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

WIP of timmy's changes merged in. Not properly initializing the probes/array slots just yet.

Browse source
This commit is contained in:
Areloch 2019-03-24 18:18:44 -05:00
parent ead78ec588
commit 399088d09e
10 changed files with 485 additions and 159 deletions
Download patch file Download diff file Expand all files Collapse all files

113
Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp
View file

@ -141,7 +141,7 @@ void GFXD3D11Cubemap::initStatic(GFXTexHandle *faces)
mSRView->GetDesc(&viewDesc);
mMipMapLevels = viewDesc.TextureCube.MipLevels;
}
mInitialized = true;
}
void GFXD3D11Cubemap::initStatic(DDSFile *dds)
@ -208,7 +208,6 @@ void GFXD3D11Cubemap::initStatic(DDSFile *dds)
{
AssertFatal(false, "GFXD3D11Cubemap::initStatic(DDSFile *dds) - CreateTexture2D call failure");
}
mInitialized = true;
}
void GFXD3D11Cubemap::initDynamic(U32 texSize, GFXFormat faceFormat, U32 mipLevels)
@ -331,7 +330,7 @@ void GFXD3D11Cubemap::initDynamic(U32 texSize, GFXFormat faceFormat, U32 mipLeve
}
SAFE_RELEASE(depthTex);
mInitialized = true;
}
//-----------------------------------------------------------------------------
@ -392,10 +391,11 @@ GFXD3D11CubemapArray::~GFXD3D11CubemapArray()
SAFE_RELEASE(mTexture);
}
void GFXD3D11CubemapArray::initStatic(GFXCubemapHandle *cubemaps, const U32 cubemapCount)
//TODO: really need a common private 'init' function to avoid code double up with these init* functions
void GFXD3D11CubemapArray::init(GFXCubemapHandle *cubemaps, const U32 cubemapCount)
{
AssertFatal(cubemaps, "GFXD3D11CubemapArray - Got null GFXCubemapHandle!");
AssertFatal(*cubemaps, "GFXD3D11CubemapArray - Got empty cubemap!");
AssertFatal(cubemaps, "GFXD3D11CubemapArray::initStatic - Got null GFXCubemapHandle!");
AssertFatal(*cubemaps, "GFXD3D11CubemapArray::initStatic - Got empty cubemap!");
//all cubemaps must be the same size,format and number of mipmaps. Grab the details from the first cubemap
mSize = cubemaps[0]->getSize();
@ -424,7 +424,7 @@ void GFXD3D11CubemapArray::initStatic(GFXCubemapHandle *cubemaps, const U32 cube
HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, NULL, &mTexture);
if (FAILED(hr))
AssertFatal(false, "GFXD3D11CubemapArray:initStatic(GFXCubemap *cubemaps,const U32 cubemapCount) - CreateTexture2D failure");
AssertFatal(false, "GFXD3D11CubemapArray::initStatic - CreateTexture2D failure");
for (U32 i = 0; i < cubemapCount; i++)
{
@ -434,7 +434,7 @@ void GFXD3D11CubemapArray::initStatic(GFXCubemapHandle *cubemaps, const U32 cube
{
Con::printf("Trying to add an invalid Cubemap to a CubemapArray");
//destroy array here first
AssertFatal(false, "GFXD3D11CubemapArray:initStatic(GFXCubemap *cubemaps,const U32 cubemapCount) - invalid cubemap");
AssertFatal(false, "GFXD3D11CubemapArray::initStatic - invalid cubemap");
}
for (U32 face = 0; face < CubeFaces; face++)
@ -460,7 +460,102 @@ void GFXD3D11CubemapArray::initStatic(GFXCubemapHandle *cubemaps, const U32 cube
hr = D3D11DEVICE->CreateShaderResourceView(mTexture, &SMViewDesc, &mSRView);
if (FAILED(hr))
AssertFatal(false, "GFXD3D11CubemapArray:initStatic(GFXCubemap *cubemaps,const U32 cubemapCount) - shader resource view creation failure");
AssertFatal(false, "GFXD3D11CubemapArray::initStatic - shader resource view creation failure");
}
//Just allocate the cubemap array but we don't upload any data
void GFXD3D11CubemapArray::init(const U32 cubemapCount, const U32 cubemapFaceSize, const GFXFormat format)
{
mSize = cubemapFaceSize;
mMipMapLevels = ImageUtil::getMaxMipCount(cubemapFaceSize, cubemapFaceSize);
mNumCubemaps = cubemapCount;
mFormat = format;
//create texture object
UINT bindFlags = D3D11_BIND_SHADER_RESOURCE;
UINT miscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE;
D3D11_TEXTURE2D_DESC desc;
ZeroMemory(&desc, sizeof(D3D11_TEXTURE2D_DESC));
desc.Width = mSize;
desc.Height = mSize;
desc.MipLevels = mMipMapLevels;
desc.ArraySize = CubeFaces * cubemapCount;
desc.Format = GFXD3D11TextureFormat[mFormat];
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = bindFlags;
desc.MiscFlags = miscFlags;
desc.CPUAccessFlags = 0;
HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, NULL, &mTexture);
if (FAILED(hr))
AssertFatal(false, "GFXD3D11CubemapArray::initStatic - CreateTexture2D failure");
//create shader resource view
D3D11_SHADER_RESOURCE_VIEW_DESC SMViewDesc;
SMViewDesc.Format = GFXD3D11TextureFormat[mFormat];
SMViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
SMViewDesc.TextureCubeArray.MipLevels = mMipMapLevels;
SMViewDesc.TextureCubeArray.MostDetailedMip = 0;
SMViewDesc.TextureCubeArray.NumCubes = mNumCubemaps;
SMViewDesc.TextureCubeArray.First2DArrayFace = 0;
hr = D3D11DEVICE->CreateShaderResourceView(mTexture, &SMViewDesc, &mSRView);
if (FAILED(hr))
AssertFatal(false, "GFXD3D11CubemapArray::initStatic - shader resource view creation failure");
}
void GFXD3D11CubemapArray::updateTexture(const GFXCubemapHandle &cubemap, const U32 slot)
{
AssertFatal(slot <= mNumCubemaps, "GFXD3D11CubemapArray::updateTexture - trying to update a cubemap texture that is out of bounds!");
GFXD3D11Cubemap *pCubeObj = static_cast<GFXD3D11Cubemap*>((GFXCubemap*)cubemap);
ID3D11Resource *pDstRes = pCubeObj->get2DTex();
for (U32 face = 0; face < CubeFaces; face++)
{
const U32 arraySlice = face + CubeFaces * slot;
for (U32 currentMip = 0; currentMip < mMipMapLevels; currentMip++)
{
const U32 srcSubResource = D3D11CalcSubresource(currentMip, face, mMipMapLevels);
const U32 dstSubResource = D3D11CalcSubresource(currentMip, arraySlice, mMipMapLevels);
D3D11DEVICECONTEXT->CopySubresourceRegion(mTexture, dstSubResource, 0, 0, 0, pDstRes, srcSubResource, NULL);
}
}
}
void GFXD3D11CubemapArray::copyTo(GFXCubemapArray *pDstCubemap)
{
AssertFatal(pDstCubemap, "GFXD3D11CubemapArray::copyTo - Got null GFXCubemapArray");
const U32 dstCount = pDstCubemap->getNumCubemaps();
const GFXFormat dstFmt = pDstCubemap->getFormat();
const U32 dstSize = pDstCubemap->getSize();
const U32 dstMips = pDstCubemap->getMipMapLevels();
AssertFatal(dstCount > mNumCubemaps, "GFXD3D11CubemapArray::copyTo - Destination too small");
AssertFatal(dstFmt == mFormat, "GFXD3D11CubemapArray::copyTo - Destination format doesn't match");
AssertFatal(dstSize == mSize, "GFXD3D11CubemapArray::copyTo - Destination size doesn't match");
AssertFatal(dstMips == mMipMapLevels, "GFXD3D11CubemapArray::copyTo - Destination mip levels doesn't match");
GFXD3D11CubemapArray *pDstCube = static_cast<GFXD3D11CubemapArray*>(pDstCubemap);
ID3D11Resource *pDstRes = pDstCube->get2DTex();
for (U32 cubeMap = 0; cubeMap < mNumCubemaps; cubeMap++)
{
for (U32 face = 0; face < CubeFaces; face++)
{
const U32 arraySlice = face + CubeFaces * cubeMap;
for (U32 currentMip = 0; currentMip < mMipMapLevels; currentMip++)
{
const U32 subResource = D3D11CalcSubresource(currentMip, arraySlice, mMipMapLevels);
D3D11DEVICECONTEXT->CopySubresourceRegion(pDstRes, subResource, 0, 0, 0, mTexture, subResource, NULL);
}
}
}
}

7
Engine/source/gfx/D3D11/gfxD3D11Cubemap.h
View file

@ -48,6 +48,8 @@ public:
virtual void zombify();
virtual void resurrect();
virtual bool isInitialized() { return mTexture ? true : false; }
// Get functions
ID3D11ShaderResourceView* getSRView();
ID3D11RenderTargetView* getRTView(U32 faceIdx, U32 mipIndex=0);
@ -81,7 +83,10 @@ class GFXD3D11CubemapArray : public GFXCubemapArray
public:
GFXD3D11CubemapArray();
virtual ~GFXD3D11CubemapArray();
virtual void initStatic(GFXCubemapHandle *cubemaps, const U32 cubemapCount);
virtual void init(GFXCubemapHandle *cubemaps, const U32 cubemapCount);
virtual void init(const U32 cubemapCount, const U32 cubemapFaceSize, const GFXFormat format);
virtual void updateTexture(const GFXCubemapHandle &cubemap, const U32 slot);
virtual void copyTo(GFXCubemapArray *pDstCubemap);
virtual void setToTexUnit(U32 tuNum);
ID3D11ShaderResourceView* getSRView() { return mSRView; }

6
Engine/source/gfx/Null/gfxNullDevice.cpp
View file

@ -169,8 +169,10 @@ private:
virtual void setToTexUnit(U32 tuNum) { };
public:
virtual void initStatic(GFXCubemapHandle *cubemaps, const U32 cubemapCount) { };
virtual void init(GFXCubemapHandle *cubemaps, const U32 cubemapCount) { };
virtual void init(const U32 cubemapCount, const U32 cubemapFaceSize, const GFXFormat format) { };
virtual void updateTexture(const GFXCubemapHandle &cubemap, const U32 slot) { };
virtual void copyTo(GFXCubemapArray *pDstCubemap) { }
virtual ~GFXNullCubemapArray() {};
virtual void zombify() {}
virtual void resurrect() {}

5
Engine/source/gfx/bitmap/imageUtils.cpp
View file

@ -301,4 +301,9 @@ namespace ImageUtil
return format;
};
}
U32 getMaxMipCount(const U32 width, const U32 height)
{
return mFloor(mLog2(mMax(width, height))) + 1;
}
}

