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

Merge pull request #424 from lukaspj/feature/new-terrain-blending

Browse source 
Height based terrain texture blending
This commit is contained in:
Brian Roberts 2021-01-04 05:36:50 -06:00 • committed by GitHub
commit 27641b16ca
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
49 changed files with 3628 additions and 1280 deletions
Download patch file Download diff file Expand all files Collapse all files

11
Engine/source/gfx/D3D11/gfxD3D11Device.cpp
View file

@ -40,6 +40,8 @@
#include "shaderGen/shaderGen.h"
#include <d3d9.h> //d3dperf
#include "gfxD3D11TextureArray.h"
#ifdef TORQUE_DEBUG
#include "d3d11sdklayers.h"
#endif
@ -48,6 +50,8 @@
#pragma comment(lib, "d3d9.lib") //d3dperf
#pragma comment(lib, "d3d11.lib")
class GFXD3D11TextureArray;
class GFXPCD3D11RegisterDevice
{
public:
@ -1736,6 +1740,13 @@ GFXCubemapArray * GFXD3D11Device::createCubemapArray()
return cubeArray;
}
GFXTextureArray * GFXD3D11Device::createTextureArray()
{
GFXD3D11TextureArray* textureArray = new GFXD3D11TextureArray();
textureArray->registerResourceWithDevice(this);
return textureArray;
}
// Debug events
//------------------------------------------------------------------------------
void GFXD3D11Device::enterDebugEvent(ColorI color, const char *name)

1
Engine/source/gfx/D3D11/gfxD3D11Device.h
View file

@ -231,6 +231,7 @@ public:
virtual GFXCubemap *createCubemap();
virtual GFXCubemapArray *createCubemapArray();
virtual GFXTextureArray* createTextureArray();
virtual F32 getPixelShaderVersion() const { return mPixVersion; }
virtual void setPixelShaderVersion( F32 version ){ mPixVersion = version;}

3
Engine/source/gfx/D3D11/gfxD3D11Shader.cpp
View file

@ -1385,7 +1385,8 @@ void GFXD3D11Shader::_buildSamplerShaderConstantHandles( Vector<GFXShaderConstDe
AssertFatal( desc.constType == GFXSCT_Sampler ||
desc.constType == GFXSCT_SamplerCube ||
desc.constType == GFXSCT_SamplerCubeArray,
desc.constType == GFXSCT_SamplerCubeArray ||
desc.constType == GFXSCT_SamplerTextureArray,
"GFXD3D11Shader::_buildSamplerShaderConstantHandles - Invalid samplerDescription type!" );
GFXD3D11ShaderConstHandle *handle;

150
Engine/source/gfx/D3D11/gfxD3D11TextureArray.cpp Normal file
View file

@ -0,0 +1,150 @@
#include "gfxD3D11TextureArray.h"
#include <d3d11.h>
#include "gfxD3D11Device.h"
#include "gfxD3D11EnumTranslate.h"
#include "core/util/tVector.h"
#include "gfx/util/screenspace.h"
#include "shaderGen/shaderFeature.h"
void GFXD3D11TextureArray::init()
{
mTextureArrayDesc.Width = mWidth;
mTextureArrayDesc.Height = mHeight;
mTextureArrayDesc.MipLevels = mMipLevels;
mTextureArrayDesc.ArraySize = mArraySize;
mTextureArrayDesc.Format = GFXD3D11TextureFormat[mFormat];
mTextureArrayDesc.SampleDesc.Count = 1;
mTextureArrayDesc.SampleDesc.Quality = 0;
mTextureArrayDesc.Usage = D3D11_USAGE_DEFAULT;
mTextureArrayDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
mTextureArrayDesc.CPUAccessFlags = 0;
mTextureArrayDesc.MiscFlags = 0;
HRESULT hr = D3D11DEVICE->CreateTexture2D(&mTextureArrayDesc, NULL, &mTextureArray);
AssertFatal(SUCCEEDED(hr), "GFXD3D11TextureArray::init failed to create texture array!");
//---------------------------------------------------------------------------------------
// Create a resource view to the texture array.
//---------------------------------------------------------------------------------------
createResourceView(mTextureArrayDesc.Format, mTextureArrayDesc.MipLevels, mTextureArrayDesc.BindFlags);
//---------------------------------------------------------------------------------------
}
void GFXD3D11TextureArray::_setTexture(const GFXTexHandle& texture, U32 slot)
{
GFXD3D11TextureObject *texObj = dynamic_cast<GFXD3D11TextureObject*>(texture.getPointer());
ID3D11Texture2D* tex2d = texObj->get2DTex();
D3D11_TEXTURE2D_DESC desc;
tex2d->GetDesc(&desc);
// for each mipmap level...
for (UINT j = 0; j < desc.MipLevels; ++j)
{
const U32 srcSubResource = D3D11CalcSubresource(j, 0, desc.MipLevels);
const U32 dstSubResource = D3D11CalcSubresource(j, slot, mTextureArrayDesc.MipLevels);
D3D11DEVICECONTEXT->CopySubresourceRegion(mTextureArray, dstSubResource, 0, 0, 0, tex2d, srcSubResource, NULL);
}
}
void GFXD3D11TextureArray::setToTexUnit(U32 tuNum)
{
D3D11DEVICECONTEXT->PSSetShaderResources(tuNum, 1, &mSRView);
}
void GFXD3D11TextureArray::createResourceView(DXGI_FORMAT format, U32 numMipLevels, U32 usageFlags)
{
HRESULT hr;
if (usageFlags & D3D11_BIND_SHADER_RESOURCE)
{
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
if (usageFlags & D3D11_BIND_DEPTH_STENCIL)
desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; // reads the depth
else
desc.Format = format;
desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
desc.Texture2DArray.MostDetailedMip = 0;
desc.Texture2DArray.MipLevels = numMipLevels;
desc.Texture2DArray.FirstArraySlice = 0;
desc.Texture2DArray.ArraySize = mArraySize;
hr = D3D11DEVICE->CreateShaderResourceView(mTextureArray, &desc, &mSRView);
AssertFatal(SUCCEEDED(hr), "GFXD3D11TextureArray::CreateShaderResourceView failed to create view!");
}
if (usageFlags & D3D11_BIND_RENDER_TARGET)
{
D3D11_RENDER_TARGET_VIEW_DESC desc;
desc.Format = format;
desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
desc.Texture2DArray.MipSlice = 0;
desc.Texture2DArray.FirstArraySlice = 0;
desc.Texture2DArray.ArraySize = mArraySize;
hr = D3D11DEVICE->CreateRenderTargetView(mTextureArray, &desc, &mRTView);
AssertFatal(SUCCEEDED(hr), "GFXD3D11TextureArray::CreateRenderTargetView failed to create view!");
}
if (usageFlags & D3D11_BIND_DEPTH_STENCIL)
{
D3D11_DEPTH_STENCIL_VIEW_DESC desc;
desc.Format = format;
desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
desc.Texture2DArray.MipSlice = 0;
desc.Texture2DArray.FirstArraySlice = 0;
desc.Texture2DArray.ArraySize = mArraySize;
desc.Flags = 0;
hr = D3D11DEVICE->CreateDepthStencilView(mTextureArray, &desc, &mDSView);
AssertFatal(SUCCEEDED(hr), "GFXD3D11TextureArray::CreateDepthStencilView failed to create view!");
}
}
void GFXD3D11TextureArray::Release()
{
SAFE_RELEASE(mSRView)
SAFE_RELEASE(mRTView)
SAFE_RELEASE(mDSView)
SAFE_RELEASE(mTextureArray)
GFXTextureArray::Release();
}
ID3D11ShaderResourceView* GFXD3D11TextureArray::getSRView()
{
return mSRView;
}
ID3D11RenderTargetView* GFXD3D11TextureArray::getRTView()
{
return mRTView;
}
ID3D11DepthStencilView* GFXD3D11TextureArray::getDSView()
{
return mDSView;
}
ID3D11ShaderResourceView** GFXD3D11TextureArray::getSRViewPtr()
{
return &mSRView;
}
ID3D11RenderTargetView** GFXD3D11TextureArray::getRTViewPtr()
{
return &mRTView;
}
ID3D11DepthStencilView** GFXD3D11TextureArray::getDSViewPtr()
{
return &mDSView;
}
void GFXD3D11TextureArray::zombify()
{
// Unsupported
}
void GFXD3D11TextureArray::resurrect()
{
// Unsupported
}

56
Engine/source/gfx/D3D11/gfxD3D11TextureArray.h Normal file
View file

@ -0,0 +1,56 @@
#ifndef _GFXD3D11TEXTUREARRAY_H_
#define _GFXD3D11TEXTUREARRAY_H_
#include <dxgiformat.h>
#include "gfx/gfxTextureArray.h"
#include "gfx/gfxTextureManager.h"
#include "core/util/safeRelease.h"
#include "gfxD3D11TextureManager.h"
class GFXD3D11TextureArray : public GFXTextureArray
{
public:
GFXD3D11TextureArray()
: mSRView( NULL ),
mRTView( NULL ),
mDSView( NULL ),
mTextureArray( NULL )
{
}
~GFXD3D11TextureArray() { Release(); };
void init();
void setToTexUnit(U32 tuNum) override;
void createResourceView(DXGI_FORMAT format, U32 numMipLevels, U32 usageFlags);
// GFXResource interface
void zombify() override;
void resurrect() override;
void Release() override;
ID3D11ShaderResourceView* getSRView();
ID3D11RenderTargetView* getRTView();
ID3D11DepthStencilView* getDSView();
ID3D11ShaderResourceView** getSRViewPtr();
ID3D11RenderTargetView** getRTViewPtr();
ID3D11DepthStencilView** getDSViewPtr();
protected:
void _setTexture(const GFXTexHandle& texture, U32 slot) override;
private:
ID3D11ShaderResourceView* mSRView; // for shader resource input
ID3D11RenderTargetView* mRTView; // for render targets
ID3D11DepthStencilView* mDSView; //render target view for depth stencil
ID3D11Texture2D* mTextureArray;
D3D11_TEXTURE2D_DESC mTextureArrayDesc;
};
#endif

5
Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp
View file

@ -210,8 +210,8 @@ bool GFXD3D11TextureObject::copyToBmp(GBitmap* bmp)
// check format limitations
// at the moment we only support RGBA for the source (other 4 byte formats should
// be easy to add though)
AssertFatal(mFormat == GFXFormatR16G16B16A16F || mFormat == GFXFormatR8G8B8A8 || mFormat == GFXFormatR8G8B8A8_LINEAR_FORCE || mFormat == GFXFormatR8G8B8A8_SRGB, "copyToBmp: invalid format");
if (mFormat != GFXFormatR16G16B16A16F && mFormat != GFXFormatR8G8B8A8 && mFormat != GFXFormatR8G8B8A8_LINEAR_FORCE && mFormat != GFXFormatR8G8B8A8_SRGB)
AssertFatal(mFormat == GFXFormatR16G16B16A16F || mFormat == GFXFormatR8G8B8A8 || mFormat == GFXFormatR8G8B8A8_LINEAR_FORCE || mFormat == GFXFormatR8G8B8A8_SRGB || mFormat == GFXFormatR8G8B8, "copyToBmp: invalid format");
if (mFormat != GFXFormatR16G16B16A16F && mFormat != GFXFormatR8G8B8A8 && mFormat != GFXFormatR8G8B8A8_LINEAR_FORCE && mFormat != GFXFormatR8G8B8A8_SRGB && mFormat != GFXFormatR8G8B8)
return false;
PROFILE_START(GFXD3D11TextureObject_copyToBmp);
@ -248,6 +248,7 @@ bool GFXD3D11TextureObject::copyToBmp(GBitmap* bmp)
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
desc.Usage = D3D11_USAGE_STAGING;
desc.MiscFlags = 0;
ID3D11Texture2D* pStagingTexture = NULL;
HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, NULL, &pStagingTexture);

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

