2.50: svn merge https://svn.blender.org/svnroot/bf-blender/trunk/blender -r19323...
[blender.git] / source / gameengine / Rasterizer / RAS_MaterialBucket.h
index 06b1261c5322540dcb4066745265fd25c5de95ee..f5c8cd3e1079d2c877aa4e1db3cbd1793c061604 100644 (file)
@@ -1,15 +1,12 @@
 /**
  * $Id$
  *
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. The Blender
- * Foundation also sells licenses for use in proprietary software under
- * the Blender License.  See http://www.blender.org/BL/ for information
- * about this.
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -27,7 +24,7 @@
  *
  * Contributor(s): none yet.
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 #ifndef __RAS_MATERIALBUCKET
 #define __RAS_MATERIALBUCKET
 
 #include "MT_Transform.h"
 #include "RAS_IPolygonMaterial.h"
-#include "RAS_Deformer.h"      // __NLA
+#include "RAS_IRasterizer.h"
+#include "RAS_Deformer.h"
+
 #include <vector>
-#include <map>
 #include <set>
+#include <list>
 using namespace std;
 
-typedef vector< vector<class RAS_TexVert>* >  vecVertexArray;
-typedef vector<unsigned int> KX_IndexArray;
-typedef vector< KX_IndexArray* > vecIndexArrays;
+/* Display List Slot */
 
-typedef vector<RAS_TexVert> KX_VertexArray;
+class KX_ListSlot
+{
+protected:
+       int m_refcount;
+public:
+       KX_ListSlot(){ m_refcount=1; }
+       virtual ~KX_ListSlot() {}
+       virtual int Release() { 
+               if (--m_refcount > 0)
+                       return m_refcount;
+               delete this;
+               return 0;
+       }
+       virtual KX_ListSlot* AddRef() {
+               m_refcount++;
+               return this;
+       }
+       virtual void SetModified(bool mod)=0;
+};
 
+class RAS_DisplayArray;
+class RAS_MeshSlot;
+class RAS_MeshMaterial;
+class RAS_MaterialBucket;
 
+/* An array with data used for OpenGL drawing */
 
