BVB Source Codes

CRYENGINE Show VoxelSegment.h Source code

Return Download CRYENGINE: download VoxelSegment.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __VOXELSEGMENT_H__
  4. #define __VOXELSEGMENT_H__
  5.  
  6. #if defined(FEATURE_SVO_GI)
  7.  
  8.         #pragma pack(push,4)
  9.  
  10. //#pragma optimize("",off)
  11.  
  12. const int nVoxTexMaxDim = (16);
  13. const int nVoxBloMaxDim = (16);
  14. const int nVoxNodMaxDim = 2;
  15.  
  16.         #define nAtlasDimMaxXY            (CVoxelSegment::nVoxTexPoolDimXY / nVoxBloMaxDim)
  17.         #define nAtlasDimMaxZ             (CVoxelSegment::nVoxTexPoolDimZ / nVoxBloMaxDim)
  18.  
  19.         #define nAtlasDimBriXY            (CVoxelSegment::nVoxTexPoolDimXY / nVoxTexMaxDim)
  20.         #define nAtlasDimBriZ             (CVoxelSegment::nVoxTexPoolDimZ / nVoxTexMaxDim)
  21.  
  22.         #define nVoxNodPoolDimXY          (nVoxNodMaxDim * nAtlasDimMaxXY)
  23.         #define nVoxNodPoolDimZ           (nVoxNodMaxDim * nAtlasDimMaxZ)
  24.  
  25.         #define VOXEL_PAINT_SAFETY_BORDER 4.f
  26.  
  27.         #define SVO_TEMP_FILE_NAME        "CDD.TMP"
  28.  
  29. typedef std::set<class CVoxelSegment*> VsSet;
  30.  
  31. struct SCpuBrickItem
  32. {
  33.         ColorB arrData[nVoxTexMaxDim * nVoxTexMaxDim * nVoxTexMaxDim];
  34. };
  35.  
  36. template<class T>
  37. class PodArrayRT : public PodArray<T>
  38. {
  39. public:
  40.         PodArrayRT()
  41.         {
  42.                 m_bModified = false;
  43.                 m_nTexId = 0;
  44.         }
  45.         CryReadModifyLock m_Lock;
  46.         bool              m_bModified;
  47.         int               m_nTexId;
  48. };
  49.  
  50. struct SObjInfo
  51. {
  52.         SObjInfo() { ZeroStruct(*this); }
  53.         Matrix34   matObjInv;
  54.         Matrix34   matObj;
  55.         float      fObjScale;
  56.         IMaterial* pMat;
  57.         CStatObj*  pStatObj;
  58.         bool       bIndoor;
  59.         bool       bVegetation;
  60. };
  61.  
  62. struct SVoxSegmentFileHeader
  63. {
  64.         int32 nSecId;
  65.         int32 key;
  66.         AABB  box;
  67.         float fPointSize;
  68.         int32 nVrtNum;
  69.         int32 nIndNum;
  70.         int32 nSprNum;
  71.         Vec3i vCropTexSize;
  72.         Vec3  vCropBoxMin;
  73. };
  74.  
  75. // SSuperMesh index type
  76.         #if CRY_PLATFORM_WINDOWS && CRY_PLATFORM_64BIT
  77. typedef uint32 SMINDEX;
  78.         #else
  79. typedef uint16 SMINDEX;
  80.         #endif
  81.  
  82. struct SRayHitTriangleIndexed
  83. {
  84.         SRayHitTriangleIndexed() { ZeroStruct(*this); arrVertId[0] = arrVertId[1] = arrVertId[2] = (SMINDEX) ~0; }
  85.         #ifdef FEATURE_SVO_GI_ALLOW_HQ
  86.         Vec3 vFaceNorm;
  87.                 #ifdef FEATURE_SVO_GI_USE_MESH_RT
  88.         uint nGLobalId;
  89.                 #endif
  90.         #endif
  91.         uint8   nTriArea;
  92.         uint8   nOpacity;
  93.         uint8   nHitObjType;
  94.         SMINDEX arrVertId[3];
  95.         uint16  nMatID;
  96. };
  97.  
  98. struct SRayHitVertex
  99. {
  100.         Vec3   v;
  101.         Vec2   t;
  102.         #ifdef FEATURE_SVO_GI_ALLOW_HQ
  103.         ColorB c;
  104.         #endif
  105. };
  106.  
  107. struct SSuperMesh
  108. {
  109.         SSuperMesh();
  110.         ~SSuperMesh();
  111.  
  112.         struct SSvoMatInfo
  113.         {
  114.                 SSvoMatInfo(){ ZeroStruct(*this); }
  115.                 IMaterial* pMat;
  116.                 ColorB*    pTexRgb;
  117.                 uint16     nTexWidth;
  118.                 uint16     nTexHeight;
  119.                 inline bool operator==(const SSvoMatInfo& other) const { return pMat == other.pMat; }
  120.         };
  121.  
  122.         static const int nHashDim = 8;
  123.         void AddSuperTriangle(SRayHitTriangle& htIn, PodArray<SMINDEX> arrVertHash[nHashDim][nHashDim][nHashDim]);
  124.         void AddSuperMesh(SSuperMesh& smIn, float fVertexOffset);
  125.         void Clear(PodArray<SMINDEX>* parrVertHash);
  126.  
  127.         PodArrayRT<SRayHitTriangleIndexed>* m_pTrisInArea;
  128.         PodArrayRT<Vec3>*                   m_pFaceNormals;
  129.         PodArrayRT<SRayHitVertex>*          m_pVertInArea;
  130.         PodArrayRT<SSvoMatInfo>*            m_pMatsInArea;
  131.         AABB                                m_boxTris;
  132.  
  133. protected:
  134.         int FindVertex(const Vec3& rPos, const Vec2 rTC, PodArray<SMINDEX> arrVertHash[nHashDim][nHashDim][nHashDim], PodArrayRT<SRayHitVertex>& vertsInArea);
  135.         int AddVertex(const SRayHitVertex& rVert, PodArray<SMINDEX> arrVertHash[nHashDim][nHashDim][nHashDim], PodArrayRT<SRayHitVertex>& vertsInArea);
  136.         bool m_bExternalData;
  137. };
  138.  
  139. class CVoxelSegment : public Cry3DEngineBase, public SSuperMesh
  140. {
  141. public:
  142.  
  143.         CVoxelSegment(class CSvoNode* pNode, bool bDumpToDiskInUse = false, EFileStreamingStatus eStreamingStatus = ecss_Ready, bool bDroppedOnDisk = false);
  144.         ~CVoxelSegment();
  145.         bool         CheckUpdateBrickRenderData(bool bJustCheck);
  146.         bool         LoadFromMem(CMemoryBlock* pMB);
  147.         bool         StartStreaming();
  148.         bool         UpdateBrickRenderData();
  149.         ColorF       GetBilinearAt(float iniX, float iniY, const ColorB* pImg, int nDimW, int nDimH, float fBr);
  150.         ColorF       GetColorF_255(int x, int y, const ColorB* pImg, int nImgSizeW, int nImgSizeH);
  151.         ColorF       ProcessMaterial(const SRayHitTriangleIndexed& tr, const Vec3& voxBox);
  152.         const AABB&  GetBoxOS()   { return m_boxOS; }
  153.         float        GetBoxSize() { return (m_boxOS.max.z - m_boxOS.min.z); }
  154.         int          StoreIndicesIntoPool(const PodArray<int>& nodeTInd, int& nCountStored);
  155.         int32        GetID()      { return m_nSegID; }
  156.         static AABB  GetChildBBox(const AABB& parentBox, int nChildId);
  157.         static int   GetBrickPoolUsageLoadedMB();
  158.         static int   GetBrickPoolUsageMB();
  159.         static int32 ComparemLastVisFrameID(const void* v1, const void* v2);
  160.         static void  CheckAllocateBrick(ColorB*& pPtr, int nElems, bool bClean = false);
  161.         static void  CheckAllocateTexturePool();
  162.         static void  FreeBrick(ColorB*& pPtr);
  163.         static void  MakeFolderName(char szFolder[256], bool bCreateDirectory = false);
  164.         static void  SetVoxCamera(const CCamera& newCam);
  165.         static void  UpdateStreamingEngine();
  166.         static void  ErrorTerminate(const char* format, ...);
  167.         Vec3i        GetDxtDim();
  168.         void         AddTriangle(const SRayHitTriangleIndexed& ht, int trId, PodArray<int>*& rpNodeTrisXYZ, PodArrayRT<SRayHitVertex>* pVertInArea);
  169.         void         CheckStoreTextureInPool(SShaderItem* pShItem, uint16& nTexW, uint16& nTexH, int** ppSysTexId);
  170.         void         ComputeDistancesFast_MinDistToSurf(ColorB* pTex3dOptRGBA, ColorB* pTex3dOptNorm, ColorB* pTex3dOptOpac, int nTID);
  171.         void         CropVoxTexture(int nTID, bool bCompSurfDist);
  172.         void         DebugDrawVoxels();
  173.         void         FindTrianglesForVoxelization(int nTID, PodArray<int>*& rpNodeTrisXYZ, bool bThisIsAreaParent);
  174.         static bool  CheckCollectObjectsForVoxelization(const AABB& nodeBox, PodArray<SObjInfo>* parrObjects, bool& bThisIsAreaParent, bool& bThisIsLowLodNode, bool bAllowStartStreaming);
  175.         void         FreeAllBrickData();
  176.         void         FreeRenderData();
  177.         void         PropagateDirtyFlag();
  178.         void         ReleaseAtlasBlock();
  179.         void         RenderMesh(CRenderObject* pObj, PodArray<SVF_P3F_C4B_T2F>& arrVertsOut);
  180.         void         SetBoxOS(const AABB& box) { m_boxOS = box; }
  181.         void         SetID(int32 nID)          { m_nSegID = nID; }
  182.         void         StoreAreaTrisIntoTriPool(PodArray<SRayHitTriangle>& allTrisInLevel);
  183.         void         StreamAsyncOnComplete(byte* pDataRead, int nBytesRead, int nTID);
  184.         void         StreamOnComplete();
  185.         void         UnloadStreamableData();
  186.         void         UpdateMeshRenderData();
  187.         void         UpdateNodeRenderData();
  188.         void         UpdateVoxRenderData();
  189.         void         VoxelizeMeshes(int nTID);
  190.  
  191.         AABB            m_boxClipped;
  192.         AABB            m_boxOS;
  193.         bool            m_bStatLightsChanged;
  194.         byte            m_nChildOffsetsDirty;
  195.         class CSvoNode* m_pNode;
  196.         ColorB*         m_pVoxOpacit;
  197.         #ifdef FEATURE_SVO_GI_ALLOW_HQ
  198.         ColorB*         m_pVoxVolume;
  199.         ColorB*         m_pVoxNormal;
  200.                 #ifdef FEATURE_SVO_GI_USE_MESH_RT
  201.         ColorB*         m_pVoxTris;
  202.                 #endif
  203.         #endif
  204.         CVoxelSegment*                    m_pParentCloud;
  205.         EFileStreamingStatus              m_eStreamingStatus;
  206.         float                             m_fMaxAlphaInBrick;
  207.         int                               m_nAllocatedAtlasOffset;
  208.         int                               m_nFileStreamSize;
  209.         int32                             m_arrChildOffset[8];
  210.         int32                             m_nSegID;
  211.         int64                             m_nFileStreamOffset64;
  212.         PodArray<int>                     m_nodeTrisAllMerged;
  213.  
  214.         static CCamera                    m_voxCam;
  215.         static class CBlockPacker3D*      m_pBlockPacker;
  216.         static CryCriticalSection         m_csLockBrick;
  217.         static int                        m_nAddPolygonToSceneCounter;
  218.         static int                        m_nCheckReadyCounter;
  219.         static int                        m_nCloudsCounter;
  220.         static int                        m_nPostponedCounter;
  221.         static int                        m_nCurrPassMainFrameID;
  222.         static int                        m_nMaxBrickUpdates;
  223.         static int                        m_nNextCloudId;
  224.         static int                        m_nPoolUsageBytes;
  225.         static int                        m_nPoolUsageItems;
  226.         static int                        m_nSvoDataPoolsCounter;
  227.         static int                        m_nVoxTrisCounter;
  228.         static int                        nVoxTexPoolDimXY;
  229.         static int                        nVoxTexPoolDimZ;
  230.         static int32                      m_nStreamingTasksInProgress;
  231.         static int32                      m_nTasksInProgressALL;
  232.         static int32                      m_nUpdatesInProgressBri;
  233.         static int32                      m_nUpdatesInProgressTex;
  234.         static PodArray<CVoxelSegment*>   m_arrLoadedSegments;
  235.         static SRenderingPassInfo*        m_pCurrPassInfo;
  236.         static string                     m_strRenderDataFileName;
  237.         static PodArrayRT<ITexture*>      m_arrLockedTextures;
  238.         static PodArrayRT<IMaterial*>     m_arrLockedMaterials;
  239.         static std::map<CStatObj*, float> m_cgfTimeStats;
  240.         static CryReadModifyLock          m_cgfTimeStatsLock;
  241.         struct SBlockMinMax*              m_pBlockInfo;
  242.         SVF_P3F_C4B_T2F                   m_vertForGS;
  243.         uint                              m_nLastRendFrameId;
  244.         uint                              m_nLastTexUpdateFrameId;
  245.         uint16                            m_nVoxNum;
  246.         uint8                             m_dwChildTrisTest;
  247.         Vec3                              m_vCropBoxMin;
  248.         Vec3                              m_vSegOrigin;
  249.         Vec3i                             m_vCropTexSize;
  250.         Vec3i                             m_vStaticGeomCheckSumm;
  251.         Vec3i                             m_vStatLightsCheckSumm;
  252.         CryReadModifyLock                 m_superMeshLock;
  253. };
  254.  
  255. template<class T, int nMaxQeueSize>
  256. struct SThreadSafeArray
  257. {
  258.         SThreadSafeArray()
  259.         {
  260.                 m_bThreadDone = false;
  261.                 m_nMaxQeueSize = nMaxQeueSize;
  262.                 m_ucOverflow = 0;
  263.                 m_nRequestFrameId = 0;
  264.         }
  265.  
  266.         bool               m_bThreadDone;
  267.         int                m_nMaxQeueSize;
  268.         PodArray<T>        m_arrQeue;
  269.         CryCriticalSection m_csQeue;
  270.         unsigned char      m_ucOverflow;
  271.         int                m_nRequestFrameId;
  272.  
  273.         T                  GetNextTaskFromQeue()
  274.         {
  275.                 T pNewTask = NULL;
  276.  
  277.                 if (m_arrQeue.Count())
  278.                 {
  279.                         AUTO_LOCK(m_csQeue);
  280.                         if (m_arrQeue.Count())
  281.                         {
  282.                                 pNewTask = m_arrQeue[0];
  283.                                 m_arrQeue.Delete((const int)0);
  284.                         }
  285.                 }
  286.  
  287.                 return pNewTask;
  288.         }
  289.  
  290.         T GetNextTaskFromQeueOrdered2()
  291.         {
  292.                 T pNewTask = NULL;
  293.  
  294.                 if (m_arrQeue.Count())
  295.                 {
  296.                         AUTO_LOCK(m_csQeue);
  297.                         if (m_arrQeue.Count())
  298.                         {
  299.                                 for (int i = 0; i < m_arrQeue.Count(); i++)
  300.                                 {
  301.                                         if (m_arrQeue[i].nRequestFrameId == m_nRequestFrameId)
  302.                                         {
  303.                                                 pNewTask = m_arrQeue[i];
  304.                                                 m_arrQeue.Delete((const int)i);
  305.                                                 m_nRequestFrameId++;
  306.                                                 break;
  307.                                         }
  308.                                 }
  309.                         }
  310.                 }
  311.  
  312.                 return pNewTask;
  313.         }
  314.  
  315.         T GetNextTaskFromQeueOrdered()
  316.         {
  317.                 T pNewTask = NULL;
  318.  
  319.                 if (m_arrQeue.Count())
  320.                 {
  321.                         AUTO_LOCK(m_csQeue);
  322.                         if (m_arrQeue.Count())
  323.                         {
  324.                                 for (int i = 0; i < m_arrQeue.Count(); i++)
  325.                                 {
  326.                                         if (m_arrQeue[i]->pIBackBufferReader->nRequestFrameId == m_nRequestFrameId)
  327.                                         {
  328.                                                 pNewTask = m_arrQeue[i];
  329.                                                 m_arrQeue.Delete((const int)i);
  330.                                                 m_nRequestFrameId++;
  331.                                                 break;
  332.                                         }
  333.                                 }
  334.                         }
  335.                 }
  336.  
  337.                 return pNewTask;
  338.         }
  339.  
  340.         T GetNextTaskFromQeueOrderedForThread(int nCTID)
  341.         {
  342.                 T pNewTask = NULL;
  343.  
  344.                 if (m_arrQeue.Count())
  345.                 {
  346.                         AUTO_LOCK(m_csQeue);
  347.                         if (m_arrQeue.Count())
  348.                         {
  349.                                 for (int i = 0; i < m_arrQeue.Count(); i++)
  350.                                 {
  351.                                         if (m_arrQeue[i]->pIBackBufferReader->nRequestFrameId == m_nRequestFrameId && ((m_arrQeue[i]->pIBackBufferReader->nUserId & 1) == (nCTID & 1)))
  352.                                         {
  353.                                                 pNewTask = m_arrQeue[i];
  354.                                                 m_arrQeue.Delete((const int)i);
  355.                                                 m_nRequestFrameId++;
  356.                                                 break;
  357.                                         }
  358.                                 }
  359.                         }
  360.                 }
  361.  
  362.                 return pNewTask;
  363.         }
  364.  
  365.         void AddNewTaskToQeue(T pNewTask, bool bSkipOverflow = false)
  366.         {
  367.                 if (m_ucOverflow)
  368.                         m_ucOverflow--;
  369.  
  370.                 if (bSkipOverflow)
  371.                 {
  372.                         // drop new item in case of overflow
  373.                         if (m_arrQeue.Count() >= m_nMaxQeueSize)
  374.                         {
  375.                                 m_ucOverflow = ~0;
  376.                                 return;
  377.                         }
  378.                 }
  379.                 else
  380.                 {
  381.                         // stall in case of overflow
  382.                         while (m_arrQeue.Count() >= m_nMaxQeueSize)
  383.                         {
  384.                                 m_ucOverflow = ~0;
  385.                                 CrySleep(1);
  386.                         }
  387.                 }
  388.  
  389.                 {
  390.                         AUTO_LOCK(m_csQeue);
  391.                         m_arrQeue.Add(pNewTask);
  392.                 }
  393.         }
  394.  
  395.         int Count()
  396.         {
  397.                 return m_arrQeue.Count();
  398.         }
  399.  
  400.         void OnDisplayInfo(float& fTextPosX, float& fTextPosY, float& fTextStepY, float fTextScale, C3DEngine* pEnd, const char* szName)
  401.         {
  402.                 ColorF colRed = ColorF(1, 0, 0, 1);
  403.                 ColorF colGreen = ColorF(0, 1, 0, 1);
  404.                 pEnd->DrawTextRightAligned(fTextPosX, fTextPosY += fTextStepY, fTextScale, m_ucOverflow ? Col_Red : Col_Green, "%s: %2d", szName, Count());
  405.         }
  406. };
  407.  
  408. inline uint GetCurrPassMainFrameID() { return CVoxelSegment::m_nCurrPassMainFrameID; }
  409.  
  410.         #pragma pack(pop)
  411.  
  412. #endif
  413.  
  414. #endif
  415.  
downloadVoxelSegment.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top