@ -178,6 +178,19 @@ public:
virtual void resurrect() {}
};
class GFXNullTextureArray : public GFXTextureArray
{
public:
void zombify() override {}
void resurrect() override {}
void Release() override {}
void setToTexUnit(U32 tuNum) override { }
void init() override { }
protected:
void _setTexture(const GFXTexHandle& texture, U32 slot) override { }
};
class GFXNullVertexBuffer : public GFXVertexBuffer
{
unsigned char* tempBuf;
@ -317,6 +330,11 @@ GFXCubemapArray* GFXNullDevice::createCubemapArray()
return new GFXNullCubemapArray();
};
GFXTextureArray* GFXNullDevice::createTextureArray()
{
return new GFXNullTextureArray();
};
void GFXNullDevice::enumerateAdapters( Vector<GFXAdapter*> &adapterList )
{
// Add the NULL renderer

1
Engine/source/gfx/Null/gfxNullDevice.h
View file

@ -130,6 +130,7 @@ protected:
public:
virtual GFXCubemap * createCubemap();
virtual GFXCubemapArray *createCubemapArray();
virtual GFXTextureArray *createTextureArray();
virtual F32 getFillConventionOffset() const { return 0.0f; };

20
Engine/source/gfx/bitmap/gBitmap.cpp
View file

@ -319,7 +319,7 @@ void GBitmap::allocateBitmap(const U32 in_width, const U32 in_height, const bool
U32 currWidth = in_width;
U32 currHeight = in_height;
do
while (currWidth != 1 || currHeight != 1)
{
mMipLevelOffsets[mNumMipLevels] = mMipLevelOffsets[mNumMipLevels - 1] +
(currWidth * currHeight * mBytesPerPixel);
@ -330,7 +330,7 @@ void GBitmap::allocateBitmap(const U32 in_width, const U32 in_height, const bool
mNumMipLevels++;
allocPixels += currWidth * currHeight * mBytesPerPixel;
} while (currWidth != 1 || currHeight != 1);
}
U32 expectedMips = mFloor(mLog2(mMax(in_width, in_height))) + 1;
AssertFatal(mNumMipLevels == expectedMips, "GBitmap::allocateBitmap: mipmap count wrong");
@ -727,7 +727,7 @@ bool GBitmap::checkForTransparency()
}
//------------------------------------------------------------------------------
LinearColorF GBitmap::sampleTexel(F32 u, F32 v) const
LinearColorF GBitmap::sampleTexel(F32 u, F32 v, bool retAlpha) const
{
LinearColorF col(0.5f, 0.5f, 0.5f);
// normally sampling wraps all the way around at 1.0,
@ -751,6 +751,13 @@ LinearColorF GBitmap::sampleTexel(F32 u, F32 v) const
col.red = F32(buffer[lexelindex + 0]) / 255.0f;
col.green = F32(buffer[lexelindex + 1]) / 255.0f;
col.blue = F32(buffer[lexelindex + 2]) / 255.0f;
if (retAlpha)
{
if (getHasTransparency())
col.alpha = F32(buffer[lexelindex + 3]) / 255.0f;
else
col.alpha = 1.0f;
}
}
return col;
@ -1352,7 +1359,7 @@ U32 GBitmap::getSurfaceSize(const U32 mipLevel) const
}
DefineEngineFunction( getBitmapInfo, String, ( const char *filename ),,
"Returns image info in the following format: width TAB height TAB bytesPerPixel. "
"Returns image info in the following format: width TAB height TAB bytesPerPixel TAB format. "
"It will return an empty string if the file is not found.\n"
"@ingroup Rendering\n" )
{
@ -1360,7 +1367,8 @@ DefineEngineFunction( getBitmapInfo, String, ( const char *filename ),,
if ( !image )
return String::EmptyString;
return String::ToString( "%d\t%d\t%d", image->getWidth(),
return String::ToString( "%d\t%d\t%d\t%d", image->getWidth(),
image->getHeight(),
image->getBytesPerPixel() );
image->getBytesPerPixel(),
image->getFormat());
}

2
Engine/source/gfx/bitmap/gBitmap.h
View file

@ -205,7 +205,7 @@ public:
/// the bitmap bits and to check for alpha values less than 255
bool checkForTransparency();
LinearColorF sampleTexel(F32 u, F32 v) const;
LinearColorF sampleTexel(F32 u, F32 v, bool retAlpha = false) const;
bool getColor(const U32 x, const U32 y, ColorI& rColor) const;
bool setColor(const U32 x, const U32 y, const ColorI& rColor);
U8 getChanelValueAt(U32 x, U32 y, U32 chan);

72
Engine/source/gfx/gfxDevice.cpp
View file

@ -132,6 +132,8 @@ GFXDevice::GFXDevice()
mCurrentCubemap[i] = NULL;
mNewCubemap[i] = NULL;
mCurrentCubemapArray[i] = NULL;
mNewTextureArray[i] = NULL;
mCurrentTextureArray[i] = NULL;
mNewCubemapArray[i] = NULL;
mTexType[i] = GFXTDT_Normal;
@ -266,6 +268,8 @@ GFXDevice::~GFXDevice()
mNewCubemap[i] = NULL;
mCurrentCubemapArray[i] = NULL;
mNewCubemapArray[i] = NULL;
mCurrentTextureArray[i] = NULL;
mNewTextureArray[i] = NULL;
}
mCurrentRT = NULL;
@ -403,14 +407,23 @@ void GFXDevice::updateStates(bool forceSetAll /*=false*/)
}
break;
case GFXTDT_CubeArray:
{
mCurrentCubemapArray[i] = mNewCubemapArray[i];
if (mCurrentCubemapArray[i])
mCurrentCubemapArray[i]->setToTexUnit(i);
else
setTextureInternal(i, NULL);
}
break;
{
mCurrentCubemapArray[i] = mNewCubemapArray[i];
if (mCurrentCubemapArray[i])
mCurrentCubemapArray[i]->setToTexUnit(i);
else
setTextureInternal(i, NULL);
}
break;
case GFXTDT_TextureArray:
{
mCurrentTextureArray[i] = mNewTextureArray[i];
if (mCurrentTextureArray[i])
mCurrentTextureArray[i]->setToTexUnit(i);
else
setTextureInternal(i, NULL);
}
break;
default:
AssertFatal(false, "Unknown texture type!");
break;
@ -557,6 +570,15 @@ void GFXDevice::updateStates(bool forceSetAll /*=false*/)
mCurrentCubemapArray[i]->setToTexUnit(i);
else
setTextureInternal(i, NULL);
}
break;
case GFXTDT_TextureArray:
{
mCurrentTextureArray[i] = mNewTextureArray[i];
if (mCurrentTextureArray[i])
mCurrentTextureArray[i]->setToTexUnit(i);
else
setTextureInternal(i, NULL);
}
break;
default:
@ -801,6 +823,8 @@ void GFXDevice::setTexture( U32 stage, GFXTextureObject *texture )
mCurrentCubemap[stage] = NULL;
mNewCubemapArray[stage] = NULL;
mCurrentCubemapArray[stage] = NULL;
mNewTextureArray[stage] = NULL;
mCurrentTextureArray[stage] = NULL;
}
//-----------------------------------------------------------------------------
@ -827,6 +851,8 @@ void GFXDevice::setCubeTexture( U32 stage, GFXCubemap *cubemap )
mCurrentTexture[stage] = NULL;
mNewCubemapArray[stage] = NULL;
mCurrentCubemapArray[stage] = NULL;
mNewTextureArray[stage] = NULL;
mCurrentTextureArray[stage] = NULL;
}
//-----------------------------------------------------------------------------
@ -853,6 +879,36 @@ void GFXDevice::setCubeArrayTexture(U32 stage, GFXCubemapArray *cubemapArray)
mCurrentTexture[stage] = NULL;
mNewCubemap[stage] = NULL;
mCurrentCubemap[stage] = NULL;
mNewTextureArray[stage] = NULL;
mCurrentTextureArray[stage] = NULL;
}
//-----------------------------------------------------------------------------
// Set texture array
//-----------------------------------------------------------------------------
void GFXDevice::setTextureArray(U32 stage, GFXTextureArray *textureArray)
{
AssertFatal(stage < getNumSamplers(), avar("GFXDevice::setTextureArray - out of range stage! %i>%i", stage, getNumSamplers()));
if (mTexType[stage] == GFXTDT_TextureArray &&
((mTextureDirty[stage] && mNewTextureArray[stage].getPointer() == textureArray) ||
(!mTextureDirty[stage] && mCurrentTextureArray[stage].getPointer() == textureArray)))
return;
mStateDirty = true;
mTexturesDirty = true;
mTextureDirty[stage] = true;
mNewTextureArray[stage] = textureArray;
mTexType[stage] = GFXTDT_TextureArray;
// Clear out textures
mNewTexture[stage] = NULL;
mCurrentTexture[stage] = NULL;
mNewCubemap[stage] = NULL;
mCurrentCubemap[stage] = NULL;
mNewCubemapArray[stage] = NULL;
mCurrentCubemapArray[stage] = NULL;
}
//------------------------------------------------------------------------------

