TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-04-23 21:35:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Implementation of reflection and skylight probes.

Browse source 
Moves lighting math to the diffuse/specular two-channel logic.
This commit is contained in:
Areloch 2018-09-16 22:15:07 -05:00
parent 83dd55e851
commit 2be32ad737
102 changed files with 12346 additions and 1911 deletions
Download patch file Download diff file Expand all files Collapse all files

573
Engine/source/T3D/lighting/IBLUtilities.cpp Normal file
View file

@ -0,0 +1,573 @@
#include "console/engineAPI.h"
#include "materials/shaderData.h"
#include "gfx/gfxTextureManager.h"
#include "gfx/gfxTransformSaver.h"
#include "gfx/bitmap/cubemapSaver.h"
namespace IBLUtilities
{
void GenerateIrradianceMap(GFXTextureTargetRef renderTarget, GFXCubemapHandle cubemap, GFXCubemapHandle &cubemapOut)
{
GFXTransformSaver saver;
GFXStateBlockRef irrStateBlock;
ShaderData *irrShaderData;
GFXShaderRef irrShader = Sim::findObject("IrradianceShader", irrShaderData) ? irrShaderData->getShader() : NULL;
if (!irrShader)
{
Con::errorf("IBLUtilities::GenerateIrradianceMap() - could not find IrradianceShader");
return;
}
GFXShaderConstBufferRef irrConsts = irrShader->allocConstBuffer();
GFXShaderConstHandle* irrEnvMapSC = irrShader->getShaderConstHandle("$environmentMap");
GFXShaderConstHandle* irrFaceSC = irrShader->getShaderConstHandle("$face");
GFXStateBlockDesc desc;
desc.zEnable = false;
desc.samplersDefined = true;
desc.samplers[0].addressModeU = GFXAddressClamp;
desc.samplers[0].addressModeV = GFXAddressClamp;
desc.samplers[0].addressModeW = GFXAddressClamp;
desc.samplers[0].magFilter = GFXTextureFilterLinear;
desc.samplers[0].minFilter = GFXTextureFilterLinear;
desc.samplers[0].mipFilter = GFXTextureFilterLinear;
irrStateBlock = GFX->createStateBlock(desc);
GFX->pushActiveRenderTarget();
GFX->setShader(irrShader);
GFX->setShaderConstBuffer(irrConsts);
GFX->setStateBlock(irrStateBlock);
GFX->setVertexBuffer(NULL);
GFX->setCubeTexture(0, cubemap);
for (U32 i = 0; i < 6; i++)
{
renderTarget->attachTexture(GFXTextureTarget::Color0, cubemapOut, i);
irrConsts->setSafe(irrFaceSC, (S32)i);
GFX->setActiveRenderTarget(renderTarget);
GFX->clear(GFXClearTarget, LinearColorF::BLACK, 1.0f, 0);
GFX->drawPrimitive(GFXTriangleList, 0, 3);
renderTarget->resolve();
}
GFX->popActiveRenderTarget();
}
void GeneratePrefilterMap(GFXTextureTargetRef renderTarget, GFXCubemapHandle cubemap, U32 mipLevels, GFXCubemapHandle &cubemapOut)
{
GFXTransformSaver saver;
ShaderData *prefilterShaderData;
GFXShaderRef prefilterShader = Sim::findObject("PrefiterCubemapShader", prefilterShaderData) ? prefilterShaderData->getShader() : NULL;
if (!prefilterShader)
{
Con::errorf("IBLUtilities::GeneratePrefilterMap() - could not find PrefiterCubemapShader");
return;
}
GFXShaderConstBufferRef prefilterConsts = prefilterShader->allocConstBuffer();
GFXShaderConstHandle* prefilterEnvMapSC = prefilterShader->getShaderConstHandle("$environmentMap");
GFXShaderConstHandle* prefilterFaceSC = prefilterShader->getShaderConstHandle("$face");
GFXShaderConstHandle* prefilterRoughnessSC = prefilterShader->getShaderConstHandle("$roughness");
GFXShaderConstHandle* prefilterMipSizeSC = prefilterShader->getShaderConstHandle("$mipSize");
GFXShaderConstHandle* prefilterResolutionSC = prefilterShader->getShaderConstHandle("$resolution");
GFX->pushActiveRenderTarget();
GFX->setShader(prefilterShader);
GFX->setShaderConstBuffer(prefilterConsts);
GFX->setCubeTexture(0, cubemap);
U32 prefilterSize = cubemapOut->getSize();
for (U32 face = 0; face < 6; face++)
{
prefilterConsts->setSafe(prefilterFaceSC, (S32)face);
prefilterConsts->setSafe(prefilterResolutionSC, renderTarget->getSize().x);
for (U32 mip = 0; mip < mipLevels; mip++)
{
S32 mipSize = prefilterSize >> mip;
F32 roughness = (float)mip / (float)(mipLevels - 1);
prefilterConsts->setSafe(prefilterRoughnessSC, roughness);
prefilterConsts->setSafe(prefilterMipSizeSC, mipSize);
U32 size = prefilterSize * mPow(0.5f, mip);
renderTarget->attachTexture(GFXTextureTarget::Color0, cubemapOut, face, mip);
GFX->setActiveRenderTarget(renderTarget, false);//we set the viewport ourselves
GFX->setViewport(RectI(0, 0, size, size));
GFX->clear(GFXClearTarget, LinearColorF::BLACK, 1.0f, 0);
GFX->drawPrimitive(GFXTriangleList, 0, 3);
renderTarget->resolve();
}
}
GFX->popActiveRenderTarget();
}
void GenerateBRDFTexture(GFXTexHandle &textureOut)
{
GFXTransformSaver saver;
ShaderData *brdfShaderData;
GFXShaderRef brdfShader = Sim::findObject("BRDFLookupShader", brdfShaderData) ? brdfShaderData->getShader() : NULL;
if (!brdfShader)
{
Con::errorf("IBLUtilities::GenerateBRDFTexture() - could not find BRDFLookupShader");
return;
}
U32 textureSize = textureOut->getWidth();
GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget();
GFX->pushActiveRenderTarget();
GFX->setShader(brdfShader);
renderTarget->attachTexture(GFXTextureTarget::Color0, textureOut);
GFX->setActiveRenderTarget(renderTarget);//potential bug here with the viewport not updating with the new size
GFX->setViewport(RectI(0, 0, textureSize, textureSize));//see above comment
GFX->clear(GFXClearTarget, LinearColorF::BLUE, 1.0f, 0);
GFX->drawPrimitive(GFXTriangleList, 0, 3);
renderTarget->resolve();
GFX->popActiveRenderTarget();
}
void bakeReflection(String outputPath, S32 resolution)
{
//GFXDEBUGEVENT_SCOPE(ReflectionProbe_Bake, ColorI::WHITE);
/*PostEffect *preCapture = dynamic_cast<PostEffect*>(Sim::findObject("AL_PreCapture"));
PostEffect *deferredShading = dynamic_cast<PostEffect*>(Sim::findObject("AL_DeferredShading"));
if (preCapture)
preCapture->enable();
if (deferredShading)
deferredShading->disable();
//if (mReflectionModeType == StaticCubemap || mReflectionModeType == BakedCubemap || mReflectionModeType == SkyLight)
{
if (!mCubemap)
{
mCubemap = new CubemapData();
mCubemap->registerObject();
}
}
if (mReflectionModeType == DynamicCubemap && mDynamicCubemap.isNull())
{
//mCubemap->createMap();
mDynamicCubemap = GFX->createCubemap();
mDynamicCubemap->initDynamic(resolution, GFXFormatR8G8B8);
}
else if (mReflectionModeType != DynamicCubemap)
{
if (mReflectionPath.isEmpty() || !mPersistentId)
{
if (!mPersistentId)
mPersistentId = getOrCreatePersistentId();
mReflectionPath = outputPath.c_str();
mProbeUniqueID = std::to_string(mPersistentId->getUUID().getHash()).c_str();
}
}
bool validCubemap = true;
// Save the current transforms so we can restore
// it for child control rendering below.
GFXTransformSaver saver;
//bool saveEditingMission = gEditingMission;
//gEditingMission = false;
//Set this to true to use the prior method where it goes through the SPT_Reflect path for the bake
bool probeRenderState = ReflectionProbe::smRenderReflectionProbes;
ReflectionProbe::smRenderReflectionProbes = false;
for (U32 i = 0; i < 6; ++i)
{
GFXTexHandle blendTex;
blendTex.set(resolution, resolution, GFXFormatR8G8B8A8, &GFXRenderTargetProfile, "");
GFXTextureTargetRef mBaseTarget = GFX->allocRenderToTextureTarget();
GFX->clearTextureStateImmediate(0);
if (mReflectionModeType == DynamicCubemap)
mBaseTarget->attachTexture(GFXTextureTarget::Color0, mDynamicCubemap, i);
else
mBaseTarget->attachTexture(GFXTextureTarget::Color0, blendTex);
// Standard view that will be overridden below.
VectorF vLookatPt(0.0f, 0.0f, 0.0f), vUpVec(0.0f, 0.0f, 0.0f), vRight(0.0f, 0.0f, 0.0f);
switch (i)
{
case 0: // D3DCUBEMAP_FACE_POSITIVE_X:
vLookatPt = VectorF(1.0f, 0.0f, 0.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 1: // D3DCUBEMAP_FACE_NEGATIVE_X:
vLookatPt = VectorF(-1.0f, 0.0f, 0.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 2: // D3DCUBEMAP_FACE_POSITIVE_Y:
vLookatPt = VectorF(0.0f, 1.0f, 0.0f);
vUpVec = VectorF(0.0f, 0.0f, -1.0f);
break;
case 3: // D3DCUBEMAP_FACE_NEGATIVE_Y:
vLookatPt = VectorF(0.0f, -1.0f, 0.0f);
vUpVec = VectorF(0.0f, 0.0f, 1.0f);
break;
case 4: // D3DCUBEMAP_FACE_POSITIVE_Z:
vLookatPt = VectorF(0.0f, 0.0f, 1.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 5: // D3DCUBEMAP_FACE_NEGATIVE_Z:
vLookatPt = VectorF(0.0f, 0.0f, -1.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
}
// create camera matrix
VectorF cross = mCross(vUpVec, vLookatPt);
cross.normalizeSafe();
MatrixF matView(true);
matView.setColumn(0, cross);
matView.setColumn(1, vLookatPt);
matView.setColumn(2, vUpVec);
matView.setPosition(getPosition());
matView.inverse();
// set projection to 90 degrees vertical and horizontal
F32 left, right, top, bottom;
F32 nearPlane = 0.01f;
F32 farDist = 1000.f;
MathUtils::makeFrustum(&left, &right, &top, &bottom, M_HALFPI_F, 1.0f, nearPlane);
Frustum frustum(false, left, right, top, bottom, nearPlane, farDist);
renderFrame(&mBaseTarget, matView, frustum, StaticObjectType | StaticShapeObjectType & EDITOR_RENDER_TYPEMASK, gCanvasClearColor);
mBaseTarget->resolve();
mCubemap->setCubeFaceTexture(i, blendTex);
}
if (mReflectionModeType != DynamicCubemap && validCubemap)
{
if (mCubemap->mCubemap)
mCubemap->updateFaces();
else
mCubemap->createMap();
char fileName[256];
dSprintf(fileName, 256, "%s%s.DDS", mReflectionPath.c_str(), mProbeUniqueID.c_str());
CubemapSaver::save(mCubemap->mCubemap, fileName);
if (!Platform::isFile(fileName))
{
validCubemap = false; //if we didn't save right, just
Con::errorf("Failed to properly save out the skylight baked cubemap!");
}
mDirty = false;
}
//calculateSHTerms();
ReflectionProbe::smRenderReflectionProbes = probeRenderState;
setMaskBits(-1);
if (preCapture)
preCapture->disable();
if (deferredShading)
deferredShading->enable();*/
}
LinearColorF decodeSH(Point3F normal, const LinearColorF SHTerms[9], const F32 SHConstants[5])
{
float x = normal.x;
float y = normal.y;
float z = normal.z;
LinearColorF l00 = SHTerms[0];
LinearColorF l10 = SHTerms[1];
LinearColorF l11 = SHTerms[2];
LinearColorF l12 = SHTerms[3];
LinearColorF l20 = SHTerms[4];
LinearColorF l21 = SHTerms[5];
LinearColorF l22 = SHTerms[6];
LinearColorF l23 = SHTerms[7];
LinearColorF l24 = SHTerms[8];
LinearColorF result = (
l00 * SHConstants[0] +
l12 * SHConstants[1] * x +
l10 * SHConstants[1] * y +
l11 * SHConstants[1] * z +
l20 * SHConstants[2] * x*y +
l21 * SHConstants[2] * y*z +
l22 * SHConstants[3] * (3.0*z*z - 1.0) +
l23 * SHConstants[2] * x*z +
l24 * SHConstants[4] * (x*x - y * y)
);
return LinearColorF(mMax(result.red, 0), mMax(result.green, 0), mMax(result.blue, 0));
}
MatrixF getSideMatrix(U32 side)
{
// Standard view that will be overridden below.
VectorF vLookatPt(0.0f, 0.0f, 0.0f), vUpVec(0.0f, 0.0f, 0.0f), vRight(0.0f, 0.0f, 0.0f);
switch (side)
{
case 0: // D3DCUBEMAP_FACE_POSITIVE_X:
vLookatPt = VectorF(1.0f, 0.0f, 0.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 1: // D3DCUBEMAP_FACE_NEGATIVE_X:
vLookatPt = VectorF(-1.0f, 0.0f, 0.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 2: // D3DCUBEMAP_FACE_POSITIVE_Y:
vLookatPt = VectorF(0.0f, 1.0f, 0.0f);
vUpVec = VectorF(0.0f, 0.0f, -1.0f);
break;
case 3: // D3DCUBEMAP_FACE_NEGATIVE_Y:
vLookatPt = VectorF(0.0f, -1.0f, 0.0f);
vUpVec = VectorF(0.0f, 0.0f, 1.0f);
break;
case 4: // D3DCUBEMAP_FACE_POSITIVE_Z:
vLookatPt = VectorF(0.0f, 0.0f, 1.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 5: // D3DCUBEMAP_FACE_NEGATIVE_Z:
vLookatPt = VectorF(0.0f, 0.0f, -1.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
}
// create camera matrix
VectorF cross = mCross(vUpVec, vLookatPt);
cross.normalizeSafe();
MatrixF rotMat(true);
rotMat.setColumn(0, cross);
rotMat.setColumn(1, vLookatPt);
rotMat.setColumn(2, vUpVec);
//rotMat.inverse();
return rotMat;
}
F32 harmonics(U32 termId, Point3F normal)
{
F32 x = normal.x;
F32 y = normal.y;
F32 z = normal.z;
switch (termId)
{
case 0:
return 1.0;
case 1:
return y;
case 2:
return z;
case 3:
return x;
case 4:
return x * y;
case 5:
return y * z;
case 6:
return 3.0*z*z - 1.0;
case 7:
return x * z;
default:
return x * x - y * y;
}
}
LinearColorF sampleSide(GBitmap* cubeFaceBitmaps[6], const U32& cubemapResolution, const U32& termindex, const U32& sideIndex)
{
MatrixF sideRot = getSideMatrix(sideIndex);
LinearColorF result = LinearColorF::ZERO;
F32 divider = 0;
for (int y = 0; y<cubemapResolution; y++)
{
for (int x = 0; x<cubemapResolution; x++)
{
Point2F sidecoord = ((Point2F(x, y) + Point2F(0.5, 0.5)) / Point2F(cubemapResolution, cubemapResolution))*2.0 - Point2F(1.0, 1.0);
Point3F normal = Point3F(sidecoord.x, sidecoord.y, -1.0);
normal.normalize();
F32 minBrightness = Con::getFloatVariable("$pref::GI::Cubemap_Sample_MinBrightness", 0.001f);
LinearColorF texel = cubeFaceBitmaps[sideIndex]->sampleTexel(y, x);
texel = LinearColorF(mMax(texel.red, minBrightness), mMax(texel.green, minBrightness), mMax(texel.blue, minBrightness)) * Con::getFloatVariable("$pref::GI::Cubemap_Gain", 1.5);
Point3F dir;
sideRot.mulP(normal, &dir);
result += texel * harmonics(termindex, dir) * -normal.z;
divider += -normal.z;
}
}
result /= divider;
return result;
}
//
//SH Calculations
// From http://sunandblackcat.com/tipFullView.php?l=eng&topicid=32&topic=Spherical-Harmonics-From-Cube-Texture
// With shader decode logic from https://github.com/nicknikolov/cubemap-sh
void calculateSHTerms(GFXCubemapHandle cubemap, LinearColorF SHTerms[9], F32 SHConstants[5])
{
if (!cubemap)
return;
const VectorF cubemapFaceNormals[6] =
{
// D3DCUBEMAP_FACE_POSITIVE_X:
VectorF(1.0f, 0.0f, 0.0f),
// D3DCUBEMAP_FACE_NEGATIVE_X:
VectorF(-1.0f, 0.0f, 0.0f),
// D3DCUBEMAP_FACE_POSITIVE_Y:
VectorF(0.0f, 1.0f, 0.0f),
// D3DCUBEMAP_FACE_NEGATIVE_Y:
VectorF(0.0f, -1.0f, 0.0f),
// D3DCUBEMAP_FACE_POSITIVE_Z:
VectorF(0.0f, 0.0f, 1.0f),
// D3DCUBEMAP_FACE_NEGATIVE_Z:
VectorF(0.0f, 0.0f, -1.0f),
};
U32 cubemapResolution = cubemap->getSize();
GBitmap* cubeFaceBitmaps[6];
for (U32 i = 0; i < 6; i++)
{
cubeFaceBitmaps[i] = new GBitmap(cubemapResolution, cubemapResolution, false, GFXFormatR16G16B16A16F);
}
//If we fail to parse the cubemap for whatever reason, we really can't continue
if (!CubemapSaver::getBitmaps(cubemap, GFXFormatR8G8B8, cubeFaceBitmaps))
return;
//Set up our constants
F32 L0 = Con::getFloatVariable("$pref::GI::SH_Term_L0", 1.0f);
F32 L1 = Con::getFloatVariable("$pref::GI::SH_Term_L1", 1.8f);
F32 L2 = Con::getFloatVariable("$pref::GI::SH_Term_L2", 0.83f);
F32 L2m2_L2m1_L21 = Con::getFloatVariable("$pref::GI::SH_Term_L2m2", 2.9f);
F32 L20 = Con::getFloatVariable("$pref::GI::SH_Term_L20", 0.58f);
F32 L22 = Con::getFloatVariable("$pref::GI::SH_Term_L22", 1.1f);
SHConstants[0] = L0;
SHConstants[1] = L1;
SHConstants[2] = L2 * L2m2_L2m1_L21;
SHConstants[3] = L2 * L20;
SHConstants[4] = L2 * L22;
for (U32 i = 0; i < 9; i++)
{
//Clear it, just to be sure
SHTerms[i] = LinearColorF(0.f, 0.f, 0.f);
//Now, encode for each side
SHTerms[i] = sampleSide(cubeFaceBitmaps, cubemapResolution, i, 0); //POS_X
SHTerms[i] += sampleSide(cubeFaceBitmaps, cubemapResolution, i, 1); //NEG_X
SHTerms[i] += sampleSide(cubeFaceBitmaps, cubemapResolution, i, 2); //POS_Y
SHTerms[i] += sampleSide(cubeFaceBitmaps, cubemapResolution, i, 3); //NEG_Y
SHTerms[i] += sampleSide(cubeFaceBitmaps, cubemapResolution, i, 4); //POS_Z
SHTerms[i] += sampleSide(cubeFaceBitmaps, cubemapResolution, i, 5); //NEG_Z
//Average
SHTerms[i] /= 6;
}
for (U32 i = 0; i < 6; i++)
SAFE_DELETE(cubeFaceBitmaps[i]);
/*bool mExportSHTerms = false;
if (mExportSHTerms)
{
for (U32 f = 0; f < 6; f++)
{
char fileName[256];
dSprintf(fileName, 256, "%s%s_DecodedFaces_%d.png", mReflectionPath.c_str(),
mProbeUniqueID.c_str(), f);
LinearColorF color = decodeSH(cubemapFaceNormals[f]);
FileStream stream;
if (stream.open(fileName, Torque::FS::File::Write))
{
GBitmap bitmap(mCubemapResolution, mCubemapResolution, false, GFXFormatR8G8B8);
bitmap.fill(color.toColorI());
bitmap.writeBitmap("png", stream);
}
}
for (U32 f = 0; f < 9; f++)
{
char fileName[256];
dSprintf(fileName, 256, "%s%s_SHTerms_%d.png", mReflectionPath.c_str(),
mProbeUniqueID.c_str(), f);
LinearColorF color = mProbeInfo->SHTerms[f];
FileStream stream;
if (stream.open(fileName, Torque::FS::File::Write))
{
GBitmap bitmap(mCubemapResolution, mCubemapResolution, false, GFXFormatR8G8B8);
bitmap.fill(color.toColorI());
bitmap.writeBitmap("png", stream);
}
}
}*/
}
F32 areaElement(F32 x, F32 y)
{
return mAtan2(x * y, (F32)mSqrt(x * x + y * y + 1.0));
}
F32 texelSolidAngle(F32 aU, F32 aV, U32 width, U32 height)
{
// transform from [0..res - 1] to [- (1 - 1 / res) .. (1 - 1 / res)]
// ( 0.5 is for texel center addressing)
const F32 U = (2.0 * (aU + 0.5) / width) - 1.0;
const F32 V = (2.0 * (aV + 0.5) / height) - 1.0;
// shift from a demi texel, mean 1.0 / size with U and V in [-1..1]
const F32 invResolutionW = 1.0 / width;
const F32 invResolutionH = 1.0 / height;
// U and V are the -1..1 texture coordinate on the current face.
// get projected area for this texel
const F32 x0 = U - invResolutionW;
const F32 y0 = V - invResolutionH;
const F32 x1 = U + invResolutionW;
const F32 y1 = V + invResolutionH;
const F32 angle = areaElement(x0, y0) - areaElement(x0, y1) - areaElement(x1, y0) + areaElement(x1, y1);
return angle;
}
};

30
Engine/source/T3D/lighting/IBLUtilities.h Normal file
View file

@ -0,0 +1,30 @@
#pragma once
namespace IBLUtilities
{
void GenerateIrradianceMap(GFXTextureTargetRef renderTarget, GFXCubemapHandle cubemap, GFXCubemapHandle &cubemapOut);
void GeneratePrefilterMap(GFXTextureTargetRef renderTarget, GFXCubemapHandle cubemap, U32 mipLevels, GFXCubemapHandle &cubemapOut);
void GenerateBRDFTexture(GFXTexHandle &textureOut);
void bakeReflection(String outputPath, S32 resolution);
LinearColorF decodeSH(Point3F normal, const LinearColorF SHTerms[9], const F32 SHConstants[5]);
MatrixF getSideMatrix(U32 side);
F32 harmonics(U32 termId, Point3F normal);
LinearColorF sampleSide(GBitmap* cubeFaceBitmaps[6], const U32& cubemapResolution, const U32& termindex, const U32& sideIndex);
//
//SH Calculations
// From http://sunandblackcat.com/tipFullView.php?l=eng&topicid=32&topic=Spherical-Harmonics-From-Cube-Texture
// With shader decode logic from https://github.com/nicknikolov/cubemap-sh
void calculateSHTerms(GFXCubemapHandle cubemap, LinearColorF SHTerms[9], F32 SHConstants[5]);
F32 texelSolidAngle(F32 aU, F32 aV, U32 width, U32 height);
F32 areaElement(F32 x, F32 y);
};

1285
Engine/source/T3D/lighting/reflectionProbe.cpp Normal file
View file

File diff suppressed because it is too large Load diff

278
Engine/source/T3D/lighting/reflectionProbe.h Normal file
View file

@ -0,0 +1,278 @@
//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
#ifndef REFLECTIONPROBE_H
#define REFLECTIONPROBE_H
#ifndef _SCENEOBJECT_H_
#include "scene/sceneObject.h"
#endif
#ifndef _GFXVERTEXBUFFER_H_
#include "gfx/gfxVertexBuffer.h"
#endif
#ifndef _GFXPRIMITIVEBUFFER_H_
#include "gfx/gfxPrimitiveBuffer.h"
#endif
#ifndef _TSSHAPEINSTANCE_H_
#include "ts/tsShapeInstance.h"
#endif
#include "lighting/lightInfo.h"
#ifndef _RENDERPASSMANAGER_H_
#include "renderInstance/renderPassManager.h"
#endif
#ifndef PROBEMANAGER_H
#include "lighting/probeManager.h"
#endif
class BaseMatInstance;
//-----------------------------------------------------------------------------
// This class implements a basic SceneObject that can exist in the world at a
// 3D position and render itself. There are several valid ways to render an
// object in Torque. This class implements the preferred rendering method which
// is to submit a MeshRenderInst along with a Material, vertex buffer,
// primitive buffer, and transform and allow the RenderMeshMgr handle the
// actual setup and rendering for you.
//-----------------------------------------------------------------------------
class ReflectionProbe : public SceneObject
{
typedef SceneObject Parent;
public:
enum IndrectLightingModeType
{
NoIndirect = 0,
AmbientColor = 1,
SphericalHarmonics = 2
};
enum ReflectionModeType
{
NoReflection = 0,
StaticCubemap = 1,
BakedCubemap = 2,
DynamicCubemap = 5,
};
private:
// Networking masks
// We need to implement a mask specifically to handle
// updating our transform from the server object to its
// client-side "ghost". We also need to implement a
// maks for handling editor updates to our properties
// (like material).
enum MaskBits
{
TransformMask = Parent::NextFreeMask << 0,
UpdateMask = Parent::NextFreeMask << 1,
EnabledMask = Parent::NextFreeMask << 2,
CubemapMask = Parent::NextFreeMask << 3,
ModeMask = Parent::NextFreeMask << 4,
RadiusMask = Parent::NextFreeMask << 5,
ShapeTypeMask = Parent::NextFreeMask << 6,
BakeInfoMask = Parent::NextFreeMask << 7,
NextFreeMask = Parent::NextFreeMask << 8
};
bool mBake;
bool mEnabled;
bool mDirty;
Resource<TSShape> mEditorShape;
TSShapeInstance* mEditorShapeInst;
//--------------------------------------------------------------------------
// Rendering variables
//--------------------------------------------------------------------------
ProbeInfo::ProbeShapeType mProbeShapeType;
ProbeInfo* mProbeInfo;
//Indirect Lighting Contribution stuff
IndrectLightingModeType mIndrectLightingModeType;
LinearColorF mAmbientColor;
LinearColorF mSphericalHarmonics;
//Reflection Contribution stuff
ReflectionModeType mReflectionModeType;
F32 mRadius;
String mCubemapName;
CubemapData *mCubemap;
GFXCubemapHandle mDynamicCubemap;
bool mUseCubemap;
//irridiance resources
GFXCubemapHandle mIrridianceMap;
//prefilter resources
GFXCubemapHandle mPrefilterMap;
U32 mPrefilterMipLevels;
U32 mPrefilterSize;
//brdflookup resources - shares the texture target with the prefilter
GFXTexHandle mBrdfTexture;
String mReflectionPath;
String mProbeUniqueID;
// Define our vertex format here so we don't have to
// change it in multiple spots later
typedef GFXVertexPNTTB VertexType;
// The GFX vertex and primitive buffers
GFXVertexBufferHandle< VertexType > mVertexBuffer;
GFXPrimitiveBufferHandle mPrimitiveBuffer;
U32 mSphereVertCount;
U32 mSpherePrimitiveCount;
//Debug rendering
static bool smRenderReflectionProbes;
static bool smRenderPreviewProbes;
U32 mDynamicLastBakeMS;
U32 mRefreshRateMS;
GBitmap* mCubeFaceBitmaps[6];
U32 mCubemapResolution;
F32 mMaxDrawDistance;
bool mResourcesCreated;
public:
ReflectionProbe();
virtual ~ReflectionProbe();
// Declare this object as a ConsoleObject so that we can
// instantiate it into the world and network it
DECLARE_CONOBJECT(ReflectionProbe);
//--------------------------------------------------------------------------
// Object Editing
// Since there is always a server and a client object in Torque and we
// actually edit the server object we need to implement some basic
// networking functions
//--------------------------------------------------------------------------
// Set up any fields that we want to be editable (like position)
static void initPersistFields();
// Allows the object to update its editable settings
// from the server object to the client
virtual void inspectPostApply();
static bool _setEnabled(void *object, const char *index, const char *data);
static bool _doBake(void *object, const char *index, const char *data);
static bool protectedSetSHTerms(void *object, const char *index, const char *data);
static bool protectedSetSHConsts(void *object, const char *index, const char *data);
// Handle when we are added to the scene and removed from the scene
bool onAdd();
void onRemove();
virtual void writeFields(Stream &stream, U32 tabStop);
virtual bool writeField(StringTableEntry fieldname, const char *value);
// Override this so that we can dirty the network flag when it is called
void setTransform(const MatrixF &mat);
// This function handles sending the relevant data from the server
// object to the client object
U32 packUpdate(NetConnection *conn, U32 mask, BitStream *stream);
// This function handles receiving relevant data from the server
// object and applying it to the client object
void unpackUpdate(NetConnection *conn, BitStream *stream);
//--------------------------------------------------------------------------
// Object Rendering
// Torque utilizes a "batch" rendering system. This means that it builds a
// list of objects that need to render (via RenderInst's) and then renders
// them all in one batch. This allows it to optimized on things like
// minimizing texture, state, and shader switching by grouping objects that
// use the same Materials.
//--------------------------------------------------------------------------
// Create the geometry for rendering
void createGeometry();
// Get the Material instance
void updateMaterial();
void updateProbeParams();
bool createClientResources();
void generateTextures();
// This is the function that allows this object to submit itself for rendering
void prepRenderImage(SceneRenderState *state);
void _onRenderViz(ObjectRenderInst *ri,
SceneRenderState *state,
BaseMatInstance *overrideMat);
void setPreviewMatParameters(SceneRenderState* renderState, BaseMatInstance* mat);
//Spherical Harmonics
void calculateSHTerms();
F32 texelSolidAngle(F32 aU, F32 aV, U32 width, U32 height);
F32 areaElement(F32 x, F32 y);
//
MatrixF getSideMatrix(U32 side);
LinearColorF decodeSH(Point3F normal);
//
void calcDirectionVector(U32 face, U32 face_x, U32 face_y, F32& out_x, F32& out_y, F32& out_z) const;
F32 calcSolidAngle(U32 face, U32 x, U32 y) const;
LinearColorF sampleFace(U32 face, F32 s, F32 t);
LinearColorF readTexelClamped(U32 face, U32 x, U32 y);
void computeTexCoords(F32 x, F32 y, F32 z, U32& out_face, F32& out_s, F32& out_t);
LinearColorF readTexel(U32 face, U32 x, U32 y) const;
//
LinearColorF sampleSide(U32 termindex, U32 sideIndex);
F32 harmonics(U32 termId, Point3F normal);
//Baking
void bake(String outputPath, S32 resolution);
};
typedef ProbeInfo::ProbeShapeType ReflectProbeType;
DefineEnumType(ReflectProbeType);
typedef ReflectionProbe::IndrectLightingModeType IndrectLightingModeEnum;
DefineEnumType(IndrectLightingModeEnum);
typedef ReflectionProbe::ReflectionModeType ReflectionModeEnum;
DefineEnumType(ReflectionModeEnum);
#endif // _ReflectionProbe_H_

899
Engine/source/T3D/lighting/skylight.cpp Normal file
View file

@ -0,0 +1,899 @@
//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
#include "T3D/lighting/Skylight.h"
#include "math/mathIO.h"
#include "scene/sceneRenderState.h"
#include "console/consoleTypes.h"
#include "core/stream/bitStream.h"
#include "materials/baseMatInstance.h"
#include "console/engineAPI.h"
#include "gfx/gfxDrawUtil.h"
#include "gfx/gfxDebugEvent.h"
#include "gfx/gfxTransformSaver.h"
#include "math/mathUtils.h"
#include "gfx/bitmap/gBitmap.h"
#include "core/stream/fileStream.h"
#include "core/fileObject.h"
#include "core/resourceManager.h"
#include "console/simPersistId.h"
#include <string>
#include "T3D/gameFunctions.h"
#include "postFx/postEffect.h"
#include "renderInstance/renderProbeMgr.h"
#include "lighting/probeManager.h"
#include "math/util/sphereMesh.h"
#include "materials/materialManager.h"
#include "math/util/matrixSet.h"
#include "gfx/bitmap/cubemapSaver.h"
#include "materials/materialFeatureTypes.h"
#include "materials/shaderData.h"
#include "gfx/gfxTextureManager.h"
#include "gfx/bitmap/imageUtils.h"
#include "T3D/lighting/IBLUtilities.h"
extern bool gEditingMission;
extern ColorI gCanvasClearColor;
bool Skylight::smRenderSkylights = true;
bool Skylight::smRenderPreviewProbes = true;
IMPLEMENT_CO_NETOBJECT_V1(Skylight);
ConsoleDocClass(Skylight,
"@brief An example scene object which renders a mesh.\n\n"
"This class implements a basic SceneObject that can exist in the world at a "
"3D position and render itself. There are several valid ways to render an "
"object in Torque. This class implements the preferred rendering method which "
"is to submit a MeshRenderInst along with a Material, vertex buffer, "
"primitive buffer, and transform and allow the RenderMeshMgr handle the "
"actual setup and rendering for you.\n\n"
"See the C++ code for implementation details.\n\n"
"@ingroup Examples\n");
ImplementEnumType(SkylightReflectionModeEnum,
"Type of mesh data available in a shape.\n"
"@ingroup gameObjects")
{ Skylight::StaticCubemap, "Static Cubemap", "Uses a static CubemapData" },
{ Skylight::BakedCubemap, "Baked Cubemap", "Uses a cubemap baked from the probe's current position" },
EndImplementEnumType;
//-----------------------------------------------------------------------------
// Object setup and teardown
//-----------------------------------------------------------------------------
Skylight::Skylight()
{
// Flag this object so that it will always
// be sent across the network to clients
mNetFlags.set(Ghostable | ScopeAlways);
mTypeMask = LightObjectType | MarkerObjectType;
mReflectionModeType = StaticCubemap;
mEnabled = true;
mBake = false;
mDirty = false;
mCubemap = NULL;
mReflectionPath = "";
mProbeUniqueID = "";
mEditorShapeInst = NULL;
mEditorShape = NULL;
mIrridianceMap = NULL;
mPrefilterMap = NULL;
mBrdfTexture = NULL;
mResourcesCreated = false;
mPrefilterSize = 512;
mPrefilterMipLevels = 6;
mProbeInfo = new ProbeInfo();
}
Skylight::~Skylight()
{
if (mEditorShapeInst)
SAFE_DELETE(mEditorShapeInst);
if (mReflectionModeType != StaticCubemap && mCubemap)
mCubemap->deleteObject();
}
//-----------------------------------------------------------------------------
// Object Editing
//-----------------------------------------------------------------------------
void Skylight::initPersistFields()
{
addGroup("Rendering");
addProtectedField("enabled", TypeBool, Offset(mEnabled, Skylight),
&_setEnabled, &defaultProtectedGetFn, "Regenerate Voxel Grid");
endGroup("Rendering");
addGroup("Reflection");
//addField("ReflectionMode", TypeSkylightReflectionModeEnum, Offset(mReflectionModeType, Skylight),
// "The type of mesh data to use for collision queries.");
//addField("reflectionPath", TypeImageFilename, Offset(mReflectionPath, Skylight),
// "The type of mesh data to use for collision queries.");
addField("StaticCubemap", TypeCubemapName, Offset(mCubemapName, Skylight), "Cubemap used instead of reflection texture if fullReflect is off.");
//addProtectedField("Bake", TypeBool, Offset(mBake, Skylight),
// &_doBake, &defaultProtectedGetFn, "Regenerate Voxel Grid", AbstractClassRep::FieldFlags::FIELD_ComponentInspectors);
endGroup("Reflection");
Con::addVariable("$Light::renderSkylights", TypeBool, &Skylight::smRenderSkylights,
"Toggles rendering of light frustums when the light is selected in the editor.\n\n"
"@note Only works for shadow mapped lights.\n\n"
"@ingroup Lighting");
Con::addVariable("$Light::renderPreviewProbes", TypeBool, &Skylight::smRenderPreviewProbes,
"Toggles rendering of light frustums when the light is selected in the editor.\n\n"
"@note Only works for shadow mapped lights.\n\n"
"@ingroup Lighting");
// SceneObject already handles exposing the transform
Parent::initPersistFields();
}
void Skylight::inspectPostApply()
{
Parent::inspectPostApply();
mDirty = true;
// Flag the network mask to send the updates
// to the client object
setMaskBits(-1);
}
bool Skylight::_setEnabled(void *object, const char *index, const char *data)
{
Skylight* probe = reinterpret_cast< Skylight* >(object);
probe->mEnabled = dAtob(data);
probe->setMaskBits(-1);
return true;
}
bool Skylight::_doBake(void *object, const char *index, const char *data)
{
Skylight* probe = reinterpret_cast< Skylight* >(object);
if (probe->mDirty)
probe->bake(probe->mReflectionPath, 256);
return false;
}
bool Skylight::onAdd()
{
if (!Parent::onAdd())
return false;
mObjBox.minExtents.set(-1, -1, -1);
mObjBox.maxExtents.set(1, 1, 1);
// Skip our transform... it just dirties mask bits.
Parent::setTransform(mObjToWorld);
resetWorldBox();
// Add this object to the scene
addToScene();
if (isServerObject())
{
if (!mPersistentId)
mPersistentId = getOrCreatePersistentId();
mProbeUniqueID = std::to_string(mPersistentId->getUUID().getHash()).c_str();
}
// Refresh this object's material (if any)
if (isClientObject())
updateMaterial();
setMaskBits(-1);
return true;
}
void Skylight::onRemove()
{
// Remove this object from the scene
removeFromScene();
Parent::onRemove();
}
void Skylight::setTransform(const MatrixF & mat)
{
// Let SceneObject handle all of the matrix manipulation
Parent::setTransform(mat);
mDirty = true;
// Dirty our network mask so that the new transform gets
// transmitted to the client object
setMaskBits(TransformMask);
}
U32 Skylight::packUpdate(NetConnection *conn, U32 mask, BitStream *stream)
{
// Allow the Parent to get a crack at writing its info
U32 retMask = Parent::packUpdate(conn, mask, stream);
if (stream->writeFlag(mask & InitialUpdateMask))
{
//initial work, just in case?
}
// Write our transform information
if (stream->writeFlag(mask & TransformMask))
{
mathWrite(*stream, getTransform());
mathWrite(*stream, getScale());
}
/*if (stream->writeFlag(mask & BakeInfoMask))
{
stream->write(mReflectionPath);
stream->write(mProbeUniqueID);
}*/
if (stream->writeFlag(mask & EnabledMask))
{
stream->writeFlag(mEnabled);
}
/*if (stream->writeFlag(mask & ModeMask))
{
stream->write((U32)mReflectionModeType);
}*/
if (stream->writeFlag(mask & CubemapMask))
{
stream->write(mCubemapName);
}
return retMask;
}
void Skylight::unpackUpdate(NetConnection *conn, BitStream *stream)
{
// Let the Parent read any info it sent
Parent::unpackUpdate(conn, stream);
if (stream->readFlag())
{
//some initial work?
createGeometry();
}
if (stream->readFlag()) // TransformMask
{
mathRead(*stream, &mObjToWorld);
mathRead(*stream, &mObjScale);
setTransform(mObjToWorld);
}
/*if (stream->readFlag()) // BakeInfoMask
{
stream->read(&mReflectionPath);
stream->read(&mProbeUniqueID);
}*/
if (stream->readFlag()) // EnabledMask
{
mEnabled = stream->readFlag();
}
bool isMaterialDirty = false;
/*if (stream->readFlag()) // ModeMask
{
U32 reflectModeType = StaticCubemap;
stream->read(&reflectModeType);
mReflectionModeType = (ReflectionModeType)reflectModeType;
isMaterialDirty = true;
}*/
if (stream->readFlag()) // CubemapMask
{
stream->read(&mCubemapName);
isMaterialDirty = true;
}
updateProbeParams();
if(isMaterialDirty)
updateMaterial();
}
void Skylight::createGeometry()
{
// Clean up our previous shape
if (mEditorShapeInst)
SAFE_DELETE(mEditorShapeInst);
mEditorShape = NULL;
String shapeFile = "tools/resources/ReflectProbeSphere.dae";
// Attempt to get the resource from the ResourceManager
mEditorShape = ResourceManager::get().load(shapeFile);
if (mEditorShape)
{
mEditorShapeInst = new TSShapeInstance(mEditorShape, isClientObject());
}
}
//-----------------------------------------------------------------------------
// Object Rendering
//-----------------------------------------------------------------------------
void Skylight::updateProbeParams()
{
if (mProbeInfo == nullptr)
return;
mProbeInfo->mIntensity = 1;
mProbeInfo->mAmbient = LinearColorF(0, 0, 0, 0);
mProbeInfo->mProbeShapeType = ProbeInfo::Sphere;
mProbeInfo->setPosition(getPosition());
//Update the bounds
mObjBox.minExtents.set(-1, -1, -1);
mObjBox.maxExtents.set(1, 1, 1);
// Skip our transform... it just dirties mask bits.
Parent::setTransform(mObjToWorld);
resetWorldBox();
F32 visDist = gClientSceneGraph->getVisibleDistance();
Box3F skylightBounds = Box3F(visDist * 2);
skylightBounds.setCenter(Point3F::Zero);
mProbeInfo->setPosition(Point3F::Zero);
mProbeInfo->mBounds = skylightBounds;
setGlobalBounds();
mProbeInfo->mIsSkylight = true;
mProbeInfo->mScore = -1.0f; //sky comes first
}
bool Skylight::createClientResources()
{
//irridiance resources
mIrridianceMap = GFX->createCubemap();
mIrridianceMap->initDynamic(128, GFXFormatR16G16B16A16F, 1);
//prefilter resources - we share the irridiance stateblock
mPrefilterMap = GFX->createCubemap();
mPrefilterMap->initDynamic(mPrefilterSize, GFXFormatR16G16B16A16F, mPrefilterMipLevels);
//brdf lookup resources
//make the brdf lookup texture the same size as the prefilter texture
mBrdfTexture = TEXMGR->createTexture(mPrefilterSize, mPrefilterSize, GFXFormatR16G16B16A16F, &GFXRenderTargetProfile, 1, 0);
mResourcesCreated = true;
return true;
}
void Skylight::updateMaterial()
{
if ((mReflectionModeType == BakedCubemap) && !mProbeUniqueID.isEmpty())
{
bool validCubemap = true;
char fileName[256];
dSprintf(fileName, 256, "%s%s.DDS", mReflectionPath.c_str(), mProbeUniqueID.c_str());
Vector<FileName> fileNames;
if (Platform::isFile(fileName))
{
if (!mCubemap)
{
mCubemap = new CubemapData();
mCubemap->registerObject();
}
mCubemap->setCubemapFile(FileName(fileName));
}
else
{
validCubemap = false;
}
if (validCubemap)
{
if (mCubemap->mCubemap)
mCubemap->updateFaces();
else
mCubemap->createMap();
mDirty = false;
mProbeInfo->mCubemap = &mCubemap->mCubemap;
}
/*for (U32 i = 0; i < 6; ++i)
{
char faceFile[256];
dSprintf(faceFile, sizeof(faceFile), "%s%s_%i.png", mReflectionPath.c_str(),
mProbeUniqueID.c_str(), i);
if (Platform::isFile(faceFile))
{
fileNames.push_back(FileName(faceFile));
}
else
{
validCubemap = false;
break;
}
}
if (validCubemap)
{
if (!mCubemap)
{
mCubemap = new CubemapData();
mCubemap->registerObject();
}
for(U32 i=0; i < 6; i++)
mCubemap->setCubeFaceFile(i, fileNames[i]);
mCubemap->createMap();
mCubemap->updateFaces();
mProbeInfo->mCubemap = &mCubemap->mCubemap;
}*/
}
else if (mReflectionModeType == StaticCubemap && !mCubemapName.isEmpty())
{
Sim::findObject(mCubemapName, mCubemap);
if (!mCubemap)
return;
if (mCubemap->mCubemap)
mCubemap->updateFaces();
else
mCubemap->createMap();
mProbeInfo->mCubemap = &mCubemap->mCubemap;
}
//calculateSHTerms();
generateTextures();
//Now that the work is done, assign the relevent maps
if (mPrefilterMap.isValid())
{
mProbeInfo->mCubemap = &mPrefilterMap;
mProbeInfo->mIrradianceCubemap = &mIrridianceMap;
mProbeInfo->mBRDFTexture = &mBrdfTexture;
}
}
void Skylight::generateTextures()
{
if (!mCubemap)
return;
if (!mResourcesCreated)
{
if (!createClientResources())
{
Con::errorf("SkyLight::createIrridianceMap: Failed to create resources");
return;
}
}
//GFXTransformSaver saver;
GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget(false);
IBLUtilities::GenerateIrradianceMap(renderTarget, mCubemap->mCubemap, mIrridianceMap);
//Write it out
char fileName[256];
dSprintf(fileName, 256, "levels/test/irradiance.DDS");
CubemapSaver::save(mIrridianceMap, fileName);
if (!Platform::isFile(fileName))
{
Con::errorf("Failed to properly save out the skylight baked irradiance!");
}
//create prefilter cubemap (radiance)
IBLUtilities::GeneratePrefilterMap(renderTarget, mCubemap->mCubemap, mPrefilterMipLevels, mPrefilterMap);
//Write it out
fileName[256];
dSprintf(fileName, 256, "levels/test/prefilter.DDS");
CubemapSaver::save(mPrefilterMap, fileName);
if (!Platform::isFile(fileName))
{
Con::errorf("Failed to properly save out the skylight baked irradiance!");
}
//create brdf lookup
IBLUtilities::GenerateBRDFTexture(mBrdfTexture);
/*FileStream fs;
if (fs.open("levels/test/brdf.DDS", Torque::FS::File::Write))
{
// Read back the render target, dxt compress it, and write it to disk.
GBitmap brdfBmp(mBrdfTexture.getHeight(), mBrdfTexture.getWidth(), false, GFXFormatR8G8B8A8);
mBrdfTexture.copyToBmp(&brdfBmp);
brdfBmp.extrudeMipLevels();
DDSFile *brdfDDS = DDSFile::createDDSFileFromGBitmap(&brdfBmp);
ImageUtil::ddsCompress(brdfDDS, GFXFormatBC1);
// Write result to file stream
brdfDDS->write(fs);
delete brdfDDS;
}
fs.close();*/
}
void Skylight::prepRenderImage(SceneRenderState *state)
{
if (!mEnabled || !Skylight::smRenderSkylights)
return;
Point3F distVec = getPosition() - state->getCameraPosition();
F32 dist = distVec.len();
//special hook-in for skylights
Point3F camPos = state->getCameraPosition();
mProbeInfo->mBounds.setCenter(camPos);
mProbeInfo->setPosition(camPos);
//Submit our probe to actually do the probe action
// Get a handy pointer to our RenderPassmanager
//RenderPassManager *renderPass = state->getRenderPass();
PROBEMGR->registerSkylight(mProbeInfo, this);
if (Skylight::smRenderPreviewProbes && gEditingMission && mEditorShapeInst && mCubemap != nullptr)
{
GFXTransformSaver saver;
// Calculate the distance of this object from the camera
Point3F cameraOffset;
getRenderTransform().getColumn(3, &cameraOffset);
cameraOffset -= state->getDiffuseCameraPosition();
F32 dist = cameraOffset.len();
if (dist < 0.01f)
dist = 0.01f;
// Set up the LOD for the shape
F32 invScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z));
mEditorShapeInst->setDetailFromDistance(state, dist * invScale);
// Make sure we have a valid level of detail
if (mEditorShapeInst->getCurrentDetail() < 0)
return;
BaseMatInstance* probePrevMat = mEditorShapeInst->getMaterialList()->getMaterialInst(0);
setPreviewMatParameters(state, probePrevMat);
// GFXTransformSaver is a handy helper class that restores
// the current GFX matrices to their original values when
// it goes out of scope at the end of the function
// Set up our TS render state
TSRenderState rdata;
rdata.setSceneState(state);
rdata.setFadeOverride(1.0f);
// We might have some forward lit materials
// so pass down a query to gather lights.
LightQuery query;
query.init(getWorldSphere());
rdata.setLightQuery(&query);
// Set the world matrix to the objects render transform
MatrixF mat = getRenderTransform();
mat.scale(Point3F(1, 1, 1));
GFX->setWorldMatrix(mat);
// Animate the the shape
mEditorShapeInst->animate();
// Allow the shape to submit the RenderInst(s) for itself
mEditorShapeInst->render(rdata);
saver.restore();
}
// If the light is selected or light visualization
// is enabled then register the callback.
const bool isSelectedInEditor = (gEditingMission && isSelected());
if (isSelectedInEditor)
{
}
}
void Skylight::setPreviewMatParameters(SceneRenderState* renderState, BaseMatInstance* mat)
{
if (!mat->getFeatures().hasFeature(MFT_isDeferred))
return;
//Set up the params
MaterialParameters *matParams = mat->getMaterialParameters();
//Get the deferred render target
NamedTexTarget* deferredTexTarget = NamedTexTarget::find("deferred");
GFXTextureObject *deferredTexObject = deferredTexTarget->getTexture();
if (!deferredTexObject)
return;
GFX->setTexture(0, deferredTexObject);
//Set the cubemap
GFX->setCubeTexture(1, mCubemap->mCubemap);
//Set the invViewMat
MatrixSet &matrixSet = renderState->getRenderPass()->getMatrixSet();
const MatrixF &worldToCameraXfm = matrixSet.getWorldToCamera();
MaterialParameterHandle *invViewMat = mat->getMaterialParameterHandle("$invViewMat");
matParams->setSafe(invViewMat, worldToCameraXfm);
}
DefineEngineMethod(Skylight, postApply, void, (), ,
"A utility method for forcing a network update.\n")
{
object->inspectPostApply();
}
void Skylight::bake(String outputPath, S32 resolution)
{
GFXDEBUGEVENT_SCOPE(Skylight_Bake, ColorI::WHITE);
PostEffect *preCapture = dynamic_cast<PostEffect*>(Sim::findObject("AL_PreCapture"));
PostEffect *deferredShading = dynamic_cast<PostEffect*>(Sim::findObject("AL_DeferredShading"));
if (preCapture)
preCapture->enable();
if (deferredShading)
deferredShading->disable();
//if (mReflectionModeType == StaticCubemap || mReflectionModeType == BakedCubemap || mReflectionModeType == SkyLight)
{
if (!mCubemap)
{
mCubemap = new CubemapData();
mCubemap->registerObject();
}
}
if (mReflectionModeType == BakedCubemap)
{
if (mReflectionPath.isEmpty() || !mPersistentId)
{
if (!mPersistentId)
mPersistentId = getOrCreatePersistentId();
mReflectionPath = outputPath.c_str();
mProbeUniqueID = std::to_string(mPersistentId->getUUID().getHash()).c_str();
}
}
bool validCubemap = true;
// Save the current transforms so we can restore
// it for child control rendering below.
GFXTransformSaver saver;
//bool saveEditingMission = gEditingMission;
//gEditingMission = false;
//Set this to true to use the prior method where it goes through the SPT_Reflect path for the bake
bool probeRenderState = Skylight::smRenderSkylights;
Skylight::smRenderSkylights = false;
for (U32 i = 0; i < 6; ++i)
{
GFXTexHandle blendTex;
blendTex.set(resolution, resolution, GFXFormatR8G8B8A8, &GFXRenderTargetProfile, "");
GFXTextureTargetRef mBaseTarget = GFX->allocRenderToTextureTarget();
GFX->clearTextureStateImmediate(0);
mBaseTarget->attachTexture(GFXTextureTarget::Color0, blendTex);
// Standard view that will be overridden below.
VectorF vLookatPt(0.0f, 0.0f, 0.0f), vUpVec(0.0f, 0.0f, 0.0f), vRight(0.0f, 0.0f, 0.0f);
switch (i)
{
case 0: // D3DCUBEMAP_FACE_POSITIVE_X:
vLookatPt = VectorF(1.0f, 0.0f, 0.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 1: // D3DCUBEMAP_FACE_NEGATIVE_X:
vLookatPt = VectorF(-1.0f, 0.0f, 0.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 2: // D3DCUBEMAP_FACE_POSITIVE_Y:
vLookatPt = VectorF(0.0f, 1.0f, 0.0f);
vUpVec = VectorF(0.0f, 0.0f, -1.0f);
break;
case 3: // D3DCUBEMAP_FACE_NEGATIVE_Y:
vLookatPt = VectorF(0.0f, -1.0f, 0.0f);
vUpVec = VectorF(0.0f, 0.0f, 1.0f);
break;
case 4: // D3DCUBEMAP_FACE_POSITIVE_Z:
vLookatPt = VectorF(0.0f, 0.0f, 1.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
case 5: // D3DCUBEMAP_FACE_NEGATIVE_Z:
vLookatPt = VectorF(0.0f, 0.0f, -1.0f);
vUpVec = VectorF(0.0f, 1.0f, 0.0f);
break;
}
// create camera matrix
VectorF cross = mCross(vUpVec, vLookatPt);
cross.normalizeSafe();
MatrixF matView(true);
matView.setColumn(0, cross);
matView.setColumn(1, vLookatPt);
matView.setColumn(2, vUpVec);
matView.setPosition(getPosition());
matView.inverse();
// set projection to 90 degrees vertical and horizontal
F32 left, right, top, bottom;
F32 nearPlane = 100.f;
F32 farDist = 10000.f;
MathUtils::makeFrustum(&left, &right, &top, &bottom, M_HALFPI_F, 1.0f, nearPlane);
Frustum frustum(false, left, right, top, bottom, nearPlane, farDist);
renderFrame(&mBaseTarget, matView, frustum, StaticObjectType | StaticShapeObjectType & EDITOR_RENDER_TYPEMASK, ColorI::RED);
mBaseTarget->resolve();
mCubemap->setCubeFaceTexture(i, blendTex);
char fileName[256];
dSprintf(fileName, 256, "%s%s_%i.png", mReflectionPath.c_str(),
mProbeUniqueID.c_str(), i);
FileStream stream;
if (!stream.open(fileName, Torque::FS::File::Write))
{
Con::errorf("ReflectionProbe::bake(): Couldn't open cubemap face file fo writing " + String(fileName));
if (preCapture)
preCapture->disable();
if (deferredShading)
deferredShading->enable();
return;
}
GBitmap bitmap(blendTex->getWidth(), blendTex->getHeight(), false, GFXFormatR8G8B8);
blendTex->copyToBmp(&bitmap);
bitmap.writeBitmap("png", stream);
if (Platform::isFile(fileName) && mCubemap)
{
mCubemap->setCubeFaceFile(i, FileName(fileName));
}
else
{
validCubemap = false;
break;
}
bitmap.deleteImage();
}
if (validCubemap)
{
if (mCubemap->mCubemap)
mCubemap->updateFaces();
else
mCubemap->createMap();
char fileName[256];
dSprintf(fileName, 256, "%s%s.DDS", mReflectionPath.c_str(), mProbeUniqueID.c_str());
CubemapSaver::save(mCubemap->mCubemap, fileName);
if (!Platform::isFile(fileName))
{
validCubemap = false; //if we didn't save right, just
Con::errorf("Failed to properly save out the skylight baked cubemap!");
}
}
if (validCubemap)
{
mDirty = false;
//remove the temp files
for (U32 i = 0; i < 6; i++)
{
char fileName[256];
dSprintf(fileName, 256, "%s%s_%i.png", mReflectionPath.c_str(),
mProbeUniqueID.c_str(), i);
Platform::fileDelete(fileName);
}
}
//calculateSHTerms();
Skylight::smRenderSkylights = probeRenderState;
setMaskBits(-1);
if (preCapture)
preCapture->disable();
if (deferredShading)
deferredShading->enable();
}
DefineEngineMethod(Skylight, Bake, void, (String outputPath, S32 resolution), ("", 256),
"@brief returns true if control object is inside the fog\n\n.")
{
object->bake(outputPath, resolution);
}

212
Engine/source/T3D/lighting/skylight.h Normal file
View file

@ -0,0 +1,212 @@
//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
#ifndef SKYLIGHT_H
#define SKYLIGHT_H
#ifndef _SCENEOBJECT_H_
#include "scene/sceneObject.h"
#endif
#ifndef _GFXVERTEXBUFFER_H_
#include "gfx/gfxVertexBuffer.h"
#endif
#ifndef _GFXPRIMITIVEBUFFER_H_
#include "gfx/gfxPrimitiveBuffer.h"
#endif
#ifndef _TSSHAPEINSTANCE_H_
#include "ts/tsShapeInstance.h"
#endif
#include "lighting/lightInfo.h"
#ifndef _RENDERPASSMANAGER_H_
#include "renderInstance/renderPassManager.h"
#endif
#ifndef PROBEMANAGER_H
#include "lighting/probeManager.h"
#endif
class BaseMatInstance;
//-----------------------------------------------------------------------------
// This class implements a basic SceneObject that can exist in the world at a
// 3D position and render itself. There are several valid ways to render an
// object in Torque. This class implements the preferred rendering method which
// is to submit a MeshRenderInst along with a Material, vertex buffer,
// primitive buffer, and transform and allow the RenderMeshMgr handle the
// actual setup and rendering for you.
//-----------------------------------------------------------------------------
class Skylight : public SceneObject
{
typedef SceneObject Parent;
public:
enum IndrectLightingModeType
{
NoIndirect = 0,
AmbientColor = 1,
SphericalHarmonics = 2
};
enum ReflectionModeType
{
StaticCubemap = 1,
BakedCubemap = 2
};
private:
// Networking masks
// We need to implement a mask specifically to handle
// updating our transform from the server object to its
// client-side "ghost". We also need to implement a
// maks for handling editor updates to our properties
// (like material).
enum MaskBits
{
TransformMask = Parent::NextFreeMask << 0,
UpdateMask = Parent::NextFreeMask << 1,
EnabledMask = Parent::NextFreeMask << 2,
CubemapMask = Parent::NextFreeMask << 3,
ModeMask = Parent::NextFreeMask << 4,
RadiusMask = Parent::NextFreeMask << 5,
ShapeTypeMask = Parent::NextFreeMask << 6,
BakeInfoMask = Parent::NextFreeMask << 7,
NextFreeMask = Parent::NextFreeMask << 8
};
bool mBake;
bool mEnabled;
bool mDirty;
Resource<TSShape> mEditorShape;
TSShapeInstance* mEditorShapeInst;
//--------------------------------------------------------------------------
// Rendering variables
//--------------------------------------------------------------------------
ProbeInfo* mProbeInfo;
//Reflection Contribution stuff
ReflectionModeType mReflectionModeType;
String mCubemapName;
CubemapData *mCubemap;
String mReflectionPath;
String mProbeUniqueID;
//Debug rendering
static bool smRenderSkylights;
static bool smRenderPreviewProbes;
//irridiance resources
GFXCubemapHandle mIrridianceMap;
//prefilter resources
GFXCubemapHandle mPrefilterMap;
U32 mPrefilterMipLevels;
U32 mPrefilterSize;
//brdflookup resources - shares the texture target with the prefilter
GFXTexHandle mBrdfTexture;
bool mResourcesCreated;
public:
Skylight();
virtual ~Skylight();
// Declare this object as a ConsoleObject so that we can
// instantiate it into the world and network it
DECLARE_CONOBJECT(Skylight);
//--------------------------------------------------------------------------
// Object Editing
// Since there is always a server and a client object in Torque and we
// actually edit the server object we need to implement some basic
// networking functions
//--------------------------------------------------------------------------
// Set up any fields that we want to be editable (like position)
static void initPersistFields();
// Allows the object to update its editable settings
// from the server object to the client
virtual void inspectPostApply();
static bool _setEnabled(void *object, const char *index, const char *data);
static bool _doBake(void *object, const char *index, const char *data);
// Handle when we are added to the scene and removed from the scene
bool onAdd();
void onRemove();
// Override this so that we can dirty the network flag when it is called
void setTransform(const MatrixF &mat);
// This function handles sending the relevant data from the server
// object to the client object
U32 packUpdate(NetConnection *conn, U32 mask, BitStream *stream);
// This function handles receiving relevant data from the server
// object and applying it to the client object
void unpackUpdate(NetConnection *conn, BitStream *stream);
//--------------------------------------------------------------------------
// Object Rendering
// Torque utilizes a "batch" rendering system. This means that it builds a
// list of objects that need to render (via RenderInst's) and then renders
// them all in one batch. This allows it to optimized on things like
// minimizing texture, state, and shader switching by grouping objects that
// use the same Materials.
//--------------------------------------------------------------------------
// Create the geometry for rendering
void createGeometry();
bool createClientResources();
// Get the Material instance
void updateMaterial();
void generateTextures();
void updateProbeParams();
// This is the function that allows this object to submit itself for rendering
void prepRenderImage(SceneRenderState *state);
void setPreviewMatParameters(SceneRenderState* renderState, BaseMatInstance* mat);
//Baking
void bake(String outputPath, S32 resolution);
};
typedef Skylight::IndrectLightingModeType SkylightIndrectLightingModeEnum;
DefineEnumType(SkylightIndrectLightingModeEnum);
typedef Skylight::ReflectionModeType SkylightReflectionModeEnum;
DefineEnumType(SkylightReflectionModeEnum);
#endif // _Skylight_H_