fxFoliageReplicator.h

Public Functions

GFXDeclareVertexFormat(GFXVertexFoliage )

  1
  2//-----------------------------------------------------------------------------
  3// Copyright (c) 2012 GarageGames, LLC
  4//
  5// Permission is hereby granted, free of charge, to any person obtaining a copy
  6// of this software and associated documentation files (the "Software"), to
  7// deal in the Software without restriction, including without limitation the
  8// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  9// sell copies of the Software, and to permit persons to whom the Software is
 10// furnished to do so, subject to the following conditions:
 11//
 12// The above copyright notice and this permission notice shall be included in
 13// all copies or substantial portions of the Software.
 14//
 15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 21// IN THE SOFTWARE.
 22//-----------------------------------------------------------------------------
 23
 24#ifndef _FOLIAGEREPLICATOR_H_
 25#define _FOLIAGEREPLICATOR_H_
 26
 27#ifndef _SCENEOBJECT_H_
 28#include "scene/sceneObject.h"
 29#endif
 30#ifndef _GFXTEXTUREHANDLE_H_
 31#include "gfx/gfxTextureHandle.h"
 32#endif
 33#ifndef _GFXPRIMITIVEBUFFER_H_
 34#include "gfx/gfxPrimitiveBuffer.h"
 35#endif
 36#ifndef _GBITMAP_H_
 37#include "gfx/bitmap/gBitmap.h"
 38#endif
 39#ifndef _RENDERPASSMANAGER_H_
 40#include "renderInstance/renderPassManager.h"
 41#endif
 42#ifndef _MATHUTIL_FRUSTUM_H_
 43#include "math/util/frustum.h"
 44#endif
 45
 46#pragma warning( push, 4 )
 47
 48#define AREA_ANIMATION_ARC         (1.0f / 360.0f)
 49
 50#define FXFOLIAGEREPLICATOR_COLLISION_MASK   (   TerrainObjectType     |   \
 51                                                 StaticShapeObjectType |   \
 52                                                 WaterObjectType      )
 53
 54#define FXFOLIAGEREPLICATOR_NOWATER_COLLISION_MASK   (   TerrainObjectType      |   \
 55                                          StaticShapeObjectType   )
 56
 57
 58#define FXFOLIAGE_ALPHA_EPSILON            1e-4
 59
 60
 61
 62//------------------------------------------------------------------------------
 63// Class: fxFoliageItem
 64//------------------------------------------------------------------------------
 65class fxFoliageItem
 66{
 67public:
 68   MatrixF     Transform;     
 69   F32         Width;         
 70   F32         Height;        
 71   Box3F       FoliageBox;    
 72   bool        Flipped;       
 73   F32         SwayPhase;     
 74   F32         SwayTimeRatio; 
 75   F32         LightPhase;    
 76   F32         LightTimeRatio; 
 77   U32         LastFrameSerialID; 
 78};
 79
 80//------------------------------------------------------------------------------
 81// Class: fxFoliageCulledList
 82//------------------------------------------------------------------------------
 83class fxFoliageCulledList
 84{
 85public:
 86   fxFoliageCulledList() {};
 87   fxFoliageCulledList(Box3F SearchBox, fxFoliageCulledList* InVec);
 88   ~fxFoliageCulledList() {};
 89
 90   void FindCandidates(const Box3F& SearchBox, fxFoliageCulledList* InVec);
 91
 92   U32 GetListCount(void) { return mCulledObjectSet.size(); };
 93   fxFoliageItem* GetElement(U32 index) { return mCulledObjectSet[index]; };
 94
 95   Vector<fxFoliageItem*>   mCulledObjectSet;      // Culled Object Set.
 96};
 97
 98
 99//------------------------------------------------------------------------------
