BVB Source Codes

CRYENGINE Show Decal.cpp Source code

Return Download CRYENGINE: download Decal.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   decals.cpp
  5. //  Version:     v1.00
  6. //  Created:     28/5/2001 by Vladimir Kajalin
  7. //  Compilers:   Visual Studio.NET
  8. //  Description: draw, create decals on the world
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15.  
  16. #include "DecalManager.h"
  17. #include "3dEngine.h"
  18. #include "ObjMan.h"
  19. #include "Vegetation.h"
  20. #include "terrain.h"
  21.  
  22. IGeometry* CDecal::s_pSphere = 0;
  23.  
  24. void CDecal::ResetStaticData()
  25. {
  26.         SAFE_RELEASE(s_pSphere);
  27. }
  28.  
  29. int CDecal::Update(bool& active, const float fFrameTime)
  30. {
  31.         // process life time and disable decal when needed
  32.         m_fLifeTime -= fFrameTime;
  33.  
  34.         if (m_fLifeTime < 0)
  35.         {
  36.                 active = 0;
  37.                 FreeRenderData();
  38.         }
  39.         else if (m_ownerInfo.pRenderNode && m_ownerInfo.pRenderNode->m_nInternalFlags & IRenderNode::UPDATE_DECALS)
  40.         {
  41.                 active = false;
  42.                 return 1;
  43.         }
  44.         return 0;
  45. }
  46.  
  47. Vec3 CDecal::GetWorldPosition()
  48. {
  49.         Vec3 vPos = m_vPos;
  50.  
  51.         if (m_ownerInfo.pRenderNode)
  52.         {
  53.                 if (m_eDecalType == eDecalType_OS_SimpleQuad || m_eDecalType == eDecalType_OS_OwnersVerticesUsed)
  54.                 {
  55.                         assert(m_ownerInfo.pRenderNode);
  56.                         if (m_ownerInfo.pRenderNode)
  57.                         {
  58.                                 Matrix34A objMat;
  59.                                 if (IStatObj* pEntObject = m_ownerInfo.GetOwner(objMat))
  60.                                         vPos = objMat.TransformPoint(vPos);
  61.                         }
  62.                 }
  63.         }
  64.  
  65.         return vPos;
  66. }
  67.  
  68. void CDecal::Render(const float fCurTime, int nAfterWater, float fDistanceFading, float fDistance, const SRenderingPassInfo& passInfo)
  69. {
  70.         FUNCTION_PROFILER_3DENGINE;
  71.  
  72.         if (!m_pMaterial || !m_pMaterial->GetShaderItem().m_pShader || m_pMaterial->GetShaderItem().m_pShader->GetShaderType() != eST_General)
  73.                 return; // shader not supported for decals
  74.  
  75.         // Get decal alpha from life time
  76.         float fAlpha = m_fLifeTime * 2;
  77.  
  78.         if (fAlpha > 1.f)
  79.                 fAlpha = 1.f;
  80.         else if (fAlpha < 0)
  81.                 return;
  82.  
  83.         fAlpha *= fDistanceFading;
  84.  
  85.         float fSizeK;
  86.         if (m_fGrowTime)
  87.                 fSizeK = min(1.f, sqrt_tpl((fCurTime - m_fLifeBeginTime) / m_fGrowTime));
  88.         else
  89.                 fSizeK = 1.f;
  90.  
  91.         float fSizeAlphaK;
  92.         if (m_fGrowTimeAlpha)
  93.                 fSizeAlphaK = min(1.f, sqrt_tpl((fCurTime - m_fLifeBeginTime) / m_fGrowTimeAlpha));
  94.         else
  95.                 fSizeAlphaK = 1.f;
  96.  
  97.         if (m_bDeferred)
  98.         {
  99.                 SDeferredDecal newItem;
  100.                 newItem.fAlpha = fAlpha;
  101.                 newItem.pMaterial = m_pMaterial;
  102.                 newItem.nSortOrder = m_sortPrio;
  103.                 newItem.nFlags = 0;
  104.  
  105.                 Vec3 vRight, vUp, vNorm;
  106.                 Matrix34A objMat;
  107.  
  108.                 if (IStatObj* pEntObject = m_ownerInfo.GetOwner(objMat))
  109.                 {
  110.                         vRight = objMat.TransformVector(m_vRight * m_fSize);
  111.                         vUp = objMat.TransformVector(m_vUp * m_fSize);
  112.                         vNorm = objMat.TransformVector((Vec3(m_vRight).Cross(m_vUp)) * m_fSize);
  113.                 }
  114.                 else
  115.                 {
  116.                         vRight = (m_vRight * m_fSize);
  117.                         vUp = (m_vUp * m_fSize);
  118.                         vNorm = ((Vec3(m_vRight).Cross(m_vUp)) * m_fSize);
  119.                 }
  120.  
  121.                 Matrix33 matRotation;
  122.                 matRotation.SetColumn(0, vRight);
  123.                 matRotation.SetColumn(1, vUp);
  124.                 matRotation.SetColumn(2, vNorm * GetFloatCVar(e_DecalsDeferredDynamicDepthScale));
  125.                 newItem.projMatrix.SetRotation33(matRotation);
  126.                 newItem.projMatrix.SetTranslation(m_vWSPos + vNorm * .1f * m_fWSSize);
  127.  
  128.                 if (m_fGrowTimeAlpha)
  129.                         newItem.fGrowAlphaRef = max(.02f, 1.f - fSizeAlphaK);
  130.                 else
  131.                         newItem.fGrowAlphaRef = 0;
  132.  
  133.                 GetRenderer()->EF_AddDeferredDecal(newItem, passInfo);
  134.                 return;
  135.         }
  136.  
  137.         switch (m_eDecalType)
  138.         {
  139.         case eDecalType_WS_Merged:
  140.         case eDecalType_OS_OwnersVerticesUsed:
  141.                 {
  142.                         // check if owner mesh was deleted
  143.                         if (m_pRenderMesh && (m_pRenderMesh->GetVertexContainer() == m_pRenderMesh) && m_pRenderMesh->GetVerticesCount() < 3)
  144.                                 FreeRenderData();
  145.  
  146.                         if (!m_pRenderMesh)
  147.                                 break;
  148.  
  149.                         // setup transformation
  150.                         CRenderObject* pObj = GetRenderer()->EF_GetObject_Temp(passInfo.ThreadID());
  151.                         if (!pObj)
  152.                                 return;
  153.                         pObj->m_fSort = 0;
  154.                         pObj->m_RState = 0;
  155.  
  156.                         Matrix34A objMat;
  157.                         if (m_ownerInfo.pRenderNode && !m_ownerInfo.GetOwner(objMat))
  158.                         {
  159.                                 assert(0);
  160.                                 return;
  161.                         }
  162.                         else if (!m_ownerInfo.pRenderNode)
  163.                         {
  164.                                 objMat.SetIdentity();
  165.                                 if (m_eDecalType == eDecalType_WS_Merged)
  166.                                 {
  167.                                         objMat.SetTranslation(m_vPos);
  168.                                         pObj->m_ObjFlags |= FOB_TRANS_MASK;
  169.                                 }
  170.                         }
  171.  
  172.                         pObj->m_II.m_Matrix = objMat;
  173.                         if (m_ownerInfo.pRenderNode)
  174.                                 pObj->m_ObjFlags |= FOB_TRANS_MASK;
  175.  
  176.                         pObj->m_nSort = m_sortPrio;
  177.  
  178.                         // somehow it's need's to be twice bigger to be same as simple decals
  179.                         float fSize2 = m_fSize * fSizeK * 2.f;///m_ownerInfo.pRenderNode->GetScale();
  180.                         if (fSize2 < 0.0001f)
  181.                                 return;
  182.  
  183.                         // setup texgen
  184.                         // S component
  185.                         float correctScale(-1);
  186.                         m_arrBigDecalRMCustomData[0] = correctScale * m_vUp.x / fSize2;
  187.                         m_arrBigDecalRMCustomData[1] = correctScale * m_vUp.y / fSize2;
  188.                         m_arrBigDecalRMCustomData[2] = correctScale * m_vUp.z / fSize2;
  189.  
  190.                         Vec3 vPosDecS = m_vPos;
  191.                         if (m_eDecalType == eDecalType_WS_Merged)
  192.                                 vPosDecS.zero();
  193.  
  194.                         float D0 =
  195.                           m_arrBigDecalRMCustomData[0] * vPosDecS.x +
  196.                           m_arrBigDecalRMCustomData[1] * vPosDecS.y +
  197.                           m_arrBigDecalRMCustomData[2] * vPosDecS.z;
  198.  
  199.                         m_arrBigDecalRMCustomData[3] = -D0 + 0.5f;
  200.  
  201.                         // T component
  202.                         m_arrBigDecalRMCustomData[4] = m_vRight.x / fSize2;
  203.                         m_arrBigDecalRMCustomData[5] = m_vRight.y / fSize2;
  204.                         m_arrBigDecalRMCustomData[6] = m_vRight.z / fSize2;
  205.  
  206.                         float D1 =
  207.                           m_arrBigDecalRMCustomData[4] * vPosDecS.x +
  208.                           m_arrBigDecalRMCustomData[5] * vPosDecS.y +
  209.                           m_arrBigDecalRMCustomData[6] * vPosDecS.z;
  210.  
  211.                         m_arrBigDecalRMCustomData[7] = -D1 + 0.5f;
  212.  
  213.                         // pass attenuation info
  214.                         m_arrBigDecalRMCustomData[8] = vPosDecS.x;
  215.                         m_arrBigDecalRMCustomData[9] = vPosDecS.y;
  216.                         m_arrBigDecalRMCustomData[10] = vPosDecS.z;
  217.                         m_arrBigDecalRMCustomData[11] = m_fSize;
  218.  
  219.                         // N component
  220.                         Vec3 vNormal(Vec3(correctScale * m_vUp).Cross(m_vRight).GetNormalized());
  221.                         m_arrBigDecalRMCustomData[12] = vNormal.x * (m_fSize / m_fWSSize);
  222.                         m_arrBigDecalRMCustomData[13] = vNormal.y * (m_fSize / m_fWSSize);
  223.                         m_arrBigDecalRMCustomData[14] = vNormal.z * (m_fSize / m_fWSSize);
  224.                         m_arrBigDecalRMCustomData[15] = 0;
  225.  
  226.                         CStatObj* pBody = NULL;
  227.                         bool bUseBending = GetCVars()->e_VegetationBending != 0;
  228.                         if (m_ownerInfo.pRenderNode && m_ownerInfo.pRenderNode->GetRenderNodeType() == eERType_Vegetation)
  229.                         {
  230.                                 CObjManager* pObjManager = GetObjManager();
  231.                                 CVegetation* pVegetation = (CVegetation*)m_ownerInfo.pRenderNode;
  232.                                 pBody = pVegetation->GetStatObj();
  233.                                 assert(pObjManager && pVegetation && pBody);
  234.  
  235.                                 if (pVegetation && pBody && bUseBending)
  236.                                 {
  237.                                         pVegetation->FillBendingData(pObj);
  238.                                 }
  239.                                 IMaterial* pMat = m_ownerInfo.pRenderNode->GetMaterial();
  240.                                 pMat = pMat->GetSubMtl(m_ownerInfo.nMatID);
  241.                                 if (pMat)
  242.                                 {
  243.                                         // Support for public parameters from owner (deformations)
  244.                                         SShaderItem& SH = pMat->GetShaderItem();
  245.                                         if (SH.m_pShaderResources)
  246.                                         {
  247.                                                 IMaterial* pMatDecal = m_pMaterial;
  248.                                                 SShaderItem& SHDecal = pMatDecal->GetShaderItem();
  249.                                                 if (bUseBending)
  250.                                                 {
  251.                                                         pObj->m_nMDV = SH.m_pShader->GetVertexModificator();
  252.                                                         //if (SHDecal.m_pShaderResources && pObj->m_nMDV)
  253.                                                         //SH.m_pShaderResources->ExportModificators(SHDecal.m_pShaderResources, pObj);
  254.                                                 }
  255.                                         }
  256.                                 }
  257.                                 if (m_eDecalType == eDecalType_OS_OwnersVerticesUsed)
  258.                                         pObj->m_ObjFlags |= FOB_OWNER_GEOMETRY;
  259.                                 IFoliage* pFol = pVegetation->GetFoliage();
  260.                                 if (pFol)
  261.                                 {
  262.                                         SRenderObjData* pOD = pObj->GetObjData();
  263.                                         if (pOD)
  264.                                         {
  265.                                                 pOD->m_pSkinningData = pFol->GetSkinningData(pObj->m_II.m_Matrix, passInfo);
  266.                                         }
  267.                                 }
  268.                                 if (pBody && pBody->m_pRenderMesh)
  269.                                 {
  270.                                         m_pRenderMesh->SetVertexContainer(pBody->m_pRenderMesh);
  271.                                 }
  272.                         }
  273.  
  274.                         // draw complex decal using new indices and original object vertices
  275.                         pObj->m_fAlpha = fAlpha;
  276.                         pObj->m_ObjFlags |= FOB_DECAL | FOB_DECAL_TEXGEN_2D | FOB_INSHADOW;
  277.                         pObj->m_II.m_AmbColor = m_vAmbient;
  278.                         if (GetCVars()->e_DecalsScissor)
  279.                         {
  280.                                 Matrix44 view;
  281.                                 GetRenderer()->GetModelViewMatrix(view.GetData());
  282.  
  283.                                 Matrix44 proj;
  284.                                 GetRenderer()->GetProjectionMatrix(proj.GetData());
  285.  
  286.                                 Vec4 viewspacePos = Vec4(m_vWSPos, 1) * view;
  287.                                 //if (fabsf(viewspacePos.z) >= 1e-4f && fabsf(proj.m23) == 1)
  288.                                 if (viewspacePos.z < -1e-4f)
  289.                                 {
  290.                                         int width = GetRenderer()->GetWidth();
  291.                                         int height = GetRenderer()->GetHeight();
  292.  
  293.                                         float corner1x = viewspacePos.x - 1.5f * m_fWSSize;
  294.                                         float corner1y = viewspacePos.y + 1.5f * m_fWSSize;
  295.                                         float corner2x = viewspacePos.x + 1.5f * m_fWSSize;
  296.                                         float corner2y = viewspacePos.y - 1.5f * m_fWSSize;
  297.  
  298.                                         float w = 0.5f / viewspacePos.z * proj.m23;
  299.                                         float scissorMinX = (corner1x * proj.m00) * w;
  300.                                         float scissorMinY = -(corner1y * proj.m11) * w;
  301.                                         float scissorMaxX = (corner2x * proj.m00) * w;
  302.                                         float scissorMaxY = -(corner2y * proj.m11) * w;
  303.  
  304.                                         uint16 scissorX1 = max(min((int)(width * (scissorMinX + 0.5f)), width), 0);
  305.                                         uint16 scissorY1 = max(min((int)(height * (scissorMinY + 0.5f)), height), 0);
  306.                                         uint16 scissorX2 = max(min((int)(width * (scissorMaxX + 0.5f)), width), 0);
  307.                                         uint16 scissorY2 = max(min((int)(height * (scissorMaxY + 0.5f)), height), 0);
  308.  
  309.                                         if (scissorX1 < scissorX2 && scissorY1 < scissorY2)
  310.                                         {
  311.                                                 SRenderObjData* pOD = pObj->GetObjData();
  312.                                                 pOD->m_scissorX = scissorX1;
  313.                                                 pOD->m_scissorY = scissorY1;
  314.                                                 pOD->m_scissorWidth = scissorX2 - scissorX1;
  315.                                                 pOD->m_scissorHeight = scissorY2 - scissorY1;
  316.                                         }
  317.                                 }
  318.                         }
  319.                         m_pRenderMesh->SetREUserData(m_arrBigDecalRMCustomData, 0, fAlpha);
  320.                         m_pRenderMesh->AddRenderElements(m_pMaterial, pObj, passInfo, EFSLIST_GENERAL, nAfterWater);
  321.                 }
  322.                 break;
  323.  
  324.         case eDecalType_OS_SimpleQuad:
  325.                 {
  326.                         assert(m_ownerInfo.pRenderNode);
  327.                         if (!m_ownerInfo.pRenderNode)
  328.                                 break;
  329.  
  330.                         // transform decal in software from owner space into world space and render as quad
  331.                         Matrix34A objMat;
  332.                         IStatObj* pEntObject = m_ownerInfo.GetOwner(objMat);
  333.                         if (!pEntObject)
  334.                                 break;
  335.  
  336.                         Vec3 vPos = objMat.TransformPoint(m_vPos);
  337.                         Vec3 vRight = objMat.TransformVector(m_vRight * m_fSize);
  338.                         Vec3 vUp = objMat.TransformVector(m_vUp * m_fSize);
  339.                         UCol uCol;
  340.  
  341.                         uCol.dcolor = 0xffffffff;
  342.                         uCol.bcolor[3] = fastround_positive(fAlpha * 255);
  343.  
  344.                         AddDecalToRenderView(fDistance, m_pMaterial, m_sortPrio, vRight * fSizeK, vUp * fSizeK, uCol,
  345.                                              OS_ALPHA_BLEND, m_vAmbient, vPos, nAfterWater,
  346.                                              m_ownerInfo.pRenderNode->GetRenderNodeType() == eERType_Vegetation ? (CVegetation*) m_ownerInfo.pRenderNode : nullptr, passInfo);
  347.                 }
  348.                 break;
  349.  
  350.         case eDecalType_WS_SimpleQuad:
  351.                 {
  352.                         // draw small world space decal untransformed
  353.                         UCol uCol;
  354.                         uCol.dcolor = 0;
  355.                         uCol.bcolor[3] = fastround_positive(fAlpha * 255);
  356.                         AddDecalToRenderView(fDistance, m_pMaterial, m_sortPrio, m_vRight * m_fSize * fSizeK,
  357.                                              m_vUp * m_fSize * fSizeK, uCol, OS_ALPHA_BLEND, m_vAmbient, m_vPos, nAfterWater, nullptr, passInfo);
  358.                 }
  359.                 break;
  360.  
  361.         case eDecalType_WS_OnTheGround:
  362.                 {
  363.                         RenderBigDecalOnTerrain(fAlpha, fSizeK, passInfo);
  364.                 }
  365.                 break;
  366.         }
  367. }
  368.  
  369. void CDecal::FreeRenderData()
  370. {
  371.         // delete render mesh
  372.         m_pRenderMesh = NULL;
  373.  
  374.         m_ownerInfo.pRenderNode = 0;
  375. }
  376.  
  377. void CDecal::RenderBigDecalOnTerrain(float fAlpha, float fScale, const SRenderingPassInfo& passInfo)
  378. {
  379.         float fRadius = m_fSize * fScale;
  380.  
  381.         // check terrain bounds
  382.         if (m_vPos.x < -fRadius || m_vPos.y < -fRadius)
  383.                 return;
  384.         if (m_vPos.x >= CTerrain::GetTerrainSize() + fRadius || m_vPos.y >= CTerrain::GetTerrainSize() + fRadius)
  385.                 return;
  386.  
  387.         const int nUsintSize = CTerrain::GetHeightMapUnitSize();
  388.         fRadius += nUsintSize;
  389.  
  390.         if (fabs(m_vPos.z - Get3DEngine()->GetTerrainZ(int(m_vPos.x), int(m_vPos.y))) > fRadius)
  391.                 return; // too far from ground surface
  392.  
  393.         // setup texgen
  394.         float fSize2 = m_fSize * fScale * 2.f;
  395.         if (fSize2 < 0.05f)
  396.                 return;
  397.  
  398.         // S component
  399.         float correctScale(-1);
  400.         m_arrBigDecalRMCustomData[0] = correctScale * m_vUp.x / fSize2;
  401.         m_arrBigDecalRMCustomData[1] = correctScale * m_vUp.y / fSize2;
  402.         m_arrBigDecalRMCustomData[2] = correctScale * m_vUp.z / fSize2;
  403.  
  404.         float D0 = 0;
  405.  
  406.         m_arrBigDecalRMCustomData[3] = -D0 + 0.5f;
  407.  
  408.         // T component
  409.         m_arrBigDecalRMCustomData[4] = m_vRight.x / fSize2;
  410.         m_arrBigDecalRMCustomData[5] = m_vRight.y / fSize2;
  411.         m_arrBigDecalRMCustomData[6] = m_vRight.z / fSize2;
  412.  
  413.         float D1 = 0;
  414.  
  415.         m_arrBigDecalRMCustomData[7] = -D1 + 0.5f;
  416.  
  417.         // pass attenuation info
  418.         m_arrBigDecalRMCustomData[8] = 0;
  419.         m_arrBigDecalRMCustomData[9] = 0;
  420.         m_arrBigDecalRMCustomData[10] = 0;
  421.         m_arrBigDecalRMCustomData[11] = fSize2;
  422.  
  423.         Vec3 vNormal(Vec3(correctScale * m_vUp).Cross(m_vRight).GetNormalized());
  424.         m_arrBigDecalRMCustomData[12] = vNormal.x;
  425.         m_arrBigDecalRMCustomData[13] = vNormal.y;
  426.         m_arrBigDecalRMCustomData[14] = vNormal.z;
  427.         m_arrBigDecalRMCustomData[15] = 0;
  428.  
  429.         CRenderObject* pObj = GetIdentityCRenderObject(passInfo.ThreadID());
  430.         if (!pObj)
  431.                 return;
  432.  
  433.         pObj->m_II.m_Matrix.SetTranslation(m_vPos);
  434.         pObj->m_ObjFlags |= FOB_TRANS_TRANSLATE;
  435.  
  436.         pObj->m_fAlpha = fAlpha;
  437.         pObj->m_ObjFlags |= FOB_DECAL | FOB_DECAL_TEXGEN_2D | FOB_INSHADOW;
  438.         pObj->m_II.m_AmbColor = m_vAmbient;
  439.  
  440.         pObj->m_nSort = m_sortPrio;
  441.  
  442.         Plane planes[4];
  443.         planes[0].SetPlane(m_vRight, m_vRight * m_fSize + m_vPos);
  444.         planes[1].SetPlane(-m_vRight, -m_vRight * m_fSize + m_vPos);
  445.         planes[2].SetPlane(m_vUp, m_vUp * m_fSize + m_vPos);
  446.         planes[3].SetPlane(-m_vUp, -m_vUp * m_fSize + m_vPos);
  447.  
  448.         // m_pRenderMesh might get updated by the following function
  449.         GetTerrain()->RenderArea(m_vPos, fRadius, m_pRenderMesh,
  450.                                  pObj, m_pMaterial, "BigDecalOnTerrain", m_arrBigDecalRMCustomData, GetCVars()->e_DecalsClip ? planes : NULL, passInfo);
  451. }
  452.  
  453. //////////////////////////////////////////////////////////////////////////
  454. void CDecal::AddDecalToRenderView(float fDistance,
  455.                                   IMaterial* pMaterial,
  456.                                   const uint8 sortPrio,
  457.                                   Vec3 right,
  458.                                   Vec3 up,
  459.                                   const UCol& ucResCol,
  460.                                   const uint8 uBlendType,
  461.                                   const Vec3& vAmbientColor,
  462.                                   Vec3 vPos,
  463.                                   const int nAfterWater,
  464.                                   CVegetation* pVegetation,
  465.                                   const SRenderingPassInfo& passInfo)
  466. {
  467.         FUNCTION_PROFILER_3DENGINE;
  468.         MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "AddDecalToRenderer");
  469.  
  470.         CRenderObject* pRenderObject(GetIdentityCRenderObject(passInfo.ThreadID()));
  471.         if (!pRenderObject)
  472.                 return;
  473.  
  474.         // prepare render object
  475.         pRenderObject->m_fDistance = fDistance;
  476.         pRenderObject->m_fAlpha = (float)ucResCol.bcolor[3] / 255.f;
  477.         pRenderObject->m_II.m_AmbColor = vAmbientColor;
  478.         pRenderObject->m_fSort = 0;
  479.         pRenderObject->m_ObjFlags |= FOB_DECAL | FOB_INSHADOW;
  480.         pRenderObject->m_nSort = sortPrio;
  481.  
  482.         bool bBending = pVegetation && pVegetation->IsBending();
  483.  
  484.         if (bBending)
  485.         {
  486.                 // transfer decal into object space
  487.                 Matrix34A objMat;
  488.                 IStatObj* pEntObject = pVegetation->GetEntityStatObj(0, 0, &objMat);
  489.                 pRenderObject->m_II.m_Matrix = objMat;
  490.                 pRenderObject->m_ObjFlags |= FOB_TRANS_MASK;
  491.                 pVegetation->FillBendingData(pRenderObject);
  492.                 assert(pEntObject);
  493.                 if (pEntObject)
  494.                 {
  495.                         objMat.Invert();
  496.                         vPos = objMat.TransformPoint(vPos);
  497.                         right = objMat.TransformVector(right);
  498.                         up = objMat.TransformVector(up);
  499.                 }
  500.         }
  501.  
  502.         SVF_P3F_C4B_T2F pVerts[4];
  503.         uint16 pIndices[6];
  504.  
  505.         // TODO: determine whether this is a decal on opaque or transparent geometry
  506.         // (put it in the respective renderlist for correct shadowing)
  507.         // fill general vertex data
  508.         pVerts[0].xyz = (-right - up) + vPos;
  509.         pVerts[0].st = Vec2(0, 1);
  510.         pVerts[0].color.dcolor = ~0;
  511.  
  512.         pVerts[1].xyz = (right - up) + vPos;
  513.         pVerts[1].st = Vec2(1, 1);
  514.         pVerts[1].color.dcolor = ~0;
  515.  
  516.         pVerts[2].xyz = (right + up) + vPos;
  517.         pVerts[2].st = Vec2(1, 0);
  518.         pVerts[2].color.dcolor = ~0;
  519.  
  520.         pVerts[3].xyz = (-right + up) + vPos;
  521.         pVerts[3].st = Vec2(0, 0);
  522.         pVerts[3].color.dcolor = ~0;
  523.  
  524.         // prepare tangent space (tangent, bitangent) and fill it in
  525.         Vec3 rightUnit(right.GetNormalized());
  526.         Vec3 upUnit(up.GetNormalized());
  527.  
  528.         SPipTangents pTangents[4];
  529.  
  530.         pTangents[0] = SPipTangents(rightUnit, -upUnit, -1);
  531.         pTangents[1] = pTangents[0];
  532.         pTangents[2] = pTangents[0];
  533.         pTangents[3] = pTangents[0];
  534.  
  535.         // fill decals topology (two triangles)
  536.         pIndices[0] = 0;
  537.         pIndices[1] = 1;
  538.         pIndices[2] = 2;
  539.  
  540.         pIndices[3] = 0;
  541.         pIndices[4] = 2;
  542.         pIndices[5] = 3;
  543.  
  544.         SRenderPolygonDescription poly(pRenderObject, pMaterial->GetShaderItem(), 4, pVerts, pTangents, pIndices, 6, EFSLIST_DECAL, nAfterWater);
  545.         passInfo.GetIRenderView()->AddPolygon(poly, passInfo);
  546. }
  547.  
downloadDecal.cpp 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