This is the source code for a complete shading node.

Note:: This document covers LightWrap++ and not the LightWave SDK. A fairly thorough understanding of the LightWave SDK is required to understand the details of this sample. While lwpp wraps the LightWave 3D SDK it does not replace many of the concepts, it only expands upon them.

First you need to include the appropriate headers:

#include <lwpp/node_handler.h>

#include <lwpp/vparm.h>

Plugin class definition

The next step is to actually define the class.

Since this will be a Node with an XPanel GUI, it will be derived from lwpp::XPanelNodeHandler.

You only need to actually define and implement the member functions you need. However, the constructor is essential.

Note:: Don't worry about the MaterialComponent, this will be covered later

class MaterialMixer : public lwpp::XPanelNodeHandler
{
  private:
    lwpp::LWNodeUtility nodeUtil;
    lwpp::LWNodeOutput *outMaterial;
    lwpp::LWNodeOutput *outDiffuse, *outSpecular, *outReflection, *outRefraction, *outTransparency;
    lwpp::LWNodeInput *inBaseMaterial, *inTopMaterial;
    lwpp::LWNodeInput *inBaseDiffuse, *inBaseSpecular, *inBaseReflection, *inBaseRefraction, *inBaseTransparency;
    lwpp::LWNodeInput *inTopDiffuse, *inTopSpecular, *inTopReflection, *inTopRefraction, *inTopTransparency;
    MaterialComponent Diffuse, Specular, Reflection, Refraction, Transparency;
  public:
  MaterialMixer (void *priv, void *context, LWError *err);
  ~MaterialMixer ();
  virtual void  Evaluate (LWNodalAccess *na, NodeOutputID outID, NodeValue value);
  virtual int   Interface (int version, LWInterface *local, void *serverdata);
  virtual void *DataGet (unsigned int vid);
  virtual LWXPRefreshCode DataSet (unsigned int vid, void *value);
  virtual MaterialMixer &operator=(const MaterialMixer &from);
  virtual LWError NewTime (LWFrame frame, LWTime time);
  virtual void  ChangeNotify (LWXPanelID panel, unsigned int cid, unsigned int vid, int event_type);
  virtual LWError Load (const lwpp::LoadState &ls);
  virtual LWError Save (const lwpp::SaveState &ss);
};

Registering the plugin

The next step is to register the plugin with lwpp. This will allow lwpp to create the plugin once the plugin file is loaded into LightWave. (For seasoned developers: This completely replaces the need to create a ServerDesc or _mod_descrip).

ServerTagInfo tags[] =
{
  {"Material Blender",SRVTAG_USERNAME},
  {"db&w/Materials",SRVTAG_NODEGROUP},
  { NULL }
};
lwpp::XPanelNodeAdaptor<MaterialMixer> mixerInstance(pluginName, tags);

Initializing the plugin, basic member functions

Let's have a look at the constructor of the plugin.

MaterialMixer::MaterialMixer (void *priv, void *context, LWError *err)
    : lwpp::XPanelNodeHandler(priv, context, err)
{

You need to initilize the base classe lwpp::XPanelNodeHandler with the parameters to your plugin. These are the same for most kinds of plugins.

The following lines check the version of LW and will return an error message if LightWave is of a version earlier than 9.2 (since this is when Materials got introduced). The error message will be returned to LightWave and displayed, initializing the plugin will fail and the destructor will be called.

  if ( (lwpp::LightWave::Major() < 9) ||
       ( (lwpp::LightWave::Major() == 9) && (lwpp::LightWave::Minor() < 2) ) )
  {
    *err = "This plugin needs a newer version of LightWave 3D (9.2 as a minimum)";
    return;
  }

This is how inputs are added to the node. The variables are member variables.

  inBaseMaterial =  addMaterialInput("Fg Material");
  inBaseDiffuse = addColourInput("Fg Diffuse");
  inBaseSpecular =  addColourInput("Fg Specular");
  inBaseReflection =  addColourInput("Fg Reflection");
  inBaseRefraction =  addColourInput("Fg Refraction");
  inBaseTransparency =  addScalarInput("Fg Transparency");
  inTopMaterial = addMaterialInput("Bg Material");
  inTopDiffuse =  addColourInput("Bg Diffuse");
  inTopSpecular = addColourInput("Bg Specular");
  inTopReflection = addColourInput("Bg Reflection");
  inTopRefraction = addColourInput("Bg Refraction");
  inTopTransparency = addScalarInput("Bg Transparency");

Attaching outputs to the node is quite similar.

  outMaterial = addMaterialOutput("Material");
  outDiffuse =  addColorOutput("Diffuse");
  outSpecular = addColorOutput("Specular");
  outReflection = addColorOutput("Reflection");
  outRefraction = addColorOutput("Refraction");
  outTransparency = addScalarOutput("Transparency");

Here we initialize our MaterialComponent classes - again, more on that later.

  Diffuse.Initialize(*this, "Diffuse");
  Specular.Initialize(*this, "Specular");
  Reflection.Initialize(*this, "Reflection");
  Refraction.Initialize(*this, "Refraction");
  Transparency.Initialize(*this, "Transparency");
}

The Destructor does nothing in this case.

MaterialMixer::~MaterialMixer ()
{
  ;
}

Things are starting to heat up a little. lwpp uses operator=() to copy instances of the plugin. In this case you need to manually copy the MaterialComponent class.

