Help needed with RenderBins

#ifndef _TEXTARGETBIN_MGR_H_
#include "renderInstance/renderTexTargetBinManager.h"
#endif

class PostEffect;

class RenderGlowMgr : public RenderTexTargetBinManager
{  
   typedef RenderTexTargetBinManager Parent;

public:

   RenderGlowMgr();
   virtual ~RenderGlowMgr();

   /// Returns true if the glow post effect is
   /// enabled and the glow buffer should be updated.
   bool isGlowEnabled();

   // RenderBinManager
   virtual RenderBinManager::AddInstResult addElement( RenderInst *inst );
   virtual void render( SceneState *state );

   // ConsoleObject
   DECLARE_CONOBJECT( RenderGlowMgr );

protected:

   SimObjectPtr<PostEffect> mGlowEffect;

};

#include "platform/platform.h"
#include "renderInstance/renderGlowMgr.h"

#include "sceneGraph/sceneGraph.h"
#include "sceneGraph/sceneState.h"
#include "materials/sceneData.h"
#include "materials/matInstance.h"
#include "materials/materialFeatureTypes.h"
#include "materials/processedMaterial.h"
#include "postFx/postEffect.h"
#include "gfx/gfxTransformSaver.h"
#include "gfx/gfxDebugEvent.h"

IMPLEMENT_CONOBJECT( RenderGlowMgr );

RenderGlowMgr::RenderGlowMgr()
   : RenderTexTargetBinManager(  RenderPassManager::RIT_Mesh, 
                                 1.0f, 
                                 1.0f,
                                 GFXFormatR8G8B8A8,
                                 Point2I( 512, 512 ) )
{
   mTargetSizeType = WindowSize;
   MatTextureTarget::registerTarget( "glowbuffer", this );
}

RenderGlowMgr::~RenderGlowMgr()
{
   MatTextureTarget::unregisterTarget( "glowbuffer", this );   
}

bool RenderGlowMgr::isGlowEnabled()
{
   if ( !mGlowEffect )
      mGlowEffect = dynamic_cast<PostEffect*>( Sim::findObject( "GlowPostFx" ) );

   return mGlowEffect && mGlowEffect->isEnabled();
}

RenderBinManager::AddInstResult RenderGlowMgr::addElement( RenderInst *inst )
{
   // Skip out if we don't have the glow post 
   // effect enabled at this time.
   if ( !isGlowEnabled() )
      return RenderBinManager::arSkipped;

   // TODO: We need to get the scene state here in a more reliable
   // manner so we can skip glow in a non-diffuse render pass.
   //if ( !mParentManager->getSceneManager()->getSceneState()->isDiffusePass() )
      //return RenderBinManager::arSkipped;
      
   BaseMatInstance* matInst = getMaterial(inst);
   bool hasGlow = matInst && matInst->hasGlow();
   if ( !hasGlow )   
      return RenderBinManager::arSkipped;

   internalAddElement(inst);

   return RenderBinManager::arAdded;
}


void RenderGlowMgr::render( SceneState *state )
{
   PROFILE_SCOPE( RenderGlowMgr_Render );

   // Don't allow non-diffuse passes.
   if ( !state->isDiffusePass() )
      return;

   GFXDEBUGEVENT_SCOPE( RenderGlowMgr_Render, ColorI::GREEN );

   GFXTransformSaver saver;

   // Tell the superclass we're about to render, preserve contents
   const bool isRenderingToTarget = _onPreRender( state, true );

   // Clear all the buffers to black.
   GFX->clear( GFXClearTarget, ColorI::BLACK, 1.0f, 0);

   // init loop data
   SceneGraphData sgData;
   U32 binSize = mElementList.size();

   for( U32 j=0; j<binSize; )
   {
      MeshRenderInst *ri = static_cast<MeshRenderInst*>(mElementList[j].inst);

      // temp fix - these shouldn't submit glow ri's...
      if(ri->dynamicLight)
      {
         j++;
         continue;
      }

      setupSGData( ri, sgData );
      sgData.binType = SceneGraphData::GlowBin;

      BaseMatInstance *mat = ri->matInst;

      U32 matListEnd = j;

      while( mat->setupPass( state, sgData ) )
      {
         U32 a;
         for( a=j; a<binSize; a++ )
         {
            MeshRenderInst *passRI = static_cast<MeshRenderInst*>(mElementList[a].inst);

            if (newPassNeeded(mat, passRI))
               break;

            mat->setTransforms(*passRI->objectToWorld, *passRI->worldToCamera, *passRI->projection);
            mat->setEyePosition(*passRI->objectToWorld, state->getCameraPosition());
            mat->setBuffers(passRI->vertBuff, passRI->primBuff);

            if ( passRI->prim )
               GFX->drawPrimitive( *passRI->prim );
            else
               GFX->drawPrimitive( passRI->primBuffIndex );
         }
         matListEnd = a;
      }

      // force increment if none happened, otherwise go to end of batch
      j = ( j == matListEnd ) ? j+1 : matListEnd;
   }

   // Finish up.
   if ( isRenderingToTarget )
      _onPostRender();
}

Quote:2. What are conditioners and unconditioners for?

state->getRenderPass()->addInst(ri);