About RenderItem

IMeshDisplay2* pMeshDisplay = NULL;
pMeshDisplay = static_cast<IMeshDisplay2*>(mesh.GetInterface(IMesh_DISPLAY2_INTERFACE_ID));

class IMeshDisplay2:public BaseInterface
{
    virtual void PrepareDisplay(
        const GenerateMeshRenderItemsContext& renderItemContext) = 0;
    virtual bool GetRenderItems(
        const GenerateMeshRenderItemsContext& renderItemContext,
        UpdateNodeContext& nodeContext,
        IRenderItemContainer& targetRenderItemContainer) = 0;
};

GenerateMeshRenderItemsContext renderItemContext;
renderItemContext.GenerateDefaultContext(displayContext);

GenerateMeshRenderItemsContext renderItemContext;
MeshElementDescription elementDescription;

elementDescription = GetBuiltInMeshElementDescription(ElementDescriptionVetexTicks);
elementDescription.SetBackfaceCull(true);
renderItemContext.AddMeshElementDescription(elementDescription);

class PrimitiveListGeometry:public IRenderGeometry
{
public:
    // From IRenderGeometry
    virtual void Display(
        DrawContext& dc,
        int start,
        int count,
        int lod)
    {
        IVirtualDevice& vd = *dc.GetVirtualDevice();
        vd.SetStreamFormat(mStreamFormat);
        vd.SetVertexStreams(mVertexBufferArray);
        if (mIndexBuffer.IsValid())
        {
            vd.SetIndexBuffer(&mIndexBuffer);
        }
        else
        {
            vd.SetIndexBuffer(nullptr);
        }
        vd.Draw(mPrimType, start, count);
    }

    virtual PrimitiveType GetPrimitiveType()
    {
        return mPrimType;
    }

    virtual size_t GetVertexCount()
    {
        if (mVertexBufferArray.length() > 0)
        {
            return mVertexBufferArray[0].GetNumberOfVertices();
        }
        else
        {
            return 0;
        }
    }
    // Other functions

private:
    VertexBufferHandleArray mVertexBufferArray;
    IndexBufferHandle mIndexBuffer;
    PrimitiveType mPrimType;
    MaterialRequiredStreams mStreamFormat;
    size_t mPrimitiveCount;
};

class CustomRenderItemHandle:public RenderItemHandle
{
public:
    virtual void SetCustomImplementation(ICustomRenderItem* impl) = 0;
    virtual ICustomRenderItem* GetCustomImplementation() = 0;
};

class ICustomRenderItem:public ARefObject, public BaseInterfaceServer
{
public:
    virtual void Realize(DrawContext& dc) = 0;
    virtual void Display(DrawContext& dc) = 0;
};

class SampleItemDX9 : public ICustomRenderItem
{
    ...
};
void SampleItemDX9::Display(DrawContext& dc)
{
    IVirtualDevice& vd = drawContext.GetVirtualDevice();
    BaseMaterialHandle& material = const_cast<BaseMaterialHandle&>(drawContext.GetMaterial()); //Use draw context’s material
    vd.SetStreamFormat(const_cast<MaterialRequiredStreams&>(*material.GetRequiredStreams()));
    vd.SetVertexStreams(mVertexBuffer);
    vd.SetIndexBuffer(&mIndexBuffer);
    
    material.Activate(drawContext);
    unsigned int passCount = material.GetPassCount(drawContext);
    for (int pass = 0; pass < passCount; ++pass) //Loop through all passes
    {
        material.ActivatePass(drawContext, pass);
        vd.Draw(PrimitiveTriangleList, 0, (int)mPrimitiveCount);
    }
    material.Terminate(drawContext);
}

bool CustomPlugin::PrepareDisplay(
      const MaxSDK::Graphics::UpdateDisplayContext& displayContext)
{
      if (nullptr == mpSampleItem)
      {
           MaxSDK::Graphics::DeviceCaps caps;
           GetIDisplayManager2()->GetDeviceCaps(caps);
           if (caps.FeatureLevel != Level5_0)
           {
               mpSampleItem = new SampleItemDX9;
           }
           else
           {
               mpSampleItem = new SampleItemDX11;
           }		
      }
}

bool CustomPlugin::UpdatePerNodeItems(
      const UpdateDisplayContext& updateDisplayContext,
      UpdateNodeContext& nodeContext,
      IRenderItemContainer& targetRenderItemContainer)
{
      CustomRenderItemHandle newHandle;
      newHandle.Initialize();
      //VisibilityGroup can be shaded or gizmo. By putting to shaded group,
      //the render item can take benefit from multipass effects like DOF.
      //Gizmo group is rendered in each viewport.
      newHandle.SetVisibilityGroup(RenderItemVisible_Gizmo);
      newHandle.SetCustomImplementation(mpSampleItem.GetPointer());
      targetRenderItemContainer.AddRenderItem(newHandle);
      return true;
}