5
Engine/source/gfx/bitmap/imageUtils.h
View file

@ -29,6 +29,9 @@
#ifndef _GFXENUMS_H_
#include "gfx/gfxEnums.h"
#endif
#ifndef _MMATHFN_H_
#include "math/mMathFn.h"
#endif
struct DDSFile;
@ -57,6 +60,8 @@ namespace ImageUtil
//convert to sRGB format
GFXFormat toSRGBFormat(const GFXFormat format);
U32 getMaxMipCount(const U32 width, const U32 height);
};
#endif

25
Engine/source/gfx/gfxCubemap.h
View file

@ -49,6 +49,7 @@ protected:
U32 mMipMapLevels;
bool mInitialized;
public:
@ -62,6 +63,7 @@ public:
virtual void initDynamic( U32 texSize, GFXFormat faceFormat = GFXFormatR8G8B8A8, U32 mipLevels = 0 ) = 0;
void initNormalize(U32 size);
GFXCubemap();
virtual ~GFXCubemap();
@ -71,6 +73,9 @@ public:
/// Returns the face texture format.
virtual GFXFormat getFormat() const = 0;
/// Returns if this cubemap has been initialized
virtual bool isInitialized() { return false; }
/// Returns the cubemap file path set at creation.
const String& getPath() const { return mPath; }
@ -83,7 +88,6 @@ public:
/// Get Z up face index of the cubemap. DDS files will be stored Y up
static U32 zUpFaceIndex(const U32 index);
bool isInitialised() { return mInitialized; }
};
@ -102,32 +106,43 @@ public:
void free() { StrongObjectRef::set( NULL ); }
};
/// Cubemap array
/// Cubemap array - data lives on the GPU only with this class, but the data is not immutable so it can be updated
class GFXCubemapArray : public StrongRefBase, public GFXResource
{
friend class GFXDevice;
friend class GFXTextureManager;
protected:
// should only be called by GFXDevice
/// should only be called by GFXDevice
virtual void setToTexUnit( U32 tuNum ) = 0;
/// number of cubemaps in the array
U32 mNumCubemaps;
/// cubemap face size
U32 mSize;
/// number of mip levels
U32 mMipMapLevels;
/// format
GFXFormat mFormat;
public:
virtual ~GFXCubemapArray() {};
virtual void initStatic(GFXCubemapHandle *cubemaps, const U32 cubemapCount) = 0;
/// Initialize from an array of cubemaps
virtual void init(GFXCubemapHandle *cubemaps, const U32 cubemapCount) = 0;
/// Initialize cubemapCount number of blank cubemaps in the array
virtual void init(const U32 cubemapCount, const U32 cubemapFaceSize, const GFXFormat format) = 0;
/// Update cubemap in the array
virtual void updateTexture(const GFXCubemapHandle &cubemap, const U32 slot) = 0;
/// Copy this cubemap to another - destination must be same format, same face size & at-least the same size(or larger)
virtual void copyTo(GFXCubemapArray *pDstCubemap) = 0;
/// Return number of textures in the array
const U32 getNumCubemaps() const { return mNumCubemaps; }
/// Get the number of mip maps
const U32 getMipMapLevels() const { return mMipMapLevels; }
/// Returns the size of the faces.
const U32 getSize() const { return mSize; }
/// Returns the format
const GFXFormat getFormat() const { return mFormat; }
virtual const String describeSelf() const;
};