renderProbeMgr.cpp 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968
  1. //-----------------------------------------------------------------------------
  2. // Copyright (c) 2012 GarageGames, LLC
  3. //
  4. // Permission is hereby granted, free of charge, to any person obtaining a copy
  5. // of this software and associated documentation files (the "Software"), to
  6. // deal in the Software without restriction, including without limitation the
  7. // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  8. // sell copies of the Software, and to permit persons to whom the Software is
  9. // furnished to do so, subject to the following conditions:
  10. //
  11. // The above copyright notice and this permission notice shall be included in
  12. // all copies or substantial portions of the Software.
  13. //
  14. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15. // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16. // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17. // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18. // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  20. // IN THE SOFTWARE.
  21. //-----------------------------------------------------------------------------
  22. #include "renderProbeMgr.h"
  23. #include "console/consoleTypes.h"
  24. #include "scene/sceneObject.h"
  25. #include "materials/materialManager.h"
  26. #include "scene/sceneRenderState.h"
  27. #include "math/util/sphereMesh.h"
  28. #include "math/util/matrixSet.h"
  29. #include "materials/processedMaterial.h"
  30. #include "renderInstance/renderDeferredMgr.h"
  31. #include "math/mPolyhedron.impl.h"
  32. #include "gfx/gfxTransformSaver.h"
  33. #include "gfx/gfxDebugEvent.h"
  34. #include "shaderGen/shaderGenVars.h"
  35. #include "materials/shaderData.h"
  36. #include "gfx/gfxTextureManager.h"
  37. #include "postFx/postEffect.h"
  38. #include "T3D/lighting/reflectionProbe.h"
  39. #include "T3D/lighting/IBLUtilities.h"
  40. //For our cameraQuery setup
  41. #include "T3D/gameTSCtrl.h"
  42. #define TORQUE_GFX_VISUAL_DEBUG //renderdoc debugging
  43. IMPLEMENT_CONOBJECT(RenderProbeMgr);
  44. ConsoleDocClass( RenderProbeMgr,
  45. "@brief A render bin which uses object callbacks for rendering.\n\n"
  46. "This render bin gathers object render instances and calls its delegate "
  47. "method to perform rendering. It is used infrequently for specialized "
  48. "scene objects which perform custom rendering.\n\n"
  49. "@ingroup RenderBin\n" );
  50. RenderProbeMgr *RenderProbeMgr::smProbeManager = NULL;
  51. bool RenderProbeMgr::smRenderReflectionProbes = true;
  52. S32 QSORT_CALLBACK AscendingReflectProbeInfluence(const void* a, const void* b)
  53. {
  54. // Debug Profiling.
  55. PROFILE_SCOPE(AdvancedLightBinManager_AscendingReflectProbeInfluence);
  56. // Fetch asset definitions.
  57. const ProbeRenderInst* pReflectProbeA = (*(ProbeRenderInst**)a);
  58. const ProbeRenderInst* pReflectProbeB = (*(ProbeRenderInst**)b);
  59. //sort by score
  60. return pReflectProbeA->mScore - pReflectProbeB->mScore;
  61. }
  62. //
  63. //
  64. ProbeRenderInst::ProbeRenderInst() :
  65. mIsEnabled(true),
  66. mTransform(true),
  67. mDirty(false),
  68. mPriority(1.0f),
  69. mScore(0.0f),
  70. mPrefilterCubemap(NULL),
  71. mIrradianceCubemap(NULL),
  72. mRadius(1.0f),
  73. mProbeRefOffset(0, 0, 0),
  74. mProbeRefScale(1,1,1),
  75. mAtten(0.0),
  76. mCubemapIndex(0),
  77. mIsSkylight(false),
  78. mProbeIdx(0),
  79. mProbeShapeType(Box)
  80. {
  81. }
  82. ProbeRenderInst::~ProbeRenderInst()
  83. {
  84. if (mPrefilterCubemap && mPrefilterCubemap.isValid())
  85. {
  86. mPrefilterCubemap.free();
  87. }
  88. if (mIrradianceCubemap && mIrradianceCubemap.isValid())
  89. {
  90. mIrradianceCubemap.free();
  91. }
  92. }
  93. void ProbeRenderInst::set(const ProbeRenderInst *probeInfo)
  94. {
  95. mTransform = probeInfo->mTransform;
  96. mPrefilterCubemap = probeInfo->mPrefilterCubemap;
  97. mIrradianceCubemap = probeInfo->mIrradianceCubemap;
  98. mRadius = probeInfo->mRadius;
  99. mProbeShapeType = probeInfo->mProbeShapeType;
  100. mBounds = probeInfo->mBounds;
  101. mIsSkylight = probeInfo->mIsSkylight;
  102. mScore = probeInfo->mScore;
  103. mAtten = probeInfo->mAtten;
  104. }
  105. //
  106. //
  107. ProbeShaderConstants::ProbeShaderConstants()
  108. : mInit(false),
  109. mShader(NULL),
  110. mProbePositionSC(NULL),
  111. mProbeRefPosSC(NULL),
  112. mProbeBoxMinSC(NULL),
  113. mProbeBoxMaxSC(NULL),
  114. mProbeConfigDataSC(NULL),
  115. mProbeSpecularCubemapSC(NULL),
  116. mProbeIrradianceCubemapSC(NULL),
  117. mProbeCountSC(NULL),
  118. mBRDFTextureMap(NULL),
  119. mSkylightSpecularMap(NULL),
  120. mSkylightIrradMap(NULL),
  121. mHasSkylight(NULL),
  122. mWorldToObjArraySC(NULL)
  123. {
  124. }
  125. ProbeShaderConstants::~ProbeShaderConstants()
  126. {
  127. if (mShader.isValid())
  128. {
  129. mShader->getReloadSignal().remove(this, &ProbeShaderConstants::_onShaderReload);
  130. mShader = NULL;
  131. }
  132. }
  133. void ProbeShaderConstants::init(GFXShader* shader)
  134. {
  135. if (mShader.getPointer() != shader)
  136. {
  137. if (mShader.isValid())
  138. mShader->getReloadSignal().remove(this, &ProbeShaderConstants::_onShaderReload);
  139. mShader = shader;
  140. mShader->getReloadSignal().notify(this, &ProbeShaderConstants::_onShaderReload);
  141. }
  142. //Reflection Probes
  143. mProbePositionSC = shader->getShaderConstHandle(ShaderGenVars::probePosition);
  144. mProbeRefPosSC = shader->getShaderConstHandle(ShaderGenVars::probeRefPos);
  145. mProbeBoxMinSC = shader->getShaderConstHandle(ShaderGenVars::probeBoxMin);
  146. mProbeBoxMaxSC = shader->getShaderConstHandle(ShaderGenVars::probeBoxMax);
  147. mWorldToObjArraySC = shader->getShaderConstHandle(ShaderGenVars::worldToObjArray);
  148. mProbeConfigDataSC = shader->getShaderConstHandle(ShaderGenVars::probeConfigData);
  149. mProbeSpecularCubemapSC = shader->getShaderConstHandle(ShaderGenVars::specularCubemapAR);
  150. mProbeIrradianceCubemapSC = shader->getShaderConstHandle(ShaderGenVars::irradianceCubemapAR);
  151. mProbeCountSC = shader->getShaderConstHandle(ShaderGenVars::probeCount);
  152. mBRDFTextureMap = shader->getShaderConstHandle(ShaderGenVars::BRDFTextureMap);
  153. mSkylightSpecularMap = shader->getShaderConstHandle(ShaderGenVars::skylightPrefilterMap);
  154. mSkylightIrradMap = shader->getShaderConstHandle(ShaderGenVars::skylightIrradMap);
  155. mHasSkylight = shader->getShaderConstHandle(ShaderGenVars::hasSkylight);
  156. mInit = true;
  157. }
  158. bool ProbeShaderConstants::isValid()
  159. {
  160. if (mProbePositionSC->isValid() ||
  161. mProbeConfigDataSC->isValid() ||
  162. mProbeBoxMinSC->isValid() ||
  163. mProbeBoxMaxSC->isValid() ||
  164. mProbeSpecularCubemapSC->isValid() ||
  165. mProbeIrradianceCubemapSC->isValid())
  166. return true;
  167. return false;
  168. }
  169. void ProbeShaderConstants::_onShaderReload()
  170. {
  171. if (mShader.isValid())
  172. init(mShader);
  173. }
  174. //
  175. //
  176. RenderProbeMgr::RenderProbeMgr()
  177. : RenderBinManager(RenderPassManager::RIT_Probes, 1.0f, 1.0f),
  178. mLastShader(nullptr),
  179. mLastConstants(nullptr),
  180. mProbesDirty(false),
  181. mHasSkylight(false),
  182. mSkylightCubemapIdx(-1),
  183. mCubeMapCount(0),
  184. mDefaultSkyLight(nullptr)
  185. {
  186. mEffectiveProbeCount = 0;
  187. mMipCount = 0;
  188. mProbeArrayEffect = nullptr;
  189. smProbeManager = this;
  190. mCubeMapCount = 0;
  191. for (U32 i = 0; i < PROBE_MAX_COUNT; i++)
  192. {
  193. mCubeMapSlots[i] = false;
  194. }
  195. }
  196. RenderProbeMgr::RenderProbeMgr(RenderInstType riType, F32 renderOrder, F32 processAddOrder)
  197. : RenderBinManager(riType, renderOrder, processAddOrder)
  198. {
  199. }
  200. RenderProbeMgr::~RenderProbeMgr()
  201. {
  202. mLastShader = NULL;
  203. mLastConstants = NULL;
  204. for (ProbeConstantMap::Iterator i = mConstantLookup.begin(); i != mConstantLookup.end(); i++)
  205. {
  206. if (i->value)
  207. SAFE_DELETE(i->value);
  208. }
  209. mConstantLookup.clear();
  210. }
  211. bool RenderProbeMgr::onAdd()
  212. {
  213. if (!Parent::onAdd())
  214. return false;
  215. mIrradianceArray = GFXCubemapArrayHandle(GFX->createCubemapArray());
  216. mPrefilterArray = GFXCubemapArrayHandle(GFX->createCubemapArray());
  217. //pre-allocate a few slots
  218. mIrradianceArray->init(PROBE_ARRAY_SLOT_BUFFER_SIZE, PROBE_IRRAD_SIZE, PROBE_FORMAT);
  219. mPrefilterArray->init(PROBE_ARRAY_SLOT_BUFFER_SIZE, PROBE_PREFILTER_SIZE, PROBE_FORMAT);
  220. mCubeSlotCount = PROBE_ARRAY_SLOT_BUFFER_SIZE;
  221. //create our own default default skylight
  222. mDefaultSkyLight = new ProbeRenderInst;
  223. mDefaultSkyLight->mProbeShapeType = ProbeRenderInst::Skylight;
  224. mDefaultSkyLight->mIsEnabled = false;
  225. String defaultIrradMapPath = GFXTextureManager::getDefaultIrradianceCubemapPath();
  226. if (!mDefaultSkyLight->mIrradianceCubemap.set(defaultIrradMapPath))
  227. {
  228. Con::errorf("RenderProbeMgr::onAdd: Failed to load default irradiance cubemap");
  229. return false;
  230. }
  231. String defaultPrefilterPath = GFXTextureManager::getDefaultPrefilterCubemapPath();
  232. if (!mDefaultSkyLight->mPrefilterCubemap.set(defaultPrefilterPath))
  233. {
  234. Con::errorf("RenderProbeMgr::onAdd: Failed to load default prefilter cubemap");
  235. return false;
  236. }
  237. String brdfTexturePath = GFXTextureManager::getBRDFTexturePath();
  238. if (!mBRDFTexture.set(brdfTexturePath, &GFXTexturePersistentSRGBProfile, "BRDFTexture"))
  239. {
  240. Con::errorf("RenderProbeMgr::onAdd: Failed to load BRDF Texture");
  241. return false;
  242. }
  243. return true;
  244. }
  245. void RenderProbeMgr::onRemove()
  246. {
  247. Parent::onRemove();
  248. }
  249. void RenderProbeMgr::initPersistFields()
  250. {
  251. Parent::initPersistFields();
  252. }
  253. void RenderProbeMgr::addElement(RenderInst *inst)
  254. {
  255. // If this instance is translucent handle it in RenderTranslucentMgr
  256. //if (inst->translucentSort)
  257. return;
  258. //AssertFatal(inst->defaultKey != 0, "RenderMeshMgr::addElement() - Got null sort key... did you forget to set it?");
  259. /*internalAddElement(inst);
  260. ProbeRenderInst* probeInst = static_cast<ProbeRenderInst*>(inst);
  261. if (probeInst->mIsSkylight)
  262. {
  263. addSkylightProbe(probeInst);
  264. }
  265. else
  266. {
  267. if (probeInst->mProbeShapeType == ProbeInfo::Sphere)
  268. addSphereReflectionProbe(probeInst);
  269. else
  270. addConvexReflectionProbe(probeInst);
  271. }*/
  272. }
  273. ProbeRenderInst* RenderProbeMgr::registerProbe()
  274. {
  275. ProbeRenderInst newProbe;
  276. mRegisteredProbes.push_back(newProbe);
  277. newProbe.mProbeIdx = mRegisteredProbes.size();
  278. const U32 cubeIndex = _findNextEmptyCubeSlot();
  279. if (cubeIndex == INVALID_CUBE_SLOT)
  280. {
  281. Con::warnf("RenderProbeMgr::addProbe: Invalid cubemap slot.");
  282. return nullptr;
  283. }
  284. //check if we need to resize the cubemap array
  285. if (cubeIndex >= mCubeSlotCount)
  286. {
  287. //alloc temp array handles
  288. GFXCubemapArrayHandle irr = GFXCubemapArrayHandle(GFX->createCubemapArray());
  289. GFXCubemapArrayHandle prefilter = GFXCubemapArrayHandle(GFX->createCubemapArray());
  290. irr->init(mCubeSlotCount + PROBE_ARRAY_SLOT_BUFFER_SIZE, PROBE_IRRAD_SIZE, PROBE_FORMAT);
  291. prefilter->init(mCubeSlotCount + PROBE_ARRAY_SLOT_BUFFER_SIZE, PROBE_PREFILTER_SIZE, PROBE_FORMAT);
  292. mIrradianceArray->copyTo(irr);
  293. mPrefilterArray->copyTo(prefilter);
  294. //assign the temp handles to the new ones, this will destroy the old ones as well
  295. mIrradianceArray = irr;
  296. mPrefilterArray = prefilter;
  297. mCubeSlotCount += PROBE_ARRAY_SLOT_BUFFER_SIZE;
  298. }
  299. newProbe.mCubemapIndex = cubeIndex;
  300. //mark cubemap slot as taken
  301. mCubeMapSlots[cubeIndex] = true;
  302. mCubeMapCount++;
  303. Con::warnf("RenderProbeMgr::registerProbe: Registered probe %u to cubeIndex %u", newProbe.mProbeIdx, cubeIndex);
  304. mProbesDirty = true;
  305. return &mRegisteredProbes.last();
  306. }
  307. void RenderProbeMgr::unregisterProbe(U32 probeIdx)
  308. {
  309. //Mostly for consolidation, but also lets us sanity check or prep any other data we need for rendering this in one place at time of flagging for render
  310. if (probeIdx >= mRegisteredProbes.size())
  311. return;
  312. if (mRegisteredProbes[probeIdx].mCubemapIndex == INVALID_CUBE_SLOT)
  313. return;
  314. //mark cubemap slot as available now
  315. mCubeMapSlots[mRegisteredProbes[probeIdx].mCubemapIndex] = false;
  316. mCubeMapCount--;
  317. mRegisteredProbes.erase(probeIdx);
  318. //rebuild our probe data
  319. mProbesDirty = true;
  320. }
  321. //
  322. //
  323. PostEffect* RenderProbeMgr::getProbeArrayEffect()
  324. {
  325. if (!mProbeArrayEffect)
  326. {
  327. mProbeArrayEffect = dynamic_cast<PostEffect*>(Sim::findObject("reflectionProbeArrayPostFX"));
  328. if (!mProbeArrayEffect)
  329. return nullptr;
  330. }
  331. return mProbeArrayEffect;
  332. }
  333. //remove
  334. //Con::setIntVariable("lightMetrics::activeReflectionProbes", mReflectProbeBin.size());
  335. //Con::setIntVariable("lightMetrics::culledReflectProbes", 0/*mNumLightsCulled*/);
  336. //
  337. void RenderProbeMgr::updateProbes()
  338. {
  339. mProbesDirty = true;
  340. }
  341. void RenderProbeMgr::_setupStaticParameters()
  342. {
  343. //Array rendering
  344. U32 probeCount = mRegisteredProbes.size();
  345. mEffectiveProbeCount = 0;
  346. mMipCount = 1;
  347. mHasSkylight = false;
  348. mSkylightCubemapIdx = -1;
  349. if (probePositionsData.size() != MAXPROBECOUNT)
  350. {
  351. probePositionsData.setSize(MAXPROBECOUNT);
  352. probeRefPositionsData.setSize(MAXPROBECOUNT);
  353. probeWorldToObjData.setSize(MAXPROBECOUNT);
  354. probeBBMinData.setSize(MAXPROBECOUNT);
  355. probeBBMaxData.setSize(MAXPROBECOUNT);
  356. probeConfigData.setSize(MAXPROBECOUNT);
  357. }
  358. probePositionsData.fill(Point4F::Zero);
  359. probeRefPositionsData.fill(Point4F::Zero);
  360. probeWorldToObjData.fill(MatrixF::Identity);
  361. probeBBMinData.fill(Point4F::Zero);
  362. probeBBMaxData.fill(Point4F::Zero);
  363. probeConfigData.fill(Point4F(-1,0,0,0));
  364. for (U32 i = 0; i < probeCount; i++)
  365. {
  366. if (mEffectiveProbeCount >= MAXPROBECOUNT)
  367. break;
  368. const ProbeRenderInst& curEntry = mRegisteredProbes[i];
  369. if (!curEntry.mIsEnabled)
  370. continue;
  371. U32 mips = mRegisteredProbes[i].mPrefilterCubemap.getPointer()->getMipMapLevels();
  372. mMipCount = mips != 0 && mips >= mMipCount ? mips : 0;
  373. if (curEntry.mIsSkylight)
  374. {
  375. mSkylightCubemapIdx = curEntry.mCubemapIndex;
  376. continue;
  377. }
  378. //Setup
  379. Point3F probePos = curEntry.getPosition();
  380. Point3F refPos = curEntry.getPosition() +curEntry.mProbeRefOffset;
  381. probePositionsData[mEffectiveProbeCount] = Point4F(probePos.x, probePos.y, probePos.z,0);
  382. probeRefPositionsData[mEffectiveProbeCount] = Point4F(refPos.x, refPos.y, refPos.z, 0);
  383. probeWorldToObjData[mEffectiveProbeCount] = curEntry.getTransform();
  384. Point3F bbMin = refPos - curEntry.mProbeRefScale/2 * curEntry.getTransform().getScale();
  385. Point3F bbMax = refPos + curEntry.mProbeRefScale/2 * curEntry.getTransform().getScale();
  386. probeBBMinData[mEffectiveProbeCount] = Point4F(bbMin.x, bbMin.y, bbMin.z, 0);
  387. probeBBMaxData[mEffectiveProbeCount] = Point4F(bbMax.x, bbMax.y, bbMax.z, 0);
  388. probeConfigData[mEffectiveProbeCount] = Point4F(curEntry.mProbeShapeType,
  389. curEntry.mRadius,
  390. curEntry.mAtten,
  391. curEntry.mCubemapIndex);
  392. mEffectiveProbeCount++;
  393. }
  394. mProbesDirty = false;
  395. }
  396. void RenderProbeMgr::updateProbeTexture(ProbeRenderInst* probeInfo)
  397. {
  398. if (probeInfo->mIrradianceCubemap.isNull() || !probeInfo->mIrradianceCubemap->isInitialized())
  399. {
  400. Con::errorf("RenderProbeMgr::updateProbeTexture() - tried to update a probe's texture with an invalid or uninitialized irradiance map!");
  401. return;
  402. }
  403. if (probeInfo->mPrefilterCubemap.isNull() || !probeInfo->mPrefilterCubemap->isInitialized())
  404. {
  405. Con::errorf("RenderProbeMgr::updateProbeTexture() - tried to update a probe's texture with an invalid or uninitialized specular map!");
  406. return;
  407. }
  408. const U32 cubeIndex = probeInfo->mCubemapIndex;
  409. mIrradianceArray->updateTexture(probeInfo->mIrradianceCubemap, cubeIndex);
  410. mPrefilterArray->updateTexture(probeInfo->mPrefilterCubemap, cubeIndex);
  411. Con::warnf("UpdatedProbeTexture - probeIdx: %u on cubeIndex %u, Irrad validity: %d, Prefilter validity: %d", probeInfo->mProbeIdx, cubeIndex,
  412. probeInfo->mIrradianceCubemap->isInitialized(), probeInfo->mPrefilterCubemap->isInitialized());
  413. }
  414. void RenderProbeMgr::_setupPerFrameParameters(const SceneRenderState *state)
  415. {
  416. PROFILE_SCOPE(RenderProbeMgr_SetupPerFrameParameters);
  417. }
  418. ProbeShaderConstants* RenderProbeMgr::getProbeShaderConstants(GFXShaderConstBuffer* buffer)
  419. {
  420. if (!buffer)
  421. return NULL;
  422. PROFILE_SCOPE(ProbeManager_GetProbeShaderConstants);
  423. GFXShader* shader = buffer->getShader();
  424. // Check to see if this is the same shader, we'll get hit repeatedly by
  425. // the same one due to the render bin loops.
  426. if (mLastShader.getPointer() != shader)
  427. {
  428. ProbeConstantMap::Iterator iter = mConstantLookup.find(shader);
  429. if (iter != mConstantLookup.end())
  430. {
  431. mLastConstants = iter->value;
  432. }
  433. else
  434. {
  435. ProbeShaderConstants* psc = new ProbeShaderConstants();
  436. mConstantLookup[shader] = psc;
  437. mLastConstants = psc;
  438. }
  439. // Set our new shader
  440. mLastShader = shader;
  441. }
  442. // Make sure that our current lighting constants are initialized
  443. if (mLastConstants && !mLastConstants->mInit)
  444. mLastConstants->init(shader);
  445. return mLastConstants;
  446. }
  447. void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData,
  448. MatrixSet &matSet,
  449. ProbeShaderConstants *probeShaderConsts,
  450. GFXShaderConstBuffer *shaderConsts)
  451. {
  452. return;
  453. PROFILE_SCOPE(ProbeManager_Update4ProbeConsts);
  454. // Skip over gathering lights if we don't have to!
  455. if (probeShaderConsts->isValid())
  456. {
  457. PROFILE_SCOPE(ProbeManager_Update4ProbeConsts_setProbes);
  458. const U32 MAX_FORWARD_PROBES = 4;
  459. static AlignedArray<Point4F> probePositionArray(MAX_FORWARD_PROBES, sizeof(Point4F));
  460. static AlignedArray<Point4F> probeBoxMinArray(MAX_FORWARD_PROBES, sizeof(Point4F));
  461. static AlignedArray<Point4F> probeBoxMaxArray(MAX_FORWARD_PROBES, sizeof(Point4F));
  462. static AlignedArray<Point4F> probeRefPositionArray(MAX_FORWARD_PROBES, sizeof(Point4F));
  463. static AlignedArray<Point4F> probeConfigArray(MAX_FORWARD_PROBES, sizeof(Point4F));
  464. Vector<MatrixF> probeWorldToObjArray;
  465. probeWorldToObjArray.setSize(MAX_FORWARD_PROBES);
  466. //static AlignedArray<CubemapData> probeCubemap(4, sizeof(CubemapData));
  467. //F32 range;
  468. // Need to clear the buffers so that we don't leak
  469. // lights from previous passes or have NaNs.
  470. dMemset(probePositionArray.getBuffer(), 0, probePositionArray.getBufferSize());
  471. dMemset(probeBoxMinArray.getBuffer(), 0, probeBoxMinArray.getBufferSize());
  472. dMemset(probeBoxMaxArray.getBuffer(), 0, probeBoxMaxArray.getBufferSize());
  473. dMemset(probeRefPositionArray.getBuffer(), 0, probeRefPositionArray.getBufferSize());
  474. dMemset(probeConfigArray.getBuffer(), 0, probeConfigArray.getBufferSize());
  475. matSet.restoreSceneViewProjection();
  476. //Array rendering
  477. U32 probeCount = mRegisteredProbes.size();
  478. S8 bestPickProbes[4] = { -1,-1,-1,-1 };
  479. U32 effectiveProbeCount = 0;
  480. for (U32 i = 0; i < probeCount; i++)
  481. {
  482. //if (effectiveProbeCount >= MAX_FORWARD_PROBES)
  483. // break;
  484. const ProbeRenderInst& curEntry = mRegisteredProbes[i];
  485. if (!curEntry.mIsEnabled)
  486. continue;
  487. if (!curEntry.mIsSkylight)
  488. {
  489. F32 dist = Point3F(sgData.objTrans->getPosition() - curEntry.getPosition()).len();
  490. if (dist > curEntry.mRadius || dist > curEntry.mExtents.len())
  491. continue;
  492. if(bestPickProbes[0] == -1 || (Point3F(sgData.objTrans->getPosition() - mRegisteredProbes[bestPickProbes[0]].mPosition).len() > dist))
  493. bestPickProbes[0] = i;
  494. else if (bestPickProbes[1] == -1 || (Point3F(sgData.objTrans->getPosition() - mRegisteredProbes[bestPickProbes[1]].mPosition).len() > dist))
  495. bestPickProbes[1] = i;
  496. else if (bestPickProbes[2] == -1 || (Point3F(sgData.objTrans->getPosition() - mRegisteredProbes[bestPickProbes[2]].mPosition).len() > dist))
  497. bestPickProbes[2] = i;
  498. else if (bestPickProbes[3] == -1 || (Point3F(sgData.objTrans->getPosition() - mRegisteredProbes[bestPickProbes[3]].mPosition).len() > dist))
  499. bestPickProbes[3] = i;
  500. }
  501. }
  502. //Grab our best probe picks
  503. for (U32 i = 0; i < 4; i++)
  504. {
  505. if (bestPickProbes[i] == -1)
  506. continue;
  507. const ProbeRenderInst& curEntry = mRegisteredProbes[bestPickProbes[i]];
  508. probePositionArray[effectiveProbeCount] = curEntry.getPosition();
  509. probeRefPositionArray[effectiveProbeCount] = curEntry.mProbeRefOffset;
  510. probeWorldToObjArray[effectiveProbeCount] = curEntry.getTransform();
  511. probeWorldToObjData[mEffectiveProbeCount] = curEntry.getTransform();
  512. /*
  513. Point3F refPos = curEntry.getPosition() + curEntry.mProbeRefOffset;
  514. Point3F bbMin = refPos - curEntry.mProbeRefScale / 2 * curEntry.getTransform().getScale();
  515. Point3F bbMax = refPos + curEntry.mProbeRefScale / 2 * curEntry.getTransform().getScale();
  516. probeBoxMinArray[mEffectiveProbeCount] = Point4F(bbMin.x, bbMin.y, bbMin.z, 0);
  517. probeBoxMaxArray[mEffectiveProbeCount] = Point4F(bbMax.x, bbMax.y, bbMax.z, 0);*/
  518. probeBoxMinArray[effectiveProbeCount] = curEntry.mBounds.minExtents;
  519. probeBoxMaxArray[effectiveProbeCount] = curEntry.mBounds.maxExtents;
  520. probeConfigArray[effectiveProbeCount] = Point4F(curEntry.mProbeShapeType,
  521. curEntry.mRadius,
  522. curEntry.mAtten,
  523. curEntry.mCubemapIndex);
  524. effectiveProbeCount++;
  525. }
  526. shaderConsts->setSafe(probeShaderConsts->mProbeCountSC, (float)effectiveProbeCount);
  527. shaderConsts->setSafe(probeShaderConsts->mProbePositionSC, probePositionArray);
  528. shaderConsts->setSafe(probeShaderConsts->mProbeRefPosSC, probeRefPositionArray);
  529. shaderConsts->set(probeShaderConsts->mWorldToObjArraySC, probeWorldToObjArray.address(), effectiveProbeCount, GFXSCT_Float4x4);
  530. shaderConsts->setSafe(probeShaderConsts->mProbeBoxMinSC, probeBoxMinArray);
  531. shaderConsts->setSafe(probeShaderConsts->mProbeBoxMaxSC, probeBoxMaxArray);
  532. shaderConsts->setSafe(probeShaderConsts->mProbeConfigDataSC, probeConfigArray);
  533. if (mBRDFTexture.isValid())
  534. GFX->setTexture(3, mBRDFTexture);
  535. if(probeShaderConsts->mProbeSpecularCubemapSC->getSamplerRegister() != -1)
  536. GFX->setCubeArrayTexture(probeShaderConsts->mProbeSpecularCubemapSC->getSamplerRegister(), mPrefilterArray);
  537. if(probeShaderConsts->mProbeIrradianceCubemapSC->getSamplerRegister() != -1)
  538. GFX->setCubeArrayTexture(probeShaderConsts->mProbeIrradianceCubemapSC->getSamplerRegister(), mIrradianceArray);
  539. }
  540. //check for skylight action
  541. if (probeShaderConsts->mSkylightIrradMap->isValid()
  542. && probeShaderConsts->mSkylightSpecularMap->isValid())
  543. {
  544. //Array rendering
  545. U32 probeCount = mRegisteredProbes.size();
  546. bool hasSkylight = false;
  547. for (U32 i = 0; i < probeCount; i++)
  548. {
  549. const ProbeRenderInst& curEntry = mRegisteredProbes[i];
  550. if (!curEntry.mIsEnabled)
  551. continue;
  552. if (curEntry.mIsSkylight)
  553. {
  554. if (curEntry.mPrefilterCubemap->isInitialized() && curEntry.mIrradianceCubemap->isInitialized())
  555. {
  556. GFX->setCubeTexture(probeShaderConsts->mSkylightSpecularMap->getSamplerRegister(), curEntry.mPrefilterCubemap);
  557. GFX->setCubeTexture(probeShaderConsts->mSkylightIrradMap->getSamplerRegister(), curEntry.mIrradianceCubemap);
  558. shaderConsts->setSafe(probeShaderConsts->mHasSkylight, 1.0f);
  559. hasSkylight = true;
  560. break;
  561. }
  562. }
  563. }
  564. if (!hasSkylight)
  565. shaderConsts->setSafe(probeShaderConsts->mHasSkylight, 0.0f);
  566. }
  567. /*else
  568. {
  569. if (probeCubemapSC->isValid())
  570. {
  571. for (U32 i = 0; i < 4; ++i)
  572. GFX->setCubeTexture(probeCubemapSC->getSamplerRegister() + i, NULL);
  573. }
  574. }*/
  575. }
  576. void RenderProbeMgr::setProbeInfo(ProcessedMaterial *pmat,
  577. const Material *mat,
  578. const SceneData &sgData,
  579. const SceneRenderState *state,
  580. U32 pass,
  581. GFXShaderConstBuffer *shaderConsts)
  582. {
  583. // Skip this if we're rendering from the deferred bin.
  584. if (sgData.binType == SceneData::DeferredBin)
  585. return;
  586. // if (mRegisteredProbes.empty())
  587. // return;
  588. PROFILE_SCOPE(ProbeManager_setProbeInfo);
  589. ProbeShaderConstants *psc = getProbeShaderConstants(shaderConsts);
  590. // NOTE: If you encounter a crash from this point forward
  591. // while setting a shader constant its probably because the
  592. // mConstantLookup has bad shaders/constants in it.
  593. //
  594. // This is a known crash bug that can occur if materials/shaders
  595. // are reloaded and the light manager is not reset.
  596. //
  597. // We should look to fix this by clearing the table.
  598. MatrixSet matSet = state->getRenderPass()->getMatrixSet();
  599. // Update the forward shading light constants.
  600. _update4ProbeConsts(sgData, matSet, psc, shaderConsts);
  601. }
  602. //-----------------------------------------------------------------------------
  603. // render objects
  604. //-----------------------------------------------------------------------------
  605. void RenderProbeMgr::render( SceneRenderState *state )
  606. {
  607. if (getProbeArrayEffect() == nullptr)
  608. return;
  609. if (mProbesDirty)
  610. _setupStaticParameters();
  611. // Early out if nothing to draw.
  612. if (!RenderProbeMgr::smRenderReflectionProbes || !state->isDiffusePass() || (mEffectiveProbeCount == 0 && mSkylightCubemapIdx == -1))
  613. {
  614. getProbeArrayEffect()->setSkip(true);
  615. return;
  616. }
  617. GFXTransformSaver saver;
  618. GFXDEBUGEVENT_SCOPE(RenderProbeMgr_render, ColorI::WHITE);
  619. // Initialize and set the per-frame parameters after getting
  620. // the vector light material as we use lazy creation.
  621. //_setupPerFrameParameters(state);
  622. //Visualization
  623. String useDebugAtten = Con::getVariable("$Probes::showAttenuation", "0");
  624. mProbeArrayEffect->setShaderMacro("DEBUGVIZ_ATTENUATION", useDebugAtten);
  625. String useDebugSpecCubemap = Con::getVariable("$Probes::showSpecularCubemaps", "0");
  626. mProbeArrayEffect->setShaderMacro("DEBUGVIZ_SPECCUBEMAP", useDebugSpecCubemap);
  627. String useDebugDiffuseCubemap = Con::getVariable("$Probes::showDiffuseCubemaps", "0");
  628. mProbeArrayEffect->setShaderMacro("DEBUGVIZ_DIFFCUBEMAP", useDebugDiffuseCubemap);
  629. String useDebugContrib = Con::getVariable("$Probes::showProbeContrib", "0");
  630. mProbeArrayEffect->setShaderMacro("DEBUGVIZ_CONTRIB", useDebugContrib);
  631. if(mHasSkylight && mEffectiveProbeCount == 0)
  632. mProbeArrayEffect->setShaderMacro("SKYLIGHT_ONLY", "1");
  633. mProbeArrayEffect->setTexture(3, mBRDFTexture);
  634. mProbeArrayEffect->setCubemapArrayTexture(4, mPrefilterArray);
  635. mProbeArrayEffect->setCubemapArrayTexture(5, mIrradianceArray);
  636. mProbeArrayEffect->setShaderConst("$numProbes", (S32)mEffectiveProbeCount);
  637. mProbeArrayEffect->setShaderConst("$skylightCubemapIdx", mSkylightCubemapIdx);
  638. mProbeArrayEffect->setShaderConst("$cubeMips", (float)mMipCount);
  639. //also set up some colors
  640. Vector<Point4F> contribColors;
  641. contribColors.setSize(MAXPROBECOUNT);
  642. if (mEffectiveProbeCount != 0)
  643. {
  644. if (useDebugContrib == String("1"))
  645. {
  646. MRandomLCG RandomGen;
  647. RandomGen.setSeed(mEffectiveProbeCount);
  648. for (U32 i = 0; i < mEffectiveProbeCount; i++)
  649. {
  650. //we're going to cheat here a little for consistent debugging behavior. The first 3 probes will always have R G and then B for their colors, every other will be random
  651. if (i == 0)
  652. contribColors[i] = Point4F(1, 0, 0, 1);
  653. else if (i == 1)
  654. contribColors[i] = Point4F(0, 1, 0, 1);
  655. else if (i == 2)
  656. contribColors[i] = Point4F(0, 0, 1, 1);
  657. else
  658. contribColors[i] = Point4F(RandomGen.randF(0, 1), RandomGen.randF(0, 1), RandomGen.randF(0, 1), 1);
  659. }
  660. }
  661. }
  662. mProbeArrayEffect->setShaderConst("$probeContribColors", contribColors);
  663. mProbeArrayEffect->setShaderConst("$inProbePosArray", probePositionsData);
  664. mProbeArrayEffect->setShaderConst("$inRefPosArray", probeRefPositionsData);
  665. mProbeArrayEffect->setShaderConst("$worldToObjArray", probeWorldToObjData);
  666. mProbeArrayEffect->setShaderConst("$bbMinArray", probeBBMinData);
  667. mProbeArrayEffect->setShaderConst("$bbMaxArray", probeBBMaxData);
  668. mProbeArrayEffect->setShaderConst("$probeConfigData", probeConfigData);
  669. // Make sure the effect is gonna render.
  670. getProbeArrayEffect()->setSkip(false);
  671. //PROFILE_END();
  672. }
  673. void RenderProbeMgr::bakeProbe(ReflectionProbe *probe)
  674. {
  675. GFXDEBUGEVENT_SCOPE(RenderProbeMgr_Bake, ColorI::WHITE);
  676. Con::warnf("RenderProbeMgr::bakeProbe() - Beginning bake!");
  677. U32 startMSTime = Platform::getRealMilliseconds();
  678. String path = Con::getVariable("$pref::ReflectionProbes::CurrentLevelPath", "levels/");
  679. U32 resolution = Con::getIntVariable("$pref::ReflectionProbes::BakeResolution", 64);
  680. U32 prefilterMipLevels = mLog2(F32(resolution));
  681. bool renderWithProbes = Con::getIntVariable("$pref::ReflectionProbes::RenderWithProbes", false);
  682. ReflectionProbe *clientProbe = static_cast<ReflectionProbe*>(probe->getClientObject());
  683. if (clientProbe == nullptr)
  684. return;
  685. String probePrefilterPath = clientProbe->getPrefilterMapPath();
  686. String probeIrradPath = clientProbe->getIrradianceMapPath();
  687. if (clientProbe->mReflectionModeType != ReflectionProbe::DynamicCubemap)
  688. {
  689. //Prep our bake path
  690. if (probePrefilterPath.isEmpty() || probeIrradPath.isEmpty())
  691. {
  692. Con::errorf("RenderProbeMgr::bake() - Unable to bake our captures because probe doesn't have a path set");
  693. return;
  694. }
  695. }
  696. // Save the current transforms so we can restore
  697. // it for child control rendering below.
  698. GFXTransformSaver saver;
  699. bool probeRenderState = RenderProbeMgr::smRenderReflectionProbes;
  700. F32 farPlane = 1000.0f;
  701. ReflectorDesc reflDesc;
  702. reflDesc.texSize = resolution;
  703. reflDesc.farDist = farPlane;
  704. reflDesc.detailAdjust = 1;
  705. reflDesc.objectTypeMask = -1;
  706. CubeReflector cubeRefl;
  707. cubeRefl.registerReflector(probe, &reflDesc);
  708. ReflectParams reflParams;
  709. //need to get the query somehow. Likely do some sort of get function to fetch from the guiTSControl that's active
  710. CameraQuery query; //need to get the last cameraQuery
  711. query.fov = 90; //90 degree slices for each of the 6 sides
  712. query.nearPlane = 0.1f;
  713. query.farPlane = farPlane;
  714. query.headMatrix = MatrixF();
  715. query.cameraMatrix = clientProbe->getTransform();
  716. Frustum culler;
  717. culler.set(false,
  718. query.fov,
  719. (F32)resolution / (F32)resolution,
  720. query.nearPlane,
  721. query.farPlane,
  722. query.cameraMatrix);
  723. S32 stereoTarget = GFX->getCurrentStereoTarget();
  724. Point2I maxRes(2048, 2048); //basically a boundary so we don't go over this and break stuff
  725. reflParams.culler = culler;
  726. reflParams.eyeId = stereoTarget;
  727. reflParams.query = &query;
  728. reflParams.startOfUpdateMs = startMSTime;
  729. reflParams.viewportExtent = maxRes;
  730. if (!renderWithProbes)
  731. RenderProbeMgr::smRenderReflectionProbes = false;
  732. cubeRefl.updateReflection(reflParams);
  733. //Now, save out the maps
  734. //create irridiance cubemap
  735. if (cubeRefl.getCubemap())
  736. {
  737. //Just to ensure we're prepped for the generation
  738. clientProbe->createClientResources();
  739. //Prep it with whatever resolution we've dictated for our bake
  740. if (clientProbe->mUseHDRCaptures)
  741. {
  742. clientProbe->mIrridianceMap->mCubemap->initDynamic(resolution, GFXFormatR16G16B16A16F);
  743. clientProbe->mPrefilterMap->mCubemap->initDynamic(resolution, GFXFormatR16G16B16A16F);
  744. }
  745. else
  746. {
  747. clientProbe->mIrridianceMap->mCubemap->initDynamic(resolution, GFXFormatR8G8B8A8);
  748. clientProbe->mPrefilterMap->mCubemap->initDynamic(resolution, GFXFormatR8G8B8A8);
  749. }
  750. GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget(false);
  751. IBLUtilities::GenerateIrradianceMap(renderTarget, cubeRefl.getCubemap(), clientProbe->mIrridianceMap->mCubemap);
  752. IBLUtilities::GeneratePrefilterMap(renderTarget, cubeRefl.getCubemap(), prefilterMipLevels, clientProbe->mPrefilterMap->mCubemap);
  753. U32 endMSTime = Platform::getRealMilliseconds();
  754. F32 diffTime = F32(endMSTime - startMSTime);
  755. Con::warnf("RenderProbeMgr::bake() - Finished Capture! Took %g milliseconds", diffTime);
  756. Con::warnf("RenderProbeMgr::bake() - Beginning save now!");
  757. IBLUtilities::SaveCubeMap(clientProbe->getIrradianceMapPath(), clientProbe->mIrridianceMap->mCubemap);
  758. IBLUtilities::SaveCubeMap(clientProbe->getPrefilterMapPath(), clientProbe->mPrefilterMap->mCubemap);
  759. }
  760. else
  761. {
  762. Con::errorf("RenderProbeMgr::bake() - Didn't generate a valid scene capture cubemap, unable to generate prefilter and irradiance maps!");
  763. }
  764. if (!renderWithProbes)
  765. RenderProbeMgr::smRenderReflectionProbes = probeRenderState;
  766. cubeRefl.unregisterReflector();
  767. U32 endMSTime = Platform::getRealMilliseconds();
  768. F32 diffTime = F32(endMSTime - startMSTime);
  769. Con::warnf("RenderProbeMgr::bake() - Finished bake! Took %g milliseconds", diffTime);
  770. }
  771. void RenderProbeMgr::bakeProbes()
  772. {
  773. //TODO: make this just find every probe in the current missionGroup and run the bake on it automagically
  774. }
  775. DefineEngineMethod(RenderProbeMgr, bakeProbe, void, (ReflectionProbe* probe), (nullAsType< ReflectionProbe*>()),
  776. "@brief returns true if control object is inside the fog\n\n.")
  777. {
  778. if(probe != nullptr)
  779. object->bakeProbe(probe);
  780. }