MaterialMixer &MaterialMixer::operator=(const MaterialMixer &from)
{
  if (&from != this)
  {
    Diffuse = from.Diffuse;
    Specular = from.Specular;
    Reflection = from.Reflection;
    Refraction = from.Refraction;
    Transparency = from.Transparency;
  }
  return *this;
}

NewTime is called once per pass when rendering, or whenever the current frame changes. In this case the NewTime member function of the MaterialComponent member variables are called.

This is usually a good place to update lwpp::VParm for example.

LWError MaterialMixer::NewTime (LWFrame frame, LWTime time)
{
  Diffuse.NewTime(frame, time);
  Specular.NewTime(frame, time);
  Reflection.NewTime(frame, time);
  Refraction.NewTime(frame, time);
  Transparency.NewTime(frame, time);
  return 0;
}

Evaluate is where the magic happens. In this case the current values of the inputs are retrieved and used for processing. setValue() (a member function of lwpp::Node, that lwpp::NodeHandler and thus lwpp::XPanelNodeHandler derive from) is used to set the output value for the current output that is evaluated.

void  MaterialMixer::Evaluate (LWNodalAccess *na, NodeOutputID outID, NodeValue value)
{
  LWNodalMaterial bgMat = {{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},0};
  LWNodalMaterial fgMat = {{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},0};
  LWNodalMaterial outMat= {{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},{0.0, 0.0, 0.0},0};
  inBaseMaterial->evaluate(na, bgMat);
  inTopMaterial->evaluate(na, fgMat);
  if (outMaterial->isID(outID))
  {
    inBaseDiffuse->evaluate(na, bgMat.diffuse);
    inBaseSpecular->evaluate(na, bgMat.specular);
    inBaseReflection->evaluate(na, bgMat.reflection);
    inBaseRefraction->evaluate(na, bgMat.refraction);
    inBaseTransparency->evaluate(na, bgMat.transparency);
    inTopDiffuse->evaluate(na, fgMat.diffuse);
    inTopSpecular->evaluate(na, fgMat.specular);
    inTopReflection->evaluate(na, fgMat.reflection);
    inTopRefraction->evaluate(na, fgMat.refraction);
    inTopTransparency->evaluate(na, fgMat.transparency);
    Diffuse.evaluate(na, bgMat.diffuse, fgMat.diffuse, outMat.diffuse);
    Specular.evaluate(na, bgMat.specular, fgMat.specular, outMat.specular);
    Reflection.evaluate(na, bgMat.reflection, fgMat.reflection, outMat.reflection);
    Refraction.evaluate(na, bgMat.refraction, fgMat.refraction, outMat.refraction);
    Transparency.evaluate(na, bgMat.transparency, fgMat.transparency, outMat.transparency);
    setValue(value, outMat);
  }
  else if (outDiffuse->isID(outID))
  {
    inBaseDiffuse->evaluate(na, bgMat.diffuse);
    inTopDiffuse->evaluate(na, fgMat.diffuse);
    Diffuse.evaluate(na, bgMat.diffuse, fgMat.diffuse, outMat.diffuse);
    setValue(value, outMat.diffuse);
  }
  else if (outSpecular->isID(outID))
  {
    inBaseSpecular->evaluate(na, bgMat.specular);
    inTopSpecular->evaluate(na, fgMat.specular);
    Specular.evaluate(na, bgMat.specular, fgMat.specular, outMat.specular);
    setValue(value, outMat.specular);
  }
  else if (outReflection->isID(outID))
  {
    inBaseReflection->evaluate(na, bgMat.reflection);
    inTopReflection->evaluate(na, fgMat.reflection);
    Reflection.evaluate(na, bgMat.reflection, fgMat.reflection, outMat.reflection);
    setValue(value, outMat.reflection);
  }
  else if (outRefraction->isID(outID))
  {
    inBaseRefraction->evaluate(na, bgMat.refraction);
    inTopRefraction->evaluate(na, fgMat.refraction);
    Refraction.evaluate(na, bgMat.refraction, fgMat.refraction, outMat.refraction);
    setValue(value, outMat.refraction);
  }
  else if (outTransparency->isID(outID))
  {
    inBaseTransparency->evaluate(na, bgMat.transparency);
    inTopTransparency->evaluate(na, fgMat.transparency);
    Transparency.evaluate(na, bgMat.transparency, fgMat.transparency, outMat.transparency);
    setValue(value, outMat.transparency);
  }
}

Next we'll define an enum for the IDs of the XPanel controls as well as a static array of strings for the pop-up defining the blend mode.

enum { BDiff = 0x9000, MDiff, BSpec, MSpec, BRefl, MRefl, BRefr, MRefr, BTran, MTran};
static char *blendModeS[] =
{
  "Normal", "Additive", "Subtractive", "Multiply", "Screen", "Darken", "Lighten", "Difference", "Negative", "Colour Dodge", "Colour Burn", "Red", "Green", "Blue",  0
};

Creating an XPanels GUI

Now we're

Now we define the LWXPanelControl and LWXPanelDataDesc arrays for XPanel as well as our hints for the GUI. This is identical to using the C SDK for XPanels.

{

static LWXPanelControl ctrl[] =

{MDiff, "Diffuse Mode", "iPopChoice"},

{BDiff, "Diffuse Opacity", "percent-env"},

{MSpec, "Specular Mode", "iPopChoice"},

Plugin class definition

Registering the plugin

Initializing the plugin, basic member functions

Creating an XPanels GUI

Loading and saving settings

The MaterialComponent class