Engine directory for ticket #1

Engine/source/renderInstance/renderPassManager.h

@@ -0,0 +1,446 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef _RENDERPASSMANAGER_H_
+#define _RENDERPASSMANAGER_H_
+
+#ifndef _GFXDEVICE_H_
+#include "gfx/gfxDevice.h"
+#endif
+#ifndef _SCENEOBJECT_H_
+#include "scene/sceneObject.h"
+#endif
+#ifndef _SIMOBJECT_H_
+#include "console/simObject.h"
+#endif
+#ifndef _DATACHUNKER_H_
+#include "core/dataChunker.h"
+#endif
+#ifndef _SCENEMANAGER_H_
+#include "scene/sceneManager.h"
+#endif
+
+class SceneRenderState;
+class ISceneObject;
+class BaseMatInstance;
+struct SceneData;
+class ShaderData;
+class RenderBinManager;
+class LightInfo;
+struct RenderInst;
+class MatrixSet;
+class GFXPrimitiveBufferHandle;
+
+/// A RenderInstType hash value.
+typedef U32 RenderInstTypeHash;
+
+/// A a tiny wrapper around String that exposes a U32 operator so
+/// that we can assign the RIT to RenderInst::type field.
+class RenderInstType
+{
+   /// For direct access to mName.
+   friend class RenderBinManager;
+
+protected:
+      
+   String mName;
+
+public:  
+
+   RenderInstType( const RenderInstType &type = Invalid ) 
+      :  mName( type.mName )
+   {
+   }
+
+   RenderInstType( const String &name ) 
+      :  mName( name )
+   {
+   }
+
+   ~RenderInstType() {}
+
+   operator RenderInstTypeHash() const { return (RenderInstTypeHash)mName.getHashCaseInsensitive(); }
+
+   const String& getName() const { return mName; }
+
+   bool isValid() const { return (RenderInstTypeHash)*this != (RenderInstTypeHash)Invalid; }
+
+   static const RenderInstType Invalid;
+};
+
+
+///
+class RenderPassManager : public SimObject
+{
+   typedef SimObject Parent;
+
+public:   
+
+   // Default bin types.  Not necessarily the only bin types in the system.
+   // RIT = "R"ender "I"nstance "T"ype
+   static const RenderInstType RIT_Interior;
+   static const RenderInstType RIT_Mesh;
+   static const RenderInstType RIT_Shadow;
+   static const RenderInstType RIT_Sky;
+   static const RenderInstType RIT_Terrain;
+   static const RenderInstType RIT_Object;   // objects that do their own rendering
+   static const RenderInstType RIT_ObjectTranslucent;// self rendering; but sorted with static const RenderInstType RIT_Translucent
+   static const RenderInstType RIT_Decal;
+   static const RenderInstType RIT_Water;
+   static const RenderInstType RIT_Foliage;
+   static const RenderInstType RIT_Translucent;
+   static const RenderInstType RIT_Begin;
+   static const RenderInstType RIT_Custom;
+   static const RenderInstType RIT_Particle;
+   static const RenderInstType RIT_Occluder;
+   static const RenderInstType RIT_Editor;
+
+public:
+
+   RenderPassManager();
+   virtual ~RenderPassManager();
+
+   /// @name Allocation interface
+   /// @{
+
+   /// Allocate a render instance, use like so:  MyRenderInstType* t = gRenderInstMgr->allocInst<MyRenderInstType>();
+   /// Valid until ::clear called.
+   template <typename T>
+   T* allocInst()
+   {
+      T* inst = mChunker.alloc<T>();
+      inst->clear();
+      return inst;
+   }
+
+   /// Allocate a matrix, valid until ::clear called.
+   MatrixF* allocUniqueXform(const MatrixF& data) 
+   { 
+      MatrixF *r = mChunker.alloc<MatrixF>(); 
+      *r = data; 
+      return r; 
+   }
+
+   enum SharedTransformType
+   {
+      View,
+      Projection,
+   };
+
+   const MatrixF* allocSharedXform(SharedTransformType stt);
+
+   void assignSharedXform(SharedTransformType stt, const MatrixF &xfm);
+
+   MatrixSet &getMatrixSet() { return *mMatrixSet; }
+
+   /// Allocate a GFXPrimitive object which will remain valid 
+   /// until the pass manager is cleared.
+   GFXPrimitive* allocPrim() { return mChunker.alloc<GFXPrimitive>(); }
+   /// @}
+
+   /// Add a RenderInstance to the list
+   virtual void addInst( RenderInst *inst );
+   
+   /// Sorts the list of RenderInst's per bin. (Normally, one should just call renderPass)
+   void sort();
+
+   /// Renders the list of RenderInsts (Normally, one should just call renderPass)
+   void render( SceneRenderState *state );
+
+   /// Resets our allocated RenderInstances and Matrices. (Normally, one should just call renderPass)
+   void clear();
+
+   // Calls sort, render, and clear
+   void renderPass( SceneRenderState *state );
+
+   /// Returns the active depth buffer for this pass (NOTE: This value may be GFXTextureTarget::sDefaultDepthStencil)
+   GFXTextureObject *getDepthTargetTexture();
+
+   /// Assigns the value for the above method
+   void setDepthTargetTexture(GFXTextureObject *zTarget);
+
+   /// @name RenderBinManager interface
+   /// @{
+
+   /// Add a render bin manager to the list of render bin manager, this SceneRenderPassManager now owns the render bin manager and will free it when needed.
+   /// @param mgr Render manager to add
+   /// @param processAddOrder Where to add the manager in the addInst list, set to NO_PROCESSADD to skip processing
+   ///        this is in place for RenderManagers that will bypass the main ::addInst interface and doesn't want to process
+   ///        them.
+   /// @param renderOrder Where to add the manager in the render list.
+   void addManager(RenderBinManager* mgr);
+   
+   /// Removes a manager from render and process add lists
+   /// @param mgr Render bin manager to remove, the caller is now responsible for freeing the mgr.
+   void removeManager(RenderBinManager* mgr);
+
+   /// How many render bin managers do we have?
+   U32 getManagerCount() const { return mRenderBins.size(); }
+
+   /// Get the render manager at i
+   RenderBinManager* getManager( S32 i ) const;
+
+   /// @}
+
+   /// Get scene manager which this render pass belongs to.
+   SceneManager* getSceneManager()
+   {
+      if ( !mSceneManager )
+         mSceneManager = gClientSceneGraph;
+
+      return mSceneManager;
+   }
+
+   /// This signal is triggered when a render bin is about to be rendered.
+   ///
+   /// @param bin    The render bin we're signaling.
+   /// @param state  The current scene state.
+   /// @params preRender   If true it is before the bin is rendered, else its 
+   ///                     after being rendered.
+   ///
+   typedef Signal <void (  RenderBinManager *bin, 
+                           const SceneRenderState *state, 
+                           bool preRender )> RenderBinEventSignal;
+
+   /// @see RenderBinEventSignal
+   static RenderBinEventSignal& getRenderBinSignal();
+
+
+   typedef Signal<void(RenderInst *inst)> AddInstSignal;
+
+   AddInstSignal& getAddSignal( RenderInstTypeHash type )
+   {
+      return mAddInstSignals.findOrInsert( type )->value; 
+   }
+
+   // ConsoleObject interface
+   static void initPersistFields();
+   DECLARE_CONOBJECT(RenderPassManager);
+
+protected:
+
+   MultiTypedChunker mChunker;
+      
+   Vector< RenderBinManager* > mRenderBins;
+
+
+   typedef HashTable<RenderInstTypeHash,AddInstSignal> AddInstTable;
+
+   AddInstTable mAddInstSignals;
+
+   SceneManager * mSceneManager;
+   GFXTexHandle mDepthBuff;
+   MatrixSet *mMatrixSet;
+
+   /// Do a sorted insert into a vector, renderOrder bool controls which test we run for insertion.
+   void _insertSort(Vector<RenderBinManager*>& list, RenderBinManager* mgr, bool renderOrder);
+};
+
+//**************************************************************************
+// Render Instance
+//**************************************************************************
+struct RenderInst
+{
+   /// The type of render instance this is.
+   RenderInstTypeHash type;
+
+   /// This should be true if the object needs to be sorted 
+   /// back to front with other translucent instances.
+   /// @see sortDistSq
+   bool translucentSort;  
+
+   /// The reference squared distance from the camera used for
+   /// back to front sorting of the instances.
+   /// @see translucentSort
+   F32 sortDistSq;
+
+   /// The default key used by render managers for
+   /// internal sorting.
+   U32 defaultKey;
+
+   /// The secondary key used by render managers for
+   /// internal sorting.
+   U32 defaultKey2;
+
+   /// Does a memset to clear the render instance.
+   void clear();
+};
+
+struct ObjectRenderInst : public RenderInst
+{
+   /// This is a delegate specific index which is usually
+   /// used to define a mounted object.
+   S32 objectIndex;
+
+   /// Extra data to be used within the render callback.
+   /// ObjectRenderInst does not own or cleanup this data.
+   void *userData;
+
+   /// The delegate callback function to call to render
+   /// this object instance.
+   ///
+   /// @param ri           The ObjectRenderInst that called the delegate.
+   ///
+   /// @param state        The scene state we're rendering.
+   ///
+   /// @param overrideMat  An alternative material to use during rendering... usually
+   ///                     used for special renders like shadows.  If the object doesn't
+   ///                     support override materials it shouldn't render at all.
+   Delegate<void( ObjectRenderInst *ri, 
+                  SceneRenderState *state, 
+                  BaseMatInstance *overrideMat )> renderDelegate;
+
+   // Clear this instance.
+   void clear();
+};
+
+struct MeshRenderInst : public RenderInst
+{
+   ////
+   GFXVertexBufferHandleBase *vertBuff;
+   
+   ////
+   GFXPrimitiveBufferHandle *primBuff;
+
+   /// If not NULL it is used to draw the primitive, else
+   /// the primBuffIndex is used.
+   /// @see primBuffIndex
+   GFXPrimitive *prim;
+
+   /// If prim is NULL then this index is used to draw the
+   /// indexed primitive from the primitive buffer.
+   /// @see prim
+   U32 primBuffIndex;
+   
+   /// The material to setup when drawing this instance.
+   BaseMatInstance *matInst;
+
+   /// The object to world transform (world transform in most API's).
+   const MatrixF *objectToWorld;       
+   
+   /// The worldToCamera (view transform in most API's).
+   const MatrixF* worldToCamera;       
+   
+   /// The projection matrix.
+   const MatrixF* projection;         
+
+   // misc render states
+   U8    transFlags;
+   bool  reflective;
+   F32   visibility;
+
+   /// A generic hint value passed from the game
+   /// code down to the material for use by shader 
+   /// features.
+   void *materialHint;
+
+   /// The lights we pass to the material for this 
+   /// mesh in order light importance.
+   LightInfo* lights[8];
+
+   // textures
+   GFXTextureObject *lightmap;
+   GFXTextureObject *fogTex;
+   GFXTextureObject *backBuffTex;
+   GFXTextureObject *reflectTex;
+   GFXTextureObject *miscTex;
+   GFXCubemap   *cubemap;
+
+   void clear();
+};
+
+enum ParticleSystemState
+{
+   PSS_AwaitingHighResDraw = 0, // Keep this as first element so that if the offscreen manager rejects a particle system it will get drawn high-res
+   PSS_AwaitingOffscreenDraw,
+   PSS_AwaitingCompositeDraw,
+   PSS_AwaitingMixedResDraw,
+   PSS_DrawComplete,
+};
+
+/// A special render instance for particles.
+struct ParticleRenderInst : public RenderInst
+{
+   /// The vertex buffer.
+   GFXVertexBufferHandleBase *vertBuff;
+   
+   /// The primitive buffer.
+   GFXPrimitiveBufferHandle *primBuff;
+
+   /// The total particle count to render.
+   S32 count;
+
+   /// The combined model, camera, and projection transform.
+   const MatrixF *modelViewProj;       
+        
+   /// Blend style for the particle system 
+   enum BlendStyle {
+      BlendUndefined = 0,
+      BlendNormal,
+      BlendAdditive,
+      BlendSubtractive,
+      BlendPremultAlpha,
+      BlendGreyscale,
+      BlendStyle_COUNT,
+   };
+   U8 blendStyle;
+
+   /// For the offscreen particle manager
+   U8 targetIndex;
+
+   /// State for the particle system
+   ParticleSystemState systemState;
+
+   /// The soft particle fade distance in meters.
+   F32 softnessDistance;
+
+   /// Bounding box render transform
+   const MatrixF *bbModelViewProj;
+
+   /// The particle texture.
+   GFXTextureObject *diffuseTex;
+
+   void clear();
+};
+
+class GFXOcclusionQuery;
+class SceneObject;
+
+/// A special render instance for occlusion tests.
+struct OccluderRenderInst : public RenderInst
+{   
+   Point3F scale;
+   Point3F position;   
+   const MatrixF *orientation;
+   GFXOcclusionQuery *query; 
+   
+   // This optional query will have all pixels rendered.
+   // Its purpose is to return to the user the full pixel count for comparison
+   // with the other query.
+   GFXOcclusionQuery *query2;
+
+   /// Render a sphere or a box.
+   bool isSphere;
+
+   void clear();
+};
+
+#endif // _RENDERPASSMANAGER_H_