-struct KX_VertexIndex {
+class RAS_DisplayArray
+{
 public:
-       KX_VertexIndex(int size);
-       void    SetIndex(short loc,short index);
-       short   m_vtxarray;
-       short   m_indexarray[4];
-       short   m_size;
+       vector<RAS_TexVert> m_vertex;
+       vector<unsigned short> m_index;
+       enum { LINE = 2, TRIANGLE = 3, QUAD = 4 } m_type;
+       //RAS_MeshSlot *m_origSlot;
+       int m_users;
+
+       enum { BUCKET_MAX_INDEX = 65535 };
+       enum { BUCKET_MAX_VERTEX = 65535 };
 };
 
+/* Entry of a RAS_MeshObject into RAS_MaterialBucket */
+typedef std::vector<RAS_DisplayArray*> RAS_DisplayArrayList;
 
-
-class KX_MeshSlot
+class RAS_MeshSlot
 {
+       friend class RAS_ListRasterizer;
+private:
+       //  indices into display arrays
+       int                                                     m_startarray;
+       int                                                     m_endarray;
+       int                                                     m_startindex;
+       int                                                     m_endindex;
+       int                                                     m_startvertex;
+       int                                                     m_endvertex;
+       RAS_DisplayArrayList            m_displayArrays;
+
+       // for construction only
+       RAS_DisplayArray*                       m_currentArray;
+
 public:
+       // for rendering
+       RAS_MaterialBucket*             m_bucket;
+       RAS_MeshObject*                 m_mesh;
        void*                                   m_clientObj;
-       RAS_Deformer*                   m_pDeformer;    //      __NLA
+       RAS_Deformer*                   m_pDeformer;
        double*                                 m_OpenGLMatrix;
-       class RAS_MeshObject*   m_mesh;
-       mutable bool                    m_bVisible; // for visibility
-       mutable bool                m_bObjectColor;
-       mutable MT_Vector4              m_RGBAcolor;
-       
-       KX_MeshSlot() :m_bVisible(true), m_pDeformer(NULL) {}
-       //      KX_MeshSlot() :m_bVisible(true) {}
+       // visibility
+       bool                                    m_bVisible;
+       bool                                    m_bCulled;
+       // object color
+       bool                                    m_bObjectColor;
+       MT_Vector4                              m_RGBAcolor;
+       // display lists
+       KX_ListSlot*                    m_DisplayList;
+       bool                                    m_bDisplayList;
+       // joined mesh slots
+       RAS_MeshSlot*                   m_joinSlot;
+       MT_Matrix4x4                    m_joinInvTransform;
+       list<RAS_MeshSlot*>             m_joinedSlots;
+
+       RAS_MeshSlot();
+       RAS_MeshSlot(const RAS_MeshSlot& slot);
+       virtual ~RAS_MeshSlot();
        
-       bool                                    Less(const KX_MeshSlot& lhs) const;
+       void init(RAS_MaterialBucket *bucket, int numverts);
+
+       struct iterator {
+               RAS_DisplayArray *array;
+               RAS_TexVert *vertex;
+               unsigned short *index;
+               size_t startvertex;
+               size_t endvertex;
+               size_t totindex;
+               size_t arraynum;
+       };
+
+       void begin(iterator& it);
+       void next(iterator& it);
+       bool end(iterator& it);
+
+       /* used during construction */
+       void SetDisplayArray(int numverts);
+       RAS_DisplayArray *CurrentDisplayArray();
+
+       void AddPolygon(int numverts);
+       int AddVertex(const RAS_TexVert& tv);
+       void AddPolygonVertex(int offset);
+
+       /* optimization */
+       bool Split(bool force=false);
+       bool Join(RAS_MeshSlot *target, MT_Scalar distance);
+       bool Equals(RAS_MeshSlot *target);
+       bool IsCulled();
+       void SetCulled(bool culled) { m_bCulled = culled; }
 };
 
+/* Used by RAS_MeshObject, to point to it's slots in a bucket */
 
-inline bool operator <( const KX_MeshSlot& rhs,const KX_MeshSlot& lhs)
+class RAS_MeshMaterial
 {
-       return ( rhs.Less(lhs));
-}
+public:
+       RAS_MeshSlot *m_baseslot;
+       class RAS_MaterialBucket *m_bucket;
 
+       GEN_Map<GEN_HashedPtr,RAS_MeshSlot*> m_slots;
+};
+
+/* Contains a list of display arrays with the same material,
+ * and a mesh slot for each mesh that uses display arrays in
+ * this bucket */
 
 class RAS_MaterialBucket
 {
-       typedef std::set<KX_MeshSlot> T_MeshSlotList;
-       
-       T_MeshSlotList                          m_meshSlots;
-       bool                                            m_bScheduled;
-       bool                                            m_bModified;
-       RAS_IPolyMaterial*                      m_material;
-       double*                                         m_pOGLMatrix;
-       
 public:
        RAS_MaterialBucket(RAS_IPolyMaterial* mat);
-       virtual ~RAS_MaterialBucket() {}
+       virtual ~RAS_MaterialBucket();
        
-       void    Render(const MT_Transform& cameratrans,
-                                          class RAS_IRasterizer* rasty,
-                                          class RAS_IRenderTools* rendertools);
+       /* Bucket Sorting */
+       struct less;
+       typedef set<RAS_MaterialBucket*, less> Set;
+
+       /* Material Properties */
+       RAS_IPolyMaterial*              GetPolyMaterial() const;
+       bool                                    IsAlpha() const;
+       bool                                    IsZSort() const;
+               
+       /* Rendering */
+       bool ActivateMaterial(const MT_Transform& cameratrans, RAS_IRasterizer* rasty,
+               RAS_IRenderTools *rendertools);
+       void RenderMeshSlot(const MT_Transform& cameratrans, RAS_IRasterizer* rasty,
+               RAS_IRenderTools* rendertools, RAS_MeshSlot &ms);
        
-       void    SchedulePolygons(int drawingmode);
-       void    ClearScheduledPolygons();
+       /* Mesh Slot Access */
+       list<RAS_MeshSlot>::iterator msBegin();
+       list<RAS_MeshSlot>::iterator msEnd();
+
+       class RAS_MeshSlot*     AddMesh(int numverts);
+       class RAS_MeshSlot* CopyMesh(class RAS_MeshSlot *ms);
+       void                            RemoveMesh(class RAS_MeshSlot* ms);
+       void                            Optimize(MT_Scalar distance);
+
+private:
+       list<RAS_MeshSlot>                      m_meshSlots;
+       RAS_IPolyMaterial*                      m_material;
        
-       RAS_IPolyMaterial*              GetPolyMaterial();
-       bool    IsTransparant();
-               
-       static void     StartFrame();
-       static void EndFrame();
-
-       void    SetMeshSlot(KX_MeshSlot& ms);
-       void    RemoveMeshSlot(KX_MeshSlot& ms);
-       void    MarkVisibleMeshSlot(KX_MeshSlot& ms,
-                                                               bool visible,
-                                                               bool color,
-                                                               const MT_Vector4& rgbavec);
 };
 
+#endif //__RAS_MATERIAL_BUCKET
 
-#endif //__KX_BUCKET