8
Engine/source/gfx/gfxDevice.h
View file

@ -57,6 +57,7 @@
#ifndef _PLATFORM_PLATFORMTIMER_H_
#include "platform/platformTimer.h"
#endif
#include "gfxTextureArray.h"
class FontRenderBatcher;
class GFont;
@ -498,7 +499,8 @@ protected:
{
GFXTDT_Normal,
GFXTDT_Cube,
GFXTDT_CubeArray
GFXTDT_CubeArray,
GFXTDT_TextureArray
};
GFXTexHandle mCurrentTexture[TEXTURE_STAGE_COUNT];
@ -507,6 +509,8 @@ protected:
GFXCubemapHandle mNewCubemap[TEXTURE_STAGE_COUNT];
GFXCubemapArrayHandle mCurrentCubemapArray[TEXTURE_STAGE_COUNT];
GFXCubemapArrayHandle mNewCubemapArray[TEXTURE_STAGE_COUNT];
GFXTextureArrayHandle mCurrentTextureArray[TEXTURE_STAGE_COUNT];
GFXTextureArrayHandle mNewTextureArray[TEXTURE_STAGE_COUNT];
TexDirtyType mTexType[TEXTURE_STAGE_COUNT];
bool mTextureDirty[TEXTURE_STAGE_COUNT];
@ -757,6 +761,7 @@ protected:
public:
virtual GFXCubemap * createCubemap() = 0;
virtual GFXCubemapArray *createCubemapArray() = 0;
virtual GFXTextureArray *createTextureArray() = 0;
inline GFXTextureManager *getTextureManager()
{
@ -952,6 +957,7 @@ public:
void setTexture(U32 stage, GFXTextureObject *texture);
void setCubeTexture( U32 stage, GFXCubemap *cubemap );
void setCubeArrayTexture( U32 stage, GFXCubemapArray *cubemapArray);
void setTextureArray( U32 stage, GFXTextureArray *textureArray);
inline GFXTextureObject* getCurrentTexture( U32 stage ) { return mCurrentTexture[stage]; }
/// @}

3
Engine/source/gfx/gfxEnums.h
View file

@ -599,7 +599,8 @@ enum GFXShaderConstType
// Samplers
GFXSCT_Sampler,
GFXSCT_SamplerCube,
GFXSCT_SamplerCubeArray
GFXSCT_SamplerCubeArray,
GFXSCT_SamplerTextureArray
};

181
Engine/source/gfx/gfxTextureArray.cpp Normal file
View file

@ -0,0 +1,181 @@
#include "gfxTextureArray.h"
#include "gfxDevice.h"
#include "gfxTextureManager.h"
#include "bitmap/imageUtils.h"
#include "console/console.h"
GFXTextureArray::GFXTextureArray()
: mFormat(GFXFormat_COUNT),
mIsCompressed(false),
mWidth(0),
mHeight(0),
mArraySize(0),
mMipLevels(0)
{
}
void GFXTextureArray::set(U32 width, U32 height, U32 size, GFXFormat format, U32 mipLevels)
{
if (mipLevels == 0 && width == height && isPow2(width))
{
mipLevels = mLog2(static_cast<F32>(width)) + 1;
}
if (
mWidth == width &&
mHeight == height &&
mArraySize == size &&
mFormat == format &&
mMipLevels == mipLevels
)
{
return;
}
Release();
mWidth = width;
mHeight = height;
mArraySize = size;
mFormat = format;
mIsCompressed = ImageUtil::isCompressedFormat(mFormat);
mMipLevels = getMax(mipLevels, static_cast<U32>(1));
mTextures.setSize(size);
init();
}
bool GFXTextureArray::fromTextureArray(const Vector<GFXTexHandle>& textureArray, U32 capacity)
{
bool success = true;
// Not initialized, infer it from the given array of textures
if (mArraySize == 0)
{
bool found = false;
for (const GFXTexHandle& texObj : textureArray)
{
if (texObj.isValid())
{
if (!found)
{
found = true;
mFormat = texObj.getFormat();
mWidth = texObj.getWidth();
mHeight = texObj.getHeight();
mMipLevels = texObj->getMipLevels();
}
if (mFormat != texObj.getFormat() || mWidth != texObj.getWidth() || mHeight != texObj.getHeight())
{
AssertWarn(true, "GFXTextureArray::fromTextureArray there was a mismatch in texture formats, defaulting to uncompressed format");
Con::warnf("GFXTextureArray::fromTextureArray there was a mismatch in texture formats, defaulting to uncompressed format");
success = false;
mFormat = GFXFormatR8G8B8A8;
}
}
}
// One might think this should return false in this case, but the return value is mostly to highlight internal errors not input errors.
if (!found) return true;
//---------------------------------------------------------------------------------------
// Create the texture array. Each element in the texture
// array has the same format/dimensions.
//---------------------------------------------------------------------------------------
U32 size = capacity;
if (size == 0)
{
size = textureArray.size();
}
set(mWidth, mHeight, size, mFormat, mMipLevels);
}
//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
// Copy individual texture elements into texture array.
//---------------------------------------------------------------------------------------
// for each texture element...
for (U32 i = 0; i < textureArray.size(); ++i)
{
if (textureArray[i].isValid())
{
setTexture(textureArray[i], i);
}
}
//---------------------------------------------------------------------------------------
return success;
}
void GFXTextureArray::setTexture(const GFXTexHandle& texture, U32 slot)
{
GFXTexHandle handle = texture;
if (texture->getPath().isNotEmpty())
{
if (texture.getHeight() != mHeight || texture.getWidth() != mWidth || texture.getFormat() != mFormat || texture->getMipLevels() < mMipLevels)
{
if (texture.getHeight() != mHeight || texture.getWidth() != mWidth)
{
AssertWarn(true, "GFXTextureArray::setTexture all textures should be the same size");
Con::warnf("GFXTextureArray::setTexture all textures should be the same size");
}
else if (texture->getMipLevels() < mMipLevels)
{
AssertWarn(true, "GFXTextureArray::setTexture all textures should have at least the same number of mips");
Con::warnf("GFXTextureArray::setTexture all textures should have at least the same number of mips");
}
else
{
AssertWarn(true, "GFXTextureArray::setTexture all textures should have the same format");
Con::warnf("GFXTextureArray::setTexture all textures should have the same format");
}
GBitmap* inBitmap = TEXMGR->loadUncompressedTexture(texture->getPath(), &GFXTexturePersistentProfile, mWidth, mHeight);
if (!inBitmap->setFormat(mFormat))
{
AssertFatal(true, "GFXTextureArray::setTexture all textures must be convertible to GFXFormat " + mFormat);
Con::errorf("GFXTextureArray::setTexture all textures must be convertible to GFXFormat" + mFormat);
handle = NULL;
delete inBitmap;
}
else
{
handle = TEXMGR->createTexture(inBitmap, "", &GFXStaticTextureProfile, true);
}
}
}
if (!handle.isValid())
{
return;
}
if (handle.getHeight() != mHeight || handle.getWidth() != mWidth || handle.getFormat() != mFormat || handle->getMipLevels() < mMipLevels)
{
AssertFatal(true, "GFXTextureArray::setTexture all textures must have the same size and format");
Con::errorf("GFXTextureArray::setTexture all textures must have the same size and format");
return;
}
mTextures[slot] = handle;
_setTexture(handle, slot);
}
void GFXTextureArray::Release()
{
for (GFXTexHandle& mTexture : mTextures)
{
mTexture = NULL;
}
}
const String GFXTextureArray::describeSelf() const
{
// We've got nothing
return String();
}

