DtLineRenderer.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2010 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

#pragma once

#include <vrvGraphics/DtPrimitiveRenderer.h>
#include <vrvGraphics/DtFlat2DLineRenderer.h>

#include <vector>
#include <boost/unordered_map.hpp>

namespace makVrv
{
   class DtBufferObject;
   class DtFlat2DLineRenderer;
   class DtLineSegmentProxy;
   class DtOverlayResourceProvider;
   class DtProjected2DLineEffect;

   class DT_DLL_VRVGRAPHICS DtLineRenderer : public DtPrimitiveRenderer
   {
      friend class DtLineSegmentProxy;
   public:

      struct LineSegmentPrimitive
      {
         DtLineVertex p1;
         DtLineVertex p2;
      };

      const static unsigned short NoStipple = 0xFFFF;
      const static unsigned short NoLine = 0x0;

      DtLineRenderer(DtOverlayResourceProvider& provider);

      virtual ~DtLineRenderer();

      virtual int numberOfPrimitives() const;

      virtual void render(bool geocentric, float geocentricAlpha,
         const double cameraLocation[3],
         const double positionMatrix[16], 
         const double projectionMatrix[16],
         bool picking);

      virtual void releaseResources();

      virtual bool isRenderModeSupported(int mode);

      DtLineSegmentProxy* allocateNewSegment();

   protected:

      // Called when a proxy modified data.
      void dirty(DtLineSegmentProxy*);

      //Called in proxy destructor.
      void deallocateProxy(const DtLineSegmentProxy&);

      // Move Segment from one list to another.
      int moveSegmentToOtherList(
         const float currentWidth,
         const int currentSegmentIndex,
         const int currentPrimativeIndex,
         const float desiredWidth,
         const int desiredSegmentIndex);

   private:

      typedef std::vector<LineSegmentPrimitive> LineSegments;
      typedef std::vector<DtLineSegmentProxy*> LineSegmentProxyList;

      struct LineSegmentSets
      {
         LineSegmentProxyList mySimpleProxies;
         LineSegmentProxyList myStippledProxies;

         LineSegments mySimpleLines;
         LineSegments myStippledLines;

         LineSegmentSets();

         LineSegments& segmentsByIndex(unsigned int index)
         {
            if(index == 0) 
               return mySimpleLines;
            else
               return myStippledLines;
         }

         LineSegmentProxyList& proxiesByIndex(unsigned int index)
         {
            if(index == 0)
               return mySimpleProxies;
            else
               return myStippledProxies;
         }

         void updateRenderData(void);
         void releaseResources(void);

         DtBufferObject* myBufferObjectSimpleLines;
         DtBufferObject* myBufferObjectStippleLines;
      };

      typedef boost::unordered_map<float,LineSegmentSets> LineMap;

      void renderUsingVertexBufferObjects(DtFlat2DLineRenderer& renderer);      
      void renderStippledLineArrays(DtFlat2DLineRenderer& renderer, LineSegmentSets& lss);
      void updateRenderData();
      void sortByStipple();

      LineMap myLines;
      DtProjected2DLineEffect * myEffect;
      LineSegmentProxyList myDirtyList;
      unsigned int myPrimitiveCount;
   };

   class DT_DLL_VRVGRAPHICS DtLineSegmentProxy
   {
      friend class DtLineRenderer;
   public:   
      ~DtLineSegmentProxy();  

      const DtLineRenderer::LineSegmentPrimitive& mapReadOnly() const;
      DtLineRenderer::LineSegmentPrimitive& mapReadWrite();

      void enableStipple();

      void disableStipple();

      void setWidth(float w);

      float width() const;

      void setGroup(float group);

      float group() const;

      //Needed for sorting.
      static inline void swap(DtLineSegmentProxy*& v1,DtLineSegmentProxy*& v2)
      {
         //Swap what they point to
         std::swap(v1->myParent->myLines[v1->myWidth].segmentsByIndex(v1->mySegmentIndex)[v1->myIndex],
            v2->myParent->myLines[v2->myWidth].segmentsByIndex(v2->mySegmentIndex)[v2->myIndex]);
         //Swap their indices
         std::swap(v1->myIndex,v2->myIndex);
         //Swap themselves
         std::swap(v1,v2);
      }

      //Needed for sorting.
      static inline bool less(DtLineSegmentProxy*& v1,DtLineSegmentProxy*& v2)
      {
         DtLineRenderer::LineSegmentPrimitive& line1 = 
            v1->myParent->myLines[v1->myWidth].segmentsByIndex(v1->mySegmentIndex)[v1->myIndex];
         DtLineRenderer::LineSegmentPrimitive& line2 =
            v2->myParent->myLines[v2->myWidth].segmentsByIndex(v2->mySegmentIndex)[v2->myIndex];

         return (((unsigned int)line1.p1.lineParams[0]) << 16 |
                  (unsigned int)(line1.p1.lineParams[1])) 
                < 
                (((unsigned int)line2.p1.lineParams[0]) << 16 | 
                  (unsigned int)(line2.p1.lineParams[1]));
      }

      //Needed for sorting.
      static inline bool equal(DtLineSegmentProxy*& v1,DtLineSegmentProxy*& v2)
      {
         DtLineRenderer::LineSegmentPrimitive& line1 = 
            v1->myParent->myLines[v1->myWidth].segmentsByIndex(v1->mySegmentIndex)[v1->myIndex];
         DtLineRenderer::LineSegmentPrimitive& line2 =
            v2->myParent->myLines[v2->myWidth].segmentsByIndex(v2->mySegmentIndex)[v2->myIndex];

         return (((unsigned int)line1.p1.lineParams[0]) << 16 | 
                   (unsigned int)(line1.p1.lineParams[1])) 
                == 
                (((unsigned int)line2.p1.lineParams[0]) << 16 | 
                  (unsigned int)(line2.p1.lineParams[1]));
      }

   protected:
      DtLineSegmentProxy(DtLineRenderer& parent,int index);
      DtLineRenderer* myParent;

      bool myDirtyFlag;
      int mySegmentIndex;
      int myIndex;
      float myWidth;

   };

}