diff --git a/Engine/source/T3D/lighting/boxEnvironmentProbe.cpp b/Engine/source/T3D/lighting/boxEnvironmentProbe.cpp new file mode 100644 index 000000000..23d58d1e7 --- /dev/null +++ b/Engine/source/T3D/lighting/boxEnvironmentProbe.cpp @@ -0,0 +1,232 @@ +//----------------------------------------------------------------------------- +// 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/boxEnvironmentProbe.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 "T3D/gameFunctions.h" +#include "postFx/postEffect.h" +#include "renderInstance/renderProbeMgr.h" +#include "renderInstance/renderProbeMgr.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; + +IMPLEMENT_CO_NETOBJECT_V1(BoxEnvironmentProbe); + +ConsoleDocClass(BoxEnvironmentProbe, + "@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"); + +//----------------------------------------------------------------------------- +// Object setup and teardown +//----------------------------------------------------------------------------- +BoxEnvironmentProbe::BoxEnvironmentProbe() : ReflectionProbe() +{ + mCaptureMask = REFLECTION_PROBE_CAPTURE_TYPEMASK; +} + +BoxEnvironmentProbe::~BoxEnvironmentProbe() +{ +} + +//----------------------------------------------------------------------------- +// Object Editing +//----------------------------------------------------------------------------- +void BoxEnvironmentProbe::initPersistFields() +{ + // SceneObject already handles exposing the transform + Parent::initPersistFields(); +} + +void BoxEnvironmentProbe::inspectPostApply() +{ + Parent::inspectPostApply(); + + mDirty = true; + + // Flag the network mask to send the updates + // to the client object + setMaskBits(-1); +} + +bool BoxEnvironmentProbe::onAdd() +{ + if (!Parent::onAdd()) + return false; + + return true; +} + +void BoxEnvironmentProbe::onRemove() +{ + Parent::onRemove(); +} + +void BoxEnvironmentProbe::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 BoxEnvironmentProbe::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); + + return retMask; +} + +void BoxEnvironmentProbe::unpackUpdate(NetConnection *conn, BitStream *stream) +{ + // Let the Parent read any info it sent + Parent::unpackUpdate(conn, stream); +} + +//----------------------------------------------------------------------------- +// Object Rendering +//----------------------------------------------------------------------------- + +void BoxEnvironmentProbe::updateProbeParams() +{ + Parent::updateProbeParams(); + + mProbeInfo->mProbeShapeType = ProbeRenderInst::Box; +} + +void BoxEnvironmentProbe::prepRenderImage(SceneRenderState *state) +{ + if (!mEnabled || !ReflectionProbe::smRenderPreviewProbes) + return; + + //special hook-in for BoxEnvironmentProbes + Point3F camPos = state->getCameraPosition(); + mProbeInfo->mBounds.setCenter(camPos); + + mProbeInfo->setPosition(camPos); + + if (ReflectionProbe::smRenderPreviewProbes && gEditingMission && mEditorShapeInst && mPrefilterMap != 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 BoxEnvironmentProbe::setPreviewMatParameters(SceneRenderState* renderState, BaseMatInstance* mat) +{ + Parent::setPreviewMatParameters(renderState, mat); +} \ No newline at end of file diff --git a/Engine/source/T3D/lighting/boxEnvironmentProbe.h b/Engine/source/T3D/lighting/boxEnvironmentProbe.h new file mode 100644 index 000000000..742472f97 --- /dev/null +++ b/Engine/source/T3D/lighting/boxEnvironmentProbe.h @@ -0,0 +1,116 @@ +//----------------------------------------------------------------------------- +// 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 BOX_ENVIRONMENT_PROBE_H +#define BOX_ENVIRONMENT_PROBE_H + +#ifndef REFLECTIONPROBE_H +#include "T3D/lighting/reflectionProbe.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 + +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 BoxEnvironmentProbe : public ReflectionProbe +{ + typedef ReflectionProbe Parent; + +private: + + //Debug rendering + static bool smRenderPreviewProbes; + +public: + BoxEnvironmentProbe(); + virtual ~BoxEnvironmentProbe(); + + // Declare this object as a ConsoleObject so that we can + // instantiate it into the world and network it + DECLARE_CONOBJECT(BoxEnvironmentProbe); + + //-------------------------------------------------------------------------- + // 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(); + + // 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. + //-------------------------------------------------------------------------- + virtual 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); +}; + +#endif // BOX_ENVIRONMENT_PROBE_H \ No newline at end of file diff --git a/Engine/source/T3D/lighting/reflectionProbe.cpp b/Engine/source/T3D/lighting/reflectionProbe.cpp index 218b26c81..10bc07abc 100644 --- a/Engine/source/T3D/lighting/reflectionProbe.cpp +++ b/Engine/source/T3D/lighting/reflectionProbe.cpp @@ -51,6 +51,8 @@ #include "gfx/gfxTextureManager.h" #include "T3D/lighting/IBLUtilities.h" +#include "scene/reflector.h" + extern bool gEditingMission; extern ColorI gCanvasClearColor; bool ReflectionProbe::smRenderPreviewProbes = true; @@ -75,14 +77,6 @@ ImplementEnumType(ReflectProbeType, { ProbeRenderInst::Box, "Box", "Box shape" } EndImplementEnumType; -ImplementEnumType(IndrectLightingModeEnum, - "Type of mesh data available in a shape.\n" - "@ingroup gameObjects") -{ ReflectionProbe::NoIndirect, "No Lighting", "This probe does not provide any local indirect lighting data" }, -{ ReflectionProbe::AmbientColor, "Ambient Color", "Adds a flat color to act as the local indirect lighting" }, -{ ReflectionProbe::SphericalHarmonics, "Spherical Harmonics", "Creates spherical harmonics data based off the reflection data" }, - EndImplementEnumType; - ImplementEnumType(ReflectionModeEnum, "Type of mesh data available in a shape.\n" "@ingroup gameObjects") @@ -105,8 +99,6 @@ ReflectionProbe::ReflectionProbe() mProbeShapeType = ProbeRenderInst::Box; - mIndrectLightingModeType = NoIndirect; - mReflectionModeType = BakedCubemap; mEnabled = true; @@ -119,7 +111,6 @@ ReflectionProbe::ReflectionProbe() mUseHDRCaptures = true; mStaticCubemap = NULL; - mReflectionPath = ""; mProbeUniqueID = ""; mEditorShapeInst = NULL; @@ -168,9 +159,7 @@ void ReflectionProbe::initPersistFields() addProtectedField("enabled", TypeBool, Offset(mEnabled, ReflectionProbe), &_setEnabled, &defaultProtectedGetFn, "Regenerate Voxel Grid"); - addField("ProbeShape", TypeReflectProbeType, Offset(mProbeShapeType, ReflectionProbe), - "The type of mesh data to use for collision queries."); - addField("radius", TypeF32, Offset(mRadius, ReflectionProbe), "The name of the material used to render the mesh."); + addField("radius", TypeF32, Offset(mRadius, ReflectionProbe), "The name of the material used to render the mesh."); addField("posOffset", TypePoint3F, Offset(mProbePosOffset, ReflectionProbe), ""); //addProtectedField("EditPosOffset", TypeBool, Offset(mEditPosOffset, ReflectionProbe), @@ -181,9 +170,6 @@ void ReflectionProbe::initPersistFields() addField("ReflectionMode", TypeReflectionModeEnum, Offset(mReflectionModeType, ReflectionProbe), "The type of mesh data to use for collision queries."); - addField("reflectionPath", TypeImageFilename, Offset(mReflectionPath, ReflectionProbe), - "The type of mesh data to use for collision queries."); - addField("StaticCubemap", TypeCubemapName, Offset(mCubemapName, ReflectionProbe), "Cubemap used instead of reflection texture if fullReflect is off."); addProtectedField("Bake", TypeBool, Offset(mBake, ReflectionProbe), @@ -236,7 +222,7 @@ bool ReflectionProbe::_doBake(void *object, const char *index, const char *data) if (clientProbe) { - clientProbe->bake(clientProbe->mReflectionPath, 64); + clientProbe->bake(); } return false; @@ -361,7 +347,6 @@ U32 ReflectionProbe::packUpdate(NetConnection *conn, U32 mask, BitStream *stream if (stream->writeFlag(mask & BakeInfoMask)) { - stream->write(mReflectionPath); stream->write(mProbeUniqueID); } @@ -372,7 +357,6 @@ U32 ReflectionProbe::packUpdate(NetConnection *conn, U32 mask, BitStream *stream if (stream->writeFlag(mask & ModeMask)) { - stream->write((U32)mIndrectLightingModeType); stream->write((U32)mReflectionModeType); } @@ -416,7 +400,6 @@ void ReflectionProbe::unpackUpdate(NetConnection *conn, BitStream *stream) if (stream->readFlag()) // BakeInfoMask { - stream->read(&mReflectionPath); stream->read(&mProbeUniqueID); } @@ -429,10 +412,6 @@ void ReflectionProbe::unpackUpdate(NetConnection *conn, BitStream *stream) if (stream->readFlag()) // ModeMask { - U32 indirectModeType = AmbientColor; - stream->read(&indirectModeType); - mIndrectLightingModeType = (IndrectLightingModeType)indirectModeType; - U32 reflectModeType = BakedCubemap; stream->read(&reflectModeType); mReflectionModeType = (ReflectionModeType)reflectModeType; @@ -461,6 +440,8 @@ void ReflectionProbe::unpackUpdate(NetConnection *conn, BitStream *stream) { updateMaterial(); } + + //PROBEMGR->updateProbes(); } void ReflectionProbe::createGeometry() @@ -484,7 +465,6 @@ void ReflectionProbe::createGeometry() //----------------------------------------------------------------------------- // Object Rendering //----------------------------------------------------------------------------- - void ReflectionProbe::updateProbeParams() { if (mProbeInfo == nullptr) @@ -496,19 +476,11 @@ void ReflectionProbe::updateProbeParams() updateMaterial(); - mProbeInfo->mAmbient = LinearColorF(0, 0, 0, 0); - mProbeInfo->mProbeShapeType = mProbeShapeType; mProbeInfo->mTransform = getWorldTransform(); - mProbeInfo->mTransform.inverse(); - mProbeInfo->setPosition(getPosition()); - //Point3F pos = mProbeInfo->mTransform.getPosition(); - - //Update the bounds - //mObjBox.minExtents.set(-1, -1, -1); - //mObjBox.maxExtents.set(1, 1, 1); + mProbeInfo->mPosition = getPosition(); mObjScale.set(mRadius, mRadius, mRadius); @@ -584,6 +556,8 @@ void ReflectionProbe::updateMaterial() if (mReflectionModeType != DynamicCubemap) { + mProbeInfo->mCubeReflector.unregisterReflector(); + if ((mReflectionModeType == BakedCubemap) && !mProbeUniqueID.isEmpty()) { if (mPrefilterMap != nullptr && mPrefilterMap->mCubemap.isValid()) @@ -609,6 +583,8 @@ void ReflectionProbe::updateMaterial() if (mReflectionModeType == DynamicCubemap && !mDynamicCubemap.isNull()) { mProbeInfo->mCubemap = mDynamicCubemap; + + mProbeInfo->mCubeReflector.registerReflector(this, reflectorDesc); //need to decide how we wanna do the reflectorDesc. static name or a field } else { @@ -616,11 +592,6 @@ void ReflectionProbe::updateMaterial() } } - if (mBrdfTexture.isValid()) - { - mProbeInfo->mBRDFTexture = &mBrdfTexture; - } - //Make us ready to render if (mEnabled) mProbeInfo->mIsEnabled = true; @@ -668,15 +639,6 @@ bool ReflectionProbe::createClientResources() if (mPrefilterMap->mCubemap.isNull()) Con::errorf("ReflectionProbe::createClientResources() - Unable to load baked prefilter map at %s", getPrefilterMapPath().c_str()); - //brdf lookup texture - String brdfPath = Con::getVariable("$Core::BRDFTexture", "core/art/pbr/brdfTexture.dds"); - mBrdfTexture = TEXMGR->createTexture(brdfPath, &GFXTexturePersistentProfile); - - if (!mBrdfTexture) - { - return false; - } - mResourcesCreated = true; return true; @@ -703,7 +665,7 @@ void ReflectionProbe::prepRenderImage(SceneRenderState *state) if (mReflectionModeType == DynamicCubemap && mRefreshRateMS < (Platform::getRealMilliseconds() - mDynamicLastBakeMS)) { - bake("", 32); + bake(); mDynamicLastBakeMS = Platform::getRealMilliseconds(); } @@ -870,244 +832,53 @@ DefineEngineMethod(ReflectionProbe, postApply, void, (), , String ReflectionProbe::getPrefilterMapPath() { - if (mReflectionPath.isEmpty() || mProbeUniqueID.isEmpty()) + if (mProbeUniqueID.isEmpty()) { Con::errorf("ReflectionProbe::getPrefilterMapPath() - We don't have a set output path or persistant id, so no valid path can be provided!"); return ""; } + String path = Con::getVariable("$pref::ReflectionProbes::CurrentLevelPath", "levels/"); + char fileName[256]; - dSprintf(fileName, 256, "%s%s_Prefilter.dds", mReflectionPath.c_str(), mProbeUniqueID.c_str()); + dSprintf(fileName, 256, "%s%s_Prefilter.dds", path.c_str(), mProbeUniqueID.c_str()); return fileName; } String ReflectionProbe::getIrradianceMapPath() { - if (mReflectionPath.isEmpty() || mProbeUniqueID.isEmpty()) + if (mProbeUniqueID.isEmpty()) { Con::errorf("ReflectionProbe::getIrradianceMapPath() - We don't have a set output path or persistant id, so no valid path can be provided!"); return ""; } + String path = Con::getVariable("$pref::ReflectionProbes::CurrentLevelPath", "levels/"); + char fileName[256]; - dSprintf(fileName, 256, "%s%s_Irradiance.dds", mReflectionPath.c_str(), mProbeUniqueID.c_str()); + dSprintf(fileName, 256, "%s%s_Irradiance.dds", path.c_str(), mProbeUniqueID.c_str()); return fileName; } -void ReflectionProbe::bake(String outputPath, S32 resolution, bool renderWithProbes) +void ReflectionProbe::bake() { - GFXDEBUGEVENT_SCOPE(ReflectionProbe_Bake, ColorI::WHITE); + if (mReflectionModeType == DynamicCubemap) + return; - Con::warnf("ReflectionProbe::bake() - Beginning bake!"); + PROBEMGR->bakeProbe(this); - U32 startMSTime = Platform::getRealMilliseconds(); - - /*PostEffect *preCapture = dynamic_cast(Sim::findObject("AL_PreCapture")); - PostEffect *deferredShading = dynamic_cast(Sim::findObject("AL_DeferredShading")); - if (preCapture) - { - preCapture->setShaderConst("$radius",String::ToString(mRadius)); - preCapture->setShaderConst("$captureRez", String::ToString(F32(resolution))); - preCapture->enable(); - } - if (deferredShading) - deferredShading->disable();*/ - - GFXCubemapHandle sceneCaptureCubemap; - - if (mReflectionModeType == DynamicCubemap && mDynamicCubemap.isNull()) - { - //mCubemap->createMap(); - mDynamicCubemap = GFX->createCubemap(); - - if(mUseHDRCaptures) - mDynamicCubemap->initDynamic(resolution, GFXFormatR16G16B16A16F); - else - mDynamicCubemap->initDynamic(resolution, GFXFormatB8G8R8A8); - - sceneCaptureCubemap = mDynamicCubemap; - } - else if (mReflectionModeType != DynamicCubemap) - { - //Prep our bake path - if (mReflectionPath.isEmpty()) - { - Con::errorf("ReflectionProbe::bake() - Unable to bake our captures because probe doesn't have a path set"); - return; - } - - if (mProbeUniqueID.isEmpty()) - { - Con::errorf("ReflectionProbe::bake() - Unable to bake our captures because probe doesn't have a unique ID set"); - return; - } - - sceneCaptureCubemap = GFX->createCubemap(); - - if (mUseHDRCaptures) - sceneCaptureCubemap->initDynamic(resolution, GFXFormatR16G16B16A16F); - else - sceneCaptureCubemap->initDynamic(resolution, GFXFormatR8G8B8A8); - } - - 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 = RenderProbeMgr::smRenderReflectionProbes; - - if (!renderWithProbes) - RenderProbeMgr::smRenderReflectionProbes = false; - - for (U32 i = 0; i < 6; ++i) - { - GFXTexHandle blendTex; - blendTex.set(resolution, resolution, GFXFormatR16G16B16A16F, &GFXRenderTargetProfile, ""); - - GFXTextureTargetRef baseTarget = GFX->allocRenderToTextureTarget(); - - GFX->clearTextureStateImmediate(0); - - baseTarget->attachTexture(GFXTextureTarget::Color0, sceneCaptureCubemap, i); - - // 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()+mProbePosOffset); - 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); - - F32 detailAdjustBackup = TSShapeInstance::smDetailAdjust; - TSShapeInstance::smDetailAdjust *= getNextPow2(resolution); - renderFrame(&baseTarget, matView, frustum, mCaptureMask & EDITOR_RENDER_TYPEMASK, gCanvasClearColor); - TSShapeInstance::smDetailAdjust = detailAdjustBackup; - - baseTarget->resolve(); - } - - if (sceneCaptureCubemap.isValid()) - { - validCubemap = true; - mDirty = false; - } - else - { - validCubemap = false; - } - - //Now, save out the maps - //create irridiance cubemap - if (validCubemap) - { - bool se = isServerObject(); - - //Just to ensure we're prepped for the generation - createClientResources(); - - //Prep it with whatever resolution we've dictated for our bake - if (mUseHDRCaptures) - { - mIrridianceMap->mCubemap->initDynamic(resolution, GFXFormatR16G16B16A16F); - mPrefilterMap->mCubemap->initDynamic(resolution, GFXFormatR16G16B16A16F); - } - else - { - mIrridianceMap->mCubemap->initDynamic(resolution, GFXFormatR8G8B8A8); - mPrefilterMap->mCubemap->initDynamic(resolution, GFXFormatR8G8B8A8); - } - - //IBLUtilities::GenerateAndSaveIrradianceMap(getIrradianceMapPath(), resolution, sceneCaptureCubemap, mIrridianceMap->mCubemap); - //IBLUtilities::GenerateAndSavePrefilterMap(getPrefilterMapPath(), resolution, sceneCaptureCubemap, mPrefilterMipLevels, mPrefilterMap->mCubemap); - - GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget(false); - - IBLUtilities::GenerateIrradianceMap(renderTarget, sceneCaptureCubemap, mIrridianceMap->mCubemap); - IBLUtilities::GeneratePrefilterMap(renderTarget, sceneCaptureCubemap, mPrefilterMipLevels, mPrefilterMap->mCubemap); - - IBLUtilities::SaveCubeMap(getIrradianceMapPath(), mIrridianceMap->mCubemap); - IBLUtilities::SaveCubeMap(getPrefilterMapPath(), mPrefilterMap->mCubemap); - } - else - { - Con::errorf("ReflectionProbe::bake() - Didn't generate a valid scene capture cubemap, unable to generate prefilter and irradiance maps!"); - } - - if(!renderWithProbes) - RenderProbeMgr::smRenderReflectionProbes = probeRenderState; - - setMaskBits(-1); - - /*if (preCapture) - preCapture->disable(); - if (deferredShading) - deferredShading->enable();*/ - - U32 endMSTime = Platform::getRealMilliseconds(); - F32 diffTime = F32(endMSTime - startMSTime); - - Con::warnf("ReflectionProbe::bake() - Finished bake! Took %g milliseconds", diffTime); + setMaskBits(CubemapMask); } -DefineEngineMethod(ReflectionProbe, Bake, void, (String outputPath, S32 resolution, bool renderWithProbes), ("", 64, false), +DefineEngineMethod(ReflectionProbe, Bake, void, (), , "@brief returns true if control object is inside the fog\n\n.") { ReflectionProbe *clientProbe = (ReflectionProbe*)object->getClientObject(); if (clientProbe) { - clientProbe->bake(outputPath, resolution, renderWithProbes); + clientProbe->bake(); } - //object->bake(outputPath, resolution); } \ No newline at end of file diff --git a/Engine/source/T3D/lighting/reflectionProbe.h b/Engine/source/T3D/lighting/reflectionProbe.h index db4bf4d7a..8155c5696 100644 --- a/Engine/source/T3D/lighting/reflectionProbe.h +++ b/Engine/source/T3D/lighting/reflectionProbe.h @@ -47,7 +47,6 @@ 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 @@ -60,16 +59,10 @@ class BaseMatInstance; class ReflectionProbe : public SceneObject { typedef SceneObject Parent; + friend class RenderProbeMgr; public: - enum IndrectLightingModeType - { - NoIndirect = 0, - AmbientColor = 1, - SphericalHarmonics = 2 - }; - enum ReflectionModeType { NoReflection = 0, @@ -114,9 +107,6 @@ protected: ProbeRenderInst* mProbeInfo; U32 mProbeInfoIdx; - //Indirect Lighting Contribution stuff - IndrectLightingModeType mIndrectLightingModeType; - //Reflection Contribution stuff ReflectionModeType mReflectionModeType; @@ -129,6 +119,10 @@ protected: GFXCubemapHandle mDynamicCubemap; bool mUseCubemap; + String cubeDescName; + U32 cubeDescId; + ReflectorDesc *reflectorDesc; + ///Prevents us from saving out the cubemaps(for now) but allows us the full HDR range on the in-memory cubemap captures bool mUseHDRCaptures; @@ -140,10 +134,6 @@ protected: 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 @@ -246,7 +236,7 @@ public: //Baking String getPrefilterMapPath(); String getIrradianceMapPath(); - void bake(String outputPath, S32 resolution, bool renderWithProbes = false); + void bake(); const U32 getProbeInfoIndex() { return mProbeInfoIdx; } }; @@ -254,9 +244,6 @@ public: typedef ProbeRenderInst::ProbeShapeType ReflectProbeType; DefineEnumType(ReflectProbeType); -typedef ReflectionProbe::IndrectLightingModeType IndrectLightingModeEnum; -DefineEnumType(IndrectLightingModeEnum); - typedef ReflectionProbe::ReflectionModeType ReflectionModeEnum; DefineEnumType(ReflectionModeEnum); diff --git a/Engine/source/T3D/lighting/skylight.cpp b/Engine/source/T3D/lighting/skylight.cpp index 010634a31..20564222e 100644 --- a/Engine/source/T3D/lighting/skylight.cpp +++ b/Engine/source/T3D/lighting/skylight.cpp @@ -171,8 +171,6 @@ void Skylight::updateProbeParams() setGlobalBounds(); - mProbeInfo->mAmbient = LinearColorF(1, 1, 1, 1); - mProbeInfo->mIsSkylight = true; mProbeInfo->mScore = -1.0f; //sky comes first } diff --git a/Engine/source/T3D/lighting/sphereEnvironmentProbe.cpp b/Engine/source/T3D/lighting/sphereEnvironmentProbe.cpp new file mode 100644 index 000000000..a0edafb50 --- /dev/null +++ b/Engine/source/T3D/lighting/sphereEnvironmentProbe.cpp @@ -0,0 +1,232 @@ +//----------------------------------------------------------------------------- +// 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/sphereEnvironmentProbe.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 "T3D/gameFunctions.h" +#include "postFx/postEffect.h" +#include "renderInstance/renderProbeMgr.h" +#include "renderInstance/renderProbeMgr.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; + +IMPLEMENT_CO_NETOBJECT_V1(SphereEnvironmentProbe); + +ConsoleDocClass(SphereEnvironmentProbe, + "@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"); + +//----------------------------------------------------------------------------- +// Object setup and teardown +//----------------------------------------------------------------------------- +SphereEnvironmentProbe::SphereEnvironmentProbe() : ReflectionProbe() +{ + mCaptureMask = REFLECTION_PROBE_CAPTURE_TYPEMASK; +} + +SphereEnvironmentProbe::~SphereEnvironmentProbe() +{ +} + +//----------------------------------------------------------------------------- +// Object Editing +//----------------------------------------------------------------------------- +void SphereEnvironmentProbe::initPersistFields() +{ + // SceneObject already handles exposing the transform + Parent::initPersistFields(); +} + +void SphereEnvironmentProbe::inspectPostApply() +{ + Parent::inspectPostApply(); + + mDirty = true; + + // Flag the network mask to send the updates + // to the client object + setMaskBits(-1); +} + +bool SphereEnvironmentProbe::onAdd() +{ + if (!Parent::onAdd()) + return false; + + return true; +} + +void SphereEnvironmentProbe::onRemove() +{ + Parent::onRemove(); +} + +void SphereEnvironmentProbe::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 SphereEnvironmentProbe::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); + + return retMask; +} + +void SphereEnvironmentProbe::unpackUpdate(NetConnection *conn, BitStream *stream) +{ + // Let the Parent read any info it sent + Parent::unpackUpdate(conn, stream); +} + +//----------------------------------------------------------------------------- +// Object Rendering +//----------------------------------------------------------------------------- + +void SphereEnvironmentProbe::updateProbeParams() +{ + Parent::updateProbeParams(); + + mProbeInfo->mProbeShapeType = ProbeRenderInst::Sphere; +} + +void SphereEnvironmentProbe::prepRenderImage(SceneRenderState *state) +{ + if (!mEnabled || !ReflectionProbe::smRenderPreviewProbes) + return; + + //special hook-in for SphereEnvironmentProbes + Point3F camPos = state->getCameraPosition(); + mProbeInfo->mBounds.setCenter(camPos); + + mProbeInfo->setPosition(camPos); + + if (ReflectionProbe::smRenderPreviewProbes && gEditingMission && mEditorShapeInst && mPrefilterMap != 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 SphereEnvironmentProbe::setPreviewMatParameters(SceneRenderState* renderState, BaseMatInstance* mat) +{ + Parent::setPreviewMatParameters(renderState, mat); +} \ No newline at end of file diff --git a/Engine/source/T3D/lighting/sphereEnvironmentProbe.h b/Engine/source/T3D/lighting/sphereEnvironmentProbe.h new file mode 100644 index 000000000..59c602cc3 --- /dev/null +++ b/Engine/source/T3D/lighting/sphereEnvironmentProbe.h @@ -0,0 +1,111 @@ +//----------------------------------------------------------------------------- +// 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 SPHERE_ENVIRONMENT_PROBE_H +#define SPHERE_ENVIRONMENT_PROBE_H + +#ifndef REFLECTIONPROBE_H +#include "T3D/lighting/reflectionProbe.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 + +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 SphereEnvironmentProbe : public ReflectionProbe +{ + typedef ReflectionProbe Parent; + +public: + SphereEnvironmentProbe(); + virtual ~SphereEnvironmentProbe(); + + // Declare this object as a ConsoleObject so that we can + // instantiate it into the world and network it + DECLARE_CONOBJECT(SphereEnvironmentProbe); + + //-------------------------------------------------------------------------- + // 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(); + + // 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. + //-------------------------------------------------------------------------- + virtual 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); +}; + +#endif // SPHERE_ENVIRONMENT_PROBE_H \ No newline at end of file diff --git a/Engine/source/postFx/postEffect.cpp b/Engine/source/postFx/postEffect.cpp index 4054554f0..f93333d16 100644 --- a/Engine/source/postFx/postEffect.cpp +++ b/Engine/source/postFx/postEffect.cpp @@ -170,6 +170,57 @@ void PostEffect::EffectConst::set( const String &newVal ) mStringVal = newVal; mDirty = true; + mValueType = StringType; +} + +void PostEffect::EffectConst::set(const F32 &newVal) +{ + if (mFloatVal == newVal) + return; + + mFloatVal = newVal; + mDirty = true; + mValueType = FloatType; +} + +void PostEffect::EffectConst::set(const Point4F &newVal) +{ + if (mPointVal == newVal) + return; + + mPointVal = newVal; + mDirty = true; + mValueType = PointType; +} + +void PostEffect::EffectConst::set(const MatrixF &newVal) +{ + if (mMatrixVal == newVal) + return; + + mMatrixVal = newVal; + mDirty = true; + mValueType = MatrixType; +} + +void PostEffect::EffectConst::set(const Vector &newVal) +{ + //if (mPointArrayVal == newVal) + // return; + + mPointArrayVal = newVal; + mDirty = true; + mValueType = PointArrayType; +} + +void PostEffect::EffectConst::set(const Vector &newVal) +{ + //if (mMatrixArrayVal == newVal) + // return; + + mMatrixArrayVal = newVal; + mDirty = true; + mValueType = MatrixArrayType; } void PostEffect::EffectConst::setToBuffer( GFXShaderConstBufferRef buff ) @@ -194,71 +245,179 @@ void PostEffect::EffectConst::setToBuffer( GFXShaderConstBufferRef buff ) // Expand to other types as necessary. U32 arraySize = mHandle->getArraySize(); - const char *strVal = mStringVal.c_str(); + if (mValueType == StringType) + { + const char *strVal = mStringVal.c_str(); - if ( type == GFXSCT_Int ) - { - S32 val; - Con::setData( TypeS32, &val, 0, 1, &strVal ); - buff->set( mHandle, val ); - } - else if ( type == GFXSCT_Float ) - { - F32 val; - Con::setData( TypeF32, &val, 0, 1, &strVal ); - buff->set( mHandle, val ); - } - else if ( type == GFXSCT_Float2 ) - { - Point2F val; - Con::setData( TypePoint2F, &val, 0, 1, &strVal ); - buff->set( mHandle, val ); - } - else if ( type == GFXSCT_Float3 ) - { - Point3F val; - Con::setData( TypePoint3F, &val, 0, 1, &strVal ); - buff->set( mHandle, val ); - } - else if ( type == GFXSCT_Float4 ) - { - Point4F val; - - if ( arraySize > 1 ) + if (type == GFXSCT_Int) { - // Do array setup! - //U32 unitCount = StringUnit::getUnitCount( strVal, "\t" ); - //AssertFatal( unitCount == arraySize, "" ); + S32 val; + Con::setData(TypeS32, &val, 0, 1, &strVal); + buff->set(mHandle, val); + } + else if (type == GFXSCT_Float) + { + F32 val; + Con::setData(TypeF32, &val, 0, 1, &strVal); + buff->set(mHandle, val); + } + else if (type == GFXSCT_Float2) + { + Point2F val; + Con::setData(TypePoint2F, &val, 0, 1, &strVal); + buff->set(mHandle, val); + } + else if (type == GFXSCT_Float3) + { + Point3F val; + Con::setData(TypePoint3F, &val, 0, 1, &strVal); + buff->set(mHandle, val); + } + else if (type == GFXSCT_Float4) + { + Point4F val; - String tmpString; - Vector valArray; - - for ( U32 i = 0; i < arraySize; i++ ) + if (arraySize > 1) { - tmpString = StringUnit::getUnit( strVal, i, "\t" ); - valArray.increment(); - const char *tmpCStr = tmpString.c_str(); + // Do array setup! + //U32 unitCount = StringUnit::getUnitCount( strVal, "\t" ); + //AssertFatal( unitCount == arraySize, "" ); - Con::setData( TypePoint4F, &valArray.last(), 0, 1, &tmpCStr ); + String tmpString; + Vector valArray; + + for (U32 i = 0; i < arraySize; i++) + { + tmpString = StringUnit::getUnit(strVal, i, "\t"); + valArray.increment(); + const char *tmpCStr = tmpString.c_str(); + + Con::setData(TypePoint4F, &valArray.last(), 0, 1, &tmpCStr); + } + + AlignedArray rectData(valArray.size(), sizeof(Point4F), (U8*)valArray.address(), false); + buff->set(mHandle, rectData); + } + else + { + // Do regular setup. + Con::setData(TypePoint4F, &val, 0, 1, &strVal); + buff->set(mHandle, val); } - - AlignedArray rectData( valArray.size(), sizeof( Point4F ), (U8*)valArray.address(), false ); - buff->set( mHandle, rectData ); } else { - // Do regular setup. - Con::setData( TypePoint4F, &val, 0, 1, &strVal ); - buff->set( mHandle, val ); +#if TORQUE_DEBUG + const char* err = avar("PostEffect::EffectConst::setToBuffer $s type is not implemented", mName.c_str()); + Con::errorf(err); + GFXAssertFatal(0, err); +#endif } } - else + else if (mValueType == FloatType) { + if (type == GFXSCT_Float) + { + buff->set(mHandle, mFloatVal); + } + else + { #if TORQUE_DEBUG - const char* err = avar("PostEffect::EffectConst::setToBuffer $s type is not implemented", mName.c_str()); - Con::errorf(err); - GFXAssertFatal(0,err); + const char* err = avar("PostEffect::EffectConst::setToBuffer $s type is not implemented", mName.c_str()); + Con::errorf(err); + GFXAssertFatal(0, err); #endif + } + } + else if (mValueType == PointType) + { + if (type == GFXSCT_Float2) + { + buff->set(mHandle, Point2F(mPointVal.x, mPointVal.y)); + } + else if (type == GFXSCT_Float3) + { + buff->set(mHandle, Point3F(mPointVal.x, mPointVal.y, mPointVal.z)); + } + else if (type == GFXSCT_Float4) + { + buff->set(mHandle, mPointVal); + } + else + { +#if TORQUE_DEBUG + const char* err = avar("PostEffect::EffectConst::setToBuffer $s type is not implemented", mName.c_str()); + Con::errorf(err); + GFXAssertFatal(0, err); +#endif + } + } + else if (mValueType == MatrixType) + { + if (type == GFXSCT_Float4x4) + { + buff->set(mHandle, mMatrixVal); + } + else + { + #if TORQUE_DEBUG + const char* err = avar("PostEffect::EffectConst::setToBuffer $s type is not implemented", mName.c_str()); + Con::errorf(err); + GFXAssertFatal(0, err); + #endif + } + } + else if (mValueType == PointArrayType) + { + if (type == GFXSCT_Float4) + { + if (arraySize != mPointArrayVal.size()) + { + #if TORQUE_DEBUG + const char* err = avar("PostEffect::EffectConst::setToBuffer PointArrayType, attempted to feed an array that does not match the uniform array's size!"); + Con::errorf(err); + GFXAssertFatal(0, err); + #endif + return; + } + + AlignedArray alignedVal = AlignedArray(arraySize, sizeof(Point4F), (U8*)mPointArrayVal.address(), false); + + buff->set(mHandle, alignedVal); + } + else + { + #if TORQUE_DEBUG + const char* err = avar("PostEffect::EffectConst::setToBuffer $s type is not implemented", mName.c_str()); + Con::errorf(err); + GFXAssertFatal(0, err); + #endif + } + } + else if (mValueType == MatrixArrayType) + { + if (type == GFXSCT_Float4x4) + { + if (arraySize != mMatrixArrayVal.size()) + { + #if TORQUE_DEBUG + const char* err = avar("PostEffect::EffectConst::setToBuffer MatrixArrayType, attempted to feed an array that does not match the uniform array's size!"); + Con::errorf(err); + GFXAssertFatal(0, err); + #endif + return; + } + + buff->set(mHandle, mMatrixArrayVal.address(), arraySize); + } + else + { + #if TORQUE_DEBUG + const char* err = avar("PostEffect::EffectConst::setToBuffer $s type is not implemented", mName.c_str()); + Con::errorf(err); + GFXAssertFatal(0, err); + #endif + } } } @@ -413,6 +572,8 @@ bool PostEffect::onAdd() // Find additional textures for( S32 i = 0; i < NumTextures; i++ ) { + mTextureType[i] = NormalTextureType; + String texFilename = mTexFilename[i]; // Skip empty stages or ones with variable or target names. @@ -915,6 +1076,11 @@ void PostEffect::_setupConstants( const SceneRenderState *state ) setShaderConsts_callback(); } + if (mShaderName == String("PFX_ReflectionProbeArray") || getName() == StringTable->insert("reflectionProbeArrayPostFX")) + { + bool derp = true; + } + EffectConstTable::Iterator iter = mEffectConsts.begin(); for ( ; iter != mEffectConsts.end(); iter++ ) iter->value->setToBuffer( mShaderConsts ); @@ -972,6 +1138,30 @@ void PostEffect::_setupTexture( U32 stage, GFXTexHandle &inputTex, const RectI * GFX->setTexture( stage, theTex ); } +void PostEffect::_setupCubemapTexture(U32 stage, GFXCubemapHandle &inputTex) +{ + RectI viewport = GFX->getViewport(); + + mActiveTextures[stage] = nullptr; + mActiveNamedTarget[stage] = nullptr; + mActiveTextureViewport[stage] = viewport; + + if (inputTex.isValid()) + GFX->setCubeTexture(stage, inputTex); +} + +void PostEffect::_setupCubemapArrayTexture(U32 stage, GFXCubemapArrayHandle &inputTex) +{ + RectI viewport = GFX->getViewport(); + + mActiveTextures[stage] = nullptr; + mActiveNamedTarget[stage] = nullptr; + mActiveTextureViewport[stage] = viewport; + + if (inputTex.isValid()) + GFX->setCubeArrayTexture(stage, inputTex); +} + void PostEffect::_setupTransforms() { // Set everything to identity. @@ -1188,8 +1378,15 @@ void PostEffect::process( const SceneRenderState *state, GFXTransformSaver saver; // Set the textures. - for ( U32 i = 0; i < NumTextures; i++ ) - _setupTexture( i, inOutTex, inTexViewport ); + for (U32 i = 0; i < NumTextures; i++) + { + if (mTextureType[i] == NormalTextureType) + _setupTexture(i, inOutTex, inTexViewport); + else if (mTextureType[i] == CubemapType) + _setupCubemapTexture(i, mCubemapTextures[i]); + else if (mTextureType[i] == CubemapArrayType) + _setupCubemapArrayTexture(i, mCubemapArrayTextures[i]); + } _setupStateBlock( state ) ; _setupTransforms(); @@ -1406,6 +1603,38 @@ void PostEffect::setTexture( U32 index, const String &texFilePath ) // Try to load the texture. mTextures[index].set( texFilePath, &PostFxTextureProfile, avar( "%s() - (line %d)", __FUNCTION__, __LINE__ ) ); + + mTextureType[index] = NormalTextureType; +} + +void PostEffect::setCubemapTexture(U32 index, const GFXCubemapHandle &cubemapHandle) +{ + // Set the new texture name. + mCubemapTextures[index].free(); + + // Skip empty stages or ones with variable or target names. + if (cubemapHandle.isNull()) + return; + + // Try to load the texture. + mCubemapTextures[index] = cubemapHandle; + + mTextureType[index] = CubemapType; +} + +void PostEffect::setCubemapArrayTexture(U32 index, const GFXCubemapArrayHandle &cubemapArrayHandle) +{ + // Set the new texture name. + mCubemapArrayTextures[index].free(); + + // Skip empty stages or ones with variable or target names. + if (cubemapArrayHandle.isNull()) + return; + + // Try to load the texture. + mCubemapArrayTextures[index] = cubemapArrayHandle; + + mTextureType[index] = CubemapArrayType; } void PostEffect::setShaderConst( const String &name, const String &val ) @@ -1422,6 +1651,76 @@ void PostEffect::setShaderConst( const String &name, const String &val ) iter->value->set( val ); } +void PostEffect::setShaderConst(const String &name, const F32 &val) +{ + PROFILE_SCOPE(PostEffect_SetShaderConst_Float); + + EffectConstTable::Iterator iter = mEffectConsts.find(name); + if (iter == mEffectConsts.end()) + { + EffectConst *newConst = new EffectConst(name, val); + iter = mEffectConsts.insertUnique(name, newConst); + } + + iter->value->set(val); +} + +void PostEffect::setShaderConst(const String &name, const Point4F &val) +{ + PROFILE_SCOPE(PostEffect_SetShaderConst_Point); + + EffectConstTable::Iterator iter = mEffectConsts.find(name); + if (iter == mEffectConsts.end()) + { + EffectConst *newConst = new EffectConst(name, val); + iter = mEffectConsts.insertUnique(name, newConst); + } + + iter->value->set(val); +} + +void PostEffect::setShaderConst(const String &name, const MatrixF &val) +{ + PROFILE_SCOPE(PostEffect_SetShaderConst_Matrix); + + EffectConstTable::Iterator iter = mEffectConsts.find(name); + if (iter == mEffectConsts.end()) + { + EffectConst *newConst = new EffectConst(name, val); + iter = mEffectConsts.insertUnique(name, newConst); + } + + iter->value->set(val); +} + +void PostEffect::setShaderConst(const String &name, const Vector &val) +{ + PROFILE_SCOPE(PostEffect_SetShaderConst_PointArray); + + EffectConstTable::Iterator iter = mEffectConsts.find(name); + if (iter == mEffectConsts.end()) + { + EffectConst *newConst = new EffectConst(name, val); + iter = mEffectConsts.insertUnique(name, newConst); + } + + iter->value->set(val); +} + +void PostEffect::setShaderConst(const String &name, const Vector &val) +{ + PROFILE_SCOPE(PostEffect_SetShaderConst_MatrixArray); + + EffectConstTable::Iterator iter = mEffectConsts.find(name); + if (iter == mEffectConsts.end()) + { + EffectConst *newConst = new EffectConst(name, val); + iter = mEffectConsts.insertUnique(name, newConst); + } + + iter->value->set(val); +} + F32 PostEffect::getAspectRatio() const { const Point2I &rtSize = GFX->getActiveRenderTarget()->getSize(); @@ -1434,6 +1733,11 @@ void PostEffect::_checkRequirements() // properly, we can find all the input textures, // and its formats are supported. + if (mShaderName == String("PFX_ReflectionProbeArray") || getName() == StringTable->insert("reflectionProbeArrayPostFX")) + { + bool derp = true; + } + mIsValid = false; mUpdateShader = false; mShader = NULL; @@ -1468,16 +1772,21 @@ void PostEffect::_checkRequirements() // they exist... else we're invalid. for ( U32 i=0; i < NumTextures; i++ ) { - const String &texFilename = mTexFilename[i]; - - if ( texFilename.isNotEmpty() && texFilename[0] == '#' ) + if (mTextureType[i] == NormalTextureType) { - NamedTexTarget *namedTarget = NamedTexTarget::find( texFilename.c_str() + 1 ); - if ( !namedTarget ) - return; + const String &texFilename = mTexFilename[i]; - // Grab the macros for shader initialization. - namedTarget->getShaderMacros( ¯os ); + if (texFilename.isNotEmpty() && texFilename[0] == '#') + { + NamedTexTarget *namedTarget = NamedTexTarget::find(texFilename.c_str() + 1); + if (!namedTarget) + { + return; + } + + // Grab the macros for shader initialization. + namedTarget->getShaderMacros(¯os); + } } } diff --git a/Engine/source/postFx/postEffect.h b/Engine/source/postFx/postEffect.h index 53ee0b1d5..377336a9e 100644 --- a/Engine/source/postFx/postEffect.h +++ b/Engine/source/postFx/postEffect.h @@ -41,6 +41,9 @@ #ifndef _GFXTEXTUREHANDLE_H_ #include "gfx/gfxTextureHandle.h" #endif +#ifndef _GFXCUBEMAP_H_ +#include "gfx/gfxCubemap.h" +#endif #ifndef _GFXTARGET_H_ #include "gfx/gfxTarget.h" #endif @@ -88,7 +91,16 @@ protected: FileName mTexFilename[NumTextures]; bool mTexSRGB[NumTextures]; + enum + { + NormalTextureType = 0, + CubemapType, + CubemapArrayType, + } mTextureType[NumTextures]; + GFXTexHandle mTextures[NumTextures]; + GFXCubemapHandle mCubemapTextures[NumTextures]; + GFXCubemapArrayHandle mCubemapArrayTextures[NumTextures]; NamedTexTarget mNamedTarget; NamedTexTarget mNamedTargetDepthStencil; @@ -210,7 +222,52 @@ protected: set( val ); } + EffectConst(const String &name, const F32 &val) + : mName(name), + mHandle(NULL), + mDirty(true) + { + set(val); + } + + EffectConst(const String &name, const Point4F &val) + : mName(name), + mHandle(NULL), + mDirty(true) + { + set(val); + } + + EffectConst(const String &name, const MatrixF &val) + : mName(name), + mHandle(NULL), + mDirty(true) + { + set(val); + } + + EffectConst(const String &name, const Vector &val) + : mName(name), + mHandle(NULL), + mDirty(true) + { + set(val); + } + + EffectConst(const String &name, const Vector &val) + : mName(name), + mHandle(NULL), + mDirty(true) + { + set(val); + } + void set( const String &newVal ); + void set(const F32 &newVal); + void set(const Point4F &newVal); + void set(const MatrixF &newVal); + void set(const Vector &newVal); + void set(const Vector &newVal); void setToBuffer( GFXShaderConstBufferRef buff ); @@ -220,6 +277,23 @@ protected: String mStringVal; + F32 mFloatVal; + Point4F mPointVal; + MatrixF mMatrixVal; + + Vector mPointArrayVal; + Vector mMatrixArrayVal; + + enum + { + StringType, + FloatType, + PointType, + MatrixType, + PointArrayType, + MatrixArrayType + } mValueType; + bool mDirty; }; @@ -245,6 +319,9 @@ protected: /// virtual void _setupTexture( U32 slot, GFXTexHandle &inputTex, const RectI *inTexViewport ); + virtual void _setupCubemapTexture(U32 stage, GFXCubemapHandle &inputTex); + virtual void _setupCubemapArrayTexture(U32 slot, GFXCubemapArrayHandle &inputTex); + /// Protected set method for toggling the enabled state. static bool _setIsEnabled( void *object, const char *index, const char *data ); @@ -339,6 +416,8 @@ public: F32 getPriority() const { return mRenderPriority; } void setTexture( U32 index, const String &filePath ); + void setCubemapTexture(U32 index, const GFXCubemapHandle &cubemapHandle); + void setCubemapArrayTexture(U32 index, const GFXCubemapArrayHandle &cubemapArrayHandle); void setShaderMacro( const String &name, const String &value = String::EmptyString ); bool removeShaderMacro( const String &name ); @@ -346,6 +425,11 @@ public: /// void setShaderConst( const String &name, const String &val ); + void setShaderConst(const String &name, const F32 &val); + void setShaderConst(const String &name, const Point4F &val); + void setShaderConst(const String &name, const MatrixF &val); + void setShaderConst(const String &name, const Vector &val); + void setShaderConst(const String &name, const Vector &val); void setOnThisFrame( bool enabled ) { mOnThisFrame = enabled; } bool isOnThisFrame() { return mOnThisFrame; } @@ -353,6 +437,10 @@ public: bool isOneFrameOnly() { return mOneFrameOnly; } F32 getAspectRatio() const; + + GFXShaderRef getShader() { return mShader; } + Vector* getShaderMacros() { return &mShaderMacros; } + GFXShaderConstBufferRef getShaderConstBuffer() { return mShaderConsts; } enum PostEffectRequirements diff --git a/Engine/source/renderInstance/renderProbeMgr.cpp b/Engine/source/renderInstance/renderProbeMgr.cpp index f30827d77..f5d3504d3 100644 --- a/Engine/source/renderInstance/renderProbeMgr.cpp +++ b/Engine/source/renderInstance/renderProbeMgr.cpp @@ -36,6 +36,14 @@ #include "materials/shaderData.h" #include "gfx/gfxTextureManager.h" + +#include "postFx/postEffect.h" +#include "T3D/lighting/reflectionProbe.h" +#include "T3D/lighting/IBLUtilities.h" + +//For our cameraQuery setup +#include "T3D/gameTSCtrl.h" + IMPLEMENT_CONOBJECT(RenderProbeMgr); ConsoleDocClass( RenderProbeMgr, @@ -66,22 +74,13 @@ S32 QSORT_CALLBACK AscendingReflectProbeInfluence(const void* a, const void* b) ProbeRenderInst::ProbeRenderInst() : SystemInterface(), mTransform(true), mDirty(false), - mAmbient(0.0f, 0.0f, 0.0f, 1.0f), mPriority(1.0f), mScore(0.0f), - mDebugRender(false), mCubemap(NULL), mIrradianceCubemap(NULL), - mBRDFTexture(NULL), mRadius(1.0f), - mIntensity(1.0f), - mProbePosOffset(0, 0, 0), - numPrims(0) + mProbePosOffset(0, 0, 0) { - for (U32 i = 0; i < 5; ++i) - { - mSHConstants[i] = 0; - } } ProbeRenderInst::~ProbeRenderInst() @@ -94,46 +93,22 @@ ProbeRenderInst::~ProbeRenderInst() { mIrradianceCubemap.free(); } - if (mBRDFTexture && mBRDFTexture->isValid()) - { - mBRDFTexture->free(); - } } void ProbeRenderInst::set(const ProbeRenderInst *probeInfo) { mTransform = probeInfo->mTransform; - mAmbient = probeInfo->mAmbient; mCubemap = probeInfo->mCubemap; mIrradianceCubemap = probeInfo->mIrradianceCubemap; - mBRDFTexture = probeInfo->mBRDFTexture; mRadius = probeInfo->mRadius; - mIntensity = probeInfo->mIntensity; mProbeShapeType = probeInfo->mProbeShapeType; - numPrims = probeInfo->numPrims; - numVerts = probeInfo->numVerts; - numIndicesForPoly = probeInfo->numIndicesForPoly; mBounds = probeInfo->mBounds; mIsSkylight = probeInfo->mIsSkylight; mScore = probeInfo->mScore; - - for (U32 i = 0; i < 9; i++) - { - mSHTerms[i] = probeInfo->mSHTerms[i]; - } - - for (U32 i = 0; i < 5; i++) - { - mSHConstants[i] = probeInfo->mSHConstants[i]; - } -} - -void ProbeRenderInst::getWorldToLightProj(MatrixF *outMatrix) const -{ - *outMatrix = getTransform(); - outMatrix->inverse(); } +// +// ProbeShaderConstants::ProbeShaderConstants() : mInit(false), mShader(NULL), @@ -190,83 +165,19 @@ void ProbeShaderConstants::_onShaderReload() init(mShader); } -// -// -bool ReflectProbeMatInstance::init(const FeatureSet &features, const GFXVertexFormat *vertexFormat) -{ - mShaderMat = nullptr; - - bool success = Parent::init(features, vertexFormat); - - // If the initialization failed don't continue. - if (!success || !mProcessedMaterial || mProcessedMaterial->getNumPasses() == 0) - return false; - - mShaderMat = static_cast(getShaderMaterial()); - mShaderMat->init(features, vertexFormat, mFeaturesDelegate); - - //mShaderMat->setMaterialParameters(mDefaultParameters, 0); - - return true; -} - -bool ReflectProbeMatInstance::setupPass(SceneRenderState *state, const SceneData &sgData) -{ - if (!Parent::setupPass(state, sgData)) - return false; - - AssertFatal(mProcessedMaterial->getNumPasses() > 0, "No passes created! Ohnoes"); - const RenderPassData *rpd = mProcessedMaterial->getPass(0); - AssertFatal(rpd, "No render pass data!"); - AssertFatal(rpd->mRenderStates[0], "No render state 0!"); - - if (!mProjectionState) - { - GFXStateBlockDesc desc; - desc.setZReadWrite(false); - desc.zWriteEnable = false; - desc.setCullMode(GFXCullNone); - desc.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvDestAlpha, GFXBlendOpAdd); - mProjectionState = GFX->createStateBlock(desc); - } - // Now override stateblock with our own - GFX->setStateBlock(mProjectionState); - - return true; -} - // // RenderProbeMgr::RenderProbeMgr() : RenderBinManager(RenderPassManager::RIT_Probes, 1.0f, 1.0f), - mReflectProbeMaterial(nullptr), - mSceneManager(nullptr), mLastShader(nullptr), mLastConstants(nullptr) { - String brdfPath = Con::getVariable("$Core::BRDFTexture", "core/art/pbr/brdfTexture.dds"); - mBrdfTexture = TEXMGR->createTexture(brdfPath, &GFXTexturePersistentProfile); + mEffectiveProbeCount = 0; + mMipCount = 0; - probePositions.setSize(MAXPROBECOUNT); - probePositions.fill(Point3F::Zero); + mProbeArrayEffect = nullptr; - probeWorldToObj.setSize(MAXPROBECOUNT); - probeWorldToObj.fill(MatrixF::Identity); - - probeBBMin.setSize(MAXPROBECOUNT); - probeBBMin.fill(Point3F::Zero); - - probeBBMax.setSize(MAXPROBECOUNT); - probeBBMax.fill(Point3F::Zero); - - probeUseSphereMode.setSize(MAXPROBECOUNT); - probeUseSphereMode.fill(0.0f); - - probeRadius.setSize(MAXPROBECOUNT); - probeRadius.fill(0.0f); - - probeAttenuation.setSize(MAXPROBECOUNT); - probeAttenuation.fill(0.0f); + smProbeManager = this; } RenderProbeMgr::RenderProbeMgr(RenderInstType riType, F32 renderOrder, F32 processAddOrder) @@ -274,6 +185,12 @@ RenderProbeMgr::RenderProbeMgr(RenderInstType riType, F32 renderOrder, F32 proce { } +void RenderProbeMgr::onRemove() +{ + SAFE_DELETE(mLastConstants); + + Parent::onRemove(); +} void RenderProbeMgr::initPersistFields() { Parent::initPersistFields(); @@ -311,6 +228,35 @@ void RenderProbeMgr::registerProbe(U32 probeIdx) return; mRegisteredProbes.push_back_unique(probeIdx); + + //rebuild our probe data + //_setupStaticParameters(); +} + +void RenderProbeMgr::unregisterProbe(U32 probeIdx) +{ + //Mostly for consolidation, but also lets us sanity check or prep any other data we need for rendering this in one place at time of flagging for render + if (probeIdx >= ProbeRenderInst::all.size()) + return; + + mRegisteredProbes.remove(probeIdx); + + //rebuild our probe data + //_setupStaticParameters(); +} + +// +// +PostEffect* RenderProbeMgr::getProbeArrayEffect() +{ + if (!mProbeArrayEffect) + { + mProbeArrayEffect = dynamic_cast(Sim::findObject("reflectionProbeArrayPostFX")); + + if (!mProbeArrayEffect) + return nullptr; + } + return mProbeArrayEffect; } //remove @@ -318,78 +264,97 @@ void RenderProbeMgr::registerProbe(U32 probeIdx) //Con::setIntVariable("lightMetrics::culledReflectProbes", 0/*mNumLightsCulled*/); // -void RenderProbeMgr::_setupPerFrameParameters(const SceneRenderState *state) +void RenderProbeMgr::updateProbes() { - PROFILE_SCOPE(RenderProbeMgr_SetupPerFrameParameters); - const Frustum &frustum = state->getCameraFrustum(); + _setupStaticParameters(); +} - MatrixF invCam(frustum.getTransform()); - invCam.inverse(); +void RenderProbeMgr::_setupStaticParameters() +{ + //Array rendering + U32 probeCount = ProbeRenderInst::all.size(); - const Point3F *wsFrustumPoints = frustum.getPoints(); - const Point3F& cameraPos = frustum.getPosition(); + mEffectiveProbeCount = 0; + mMipCount = 0; - // Perform a camera offset. We need to manually perform this offset on the sun (or vector) light's - // polygon, which is at the far plane. - Point3F cameraOffsetPos = cameraPos; - - // Now build the quad for drawing full-screen vector light - // passes.... this is a volatile VB and updates every frame. - FarFrustumQuadVert verts[4]; + if (probePositionsData.size() != MAXPROBECOUNT) { - verts[0].point.set(wsFrustumPoints[Frustum::FarTopLeft] - cameraPos); - invCam.mulP(wsFrustumPoints[Frustum::FarTopLeft], &verts[0].normal); - verts[0].texCoord.set(-1.0, 1.0); - verts[0].tangent.set(wsFrustumPoints[Frustum::FarTopLeft] - cameraOffsetPos); - - verts[1].point.set(wsFrustumPoints[Frustum::FarTopRight] - cameraPos); - invCam.mulP(wsFrustumPoints[Frustum::FarTopRight], &verts[1].normal); - verts[1].texCoord.set(1.0, 1.0); - verts[1].tangent.set(wsFrustumPoints[Frustum::FarTopRight] - cameraOffsetPos); - - verts[2].point.set(wsFrustumPoints[Frustum::FarBottomLeft] - cameraPos); - invCam.mulP(wsFrustumPoints[Frustum::FarBottomLeft], &verts[2].normal); - verts[2].texCoord.set(-1.0, -1.0); - verts[2].tangent.set(wsFrustumPoints[Frustum::FarBottomLeft] - cameraOffsetPos); - - verts[3].point.set(wsFrustumPoints[Frustum::FarBottomRight] - cameraPos); - invCam.mulP(wsFrustumPoints[Frustum::FarBottomRight], &verts[3].normal); - verts[3].texCoord.set(1.0, -1.0); - verts[3].tangent.set(wsFrustumPoints[Frustum::FarBottomRight] - cameraOffsetPos); + probePositionsData.setSize(MAXPROBECOUNT); + probeWorldToObjData.setSize(MAXPROBECOUNT); + probeBBMinData.setSize(MAXPROBECOUNT); + probeBBMaxData.setSize(MAXPROBECOUNT); + probeUseSphereModeData.setSize(MAXPROBECOUNT); + probeRadiusData.setSize(MAXPROBECOUNT); + probeAttenuationData.setSize(MAXPROBECOUNT); } - mFarFrustumQuadVerts.set(GFX, 4); - dMemcpy(mFarFrustumQuadVerts.lock(), verts, sizeof(verts)); - mFarFrustumQuadVerts.unlock(); + probePositionsData.fill(Point4F::Zero); + probeWorldToObjData.fill(MatrixF::Identity); + probeBBMinData.fill(Point4F::Zero); + probeBBMaxData.fill(Point4F::Zero); + probeUseSphereModeData.fill(Point4F::Zero); + probeRadiusData.fill(Point4F::Zero); + probeAttenuationData.fill(Point4F::Zero); - PlaneF farPlane(wsFrustumPoints[Frustum::FarBottomLeft], wsFrustumPoints[Frustum::FarTopLeft], wsFrustumPoints[Frustum::FarTopRight]); - PlaneF vsFarPlane(verts[0].normal, verts[1].normal, verts[2].normal); + cubeMaps.clear(); + irradMaps.clear(); - ReflectProbeMaterialInfo* reflProbeMat = getReflectProbeMaterial(); - - if (reflProbeMat != nullptr && reflProbeMat->matInstance != nullptr) + for (U32 i = 0; i < probeCount; i++) { - reflProbeMat->setViewParameters(frustum.getNearDist(), - frustum.getFarDist(), - frustum.getPosition(), - farPlane, - vsFarPlane); + if (mEffectiveProbeCount >= MAXPROBECOUNT) + break; + + const ProbeRenderInst& curEntry = *ProbeRenderInst::all[i]; + if (!curEntry.mIsEnabled) + continue; + + if (curEntry.mCubemap.isNull() || curEntry.mIrradianceCubemap.isNull()) + continue; + + if (!curEntry.mCubemap->isInitialised()) + continue; + + if (!curEntry.mIrradianceCubemap->isInitialised()) + continue; + + if (curEntry.mIsSkylight) + continue; + + mMipCount = curEntry.mCubemap.getPointer()->getMipMapLevels(); + + //Setup + Point3F probePos = curEntry.getPosition() + curEntry.mProbePosOffset; + probePositionsData[mEffectiveProbeCount] = Point4F(probePos.x, probePos.y, probePos.z,0); + + probeWorldToObjData[mEffectiveProbeCount] = curEntry.getTransform(); + + probeBBMinData[mEffectiveProbeCount] = Point4F(curEntry.mBounds.minExtents.x, curEntry.mBounds.minExtents.y, curEntry.mBounds.minExtents.z, 0); + probeBBMaxData[mEffectiveProbeCount] = Point4F(curEntry.mBounds.maxExtents.x, curEntry.mBounds.maxExtents.y, curEntry.mBounds.maxExtents.z, 0); + + probeUseSphereModeData[mEffectiveProbeCount] = Point4F(curEntry.mProbeShapeType == ProbeRenderInst::Sphere ? 1 : 0, 0,0,0); + + probeRadiusData[mEffectiveProbeCount] = Point4F(curEntry.mRadius,0,0,0); + probeAttenuationData[mEffectiveProbeCount] = Point4F(1, 0, 0, 0); + + cubeMaps.push_back(curEntry.mCubemap); + irradMaps.push_back(curEntry.mIrradianceCubemap); + + mEffectiveProbeCount++; + } + + if (mEffectiveProbeCount != 0) + { + mCubemapArray = GFXCubemapArrayHandle(GFX->createCubemapArray()); + mIrradArray = GFXCubemapArrayHandle(GFX->createCubemapArray()); + + mCubemapArray->initStatic(cubeMaps.address(), cubeMaps.size()); + mIrradArray->initStatic(irradMaps.address(), irradMaps.size()); } } -RenderProbeMgr::ReflectProbeMaterialInfo* RenderProbeMgr::getReflectProbeMaterial() +void RenderProbeMgr::_setupPerFrameParameters(const SceneRenderState *state) { - PROFILE_SCOPE(AdvancedLightBinManager_getReflectProbeMaterial); - - //ReflectProbeMaterialInfo *info = NULL; - - if (!mReflectProbeMaterial) - - // Now create the material info object. - mReflectProbeMaterial = new ReflectProbeMaterialInfo("ReflectionProbeMaterial", - getGFXVertexFormat()); - - return mReflectProbeMaterial; + PROFILE_SCOPE(RenderProbeMgr_SetupPerFrameParameters); } ProbeShaderConstants* RenderProbeMgr::getProbeShaderConstants(GFXShaderConstBuffer* buffer) @@ -422,10 +387,8 @@ ProbeShaderConstants* RenderProbeMgr::getProbeShaderConstants(GFXShaderConstBuff mLastShader = shader; } - mLastConstants = new ProbeShaderConstants(); - // Make sure that our current lighting constants are initialized - if (!mLastConstants->mInit) + if (mLastConstants && !mLastConstants->mInit) mLastConstants->init(shader); return mLastConstants; @@ -449,7 +412,7 @@ void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData, probeRadiusSC->isValid() || probeBoxMinSC->isValid() || probeBoxMaxSC->isValid() || - probeCubemapSC->isValid() && (!ProbeRenderInst::all.empty())) + probeCubemapSC->isValid()/* && (!ProbeRenderInst::all.empty())*/) { PROFILE_SCOPE(ProbeManager_Update4ProbeConsts_setProbes); @@ -477,7 +440,7 @@ void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData, const MatrixF &worldToCameraXfm = matSet.getWorldToCamera(); // Gather the data for the first 4 probes. - const ProbeRenderInst *probe; + /*const ProbeRenderInst *probe; for (U32 i = 0; i < 4; i++) { if (i >= ProbeRenderInst::all.size()) @@ -526,6 +489,33 @@ void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData, if (samplerReg != -1) GFX->setCubeTexture(samplerReg + i, probe->mCubemap.getPointer()); } + }*/ + + for (U32 i = 0; i < 4; i++) + { + probePositions[i].x = 0; + probePositions[i].y = 0; + probePositions[i].z = 0; + + probeRadius[i] = 0; + + probeBoxMins[i].x = 0; + probeBoxMins[i].y = 0; + probeBoxMins[i].z = 0; + + probeBoxMaxs[i].x = 0; + probeBoxMaxs[i].y = 0; + probeBoxMaxs[i].z = 0; + + probeIsSphere[i] = 0; + + probeLocalPositions[i].x = 0; + probeLocalPositions[i].y = 0; + probeLocalPositions[i].z = 0; + + S32 samplerReg = probeCubemapSC->getSamplerRegister(); + + GFX->setCubeTexture(samplerReg + i, nullptr); } shaderConsts->setSafe(probePositionSC, probePositions); @@ -534,18 +524,9 @@ void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData, shaderConsts->setSafe(probeBoxMaxSC, probeBoxMaxs); shaderConsts->setSafe(probeLocalPosSC, probeLocalPositions); shaderConsts->setSafe(probeIsSphereSC, probeIsSphere); - - // - - //shaderConsts->setSafe(lightSpotAngleSC, lightSpotAngle); - //shaderConsts->setSafe(lightSpotFalloffSC, lightSpotFalloff); } else { - /*if (probe->mCubemap && !probe->mCubemap.isNull()) - { - GFX->setCubeTexture(1, probe->mCubemap.getPointer()); - }*/ if (probeCubemapSC->isValid()) { for (U32 i = 0; i < 4; ++i) @@ -573,9 +554,6 @@ void RenderProbeMgr::setProbeInfo(ProcessedMaterial *pmat, ProbeShaderConstants *psc = getProbeShaderConstants(shaderConsts); - //ProbeInfo *probe; - //probe = mRegisteredProbes[0]; - // NOTE: If you encounter a crash from this point forward // while setting a shader constant its probably because the // mConstantLookup has bad shaders/constants in it. @@ -584,7 +562,6 @@ void RenderProbeMgr::setProbeInfo(ProcessedMaterial *pmat, // are reloaded and the light manager is not reset. // // We should look to fix this by clearing the table. - MatrixSet matSet = state->getRenderPass()->getMatrixSet(); // Update the forward shading light constants. @@ -605,364 +582,182 @@ void RenderProbeMgr::setProbeInfo(ProcessedMaterial *pmat, //----------------------------------------------------------------------------- void RenderProbeMgr::render( SceneRenderState *state ) { - PROFILE_SCOPE(RenderProbeMgr_render); + //PROFILE_SCOPE(RenderProbeMgr_render); + if (getProbeArrayEffect() == nullptr) + return; + + updateProbes(); // Early out if nothing to draw. - if (!ProbeRenderInst::all.size()) - return; - - if (!RenderProbeMgr::smRenderReflectionProbes) - return; + if (!ProbeRenderInst::all.size() || !RenderProbeMgr::smRenderReflectionProbes || mEffectiveProbeCount == 0 + || !state->isDiffusePass() || cubeMaps.empty() || irradMaps.empty()) + { + getProbeArrayEffect()->setSkip(true); + return; + } GFXTransformSaver saver; GFXDEBUGEVENT_SCOPE(RenderProbeMgr_render, ColorI::WHITE); - NamedTexTargetRef sceneColorTargetRef = NamedTexTarget::find("AL_FormatToken"); - if (sceneColorTargetRef.isNull()) - return; - - GFXTextureTargetRef probeLightingTargetRef = GFX->allocRenderToTextureTarget(); - - if (probeLightingTargetRef.isNull()) - return; - - //Do a quick pass to update our probes if they're dirty - //PROBEMGR->updateDirtyProbes(); - - probeLightingTargetRef->attachTexture(GFXTextureTarget::Color0, sceneColorTargetRef->getTexture(0)); - - GFX->pushActiveRenderTarget(); - GFX->setActiveRenderTarget(probeLightingTargetRef); - - GFX->setViewport(sceneColorTargetRef->getViewport()); - - // Restore transforms - MatrixSet &matrixSet = getRenderPass()->getMatrixSet(); - matrixSet.restoreSceneViewProjection(); - - const MatrixF &worldToCameraXfm = matrixSet.getWorldToCamera(); - - // Set up the SG Data - SceneData sgData; - sgData.init(state); - // Initialize and set the per-frame parameters after getting // the vector light material as we use lazy creation. - _setupPerFrameParameters(state); - - //Order the probes by size, biggest to smallest - //dQsort(ProbeRenderInst::all.address(), ProbeRenderInst::all.size(), sizeof(const ProbeRenderInst*), AscendingReflectProbeInfluence); - - //Specular - PROFILE_START(RenderProbeManager_ReflectProbeRender); - - ReflectProbeMaterialInfo* reflProbeMat = getReflectProbeMaterial(); - - if (reflProbeMat == nullptr || reflProbeMat->matInstance == nullptr) - return; - - MaterialParameters *matParams = reflProbeMat->matInstance->getMaterialParameters(); - - MaterialParameterHandle *numProbesSC = reflProbeMat->matInstance->getMaterialParameterHandle("$numProbes"); - - MaterialParameterHandle *probePositionSC = reflProbeMat->matInstance->getMaterialParameterHandle("$inProbePosArray"); - MaterialParameterHandle *probeWorldToObjSC = reflProbeMat->matInstance->getMaterialParameterHandle("$worldToObjArray"); - MaterialParameterHandle *probeBBMinSC = reflProbeMat->matInstance->getMaterialParameterHandle("$bbMinArray"); - MaterialParameterHandle *probeBBMaxSC = reflProbeMat->matInstance->getMaterialParameterHandle("$bbMaxArray"); - MaterialParameterHandle *probeUseSphereModeSC = reflProbeMat->matInstance->getMaterialParameterHandle("$useSphereMode"); - MaterialParameterHandle *probeRadiusSC = reflProbeMat->matInstance->getMaterialParameterHandle("$radius"); - MaterialParameterHandle *probeAttenuationSC = reflProbeMat->matInstance->getMaterialParameterHandle("$attenuation"); - + //_setupPerFrameParameters(state); + //Array rendering U32 probeCount = ProbeRenderInst::all.size(); - if (probeCount == 0) - return; - MatrixF trans = MatrixF::Identity; - sgData.objTrans = &trans; - - U32 effectiveProbeCount = 0; - - for (U32 i = 0; i < probeCount; i++) + if (mEffectiveProbeCount != 0) { - if (effectiveProbeCount >= MAXPROBECOUNT) - break; + mProbeArrayEffect->setCubemapArrayTexture(4, mCubemapArray); + mProbeArrayEffect->setCubemapArrayTexture(5, mIrradArray); - ProbeRenderInst* curEntry = ProbeRenderInst::all[i]; - if (!curEntry->mIsEnabled) - continue; - - if (curEntry->mCubemap.isNull() || curEntry->mIrradianceCubemap.isNull()) - continue; - - if (!curEntry->mCubemap->isInitialised()) - continue; - - if (!curEntry->mIrradianceCubemap->isInitialised()) - continue; - - if (curEntry->mIsSkylight) - continue; - - //Setup - const Point3F &probePos = curEntry->getPosition(); - probePositions[i] = probePos + curEntry->mProbePosOffset; - - MatrixF trans = curEntry->getTransform(); - trans.inverse(); - - probeWorldToObj[i]=trans; - - probeBBMin[i] = curEntry->mBounds.minExtents; - probeBBMax[i] = curEntry->mBounds.maxExtents; - - probeUseSphereMode[i] = curEntry->mProbeShapeType == ProbeRenderInst::Sphere ? 1 : 0; - - probeRadius[i] = curEntry->mRadius; - probeAttenuation[i] = 1; - - cubeMaps.push_back(curEntry->mCubemap); - irradMaps.push_back(curEntry->mIrradianceCubemap); - - effectiveProbeCount++; + mProbeArrayEffect->setShaderConst("$cubeMips", (float)mMipCount); + + mProbeArrayEffect->setShaderConst("$numProbes", (float)mEffectiveProbeCount); + mProbeArrayEffect->setShaderConst("$inProbePosArray", probePositionsData); + mProbeArrayEffect->setShaderConst("$worldToObjArray", probeWorldToObjData); + mProbeArrayEffect->setShaderConst("$bbMinArray", probeBBMinData); + mProbeArrayEffect->setShaderConst("$bbMaxArray", probeBBMaxData); + mProbeArrayEffect->setShaderConst("$useSphereMode", probeUseSphereModeData); + mProbeArrayEffect->setShaderConst("$radius", probeRadiusData); + mProbeArrayEffect->setShaderConst("$attenuation", probeAttenuationData); } - if (effectiveProbeCount != 0) + // Make sure the effect is gonna render. + getProbeArrayEffect()->setSkip(false); + + //PROFILE_END(); +} + +void RenderProbeMgr::bakeProbe(ReflectionProbe *probe) +{ + GFXDEBUGEVENT_SCOPE(RenderProbeMgr_Bake, ColorI::WHITE); + + Con::warnf("RenderProbeMgr::bakeProbe() - Beginning bake!"); + U32 startMSTime = Platform::getRealMilliseconds(); + + String path = Con::getVariable("$pref::ReflectionProbes::CurrentLevelPath", "levels/"); + U32 resolution = Con::getIntVariable("$pref::ReflectionProbes::BakeResolution", 64); + U32 prefilterMipLevels = mLog2(F32(resolution)); + bool renderWithProbes = Con::getIntVariable("$pref::ReflectionProbes::RenderWithProbes", false); + + ReflectionProbe *clientProbe = static_cast(probe->getClientObject()); + + String probePrefilterPath = clientProbe->getPrefilterMapPath(); + String probeIrradPath = clientProbe->getIrradianceMapPath(); + + if (clientProbe->mReflectionModeType != ReflectionProbe::DynamicCubemap) { - matParams->setSafe(numProbesSC, (float)effectiveProbeCount); - - mCubemapArray = GFXCubemapArrayHandle(GFX->createCubemapArray()); - mIrradArray = GFXCubemapArrayHandle(GFX->createCubemapArray()); - - mCubemapArray->initStatic(cubeMaps.address(), cubeMaps.size()); - mIrradArray->initStatic(irradMaps.address(), irradMaps.size()); - - NamedTexTarget *deferredTarget = NamedTexTarget::find(RenderDeferredMgr::BufferName); - if (deferredTarget) - GFX->setTexture(0, deferredTarget->getTexture()); - else - GFX->setTexture(0, NULL); - - NamedTexTarget *colorTarget = NamedTexTarget::find(RenderDeferredMgr::ColorBufferName); - if (colorTarget) - GFX->setTexture(1, colorTarget->getTexture()); - else - GFX->setTexture(1, NULL); - - NamedTexTarget *matinfoTarget = NamedTexTarget::find(RenderDeferredMgr::MatInfoBufferName); - if (matinfoTarget) - GFX->setTexture(2, matinfoTarget->getTexture()); - else - GFX->setTexture(2, NULL); - - if (mBrdfTexture) + //Prep our bake path + if (probePrefilterPath.isEmpty() || probeIrradPath.isEmpty()) { - GFX->setTexture(3, mBrdfTexture); - } - else - GFX->setTexture(3, NULL); - - - GFX->setCubeArrayTexture(4, mCubemapArray); - GFX->setCubeArrayTexture(5, mIrradArray); - //Final packing - AlignedArray _probePositions(MAXPROBECOUNT, sizeof(Point4F), (U8*)probePositions.address(), false); - AlignedArray _probeBBMin(MAXPROBECOUNT, sizeof(Point4F), (U8*)probeBBMin.address(), false); - AlignedArray _probeBBMax(MAXPROBECOUNT, sizeof(Point4F), (U8*)probeBBMax.address(), false); - AlignedArray _probeUseSphereMode(MAXPROBECOUNT, sizeof(float), (U8*)probeUseSphereMode.address(), false); - AlignedArray _probeRadius(MAXPROBECOUNT, sizeof(float), (U8*)probeRadius.address(), false); - AlignedArray _probeAttenuation(MAXPROBECOUNT, sizeof(float), (U8*)probeAttenuation.address(), false); - - matParams->set(probePositionSC, _probePositions); - matParams->set(probeWorldToObjSC, probeWorldToObj.address(), MAXPROBECOUNT); - matParams->set(probeBBMinSC, _probeBBMin); - matParams->set(probeBBMaxSC, _probeBBMax); - matParams->set(probeUseSphereModeSC, _probeUseSphereMode); - matParams->set(probeRadiusSC, _probeRadius); - matParams->set(probeAttenuationSC, _probeAttenuation); - - // Set geometry - GFX->setVertexBuffer(mFarFrustumQuadVerts); - GFX->setPrimitiveBuffer(NULL); - - while (reflProbeMat->matInstance->setupPass(state, sgData)) - { - // Set transforms - matrixSet.setWorld(*sgData.objTrans); - reflProbeMat->matInstance->setTransforms(matrixSet, state); - reflProbeMat->matInstance->setSceneInfo(state, sgData); - - GFX->drawPrimitive(GFXTriangleStrip, 0, 2); + Con::errorf("RenderProbeMgr::bake() - Unable to bake our captures because probe doesn't have a path set"); + return; } } - GFX->popActiveRenderTarget(); + // Save the current transforms so we can restore + // it for child control rendering below. + GFXTransformSaver saver; - //PROBEMGR->unregisterAllProbes(); - //PROBEMGR->mRegisteredProbes.clear(); + bool probeRenderState = RenderProbeMgr::smRenderReflectionProbes; - PROFILE_END(); + F32 farPlane = 1000.0f; - GFX->setVertexBuffer(NULL); - GFX->setPrimitiveBuffer(NULL); + ReflectorDesc reflDesc; + reflDesc.texSize = resolution; + reflDesc.farDist = farPlane; + reflDesc.detailAdjust = 1; + reflDesc.objectTypeMask = -1; - // Fire off a signal to let others know that light-bin rendering is ending now - //getRenderSignal().trigger(state, this); -} + CubeReflector cubeRefl; + cubeRefl.registerReflector(probe, &reflDesc); -// -// -RenderProbeMgr::ReflectProbeMaterialInfo::ReflectProbeMaterialInfo(const String &matName, - const GFXVertexFormat *vertexFormat) - : matInstance(NULL), - zNearFarInvNearFar(NULL), - farPlane(NULL), - vsFarPlane(NULL), - negFarPlaneDotEye(NULL), - probeWSPos(NULL), - attenuation(NULL), - radius(NULL), - cubeMips(NULL) -{ - Material *mat = MATMGR->getMaterialDefinitionByName(matName); - if (!mat) - return; + ReflectParams reflParams; - matInstance = new ReflectProbeMatInstance(*mat); + //need to get the query somehow. Likely do some sort of get function to fetch from the guiTSControl that's active + CameraQuery query; //need to get the last cameraQuery + query.fov = 90; //90 degree slices for each of the 6 sides + query.nearPlane = 0.1f; + query.farPlane = farPlane; + query.headMatrix = MatrixF(); + query.cameraMatrix = clientProbe->getTransform(); - const Vector ¯os = Vector(); + Frustum culler; + culler.set(false, + query.fov, + (F32)resolution / (F32)resolution, + query.nearPlane, + query.farPlane, + query.cameraMatrix); - for (U32 i = 0; i < macros.size(); i++) - matInstance->addShaderMacro(macros[i].name, macros[i].value); + S32 stereoTarget = GFX->getCurrentStereoTarget(); - matInstance->init(MATMGR->getDefaultFeatures(), vertexFormat); + Point2I maxRes(2048, 2048); //basically a boundary so we don't go over this and break stuff - attenuation = matInstance->getMaterialParameterHandle("$attenuation"); - radius = matInstance->getMaterialParameterHandle("$radius"); - probeLSPos = matInstance->getMaterialParameterHandle("$probeLSPos"); - probeWSPos = matInstance->getMaterialParameterHandle("$probeWSPos"); - farPlane = matInstance->getMaterialParameterHandle("$farPlane"); - vsFarPlane = matInstance->getMaterialParameterHandle("$vsFarPlane"); - negFarPlaneDotEye = matInstance->getMaterialParameterHandle("$negFarPlaneDotEye"); - zNearFarInvNearFar = matInstance->getMaterialParameterHandle("$zNearFarInvNearFar"); + reflParams.culler = culler; + reflParams.eyeId = stereoTarget; + reflParams.query = &query; + reflParams.startOfUpdateMs = startMSTime; + reflParams.viewportExtent = maxRes; - useCubemap = matInstance->getMaterialParameterHandle("$useCubemap"); + if (!renderWithProbes) + RenderProbeMgr::smRenderReflectionProbes = false; - cubemap = matInstance->getMaterialParameterHandle("$cubeMap"); - cubeMips = matInstance->getMaterialParameterHandle("$cubeMips"); + cubeRefl.updateReflection(reflParams); - eyePosWorld = matInstance->getMaterialParameterHandle("$eyePosWorld"); - bbMin = matInstance->getMaterialParameterHandle("$bbMin"); - bbMax = matInstance->getMaterialParameterHandle("$bbMax"); - - useSphereMode = matInstance->getMaterialParameterHandle("$useSphereMode"); - - probeCount = matInstance->getMaterialParameterHandle("$numProbes"); - - for (U32 i = 0; i < 9; i++) - shTerms[i] = matInstance->getMaterialParameterHandle(String::ToString("$SHTerms%d", i)); - - for (U32 i = 0; i < 5; i++) - shConsts[i] = matInstance->getMaterialParameterHandle(String::ToString("$SHConsts%d", i)); -} - -RenderProbeMgr::ReflectProbeMaterialInfo::~ReflectProbeMaterialInfo() -{ - SAFE_DELETE(matInstance); -} - -void RenderProbeMgr::ReflectProbeMaterialInfo::setViewParameters(const F32 _zNear, - const F32 _zFar, - const Point3F &_eyePos, - const PlaneF &_farPlane, - const PlaneF &_vsFarPlane) -{ - MaterialParameters *matParams = matInstance->getMaterialParameters(); - - matParams->setSafe(farPlane, *((const Point4F *)&_farPlane)); - - matParams->setSafe(vsFarPlane, *((const Point4F *)&_vsFarPlane)); - - if (negFarPlaneDotEye->isValid()) + //Now, save out the maps + //create irridiance cubemap + if (cubeRefl.getCubemap()) { - // -dot( farPlane, eyePos ) - const F32 negFarPlaneDotEyeVal = -(mDot(*((const Point3F *)&_farPlane), _eyePos) + _farPlane.d); - matParams->set(negFarPlaneDotEye, negFarPlaneDotEyeVal); - } + //Just to ensure we're prepped for the generation + clientProbe->createClientResources(); - matParams->setSafe(zNearFarInvNearFar, Point4F(_zNear, _zFar, 1.0f / _zNear, 1.0f / _zFar)); + //Prep it with whatever resolution we've dictated for our bake + if (clientProbe->mUseHDRCaptures) + { + clientProbe->mIrridianceMap->mCubemap->initDynamic(resolution, GFXFormatR16G16B16A16F); + clientProbe->mPrefilterMap->mCubemap->initDynamic(resolution, GFXFormatR16G16B16A16F); + } + else + { + clientProbe->mIrridianceMap->mCubemap->initDynamic(resolution, GFXFormatR8G8B8A8); + clientProbe->mPrefilterMap->mCubemap->initDynamic(resolution, GFXFormatR8G8B8A8); + } - Point4F frPlane = *((const Point4F *)&_farPlane); - Point4F vsFrPlane = *((const Point4F *)&_vsFarPlane); - Point4F nearFarInvNearFar = Point4F(_zNear, _zFar, 1.0f / _zNear, 1.0f / _zFar); - const F32 negFarPlaneDotEyeVal = -(mDot(*((const Point3F *)&_farPlane), _eyePos) + _farPlane.d); -} + GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget(false); -void RenderProbeMgr::ReflectProbeMaterialInfo::setProbeParameters(const ProbeRenderInst *probeInfo, const SceneRenderState* renderState, const MatrixF &worldViewOnly) -{ - //Set up the params - MaterialParameters *matParams = matInstance->getMaterialParameters(); + IBLUtilities::GenerateIrradianceMap(renderTarget, cubeRefl.getCubemap(), clientProbe->mIrridianceMap->mCubemap); + IBLUtilities::GeneratePrefilterMap(renderTarget, cubeRefl.getCubemap(), prefilterMipLevels, clientProbe->mPrefilterMap->mCubemap); - matParams->setSafe(radius, probeInfo->mRadius); - - Point3F probePos = probeInfo->getPosition() + probeInfo->mProbePosOffset; - //worldViewOnly.mulP(probeInfo->getPosition(), &probePos); - matParams->setSafe(probeWSPos, probePos); - - worldViewOnly.mulP(probeInfo->getPosition(), &probePos); - matParams->setSafe(probeLSPos, probePos); - - // Get the attenuation falloff ratio and normalize it. - Point3F attenRatio = Point3F(0.0f, 1.0f, 1.0f); - F32 total = attenRatio.x + attenRatio.y + attenRatio.z; - if (total > 0.0f) - attenRatio /= total; - - F32 probeRadius = probeInfo->mRadius; - - Point2F attenParams((1.0f / probeRadius) * attenRatio.y, - (1.0f / (probeRadius * probeRadius)) * attenRatio.z); - - matParams->setSafe(attenuation, attenParams); - - NamedTexTarget* deferredTexTarget = NamedTexTarget::find("deferred"); - NamedTexTarget* matInfoTexTarget = NamedTexTarget::find("matinfo"); - NamedTexTarget* colorTexTarget = NamedTexTarget::find("color"); - - if (!deferredTexTarget || !matInfoTexTarget || !colorTexTarget) - { - Con::errorf("ProbeManager::ReflectProbeMaterialInfo::setProbeParameters: Could not retrieve gbuffer"); - return; - } - - //set textures - GFX->setTexture(0, deferredTexTarget->getTexture()); - GFX->setTexture(1, colorTexTarget->getTexture()); - GFX->setTexture(2, matInfoTexTarget->getTexture()); - - //Add some safety catches in the event the cubemaps aren't fully initialized yet - if (probeInfo->mCubemap == nullptr || probeInfo->mCubemap.isNull()) - { - GFX->setCubeTexture(3, nullptr); - matParams->setSafe(cubeMips, 2.0f); + IBLUtilities::SaveCubeMap(clientProbe->getIrradianceMapPath(), clientProbe->mIrridianceMap->mCubemap); + IBLUtilities::SaveCubeMap(clientProbe->getPrefilterMapPath(), clientProbe->mPrefilterMap->mCubemap); } else { - GFX->setCubeTexture(3, probeInfo->mCubemap.getPointer()); - matParams->setSafe(cubeMips, mPow(probeInfo->mCubemap.getPointer()->getMipMapLevels(), 2.0f)); + Con::errorf("RenderProbeMgr::bake() - Didn't generate a valid scene capture cubemap, unable to generate prefilter and irradiance maps!"); } - if (probeInfo->mIrradianceCubemap == nullptr || probeInfo->mIrradianceCubemap.isNull()) - GFX->setCubeTexture(4, nullptr); - else - GFX->setCubeTexture(4, probeInfo->mIrradianceCubemap.getPointer()); + if (!renderWithProbes) + RenderProbeMgr::smRenderReflectionProbes = probeRenderState; - GFX->setTexture(5, probeInfo->mBRDFTexture->getPointer()); + cubeRefl.unregisterReflector(); - //set material params - matParams->setSafe(eyePosWorld, renderState->getCameraPosition()); - matParams->setSafe(bbMin, probeInfo->mBounds.minExtents); - matParams->setSafe(bbMax, probeInfo->mBounds.maxExtents); - matParams->setSafe(useSphereMode, probeInfo->mProbeShapeType == ProbeRenderInst::Sphere ? 1.0f : 0.0f); + U32 endMSTime = Platform::getRealMilliseconds(); + F32 diffTime = F32(endMSTime - startMSTime); + + Con::warnf("RenderProbeMgr::bake() - Finished bake! Took %g milliseconds", diffTime); +} + +void RenderProbeMgr::bakeProbes() +{ + //TODO: make this just find every probe in the current missionGroup and run the bake on it automagically +} + +DefineEngineMethod(RenderProbeMgr, bakeProbe, void, (ReflectionProbe* probe), (nullAsType< ReflectionProbe*>()), + "@brief returns true if control object is inside the fog\n\n.") +{ + if(probe != nullptr) + object->bakeProbe(probe); } \ No newline at end of file diff --git a/Engine/source/renderInstance/renderProbeMgr.h b/Engine/source/renderInstance/renderProbeMgr.h index 3ad62d942..f9e2fb87e 100644 --- a/Engine/source/renderInstance/renderProbeMgr.h +++ b/Engine/source/renderInstance/renderProbeMgr.h @@ -48,27 +48,32 @@ #include "postFx/postEffectCommon.h" #endif +#ifndef _REFLECTOR_H_ +#include "scene/reflector.h" +#endif + static U32 MAXPROBECOUNT = 50; +class PostEffect; +class ReflectionProbe; + struct ProbeRenderInst : public SystemInterface { - LinearColorF mAmbient; - MatrixF mTransform; F32 mRadius; - F32 mIntensity; bool mDirty; Box3F mBounds; + Point3F mPosition; Point3F mProbePosOffset; GFXCubemapHandle mCubemap; - GFXCubemapHandle mIrradianceCubemap; - GFXTexHandle *mBRDFTexture; + //Utilized in dynamic reflections + CubeReflector mCubeReflector; /// The priority of this light used for /// light and shadow scoring. @@ -80,16 +85,6 @@ struct ProbeRenderInst : public SystemInterface bool mIsSkylight; - /// Whether to render debugging visualizations - /// for this light. - bool mDebugRender; - - GFXPrimitiveBufferHandle primBuffer; - GFXVertexBufferHandle vertBuffer; - U32 numPrims; - U32 numVerts; - Vector< U32 > numIndicesForPoly; - enum ProbeShapeType { Sphere = 0, ///< Sphere shaped @@ -98,10 +93,6 @@ struct ProbeRenderInst : public SystemInterface ProbeShapeType mProbeShapeType; - //Spherical Harmonics data - LinearColorF mSHTerms[9]; - F32 mSHConstants[5]; - public: ProbeRenderInst(); @@ -114,28 +105,18 @@ public: const MatrixF& getTransform() const { return mTransform; } void setTransform(const MatrixF &xfm) { mTransform = xfm; } - Point3F getPosition() const { return mTransform.getPosition(); } - void setPosition(const Point3F &pos) { mTransform.setPosition(pos); } + Point3F getPosition() const { return mPosition; } + void setPosition(const Point3F &pos) { mPosition = pos; } VectorF getDirection() const { return mTransform.getForwardVector(); } void setDirection(const VectorF &val); - const LinearColorF& getAmbient() const { return mAmbient; } - void setAmbient(const LinearColorF &val) { mAmbient = val; } - void setPriority(F32 priority) { mPriority = priority; } F32 getPriority() const { return mPriority; } void setScore(F32 score) { mScore = score; } F32 getScore() const { return mScore; } - bool isDebugRenderingEnabled() const { return mDebugRender; } - void enableDebugRendering(bool value) { mDebugRender = value; } - - // Builds the world to light view projection used for - // shadow texture and cookie lookups. - void getWorldToLightProj(MatrixF *outMatrix) const; - void clear(); }; @@ -167,26 +148,6 @@ struct ProbeShaderConstants typedef Map ProbeConstantMap; -class ReflectProbeMatInstance : public MatInstance -{ - typedef MatInstance Parent; -protected: - MaterialParameterHandle * mProbeParamsSC; - bool mInternalPass; - - GFXStateBlockRef mProjectionState; - - ProcessedShaderMaterial* mShaderMat; - -public: - ReflectProbeMatInstance(Material &mat) : Parent(mat), mProbeParamsSC(NULL), mInternalPass(false), mProjectionState(NULL) {} - - virtual bool init(const FeatureSet &features, const GFXVertexFormat *vertexFormat); - virtual bool setupPass(SceneRenderState *state, const SceneData &sgData); - - ProcessedShaderMaterial* getProcessedShaderMaterial() { return mShaderMat; } -}; - //************************************************************************** // RenderObjectMgr //************************************************************************** @@ -194,82 +155,53 @@ class RenderProbeMgr : public RenderBinManager { typedef RenderBinManager Parent; - struct ReflectProbeMaterialInfo - { - ReflectProbeMatInstance *matInstance; - - // { zNear, zFar, 1/zNear, 1/zFar } - MaterialParameterHandle *zNearFarInvNearFar; - - // Far frustum plane (World Space) - MaterialParameterHandle *farPlane; - - // Far frustum plane (View Space) - MaterialParameterHandle *vsFarPlane; - - // -dot( farPlane, eyePos ) - MaterialParameterHandle *negFarPlaneDotEye; - - // Light Parameters - MaterialParameterHandle *probeLSPos; - MaterialParameterHandle *probeWSPos; - MaterialParameterHandle *attenuation; - MaterialParameterHandle *radius; - - MaterialParameterHandle *useCubemap; - MaterialParameterHandle *cubemap; - MaterialParameterHandle *cubeMips; - - MaterialParameterHandle *eyePosWorld; - MaterialParameterHandle *bbMin; - MaterialParameterHandle *bbMax; - - MaterialParameterHandle *useSphereMode; - - MaterialParameterHandle *shTerms[9]; - MaterialParameterHandle *shConsts[5]; - - MaterialParameterHandle *probeCount; - - ReflectProbeMaterialInfo(const String &matName, const GFXVertexFormat *vertexFormat); - - virtual ~ReflectProbeMaterialInfo(); - - - void setViewParameters(const F32 zNear, - const F32 zFar, - const Point3F &eyePos, - const PlaneF &farPlane, - const PlaneF &_vsFarPlane); - - void setProbeParameters(const ProbeRenderInst *probe, const SceneRenderState* renderState, const MatrixF &worldViewOnly); - }; - - enum SpecialProbeTypesEnum - { - SkylightProbeType, - SpecialProbeTypesCount - }; - Vector mRegisteredProbes; - ReflectProbeMaterialInfo* mReflectProbeMaterial; + //Array rendering + U32 mEffectiveProbeCount; + S32 mMipCount; + Vector probePositionsData; + Vector probeWorldToObjData; + Vector probeBBMinData; + Vector probeBBMaxData; + Vector probeUseSphereModeData; + Vector probeRadiusData; + Vector probeAttenuationData; + Vector cubeMaps; + Vector irradMaps; - /// The scene graph the light manager is associated with. - SceneManager *mSceneManager; + AlignedArray mProbePositions; + AlignedArray mProbeBBMin; + AlignedArray mProbeBBMax; + AlignedArray mProbeUseSphereMode; + AlignedArray mProbeRadius; + AlignedArray mProbeAttenuation; + GFXCubemapArrayHandle mCubemapArray; + GFXCubemapArrayHandle mIrradArray; + + //Utilized in forward rendering ProbeConstantMap mConstantLookup; GFXShaderRef mLastShader; ProbeShaderConstants* mLastConstants; -protected: + // + SimObjectPtr mProbeArrayEffect; +public: + RenderProbeMgr(); + RenderProbeMgr(RenderInstType riType, F32 renderOrder, F32 processAddOrder); + + virtual void onRemove(); + + // ConsoleObject + static void initPersistFields(); + DECLARE_CONOBJECT(RenderProbeMgr); + +protected: /// The current active light manager. static RenderProbeMgr *smProbeManager; - typedef GFXVertexPNTT FarFrustumQuadVert; - GFXVertexBufferHandle mFarFrustumQuadVerts; - /// This helper function sets the shader constansts /// for the stock 4 light forward lighting code. void _update4ProbeConsts(const SceneData &sgData, @@ -283,57 +215,37 @@ protected: GFXShaderConstHandle *probeLocalPosSC, GFXShaderConstBuffer *shaderConsts); - GFXTextureObject * mBrdfTexture; - - //Array rendering - - Vector probePositions; - Vector probeWorldToObj; - Vector probeBBMin; - Vector probeBBMax; - Vector probeUseSphereMode; - Vector probeRadius; - Vector probeAttenuation; - Vector cubeMaps; - Vector irradMaps; - - GFXCubemapArrayHandle mCubemapArray; - GFXCubemapArrayHandle mIrradArray; -public: - RenderProbeMgr(); - RenderProbeMgr(RenderInstType riType, F32 renderOrder, F32 processAddOrder); - - // RenderBinMgr + void _setupStaticParameters(); void _setupPerFrameParameters(const SceneRenderState *state); virtual void addElement(RenderInst *inst); virtual void render(SceneRenderState * state); - virtual void setProbeInfo(ProcessedMaterial *pmat, - const Material *mat, - const SceneData &sgData, - const SceneRenderState *state, - U32 pass, - GFXShaderConstBuffer *shaderConsts); ProbeShaderConstants* getProbeShaderConstants(GFXShaderConstBuffer* buffer); - // ConsoleObject - static void initPersistFields(); - DECLARE_CONOBJECT(RenderProbeMgr); + PostEffect* getProbeArrayEffect(); + +public: + // RenderBinMgr + void updateProbes(); /// Returns the active LM. static inline RenderProbeMgr* getProbeManager(); - ReflectProbeMaterialInfo* getReflectProbeMaterial(); - void registerProbe(U32 probeIdx); + void unregisterProbe(U32 probeIdx); - // Returns the scene manager passed at activation. - SceneManager* getSceneManager() { return mSceneManager; } - - void setSceneManager(SceneManager* sceneManager) { mSceneManager = sceneManager; } + virtual void setProbeInfo(ProcessedMaterial *pmat, + const Material *mat, + const SceneData &sgData, + const SceneRenderState *state, + U32 pass, + GFXShaderConstBuffer *shaderConsts); /// Debug rendering static bool smRenderReflectionProbes; + + void bakeProbe(ReflectionProbe *probeInfo); + void bakeProbes(); }; RenderProbeMgr* RenderProbeMgr::getProbeManager() @@ -342,15 +254,7 @@ RenderProbeMgr* RenderProbeMgr::getProbeManager() { RenderProbeMgr* probeManager = new RenderProbeMgr(); - if (gClientSceneGraph != nullptr) - { - probeManager->setSceneManager(gClientSceneGraph); - smProbeManager = probeManager; - } - else - { - delete probeManager; - } + smProbeManager = probeManager; } return smProbeManager; diff --git a/Templates/Full/game/core/scripts/client/lighting/advanced/shaders.cs b/Templates/Full/game/core/scripts/client/lighting/advanced/shaders.cs index 8b122c5de..12925d102 100644 --- a/Templates/Full/game/core/scripts/client/lighting/advanced/shaders.cs +++ b/Templates/Full/game/core/scripts/client/lighting/advanced/shaders.cs @@ -277,94 +277,7 @@ new CustomMaterial( AL_ParticlePointLightMaterial ) pixVersion = 3.0; }; -//Reflection probe Specular -new ShaderData( ReflectionProbeShader ) -{ - /*DXVertexShaderFile = "shaders/common/lighting/advanced/convexGeometryV.hlsl"; - DXPixelShaderFile = "shaders/common/lighting/advanced/reflectionProbeP.hlsl"; - - OGLVertexShaderFile = "shaders/common/lighting/advanced/gl/convexGeometryV.glsl"; - OGLPixelShaderFile = "shaders/common/lighting/advanced/gl/reflectionProbeP.glsl"; - - samplerNames[0] = "$deferredBuffer"; - samplerNames[1] = "$colorBuffer"; - samplerNames[2] = "$matInfoBuffer"; - samplerNames[3] = "$cubeMap"; - samplerNames[4] = "$irradianceCubemap"; - samplerNames[5] = "$BRDFTexture";*/ - - DXVertexShaderFile = "shaders/common/lighting/advanced/farFrustumQuadV.hlsl"; - DXPixelShaderFile = "shaders/common/lighting/advanced/reflectionProbeArrayP.hlsl"; - - OGLVertexShaderFile = "shaders/common/lighting/advanced/gl/farFrustumQuadV.glsl"; - OGLPixelShaderFile = "shaders/common/lighting/advanced/gl/reflectionProbeArrayP.glsl"; - - samplerNames[0] = "$deferredBuffer"; - samplerNames[1] = "$colorBuffer"; - samplerNames[2] = "$matInfoBuffer"; - samplerNames[3] = "$BRDFTexture"; - samplerNames[4] = "$cubeMap"; - samplerNames[5] = "$irradianceCubemap"; - - pixVersion = 3.0; -}; - -// Convex-geometry light states -new GFXStateBlockData( AL_ProbeState ) -{ - blendDefined = true; - blendEnable = true; - blendSrc = GFXBlendSrcAlpha; //TODO change this to GFXBlendOne once probes are done in one pass! - blendDest = GFXBlendOne; - blendOp = GFXBlendOpAdd; - - colorWriteDefined = true; - colorWriteRed = true; - colorWriteBlue = true; - colorWriteGreen = true; - colorWriteAlpha = true; - - zDefined = true; - zEnable = true; - zWriteEnable = false; - zFunc = GFXCmpGreaterEqual; - - samplersDefined = true; - samplerStates[0] = SamplerClampPoint; // G-buffer - mSamplerNames[0] = "deferredBuffer"; - samplerStates[1] = SamplerClampLinear; - mSamplerNames[1] = "colorBuffer"; - samplerStates[2] = SamplerClampLinear; - mSamplerNames[2] = "matInfoBuffer"; - - mSamplerNames[3] = "BRDFTexture"; - mSamplerNames[4] = "cubeMap"; - mSamplerNames[5] = "irradianceCubemap"; - - cullDefined = true; - cullMode = GFXCullCW; - - stencilDefined = true; - stencilEnable = true; - stencilFailOp = GFXStencilOpKeep; - stencilZFailOp = GFXStencilOpKeep; - stencilPassOp = GFXStencilOpKeep; - stencilFunc = GFXCmpLess; - stencilRef = 0; -}; - -new CustomMaterial( ReflectionProbeMaterial ) -{ - shader = ReflectionProbeShader; - stateBlock = AL_ProbeState; - - sampler["deferredBuffer"] = "#deferred"; - sampler["matInfoBuffer"] = "#matinfo"; - - pixVersion = 3.0; -}; - -//Skylight +//Probe Processing new ShaderData( IrradianceShader ) { DXVertexShaderFile = "shaders/common/lighting/advanced/cubemapV.hlsl"; @@ -391,63 +304,49 @@ new ShaderData( PrefiterCubemapShader ) pixVersion = 3.0; }; -new ShaderData( SkyLightShader ) +// +singleton ShaderData( PFX_ReflectionProbeArray ) { - DXVertexShaderFile = "shaders/common/lighting/advanced/convexGeometryV.hlsl"; - DXPixelShaderFile = "shaders/common/lighting/advanced/skylightP.hlsl"; + DXVertexShaderFile = "shaders/common/postFx/postFxV.hlsl"; + DXPixelShaderFile = "shaders/common/lighting/advanced/reflectionProbeArrayP.hlsl"; - OGLVertexShaderFile = "shaders/common/lighting/advanced/gl/convexGeometryV.glsl"; - OGLPixelShaderFile = "shaders/common/lighting/advanced/gl/skylightP.glsl"; - - samplerNames[0] = "$deferredBuffer"; - samplerNames[1] = "$matInfoBuffer"; - samplerNames[2] = "$colorBuffer"; - samplerNames[3] = "$cubeMap"; - samplerNames[4] = "$irradianceCubemap"; - samplerNames[5] = "$BRDFTexture"; + //OGLVertexShaderFile = "shaders/common/postFx/gl//postFxV.glsl"; + //OGLPixelShaderFile = "shaders/common/postFx/gl/passthruP.glsl"; - pixVersion = 3.0; -}; - -new CustomMaterial( SkyLightMaterial ) -{ - shader = SkyLightShader; - stateBlock = AL_ProbeState; - - sampler["deferredBuffer"] = "#deferred"; - sampler["matInfoBuffer"] = "#matinfo"; - sampler["colorBuffer"] = "#color"; - - pixVersion = 3.0; -}; - -new ShaderData( ReflectionProbeArrayShader ) -{ - DXVertexShaderFile = "shaders/common/lighting/advanced/reflectionProbeArrayV.hlsl"; - DXPixelShaderFile = "shaders/common/lighting/advanced/reflectionProbeArrayP.hlsl"; - - OGLVertexShaderFile = "shaders/common/lighting/advanced/gl/reflectionProbeArrayV.glsl"; - OGLPixelShaderFile = "shaders/common/lighting/advanced/gl/reflectionProbeArrayP.glsl"; - samplerNames[0] = "$deferredBuffer"; samplerNames[1] = "$colorBuffer"; samplerNames[2] = "$matInfoBuffer"; samplerNames[3] = "$BRDFTexture"; samplerNames[4] = "$cubeMap"; samplerNames[5] = "$irradianceCubemap"; - - pixVersion = 3.0; + + pixVersion = 2.0; +}; + +singleton GFXStateBlockData( PFX_ReflectionProbeArrayStateBlock ) +{ + samplersDefined = true; + samplerStates[0] = SamplerClampLinear; }; -new CustomMaterial( ReflectionProbeArrayMaterial ) +singleton PostEffect( reflectionProbeArrayPostFX ) { - shader = ReflectionProbeArrayShader; - stateBlock = AL_ProbeState; + // Do not allow the selection effect to work in reflection + // passes by default so we don't do the extra drawing. + //allowReflectPass = false; + + renderTime = "PFXAfterBin"; + renderBin = "ProbeBin"; + renderPriority = 9999; + isEnabled = true; + + shader = PFX_ReflectionProbeArray; + stateBlock = PFX_ReflectionProbeArrayStateBlock; + + texture[0] = "#deferred"; + texture[1] = "#color"; + texture[2] = "#matinfo"; + texture[3] = "core/art/pbr/brdfTexture.dds"; - sampler["deferredBuffer"] = "#deferred"; - sampler["colorBuffer"] = "#color"; - sampler["matInfoBuffer"] = "#matinfo"; - sampler["BRDFTexture"] = "core/art/pbr/brdfTexture.dds"; - - pixVersion = 3.0; + target = "AL_FormatToken"; }; \ No newline at end of file diff --git a/Templates/Full/game/core/scripts/client/missionDownload.cs b/Templates/Full/game/core/scripts/client/missionDownload.cs index 78abee79f..d53464d20 100644 --- a/Templates/Full/game/core/scripts/client/missionDownload.cs +++ b/Templates/Full/game/core/scripts/client/missionDownload.cs @@ -89,6 +89,7 @@ function clientCmdMissionStartPhase3(%seq,%missionName) echo ("*** Phase 3: Mission Lighting"); $MSeq = %seq; $Client::MissionFile = %missionName; + $pref::ReflectionProbes::CurrentLevelPath = filePath($Client::MissionFile) @ "/" @ fileBase($Client::MissionFile) @ "/probes/"; // Need to light the mission before we are ready. // The sceneLightingComplete function will complete the handshake diff --git a/Templates/Full/game/levels/AProbeTest.mis b/Templates/Full/game/levels/AProbeTest.mis index e3969a879..c39162fef 100644 --- a/Templates/Full/game/levels/AProbeTest.mis +++ b/Templates/Full/game/levels/AProbeTest.mis @@ -39,11 +39,9 @@ new SimGroup(MissionGroup) { }; new Skylight() { enabled = "0"; - ProbeShape = "Box"; radius = "10"; posOffset = "0 0 0"; ReflectionMode = "Static Cubemap"; - reflectionPath = "levels/AProbeTest/probes/"; StaticCubemap = "sky_day_hdr_cubemap"; Bake = "0"; position = "0 0 0"; @@ -52,6 +50,8 @@ new SimGroup(MissionGroup) { canSave = "1"; canSaveDynamicFields = "1"; persistentId = "e4c73467-4089-11e8-b478-cd227cd60b8b"; + ProbeShape = "Box"; + reflectionPath = "levels/AProbeTest/probes/"; }; new SimGroup(PlayerDropPoints) { canSave = "1"; @@ -126,15 +126,13 @@ new SimGroup(MissionGroup) { canSaveDynamicFields = "1"; direction = "1 1 -1"; }; - new ReflectionProbe() { + new BoxEnvironmentProbe() { enabled = "1"; - ProbeShape = "Box"; radius = "5"; posOffset = "0 0 0"; ReflectionMode = "Baked Cubemap"; - reflectionPath = "levels/probeTest/probes/"; Bake = "0"; - position = "0 0.0825528 2.18272"; + position = "0 0 4"; rotation = "1 0 0 0"; scale = "5 5 5"; canSave = "1"; @@ -144,6 +142,65 @@ new SimGroup(MissionGroup) { IndirectLight = "1 1 1 1"; IndirectLightMode = "Spherical Harmonics"; Intensity = "1"; + ProbeShape = "Box"; + reflectionPath = "levels/probeTest/probes/"; + SkyColor = "0.5 0.5 1 1"; + }; + new BoxEnvironmentProbe() { + enabled = "1"; + radius = "5"; + posOffset = "0 0 0"; + ReflectionMode = "Baked Cubemap"; + Bake = "0"; + position = "-10 8 4"; + rotation = "1 0 0 0"; + scale = "5 5 5"; + canSave = "1"; + canSaveDynamicFields = "1"; + persistentId = "f281a5ff-1ae9-11e9-9c9a-df9135416cc7"; + GroundColor = "0.8 0.7 0.5 1"; + IndirectLight = "1 1 1 1"; + IndirectLightMode = "Spherical Harmonics"; + Intensity = "1"; + reflectionPath = "levels/probeTest/probes/"; + SkyColor = "0.5 0.5 1 1"; + }; + new BoxEnvironmentProbe() { + enabled = "1"; + radius = "5"; + posOffset = "0 0 0"; + ReflectionMode = "Baked Cubemap"; + Bake = "0"; + position = "-10 0 4"; + rotation = "1 0 0 0"; + scale = "5 5 5"; + canSave = "1"; + canSaveDynamicFields = "1"; + persistentId = "e9c2eed2-1ae9-11e9-9c9a-df9135416cc7"; + GroundColor = "0.8 0.7 0.5 1"; + IndirectLight = "1 1 1 1"; + IndirectLightMode = "Spherical Harmonics"; + Intensity = "1"; + reflectionPath = "levels/probeTest/probes/"; + SkyColor = "0.5 0.5 1 1"; + }; + new BoxEnvironmentProbe() { + enabled = "1"; + radius = "5"; + posOffset = "0 0 0"; + ReflectionMode = "Baked Cubemap"; + Bake = "0"; + position = "-10 -8 4"; + rotation = "1 0 0 0"; + scale = "5 5 5"; + canSave = "1"; + canSaveDynamicFields = "1"; + persistentId = "f4db4dde-1ae9-11e9-9c9a-df9135416cc7"; + GroundColor = "0.8 0.7 0.5 1"; + IndirectLight = "1 1 1 1"; + IndirectLightMode = "Spherical Harmonics"; + Intensity = "1"; + reflectionPath = "levels/probeTest/probes/"; SkyColor = "0.5 0.5 1 1"; }; new ConvexShape() { @@ -156,7 +213,7 @@ new SimGroup(MissionGroup) { surface = "0 0 0 1 0 0 0.5"; surface = "0 1 0 0 0 0 -0.5"; - surface = "0.707107 0 0 0.707106 0 0.5 0"; + surface = "0.707107 0 0 0.707107 0 0.5 0"; surface = "0 0.707107 -0.707107 0 0 -0.5 -2.84217e-14"; surface = "0.5 0.5 -0.5 0.5 -0.5 0 -9.93411e-08"; surface = "0.5 -0.5 0.5 0.5 0.5 0 -9.93411e-08"; @@ -171,7 +228,7 @@ new SimGroup(MissionGroup) { surface = "0 0 0 1 0 0 0.5"; surface = "0 1 0 0 0 0 -0.5"; - surface = "0.707107 0 0 0.707106 0 0.5 0"; + surface = "0.707107 0 0 0.707107 0 0.5 0"; surface = "0 0.707107 -0.707107 0 0 -0.5 -2.84217e-14"; surface = "0.5 0.5 -0.5 0.5 -0.5 0 -9.93411e-08"; surface = "0.5 -0.5 0.5 0.5 0.5 0 -9.93411e-08"; @@ -186,7 +243,7 @@ new SimGroup(MissionGroup) { surface = "0 0 0 1 0 0 0.5"; surface = "0 1 0 0 0 0 -0.5"; - surface = "0.707107 0 0 0.707107 0 0.5 0"; + surface = "0.707107 0 0 0.707106 0 0.5 0"; surface = "0 0.707107 -0.707107 0 0 -0.5 -2.84217e-14"; surface = "0.5 0.5 -0.5 0.5 -0.5 0 -9.93411e-08"; surface = "0.5 -0.5 0.5 0.5 0.5 0 -9.93411e-08"; @@ -201,7 +258,7 @@ new SimGroup(MissionGroup) { surface = "0 0 0 1 0 0 0.5"; surface = "0 1 0 0 0 0 -0.5"; - surface = "0.707107 0 0 0.707107 0 0.5 0"; + surface = "0.707107 0 0 0.707106 0 0.5 0"; surface = "0 0.707107 -0.707107 0 0 -0.5 -2.84217e-14"; surface = "0.5 0.5 -0.5 0.5 -0.5 0 -9.93411e-08"; surface = "0.5 -0.5 0.5 0.5 0.5 0 -9.93411e-08"; @@ -216,7 +273,7 @@ new SimGroup(MissionGroup) { surface = "0 0 0 1 0 0 0.5"; surface = "0 1 0 0 0 0 -0.5"; - surface = "0.707107 0 0 0.707107 0 0.5 0"; + surface = "0.707107 0 0 0.707106 0 0.5 0"; surface = "0 0.707107 -0.707107 0 0 -0.5 -2.84217e-14"; surface = "0.5 0.5 -0.5 0.5 -0.5 0 -9.93411e-08"; surface = "0.5 -0.5 0.5 0.5 0.5 0 -9.93411e-08"; @@ -231,7 +288,7 @@ new SimGroup(MissionGroup) { surface = "0 0 0 1 0 0 0.5"; surface = "0 1 0 0 0 0 -0.5"; - surface = "0.707107 0 0 0.707106 0 0.5 0"; + surface = "0.707107 0 0 0.707107 0 0.5 0"; surface = "0 0.707107 -0.707107 0 0 -0.5 -2.84217e-14"; surface = "0.5 0.5 -0.5 0.5 -0.5 0 -9.93411e-08"; surface = "0.5 -0.5 0.5 0.5 0.5 0 -9.93411e-08"; @@ -246,7 +303,7 @@ new SimGroup(MissionGroup) { surface = "0 0 0 1 0 0 0.5"; surface = "0 1 0 0 0 0 -0.5"; - surface = "0.707107 0 0 0.707107 0 0.5 0"; + surface = "0.707107 0 0 0.707106 0 0.5 0"; surface = "0 0.707107 -0.707107 0 0 -0.5 -2.84217e-14"; surface = "0.5 0.5 -0.5 0.5 -0.5 0 -9.93411e-08"; surface = "0.5 -0.5 0.5 0.5 0.5 0 -9.93411e-08"; @@ -313,65 +370,5 @@ new SimGroup(MissionGroup) { canSave = "1"; canSaveDynamicFields = "1"; }; - new ReflectionProbe() { - enabled = "1"; - ProbeShape = "Box"; - radius = "5"; - posOffset = "0 0 0"; - ReflectionMode = "Baked Cubemap"; - reflectionPath = "levels/probeTest/probes/"; - Bake = "0"; - position = "-8.24487 0.0825528 2.5031"; - rotation = "1 0 0 0"; - scale = "5 5 5"; - canSave = "1"; - canSaveDynamicFields = "1"; - persistentId = "e9c2eed2-1ae9-11e9-9c9a-df9135416cc7"; - GroundColor = "0.8 0.7 0.5 1"; - IndirectLight = "1 1 1 1"; - IndirectLightMode = "Spherical Harmonics"; - Intensity = "1"; - SkyColor = "0.5 0.5 1 1"; - }; - new ReflectionProbe() { - enabled = "1"; - ProbeShape = "Box"; - radius = "5"; - posOffset = "0 0 0"; - ReflectionMode = "Baked Cubemap"; - reflectionPath = "levels/probeTest/probes/"; - Bake = "0"; - position = "-8.24487 3.18253 2.18272"; - rotation = "1 0 0 0"; - scale = "5 5 5"; - canSave = "1"; - canSaveDynamicFields = "1"; - persistentId = "f281a5ff-1ae9-11e9-9c9a-df9135416cc7"; - GroundColor = "0.8 0.7 0.5 1"; - IndirectLight = "1 1 1 1"; - IndirectLightMode = "Spherical Harmonics"; - Intensity = "1"; - SkyColor = "0.5 0.5 1 1"; - }; - new ReflectionProbe() { - enabled = "1"; - ProbeShape = "Box"; - radius = "5"; - posOffset = "0 0 0"; - ReflectionMode = "Baked Cubemap"; - reflectionPath = "levels/probeTest/probes/"; - Bake = "0"; - position = "-8.24487 -3.37372 2.18272"; - rotation = "1 0 0 0"; - scale = "5 5 5"; - canSave = "1"; - canSaveDynamicFields = "1"; - persistentId = "f4db4dde-1ae9-11e9-9c9a-df9135416cc7"; - GroundColor = "0.8 0.7 0.5 1"; - IndirectLight = "1 1 1 1"; - IndirectLightMode = "Spherical Harmonics"; - Intensity = "1"; - SkyColor = "0.5 0.5 1 1"; - }; }; //--- OBJECT WRITE END --- diff --git a/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeArrayP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeArrayP.hlsl index 0eede5cd2..ad6dc7158 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeArrayP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeArrayP.hlsl @@ -1,8 +1,7 @@ +#include "../../postFx/postFx.hlsl" +#include "../../shaderModel.hlsl" #include "../../shaderModelAutoGen.hlsl" - -#include "farFrustumQuad.hlsl" #include "../../lighting.hlsl" -#include "../../torque.hlsl" TORQUE_UNIFORM_SAMPLER2D(deferredBuffer, 0); TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 1); @@ -21,13 +20,15 @@ uniform float cubeMips; uniform float numProbes; TORQUE_UNIFORM_SAMPLERCUBEARRAY(cubeMapAR, 4); TORQUE_UNIFORM_SAMPLERCUBEARRAY(irradianceCubemapAR, 5); +//TORQUE_UNIFORM_SAMPLERCUBE(cubeMapAR, 4); +//TORQUE_UNIFORM_SAMPLERCUBE(irradianceCubemapAR, 5); uniform float4 inProbePosArray[MAX_PROBES]; uniform float4x4 worldToObjArray[MAX_PROBES]; uniform float4 bbMinArray[MAX_PROBES]; uniform float4 bbMaxArray[MAX_PROBES]; -uniform float useSphereMode[MAX_PROBES]; -uniform float radius[MAX_PROBES]; -uniform float2 attenuation[MAX_PROBES]; +uniform float4 useSphereMode[MAX_PROBES]; +uniform float4 radius[MAX_PROBES]; +uniform float4 attenuation[MAX_PROBES]; // Box Projected IBL Lighting // Based on: http://www.gamedev.net/topic/568829-box-projected-cubemap-environment-mapping/ @@ -51,6 +52,7 @@ float3 iblBoxDiffuse( Surface surface, int id) float3 cubeN = boxProject(surface.P, surface.N, inProbePosArray[id].xyz, bbMinArray[id].xyz, bbMaxArray[id].xyz); cubeN.z *=-1; return TORQUE_TEXCUBEARRAYLOD(irradianceCubemapAR,cubeN,id,0).xyz; + //return TORQUE_TEXCUBELOD(irradianceCubemapAR,float4(cubeN,0)).xyz; } float3 iblBoxSpecular(Surface surface, float3 surfToEye, TORQUE_SAMPLER2D(brdfTexture), int id) @@ -67,6 +69,7 @@ float3 iblBoxSpecular(Surface surface, float3 surfToEye, TORQUE_SAMPLER2D(brdfTe cubeR = boxProject(surface.P, surface.N, inProbePosArray[id].xyz, bbMinArray[id].xyz, bbMaxArray[id].xyz); float3 radiance = TORQUE_TEXCUBEARRAYLOD(cubeMapAR,cubeR,id,lod).xyz * (brdf.x + brdf.y); + //float3 radiance = TORQUE_TEXCUBELOD(cubeMapAR,float4(cubeR,lod)).xyz * (brdf.x + brdf.y); return radiance; } @@ -76,8 +79,8 @@ float defineBoxSpaceInfluence(Surface surface, int id) float tempAttenVal = 3.5; //replace with per probe atten float3 surfPosLS = mul( worldToObjArray[id], float4(surface.P,1.0)).xyz; - float3 boxMinLS = inProbePosArray[id].xyz-(float3(1,1,1)*radius[0]); - float3 boxMaxLS = inProbePosArray[id].xyz+(float3(1,1,1)*radius[0]); + float3 boxMinLS = inProbePosArray[id].xyz-(float3(1,1,1)*radius[0].x); + float3 boxMaxLS = inProbePosArray[id].xyz+(float3(1,1,1)*radius[0].x); float boxOuterRange = length(boxMaxLS - boxMinLS); float boxInnerRange = boxOuterRange / tempAttenVal; @@ -88,11 +91,11 @@ float defineBoxSpaceInfluence(Surface surface, int id) return max(localDir.x, max(localDir.y, localDir.z)) * -1; } -float4 main( FarFrustumQuadConnectP IN ) : SV_TARGET +float4 main( PFXVertToPix IN ) : SV_TARGET { //unpack normal and linear depth float4 normDepth = TORQUE_DEFERRED_UNCONDITION(deferredBuffer, IN.uv0.xy); - + //create surface Surface surface = createSurface( normDepth, TORQUE_SAMPLER2D_MAKEARG(colorBuffer),TORQUE_SAMPLER2D_MAKEARG(matInfoBuffer), IN.uv0.xy, eyePosWorld, IN.wsEyeRay, cameraToWorld); @@ -102,29 +105,30 @@ float4 main( FarFrustumQuadConnectP IN ) : SV_TARGET { discard; } - float blendVal[MAX_PROBES]; + + float blendVal[MAX_PROBES]; float3 surfToEye = normalize(surface.P - eyePosWorld); int i = 0; - float blendSum = 0; - float invBlendSum = 0; + float blendSum = 0; + float invBlendSum = 0; for(i=0; i < numProbes; i++) { float3 probeWS = inProbePosArray[i].xyz; float3 L = probeWS - surface.P; - if(useSphereMode[i]) + /*if(useSphereMode[i]) { float3 L = inProbePosArray[i].xyz - surface.P; blendVal[i] = 1.0-length(L)/radius[i]; blendVal[i] = max(0,blendVal[i]); } else - { + {*/ blendVal[i] = defineBoxSpaceInfluence(surface, i); blendVal[i] = max(0,blendVal[i]); - } + //} blendSum += blendVal[i]; invBlendSum +=(1.0f - blendVal[i]); } @@ -141,6 +145,13 @@ float4 main( FarFrustumQuadConnectP IN ) : SV_TARGET blendSum += blendVal[i]; } + float finalSum = blendSum; + + //return TORQUE_TEX2D(colorBuffer, IN.uv0.xy); + //return float4(surface.N,1); + //return float4(1,1,1, 1); + //return float4(finalSum,finalSum,finalSum, 1); + // Normalize blendVal if (blendSum == 0.0f) // Possible with custom weight { @@ -162,11 +173,13 @@ float4 main( FarFrustumQuadConnectP IN ) : SV_TARGET kD *= 1.0 - surface.metalness; for (i = 0; i < numProbes; ++i) { - irradiance += blendVal[i]*iblBoxDiffuse(surface,i); + irradiance += float3(blendVal[i],blendVal[i],blendVal[i])/*blendVal[i]*iblBoxDiffuse(surface,i)*/; specular += blendVal[i]*F*iblBoxSpecular(surface, surfToEye, TORQUE_SAMPLER2D_MAKEARG(BRDFTexture),i); } //final diffuse color float3 diffuse = kD * irradiance * surface.baseColor.rgb; - return float4(diffuse + specular * surface.ao, blendSum); + float4 finalColor = float4(diffuse + specular * surface.ao, 1); + + return finalColor; } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeArrayV.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeArrayV.hlsl deleted file mode 100644 index 9fa2eda0e..000000000 --- a/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeArrayV.hlsl +++ /dev/null @@ -1,52 +0,0 @@ -//----------------------------------------------------------------------------- -// 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 "../../hlslStructs.hlsl" -#include "../../shaderModel.hlsl" -#include "../../torque.hlsl" - -struct GFXVertexPT -{ - float3 pos : POSITION; - float4 uv : TEXCOORD1; -}; - -struct ConnectData -{ - float4 hpos : TORQUE_POSITION; - float4 uv0 : TEXCOORD1; - float4 vsEyeDir : TEXCOORD2; -}; - -uniform float4 rtParams0; -uniform float4x4 worldViewOnly; - -ConnectData main( GFXVertexPT IN ) -{ - ConnectData OUT; - - OUT.hpos = float4(IN.pos,1.0); - OUT.uv0 = float4(viewportCoordToRenderTarget( IN.uv, rtParams0 ),0,0); - OUT.vsEyeDir = mul(worldViewOnly, float4(IN.pos, 1.0)); - - return OUT; -} diff --git a/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeP.hlsl deleted file mode 100644 index 2288fc078..000000000 --- a/Templates/Full/game/shaders/common/lighting/advanced/reflectionProbeP.hlsl +++ /dev/null @@ -1,171 +0,0 @@ -#include "../../shaderModelAutoGen.hlsl" - -#include "farFrustumQuad.hlsl" -#include "../../lighting.hlsl" -#include "../../torque.hlsl" - -struct ConvexConnectP -{ - float4 pos : TORQUE_POSITION; - float4 wsEyeDir : TEXCOORD0; - float4 ssPos : TEXCOORD1; - float4 vsEyeDir : TEXCOORD2; -}; - -TORQUE_UNIFORM_SAMPLER2D(deferredBuffer, 0); -TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 1); -TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 2); -TORQUE_UNIFORM_SAMPLERCUBE(cubeMap, 3); -TORQUE_UNIFORM_SAMPLERCUBE(irradianceCubemap, 4); -TORQUE_UNIFORM_SAMPLER2D(BRDFTexture, 5); -uniform float cubeMips; - -uniform float4 rtParams0; - -uniform float3 probeWSPos; -uniform float3 probeLSPos; -uniform float4 vsFarPlane; - -uniform float radius; -uniform float2 attenuation; - -uniform float4x4 worldToObj; -uniform float4x4 cameraToWorld; - -uniform float3 eyePosWorld; -uniform float3 bbMin; -uniform float3 bbMax; - -uniform float useSphereMode; - -#define MAX_PROBES 50 - -uniform float numProbes; -uniform float3 inProbePosArray[MAX_PROBES]; - -// 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 = 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; -} - -float3 iblBoxSpecular(float3 normal, float3 wsPos, float roughness, float3 surfToEye, - TORQUE_SAMPLER2D(brdfTexture), - TORQUE_SAMPLERCUBE(radianceCube), - float3 boxPos, - float3 boxMin, - float3 boxMax) -{ - float ndotv = clamp(dot(normal, surfToEye), 0.0, 1.0); - - // BRDF - float2 brdf = TORQUE_TEX2DLOD(brdfTexture, float4(roughness, ndotv,0.0,0.0)).xy; - - // Radiance (Specular) - 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); - - float3 radiance = TORQUE_TEXCUBELOD(radianceCube, float4(cubeR, lod)).xyz * (brdf.x + brdf.y); - - return radiance; -} - -float defineBoxSpaceInfluence(float3 surfPosWS, float3 probePos, float radius, float atten) -{ - float3 surfPosLS = mul( worldToObj, float4(surfPosWS,1.0)).xyz; - - float3 boxMinLS = probePos-(float3(1,1,1)*radius); - float3 boxMaxLS = probePos+(float3(1,1,1)*radius); - - float boxOuterRange = length(boxMaxLS - boxMinLS); - float boxInnerRange = boxOuterRange / atten; - - float3 localDir = float3(abs(surfPosLS.x), abs(surfPosLS.y), abs(surfPosLS.z)); - localDir = (localDir - boxInnerRange) / (boxOuterRange - boxInnerRange); - - return max(localDir.x, max(localDir.y, localDir.z)) * -1; -} - -float4 main( ConvexConnectP IN ) : SV_TARGET -{ - // Compute scene UV - float3 ssPos = IN.ssPos.xyz / IN.ssPos.w; - float2 uvScene = getUVFromSSPos( ssPos, rtParams0 ); - - //eye ray WS/LS - float3 vsEyeRay = getDistanceVectorToPlane( -vsFarPlane.w, IN.vsEyeDir.xyz, vsFarPlane ); - float3 wsEyeRay = mul(cameraToWorld, float4(vsEyeRay, 0)).xyz; - - //unpack normal and linear depth - float4 normDepth = TORQUE_DEFERRED_UNCONDITION(deferredBuffer, uvScene); - - //create surface - Surface surface = createSurface( normDepth, TORQUE_SAMPLER2D_MAKEARG(colorBuffer),TORQUE_SAMPLER2D_MAKEARG(matInfoBuffer), - uvScene, eyePosWorld, wsEyeRay, cameraToWorld); - float blendVal = 1.0; - /*if(useSphereMode) - { - float3 L = probeWSPos - surface.P; - blendVal = 1.0-length(L)/radius; - clip(blendVal); - } - else - { - float tempAttenVal = 3.5; - blendVal = defineBoxSpaceInfluence(surface.P, probeWSPos, radius, tempAttenVal); - clip(blendVal); - float compression = 0.05; - blendVal=(1.0-compression)+blendVal*compression; - }*/ - - float3 surfToEye = normalize(surface.P - eyePosWorld); - float3 irradiance = TORQUE_TEXCUBELOD(irradianceCubemap, float4(surface.N,0)).xyz; - float3 specular = iblBoxSpecular(surface.N, surface.P, surface.roughness, surfToEye, TORQUE_SAMPLER2D_MAKEARG(BRDFTexture), TORQUE_SAMPLERCUBE_MAKEARG(cubeMap), probeWSPos, bbMin, bbMax); - - int i; - irradiance = float3(0,0,0); - float blendSum = 0.00001; - for(i=0; i < numProbes; i++) - { - float3 probeWS = inProbePosArray[i]; - - float3 L = probeWS - surface.P; - blendVal = 1.0-length(L)/radius; - blendVal = max(0,blendVal); - - irradiance += float3(blendVal,blendVal,blendVal); - specular = irradiance; - blendSum += blendVal; - } - //irradiance /= blendSum; - //specular /= blendSum; - blendSum /= numProbes; - - //render into the bound space defined above - // - //float3 irradiance = TORQUE_TEXCUBELOD(irradianceCubemap, float4(surface.N,0)).xyz; - //float3 specular = iblBoxSpecular(surface.N, surface.P, surface.roughness, surfToEye, TORQUE_SAMPLER2D_MAKEARG(BRDFTexture), TORQUE_SAMPLERCUBE_MAKEARG(cubeMap), probeWSPos, bbMin, bbMax); - float3 F = FresnelSchlickRoughness(surface.NdotV, surface.f0, surface.roughness); - specular *= F; - //energy conservation - float3 kD = 1.0.xxx - F; - kD *= 1.0 - surface.metalness; - //final diffuse color - float3 diffuse = kD * irradiance * surface.baseColor.rgb; - - return float4(diffuse + specular * surface.ao, blendSum); -} diff --git a/Templates/Full/game/shaders/common/lighting/advanced/skylightP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/skylightP.hlsl deleted file mode 100644 index 3bf8c111f..000000000 --- a/Templates/Full/game/shaders/common/lighting/advanced/skylightP.hlsl +++ /dev/null @@ -1,62 +0,0 @@ -#include "../../shaderModelAutoGen.hlsl" - -#include "farFrustumQuad.hlsl" -#include "../../lighting.hlsl" -#include "../../torque.hlsl" - -struct ConvexConnectP -{ - float4 pos : TORQUE_POSITION; - float4 wsEyeDir : TEXCOORD0; - float4 ssPos : TEXCOORD1; - float4 vsEyeDir : TEXCOORD2; -}; - -TORQUE_UNIFORM_SAMPLER2D(deferredBuffer, 0); -TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 1); -TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 2); -TORQUE_UNIFORM_SAMPLERCUBE(cubeMap, 3); -TORQUE_UNIFORM_SAMPLERCUBE(irradianceCubemap, 4); -TORQUE_UNIFORM_SAMPLER2D(BRDFTexture, 5); - -uniform float4 rtParams0; -uniform float4 vsFarPlane; -uniform float4x4 cameraToWorld; -uniform float3 eyePosWorld; - -float3 iblSpecular(in Surface surface, float3 F) -{ - const float MAX_REFLECTION_LOD = 4.0; - float3 prefilteredColor = TORQUE_TEXCUBELOD(cubeMap, float4(surface.R, surface.roughness * MAX_REFLECTION_LOD)).rgb; - float2 envBRDF = TORQUE_TEX2D(BRDFTexture, float2(surface.NdotV, surface.roughness)).rg; - return prefilteredColor * (F * envBRDF.x + envBRDF.y); -} - -float4 main( ConvexConnectP IN ) : SV_TARGET -{ - // Compute scene UV - float3 ssPos = IN.ssPos.xyz / IN.ssPos.w; - float2 uvScene = getUVFromSSPos( ssPos, rtParams0 ); - - //eye ray WS/LS - float3 vsEyeRay = getDistanceVectorToPlane( -vsFarPlane.w, IN.vsEyeDir.xyz, vsFarPlane ); - float3 wsEyeRay = mul(cameraToWorld, float4(vsEyeRay, 0)).xyz; - - //unpack normal and linear depth - float4 normDepth = TORQUE_DEFERRED_UNCONDITION(deferredBuffer, uvScene); - - //create surface - Surface surface = createSurface( normDepth, TORQUE_SAMPLER2D_MAKEARG(colorBuffer),TORQUE_SAMPLER2D_MAKEARG(matInfoBuffer), - uvScene, eyePosWorld, wsEyeRay, cameraToWorld); - - float3 F = FresnelSchlickRoughness(surface.NdotV, surface.f0, surface.roughness); - float3 irradiance = TORQUE_TEXCUBELOD(irradianceCubemap, float4(surface.N,0)).rgb; - float3 specular = iblSpecular(surface, F); - //energy conservation - float3 kD = 1.0.xxx - F; - kD *= 1.0 - surface.metalness; - //final diffuse color - float3 diffuse = kD * irradiance * surface.baseColor.rgb; - - return float4(diffuse + specular * surface.ao, 0); -} diff --git a/Templates/Full/game/tools/worldEditor/scripts/editors/creator.ed.cs b/Templates/Full/game/tools/worldEditor/scripts/editors/creator.ed.cs index 712986e38..22c823b1f 100644 --- a/Templates/Full/game/tools/worldEditor/scripts/editors/creator.ed.cs +++ b/Templates/Full/game/tools/worldEditor/scripts/editors/creator.ed.cs @@ -56,7 +56,8 @@ function EWCreatorWindow::init( %this ) %this.registerMissionObject( "PointLight", "Point Light" ); %this.registerMissionObject( "SpotLight", "Spot Light" ); - %this.registerMissionObject( "ReflectionProbe", "Reflection Probe" ); + %this.registerMissionObject( "BoxEnvironmentProbe", "Box Environment Probe" ); + %this.registerMissionObject( "SphereEnvironmentProbe", "Sphere Environment Probe" ); %this.registerMissionObject( "Skylight", "Skylight" ); %this.registerMissionObject( "GroundCover", "Ground Cover" ); diff --git a/Templates/Full/game/tools/worldEditor/scripts/lighting.ed.cs b/Templates/Full/game/tools/worldEditor/scripts/lighting.ed.cs index f9afcaad4..180504f38 100644 --- a/Templates/Full/game/tools/worldEditor/scripts/lighting.ed.cs +++ b/Templates/Full/game/tools/worldEditor/scripts/lighting.ed.cs @@ -64,18 +64,5 @@ function EditorLightingMenu::onMenuSelect( %this ) function updateReflectionProbes() { - /*%probeIds = parseMissionGroupForIds("ReflectionProbe", ""); - %probeCount = getWordCount(%probeIds); - - for(%i=0; %i < %probeCount; %i++) - { - %probe = getWord(%probeIds, %i); - - %path = filePath($Server::MissionFile) @ "/" @ fileBase($Server::MissionFile) @ "/probes/"; - %probe.bake(%path, 64); - } - - EWorldEditor.isDirty = true;*/ - - Canvas.pushDialog(ProbeBakeDlg); + Canvas.pushDialog(ProbeBakeDlg); } diff --git a/Templates/Full/game/tools/worldEditor/scripts/probeBake.ed.cs b/Templates/Full/game/tools/worldEditor/scripts/probeBake.ed.cs index 981658d91..9c561e0bf 100644 --- a/Templates/Full/game/tools/worldEditor/scripts/probeBake.ed.cs +++ b/Templates/Full/game/tools/worldEditor/scripts/probeBake.ed.cs @@ -16,14 +16,16 @@ function ProbeBakeDlg::onWake(%this) function ProbeBakeDlg_RunBake::onClick(%this) { - %probeIds = parseMissionGroupForIds("ReflectionProbe", ""); + %boxProbeIds = parseMissionGroupForIds("BoxEnvironmentProbe", ""); + %sphereProbeIds = parseMissionGroupForIds("SphereEnvironmentProbe", ""); %skylightIds = parseMissionGroupForIds("Skylight", ""); + %probeIds = rtrim(ltrim(%boxProbeIds SPC %sphereProbeIds)); %probeIds = rtrim(ltrim(%probeIds SPC %skylightIds)); %probeCount = getWordCount(%probeIds); %numIter = ProbeBakeDlg_NumIterTxt.getText(); - %resolution = ProbeBakeDlg_ProbeResList.getText(); + $pref::ReflectionProbes::BakeResolution = ProbeBakeDlg_ProbeResList.getText(); %progressStep = 100 / (%numIter * %probeCount); %currentProgressValue = 0; @@ -32,17 +34,17 @@ function ProbeBakeDlg_RunBake::onClick(%this) for(%iter=0; %iter < %numIter; %iter++) { - %renderWithProbes = false; + $pref::ReflectionProbes::RenderWithProbes = false; if(%iter != 0) - %renderWithProbes = true; + $pref::ReflectionProbes::RenderWithProbes = true; for(%i=0; %i < %probeCount; %i++) { %probe = getWord(%probeIds, %i); - %path = filePath($Server::MissionFile) @ "/" @ fileBase($Server::MissionFile) @ "/probes/"; - %probe.bake(%path, %resolution, %renderWithProbes); + $pref::ReflectionProbes::CurrentLevelPath = filePath($Server::MissionFile) @ "/" @ fileBase($Server::MissionFile) @ "/probes/"; + ProbeBin.bakeProbe(%probe); %currentProgressValue += %progressStep; ProbeBakeDlg_Progress.setValue(%currentProgressValue);