DO NOT MERGE probe atlas RnD

Engine/source/T3D/assets/assetImporter.cpp

@@ -813,7 +813,7 @@ String AssetImporter::getAssetTypeByFile(Torque::Path filePath)
    if (fileExt == String("dts") && fileName.endsWith("cached"))
       return "";
 
-   if (fileExt == String("png") || fileExt == String("jpg") || fileExt == String("jpeg") || fileExt == String("dds"))
+   if (fileExt == String("png") || fileExt == String("jpg") || fileExt == String("jpeg") || fileExt == String("dds") || fileExt == String("bmp"))
       return "ImageAsset";
    else if (fileExt == String("dae") || fileExt == String("fbx") || fileExt == String("blend") || fileExt == String("obj") || fileExt == String("dts") || fileExt == String("gltf") || fileExt == String("glb"))
       return "ShapeAsset";

Engine/source/gfx/bitmap/bitmapUtils.h

@@ -41,10 +41,8 @@ extern void (*bitmapExtrudeRGBA)(const void *srcMip, void *mip, U32 height, U32
 extern void (*bitmapExtrude16BitRGBA)(const void *srcMip, void *mip, U32 height, U32 width, U32 bpp);
 extern void(*bitmapExtrudeFPRGBA)(const void *srcMip, void *mip, U32 height, U32 width, U32 bpp);
 extern void(*bitmapExtrudeF32RGBA)(const void *srcMip, void *mip, U32 height, U32 width, U32 bpp);
-
 extern void(*bitmapResizeToOutput)(const void* src, U32 srcHeight, U32 srcWidth, void* out, U32 outHeight, U32 outWidth, U32 bpp, GFXFormat format);
 extern bool(*bitmapConvertToOutput)(U8** src, U32 pixels, GFXFormat srcFormat, GFXFormat dstFormat);
-
 extern void (*bitmapConvertRGB_to_5551)(U8 *src, U32 pixels);
 extern void (*bitmapConvertRGB_to_1555)(U8 *src, U32 pixels);
 extern void (*bitmapConvertRGB_to_RGBX)( U8 **src, U32 pixels );
@@ -145,7 +143,6 @@ inline U16 convertFloatToHalf(F32 f)
       return (U16)(sign | (exp << 10) | (mant >> 13));
    }
 }
-
 // Convert a single 16-bit value (0..65535) to 8-bit (0..255)
 inline U8 convert16To8(U16 v16)
 {
@@ -165,5 +162,4 @@ inline U8 floatTo8(F32 v)
    return U8(mClamp(v * 255.f, 0.f, 255.f));
 }
 
-
 #endif //_BITMAPUTILS_H_

Engine/source/gfx/bitmap/ddsData.h

@@ -281,6 +281,7 @@ namespace dds
    #define DDS_MAGIC       0x20534444  // "DDS "
    #define DDS_FOURCC      0x00000004  // DDPF_FOURCC
    #define DDS_RGB         0x00000040  // DDPF_RGB
+   #define DDS_R32F        0x00000072  // R32F Fourcc
    #define DDS_RGBA        0x00000041  // DDPF_RGB | DDPF_ALPHAPIXELS
    #define DDS_LUMINANCE   0x00020000  // DDPF_LUMINANCE
    #define DDS_LUMINANCEA  0x00020001  // DDPF_LUMINANCE | DDPF_ALPHAPIXELS
@@ -517,6 +518,9 @@ namespace dds
    const DDS_PIXELFORMAT DDSPF_V16U16 =
    { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x0000ffff, 0xffff0000, 0x00000000, 0x00000000 };
 
+   const DDS_PIXELFORMAT DDSPF_F32 =
+   { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, DDS_R32F, 32, 0, 0, 0, 0 };
+
    // D3DFMT_A2R10G10B10/D3DFMT_A2B10G10R10 should be written using DX10 extension to avoid D3DX 10:10:10:2 reversal issue
 
    // This indicates the DDS_HEADER_DXT10 extension is present (the format is in dxgiFormat)
@@ -547,6 +551,7 @@ namespace dds
          case GFXFormatB8G8R8A8: return DDSPF_A8B8G8R8;
          case GFXFormatR16G16B16A16F:
          case GFXFormatR32G32B32A32F: return DDSPF_DX10;
+         case GFXFormatR32F:     return DDSPF_F32;
          //compressed
          case GFXFormatBC1:      return DDSPF_DXT1;
          case GFXFormatBC2:      return DDSPF_DXT3;
