per_shape_material_test.txt

Engine\source\materials\materialFeatureTypes.h (before the #endif)

   DeclareFeatureType( MFT_ConstantMult );  //test_material

Engine\source\materials\materialFeatureTypes.cpp (at the very end)

   ImplementFeatureType( MFT_ConstantMult , MFG_PostProcess, 998.0f, true );  //test_material

Engine\source\T3D\tsStatic.h (just after protected S32 mForceDetail; and still protected)

   ColorF mMultConstant;  //test_material

Engine\source\T3D\tsStatic.cpp (in TSStatic::TSStatic())

   mMultConstant.set(1.0f, 1.0f, 1.0f, 1.0f);  //test_material

Also in Engine\source\T3D\tsStatic.cpp (in void TSStatic::initPersistFields() before Parent::initPersistFields();)

   addField("multConstant", TypeColorF, Offset(mMultConstant, Material));  //test_material

Also in Engine\source\T3D\tsStatic.cpp (in U32 TSStatic::packUpdate( just after U32 retMask = Parent::packUpdate(con, mask, stream);)

   stream->write(mMultConstant);  //test_material

Also in Engine\source\T3D\tsStatic.cpp (in void TSStatic::unpackUpdate( just after Parent::unpackUpdate(con, stream);)

   stream->read(&mMultConstant);  //test_material

Also in Engine\source\T3D\tsStatic.cpp (in void TSStatic::prepRenderImage(after rdata.setOriginSort( mUseOriginSort );)

   rdata.setMultConstant( mMultConstant );  //test_material

Now, for that last line to work we need to change
Engine\source\ts\tsRenderState.h

class TSRenderState
{
protected:
   ColorF mMultConstant;  //test_material
public:
   const ColorF &getMultConstant() const { return mMultConstant; }  //test_material
   void setMultConstant(const ColorF &val) { mMultConstant = val; }  //test_material


Engine\source\renderInstance\renderPassManager.h (inside struct MeshRenderInst : public RenderInst{ )

   ColorF multConstant;  //test_material

Engine\source\ts\tsMesh.cpp (in void TSMesh::innerRender( TSMaterialList *materials, const TSRenderState &rdata, TSVertexBufferHandle &vb, GFXPrimitiveBufferHandle &pb ) after coreRI->type = RenderPassManager::RIT_Mesh;)

   coreRI->multConstant = rdata.getMultConstant();  //test_material

Engine\source\materials\sceneData.h (in struct SceneData{ after F32 visibility;)

   ColorF* multConstant;  //test_material

Engine\source\renderInstance\renderBinManager.cpp in (void RenderBinManager::setupSGData( )

   data.multConstant = &ri->multConstant;  //test_material

Create source\constantMult.cpp
--------------------------------------------------------------------------------------------------------------

#include "shaderGen/shaderFeature.h"
#include "shaderGen/shaderOp.h"
#include "shaderGen/featureMgr.h"
#include "materials/materialFeatureTypes.h"
#include "materials/sceneData.h"
#include "gfx/gfxDevice.h"

class ConstantMultFeature : public ShaderFeature
{
public:
   virtual void processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd )
   {
      // Find the constant value
      Var *multConst = (Var *)( LangElement::find("multConst") );
      if( multConst == NULL )
      {
         multConst = new Var;
         multConst->setType( GFX->getAdapterType() == OpenGL ? "vec4" : "float4" );
         multConst->setName( "multConst" );
         multConst->constSortPos = cspPotentialPrimitive;
         multConst->uniform = true;
      }

      // Find output fragment
      Var *color = (Var*) LangElement::find( getOutputTargetVarName(DefaultTarget) );
      if ( !color )
      {
         color = new Var;
         color->setType( GFX->getAdapterType() == OpenGL ? "vec4" : "fragout" );
         color->setName( getOutputTargetVarName(DefaultTarget) );

         if(GFX->getAdapterType() != OpenGL)
            color->setStructName( "OUT" );

         output = new GenOp( "@ = @", color, multConst );
      }
      output = new GenOp( "   @ *= @;\r\n", color, multConst );
   }

   virtual String getName() { return "ConstantMultFeature"; }


   class ConstMultFeatureHdls : public ShaderFeatureConstHandles
   {
      GFXShaderConstHandle* mMultConstSC;

      public:

      ConstMultFeatureHdls( GFXShader *shader )
      {
         mMultConstSC = shader->getShaderConstHandle("$multConst");
      }

      void init( GFXShader *shader )
      {
         mMultConstSC = shader->getShaderConstHandle("$multConst");
      }

      virtual void setConsts( SceneRenderState *state, const SceneData &sgData, GFXShaderConstBuffer *buffer )
      {
         if( mMultConstSC->isValid() && sgData.multConstant )
         {
            buffer->set( mMultConstSC, *sgData.multConstant );
         }
      }
   };

   virtual ShaderFeatureConstHandles* createConstHandles( GFXShader *shader )
   {
      // This memory is cleaned up via a delete call which takes place
      // in ShaderRenderPassData::reset()

      ConstMultFeatureHdls *handles = new ConstMultFeatureHdls(shader);
      //handles->init( shader );

      return handles;

      //return new ConstMultFeatureHdls( shader );
   }


   // These methods aren't used
   virtual Var* getVertTexCoord( const String &name ) { return NULL; }
   virtual LangElement *setupTexSpaceMat(  Vector<ShaderComponent*> &componentList, Var **texSpaceMat ) { return NULL; }
   virtual LangElement *expandNormalMap( LangElement *sampleNormalOp, LangElement *normalDecl, LangElement *normalVar, const MaterialFeatureData &fd ) { return NULL; }
   virtual LangElement *assignColor( LangElement *elem, Material::BlendOp blend, LangElement *lerpElem = NULL, ShaderFeature::OutputTarget outputTarget = ShaderFeature::DefaultTarget ) { return NULL; }
};


class ConstMultFeatureReg
{
   bool _handleGFXEvent(GFXDevice::GFXDeviceEventType evt)
   {
      if( evt == GFXDevice::deInit )
      {
         FEATUREMGR->registerFeature( MFT_ConstantMult, new ConstantMultFeature );
      }
      else if( evt == GFXDevice::deDestroy )
      {
         //this is not needed as it's unregistered in FeatureMgr::~FeatureMgr()
         //FEATUREMGR->unregisterFeature( MFT_ConstantMult );
      }
      return true;
   }

public:
   ConstMultFeatureReg()
   {
      GFXDevice::getDeviceEventSignal().notify(this, &ConstMultFeatureReg::_handleGFXEvent, 998.0f);
   }
};

static ConstMultFeatureReg sConstMultFeatureReg;
//</ShaderComponent*></ShaderComponent*>

--------------------------------------------------------------------------------------------------------------


Engine/source/materials/processedShaderMaterial.cpp (in void ProcessedShaderMaterial::_determineFeatures( before //Allow features to add themselves.)

   if ( mMaterial->mMultConstant )  //test_material
      fd.features.addFeature( MFT_ConstantMult );  //test_material


Engine/source/materials/materialDefinition.h (after String mMapTo; )

   bool mMultConstant;  //test_material

Engine\source\materials\materialDefinition.cpp (in Material::Material() at the end)

   mMultConstant = false;  //test_material

Also Engine\source\materials\materialDefinition.cpp (in void Material::initPersistFields() before Parent::initPersistFields();)

   addField("multConstant", TypeBool, Offset(mMultConstant, Material));  //test_material