mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-02-12 19:31:41 +00:00
Updates and fixes to probe and lighting logic.
This commit is contained in:
Areloch
parent
b19a4b22c8
commit
f31445751f
23 changed files with 568 additions and 1466 deletions
|
|
@ -3,6 +3,8 @@
|
|||
#include "gfx/gfxTextureManager.h"
|
||||
#include "gfx/gfxTransformSaver.h"
|
||||
#include "gfx/bitmap/cubemapSaver.h"
|
||||
#include "core/stream/fileStream.h"
|
||||
#include "gfx/bitmap/imageUtils.h"
|
||||
|
||||
namespace IBLUtilities
|
||||
{
|
||||
|
|
@ -56,6 +58,44 @@ namespace IBLUtilities
|
|||
GFX->popActiveRenderTarget();
|
||||
}
|
||||
|
||||
void GenerateAndSaveIrradianceMap(String outputPath, S32 resolution, GFXCubemapHandle cubemap, GFXCubemapHandle &cubemapOut)
|
||||
{
|
||||
if (outputPath.isEmpty())
|
||||
{
|
||||
Con::errorf("IBLUtilities::GenerateAndSaveIrradianceMap - Cannot save to an empty path!");
|
||||
return;
|
||||
}
|
||||
|
||||
GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget(false);
|
||||
|
||||
IBLUtilities::GenerateIrradianceMap(renderTarget, cubemap, cubemapOut);
|
||||
|
||||
//Write it out
|
||||
CubemapSaver::save(cubemapOut, outputPath);
|
||||
|
||||
if (!Platform::isFile(outputPath))
|
||||
{
|
||||
Con::errorf("IBLUtilities::GenerateAndSaveIrradianceMap - Failed to properly save out the baked irradiance!");
|
||||
}
|
||||
}
|
||||
|
||||
void SaveCubeMap(String outputPath, GFXCubemapHandle &cubemap)
|
||||
{
|
||||
if (outputPath.isEmpty())
|
||||
{
|
||||
Con::errorf("IBLUtilities::SaveCubeMap - Cannot save to an empty path!");
|
||||
return;
|
||||
}
|
||||
|
||||
//Write it out
|
||||
CubemapSaver::save(cubemap, outputPath);
|
||||
|
||||
if (!Platform::isFile(outputPath))
|
||||
{
|
||||
Con::errorf("IBLUtilities::SaveCubeMap - Failed to properly save out the baked irradiance!");
|
||||
}
|
||||
}
|
||||
|
||||
void GeneratePrefilterMap(GFXTextureTargetRef renderTarget, GFXCubemapHandle cubemap, U32 mipLevels, GFXCubemapHandle &cubemapOut)
|
||||
{
|
||||
GFXTransformSaver saver;
|
||||
|
|
@ -73,8 +113,8 @@ namespace IBLUtilities
|
|||
GFXShaderConstHandle* prefilterFaceSC = prefilterShader->getShaderConstHandle("$face");
|
||||
GFXShaderConstHandle* prefilterRoughnessSC = prefilterShader->getShaderConstHandle("$roughness");
|
||||
GFXShaderConstHandle* prefilterMipSizeSC = prefilterShader->getShaderConstHandle("$mipSize");
|
||||
GFXShaderConstHandle* prefilterResolutionSC = prefilterShader->getShaderConstHandle("$resolution");
|
||||
|
||||
GFXShaderConstHandle* prefilterResolutionSC = prefilterShader->getShaderConstHandle("$resolution");
|
||||
|
||||
GFX->pushActiveRenderTarget();
|
||||
GFX->setShader(prefilterShader);
|
||||
GFX->setShaderConstBuffer(prefilterConsts);
|
||||
|
|
@ -82,10 +122,13 @@ namespace IBLUtilities
|
|||
|
||||
U32 prefilterSize = cubemapOut->getSize();
|
||||
|
||||
U32 resolutionSize = prefilterSize;
|
||||
|
||||
for (U32 face = 0; face < 6; face++)
|
||||
{
|
||||
prefilterConsts->setSafe(prefilterFaceSC, (S32)face);
|
||||
prefilterConsts->setSafe(prefilterResolutionSC, renderTarget->getSize().x);
|
||||
prefilterConsts->setSafe(prefilterResolutionSC, (S32)resolutionSize);
|
||||
|
||||
for (U32 mip = 0; mip < mipLevels; mip++)
|
||||
{
|
||||
S32 mipSize = prefilterSize >> mip;
|
||||
|
|
@ -105,6 +148,27 @@ namespace IBLUtilities
|
|||
GFX->popActiveRenderTarget();
|
||||
}
|
||||
|
||||
void GenerateAndSavePrefilterMap(String outputPath, S32 resolution, GFXCubemapHandle cubemap, U32 mipLevels, GFXCubemapHandle &cubemapOut)
|
||||
{
|
||||
if (outputPath.isEmpty())
|
||||
{
|
||||
Con::errorf("IBLUtilities::GenerateAndSavePrefilterMap - Cannot save to an empty path!");
|
||||
return;
|
||||
}
|
||||
|
||||
GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget(false);
|
||||
|
||||
IBLUtilities::GeneratePrefilterMap(renderTarget, cubemap, mipLevels, cubemapOut);
|
||||
|
||||
//Write it out
|
||||
CubemapSaver::save(cubemapOut, outputPath);
|
||||
|
||||
if (!Platform::isFile(outputPath))
|
||||
{
|
||||
Con::errorf("IBLUtilities::GenerateAndSavePrefilterMap - Failed to properly save out the baked irradiance!");
|
||||
}
|
||||
}
|
||||
|
||||
void GenerateBRDFTexture(GFXTexHandle &textureOut)
|
||||
{
|
||||
GFXTransformSaver saver;
|
||||
|
|
@ -133,6 +197,33 @@ namespace IBLUtilities
|
|||
GFX->popActiveRenderTarget();
|
||||
}
|
||||
|
||||
GFXTexHandle GenerateAndSaveBRDFTexture(String outputPath, S32 resolution)
|
||||
{
|
||||
GFXTexHandle brdfTexture = TEXMGR->createTexture(resolution, resolution, GFXFormatR8G8B8A8, &GFXRenderTargetProfile, 1, 0);
|
||||
GenerateBRDFTexture(brdfTexture);
|
||||
|
||||
FileStream fs;
|
||||
if (fs.open(outputPath, Torque::FS::File::Write))
|
||||
{
|
||||
// Read back the render target, dxt compress it, and write it to disk.
|
||||
GBitmap brdfBmp(brdfTexture.getHeight(), brdfTexture.getWidth(), false, GFXFormatR8G8B8A8);
|
||||
brdfTexture.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();
|
||||
|
||||
return brdfTexture;
|
||||
}
|
||||
|
||||
void bakeReflection(String outputPath, S32 resolution)
|
||||
{
|
||||
//GFXDEBUGEVENT_SCOPE(ReflectionProbe_Bake, ColorI::WHITE);
|
||||
|
|
@ -464,7 +555,7 @@ namespace IBLUtilities
|
|||
}
|
||||
|
||||
//If we fail to parse the cubemap for whatever reason, we really can't continue
|
||||
if (!CubemapSaver::getBitmaps(cubemap, GFXFormatR8G8B8, cubeFaceBitmaps))
|
||||
if (!CubemapSaver::getBitmaps(cubemap, GFXFormatR8G8B8A8, cubeFaceBitmaps))
|
||||
return;
|
||||
|
||||
//Set up our constants
|
||||
|
|
@ -570,4 +661,10 @@ namespace IBLUtilities
|
|||
|
||||
return angle;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
DefineEngineFunction(GenerateBRDFTexture, bool, (String outputPath, S32 resolution), ("", 256),
|
||||
"@brief returns true if control object is inside the fog\n\n.")
|
||||
{
|
||||
return IBLUtilities::GenerateAndSaveBRDFTexture(outputPath, resolution);
|
||||
}
|
||||
|
|
@ -3,9 +3,14 @@
|
|||
namespace IBLUtilities
|
||||
{
|
||||
void GenerateIrradianceMap(GFXTextureTargetRef renderTarget, GFXCubemapHandle cubemap, GFXCubemapHandle &cubemapOut);
|
||||
void GenerateAndSaveIrradianceMap(String outputPath, S32 resolution, GFXCubemapHandle cubemap, GFXCubemapHandle &cubemapOut);
|
||||
|
||||
void GeneratePrefilterMap(GFXTextureTargetRef renderTarget, GFXCubemapHandle cubemap, U32 mipLevels, GFXCubemapHandle &cubemapOut);
|
||||
void GenerateAndSavePrefilterMap(String outputPath, S32 resolution, GFXCubemapHandle cubemap, U32 mipLevels, GFXCubemapHandle &cubemapOut);
|
||||
|
||||
void SaveCubeMap(String outputPath, GFXCubemapHandle &cubemap);
|
||||
|
||||
GFXTexHandle GenerateAndSaveBRDFTexture(String outputPath, S32 resolution);
|
||||
void GenerateBRDFTexture(GFXTexHandle &textureOut);
|
||||
|
||||
void bakeReflection(String outputPath, S32 resolution);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -78,7 +78,7 @@ public:
|
|||
DynamicCubemap = 5,
|
||||
};
|
||||
|
||||
private:
|
||||
protected:
|
||||
|
||||
// Networking masks
|
||||
// We need to implement a mask specifically to handle
|
||||
|
|
@ -115,24 +115,24 @@ private:
|
|||
|
||||
//Indirect Lighting Contribution stuff
|
||||
IndrectLightingModeType mIndrectLightingModeType;
|
||||
LinearColorF mAmbientColor;
|
||||
LinearColorF mSphericalHarmonics;
|
||||
|
||||
//Reflection Contribution stuff
|
||||
ReflectionModeType mReflectionModeType;
|
||||
|
||||
F32 mRadius;
|
||||
Point3F mProbePosOffset;
|
||||
bool mEditPosOffset;
|
||||
|
||||
String mCubemapName;
|
||||
CubemapData *mCubemap;
|
||||
CubemapData *mStaticCubemap;
|
||||
GFXCubemapHandle mDynamicCubemap;
|
||||
bool mUseCubemap;
|
||||
|
||||
//irridiance resources
|
||||
GFXCubemapHandle mIrridianceMap;
|
||||
CubemapData *mIrridianceMap;
|
||||
|
||||
//prefilter resources
|
||||
GFXCubemapHandle mPrefilterMap;
|
||||
CubemapData *mPrefilterMap;
|
||||
U32 mPrefilterMipLevels;
|
||||
U32 mPrefilterSize;
|
||||
|
||||
|
|
@ -190,17 +190,12 @@ public:
|
|||
|
||||
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);
|
||||
static bool _toggleEditPosOffset(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);
|
||||
|
||||
|
|
@ -240,29 +235,9 @@ public:
|
|||
|
||||
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
|
||||
String getPrefilterMapPath();
|
||||
String getIrradianceMapPath();
|
||||
void bake(String outputPath, S32 resolution);
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -59,7 +59,6 @@
|
|||
extern bool gEditingMission;
|
||||
extern ColorI gCanvasClearColor;
|
||||
bool Skylight::smRenderSkylights = true;
|
||||
bool Skylight::smRenderPreviewProbes = true;
|
||||
|
||||
IMPLEMENT_CO_NETOBJECT_V1(Skylight);
|
||||
|
||||
|
|
@ -74,54 +73,16 @@ ConsoleDocClass(Skylight,
|
|||
"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()
|
||||
Skylight::Skylight() : ReflectionProbe()
|
||||
{
|
||||
// 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();
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
|
@ -129,34 +90,6 @@ Skylight::~Skylight()
|
|||
//-----------------------------------------------------------------------------
|
||||
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();
|
||||
}
|
||||
|
|
@ -172,64 +105,16 @@ void Skylight::inspectPostApply()
|
|||
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();
|
||||
}
|
||||
|
||||
|
|
@ -250,39 +135,6 @@ 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;
|
||||
}
|
||||
|
||||
|
|
@ -290,72 +142,6 @@ 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());
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
|
@ -367,18 +153,12 @@ void Skylight::updateProbeParams()
|
|||
if (mProbeInfo == nullptr)
|
||||
return;
|
||||
|
||||
mProbeInfo->mIntensity = 1;
|
||||
|
||||
mProbeInfo->mAmbient = LinearColorF(0, 0, 0, 0);
|
||||
Parent::updateProbeParams();
|
||||
|
||||
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);
|
||||
|
||||
|
|
@ -395,197 +175,12 @@ void Skylight::updateProbeParams()
|
|||
|
||||
setGlobalBounds();
|
||||
|
||||
mProbeInfo->mAmbient = LinearColorF(1, 1, 1, 1);
|
||||
|
||||
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)
|
||||
|
|
@ -606,7 +201,7 @@ void Skylight::prepRenderImage(SceneRenderState *state)
|
|||
|
||||
PROBEMGR->registerSkylight(mProbeInfo, this);
|
||||
|
||||
if (Skylight::smRenderPreviewProbes && gEditingMission && mEditorShapeInst && mCubemap != nullptr)
|
||||
if (Skylight::smRenderPreviewProbes && gEditingMission && mEditorShapeInst && mPrefilterMap != nullptr)
|
||||
{
|
||||
GFXTransformSaver saver;
|
||||
|
||||
|
|
@ -670,230 +265,11 @@ void Skylight::prepRenderImage(SceneRenderState *state)
|
|||
|
||||
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);
|
||||
Parent::setPreviewMatParameters(renderState, mat);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
|
@ -23,8 +23,8 @@
|
|||
#ifndef SKYLIGHT_H
|
||||
#define SKYLIGHT_H
|
||||
|
||||
#ifndef _SCENEOBJECT_H_
|
||||
#include "scene/sceneObject.h"
|
||||
#ifndef REFLECTIONPROBE_H
|
||||
#include "T3D/lighting/reflectionProbe.h"
|
||||
#endif
|
||||
#ifndef _GFXVERTEXBUFFER_H_
|
||||
#include "gfx/gfxVertexBuffer.h"
|
||||
|
|
@ -57,83 +57,14 @@ class BaseMatInstance;
|
|||
// actual setup and rendering for you.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class Skylight : public SceneObject
|
||||
class Skylight : public ReflectionProbe
|
||||
{
|
||||
typedef SceneObject Parent;
|
||||
|
||||
public:
|
||||
|
||||
enum IndrectLightingModeType
|
||||
{
|
||||
NoIndirect = 0,
|
||||
AmbientColor = 1,
|
||||
SphericalHarmonics = 2
|
||||
};
|
||||
|
||||
enum ReflectionModeType
|
||||
{
|
||||
StaticCubemap = 1,
|
||||
BakedCubemap = 2
|
||||
};
|
||||
typedef ReflectionProbe Parent;
|
||||
|
||||
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
|
||||
//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();
|
||||
|
|
@ -156,9 +87,6 @@ public:
|
|||
// 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();
|
||||
|
|
@ -181,32 +109,12 @@ public:
|
|||
// 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_
|
||||
|
|
@ -33,7 +33,7 @@
|
|||
namespace CubemapSaver
|
||||
{
|
||||
// save cubemap handle to a dds cubemap with optional compression
|
||||
bool save(GFXCubemapHandle cubemap, const Torque::Path &path, GFXFormat compressionFormat = GFXFormat_FIRST);
|
||||
bool save(GFXCubemapHandle cubemap, const Torque::Path &path, GFXFormat compressionFormat = GFXFormatR8G8B8A8);
|
||||
|
||||
bool getBitmaps(GFXCubemapHandle cubemap, GFXFormat compressionFormat, GBitmap* faceBitmaps[6]);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -496,7 +496,7 @@ enum GFXTextureTransformFlags
|
|||
|
||||
// CodeReview: This number is used for the declaration of variables, but it
|
||||
// should *not* be used for any run-time purposes [7/2/2007 Pat]
|
||||
#define TEXTURE_STAGE_COUNT 32
|
||||
#define TEXTURE_STAGE_COUNT 16
|
||||
|
||||
enum GFXSamplerState
|
||||
{
|
||||
|
|
|
|||
|
|
@ -55,7 +55,8 @@ ProbeInfo::ProbeInfo()
|
|||
mIrradianceCubemap(NULL),
|
||||
mBRDFTexture(NULL),
|
||||
mRadius(1.0f),
|
||||
mIntensity(1.0f)
|
||||
mIntensity(1.0f),
|
||||
mProbePosOffset(0,0,0)
|
||||
{
|
||||
for (U32 i = 0; i < 5; ++i)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -68,6 +68,7 @@ struct ProbeInfo
|
|||
F32 mIntensity;
|
||||
|
||||
Box3F mBounds;
|
||||
Point3F mProbePosOffset;
|
||||
|
||||
GFXCubemapHandle *mCubemap;
|
||||
|
||||
|
|
|
|||
|
|
@ -487,6 +487,7 @@ struct ProbeRenderInst : public RenderInst
|
|||
F32 mIntensity;
|
||||
|
||||
Box3F mBounds;
|
||||
Point3F mProbePosOffset;
|
||||
|
||||
GFXCubemapHandle *mCubemap;
|
||||
|
||||
|
|
|
|||
|
|
@ -490,6 +490,7 @@ RenderProbeMgr::ReflectProbeMaterialInfo::ReflectProbeMaterialInfo(const String
|
|||
useCubemap = matInstance->getMaterialParameterHandle("$useCubemap");
|
||||
|
||||
cubemap = matInstance->getMaterialParameterHandle("$cubeMap");
|
||||
cubeMips = matInstance->getMaterialParameterHandle("$cubeMips");
|
||||
|
||||
eyePosWorld = matInstance->getMaterialParameterHandle("$eyePosWorld");
|
||||
bbMin = matInstance->getMaterialParameterHandle("$bbMin");
|
||||
|
|
@ -545,7 +546,7 @@ void RenderProbeMgr::ReflectProbeMaterialInfo::setProbeParameters(const ProbeRen
|
|||
|
||||
matParams->setSafe(radius, probeInfo->mRadius);
|
||||
|
||||
Point3F probePos = probeInfo->getPosition();
|
||||
Point3F probePos = probeInfo->getPosition() + probeInfo->mProbePosOffset;
|
||||
//worldViewOnly.mulP(probeInfo->getPosition(), &probePos);
|
||||
matParams->setSafe(probeWSPos, probePos);
|
||||
|
||||
|
|
@ -606,6 +607,10 @@ void RenderProbeMgr::ReflectProbeMaterialInfo::setProbeParameters(const ProbeRen
|
|||
GFX->setTexture(4, NULL);
|
||||
}
|
||||
|
||||
if(probeInfo->mCubemap->isValid())
|
||||
matParams->setSafe(cubeMips, mPow(probeInfo->mCubemap->getPointer()->getMipMapLevels(),2.0f));
|
||||
else
|
||||
matParams->setSafe(cubeMips, F32(0.0));
|
||||
|
||||
matParams->setSafe(eyePosWorld, renderState->getCameraPosition());
|
||||
matParams->setSafe(bbMin, probeInfo->mBounds.minExtents);
|
||||
|
|
@ -659,7 +664,7 @@ bool ReflectProbeMatInstance::setupPass(SceneRenderState *state, const SceneData
|
|||
desc.setZReadWrite(false);
|
||||
desc.zWriteEnable = false;
|
||||
desc.setCullMode(GFXCullNone);
|
||||
desc.setBlend(true, GFXBlendOne, GFXBlendOne);
|
||||
desc.setBlend(true, GFXBlendSrcAlpha, GFXBlendOne);
|
||||
mProjectionState = GFX->createStateBlock(desc);
|
||||
}
|
||||
// Now override stateblock with our own
|
||||
|
|
|
|||
|
|
@ -107,6 +107,7 @@ protected:
|
|||
|
||||
MaterialParameterHandle *useCubemap;
|
||||
MaterialParameterHandle *cubemap;
|
||||
MaterialParameterHandle *cubeMips;
|
||||
|
||||
MaterialParameterHandle *eyePosWorld;
|
||||
MaterialParameterHandle *bbMin;
|
||||
|
|
|
|||
|
|
@ -54,6 +54,24 @@ new ShaderData( AL_DeferredShader )
|
|||
pixVersion = 2.0;
|
||||
};
|
||||
|
||||
new GFXStateBlockData( AL_DeferredCaptureState : PFX_DefaultStateBlock )
|
||||
{
|
||||
blendEnable = false;
|
||||
|
||||
separateAlphaBlendDefined = true;
|
||||
separateAlphaBlendEnable = true;
|
||||
separateAlphaBlendSrc = GFXBlendSrcAlpha;
|
||||
separateAlphaBlendDest = GFXBlendDestAlpha;
|
||||
separateAlphaBlendOp = GFXBlendOpMin;
|
||||
|
||||
samplersDefined = true;
|
||||
samplerStates[0] = SamplerWrapLinear;
|
||||
samplerStates[1] = SamplerWrapLinear;
|
||||
samplerStates[2] = SamplerWrapLinear;
|
||||
samplerStates[3] = SamplerWrapLinear;
|
||||
samplerStates[4] = SamplerWrapLinear;
|
||||
};
|
||||
|
||||
new ShaderData( AL_ProbeShader )
|
||||
{
|
||||
DXVertexShaderFile = "shaders/common/postFx/postFxV.hlsl";
|
||||
|
|
@ -76,7 +94,7 @@ singleton PostEffect( AL_PreCapture )
|
|||
renderTime = "PFXBeforeBin";
|
||||
renderBin = "ProbeBin";
|
||||
shader = AL_ProbeShader;
|
||||
stateBlock = AL_DeferredShadingState;
|
||||
stateBlock = AL_DeferredCaptureState;
|
||||
texture[0] = "#color";
|
||||
texture[1] = "#diffuseLighting";
|
||||
texture[2] = "#matinfo";
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ new GFXStateBlockData( AL_VectorLightState )
|
|||
{
|
||||
blendDefined = true;
|
||||
blendEnable = true;
|
||||
blendSrc = GFXBlendOne;
|
||||
blendSrc = GFXBlendSrcAlpha;
|
||||
blendDest = GFXBlendOne;
|
||||
blendOp = GFXBlendOpAdd;
|
||||
|
||||
|
|
@ -102,7 +102,7 @@ new GFXStateBlockData( AL_ConvexLightState )
|
|||
{
|
||||
blendDefined = true;
|
||||
blendEnable = true;
|
||||
blendSrc = GFXBlendOne;
|
||||
blendSrc = GFXBlendSrcAlpha;
|
||||
blendDest = GFXBlendOne;
|
||||
blendOp = GFXBlendOpAdd;
|
||||
|
||||
|
|
@ -294,7 +294,7 @@ new GFXStateBlockData( AL_ProbeState )
|
|||
{
|
||||
blendDefined = true;
|
||||
blendEnable = true;
|
||||
blendSrc = GFXBlendOne;
|
||||
blendSrc = GFXBlendSrcAlpha;
|
||||
blendDest = GFXBlendOne;
|
||||
blendOp = GFXBlendOpAdd;
|
||||
|
||||
|
|
|
|||
|
|
@ -42,26 +42,29 @@ void main()
|
|||
return;
|
||||
}
|
||||
|
||||
vec3 colorBuffer = texture( colorBufferTex, uv0 ).rgb; //albedo
|
||||
vec3 albedo = texture( colorBufferTex, uv0 ).rgb; //albedo
|
||||
vec4 matInfo = texture( matInfoTex, uv0 ); //flags|smoothness|ao|metallic
|
||||
|
||||
bool emissive = getFlag(matInfo.r, 0);
|
||||
if (emissive)
|
||||
{
|
||||
OUT_col = float4(colorBuffer, 1.0);
|
||||
OUT_col = float4(albedo, 1.0);
|
||||
return;
|
||||
}
|
||||
|
||||
vec4 diffuseLighting = texture( diffuseLightingBuffer, uv0 ); //shadowmap*specular
|
||||
|
||||
vec3 specularLighting = texture( specularLightingBuffer, uv0 ).rgb; //environment mapping*lightmaps
|
||||
vec4 diffuse = texture( diffuseLightingBuffer, uv0 ); //shadowmap*specular
|
||||
vec4 specular = texture( specularLightingBuffer, uv0 ); //environment mapping*lightmaps
|
||||
|
||||
float metalness = matInfo.a;
|
||||
|
||||
float frez = diffuseLighting.a;
|
||||
|
||||
vec3 diffuseColor = colorBuffer - (colorBuffer * metalness);
|
||||
vec3 reflectColor = specularLighting*colorBuffer;
|
||||
colorBuffer = diffuseColor+lerp(reflectColor,specularLighting,frez);
|
||||
colorBuffer *= max(diffuseLighting.rgb,vec3(0,0,0));
|
||||
vec3 diffuseColor = albedo - (albedo * metalness);
|
||||
vec3 specularColor = lerp(float3(0.04,0.04,0.04), albedo, metalness);
|
||||
|
||||
vec3 light = (diffuseColor * diffuse.rgb) + (specularColor * specular.rgb);
|
||||
|
||||
//albedo = diffuseColor+lerp(reflectColor,indiffuseLighting,frez);
|
||||
//albedo *= max(diffuseLighting.rgb,vec3(0,0,0));
|
||||
|
||||
OUT_col = hdrEncode(vec4(colorBuffer,1.0));
|
||||
//OUT_col = hdrEncode(vec4(colorBuffer,1.0));
|
||||
OUT_col = hdrEncode(vec4(light, 1.0));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,34 +33,6 @@ float attenuate( vec4 lightColor, vec2 attParams, float dist )
|
|||
#endif
|
||||
}
|
||||
|
||||
// Calculate the specular coefficent
|
||||
//
|
||||
// pxlToLight - Normalized vector representing direction from the pixel being lit, to the light source, in world space
|
||||
// normal - Normalized surface normal
|
||||
// pxlToEye - Normalized vector representing direction from pixel being lit, to the camera, in world space
|
||||
// specPwr - Specular exponent
|
||||
// specularScale - A scalar on the specular output used in RGB accumulation.
|
||||
//
|
||||
float calcSpecular( vec3 pxlToLight, vec3 normal, vec3 pxlToEye, float specPwr, float specularScale )
|
||||
{
|
||||
#ifdef PHONG_SPECULAR
|
||||
// (R.V)^c
|
||||
float specVal = dot( normalize( -reflect( pxlToLight, normal ) ), pxlToEye );
|
||||
#else
|
||||
// (N.H)^c [Blinn-Phong, TGEA style, default]
|
||||
float specVal = dot( normal, normalize( pxlToLight + pxlToEye ) );
|
||||
#endif
|
||||
|
||||
#ifdef ACCUMULATE_LUV
|
||||
return pow( max( specVal, 0.00001f ), specPwr );
|
||||
#else
|
||||
// If this is RGB accumulation, than there is no facility for the luminance
|
||||
// of the light to play in to the specular intensity. In LUV, the luminance
|
||||
// of the light color gets rolled into N.L * Attenuation
|
||||
return specularScale * pow( max( specVal, 0.00001f ), specPwr );
|
||||
#endif
|
||||
}
|
||||
|
||||
vec3 getDistanceVectorToPlane( vec3 origin, vec3 direction, vec4 plane )
|
||||
{
|
||||
float denum = dot( plane.xyz, direction.xyz );
|
||||
|
|
|
|||
|
|
@ -156,7 +156,6 @@ PS_OUTPUT main(ConvexConnectP IN)
|
|||
bool emissive = getFlag(matInfo.r, 0);
|
||||
if (emissive)
|
||||
{
|
||||
//return float4(0.0, 0.0, 0.0, 0.0);
|
||||
return Output;
|
||||
}
|
||||
|
||||
|
|
@ -274,16 +273,16 @@ PS_OUTPUT main(ConvexConnectP IN)
|
|||
|
||||
//diffuse
|
||||
float disDiff = Fr_DisneyDiffuse(dotNVa, dotNLa, dotLHa, roughness);
|
||||
float3 diffuse = float3(disDiff, disDiff, disDiff) / M_PI_F;// alternative: (lightColor * dotNL) / Pi;
|
||||
//specular
|
||||
float3 diffuse = float3(disDiff, disDiff, disDiff) / M_PI_F;
|
||||
//specular
|
||||
float3 specular = directSpecular(normal, v, l, roughness, 1.0) * lightColor.rgb;
|
||||
|
||||
|
||||
if (nDotL<0) shadowed = 0;
|
||||
float Sat_NL_Att = saturate( nDotL * shadowed ) * lightBrightness;
|
||||
//output
|
||||
Output.diffuse = float4(diffuse * lightBrightness*shadowed, Sat_NL_Att);
|
||||
Output.spec = float4(specular * lightBrightness*shadowed, Sat_NL_Att);
|
||||
Output.diffuse = float4(diffuse * lightBrightness, Sat_NL_Att*shadowed);
|
||||
Output.spec = float4(specular * lightBrightness, Sat_NL_Att*shadowed);
|
||||
|
||||
return Output;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -86,13 +86,13 @@ float3 ImportanceSampleGGX(float2 Xi, float3 N)
|
|||
return normalize(sampleVec);
|
||||
}
|
||||
|
||||
float3 prefilterEnvMap(float3 R)
|
||||
float4 prefilterEnvMap(float3 R)
|
||||
{
|
||||
int sampleCount = resolution*2;
|
||||
float3 N = R;
|
||||
float3 V = R;
|
||||
float totalWeight = 0.0;
|
||||
float3 prefilteredColor = float3(0.0, 0.0, 0.0);
|
||||
float4 prefilteredColor = float4(0.0, 0.0, 0.0, 0.0);
|
||||
|
||||
for (int i = 0; i < sampleCount; ++i)
|
||||
{
|
||||
|
|
@ -114,7 +114,7 @@ float3 prefilterEnvMap(float3 R)
|
|||
|
||||
float mipLevel = roughness == 0.0 ? 0.0 : 0.5 * log2(saSample / saTexel);
|
||||
|
||||
prefilteredColor += TORQUE_TEXCUBELOD(environmentMap, float4(L, mipLevel)).rgb * NdotL;
|
||||
prefilteredColor += TORQUE_TEXCUBELOD(environmentMap, float4(L, mipLevel)) * NdotL;
|
||||
|
||||
totalWeight += NdotL;
|
||||
}
|
||||
|
|
@ -126,5 +126,5 @@ float3 prefilterEnvMap(float3 R)
|
|||
float4 main(ConnectData IN) : TORQUE_TARGET0
|
||||
{
|
||||
float3 N = getCubeDir(face, IN.uv);
|
||||
return float4(prefilterEnvMap(N), 1.0);
|
||||
return prefilterEnvMap(N);
|
||||
}
|
||||
|
|
@ -30,12 +30,14 @@ TORQUE_UNIFORM_SAMPLER2D(matInfoTex,2);
|
|||
TORQUE_UNIFORM_SAMPLER2D(specularLightingBuffer,3);
|
||||
TORQUE_UNIFORM_SAMPLER2D(deferredTex,4);
|
||||
|
||||
uniform float radius;
|
||||
uniform float2 targetSize;
|
||||
uniform int captureRez;
|
||||
float4 main( PFXVertToPix IN) : TORQUE_TARGET0
|
||||
{
|
||||
float depth = TORQUE_DEFERRED_UNCONDITION( deferredTex, IN.uv0 ).w;
|
||||
if (depth>0.9999)
|
||||
return float4(0,0,0,0);
|
||||
|
||||
clip(-1);
|
||||
float3 colorBuffer = TORQUE_TEX2D( colorBufferTex, IN.uv0 ).rgb; //albedo
|
||||
float4 matInfo = TORQUE_TEX2D(matInfoTex, IN.uv0); //flags|smoothness|ao|metallic
|
||||
|
||||
|
|
@ -47,6 +49,12 @@ float4 main( PFXVertToPix IN) : TORQUE_TARGET0
|
|||
|
||||
float4 diffuseLighting = TORQUE_TEX2D( diffuseLightingBuffer, IN.uv0 ); //shadowmap*specular
|
||||
colorBuffer *= diffuseLighting.rgb;
|
||||
float2 relUV = IN.uv0*targetSize/captureRez;
|
||||
|
||||
return hdrEncode( float4(colorBuffer.rgb, 1.0) );
|
||||
//we use a 1k depth range in the capture frustum.
|
||||
//reduce that a bit to get something resembling depth fidelity out of 8 bits
|
||||
depth*=2000/radius;
|
||||
|
||||
float rLen = length(float3(relUV,depth)-float3(0.5,0.5,0));
|
||||
return hdrEncode( float4(colorBuffer,rLen));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 1);
|
|||
TORQUE_UNIFORM_SAMPLERCUBE(cubeMap, 2);
|
||||
TORQUE_UNIFORM_SAMPLERCUBE(irradianceCubemap, 3);
|
||||
TORQUE_UNIFORM_SAMPLER2D(BRDFTexture, 4);
|
||||
uniform float cubeMips;
|
||||
|
||||
uniform float4 rtParams0;
|
||||
|
||||
|
|
@ -36,32 +37,19 @@ uniform float3 bbMax;
|
|||
|
||||
uniform float useSphereMode;
|
||||
|
||||
float3 iblSpecular(float3 v, float3 n, float roughness)
|
||||
{
|
||||
float3 R = reflect(v, n);
|
||||
const float MAX_REFLECTION_LOD = 6.0;
|
||||
float3 prefilteredColor = TORQUE_TEXCUBELOD(cubeMap, float4(R, roughness * MAX_REFLECTION_LOD)).rgb;
|
||||
float2 envBRDF = TORQUE_TEX2D(BRDFTexture, float2(max(dot(n, v), 0.0), roughness)).rg;
|
||||
//return prefilteredColor * (envBRDF.x + envBRDF.y);
|
||||
return prefilteredColor;
|
||||
}
|
||||
|
||||
// Box Projected IBL Lighting
|
||||
// Based on: http://www.gamedev.net/topic/568829-box-projected-cubemap-environment-mapping/
|
||||
|
||||
// and https://seblagarde.wordpress.com/2012/09/29/image-based-lighting-approaches-and-parallax-corrected-cubemap/
|
||||
float3 boxProject(float3 wsPosition, float3 reflectDir, float3 boxWSPos, float3 boxMin, float3 boxMax)
|
||||
{
|
||||
float3 nrdir = normalize(reflectDir);
|
||||
float3 rbmax = (boxMax - wsPosition) / nrdir;
|
||||
float3 rbmin = (boxMin - wsPosition) / nrdir;
|
||||
|
||||
float3 rbminmax;
|
||||
rbminmax.x = (nrdir.x > 0.0) ? rbmax.x : rbmin.x;
|
||||
rbminmax.y = (nrdir.y > 0.0) ? rbmax.y : rbmin.y;
|
||||
rbminmax.z = (nrdir.z > 0.0) ? rbmax.z : rbmin.z;
|
||||
|
||||
float fa = min(min(rbminmax.x, rbminmax.y), rbminmax.z);
|
||||
float3 posonbox = wsPosition + nrdir * fa;
|
||||
float3 nrdir = reflectDir;
|
||||
float3 offset = wsPosition;
|
||||
float3 plane1vec = (boxMax - offset) / nrdir;
|
||||
float3 plane2vec = (boxMin - offset) / nrdir;
|
||||
|
||||
float3 furthestPlane = max(plane1vec, plane2vec);
|
||||
float dist = min(min(furthestPlane.x, furthestPlane.y), furthestPlane.z);
|
||||
float3 posonbox = offset + nrdir * dist;
|
||||
|
||||
return posonbox - boxWSPos;
|
||||
}
|
||||
|
|
@ -83,23 +71,22 @@ float3 iblBoxDiffuse(float3 normal,
|
|||
float3 iblBoxSpecular(float3 normal,
|
||||
float3 wsPos,
|
||||
float roughness,
|
||||
float3 viewDir,
|
||||
float3 surfToEye,
|
||||
TORQUE_SAMPLER2D(brdfTexture),
|
||||
TORQUE_SAMPLERCUBE(radianceCube),
|
||||
float3 boxPos,
|
||||
float3 boxMin,
|
||||
float3 boxMax)
|
||||
{
|
||||
float3 v = viewDir;
|
||||
float3 n = normalize(normal);
|
||||
float ndotv = clamp(dot(n, v), 0.0, 1.0);
|
||||
float ndotv = clamp(dot(normal, surfToEye), 0.0, 1.0);
|
||||
|
||||
// BRDF
|
||||
float2 brdf = TORQUE_TEX2D(brdfTexture, float2(roughness, ndotv)).xy;
|
||||
|
||||
// Radiance (Specular)
|
||||
float lod = roughness * 6.0;
|
||||
float3 r = 2.0 * ndotv * n - v; // reflect(v, n);
|
||||
float maxmip = pow(cubeMips+1,2);
|
||||
float lod = roughness*maxmip;
|
||||
float3 r = reflect(surfToEye, normal);
|
||||
float3 cubeR = normalize(r);
|
||||
cubeR = boxProject(wsPos, cubeR, boxPos, boxMin, boxMax);
|
||||
|
||||
|
|
@ -114,6 +101,57 @@ struct PS_OUTPUT
|
|||
float4 spec: TORQUE_TARGET1;
|
||||
};
|
||||
|
||||
float defineSphereSpaceInfluence(float3 centroidPosVS, float rad, float2 atten, float3 surfPosVS, float3 norm)
|
||||
{
|
||||
// Build light vec, get length, clip pixel if needed
|
||||
float3 lightVec = centroidPosVS - surfPosVS;
|
||||
float lenLightV = length( lightVec );
|
||||
if (( rad - lenLightV )<0)
|
||||
return -1;
|
||||
|
||||
// Get the attenuated falloff.
|
||||
float attn = attenuate( float4(1,1,1,1), atten, lenLightV );
|
||||
if ((attn - 1e-6)<0)
|
||||
return -1;
|
||||
|
||||
// Normalize lightVec
|
||||
lightVec = lightVec /= lenLightV;
|
||||
|
||||
// If we can do dynamic branching then avoid wasting
|
||||
// fillrate on pixels that are backfacing to the light.
|
||||
float nDotL = abs(dot( lightVec, norm ));
|
||||
|
||||
return saturate( nDotL * attn );
|
||||
}
|
||||
|
||||
float defineBoxSpaceInfluence(float3 surfPosWS, float3 probePos, float rad, float2 atten) //atten currently unused
|
||||
{
|
||||
float3 boxMin = probePos-(float3(0.5,0.5,0.5)*rad);
|
||||
float3 boxMax = probePos+(float3(0.5,0.5,0.5)*rad);
|
||||
//Try to clip anything that falls outside our box as well
|
||||
//TODO: Make it support rotated boxes as well
|
||||
if(surfPosWS.x > boxMax.x || surfPosWS.y > boxMax.y || surfPosWS.z > boxMax.z ||
|
||||
surfPosWS.x < boxMin.x || surfPosWS.y < boxMin.y || surfPosWS.z < boxMin.z)
|
||||
return -1;
|
||||
|
||||
float blendVal = 1;
|
||||
//float3 atten = min(boxMax-surfPosWS,surfPosWS-boxMin);
|
||||
//blendVal = min(min(atten.x,atten.y),atten.z);
|
||||
return blendVal;
|
||||
}
|
||||
|
||||
float defineDepthInfluence(float3 probePosWS, float3 surfPosWS, TORQUE_SAMPLERCUBE(radianceCube))
|
||||
{
|
||||
//TODO properly: filter out pixels projected uppon by probes behind walls by looking up the depth stored in the probes cubemap alpha
|
||||
//and comparing legths
|
||||
float3 probeToSurf = probePosWS-surfPosWS;
|
||||
|
||||
float depthRef = TORQUE_TEXCUBELOD(cubeMap, float4(-probeToSurf,0)).a*radius;
|
||||
float dist = length( probeToSurf );
|
||||
|
||||
return depthRef-dist;
|
||||
}
|
||||
|
||||
PS_OUTPUT main( ConvexConnectP IN )
|
||||
{
|
||||
PS_OUTPUT Output = (PS_OUTPUT)0;
|
||||
|
|
@ -121,7 +159,6 @@ PS_OUTPUT main( ConvexConnectP IN )
|
|||
// Compute scene UV
|
||||
float3 ssPos = IN.ssPos.xyz / IN.ssPos.w;
|
||||
|
||||
//float4 hardCodedRTParams0 = float4(0,0.0277777780,1,0.972222209);
|
||||
float2 uvScene = getUVFromSSPos( ssPos, rtParams0 );
|
||||
|
||||
// Matinfo flags
|
||||
|
|
@ -137,10 +174,6 @@ PS_OUTPUT main( ConvexConnectP IN )
|
|||
// Need world-space normal.
|
||||
float3 wsNormal = mul(float4(normal, 1), invViewMat).rgb;
|
||||
|
||||
float4 color = float4(1, 1, 1, 1);
|
||||
float4 ref = float4(0,0,0,0);
|
||||
float alpha = 1;
|
||||
|
||||
float3 eyeRay = getDistanceVectorToPlane( -vsFarPlane.w, IN.vsEyeDir.xyz, vsFarPlane );
|
||||
float3 viewSpacePos = eyeRay * depth;
|
||||
|
||||
|
|
@ -148,70 +181,28 @@ PS_OUTPUT main( ConvexConnectP IN )
|
|||
|
||||
// Use eye ray to get ws pos
|
||||
float3 worldPos = float3(eyePosWorld + wsEyeRay * depth);
|
||||
float smoothness = min((1.0 - matInfo.b)*11.0 + 1.0, 8.0);//bump up to 8 for finalization
|
||||
|
||||
if(useSphereMode)
|
||||
|
||||
float blendVal = 1.0;
|
||||
|
||||
//clip bounds and (TODO properly: set falloff)
|
||||
if(useSphereMode)
|
||||
{
|
||||
// Build light vec, get length, clip pixel if needed
|
||||
float3 lightVec = probeLSPos - viewSpacePos;
|
||||
float lenLightV = length( lightVec );
|
||||
clip( radius - lenLightV );
|
||||
|
||||
// Get the attenuated falloff.
|
||||
float atten = attenuate( float4(1,1,1,1), attenuation, lenLightV );
|
||||
clip( atten - 1e-6 );
|
||||
|
||||
// Normalize lightVec
|
||||
lightVec = normalize(lightVec);
|
||||
|
||||
// If we can do dynamic branching then avoid wasting
|
||||
// fillrate on pixels that are backfacing to the light.
|
||||
float nDotL = abs(dot( lightVec, normal ));
|
||||
|
||||
float Sat_NL_Att = saturate( nDotL * atten );
|
||||
|
||||
float3 reflectionVec = reflect(IN.wsEyeDir, float4(wsNormal,nDotL)).xyz;
|
||||
|
||||
float3 nrdir = normalize(reflectionVec);
|
||||
float3 rbmax = (bbMax - worldPos.xyz) / nrdir;
|
||||
float3 rbmin = (bbMin - worldPos.xyz) / nrdir;
|
||||
|
||||
float3 rbminmax = (nrdir > 0.0) ? rbmax : rbmin;
|
||||
float fa = min(min(rbminmax.x,rbminmax.y),rbminmax.z);
|
||||
if (dot( lightVec, normal )<0.0f)
|
||||
clip(fa);
|
||||
|
||||
float3 posOnBox = worldPos.xyz + nrdir * fa;
|
||||
reflectionVec = posOnBox - probeWSPos;
|
||||
|
||||
reflectionVec = mul(probeWSPos,reflectionVec);
|
||||
|
||||
ref = float4(reflectionVec, smoothness);
|
||||
|
||||
alpha = Sat_NL_Att;
|
||||
float roughness = 1 - matInfo.b;
|
||||
|
||||
float3 irradiance = TORQUE_TEXCUBELOD(irradianceCubemap, ref).rgb;
|
||||
|
||||
float3 specular = TORQUE_TEXCUBELOD(cubeMap, ref).rgb;// iblSpecular(wsEyeRay, wsNormal, roughness);
|
||||
|
||||
Output.diffuse = float4(irradiance.rgb, alpha);
|
||||
Output.spec = float4(specular.rgb, alpha);
|
||||
|
||||
return Output;
|
||||
blendVal = defineSphereSpaceInfluence(probeLSPos, radius, attenuation, viewSpacePos, normal);
|
||||
}
|
||||
else
|
||||
{
|
||||
//Try to clip anything that falls outside our box as well
|
||||
//TODO: Make it support rotated boxes as well
|
||||
if(worldPos.x > bbMax.x || worldPos.y > bbMax.y || worldPos.z > bbMax.z ||
|
||||
worldPos.x < bbMin.x || worldPos.y < bbMin.y || worldPos.z < bbMin.z)
|
||||
clip(-1);
|
||||
|
||||
float blendVal = 1.0;
|
||||
float3 pixDir = normalize(eyePosWorld.xyz - worldPos.xyz);
|
||||
Output.diffuse = float4(iblBoxDiffuse(wsNormal, worldPos, TORQUE_SAMPLERCUBE_MAKEARG(irradianceCubemap), probeWSPos, bbMin, bbMax), blendVal);
|
||||
Output.spec = float4(iblBoxSpecular(wsNormal, worldPos, 1.0 - matInfo.b, pixDir, TORQUE_SAMPLER2D_MAKEARG(BRDFTexture), TORQUE_SAMPLERCUBE_MAKEARG(cubeMap), probeWSPos, bbMin, bbMax), blendVal);
|
||||
return Output;
|
||||
blendVal = defineBoxSpaceInfluence(worldPos, probeWSPos, radius*2, attenuation);
|
||||
}
|
||||
clip(blendVal);
|
||||
|
||||
//flip me on to have probes filter by depth
|
||||
//clip(defineDepthInfluence(probeWSPos, worldPos, TORQUE_SAMPLERCUBE_MAKEARG(cubeMap)));
|
||||
|
||||
|
||||
//render into the bound space defined above
|
||||
float3 surfToEye = normalize(worldPos.xyz-eyePosWorld.xyz);
|
||||
Output.diffuse = float4(iblBoxDiffuse(wsNormal, worldPos, TORQUE_SAMPLERCUBE_MAKEARG(irradianceCubemap), probeWSPos, bbMin, bbMax), blendVal);
|
||||
Output.spec = float4(iblBoxSpecular(wsNormal, worldPos, 1.0 - matInfo.b, surfToEye, TORQUE_SAMPLER2D_MAKEARG(BRDFTexture), TORQUE_SAMPLERCUBE_MAKEARG(cubeMap), probeWSPos, bbMin, bbMax), blendVal);
|
||||
|
||||
return Output;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -73,8 +73,15 @@ uniform float4x4 dynamicViewToLightProj;
|
|||
uniform float2 lightAttenuation;
|
||||
uniform float shadowSoftness;
|
||||
|
||||
float4 main( ConvexConnectP IN ) : TORQUE_TARGET0
|
||||
struct PS_OUTPUT
|
||||
{
|
||||
float4 diffuse: TORQUE_TARGET0;
|
||||
float4 spec: TORQUE_TARGET1;
|
||||
};
|
||||
|
||||
PS_OUTPUT main( ConvexConnectP IN ) : TORQUE_TARGET0
|
||||
{
|
||||
PS_OUTPUT Output = (PS_OUTPUT)0;
|
||||
// Compute scene UV
|
||||
float3 ssPos = IN.ssPos.xyz / IN.ssPos.w;
|
||||
float2 uvScene = getUVFromSSPos( ssPos, rtParams0 );
|
||||
|
|
@ -85,7 +92,7 @@ float4 main( ConvexConnectP IN ) : TORQUE_TARGET0
|
|||
bool emissive = getFlag(matInfo.r, 0);
|
||||
if (emissive)
|
||||
{
|
||||
return float4(0.0, 0.0, 0.0, 0.0);
|
||||
return Output;
|
||||
}
|
||||
|
||||
float4 colorSample = TORQUE_TEX2D( colorBuffer, uvScene );
|
||||
|
|
@ -181,36 +188,31 @@ float4 main( ConvexConnectP IN ) : TORQUE_TARGET0
|
|||
// NOTE: Do not clip on fully shadowed pixels as it would
|
||||
// cause the hardware occlusion query to disable the shadow.
|
||||
|
||||
// Specular term
|
||||
float specular = 0;
|
||||
float3 l = normalize(-lightDirection);
|
||||
float3 v = eyeRay;// normalize(eyePosWorld - worldPos.xyz);
|
||||
|
||||
float3 h = normalize(v + l);
|
||||
float dotNLa = clamp(dot(normal, l), 0.0, 1.0);
|
||||
float dotNVa = clamp(dot(normal, v), 0.0, 1.0);
|
||||
float dotNHa = clamp(dot(normal, h), 0.0, 1.0);
|
||||
float dotHVa = clamp(dot(normal, v), 0.0, 1.0);
|
||||
float dotLHa = clamp(dot(l, h), 0.0, 1.0);
|
||||
|
||||
float roughness = matInfo.g;
|
||||
float metalness = matInfo.b;
|
||||
|
||||
//diffuse
|
||||
float disDiff = Fr_DisneyDiffuse(dotNVa, dotNLa, dotLHa, roughness);
|
||||
float3 diffuse = float3(disDiff, disDiff, disDiff) / M_PI_F;
|
||||
//specular
|
||||
float3 specular = directSpecular(normal, v, l, roughness, 1.0) * lightColor.rgb;
|
||||
|
||||
float3 lightVec = lightPosition - viewSpacePos;
|
||||
float4 real_specular = EvalBDRF( float3( 1.0, 1.0, 1.0 ),
|
||||
lightcol,
|
||||
lightVec,
|
||||
viewSpacePos,
|
||||
normal,
|
||||
1.0-matInfo.b,
|
||||
matInfo.a );
|
||||
float3 lightColorOut = real_specular.rgb * lightBrightness * shadowed* atten;
|
||||
|
||||
float Sat_NL_Att = saturate( nDotL * atten * shadowed ) * lightBrightness;
|
||||
float4 addToResult = 0.0;
|
||||
if (nDotL<0) shadowed = 0;
|
||||
float Sat_NL_Att = saturate( nDotL * shadowed ) * lightBrightness;
|
||||
//output
|
||||
Output.diffuse = float4(diffuse * lightBrightness, Sat_NL_Att*shadowed);
|
||||
Output.spec = float4(specular * lightBrightness, Sat_NL_Att*shadowed);
|
||||
|
||||
// TODO: This needs to be removed when lightmapping is disabled
|
||||
// as its extra work per-pixel on dynamic lit scenes.
|
||||
//
|
||||
// Special lightmapping pass.
|
||||
if ( lightMapParams.a < 0.0 )
|
||||
{
|
||||
// This disables shadows on the backsides of objects.
|
||||
shadowed = nDotL < 0.0f ? 1.0f : shadowed;
|
||||
|
||||
Sat_NL_Att = 1.0f;
|
||||
shadowed = lerp( 1.0f, shadowed, atten );
|
||||
lightColorOut = shadowed;
|
||||
specular *= lightBrightness;
|
||||
addToResult = ( 1.0 - shadowed ) * abs(lightMapParams);
|
||||
}
|
||||
return float4((lightColorOut*Sat_NL_Att+subsurface*(1.0-Sat_NL_Att)+addToResult.rgb),real_specular.a);
|
||||
return Output;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -314,8 +314,8 @@ PS_OUTPUT main(FarFrustumQuadConnectP IN)
|
|||
float finalShadowed = shadowed;
|
||||
|
||||
//output
|
||||
Output.diffuse = float4(diffuse * (lightBrightness*shadowed), dotNLa);
|
||||
Output.spec = float4(specular * (lightBrightness*shadowed), dotNLa);
|
||||
Output.diffuse = float4(diffuse * (lightBrightness), dotNLa*shadowed);
|
||||
Output.spec = float4(specular * (lightBrightness), dotNLa*shadowed);
|
||||
|
||||
return Output;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue