BVB Source Codes

CRYENGINE Show WrinkleMapRenderProxyCallback.cpp Source code

Return Download CRYENGINE: download WrinkleMapRenderProxyCallback.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4.  
  5. #include "WrinkleMapRenderProxyCallback.h"
  6.  
  7. #include <CryAnimation/ICryAnimation.h>
  8. #include <CryExtension/CryCreateClassInstance.h>
  9.  
  10. //////////////////////////////////////////////////////////////////////////
  11.  
  12. #define WRINKLE_BONE_PREFIX "blend_control"
  13. #define MAX_WRINKLE_BONES   4
  14. #define WRINKLE_PARAM_NAME  "%WRINKLE_BLENDING"
  15. #define WRINKLE_MASK_NAME0  "WrinkleMask0"
  16. #define WRINKLE_MASK_NAME1  "WrinkleMask1"
  17. #define WRINKLE_MASK_NAME2  "WrinkleMask2"
  18.  
  19. //////////////////////////////////////////////////////////////////////////
  20.  
  21. namespace {
  22.  
  23. bool HasWrinkleBlending(IMaterial& material)
  24. {
  25.         IShader* pShader = material.GetShaderItem().m_pShader;
  26.         if (!pShader)
  27.                 return false;
  28.  
  29.         uint64 mask = pShader->GetGenerationMask();
  30.         SShaderGen* pShaderGen = pShader->GetGenerationParams();
  31.         if (!pShaderGen)
  32.                 return false;
  33.  
  34.         for (int i = 0; i < pShaderGen->m_BitMask.size(); ++i)
  35.         {
  36.                 SShaderGenBit* pShaderGenBit = pShaderGen->m_BitMask[i];
  37.                 if (pShaderGenBit->m_ParamName == WRINKLE_PARAM_NAME
  38.                     && (mask & pShaderGenBit->m_Mask) == pShaderGenBit->m_Mask)
  39.                 {
  40.                         return true;
  41.                 }
  42.         }
  43.  
  44.         return false;
  45. }
  46.  
  47. IMaterial* FindFirstMaterialWithWrinkleBlending(IMaterial& material)
  48. {
  49.         if (HasWrinkleBlending(material))
  50.                 return &material;
  51.  
  52.         for (int i = 0; i < material.GetSubMtlCount(); ++i)
  53.         {
  54.                 if (IMaterial* pMaterial = material.GetSubMtl(i))
  55.                 {
  56.                         if (HasWrinkleBlending(*pMaterial))
  57.                                 return pMaterial;
  58.                 }
  59.         }
  60.  
  61.         return NULL;
  62. }
  63.  
  64. IMaterial* FindFirstMaterialWithWrinkleBlending(ICharacterInstance& instance)
  65. {
  66.         if (IMaterial* pMaterial = instance.GetIMaterial())
  67.         {
  68.                 if (pMaterial = FindFirstMaterialWithWrinkleBlending(*pMaterial))
  69.                         return pMaterial;
  70.         }
  71.  
  72.         IAttachmentManager* pAttachmentManager = instance.GetIAttachmentManager();
  73.         if (!pAttachmentManager)
  74.                 return NULL;
  75.  
  76.         uint attachmentCount = pAttachmentManager->GetAttachmentCount();
  77.         for (uint i = 0; i < attachmentCount; ++i)
  78.         {
  79.                 IAttachment* pAttachment = pAttachmentManager->GetInterfaceByIndex(i);
  80.                 if (!pAttachment)
  81.                         continue;
  82.  
  83.                 IAttachmentObject* pAttachmentObject = pAttachment->GetIAttachmentObject();
  84.                 if (!pAttachmentObject)
  85.                         continue;
  86.  
  87.                 IAttachmentSkin* pAttachmentSkin = pAttachmentObject->GetIAttachmentSkin();
  88.                 if (!pAttachmentSkin)
  89.                         continue;
  90.  
  91.                 ISkin* pSkin = pAttachmentSkin->GetISkin();
  92.                 if (!pSkin)
  93.                         continue;
  94.  
  95.                 IMaterial* pMaterial = pSkin->GetIMaterial(0);
  96.                 if (!pMaterial)
  97.                         continue;
  98.  
  99.                 if (pMaterial = FindFirstMaterialWithWrinkleBlending(*pMaterial))
  100.                         return pMaterial;
  101.         }
  102.  
  103.         return NULL;
  104. }
  105.  
  106. } // namespace
  107.  
  108. //////////////////////////////////////////////////////////////////////////
  109.  
  110. CRYREGISTER_CLASS(CWrinkleMapShaderParamCallback)
  111. CRYREGISTER_CLASS(CWrinkleMapShaderParamCallbackUI)
  112.  
  113. //////////////////////////////////////////////////////////////////////////
  114.  
  115. CWrinkleMapShaderParamCallback::CWrinkleMapShaderParamCallback() :
  116.         m_pCachedMaterial(0),
  117.         m_pCharacterInstance(0),
  118.         m_bWrinklesEnabled(false)
  119. {
  120.         m_eSemantic[0] = 0;
  121.         m_eSemantic[1] = 0;
  122.         m_eSemantic[2] = 0;
  123. }
  124.  
  125. CWrinkleMapShaderParamCallback::~CWrinkleMapShaderParamCallback()
  126. {
  127.         m_pCachedMaterial = NULL;
  128.         m_pCharacterInstance = NULL;
  129.         m_bWrinklesEnabled = false;
  130. }
  131.  
  132. //////////////////////////////////////////////////////////////////////////
  133.  
  134. bool CWrinkleMapShaderParamCallback::Init()
  135. {
  136.         if (m_pCharacterInstance == 0)
  137.                 return false;
  138.  
  139.         SetupBoneWrinkleMapInfo();
  140.  
  141.         return true;
  142. }
  143.  
  144. //////////////////////////////////////////////////////////////////////////
  145.  
  146. void CWrinkleMapShaderParamCallback::SetupBoneWrinkleMapInfo()
  147. {
  148.         IDefaultSkeleton& rIDefaultSkeleton = m_pCharacterInstance->GetIDefaultSkeleton();
  149.         {
  150.                 // find the wrinkle bones, if any
  151.                 for (uint i = 0; i < MAX_WRINKLE_BONES; ++i)
  152.                 {
  153.                         char acTmp[32];
  154.                         cry_sprintf(acTmp, "%s_%02d", WRINKLE_BONE_PREFIX, i + 1);
  155.  
  156.                         SWrinkleBoneInfo info;
  157.                         info.m_nChannelID = i;
  158.                         info.m_nJointID = rIDefaultSkeleton.GetJointIDByName(acTmp);
  159.                         if (info.m_nJointID >= 0)
  160.                                 m_WrinkleBoneInfo.push_back(info);
  161.                 }
  162.         }
  163.  
  164.         m_eSemantic[0] = 0;
  165.         m_eSemantic[1] = 0;
  166.         m_eSemantic[2] = 0;
  167. }
  168.  
  169. //////////////////////////////////////////////////////////////////////////
  170.  
  171. void CWrinkleMapShaderParamCallback::SetupShaderParams(
  172.   IShaderPublicParams* pParams, IMaterial* pMaterial)
  173. {
  174.         // setup the bone wrinkle map info if there are any bones initialized
  175.         if (pParams && m_pCharacterInstance && !m_WrinkleBoneInfo.empty())
  176.         {
  177.                 if (!pMaterial)
  178.                         pMaterial = m_pCharacterInstance->GetIMaterial();
  179.                 if (pMaterial != m_pCachedMaterial || gEnv->IsEditor())
  180.                 {
  181.                         m_bWrinklesEnabled = false;
  182.  
  183.                         if (!pMaterial)
  184.                                 pMaterial = FindFirstMaterialWithWrinkleBlending(*m_pCharacterInstance);
  185.                         m_bWrinklesEnabled = pMaterial != NULL;
  186.  
  187.                         if (!pMaterial)
  188.                                 pMaterial = m_pCharacterInstance->GetIMaterial();
  189.                         m_pCachedMaterial = pMaterial;
  190.                 }
  191.  
  192.                 if (m_bWrinklesEnabled && m_pCharacterInstance->GetISkeletonPose())
  193.                 {
  194.                         ISkeletonPose* pSkeletonPose = m_pCharacterInstance->GetISkeletonPose();
  195.  
  196.                         static const char* wrinkleMask[3] = { WRINKLE_MASK_NAME0, WRINKLE_MASK_NAME1, WRINKLE_MASK_NAME2 };
  197.                         SShaderParam* pShaderParams[3] = { NULL, NULL, NULL };
  198.                         for (uint i = 0; i < 3; ++i)
  199.                         {
  200.                                 // retrieve the shader param
  201.                                 if (m_eSemantic[i] == 0)
  202.                                 {
  203.                                         m_eSemantic[i] = pParams->GetSemanticByName(wrinkleMask[i]);
  204.                                 }
  205.  
  206.                                 assert(m_eSemantic[i] != 0);
  207.  
  208.                                 if (pParams->GetParamBySemantic(m_eSemantic[i]) == 0)
  209.                                 {
  210.                                         SShaderParam newParam;
  211.                                         cry_strcpy(newParam.m_Name, wrinkleMask[i]);
  212.                                         newParam.m_Type = eType_FCOLOR;
  213.                                         newParam.m_eSemantic = m_eSemantic[i];
  214.                                         pParams->AddParam(newParam);
  215.                                 }
  216.                         }
  217.                         for (uint i = 0; i < 3; ++i)
  218.                         {
  219.                                 pShaderParams[i] = pParams->GetParamBySemantic(m_eSemantic[i]);
  220.                                 assert(pShaderParams[i] != NULL);
  221.                         }
  222.  
  223.                         uint infoCount = m_WrinkleBoneInfo.size();
  224.                         for (uint i = 0; i < infoCount; ++i)
  225.                         {
  226.                                 const SWrinkleBoneInfo& info = m_WrinkleBoneInfo[i];
  227.                                 const QuatT& jointTransform = pSkeletonPose->GetRelJointByID(info.m_nJointID);
  228.  
  229.                                 if (info.m_nChannelID < 4)
  230.                                 {
  231.                                         if (pShaderParams[0])
  232.                                                 pShaderParams[0]->m_Value.m_Color[i] = jointTransform.t.x;
  233.                                         if (pShaderParams[1])
  234.                                                 pShaderParams[1]->m_Value.m_Color[i] = jointTransform.t.y;
  235.                                         if (pShaderParams[2])
  236.                                                 pShaderParams[2]->m_Value.m_Color[i] = jointTransform.t.z;
  237.                                 }
  238.                         }
  239.                 }
  240.         }
  241. }
  242.  
  243. void CWrinkleMapShaderParamCallback::Disable(IShaderPublicParams* pParams)
  244. {
  245.         static const char* WrinkleMask[3] = { WRINKLE_MASK_NAME0, WRINKLE_MASK_NAME1, WRINKLE_MASK_NAME2 };
  246.  
  247.         if (pParams)
  248.         {
  249.                 for (uint i = 0; i < 3; ++i)
  250.                         pParams->RemoveParamByName(WrinkleMask[i]);
  251.         }
  252. }
  253.  
  254. //////////////////////////////////////////////////////////////////////////
  255.  
downloadWrinkleMapRenderProxyCallback.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