BVB Source Codes

CRYENGINE Show MergedMeshGeometry.h Source code

Return Download CRYENGINE: download MergedMeshGeometry.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef _PROCEDURALVEGETATION_GEOMETRY_
  4. #define _PROCEDURALVEGETATION_GEOMETRY_
  5. #include "MergedMeshRenderNode.h"
  6. #include <Cry3DEngine/IIndexedMesh.h>
  7.  
  8. #define c_MergedMeshesExtent     (18.f)
  9. #define c_MergedMeshChunkVersion (0xcafebab6)
  10.  
  11. #if MMRM_USE_VECTORIZED_SSE_INSTRUCTIONS
  12.         #include <xmmintrin.h>
  13.         #if CRY_PLATFORM_SSE3 || CRY_PLATFORM_SSE4 || CRY_PLATFORM_AVX
  14.                 #include <pmmintrin.h> // SSE3
  15.         #endif
  16.         #if CRY_PLATFORM_SSE4 || CRY_PLATFORM_AVX
  17.                 #include <smmintrin.h> // SSE4.1
  18.                 #include <nmmintrin.h> // SSE4.2
  19.         #endif
  20.         #if CRY_PLATFORM_AVX || CRY_PLATFORM_F16C
  21.                 #include <immintrin.h> // AVX, F16C
  22.  
  23.                 #pragma warning(disable:4700)
  24.                 #if CRY_COMPILER_MSVC
  25.                         #include <intrin.h>
  26.                 #endif
  27.         #endif
  28. typedef      CRY_ALIGN (16) Vec3 aVec3;
  29. typedef      CRY_ALIGN (16) Quat aQuat;
  30. #else
  31. typedef Vec3 aVec3;
  32. typedef Quat aQuat;
  33. #endif
  34.  
  35. enum MMRM_CULL_FLAGS
  36. {
  37.         MMRM_CULL_FRUSTUM             = 0x1
  38.         , MMRM_CULL_DISTANCE          = 0x2
  39.         , MMRM_CULL_LOD               = 0x4
  40.         , MMRM_LOD_SHIFT              = 3
  41.         , MMRM_SAMPLE_REDUCTION_SHIFT = 5
  42. };
  43.  
  44. struct SMergedMeshInstanceCompressed
  45. {
  46.         uint16 pos_x;
  47.         uint16 pos_y;
  48.         uint16 pos_z;
  49.         uint8  scale;
  50.         int8   rot[4];
  51.         AUTO_STRUCT_INFO_LOCAL;
  52. };
  53.  
  54. struct SMergedMeshSectorChunk
  55. {
  56.         uint32 ver, i, j, k;
  57.         uint32 m_StatInstGroupID;
  58.         uint32 m_nSamples;
  59.         AUTO_STRUCT_INFO_LOCAL;
  60. };
  61.  
  62. struct Vec3fixed16
  63. {
  64. public:
  65.         int16 x, y, z;
  66.  
  67.         Vec3fixed16() {}
  68.         Vec3fixed16(const Vec3& src)
  69.         {
  70.                 float _x(clamp_tpl(src.x, -127.f, 128.f) * (float)(1 << 8));
  71.                 float _y(clamp_tpl(src.y, -127.f, 128.f) * (float)(1 << 8));
  72.                 float _z(clamp_tpl(src.z, -127.f, 128.f) * (float)(1 << 8));
  73.                 x = static_cast<int16>(_x);
  74.                 y = static_cast<int16>(_y);
  75.                 z = static_cast<int16>(_z);
  76.         }
  77.         Vec3fixed16& operator=(const Vec3& src)
  78.         {
  79.                 float _x(clamp_tpl(src.x, -127.f, 128.f) * (float)(1 << 8));
  80.                 float _y(clamp_tpl(src.y, -127.f, 128.f) * (float)(1 << 8));
  81.                 float _z(clamp_tpl(src.z, -127.f, 128.f) * (float)(1 << 8));
  82.                 x = static_cast<int16>(_x);
  83.                 y = static_cast<int16>(_y);
  84.                 z = static_cast<int16>(_z);
  85.                 return *this;
  86.         }
  87.         Vec3 ToVec3() const
  88.         {
  89.                 int _x(static_cast<int>(x));
  90.                 int _y(static_cast<int>(y));
  91.                 int _z(static_cast<int>(z));
  92.                 Vec3 r;
  93.                 r.x = static_cast<int16>(_x / (1 << 8));
  94.                 r.y = static_cast<int16>(_y / (1 << 8));
  95.                 r.z = static_cast<int16>(_z / (1 << 8));
  96.                 return r;
  97.         }
  98. };
  99.  
  100. #if MMRM_USE_VECTORIZED_SSE_INSTRUCTIONS
  101. typedef Vec3fixed16 Vec3half;
  102. struct SMMRMBoneMapping
  103. {
  104.         CRY_ALIGN(16) float weights[4]; //weights for every bone (stored as floats to prevent lhs)
  105.         ColorB boneIds;                 //boneIDs per render-batch
  106.  
  107.         SMMRMBoneMapping& operator=(const SMeshBoneMapping_uint8& mbm)
  108.         {
  109.                 boneIds.r = mbm.boneIds[0];
  110.                 boneIds.g = mbm.boneIds[1];
  111.                 boneIds.b = mbm.boneIds[2];
  112.                 boneIds.a = mbm.boneIds[3];
  113.                 for (size_t i = 0; i < 4; ++i) weights[i] = static_cast<float>(mbm.weights[i]);
  114.                 for (size_t i = 0; i < 4; ++i) weights[i] *= 1.f / 255.f;
  115.                 return *this;
  116.         }
  117.  
  118.         bool operator!=(const SMMRMBoneMapping& mbm) const
  119.         {
  120.                 if (boneIds != mbm.boneIds) return true;
  121.                 for (size_t i = 0; i < 4; ++i)
  122.                         if (weights[i] != mbm.weights[i])
  123.                                 return true;
  124.                 return false;
  125.         }
  126. };
  127. #else
  128. typedef Vec3fixed16            Vec3half;
  129. typedef SMeshBoneMapping_uint8 SMMRMBoneMapping;
  130. #endif
  131.  
  132. struct SProcVegSample
  133. {
  134.         Vec3   pos;
  135.         Quat   q;
  136.         uint32 InstGroupId;
  137.         uint8  scale;
  138. };
  139.  
  140. struct CRY_ALIGN(16) SSampleDensity
  141. {
  142.         union
  143.         {
  144.                 uint8 density_u8[16];
  145.         };
  146. };
  147.  
  148. struct CRY_ALIGN(16) SMMRMDeformVertex
  149. {
  150.         Vec3 pos[2], vel;
  151. };
  152.  
  153. struct SMMRMDeformConstraint
  154. {
  155.         enum
  156.         {
  157.                 DC_POSITIONAL = 0,
  158.                 DC_EDGE,
  159.                 DC_BENDING,
  160.         };
  161.         // Strength of constraint (valid range 0..1, 0 meaning no enforcement, 1 full enforcement)
  162.         // Values above or below the valid range are possible (and sometimes desirable) but make
  163.         // no mathematical sense.
  164.         float k;
  165.         union
  166.         {
  167.                 // limits the edge length between two vertices at index position[0/1]
  168.                 struct
  169.                 {
  170.                         float   edge_distance;
  171.                         vtx_idx edge[2];
  172.                 };
  173.                 // limits the bending of the bending triangle spanned between the three
  174.                 // bending vertices. the initial displacement is the height of the second
  175.                 // vertex in respect to the longest edge of the triangle.
  176.                 struct
  177.                 {
  178.                         float   displacement;
  179.                         vtx_idx bending[3];
  180.                 };
  181.         };
  182.         // Type depicting data stored in the union
  183.         uint8 type;
  184. };
  185.  
  186. struct CRY_ALIGN(16) SMMRMDeform
  187. {
  188.         SMMRMDeformConstraint* constraints;
  189.         size_t nconstraints;
  190.         float* invmass;
  191.         Vec3* initial;
  192.         vtx_idx* mapping;
  193.         size_t nvertices;
  194.         SMMRMDeform()
  195.                 : constraints()
  196.                   , nconstraints()
  197.                   , invmass()
  198.                   , initial()
  199.                   , mapping()
  200.                   , nvertices()
  201.         {
  202.         }
  203.         ~SMMRMDeform()
  204.         {
  205.                 if (constraints) CryModuleMemalignFree(constraints);
  206.                 if (invmass) CryModuleMemalignFree(invmass);
  207.                 if (initial) CryModuleMemalignFree(initial);
  208.                 if (mapping) CryModuleMemalignFree(mapping);
  209.         }
  210. };
  211.  
  212. // Note: This struct NEEDs to be 64 large and 64 byte aligned
  213. // Do not change unless absolutely necessary
  214. #define SMMRMSkinVertex_ALIGN 64
  215. #define SMMRMSkinVertex_SIZE  64
  216. struct CRY_ALIGN(SMMRMSkinVertex_ALIGN) SMMRMSkinVertex
  217. {
  218.         float weights[4];
  219.         Vec3 pos;
  220.         Vec3 normal;
  221.         Vec2 uv;
  222.         UCol colour;
  223.         SPipQTangents qt;
  224.         uint8 boneIds[4];
  225.  
  226.         void SetWeights(const float* pSrcWeights)
  227.         {
  228.                 memcpy(weights, pSrcWeights, sizeof(weights));
  229.         }
  230.  
  231.         void SetWeights(const uint8* srcWeights)
  232.         {
  233.                 for (int i = 0; i < 4; ++i)
  234.                 {
  235.                         weights[i] = srcWeights[i] / 255.0f;
  236.                 }
  237.         }
  238.  
  239.         void SetBoneIds(const uint8* srcBoneIds)
  240.         {
  241.                 for (int i = 0; i < 4; ++i)
  242.                 {
  243.                         boneIds[i] = srcBoneIds[i];
  244.                 }
  245.         }
  246.  
  247.         void SetBoneIds(const ColorB& srcBoneIds)
  248.         {
  249.                 boneIds[0] = srcBoneIds.r;
  250.                 boneIds[1] = srcBoneIds.g;
  251.                 boneIds[2] = srcBoneIds.b;
  252.                 boneIds[3] = srcBoneIds.a;
  253.         }
  254.  
  255. };
  256. static_assert(sizeof(SMMRMSkinVertex) == SMMRMSkinVertex_SIZE, "Invalid type size!");
  257.  
  258. struct CRY_ALIGN(16) SMMRMChunk
  259. {
  260.         int matId;
  261.         uint32 nvertices, nvertices_alloc;
  262.         uint32 nindices, nindices_alloc;
  263.         SVF_P3F_C4B_T2F* general;
  264.         SPipQTangents* qtangents;
  265.         SMMRMBoneMapping* weights;
  266.         Vec3* normals;
  267.         vtx_idx* indices;
  268.         SMMRMSkinVertex* skin_vertices;
  269.  
  270.         SMMRMChunk(int _matId)
  271.                 : matId(_matId)
  272.                   , nvertices()
  273.                   , nvertices_alloc()
  274.                   , nindices()
  275.                   , nindices_alloc()
  276.                   , general()
  277.                   , qtangents()
  278.                   , normals()
  279.                   , weights()
  280.                   , indices()
  281.                   , skin_vertices()
  282.         {
  283.         }
  284.         ~SMMRMChunk()
  285.         {
  286.                 if (general) CryModuleMemalignFree(general);
  287.                 if (qtangents) CryModuleMemalignFree(qtangents);
  288.                 if (weights) CryModuleMemalignFree(weights);
  289.                 if (normals) CryModuleMemalignFree(normals);
  290.                 if (indices) CryModuleMemalignFree(indices);
  291.                 if (skin_vertices) CryModuleMemalignFree(skin_vertices);
  292.         }
  293.         uint32 Size() const
  294.         {
  295.                 uint32 size = 0u;
  296.                 size += sizeof(SVF_P3F_C4B_T2F) * nvertices_alloc;
  297.                 size += sizeof(SPipTangents) * nvertices_alloc;
  298.                 size += weights ? sizeof(SMMRMBoneMapping) * nvertices_alloc : 0;
  299.                 size += normals ? sizeof(Vec3) * nvertices_alloc : 0;
  300.                 size += sizeof(indices[0]) * nindices_alloc;
  301.                 size += (skin_vertices) ? sizeof(SMMRMSkinVertex) * nvertices_alloc : 0;
  302.                 return size;
  303.         }
  304. };
  305.  
  306. struct SMMRMSpineVtxBase
  307. {
  308. #if MMRM_SIMULATION_USES_FP32
  309.         Vec3     pt;
  310.         Vec3     vel;
  311. #else
  312.         Vec3half pt;
  313.         Vec3half vel;
  314. #endif
  315. };
  316.  
  317. struct CRY_ALIGN(16) SMMRMSpineVtx
  318. {
  319.         Vec3 pt;
  320.         float len, h;
  321. };
  322.  
  323. struct CRY_ALIGN(16) SMMRMSpineInfo
  324. {
  325.         size_t nSpineVtx;
  326.         float fSpineLen;
  327. };
  328.  
  329. struct CRY_ALIGN(16) SMMRMGeometry
  330. {
  331.         enum State
  332.         {
  333.                 CREATED = 0,
  334.                 PREPARED,
  335.                 NO_RENDERMESH,
  336.                 NO_STATINSTGROUP
  337.         };
  338.  
  339.         AABB aabb;
  340.         SMMRMChunk* pChunks[MAX_STATOBJ_LODS_NUM];
  341.         size_t numChunks[MAX_STATOBJ_LODS_NUM];
  342.         size_t numIdx, numVtx; // numIdx & numVtx reflect counts for first lod
  343.         size_t numSpineVtx, numSpines, maxSpinesPerVtx;
  344.         SMMRMSpineVtx* pSpineVtx;
  345.         SMMRMSpineInfo* pSpineInfo;
  346.         SMMRMDeform* deform;
  347.         State state;
  348.         union
  349.         {
  350.                 uint32    srcGroupId;
  351.                 CStatObj* srcObj;
  352.         };
  353.         size_t refCount;
  354.         JobManager::SJobState geomPrepareState;
  355. #ifdef SEG_WORLD
  356.         uint16 m_nStaticTypeSlot;
  357. #endif
  358.         const bool is_obj : 1;
  359.  
  360.         SMMRMGeometry(CStatObj * obj, uint16 slot)
  361.                 : aabb(AABB::RESET)
  362.                   , numIdx()
  363.                   , numVtx()
  364.                   , numSpineVtx()
  365.                   , numSpines()
  366.                   , maxSpinesPerVtx()
  367.                   , refCount()
  368.                   , pSpineVtx()
  369.                   , pSpineInfo()
  370.                   , deform()
  371.                   , state(CREATED)
  372.                   , srcObj(obj)
  373.                   , geomPrepareState()
  374. #ifdef SEG_WORLD
  375.                   , m_nStaticTypeSlot(slot)
  376. #endif
  377.                   , is_obj(true)
  378.         {
  379.                 memset(pChunks, 0, sizeof(pChunks));
  380.                 memset(numChunks, 0, sizeof(numChunks));
  381.                 aabb.max = aabb.min = Vec3(0, 0, 0);
  382.         };
  383.  
  384.         SMMRMGeometry(uint32 groupId, uint16 slot)
  385.                 : srcGroupId(groupId)
  386.                   , aabb(AABB::RESET)
  387.                   , numIdx()
  388.                   , numVtx()
  389.                   , numSpineVtx()
  390.                   , numSpines()
  391.                   , maxSpinesPerVtx()
  392.                   , refCount()
  393.                   , pSpineVtx()
  394.                   , pSpineInfo()
  395.                   , deform()
  396.                   , state(CREATED)
  397.                   , geomPrepareState()
  398. #ifdef SEG_WORLD
  399.                   , m_nStaticTypeSlot(slot)
  400. #endif
  401.                   , is_obj(false)
  402.         {
  403.                 memset(pChunks, 0, sizeof(pChunks));
  404.                 memset(numChunks, 0, sizeof(numChunks));
  405.         }
  406.  
  407.         ~SMMRMGeometry()
  408.         {
  409.                 for (size_t i = 0; i < MAX_STATOBJ_LODS_NUM; ++i)
  410.                         if (pChunks[i])
  411.                         {
  412.                                 for (size_t j = 0; j < numChunks[i]; ++j)
  413.                                         pChunks[i][j].~SMMRMChunk();
  414.                                 CryModuleMemalignFree(pChunks[i]);
  415.                         }
  416.                 if (pSpineVtx) CryModuleMemalignFree(pSpineVtx);
  417.                 if (pSpineInfo) CryModuleMemalignFree(pSpineInfo);
  418.                 delete deform;
  419.         }
  420.  
  421.         uint32 Size() const
  422.         {
  423.                 uint32 size = 0u;
  424.                 for (size_t i = 0; i < MAX_STATOBJ_LODS_NUM; ++i)
  425.                         for (size_t j = 0; j < numChunks[i]; ++j)
  426.                         {
  427.                                 size += pChunks[i][j].Size();
  428.                                 size += sizeof(SMMRMChunk);
  429.                         }
  430.                 for (size_t i = 0; i < numSpines; ++i)
  431.                         size += sizeof(SMMRMSpineVtx) * pSpineInfo[i].nSpineVtx;
  432.                 size += numSpines * sizeof(SMMRMSpineInfo);
  433.                 if (deform)
  434.                 {
  435.                         size += deform->nconstraints * sizeof(SMMRMDeformConstraint);
  436.                         size += deform->nvertices * sizeof(uint16);
  437.                 }
  438.                 return size;
  439.         }
  440. };
  441.  
  442. struct CRY_ALIGN(16) SMMRMInstance
  443. {
  444.         uint32 pos_x : 16;
  445.         uint32 pos_y : 16;
  446.         uint32 pos_z : 16;
  447.         int32 qx : 8;
  448.         int32 qy : 8;
  449.         int32 qz : 8;
  450.         int32 qw : 8;
  451.         uint8 scale;
  452.         int8 lastLod;
  453. };
  454.  
  455. struct SMMRMVisibleChunk
  456. {
  457.         uint32 indices;
  458.         uint32 vertices;
  459.         int32  matId;
  460. };
  461.  
  462. struct SMMRMProjectile
  463. {
  464.         Vec3  pos[2];
  465.         Vec3  dir;
  466.         float r;
  467. };
  468.  
  469. struct SMMRMPhysConfig
  470. {
  471.         float kH;
  472.         float fDamping;
  473.         float variance;
  474.         float airResistance;
  475.         float airFrequency;
  476.         float airModulation;
  477.         int   max_iter;
  478.  
  479.         SMMRMPhysConfig()
  480.                 : kH(0.5f)
  481.                 , fDamping(1.f)
  482.                 , variance(0.1f)
  483.                 , airResistance(1.f)
  484.                 , airFrequency(0.f)
  485.                 , airModulation(0.f)
  486.                 , max_iter(3)
  487.         {}
  488.  
  489.         void Update(const StatInstGroup* srcGroup, const float dampModifier = 1.f)
  490.         {
  491.                 kH = srcGroup->fStiffness;
  492.                 fDamping = srcGroup->fDamping * dampModifier;
  493.                 variance = srcGroup->fVariance;
  494.                 airResistance = srcGroup->fAirResistance;
  495.         }
  496.  
  497.         void Update(const SMMRMGeometry* geom)
  498.         {
  499.                 if (NULL == geom->srcObj)
  500.                 {
  501.                         return;
  502.                 }
  503.                 const char* szprops = geom->srcObj->GetProperties(), * pval = NULL;
  504.                 if (!szprops)
  505.                         return;
  506.                 if (pval = strstr(szprops, "mergedmesh_deform_stiffness"))
  507.                 {
  508.                         for (pval += strlen("mergedmesh_deform_stiffness"); * pval && !isdigit((unsigned char)*pval); pval++);
  509.                         if (pval)
  510.                                 kH = (float)atof(pval);
  511.                 }
  512.                 if (pval = strstr(szprops, "mergedmesh_deform_damping"))
  513.                 {
  514.                         for (pval += strlen("mergedmesh_deform_damping"); * pval && !isdigit((unsigned char)*pval); pval++);
  515.                         if (pval)
  516.                                 fDamping = (float)atof(pval);
  517.                 }
  518.                 if (pval = strstr(szprops, "mergedmesh_deform_variance"))
  519.                 {
  520.                         for (pval += strlen("mergedmesh_deform_variance"); * pval && !isdigit((unsigned char)*pval); pval++);
  521.                         if (pval)
  522.                                 variance = (float)atof(pval);
  523.                 }
  524.                 if (pval = strstr(szprops, "mergedmesh_deform_air_resistance"))
  525.                 {
  526.                         for (pval += strlen("mergedmesh_deform_air_resistance"); * pval && !isdigit((unsigned char)*pval); pval++);
  527.                         if (pval)
  528.                                 airResistance = (float)atof(pval);
  529.                 }
  530.                 if (pval = strstr(szprops, "mergedmesh_deform_air_frequency"))
  531.                 {
  532.                         for (pval += strlen("mergedmesh_deform_air_frequency"); * pval && !isdigit((unsigned char)*pval); pval++);
  533.                         if (pval)
  534.                                 airFrequency = (float)atof(pval);
  535.                 }
  536.                 if (pval = strstr(szprops, "mergedmesh_deform_air_modulation"))
  537.                 {
  538.                         for (pval += strlen("mergedmesh_deform_air_modulation"); * pval && !isdigit((unsigned char)*pval); pval++);
  539.                         if (pval)
  540.                                 airModulation = (float)atof(pval);
  541.                 }
  542.                 if (pval = strstr(szprops, "mergedmesh_deform_max_iter"))
  543.                 {
  544.                         for (pval += strlen("mergedmesh_deform_max_iter"); * pval && !isdigit((unsigned char)*pval); pval++);
  545.                         if (pval)
  546.                                 max_iter = atoi(pval);
  547.                         max_iter = min(max(max_iter, 1), 12);
  548.                 }
  549.         }
  550. };
  551.  
  552. struct CRY_ALIGN(128) SMMRMGroupHeader
  553. {
  554.         SMMRMInstance* instances;
  555.         SMMRMSpineVtxBase* spines;
  556.         SMMRMDeformVertex* deform_vertices;
  557.         SMMRMGeometry* procGeom;
  558.         SMMRMVisibleChunk* visibleChunks;
  559.         CMergedMeshInstanceProxy** proxies;
  560.         SMMRMPhysConfig physConfig;
  561.         uint32 instGroupId;
  562.         uint32 numSamples;
  563.         uint32 numSamplesAlloc;
  564.         uint32 numSamplesVisible;
  565.         uint32 numVisbleChunks;
  566.         float maxViewDistance;
  567.         float lodRationNorm;
  568.         bool specMismatch : 1;
  569.         bool splitGroup : 1;
  570.         bool is_dynamic : 1;
  571. #if MMRM_USE_BOUNDS_CHECK
  572.         volatile int debugLock;
  573. #endif
  574.  
  575.         SMMRMGroupHeader()
  576.                 : instances()
  577.                   , spines()
  578.                   , deform_vertices()
  579.                   , procGeom()
  580.                   , visibleChunks()
  581.                   , proxies()
  582.                   , physConfig()
  583.                   , instGroupId()
  584.                   , numSamples()
  585.                   , numSamplesAlloc()
  586.                   , numSamplesVisible()
  587.                   , numVisbleChunks()
  588.                   , maxViewDistance()
  589.                   , lodRationNorm()
  590.                   , specMismatch()
  591.                   , splitGroup()
  592.                   , is_dynamic(false)
  593. #if MMRM_USE_BOUNDS_CHECK
  594.                   , debugLock()
  595. #endif
  596.         {
  597.         }
  598.         ~SMMRMGroupHeader();
  599.  
  600.         void CullInstances(CCamera * cam, Vec3 * origin, Vec3 * rotationOrigin, float zRotation, int flags);
  601.  
  602. };
  603.  
  604. struct CRY_ALIGN(16) SMergedRMChunk
  605. {
  606.         uint32 ioff;
  607.         uint32 voff;
  608.         uint32 icnt;
  609.         uint32 vcnt;
  610.         uint32 matId;
  611.  
  612.         SMergedRMChunk()
  613.                 : ioff()
  614.                   , voff()
  615.                   , icnt()
  616.                   , vcnt()
  617.                   , matId()
  618.         {
  619.         }
  620.         ~SMergedRMChunk()
  621.         {
  622.                 new(this)SMergedRMChunk;
  623.         };
  624. };
  625.  
  626. struct SMMRMUpdateContext
  627. {
  628.         SMMRMGroupHeader*           group;
  629.         std::vector<SMergedRMChunk> chunks;
  630.         SVF_P3S_C4B_T2S*            general;
  631.         SPipTangents*               tangents;
  632.         Vec3f16*                    normals;
  633.         vtx_idx*                    idxBuf;
  634.         volatile int*               updateFlag;
  635.         primitives::sphere*         colliders;
  636.         int                         ncolliders;
  637.         SMMRMProjectile*            projectiles;
  638.         int                         nprojectiles;
  639.         int                         max_iter;
  640.         float                       dt, dtscale, abstime;
  641.         float                       zRotation;
  642.         Vec3                        rotationOrigin;
  643.         Vec3                        _max, _min;
  644.         Vec3*                       wind;
  645.         int                         use_spines;
  646.         int                         frame_count;
  647. #if MMRM_USE_BOUNDS_CHECK
  648.         SVF_P3S_C4B_T2S*            general_end;
  649.         SPipTangents*               tangents_end;
  650.         vtx_idx*                    idx_end;
  651. #endif
  652.  
  653.         SMMRMUpdateContext()
  654.                 : group()
  655.                 , chunks()
  656.                 , general()
  657.                 , tangents()
  658.                 , normals()
  659.                 , idxBuf()
  660.                 , updateFlag()
  661.                 , colliders()
  662.                 , ncolliders()
  663.                 , projectiles()
  664.                 , nprojectiles()
  665.                 , max_iter()
  666.                 , dt()
  667.                 , dtscale(1.f)
  668.                 , abstime()
  669.                 , zRotation()
  670.                 , rotationOrigin()
  671.                 , _max()
  672.                 , _min()
  673.                 , wind()
  674.                 , use_spines(1)
  675.                 , frame_count()
  676. #if MMRM_USE_BOUNDS_CHECK
  677.                 , general_end()
  678.                 , tangents_end()
  679.                 , idx_end()
  680. #endif
  681.         {}
  682.         ~SMMRMUpdateContext()
  683.         {
  684.         }
  685.  
  686.         void MergeInstanceMeshesSpines(CCamera*, int);
  687.         void MergeInstanceMeshesDeform(CCamera*, int);
  688. };
  689.  
  690. struct SMMRM
  691. {
  692.         std::vector<_smart_ptr<IRenderMesh>> rms;
  693.         IMaterial*                           mat;
  694.         uint32                               vertices;
  695.         uint32                               indices;
  696.         uint32                               chunks;
  697.         std::vector<SMMRMUpdateContext>      updates;
  698.         bool hasNormals   : 1;
  699.         bool hasTangents  : 1;
  700.         bool hasQTangents : 1;
  701.  
  702.         SMMRM()
  703.                 : rms()
  704.                 , mat()
  705.                 , chunks()
  706.                 , hasNormals()
  707.                 , hasTangents()
  708.                 , hasQTangents()
  709.         {}
  710. };
  711.  
  712. inline void CompressQuat(const Quat& q, SMMRMInstance& i)
  713. {
  714.         float qx(q.v.x * (1 << 7)), qy(q.v.y * (1 << 7)), qz(q.v.z * (1 << 7)), qw(q.w * (1 << 7));
  715.         i.qx = static_cast<int>(qx);
  716.         i.qy = static_cast<int>(qy);
  717.         i.qz = static_cast<int>(qz);
  718.         i.qw = static_cast<int>(qw);
  719. }
  720.  
  721. inline void DecompressQuat(Quat& q, const SMMRMInstance& i)
  722. {
  723.         int qx(i.qx), qy(i.qy), qz(i.qz), qw(i.qw);
  724.         q.v.x = qx / (float)(1 << 7);
  725.         q.v.y = qy / (float)(1 << 7);
  726.         q.v.z = qz / (float)(1 << 7);
  727.         q.w = qw / (float)(1 << 7);
  728.         q.Normalize();
  729. }
  730.  
  731. inline void ConvertInstanceAbsolute(Vec3& abs, const uint16 (&pos)[3], const Vec3& origin, const Vec3& rotationOrigin, float zRotation, const float fExtents)
  732. {
  733.         int ax(pos[0]), ay(pos[1]), az(pos[2]);
  734.         abs.x = origin.x + (ax / (float)0xffffu) * fExtents;
  735.         abs.y = origin.y + (ay / (float)0xffffu) * fExtents;
  736.         abs.z = origin.z + (az / (float)0xffffu) * fExtents;
  737.  
  738.         if (zRotation != 0.0f)
  739.         {
  740.                 // Change the position to be relative to the rotation origin
  741.                 abs -= rotationOrigin;
  742.  
  743.                 // Apply the rotation and translate it back out to its world space position
  744.                 Matrix34 mat;
  745.                 mat.SetRotationZ(zRotation, rotationOrigin);
  746.                 abs = mat * abs;
  747.         }
  748. }
  749.  
  750. inline Vec3 ConvertInstanceAbsolute(const uint16 (&pos)[3], const Vec3& origin, const Vec3& rotationOrigin, float zRotation, const float fExtents)
  751. {
  752.         Vec3 abs;
  753.         ConvertInstanceAbsolute(abs, pos, origin, rotationOrigin, zRotation, fExtents);
  754.         return abs;
  755. }
  756.  
  757. inline void ConvertInstanceAbsolute(Vec3& abs, const SMMRMInstance& i, const Vec3& origin, const Vec3& rotationOrigin, float zRotation, const float fExtents)
  758. {
  759.         int ax(i.pos_x), ay(i.pos_y), az(i.pos_z);
  760.         abs.x = origin.x + (ax / (float)0xffffu) * fExtents;
  761.         abs.y = origin.y + (ay / (float)0xffffu) * fExtents;
  762.         abs.z = origin.z + (az / (float)0xffffu) * fExtents;
  763.  
  764.         if (zRotation != 0.0f)
  765.         {
  766.                 // Change the position to be relative to the rotation origin
  767.                 abs -= rotationOrigin;
  768.  
  769.                 // Apply the rotation and translate it back out to its world space position
  770.                 Matrix34 mat;
  771.                 mat.SetRotationZ(zRotation, rotationOrigin);
  772.                 abs = mat * abs;
  773.         }
  774. }
  775.  
  776. inline Vec3 ConvertInstanceAbsolute(const SMMRMInstance& i, const Vec3& origin, const Vec3& rotationOrigin, float zRotation, const float fExtents)
  777. {
  778.         Vec3 abs;
  779.         ConvertInstanceAbsolute(abs, i, origin, rotationOrigin, zRotation, fExtents);
  780.         return abs;
  781. }
  782.  
  783. inline void ConvertInstanceRelative(SMMRMInstance& i, const Vec3& abs, const Vec3& origin, const float fExtentsRec)
  784. {
  785.         i.pos_x = (uint16)((abs.x - origin.x) * fExtentsRec * (float)0xffffu);
  786.         i.pos_y = (uint16)((abs.y - origin.y) * fExtentsRec * (float)0xffffu);
  787.         i.pos_z = (uint16)((abs.z - origin.z) * fExtentsRec * (float)0xffffu);
  788. }
  789.  
  790. inline void DecompressInstance(const SMMRMInstance& i, const Vec3& origin, const Vec3& rotationOrigin, float zRotation, const float Extents, Vec3& pos)
  791. {
  792.         ConvertInstanceAbsolute(pos, i, origin, rotationOrigin, zRotation, Extents);
  793. }
  794.  
  795. inline void DecompressInstance(const SMMRMInstance& i, const Vec3& origin, const Vec3& rotationOrigin, float zRotation, const float Extents, Vec3& pos, Quat& rot)
  796. {
  797.         ConvertInstanceAbsolute(pos, i, origin, rotationOrigin, zRotation, Extents);
  798.         DecompressQuat(rot, i);
  799. }
  800.  
  801. inline void DecompressInstance(const SMMRMInstance& i, const Vec3& origin, const Vec3& rotationOrigin, float zRotation, const float Extents, Vec3& pos, float& scale)
  802. {
  803.         int iscale(i.scale);
  804.         ConvertInstanceAbsolute(pos, i, origin, rotationOrigin, zRotation, Extents);
  805.         scale = (1.f / VEGETATION_CONV_FACTOR) * iscale;
  806. }
  807.  
  808. inline void DecompressInstance(const SMMRMInstance& i, const aVec3& origin, const Vec3& rotationOrigin, float zRotation, const float Extents, aVec3& pos, aQuat& rot, float& scale)
  809. {
  810. #if 0 && MMRM_USE_VECTORIZED_SSE_INSTRUCTIONS
  811.         __m128 vorigin = _mm_loadu_ps(&origin.x);
  812.         __m128i instance = _mm_load_si128((const __m128i*)&i);
  813.         __m128i ipos = _mm_shuffle_epi8(instance, _mm_set_epi32(0xffffffff, 0xffff0504, 0xffff0302, 0xffff0100));
  814.         __m128 pcvt = _mm_set1_ps(Extents / (float)0xffff);
  815.         __m128 rcvt = _mm_set1_ps(1.f / (float)(1 << 7));
  816.         __m128 cpos = _mm_add_ps(_mm_shuffle_ps(vorigin, vorigin, _MM_SHUFFLE(2, 2, 1, 0)), _mm_mul_ps(pcvt, _mm_cvtepi32_ps(ipos)));
  817.         __m128i irot = _mm_shuffle_epi8(instance, _mm_set_epi32(0x09ffffff, 0x08ffffff, 0x07ffffff, 0x06ffffff));
  818.         __m128 crot = _mm_mul_ps(rcvt, _mm_cvtepi32_ps(_mm_srai_epi32(irot, 24)));
  819.         __m128 len = _mm_rsqrt_ps(_mm_dp_ps(crot, crot, 0xff));
  820.         __m128 cnrot = _mm_mul_ps(crot, len);
  821.  
  822.         _mm_store_ps(&pos.x, cpos);
  823.         _mm_store_ps(&rot.v.x, cnrot);
  824.  
  825.         scale = (1.f / VEGETATION_CONV_FACTOR) * i.scale;
  826. #else
  827.         int iscale(i.scale);
  828.         ConvertInstanceAbsolute(pos, i, origin, rotationOrigin, zRotation, Extents);
  829.         DecompressQuat(rot, i);
  830.         scale = (1.f / VEGETATION_CONV_FACTOR) * iscale;
  831. #endif
  832. }
  833.  
  834. inline Matrix34 CreateRotationQ(const Quat& q, const Vec3& t)
  835. {
  836.         Matrix34 r = Matrix34(q);
  837.         r.SetTranslation(t);
  838.         return r;
  839. }
  840.  
  841. extern Vec3        SampleWind(const Vec3& pos, const Vec3 (&samples)[MMRM_WIND_DIM][MMRM_WIND_DIM][MMRM_WIND_DIM]);
  842. extern inline Vec3 SampleWind(const Vec3& pos, const Vec3* samples);
  843. #endif
  844.  
downloadMergedMeshGeometry.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