class BoolObject : 
      public GeomObject, 
      public IObjectDisplay2
{
      ...
      Mesh mMesh;
      Tab<IObjectDisplay*> mSubObjectDisplays;
      Tab<IObjectDisplay2*> mSubObject2Displays;
};

BaseInterface* BoolObject::GetInterface(Interface_ID id)
{
      // Remember to expose IOBJECT_DISPLAY2_INTERFACE_ID for 
      // the BoolObject that helps Nitrous determine if the plug-in 
      // is ported using IOjbectDisplay2
      if (id == IOBJECT_DISPLAY2_INTERFACE_ID)
      {
          return static_cast<IObjectDisplay2*>(this);
      }
      return IBoolObject::GetInterface(id);
}

unsigned long BoolObject::GetObjectDisplayRequirement() const
{
      using namespace MaxSDK::Graphics;
      unsigned long requirement = ObjectDisplayRequireLegacyDisplayMode;
      if (!GetDisplayResult())
      {
          // Because updating render items on per view basis 
          // is very time consuming, so please append the 
          // ObjectDisplayRequireUpdatePerViewItems requirement
          // when you really need to add per view items.
          requirement |= ObjectDisplayRequireUpdatePerViewItems;
      }

      return requirement;
}

bool BoolObject::PrepareDisplay(
      const UpdateDisplayContext& prepareDisplayContext)
{
      TimeValue t = prepareDisplayContext.GetDisplayTime();
      RenderItemHandleArray tempRenderItemArray;
      IObjectDisplay* pObjDisplay = NULL;

      mRenderItemHandles.ClearAllRenderItems();
      mSubObjectDisplays.SetCount(0);
      mSubObject2Displays.SetCount(0);

      if (GetDisplayResult()) {
          UpdateMesh(t,true);  
          IMeshDisplay2* pMeshDisplay = static_cast<IMeshDisplay2*>(mMesh.GetInterface(IMesh_DISPLAY2_INTERFACE_ID));
          if (NULL == pMeshDisplay)
          {
              return false;
          }
          GenerateMeshRenderItemsContext itemContext;
          itemContext.GenerateDefaultContext(prepareDisplayContext);
          pMeshDisplay->PrepareDisplay(itemContext);
      
          return true;
      } 
      // display the two sub-objects
      // Note : Currently there are still some plug-ins not yet ported 
      // using IObjectDisplay2. So, check if 
      // IObjectDisplay is exposed from the operand of this bool 
      // object and then call IObjectDisplay::UpdateDisplay 
      // accordingly.

      for (int i = 0; i < 2; i++) 
      {
          IObjectDisplay *pObjDisplay = NULL;
          IObjectDisplay2 *pObjDisplay2 = NULL;
          Object *pObject = GetPipeObj(t,i);
          if (NULL != pObject)
          {
              pObjDisplay2 = static_cast<IObjectDisplay2*>(pObject->GetInterface(IOBJECT_DISPLAY2_INTERFACE_ID));
              if (NULL != pObjDisplay2)
              {
                  pObjDisplay2->PrepareDisplay(prepareDisplayContext);
              }
              else
              {
                  pObjDisplay = static_cast<IObjectDisplay*>(pObject->GetInterface(IOBJECT_DISPLAY_INTERFACE_ID));
                  if (NULL != pObjDisplay)
                  {
                      pObjDisplay->UpdateDisplay(prepareDisplayContext);
                  }
              }
          }
          mSubObjectDisplays.Append(1,&pObjDisplay);
          mSubObject2Displays.Append(1,&pObjDisplay2);
      }
      
      return true;
}

void BoolObject::PopulateSubObjectRenderItems(
      const Matrix3& renderItemMatrix,
      const IRenderItemContainer& sourceItems,
      IRenderItemContainer& targetItems)
{
      // Using RenderItemHandleDecorator to decorate the render 
      // items of the sub-object if we need to customize the 
      // behavior of those render items. In this sample, we 
      // need RenderItemHandleDecorator for two reasons:
      // 1. When choosing the 'Operands' option in the 
      //    'Display' panel, we need to customize the position 
      //    of render items of operands.
      // 2. When choosing the 'Billboard Operands' option in 
      //    the 'Display' panel, we need to customize the 
      //    rotation of those render items of operands to 
      //    align with the view camera.
      for (size_t i = 0; i < sourceItems.GetNumberOfRenderItems(); ++i)
      {
          RenderItemHandleDecorator hRenderItemDecorator;
          if (hRenderItemDecorator.Initialize(sourceItems.GetRenderItem(i)))
          {
              Matrix44 offsetMatrix;
              MaxWorldMatrixToMatrix44(offsetMatrix,renderItemMatrix);
              hRenderItemDecorator.SetOffsetMatrix(offsetMatrix);
              targetItems.AddRenderItem(hRenderItemDecorator);
          }
      }
}