88
Engine/source/gfx/gfxTextureArray.h Normal file
View file

@ -0,0 +1,88 @@
//-----------------------------------------------------------------------------
// 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 _GFXTEXTUREARRAY_H_
#define _GFXTEXTUREARRAY_H_
#ifndef _REFBASE_H_
#include "core/util/refBase.h"
#endif
#ifndef _GFXRESOURCE_H_
#include "gfx/gfxResource.h"
#endif
#ifndef _GFXENUMS_H_
#include "gfxEnums.h"
#endif
#ifndef _GFXTEXTUREHANDLE_H_
#include "gfxTextureHandle.h"
#endif
#include "core/util/tVector.h"
class GFXTextureProfile;
class GFXTextureObject;
class GFXTextureArray : public StrongRefBase, public GFXResource
{
public:
GFXTextureArray();
virtual void init() = 0;
virtual void set(U32 width, U32 height, U32 size, GFXFormat format, U32 mipLevels = 0);
virtual bool fromTextureArray(const Vector<GFXTexHandle> &textureArray, U32 capacity = 0);
virtual void setTexture(const GFXTexHandle &texture, U32 slot);
virtual void setToTexUnit(U32 tuNum) = 0;
// GFXResource interface
virtual void zombify() = 0;
virtual void resurrect() = 0;
virtual void Release();
virtual const String describeSelf() const;
GFXFormat mFormat;
bool mIsCompressed;
U32 mWidth;
U32 mHeight;
U32 mArraySize;
U32 mMipLevels;
Vector<GFXTexHandle> mTextures;
protected:
virtual void _setTexture(const GFXTexHandle& texture, U32 slot) = 0;
};
/// A reference counted handle to a texture array resource.
class GFXTextureArrayHandle : public StrongRefPtr<GFXTextureArray>
{
public:
GFXTextureArrayHandle() {}
GFXTextureArrayHandle(GFXTextureArray* textureArray) { StrongRefPtr<GFXTextureArray>::set(textureArray); }
/// Releases the texture handle.
void free() { StrongObjectRef::set(NULL); }
};
#endif // _GFXTEXTUREARRAY_H_

39
Engine/source/gfx/gfxTextureManager.cpp
View file

@ -894,6 +894,45 @@ Torque::Path GFXTextureManager::validatePath(const Torque::Path &path)
return correctPath;
}
GBitmap *GFXTextureManager::loadUncompressedTexture(const Torque::Path &path, GFXTextureProfile *profile, U32 width, U32 height, bool genMips)
{
GBitmap* inBitmap = loadUncompressedTexture(path, &GFXTexturePersistentProfile);
if (inBitmap == NULL)
{
Con::warnf("GFXTextureManager::loadUncompressedTexture unable to load texture: %s", path.getFullPath());
return NULL;
}
// Set the format so we don't have to handle which channels are where.
if (!inBitmap->setFormat(GFXFormatR8G8B8A8))
{
Con::warnf("GFXTextureManager::loadUncompressedTexture unable to handle texture format: %s", path.getFullPath());
return NULL;
}
GBitmap* outBmp = new GBitmap(width, height, true, GFXFormatR8G8B8A8);
U8* oBits = (U8*)outBmp->getWritableBits();
for (S32 y = 0; y < width; y++)
{
for (S32 x = 0; x < height; x++)
{
ColorI texelColor = inBitmap->sampleTexel(x / F32(width), y / F32(height), true).toColorI(true);
oBits[(y * width + x) * 4] = texelColor.red;
oBits[(y * width + x) * 4 + 1] = texelColor.green;
oBits[(y * width + x) * 4 + 2] = texelColor.blue;
oBits[(y * width + x) * 4 + 3] = texelColor.alpha;
}
}
if (genMips)
outBmp->extrudeMipLevels();
return outBmp;
}
GBitmap *GFXTextureManager::loadUncompressedTexture(const Torque::Path &path, GFXTextureProfile *profile)
{
PROFILE_SCOPE(GFXTextureManager_loadUncompressedTexture);

2
Engine/source/gfx/gfxTextureManager.h
View file

@ -41,6 +41,7 @@
#ifndef _TSIGNAL_H_
#include "core/util/tSignal.h"
#endif
#include "gfxTextureHandle.h"
namespace Torque
@ -131,6 +132,7 @@ public:
S32 antialiasLevel);
Torque::Path validatePath(const Torque::Path &path);
GBitmap *loadUncompressedTexture(const Torque::Path& path, GFXTextureProfile* profile, U32 width, U32 height, bool genMips = false);
GBitmap *loadUncompressedTexture(const Torque::Path &path, GFXTextureProfile *profile);
virtual GFXTextureObject *createCompositeTexture(const Torque::Path &pathR, const Torque::Path &pathG, const Torque::Path &pathB, const Torque::Path &pathA, U32 inputKey[4],
GFXTextureProfile *profile);

25
Engine/source/gfx/gl/gfxGLDevice.cpp
View file

@ -22,6 +22,8 @@
#include "platform/platform.h"
#include "gfx/gl/gfxGLDevice.h"
#include "gfxGLTextureArray.h"
#include "platform/platformGL.h"
#include "gfx/gfxCubemap.h"
@ -457,6 +459,13 @@ GFXCubemapArray *GFXGLDevice::createCubemapArray()
return cubeArray;
}
GFXTextureArray* GFXGLDevice::createTextureArray()
{
GFXGLTextureArray* textureArray = new GFXGLTextureArray();
textureArray->registerResourceWithDevice(this);
return textureArray;
}
void GFXGLDevice::endSceneInternal()
{
// nothing to do for opengl
@ -766,6 +775,22 @@ void GFXGLDevice::setCubemapArrayInternal(U32 textureUnit, const GFXGLCubemapArr
}
}
void GFXGLDevice::setTextureArrayInternal(U32 textureUnit, const GFXGLTextureArray* texture)
{
if (texture)
{
mActiveTextureType[textureUnit] = GL_TEXTURE_2D_ARRAY;
texture->bind(textureUnit);
}
else if (mActiveTextureType[textureUnit] != GL_ZERO)
{
glActiveTexture(GL_TEXTURE0 + textureUnit);
glBindTexture(mActiveTextureType[textureUnit], 0);
getOpenglCache()->setCacheBindedTex(textureUnit, mActiveTextureType[textureUnit], 0);
mActiveTextureType[textureUnit] = GL_ZERO;
}
}
void GFXGLDevice::setMatrix( GFXMatrixType mtype, const MatrixF &mat )
{
// ONLY NEEDED ON FFP

4
Engine/source/gfx/gl/gfxGLDevice.h
View file

@ -35,6 +35,7 @@
#include "gfx/gfxResource.h"
#include "gfx/gl/gfxGLStateBlock.h"
class GFXGLTextureArray;
class GFXGLVertexBuffer;
class GFXGLPrimitiveBuffer;
class GFXGLTextureTarget;
@ -83,6 +84,7 @@ public:
virtual GFXCubemap * createCubemap();
virtual GFXCubemapArray *createCubemapArray();
virtual GFXTextureArray *createTextureArray();
virtual F32 getFillConventionOffset() const { return 0.0f; }
@ -173,6 +175,7 @@ protected:
virtual void setTextureInternal(U32 textureUnit, const GFXTextureObject*texture);
virtual void setCubemapInternal(U32 textureUnit, const GFXGLCubemap* texture);
virtual void setCubemapArrayInternal(U32 textureUnit, const GFXGLCubemapArray* texture);
virtual void setTextureArrayInternal(U32 textureUnit, const GFXGLTextureArray* texture);
virtual void setLightInternal(U32 lightStage, const GFXLightInfo light, bool lightEnable);
virtual void setLightMaterialInternal(const GFXLightMaterial mat);
@ -210,6 +213,7 @@ private:
friend class GFXGLTextureObject;
friend class GFXGLCubemap;
friend class GFXGLCubemapArray;
friend class GFXGLTextureArray;
friend class GFXGLWindowTarget;
friend class GFXGLPrimitiveBuffer;
friend class GFXGLVertexBuffer;

16
Engine/source/gfx/gl/gfxGLShader.cpp
View file

@ -82,6 +82,7 @@ static U32 shaderConstTypeSize(GFXShaderConstType type)
case GFXSCT_Sampler:
case GFXSCT_SamplerCube:
case GFXSCT_SamplerCubeArray:
case GFXSCT_SamplerTextureArray:
return 4;
case GFXSCT_Float2:
case GFXSCT_Int2:
@ -630,6 +631,9 @@ void GFXGLShader::initConstantDescs()
case GL_SAMPLER_CUBE_MAP_ARRAY_ARB:
desc.constType = GFXSCT_SamplerCubeArray;
break;
case GL_SAMPLER_2D_ARRAY:
desc.constType = GFXSCT_SamplerTextureArray;
break;
default:
AssertFatal(false, "GFXGLShader::initConstantDescs - unrecognized uniform type");
// If we don't recognize the constant don't add its description.
@ -661,7 +665,10 @@ void GFXGLShader::initHandles()
HandleMap::Iterator handle = mHandles.find(desc.name);
S32 sampler = -1;
if(desc.constType == GFXSCT_Sampler || desc.constType == GFXSCT_SamplerCube || desc.constType == GFXSCT_SamplerCubeArray)
if(desc.constType == GFXSCT_Sampler ||
desc.constType == GFXSCT_SamplerCube ||
desc.constType == GFXSCT_SamplerCubeArray ||
desc.constType == GFXSCT_SamplerTextureArray)
{
S32 idx = mSamplerNamesOrdered.find_next(desc.name);
AssertFatal(idx != -1, "");
@ -704,7 +711,11 @@ void GFXGLShader::initHandles()
for (HandleMap::Iterator iter = mHandles.begin(); iter != mHandles.end(); ++iter)
{
GFXGLShaderConstHandle* handle = iter->value;
if(handle->isValid() && (handle->getType() == GFXSCT_Sampler || handle->getType() == GFXSCT_SamplerCube || handle->getType() == GFXSCT_SamplerCubeArray))
if(handle->isValid() &&
(handle->getType() == GFXSCT_Sampler ||
handle->getType() == GFXSCT_SamplerCube ||
handle->getType() == GFXSCT_SamplerCubeArray ||
handle->getType() == GFXSCT_SamplerTextureArray))
{
// Set sampler number on our program.
glUniform1i(handle->mLocation, handle->mSamplerNum);
@ -837,6 +848,7 @@ void GFXGLShader::setConstantsFromBuffer(GFXGLShaderConstBuffer* buffer)
case GFXSCT_Sampler:
case GFXSCT_SamplerCube:
case GFXSCT_SamplerCubeArray:
case GFXSCT_SamplerTextureArray:
glUniform1iv(handle->mLocation, handle->mDesc.arraySize, (GLint*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Int2:

14
Engine/source/gfx/gl/gfxGLStateCache.h
View file

@ -20,11 +20,11 @@ public:
class TextureUnit
{
public:
TextureUnit() : mTexture1D(0), mTexture2D(0), mTexture3D(0), mTextureCube(0), mTextureCubeArray(0)
TextureUnit() : mTexture1D(0), mTexture2D(0), mTexture3D(0), mTextureCube(0), mTextureCubeArray(0), mTextureArray(0)
{
}
GLuint mTexture1D, mTexture2D, mTexture3D, mTextureCube, mTextureCubeArray;
GLuint mTexture1D, mTexture2D, mTexture3D, mTextureCube, mTextureCubeArray, mTextureArray;
};
/// after glBindTexture
@ -48,6 +48,9 @@ public:
case GL_TEXTURE_CUBE_MAP_ARRAY:
mTextureUnits[mActiveTexture].mTextureCubeArray = handle;
break;
case GL_TEXTURE_2D_ARRAY:
mTextureUnits[mActiveTexture].mTextureArray = handle;
break;
default:
AssertFatal(0, avar("GFXGLStateCache::setCacheBindedTex - binding (%x) not supported.", biding) );
return;
@ -74,6 +77,9 @@ public:
case GL_TEXTURE_CUBE_MAP_ARRAY:
mTextureUnits[mActiveTexture].mTextureCubeArray = handle;
break;
case GL_TEXTURE_2D_ARRAY:
mTextureUnits[mActiveTexture].mTextureArray = handle;
break;
case GL_FRAMEBUFFER:
mBindedFBO_W = mBindedFBO_R = handle;
break;
@ -109,6 +115,8 @@ public:
return mTextureUnits[mActiveTexture].mTextureCube;
case GL_TEXTURE_CUBE_MAP_ARRAY:
return mTextureUnits[mActiveTexture].mTextureCubeArray;
case GL_TEXTURE_2D_ARRAY:
return mTextureUnits[mActiveTexture].mTextureArray;
case GL_DRAW_FRAMEBUFFER:
return mBindedFBO_W;
case GL_READ_FRAMEBUFFER:
@ -138,4 +146,4 @@ protected:
};
#endif
#endif

98
Engine/source/gfx/gl/gfxGLTextureArray.cpp Normal file
View file

@ -0,0 +1,98 @@
#include "gfxGLTextureArray.h"
#include "gfxGLTextureObject.h"
#include "gfxGLUtils.h"
#include "core/util/tVector.h"
GFXGLTextureArray::GFXGLTextureArray()
{
mTextureArray = NULL;
}
void GFXGLTextureArray::init()
{
PRESERVE_2D_TEXTURE_ARRAY();
glGenTextures(1, &mTextureArray);
glBindTexture(GL_TEXTURE_2D_ARRAY, mTextureArray);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, mMin(mMipLevels - 1, 1));
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexStorage3D(GL_TEXTURE_2D_ARRAY, mMipLevels, GFXGLTextureInternalFormat[mFormat], mWidth, mHeight, mArraySize);
}
void GFXGLTextureArray::_setTexture(const GFXTexHandle& texture, U32 slot)
{
PRESERVE_2D_TEXTURE_ARRAY();
glBindTexture(GL_TEXTURE_2D_ARRAY, mTextureArray);
GFXGLTextureObject* texObj = dynamic_cast<GFXGLTextureObject*>(texture.getPointer());
for (U32 mip = 0; mip < mMipLevels; ++mip)
{
U8* buf = texObj->getTextureData(mip);
const U32 mipWidth = getMax(U32(1), mWidth >> mip);
const U32 mipHeight = getMax(U32(1), mHeight >> mip);
if (mIsCompressed)
{
glCompressedTexSubImage3D(
GL_TEXTURE_2D_ARRAY,
mip, 0, 0,
slot, mipWidth, mipHeight, 1,
GFXGLTextureFormat[mFormat], GFXGLTextureType[mFormat], buf
);
}
else
{
glTexSubImage3D(
GL_TEXTURE_2D_ARRAY,
mip, 0, 0,
slot, mipWidth, mipHeight, 1,
GFXGLTextureFormat[mFormat], GFXGLTextureType[mFormat], buf
);
}
delete[] buf;
}
}
void GFXGLTextureArray::setToTexUnit(U32 tuNum)
{
dynamic_cast<GFXGLDevice*>(getOwningDevice())->setTextureArrayInternal(tuNum, this);
}
void GFXGLTextureArray::Release()
{
glDeleteTextures(1, &mTextureArray);
mTextureArray = 0;
GFXTextureArray::Release();
}
void GFXGLTextureArray::bind(U32 textureUnit) const
{
glActiveTexture(GL_TEXTURE0 + textureUnit);
glBindTexture(GL_TEXTURE_2D_ARRAY, mTextureArray);
dynamic_cast<GFXGLDevice*>(getOwningDevice())->getOpenglCache()->setCacheBindedTex(textureUnit, GL_TEXTURE_2D_ARRAY, mTextureArray);
GFXGLStateBlockRef sb = dynamic_cast<GFXGLDevice*>(GFX)->getCurrentStateBlock();
AssertFatal(sb, "GFXGLTextureArray::bind - No active stateblock!");
if (!sb)
return;
const GFXSamplerStateDesc& ssd = sb->getDesc().samplers[textureUnit];
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, minificationFilter(ssd.minFilter, ssd.mipFilter, 0));
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GFXGLTextureFilter[ssd.magFilter]);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, mMin(mMipLevels - 1, 1));
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GFXGLTextureAddress[ssd.addressModeU]);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GFXGLTextureAddress[ssd.addressModeV]);
}
void GFXGLTextureArray::zombify()
{
}
void GFXGLTextureArray::resurrect()
{
}