@@ -712,6 +717,8 @@ namespace dds
          return GFXFormatR5G6B5;
       else if (format == DDSPF_A1R5G5B5)
          return GFXFormatR5G5B5A1;
+      else if (format == DDSPF_F32)
+         return GFXFormatR32F;
       else
       {
          Con::errorf("dds::getGFXFormat: unknown format");
@@ -734,6 +741,7 @@ namespace dds
          case D3DFMT_A16B16G16R16F: return GFXFormatR16G16B16A16F;
          case D3DFMT_A32B32G32R32F: return GFXFormatR32G32B32A32F;
          case D3DFMT_G16R16F: return GFXFormatR16G16F;
+         case D3DFMT_R32F: return GFXFormatR32F;            
          default:
          {
             Con::errorf("dds::getGFXFormatFourcc: unknown format");
@@ -905,4 +913,4 @@ namespace dds
 
 }
 
-#endif
+#endif

Engine/source/renderInstance/renderProbeMgr.cpp

@@ -139,6 +139,7 @@ void ProbeShaderConstants::init(GFXShader* shader)
    mProbeCountSC = shader->getShaderConstHandle(ShaderGenVars::probeCount);
 
    mBRDFTextureMap = shader->getShaderConstHandle(ShaderGenVars::BRDFTextureMap);
+   mProbeAtlasMap = shader->getShaderConstHandle(ShaderGenVars::ProbeAtlasMap);
    mWetnessTextureMap = shader->getShaderConstHandle(ShaderGenVars::WetnessTextureMap);
 
    mSkylightCubemapIdxSC = shader->getShaderConstHandle(ShaderGenVars::skylightCubemapIdx);   
@@ -177,7 +178,8 @@ RenderProbeMgr::RenderProbeMgr()
    mSkylightCubemapIdx(-1),
    mSkylightDamp(true),
    mCubeMapCount(0),
-   mUseHDRCaptures(true)
+   mUseHDRCaptures(true),
+   mProbeAtlas(NULL)
 {
    mEffectiveProbeCount = 0;
    mMipCount = 0;
@@ -803,6 +805,11 @@ void RenderProbeMgr::_update4ProbeConsts(const SceneData& sgData,
       if (mBRDFTexture.isValid() && probeShaderConsts->mBRDFTextureMap->getSamplerRegister() != -1)
          GFX->setTexture(probeShaderConsts->mBRDFTextureMap->getSamplerRegister(), mBRDFTexture);
 
+
+      if (mBRDFTexture.isValid() && probeShaderConsts->mBRDFTextureMap->getSamplerRegister() != -1)
+         GFX->setTexture(probeShaderConsts->mBRDFTextureMap->getSamplerRegister(), mBRDFTexture);
+
+
       if (mWetnessTexture.isValid() && probeShaderConsts->mWetnessTextureMap->getSamplerRegister() != -1)
          GFX->setTexture(probeShaderConsts->mWetnessTextureMap->getSamplerRegister(), mWetnessTexture);
 
@@ -881,6 +888,19 @@ void RenderProbeMgr::render( SceneRenderState *state )
    mProbeArrayEffect->setTexture(4, mPrefilterArray);
    mProbeArrayEffect->setTexture(5, mIrradianceArray);
    mProbeArrayEffect->setTexture(6, mWetnessTexture);
+
+   if (mProbeAtlas)
+   {
+      if (mProbeAtlasTexture.set(mProbeAtlas, &GFXTexturePersistentProfile, false, "atlasTexture"))
+      {
+         mProbeArrayEffect->setTexture(7, mProbeAtlasTexture);
+         //mProbeArrayEffect->setShaderConst("$numAtlasEntries", (S32)10); //make adaptive
+      }
+   }
+   else
+   {
+      mProbeArrayEffect->setTexture(7, GFXTexHandle(NULL));
+   }
    //ssao mask
    if (AdvancedLightBinManager::smUseSSAOMask)
    {
@@ -890,13 +910,11 @@ void RenderProbeMgr::render( SceneRenderState *state )
       if (pTexObj)
       {
          mProbeArrayEffect->setShaderMacro("USE_SSAO_MASK");
-         mProbeArrayEffect->setTexture(7, pTexObj);
+         mProbeArrayEffect->setTexture(8, pTexObj);
       }
    }
-   else
-   {
-      mProbeArrayEffect->setTexture(7, GFXTexHandle(NULL));
-   }
+
+
    mProbeArrayEffect->setShaderConst("$numProbes", (S32)mProbeData.effectiveProbeCount);
    mProbeArrayEffect->setShaderConst("$skylightCubemapIdx", (S32)mProbeData.skyLightIdx);
    mProbeArrayEffect->setShaderConst(ShaderGenVars::skylightDamp, mProbeData.skyLightDamp);
@@ -942,7 +960,104 @@ void RenderProbeMgr::render( SceneRenderState *state )
    // Make sure the effect is gonna render.
    getProbeArrayEffect()->setSkip(false);
 }
+#pragma pack(push, 4)
+struct ProbeSerialize
+{
+   F32 ambientCol[4]{0,1.0,0,1.0};
+   F32 xForm[4][4];
+   F32 offset[3]{ 0.0,0.0,0.0 };
+   F32 refScale[3]{ 0.0,0.0,0.0 };
+   F32 type = 0;//(U8)(ProbeInfo::Box);
+   F32 radius = 5;
+   F32 scale = 10;
+   F32 attenuation = 0;
+   U32 flags = BIT(0); //[0]canDamp
+};
+#pragma pack(pop)
+
+#define  probeDataLength (U32)(sizeof(ProbeSerialize) / 4)
+void RenderProbeMgr::serializeProbes()
+{
+   U32 count = 10;
+   U32 probeAllocSize = sizeof(ProbeSerialize) * count;
+   ProbeSerialize* saveBuffer = (ProbeSerialize*)dMalloc(probeAllocSize);
+   for (U32 i = 0; i < count; i++)
+   {
+      ProbeSerialize pSer;
+      MatrixF inmat = MatrixF(Point3F(0,0,0), Point3F(-5.0f + i * 10, 100.0f + i * 10, 0.0f));
+      inmat.scale(10);
+      for (U32 x = 0; x < 4; x++)
+      {
+         for (U32 y = 0; y < 4; y++)
+         {
+            pSer.xForm[x][y] = inmat(x, y);
+         }
+      }
+      saveBuffer[i] = pSer; // ensures defaults are applied
+
+   }
+
+   F32* checkPack = (F32*)dMalloc(probeAllocSize);
+   memcpy(checkPack, saveBuffer, probeAllocSize);
+   for (U32 i = 0; i < probeDataLength; i++)
+   {
+      Con::warnf("packed[%i]: %f",i, checkPack[i]);
+   }
+
+   DDSFile dataFile;
+   dataFile.mFormat = GFXFormatR32F;
+   dataFile.mBytesPerPixel = 4;
+   dataFile.mHeight = count;
+   dataFile.mWidth = probeDataLength;
+   dataFile.mMipMapCount = 1;
+   dataFile.mSurfaces.push_back(new DDSFile::SurfaceData);
+   dataFile.mSurfaces.last()->mMips.push_back(reinterpret_cast<U8*>(checkPack));
+
+   FileStream* out = FileStream::createAndOpen(Con::getVariable("$Probes::AtlasTexture"), Torque::FS::File::Write);
+   dataFile.write(*out);
+   out->close();
+   free(saveBuffer);
+   mProbeAtlas = dataFile.load(Con::getVariable("$Probes::AtlasTexture"), 0);
+}
+
+void RenderProbeMgr::testProbeAtlas()
+{
+   U32 count = 10;
+   DDSFile dataFile;
+   mProbeAtlas = dataFile.load(Con::getVariable("$Probes::AtlasTexture"),0);
+
+   U32 probeAllocSize = sizeof(F32) * probeDataLength * count;
+   ProbeSerialize* readBuffer = (ProbeSerialize*)dMalloc(probeAllocSize);
+   const void* dataStart = mProbeAtlas->mSurfaces[0]->mMips[0];
+   memcpy(readBuffer, dataStart, probeAllocSize);
+
+   MatrixF inmat;
+   for (U32 x = 0; x < 4; x++)
+   {
+      for (U32 y = 0; y < 4; y++)
+      {
+         inmat(x, y) = readBuffer[0].xForm[x][y];
+      }
+   }
+
+   Con::warnf(" ambient: %f %f %f %f", readBuffer[0].ambientCol[0], readBuffer[0].ambientCol[1], readBuffer[0].ambientCol[2], readBuffer[0].ambientCol[3]);
+   Con::warnf("worldPos: %f %f %f", inmat.getPosition().x, inmat.getPosition().y, inmat.getPosition().z);
+   Con::warnf("rotation: %f %f %f", inmat.getForwardVector().x, inmat.getForwardVector().y, inmat.getForwardVector().z);
+   Con::warnf("    type: %f", readBuffer[0].type);
+   Con::warnf("  radius: %f", readBuffer[0].radius);
+   Con::warnf("   scale: %f", readBuffer[0].scale);
+   Con::warnf("   atten: %f", readBuffer[0].attenuation);
+}
+
+DefineEngineFunction(bakeProbeAtlas, void, (), ,"")
+{
+   PROBEMGR->serializeProbes();
+}
 
+DefineEngineFunction(testProbeAtlas, void, (), , "")
+{
+   PROBEMGR->testProbeAtlas();
+}
 //=============================================================================
 // Console functions
 //=============================================================================

Engine/source/renderInstance/renderProbeMgr.h

@@ -98,9 +98,10 @@ struct ProbeShaderConstants
    GFXShaderConstHandle *mProbeCountSC;
 
    GFXShaderConstHandle *mBRDFTextureMap;
-   GFXShaderConstHandle* mWetnessTextureMap;   
+   GFXShaderConstHandle *mProbeAtlasMap;
+   GFXShaderConstHandle *mWetnessTextureMap;
    GFXShaderConstHandle *mSkylightCubemapIdxSC;
-   GFXShaderConstHandle* mSkylightDampSC;
+   GFXShaderConstHandle *mSkylightDampSC;
 
    GFXShaderConstHandle* mMaxProbeDrawDistanceSC;
 
@@ -278,6 +279,7 @@ class RenderProbeMgr : public RenderBinManager
    /// The BRDF texture used in PBR math calculations
    /// </summary>
    GFXTexHandle mBRDFTexture;
+   GFXTexHandle mProbeAtlasTexture;
    GFXTexHandle mWetnessTexture;
 
    /// <summary>
@@ -478,6 +480,10 @@ class RenderProbeMgr : public RenderBinManager
    void render(SceneRenderState * state) override;
 
    void clear() override { mActiveProbes.clear(); Parent::clear(); }
+
+   Resource<DDSFile> mProbeAtlas;
+   void serializeProbes();
+   void testProbeAtlas();
 };
 
 RenderProbeMgr* RenderProbeMgr::getProbeManager()

Engine/source/shaderGen/shaderGenVars.cpp

@@ -93,6 +93,7 @@ const String ShaderGenVars::irradianceCubemapAR("$IrradianceCubemapAR");
 const String ShaderGenVars::probeCount("$inNumProbes");
 
 const String ShaderGenVars::BRDFTextureMap("$BRDFTexture");
+const String ShaderGenVars::ProbeAtlasMap("$probeAtlas");
 const String ShaderGenVars::WetnessTextureMap("$WetnessTexture");
 
 const String ShaderGenVars::maxProbeDrawDistance("$maxProbeDrawDistance");

Engine/source/shaderGen/shaderGenVars.h

@@ -104,6 +104,7 @@ struct ShaderGenVars
    const static String probeCount;
 
    const static String BRDFTextureMap;
+   const static String ProbeAtlasMap;
    const static String WetnessTextureMap;   
    const static String maxProbeDrawDistance;
 

Templates/BaseGame/game/core/lighting/scripts/advancedLighting_Shaders.tscript

@@ -291,6 +291,7 @@ singleton shaderData( PrefiterCubemapShader )
 };
 
 //
+
 singleton ShaderData( PFX_ReflectionProbeArray )
 {
    DXVertexShaderFile   = $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
@@ -306,7 +307,8 @@ singleton ShaderData( PFX_ReflectionProbeArray )
    samplerNames[4] = "$specularCubemapAR";
    samplerNames[5] = "$irradianceCubemapAR";
    samplerNames[6] = "$WetnessTexture";
-   samplerNames[7] = "$ssaoMask";
+   samplerNames[7] = "$probeAtlas";
+   samplerNames[8] = "$ssaoMask";
 
    pixVersion = 2.0;
 };  
@@ -336,5 +338,6 @@ singleton GFXStateBlockData( PFX_ReflectionProbeArrayStateBlock )
    samplerStates[4] = SamplerClampLinear;
    samplerStates[5] = SamplerClampLinear;
    samplerStates[6] = SamplerWrapPoint;
-   samplerStates[7] = SamplerClampPoint;
+   samplerStates[7] = SamplerWrapPoint;
+   samplerStates[8] = SamplerClampPoint;
 };