100// Class: fxFoliageQuadNode
101//------------------------------------------------------------------------------
102class fxFoliageQuadrantNode {
103public:
104   U32                  Level;
105   Box3F               QuadrantBox;
106   fxFoliageQuadrantNode*   QuadrantChildNode[4];
107   Vector<fxFoliageItem*>   RenderList;
108   // Used in DrawIndexPrimitive call.
109   U32                      startIndex;
110   U32                      primitiveCount;
111};
112
113
114//------------------------------------------------------------------------------
115// Class: fxFoliageRenderList
116//------------------------------------------------------------------------------
117class fxFoliageRenderList
118{
119public:
120
121   Box3F                   mBox;               // Clipping Box.
122   Frustum                 mFrustum;           // View frustum.
123
124   Vector<fxFoliageItem*>     mVisObjectSet;   // Visible Object Set.
125   F32                        mHeightLerp;         // Height Lerp.
126
127public:
128   bool IsQuadrantVisible(const Box3F VisBox, const MatrixF& RenderTransform);
129   void SetupClipPlanes(SceneRenderState* state, const F32 FarClipPlane);
130   void DrawQuadBox(const Box3F& QuadBox, const ColorF Colour);
131};
132
133
134// Define a vertex 
135GFXDeclareVertexFormat( GFXVertexFoliage )
136{
137   Point3F point;
138   Point3F normal;
139   Point2F texCoord;
140   Point2F texCoord2;
141};
142
143
144//------------------------------------------------------------------------------
145// Class: fxFoliageReplicator
146//------------------------------------------------------------------------------
147class fxFoliageReplicator : public SceneObject
148{
149private:
150   typedef SceneObject      Parent;
151
152protected:
153
154   void CreateFoliage(void);
155   void DestroyFoliage(void);
156   void DestroyFoliageItems();
157
158
159   void SyncFoliageReplicators(void);
160
161   Box3F FetchQuadrant(const Box3F& Box, U32 Quadrant);
162   void ProcessQuadrant(fxFoliageQuadrantNode* pParentNode, fxFoliageCulledList* pCullList, U32 Quadrant);
163   void ProcessNodeChildren(fxFoliageQuadrantNode* pParentNode, fxFoliageCulledList* pCullList);
164
165   enum {   FoliageReplicationMask   = (1 << 0) };
166
167
168   U32   mCreationAreaAngle;
169   bool  mClientReplicationStarted;
170   U32   mCurrentFoliageCount;
171
172   Vector<fxFoliageQuadrantNode*>   mFoliageQuadTree;
173   Vector<fxFoliageItem*>           mReplicatedFoliage;
174   fxFoliageRenderList              mFrustumRenderSet;
175
176   GFXVertexBufferHandle<GFXVertexFoliage> mVertexBuffer;
177   GFXPrimitiveBufferHandle   mPrimBuffer;
178   GFXShaderRef               mShader;
179   ShaderData*                mShaderData;
180   GBitmap*                   mAlphaLookup;
181
182   MRandomLCG                 RandomGen;
183   F32                        mFadeInGradient;
184   F32                        mFadeOutGradient;
185   S32                        mLastRenderTime;
186   F32                        mGlobalSwayPhase;
187   F32                        mGlobalSwayTimeRatio;
188   F32                        mGlobalLightPhase;
189   F32                        mGlobalLightTimeRatio;
190   U32                        mFrameSerialID;
191
192   U32                        mQuadTreeLevels;            // Quad-Tree Levels.
193   U32                        mPotentialFoliageNodes;     // Potential Foliage Nodes.
194   U32                        mNextAllocatedNodeIdx;      // Next Allocated Node Index.
195   U32                        mBillboardsAcquired;        // Billboards Acquired.
196
197   // Used for alpha lookup in the pixel shader
198   GFXTexHandle               mAlphaTexture;
199
200   GFXStateBlockRef  mPlacementSB;
201   GFXStateBlockRef  mRenderSB;
202   GFXStateBlockRef  mDebugSB;
203
204   GFXShaderConstBufferRef mFoliageShaderConsts;
205
206   GFXShaderConstHandle* mFoliageShaderProjectionSC;
207   GFXShaderConstHandle* mFoliageShaderWorldSC;
208   GFXShaderConstHandle* mFoliageShaderGlobalSwayPhaseSC;
209   GFXShaderConstHandle* mFoliageShaderSwayMagnitudeSideSC;
210   GFXShaderConstHandle* mFoliageShaderSwayMagnitudeFrontSC;
211   GFXShaderConstHandle* mFoliageShaderGlobalLightPhaseSC;
212   GFXShaderConstHandle* mFoliageShaderLuminanceMagnitudeSC;
213   GFXShaderConstHandle* mFoliageShaderLuminanceMidpointSC;
214   GFXShaderConstHandle* mFoliageShaderDistanceRangeSC;
215   GFXShaderConstHandle* mFoliageShaderCameraPosSC;
216   GFXShaderConstHandle* mFoliageShaderTrueBillboardSC;
217
218   //pixel shader
219   GFXShaderConstHandle* mFoliageShaderGroundAlphaSC;
220   GFXShaderConstHandle* mFoliageShaderAmbientColorSC;
221   GFXShaderConstHandle* mDiffuseTextureSC;
222   GFXShaderConstHandle* mAlphaMapTextureSC;
223
224
225
226   bool              mDirty;
227   
228   void SetupShader();
229   void SetupBuffers();
230   void renderObject(ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance*);
231   void renderBuffers(SceneRenderState* state);
232   void renderArc(const F32 fRadiusX, const F32 fRadiusY);
233   void renderPlacementArea(const F32 ElapsedTime);
234   void renderQuad(fxFoliageQuadrantNode* quadNode, const MatrixF& RenderTransform, const bool UseDebug);
235   void computeAlphaTex();
236public:
237   fxFoliageReplicator();
238   ~fxFoliageReplicator();
239
240   void StartUp(void);
241   void ShowReplication(void);
242   void HideReplication(void);
243
244   // SceneObject
245   virtual void prepRenderImage( SceneRenderState *state );
246
247   // SimObject
248   bool onAdd();
249   void onRemove();
250   void inspectPostApply();
251
252   // NetObject
253   U32 packUpdate(NetConnection *conn, U32 mask, BitStream *stream);
254   void unpackUpdate(NetConnection *conn, BitStream *stream);
255
256   // Editor
257   void onGhostAlwaysDone();
258
259   // ConObject.
260   static void initPersistFields();
261
262   // Field Data.
263   class tagFieldData
264   {
265      public:
266
267      bool              mUseDebugInfo;
268      F32               mDebugBoxHeight;
269      U32               mSeed;
270      StringTableEntry  mFoliageFile;
271      GFXTexHandle      mFoliageTexture;
272      U32               mFoliageCount;
273      U32               mFoliageRetries;
274
275      U32               mInnerRadiusX;
276      U32               mInnerRadiusY;
277      U32               mOuterRadiusX;
278      U32               mOuterRadiusY;
279
280      F32               mMinWidth;
281      F32               mMaxWidth;
282      F32               mMinHeight;
283      F32               mMaxHeight;
284      bool              mFixAspectRatio;
285      bool              mFixSizeToMax;
286      F32               mOffsetZ;
287      bool              mRandomFlip;
288      bool              mUseTrueBillboards;
289
290      bool              mUseCulling;
291      U32               mCullResolution;
292      F32               mViewDistance;
293      F32               mViewClosest;
294      F32               mFadeInRegion;
295      F32               mFadeOutRegion;
296      F32               mAlphaCutoff;
297      F32               mGroundAlpha;
298
299      bool              mSwayOn;
300      bool              mSwaySync;
301      F32               mSwayMagnitudeSide;
302      F32               mSwayMagnitudeFront;
303      F32               mMinSwayTime;
304      F32               mMaxSwayTime;
305
306      bool              mLightOn;
307      bool              mLightSync;
308      F32               mMinLuminance;
309      F32               mMaxLuminance;
310      F32               mLightTime;
311
312      bool            mAllowOnTerrain;
313      bool            mAllowStatics;
314      bool            mAllowOnWater;
315      bool            mAllowWaterSurface;
316      S32             mAllowedTerrainSlope;
317
318      bool            mHideFoliage;
319      bool            mShowPlacementArea;
320      U32             mPlacementBandHeight;
321      ColorF          mPlaceAreaColour;
322
323      tagFieldData()
324      {
325         // Set Defaults.
326         mUseDebugInfo         = false;
327         mDebugBoxHeight       = 1.0f;
328         mSeed                 = 1376312589;
329         mFoliageFile          = StringTable->EmptyString();
330         mFoliageTexture       = GFXTexHandle();
331         mFoliageCount         = 10;
332         mFoliageRetries       = 100;
333
334         mInnerRadiusX         = 0;
335         mInnerRadiusY         = 0;
336         mOuterRadiusX         = 128;
337         mOuterRadiusY         = 128;
338
339         mMinWidth             = 1;
340         mMaxWidth             = 3;
341         mMinHeight            = 1;
342         mMaxHeight            = 5;
343         mFixAspectRatio       = true;
344         mFixSizeToMax         = false;
345         mOffsetZ              = 0;
346         mRandomFlip           = true;
347         mUseTrueBillboards    = false;
348
349         mUseCulling           = true;
350         mCullResolution       = 64;
351         mViewDistance         = 50.0f;
352         mViewClosest          = 1.0f;
353         mFadeInRegion         = 10.0f;
354         mFadeOutRegion        = 1.0f;
355         mAlphaCutoff          = 0.2f;
356         mGroundAlpha          = 1.0f;
357
358         mSwayOn               = false;
359         mSwaySync             = false;
360         mSwayMagnitudeSide    = 0.1f;
361         mSwayMagnitudeFront   = 0.2f;
362         mMinSwayTime          = 3.0f;
363         mMaxSwayTime          = 10.0f;
364
365         mLightOn              = false;
366         mLightSync            = false;
367         mMinLuminance         = 0.7f;
368         mMaxLuminance         = 1.0f;
369         mLightTime            = 5.0f;
370
371         mAllowOnTerrain       = true;
372         mAllowStatics         = true;
373         mAllowOnWater         = false;
374         mAllowWaterSurface    = false;
375         mAllowedTerrainSlope  = 90;
376
377         mHideFoliage          = false;
378         mShowPlacementArea    = true;
379         mPlacementBandHeight  = 25;
380         mPlaceAreaColour      .set(0.4f, 0, 0.8f);
381      }
382
383   } mFieldData;
384
385   // Declare Console Object.
386   DECLARE_CONOBJECT(fxFoliageReplicator);
387};
388#pragma warning( pop ) 
389#endif // _FOLIAGEREPLICATOR_H_
390