35
Engine/source/gfx/gl/gfxGLTextureArray.h Normal file
View file

@ -0,0 +1,35 @@
#ifndef _GFXGLTEXTUREARRAY_H_
#define _GFXGLTEXTUREARRAY_H_
#include <glad/glad.h>
#include "gfx/gfxTextureArray.h"
#include "gfx/gfxTextureManager.h"
class GFXGLTextureArray : public GFXTextureArray
{
public:
GFXGLTextureArray();
~GFXGLTextureArray() { Release(); };
void init();
void setToTexUnit(U32 tuNum) override;
void bind(U32 textureUnit) const;
// GFXResource interface
void zombify() override;
void resurrect() override;
void Release() override;
protected:
void _setTexture(const GFXTexHandle& texture, U32 slot) override;
private:
GLuint mTextureArray;
};
#endif

5
Engine/source/gfx/gl/gfxGLUtils.h
View file

@ -30,7 +30,7 @@
inline U32 getMaxMipmaps(U32 width, U32 height, U32 depth)
{
return getMax( getBinLog2(depth), getMax(getBinLog2(width), getBinLog2(height)));
return getMax( getBinLog2(depth), getMax(getBinLog2(width), getBinLog2(height))) + 1;
}
inline GLenum minificationFilter(U32 minFilter, U32 mipFilter, U32 /*mipLevels*/)
@ -194,6 +194,9 @@ GFXGLPreserveTexture TORQUE_CONCAT(preserve_, __LINE__) (GL_TEXTURE_CUBE_MAP, GL
#define PRESERVE_CUBEMAP_ARRAY_TEXTURE() \
GFXGLPreserveTexture TORQUE_CONCAT(preserve_, __LINE__) (GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_BINDING_CUBE_MAP_ARRAY, (GFXGLPreserveInteger::BindFn)glBindTexture)
#define PRESERVE_2D_TEXTURE_ARRAY() \
GFXGLPreserveTexture TORQUE_CONCAT(preserve_, __LINE__) (GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BINDING_2D_ARRAY, (GFXGLPreserveInteger::BindFn)glBindTexture)
#define _GET_TEXTURE_BINDING(binding) \
binding == GL_TEXTURE_2D ? GL_TEXTURE_BINDING_2D : (binding == GL_TEXTURE_3D ? GL_TEXTURE_BINDING_3D : GL_TEXTURE_BINDING_1D )

23
Engine/source/shaderGen/shaderOp.cpp
View file

@ -80,6 +80,29 @@ void EchoOp::print( Stream &stream )
WRITESTR( mStatement );
}
//**************************************************************************
// Index operation
//**************************************************************************
IndexOp::IndexOp( Var* var, U32 index ) : Parent( NULL, NULL )
{
mInput[0] = var;
mIndex = index;
}
//--------------------------------------------------------------------------
// Print
//--------------------------------------------------------------------------
void IndexOp::print( Stream &stream )
{
Var* var = dynamic_cast<Var*>(mInput[0]);
mInput[0]->print(stream);
if (var->arraySize > 1)
{
WRITESTR(String::ToString("[%d]", mIndex));
}
}
//**************************************************************************
// General operation

15
Engine/source/shaderGen/shaderOp.h
View file