void BoolObject::AddSubObjectRenderItems(
      int subObjectindex,
      const Matrix3& subObjectOffsetMatrix,
      const UpdateDisplayContext& updateDisplayContext,
      UpdateNodeContext& nodeContext,
      IRenderItemContainer& targetItems)
{
      using namespace MaxSDK::Graphics;
      if (NULL != mSubObjectDisplays[subObjectindex])
      {
          RenderItemHandleArray renderItems;
          // For IObjectDisplay instance, we still call 
          // IObjectDisplay::AddRenderItems() to add render 
          // items according to the properties of the current node
          mSubObjectDisplays[subObjectindex]->AddRenderItems(nodeContext.GetRenderNode(),renderItems);
          PopulateSubObjectRenderItems(subObjectOffsetMatrix, renderItems, targetItems);
      }
      if (NULL != mSubObject2Displays[subObjectindex])
      {
          RenderItemHandleArray renderItems;
          mSubObject2Displays[subObjectindex]->UpdatePerNodeItems(updateDisplayContext, nodeContext, renderItems);
          PopulateSubObjectRenderItems(subObjectOffsetMatrix, renderItems, targetItems);
      }
}

bool BoolObject::UpdatePerNodeItems(
      const UpdateDisplayContext& updateDisplayContext,
      UpdateNodeContext& nodeContext,
      IRenderItemContainer& targetItems)
{
      using namespace MaxSDK::Graphics;

      RenderNodeHandle& hRenderNode = nodeContext.GetRenderNode();
      if (GetDisplayResult()) 
      {  
          IMeshDisplay2* pMeshDisplay = static_cast<IMeshDisplay2*>(mMesh.GetInterface(IMesh_DISPLAY2_INTERFACE_ID));
          if (NULL == pMeshDisplay)
          {
              return false;
          }
          GenerateMeshRenderItemsContext itemContext;
          itemContext.GenerateDefaultContext(updateDisplayContext);
          // If you are not sure whether any mMesh element is not 
          // required for the current node, feel free to call 
          // GenerateMeshRenderItemsContext::
          //     RemoveInvisibleMeshElementDescriptions()
          // that will help you remove unwanted render items 
          // for hRenderNode.
          itemContext.RemoveInvisibleMeshElementDescriptions(hRenderNode);
          pMeshDisplay->GetRenderItems(itemContext,nodeContext,targetItems);
      }
      else if (TestFlag(BOOL_DISP_OPS))
      {
          TimeValue t = updateDisplayContext.GetDisplayTime();
          for (int i = 0; i < mSubObjectDisplays.Count(); ++i)
          {
          AddSubObjectRenderItems(i, GetOpTM(t,i), updateDisplayContext, nodeContext, targetItems);
          }
      }
      
      return true;
}

bool BoolObject::UpdatePerViewItems(
      const UpdateDisplayContext& updateDisplayContext,
      UpdateNodeContext& nodeContext,
      UpdateViewContext& viewContext,
      IRenderItemContainer& targetItems)
{
      using namespace MaxSDK::Graphics;
      if (GetDisplayResult())
      {
          return false;
      }

      bool bResult = false;
      TimeValue t = updateDisplayContext.GetDisplayTime();
      // To display Billborad operands
      if (TestFlag(BOOL_DISP_BILLBOARD_OPS))
      {
          Matrix3 viewMatrix;
          viewContext.GetView()->GetAffineTM(viewMatrix);
          Matrix3 inverseViewMatrix = Inverse(viewMatrix);
          for (int i = 0; i < mSubObjectDisplays.Count(); ++i)
          {	
              // Assign view-dependent offset matrix to the 
              // render items of operands
              inverseViewMatrix.SetTrans(GetOpTM(t,i).GetTrans());
              AddSubObjectRenderItems(i, inverseViewMatrix, updateDisplayContext, nodeContext, targetItems);
              bResult = true;
          }
      }

      for (int i = 0; i < mSubObject2Displays.Count(); ++i)
      {
          RenderItemHandleArray renderItems;
          IObjectDisplay2* pObjectDisplay2 = mSubObject2Displays[i];
          // For operands exposing IObjectDisplay2, we have to 
          // check if they require updating their render items 
          // on per-view basis and call IObjectDisplay2::
          // UpdatePerViewItems() accordingly.
          if (NULL != pObjectDisplay2 &&
              (pObjectDisplay2->GetObjectDisplayRequirement() & 
              ObjectDisplayRequireUpdatePerViewItems) &&
              pObjectDisplay2->UpdatePerViewItems(updateDisplayContext, nodeContext, viewContext, renderItems))
          {
              bResult = true;
              PopulateSubObjectRenderItems(
              GetOpTM(t,i),
              renderItems,
              targetItems);
          }
      }
      return bResult;
}