@ -110,6 +110,21 @@ public:
virtual void print( Stream &stream );
};
//----------------------------------------------------------------------------
/*!
Accesses the given index on the variable
*/
//----------------------------------------------------------------------------
class IndexOp : public ShaderOp
{
typedef ShaderOp Parent;
U32 mIndex;
public:
IndexOp( Var* var, U32 index );
virtual void print( Stream &stream );
};
//----------------------------------------------------------------------------
/*!

985
Engine/source/terrain/glsl/terrFeatureGLSL.cpp
View file

File diff suppressed because it is too large Load diff

30
Engine/source/terrain/glsl/terrFeatureGLSL.h
View file

@ -44,9 +44,9 @@ public:
Var* _getInMacroCoord(Vector<ShaderComponent*> &componentList );
Var* _getNormalMapTex();
Var* _getORMConfigMapTex();
Var* _getDetailMapSampler();
Var* _getNormalMapSampler();
Var* _getOrmMapSampler();
static Var* _getUniformVar( const char *name, const char *type, ConstantSortPosition csp );
@ -151,17 +151,6 @@ public:
virtual String getName() { return "Terrain Lightmap Texture"; }
};
class TerrainAdditiveFeatGLSL : public TerrainFeatGLSL
{
public:
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual String getName() { return "Terrain Additive"; }
};
class TerrainORMMapFeatGLSL : public TerrainFeatGLSL
{
public:
@ -189,4 +178,17 @@ public:
virtual String getName() { return "Blank Matinfo map"; }
};
class TerrainHeightMapBlendGLSL : public TerrainFeatGLSL
{
public:
virtual void processVert(Vector<ShaderComponent*>& componentList,
const MaterialFeatureData& fd);
virtual void processPix(Vector<ShaderComponent*>& componentList,
const MaterialFeatureData& fd);
virtual String getName() { return "Terrain Heightmap Blend"; }
};
#endif // _TERRFEATUREGLSL_H_

1018
Engine/source/terrain/hlsl/terrFeatureHLSL.cpp
View file

File diff suppressed because it is too large Load diff

30
Engine/source/terrain/hlsl/terrFeatureHLSL.h
View file

@ -45,6 +45,12 @@ public:
Var* _getInMacroCoord(Vector<ShaderComponent*> &componentList );
Var* _getDetailMapSampler();
Var* _getDetailMapArray();
Var* _getNormalMapSampler();
Var* _getNormalMapArray();
Var* _getOrmMapSampler();
Var* _getOrmMapArray();
Var* _getNormalMapTex();
Var* _getORMConfigMapTex();
@ -151,17 +157,6 @@ public:
virtual String getName() { return "Terrain Lightmap Texture"; }
};
class TerrainAdditiveFeatHLSL : public TerrainFeatHLSL
{
public:
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual String getName() { return "Terrain Additive"; }
};
class TerrainORMMapFeatHLSL : public TerrainFeatHLSL
{
public:
@ -189,4 +184,17 @@ public:
virtual String getName() { return "Blank Matinfo map"; }
};
class TerrainHeightMapBlendHLSL : public TerrainFeatHLSL
{
public:
virtual void processVert(Vector<ShaderComponent*>& componentList,
const MaterialFeatureData& fd);
virtual void processPix(Vector<ShaderComponent*>& componentList,
const MaterialFeatureData& fd);
virtual String getName() { return "Terrain Heightmap Blend"; }
};
#endif // _TERRFEATUREHLSL_H_

823
Engine/source/terrain/terrCellMaterial.cpp
View file

File diff suppressed because it is too large Load diff

118
Engine/source/terrain/terrCellMaterial.h
View file

@ -40,6 +40,7 @@
#endif
class GFXTextureArray;
class SceneRenderState;
struct SceneData;
class TerrainMaterial;
@ -58,8 +59,7 @@ protected:
public:
MaterialInfo()
:mat(NULL), layerId(0), detailTexConst(NULL), macroTexConst(NULL), normalTexConst(NULL),
ormTexConst(NULL), detailInfoVConst(NULL), detailInfoPConst(NULL), macroInfoVConst(NULL), macroInfoPConst(NULL)
:mat(NULL), layerId(0)
{
}
@ -69,95 +69,64 @@ protected:
TerrainMaterial *mat;
U32 layerId;
GFXShaderConstHandle *detailTexConst;
GFXTexHandle detailTex;
GFXShaderConstHandle *macroTexConst;
GFXTexHandle macroTex;
GFXShaderConstHandle *normalTexConst;
GFXTexHandle normalTex;
GFXShaderConstHandle *ormTexConst;
GFXTexHandle ormTex;
GFXShaderConstHandle *detailInfoVConst;
GFXShaderConstHandle *detailInfoPConst;
GFXShaderConstHandle *macroInfoVConst;
GFXShaderConstHandle *macroInfoPConst;
GFXShaderConstHandle* mBlendDepthConst;
GFXShaderConstHandle* mBlendContrastConst;
};
class Pass
{
public:
///
GFXShader *mShader;
Pass()
: shader( NULL ),
modelViewProjConst(NULL), worldViewOnly(NULL), viewToObj(NULL),
eyePosWorldConst(NULL), eyePosConst(NULL),
objTransConst(NULL), worldToObjConst(NULL), vEyeConst(NULL),
layerSizeConst(NULL), lightParamsConst(NULL), lightInfoBufferConst(NULL),
baseTexMapConst(NULL), layerTexConst(NULL),
lightMapTexConst(NULL),
squareSize(NULL), oneOverTerrainSize(NULL),
fogDataConst(NULL), fogColorConst(NULL)
{
}
GFXShaderConstBufferRef mConsts;
~Pass()
{
for ( U32 i=0; i < materials.size(); i++ )
delete materials[i];
}
GFXStateBlockRef mStateBlock;
GFXStateBlockRef mWireframeStateBlock;
GFXStateBlockRef mReflectionStateBlock;
Vector<MaterialInfo*> materials;
GFXShaderConstHandle *mModelViewProjConst;
GFXShaderConstHandle *mWorldViewOnlyConst;
GFXShaderConstHandle *mViewToObjConst;
///
GFXShader *shader;
GFXShaderConstHandle *mEyePosWorldConst;
GFXShaderConstHandle *mEyePosConst;
GFXShaderConstBufferRef consts;
GFXShaderConstHandle *mObjTransConst;
GFXShaderConstHandle *mWorldToObjConst;
GFXShaderConstHandle *mVEyeConst;
GFXStateBlockRef stateBlock;
GFXStateBlockRef wireframeStateBlock;
GFXStateBlockRef reflectionStateBlock;
GFXShaderConstHandle *mLayerSizeConst;
GFXShaderConstHandle *mLightParamsConst;
GFXShaderConstHandle *mLightInfoBufferConst;
GFXShaderConstHandle *modelViewProjConst;
GFXShaderConstHandle *worldViewOnly;
GFXShaderConstHandle *viewToObj;
GFXShaderConstHandle *mBaseTexMapConst;
GFXShaderConstHandle *mLayerTexConst;
GFXShaderConstHandle *eyePosWorldConst;
GFXShaderConstHandle *eyePosConst;
GFXShaderConstHandle *mLightMapTexConst;
GFXShaderConstHandle *objTransConst;
GFXShaderConstHandle *worldToObjConst;
GFXShaderConstHandle *vEyeConst;
GFXShaderConstHandle *mSquareSizeConst;
GFXShaderConstHandle *mOneOverTerrainSizeConst;
GFXShaderConstHandle *layerSizeConst;
GFXShaderConstHandle *lightParamsConst;
GFXShaderConstHandle *lightInfoBufferConst;
GFXShaderConstHandle* mDetailInfoVArrayConst;
GFXShaderConstHandle* mDetailInfoPArrayConst;
GFXShaderConstHandle* mMacroInfoVArrayConst;
GFXShaderConstHandle* mMacroInfoPArrayConst;
GFXShaderConstHandle *baseTexMapConst;
GFXShaderConstHandle *layerTexConst;
GFXShaderConstHandle *mFogDataConst;
GFXShaderConstHandle *mFogColorConst;
GFXShaderConstHandle *lightMapTexConst;
GFXShaderConstHandle *mDetailTexArrayConst;
GFXShaderConstHandle *mMacroTexArrayConst;
GFXShaderConstHandle *mNormalTexArrayConst;
GFXShaderConstHandle *mOrmTexArrayConst;
GFXShaderConstHandle *squareSize;
GFXShaderConstHandle *oneOverTerrainSize;
GFXShaderConstHandle *fogDataConst;
GFXShaderConstHandle *fogColorConst;
};
GFXShaderConstHandle* mBlendDepthConst;
TerrainBlock *mTerrain;
U64 mMaterials;
Vector<Pass> mPasses;
U32 mCurrPass;
U64 mMaterials;
Vector<MaterialInfo*> mMaterialInfos;
static const Vector<String> mSamplerNames;
GFXTexHandle mBaseMapTexture;
@ -175,14 +144,11 @@ protected:
/// A vector of all terrain cell materials loaded in the system.
static Vector<TerrainCellMaterial*> smAllMaterials;
bool _createPass( Vector<MaterialInfo*> *materials,
Pass *pass,
bool firstPass,
bool deferredMat,
bool _initShader( bool deferredMat,
bool reflectMat,
bool baseOnly );
void _updateMaterialConsts( Pass *pass );
void _updateMaterialConsts();
public:

18
Engine/source/terrain/terrData.cpp
View file

@ -47,11 +47,13 @@
#include "materials/baseMatInstance.h"
#include "gfx/gfxTextureManager.h"
#include "gfx/gfxCardProfile.h"
#include "gfx/gfxAPI.h"
#include "core/resourceManager.h"
#include "T3D/physics/physicsPlugin.h"
#include "T3D/physics/physicsBody.h"
#include "T3D/physics/physicsCollision.h"
#include "console/engineAPI.h"
#include "core/util/safeRelease.h"
#include "T3D/assets/TerrainMaterialAsset.h"
using namespace Torque;
@ -203,7 +205,11 @@ TerrainBlock::TerrainBlock()
mScreenError( 16 ),
mCastShadows( true ),
mZoningDirty( false ),
mUpdateBasetex ( true )
mUpdateBasetex ( true ),
mDetailTextureArray( NULL ),
mMacroTextureArray( NULL ),
mOrmTextureArray( NULL ),
mNormalTextureArray( NULL )
{
mTypeMask = TerrainObjectType | StaticObjectType | StaticShapeObjectType;
mNetFlags.set(Ghostable | ScopeAlways);
@ -231,6 +237,11 @@ TerrainBlock::~TerrainBlock()
editor->detachTerrain(this);
#endif
deleteZodiacPrimitiveBuffer();
SAFE_RELEASE(mDetailTextureArray);
SAFE_RELEASE(mMacroTextureArray);
SAFE_RELEASE(mNormalTextureArray);
SAFE_RELEASE(mOrmTextureArray);
}
void TerrainBlock::_onTextureEvent( GFXTexCallbackCode code )
@ -1461,6 +1472,11 @@ DefineEngineMethod(TerrainBlock, saveAsset, bool, (), ,
return static_cast<TerrainBlock*>(object)->saveAsset();
}
DefineEngineMethod( TerrainBlock, setMaterialsDirty, void, (),, "")
{
static_cast<TerrainBlock*>(object)->setMaterialsDirty();
}
//ConsoleMethod(TerrainBlock, save, bool, 3, 3, "(string fileName) - saves the terrain block's terrain file to the specified file name.")
//{
// char filename[256];

12
Engine/source/terrain/terrData.h
View file

@ -135,6 +135,11 @@ protected:
///
Vector<GFXTexHandle> mBaseTextures;
GFXTextureArrayHandle mDetailTextureArray;
GFXTextureArrayHandle mMacroTextureArray;
GFXTextureArrayHandle mNormalTextureArray;
GFXTextureArrayHandle mOrmTextureArray;
///
GFXTexHandle mLayerTex;
@ -308,6 +313,8 @@ public:
/// Deletes all the materials on the terrain.
void deleteAllMaterials();
void setMaterialsDirty() { mDetailsDirty = true; };
//void setMaterialName( U32 index, const String &name );
/// Accessors and mutators for TerrainMaterialUndoAction.
@ -324,6 +331,11 @@ public:
U32 getMaterialCount() const;
GFXTextureArrayHandle getDetailTextureArray() const { return mDetailTextureArray; }
GFXTextureArrayHandle getMacroTextureArray() const { return mMacroTextureArray; }
GFXTextureArrayHandle getNormalTextureArray() const { return mNormalTextureArray; }
GFXTextureArrayHandle getOrmTextureArray() const { return mOrmTextureArray; }
//BaseMatInstance* getMaterialInst( U32 x, U32 y );
void setHeight( const Point2I &pos, F32 height );

2
Engine/source/terrain/terrFeatureTypes.cpp
View file

@ -33,7 +33,7 @@ ImplementFeatureType( MFT_TerrainNormalMap, MFG_Texture, 103.0f, false );
ImplementFeatureType( MFT_TerrainMacroMap, MFG_Texture, 104.0f, false );
ImplementFeatureType( MFT_TerrainLightMap, MFG_Texture, 105.0f, false );
ImplementFeatureType( MFT_TerrainSideProject, MFG_Texture, 106.0f, false );
ImplementFeatureType( MFT_TerrainAdditive, MFG_PostProcess, 999.0f, false );
ImplementFeatureType( MFT_TerrainHeightBlend, MFG_PreLighting, 200.0f, false );
//Deferred Shading
ImplementFeatureType( MFT_DeferredTerrainBlankInfoMap, MFG_Texture, 104.1f, false);
ImplementFeatureType( MFT_TerrainORMMap, MFG_Texture, 104.2f, false);

2
Engine/source/terrain/terrFeatureTypes.h
View file

@ -34,7 +34,7 @@ DeclareFeatureType( MFT_TerrainNormalMap );
DeclareFeatureType( MFT_TerrainParallaxMap );
DeclareFeatureType( MFT_TerrainLightMap );
DeclareFeatureType( MFT_TerrainSideProject );
DeclareFeatureType( MFT_TerrainAdditive );
DeclareFeatureType( MFT_TerrainHeightBlend );
//Deferred Shading
DeclareFeatureType( MFT_TerrainORMMap );
DeclareFeatureType( MFT_DeferredTerrainBlankInfoMap );

8
Engine/source/terrain/terrMaterial.cpp
View file

@ -68,6 +68,8 @@ TerrainMaterial::TerrainMaterial()
mMacroStrength( 0.7f ),
mMacroDistance( 500.0f ),
mParallaxScale( 0.0f ),
mBlendDepth( 0.0f ),
mBlendContrast( 1.0f ),
mIsSRGB(false),
mInvertRoughness(false)
{
@ -91,6 +93,12 @@ void TerrainMaterial::initPersistFields()
addField( "parallaxScale", TypeF32, Offset( mParallaxScale, TerrainMaterial ), "Used to scale the height from the normal map to give some self "
"occlusion effect (aka parallax) to the terrain material" );
addField("blendHeightBase", TypeF32, Offset(mBlendDepth, TerrainMaterial), "A fixed value to add while blending using heightmap-based blending."
"Higher numbers = larger blend radius.");
addField("blendHeightContrast", TypeF32, Offset(mBlendContrast, TerrainMaterial), "A fixed value to add while blending using heightmap-based blending."
"Higher numbers = larger blend radius.");
scriptBindMapSlot(DetailMap, TerrainMaterial, "Raises and lowers the RGB result of the Base Albedo up close.");
addField( "detailSize", TypeF32, Offset( mDetailSize, TerrainMaterial ), "Used to scale the detail map to the material square" );
addField( "detailStrength", TypeF32, Offset( mDetailStrength, TerrainMaterial ), "Exponentially sharpens or lightens the detail map rendering on the material" );

11
Engine/source/terrain/terrMaterial.h
View file

@ -85,6 +85,13 @@ protected:
///
F32 mParallaxScale;
/// Depth for blending the textures using the new
/// blending method. Higher numbers = larger blend
/// radius.
F32 mBlendDepth;
F32 mBlendContrast;
public:
TerrainMaterial();
@ -122,6 +129,10 @@ public:
F32 getParallaxScale() const { return mParallaxScale; }
F32 getBlendDepth() const { return mBlendDepth; }
F32 getBlendContrast() const { return mBlendContrast; }
bool getIsSRGB() const { return mIsSRGB; }
bool getInvertRoughness() const { return mInvertRoughness; }

129
Engine/source/terrain/terrRender.cpp
View file

@ -96,7 +96,7 @@ void TerrainBlock::_updateMaterials()
{
TerrainMaterial *mat = mFile->mMaterials[i];
if (!mat->getDiffuseMap().isEmpty())
if (mat->getDiffuseMap().isNotEmpty())
{
mBaseTextures[i].set(mat->getDiffuseMap(), &GFXStaticTextureSRGBProfile,
"TerrainBlock::_updateMaterials() - DiffuseMap");
@ -114,6 +114,133 @@ void TerrainBlock::_updateMaterials()
mMaxDetailDistance = mat->getMacroDistance();
}
Vector<GFXTexHandle> detailTexArray;
detailTexArray.setSize(mFile->mMaterials.size());
Vector<GFXTexHandle> macroTexArray;
macroTexArray.setSize(mFile->mMaterials.size());
Vector<GFXTexHandle> normalTexArray;
normalTexArray.setSize(mFile->mMaterials.size());
Vector<GFXTexHandle> ormTexArray;
ormTexArray.setSize(mFile->mMaterials.size());
for (U32 i = 0; i < mFile->mMaterials.size(); i++)
{
TerrainMaterial* mat = mFile->mMaterials[i];
GFXTextureProfile* profile = &GFXStaticTextureProfile;
if (mat->getIsSRGB())
profile = &GFXStaticTextureSRGBProfile;
if (mat->getDetailMap().isNotEmpty())
detailTexArray[i] = TEXMGR->createTexture(mat->getDetailMap(), profile);
if (mat->getMacroMap().isNotEmpty())
macroTexArray[i] = TEXMGR->createTexture(mat->getMacroMap(), profile);
if (mat->getNormalMap().isNotEmpty())
normalTexArray[i] = TEXMGR->createTexture(mat->getNormalMap(), profile);
if (mat->getORMConfigMap().isNotEmpty())
ormTexArray[i] = TEXMGR->createTexture(mat->getORMConfigMap(), profile);
}
if (mDetailTextureArray.isNull())
{
mDetailTextureArray = GFX->createTextureArray();
}
if (mMacroTextureArray.isNull())
{
mMacroTextureArray = GFX->createTextureArray();
}
if (mNormalTextureArray.isNull())
{
mNormalTextureArray = GFX->createTextureArray();
}
if (mOrmTextureArray.isNull())
{
mOrmTextureArray = GFX->createTextureArray();
}
U32 detailTexArraySize = detailTexArray.size();
U32 macroTexArraySize = macroTexArray.size();
U32 normalTexArraySize = normalTexArray.size();
U32 ormTexArraySize = ormTexArray.size();
#ifdef TORQUE_TOOLS
// For performance improvement when adding terrain layers, we always allocate at least 32 textures to the arrays in tool builds
detailTexArraySize = mMax(32, detailTexArraySize);
macroTexArraySize = mMax(32, macroTexArraySize);
normalTexArraySize = mMax(32, normalTexArraySize);
ormTexArraySize = mMax(32, ormTexArraySize);
#endif
// Format has been explicitly set
const U32 detailTexSize = Con::getIntVariable("Terrain::DetailTextureSize");
const GFXFormat detailTexFormat = static_cast<GFXFormat>(Con::getIntVariable("Terrain::DetailTextureFormat"));
if (detailTexSize != 0)
{
GFXFormat format = GFXFormatR8G8B8A8;
if (detailTexFormat < GFXFormat_COUNT)
{
format = detailTexFormat;
}
mDetailTextureArray->set(detailTexSize, detailTexSize, detailTexArraySize, format);
}
const U32 macroTexSize = Con::getIntVariable("Terrain::MacroTextureSize");
const GFXFormat macroTexFormat = static_cast<GFXFormat>(Con::getIntVariable("Terrain::MacroTextureFormat"));
if (macroTexSize != 0)
{
GFXFormat format = GFXFormatR8G8B8A8;
if (macroTexFormat < GFXFormat_COUNT)
{
format = macroTexFormat;
}
mMacroTextureArray->set(macroTexSize, macroTexSize, macroTexArraySize, format);
}
const U32 normalTexSize = Con::getIntVariable("Terrain::NormalTextureSize");
const GFXFormat normalTexFormat = static_cast<GFXFormat>(Con::getIntVariable("Terrain::NormalTextureFormat"));
if (normalTexSize != 0)
{
GFXFormat format = GFXFormatR8G8B8A8;
if (normalTexFormat < GFXFormat_COUNT)
{
format = normalTexFormat;
}
mNormalTextureArray->set(normalTexSize, normalTexSize, normalTexArraySize, format);
}
const U32 ormTexSize = Con::getIntVariable("Terrain::OrmTextureSize");
const GFXFormat ormTexFormat = static_cast<GFXFormat>(Con::getIntVariable("Terrain::OrmTextureFormat"));
if (ormTexSize != 0)
{
GFXFormat format = GFXFormatR8G8B8A8;
if (ormTexFormat < GFXFormat_COUNT)
{
format = ormTexFormat;
}
mOrmTextureArray->set(ormTexSize, ormTexSize, ormTexArraySize, format);
}
if (!mDetailTextureArray->fromTextureArray(detailTexArray, detailTexArraySize))
{
Con::errorf("TerrainBlock::_updateMaterials - an issue with the diffuse terrain materials was detected. Please ensure they are all of the same size and format!");
}
if (!mMacroTextureArray->fromTextureArray(macroTexArray, macroTexArraySize))
{
Con::errorf("TerrainBlock::_updateMaterials - an issue with the detail terrain materials was detected. Please ensure they are all of the same size and format!");
}
if (!mNormalTextureArray->fromTextureArray(normalTexArray, normalTexArraySize))
{
Con::errorf("TerrainBlock::_updateMaterials - an issue with the normal terrain materials was detected. Please ensure they are all of the same size and format!");
}
if (!mOrmTextureArray->fromTextureArray(ormTexArray, ormTexArraySize))
{
Con::errorf("TerrainBlock::_updateMaterials - an issue with the orm terrain materials was detected. Please ensure they are all of the same size and format!");
}
if ( mCell )
mCell->deleteMaterials();
}