mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-19 20:24:49 +00:00
Merge pull request #424 from lukaspj/feature/new-terrain-blending
Height based terrain texture blending
This commit is contained in:
Brian Roberts
GitHub
commit
27641b16ca
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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;}
|
||||
|
|
|
|||
|
|
@ -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
150
Engine/source/gfx/D3D11/gfxD3D11TextureArray.cpp
Normal 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
56
Engine/source/gfx/D3D11/gfxD3D11TextureArray.h
Normal 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
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -130,6 +130,7 @@ protected:
|
|||
public:
|
||||
virtual GFXCubemap * createCubemap();
|
||||
virtual GFXCubemapArray *createCubemapArray();
|
||||
virtual GFXTextureArray *createTextureArray();
|
||||
|
||||
virtual F32 getFillConventionOffset() const { return 0.0f; };
|
||||
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -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]; }
|
||||
|
||||
/// @}
|
||||
|
|
|
|||
|
|
@ -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
181
Engine/source/gfx/gfxTextureArray.cpp
Normal 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
88
Engine/source/gfx/gfxTextureArray.h
Normal 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_
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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
98
Engine/source/gfx/gl/gfxGLTextureArray.cpp
Normal 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
35
Engine/source/gfx/gl/gfxGLTextureArray.h
Normal 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
|
||||
|
|
@ -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 )
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
/*!
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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_
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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_
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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:
|
||||
|
||||
|
|
|
|||
|
|
@ -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];
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
|
|
|
|||
|
|
@ -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" );
|
||||
|
|
|
|||
|
|
@ -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; }
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,22 @@ function Core_Rendering::onCreate(%this)
|
|||
|
||||
$pref::ReflectionProbes::BakeResolution = ProjectSettings.value("Rendering/ProbeCaptureResolution", "64");
|
||||
|
||||
$Terrain::LerpBlend = ProjectSettings.value("Terrain/LerpBlend");
|
||||
$Terrain::BlendDepth = ProjectSettings.value("Terrain/BlendDepth");
|
||||
|
||||
$Terrain::DetailTextureSize = ProjectSettings.value("Terrain/DetailTextureSize");
|
||||
$Terrain::MacroTextureSize = ProjectSettings.value("Terrain/MacroTextureSize");
|
||||
$Terrain::NormalTextureSize = ProjectSettings.value("Terrain/NormalTextureSize");
|
||||
$Terrain::OrmTextureSize = ProjectSettings.value("Terrain/OrmTextureSize");
|
||||
|
||||
// Default to R8G8B8A8 for all textures
|
||||
$Terrain::DetailTextureFormat = ProjectSettings.value("Terrain/DetailTextureFormat", 12);
|
||||
$Terrain::MacroTextureFormat = ProjectSettings.value("Terrain/MacroTextureFormat", 12);
|
||||
$Terrain::NormalTextureFormat = ProjectSettings.value("Terrain/NormalTextureFormat", 12);
|
||||
$Terrain::OrmTextureFormat = ProjectSettings.value("Terrain/OrmTextureFormat", 12);
|
||||
|
||||
exec("./scripts/graphicsOptions.cs");
|
||||
exec("./scripts/terrainSettings.cs");
|
||||
exec("./scripts/renderManager.cs");
|
||||
exec("./scripts/gfxData/clouds.cs");
|
||||
exec("./scripts/gfxData/commonMaterialData.cs");
|
||||
|
|
@ -20,6 +35,8 @@ function Core_Rendering::onCreate(%this)
|
|||
exec("./scripts/gfxData/terrainBlock.cs");
|
||||
exec("./scripts/gfxData/water.cs");
|
||||
exec("./scripts/gfxData/warningTerrainMat.cs");
|
||||
|
||||
loadTerrainSettings();
|
||||
}
|
||||
|
||||
function Core_Rendering::onDestroy(%this)
|
||||
|
|
|
|||
|
|
@ -166,6 +166,35 @@ vec2 parallaxOffsetDxtnm(sampler2D texMap, vec2 texCoord, vec3 negViewTS, float
|
|||
return offset;
|
||||
}
|
||||
|
||||
/// Same as the above but for arrays
|
||||
vec2 parallaxOffset( sampler2DArray texMap, vec3 texCoord, vec3 negViewTS, float depthScale )
|
||||
{
|
||||
float depth = texture( texMap, texCoord ).a/(PARALLAX_REFINE_STEPS*2);
|
||||
vec2 offset = negViewTS.xy * vec2( depth * depthScale )/vec2(PARALLAX_REFINE_STEPS*2);
|
||||
|
||||
for ( int i=0; i < PARALLAX_REFINE_STEPS; i++ )
|
||||
{
|
||||
depth = ( depth + texture( texMap, texCoord + vec3(offset, 0.0) ).a )/(PARALLAX_REFINE_STEPS*2);
|
||||
offset = negViewTS.xy * vec2( depth * depthScale )/vec2(PARALLAX_REFINE_STEPS*2);
|
||||
}
|
||||
|
||||
return offset;
|
||||
}
|
||||
|
||||
vec2 parallaxOffsetDxtnm(sampler2DArray texMap, vec3 texCoord, vec3 negViewTS, float depthScale)
|
||||
{
|
||||
float depth = texture(texMap, texCoord).r/(PARALLAX_REFINE_STEPS*2);
|
||||
vec2 offset = negViewTS.xy * vec2(depth * depthScale)/vec2(PARALLAX_REFINE_STEPS*2);
|
||||
|
||||
for (int i = 0; i < PARALLAX_REFINE_STEPS; i++)
|
||||
{
|
||||
depth = (depth + texture(texMap, texCoord + vec3(offset, 0.0)).r)/(PARALLAX_REFINE_STEPS*2);
|
||||
offset = negViewTS.xy * vec2(depth * depthScale)/vec2(PARALLAX_REFINE_STEPS*2);
|
||||
}
|
||||
|
||||
return offset;
|
||||
}
|
||||
|
||||
/// The maximum value for 10bit per component integer HDR encoding.
|
||||
const float HDR_RGB10_MAX = 4.0;
|
||||
|
||||
|
|
|
|||
|
|
@ -60,6 +60,7 @@
|
|||
//helper if you want to pass sampler/texture in a function
|
||||
//2D
|
||||
#define TORQUE_SAMPLER2D(tex) Texture2D texture_##tex, SamplerState tex
|
||||
#define TORQUE_SAMPLER2DARRAY(tex) Texture2DArray texture_##tex, SamplerState tex
|
||||
#define TORQUE_SAMPLER2D_MAKEARG(tex) texture_##tex, tex
|
||||
// Sampler comparison state - use above MAKEARG with this
|
||||
#define TORQUE_SAMPLER2DCMP(tex) Texture2D texture_##tex, SamplerComparisonState tex
|
||||
|
|
|
|||
|
|
@ -167,6 +167,35 @@ float2 parallaxOffsetDxtnm(TORQUE_SAMPLER2D(texMap), float2 texCoord, float3 neg
|
|||
return offset;
|
||||
}
|
||||
|
||||
/// Copy of the above to functions, but for arrays
|
||||
float2 parallaxOffsetTexArray(TORQUE_SAMPLER2DARRAY(texMap), float3 texCoord, float3 negViewTS, float depthScale)
|
||||
{
|
||||
float depth = TORQUE_TEX2D(texMap, texCoord).a/(PARALLAX_REFINE_STEPS*2);
|
||||
float2 offset = negViewTS.xy * (depth * depthScale)/(PARALLAX_REFINE_STEPS);
|
||||
|
||||
for (int i = 0; i < PARALLAX_REFINE_STEPS; i++)
|
||||
{
|
||||
depth = (depth + TORQUE_TEX2D(texMap, texCoord + float3(offset, 0.0)).a)/(PARALLAX_REFINE_STEPS*2);
|
||||
offset = negViewTS.xy * (depth * depthScale)/(PARALLAX_REFINE_STEPS);
|
||||
}
|
||||
|
||||
return offset;
|
||||
}
|
||||
|
||||
float2 parallaxOffsetDxtnmTexArray(TORQUE_SAMPLER2DARRAY(texMap), float3 texCoord, float3 negViewTS, float depthScale)
|
||||
{
|
||||
float depth = TORQUE_TEX2D(texMap, texCoord).r/(PARALLAX_REFINE_STEPS*2);
|
||||
float2 offset = negViewTS.xy * (depth * depthScale)/(PARALLAX_REFINE_STEPS*2);
|
||||
|
||||
for (int i = 0; i < PARALLAX_REFINE_STEPS; i++)
|
||||
{
|
||||
depth = (depth + TORQUE_TEX2D(texMap, texCoord + float3(offset, 0.0)).r)/(PARALLAX_REFINE_STEPS*2);
|
||||
offset = negViewTS.xy * (depth * depthScale)/(PARALLAX_REFINE_STEPS*2);
|
||||
}
|
||||
|
||||
return offset;
|
||||
}
|
||||
|
||||
/// The maximum value for 10bit per component integer HDR encoding.
|
||||
static const float HDR_RGB10_MAX = 4.0;
|
||||
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@
|
|||
new GuiBitmapCtrl() {
|
||||
Enabled = "1";
|
||||
Profile = "ToolsGuiDefaultProfile";
|
||||
position = "270 3";
|
||||
position = "230 3";
|
||||
Extent = "2 26";
|
||||
MinExtent = "1 1";
|
||||
bitmap = "tools/gui/images/separator-h.png";
|
||||
|
|
@ -222,7 +222,7 @@
|
|||
Profile = "ToolsGuiDefaultProfile";
|
||||
HorizSizing = "right";
|
||||
VertSizing = "bottom";
|
||||
Position = "262 5";
|
||||
Position = "222 5";
|
||||
Extent = "256 50";
|
||||
MinExtent = "8 2";
|
||||
canSave = "1";
|
||||
|
|
@ -370,7 +370,7 @@
|
|||
new GuiBitmapCtrl() {
|
||||
Enabled = "1";
|
||||
Profile = "ToolsGuiDefaultProfile";
|
||||
position = "525 3";
|
||||
position = "445 3";
|
||||
Extent = "2 26";
|
||||
MinExtent = "1 1";
|
||||
bitmap = "tools/gui/images/separator-h.png";
|
||||
|
|
@ -382,7 +382,7 @@
|
|||
Profile = "ToolsGuiTransparentProfile";
|
||||
HorizSizing = "right";
|
||||
VertSizing = "bottom";
|
||||
position = "540 5";
|
||||
position = "480 5";
|
||||
Extent = "120 50";
|
||||
MinExtent = "8 2";
|
||||
canSave = "1";
|
||||
|
|
@ -454,6 +454,43 @@
|
|||
bitmap = "tools/gui/images/dropslider";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiBitmapCtrl() {
|
||||
Enabled = "1";
|
||||
Profile = "ToolsGuiDefaultProfile";
|
||||
position = "618 3";
|
||||
Extent = "2 26";
|
||||
MinExtent = "1 1";
|
||||
bitmap = "tools/gui/images/separator-h.png";
|
||||
};
|
||||
|
||||
new GuiControl(TerrainTextureSettingsButtonContainer,EditorGuiGroup) {
|
||||
position = "628 5";
|
||||
extent = "90 18";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
profile = "ToolsGuiTransparentProfile";
|
||||
visible = "1";
|
||||
active = "1";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
isContainer = "1";
|
||||
canSave = "1";
|
||||
canSaveDynamicFields = "0";
|
||||
|
||||
new GuiButtonCtrl() {
|
||||
text = "Texture Settings";
|
||||
buttonType = "pushButton";
|
||||
profile = "ToolsGuiButtonProfile";
|
||||
command = "TerrainTextureSettingsDlg.show();";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
position = "0 0";
|
||||
extent = "90 18";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
//--- OBJECT WRITE END ---
|
||||
|
|
|
|||
|
|
@ -32,9 +32,9 @@
|
|||
anchorBottom = "0";
|
||||
anchorLeft = "0";
|
||||
anchorRight = "0";
|
||||
position = "315 168";
|
||||
extent = "394 494";
|
||||
minExtent = "358 432";
|
||||
position = "315 127";
|
||||
extent = "394 514";
|
||||
minExtent = "358 452";
|
||||
horizSizing = "center";
|
||||
vertSizing = "center";
|
||||
profile = "ToolsGuiWindowProfile";
|
||||
|
|
@ -149,7 +149,7 @@
|
|||
anchorLeft = "1";
|
||||
anchorRight = "0";
|
||||
position = "202 26";
|
||||
extent = "185 425";
|
||||
extent = "185 445";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "left";
|
||||
vertSizing = "height";
|
||||
|
|
@ -511,7 +511,7 @@
|
|||
anchorLeft = "1";
|
||||
anchorRight = "0";
|
||||
position = "6 122";
|
||||
extent = "185 50";
|
||||
extent = "185 100";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "width";
|
||||
vertSizing = "bottom";
|
||||
|
|
@ -712,12 +712,162 @@
|
|||
canSave = "1";
|
||||
canSaveDynamicFields = "0";
|
||||
};
|
||||
new GuiSliderCtrl(TerrainMaterialDlgBlendHeightBaseSlider) {
|
||||
range = "-0.5 0.5";
|
||||
ticks = "0";
|
||||
snap = "0";
|
||||
value = "0.5";
|
||||
useFillBar = "0";
|
||||
fillBarColor = "255 255 255 255";
|
||||
renderTicks = "1";
|
||||
position = "39 61";
|
||||
extent = "70 14";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
profile = "ToolsGuiSliderProfile";
|
||||
visible = "1";
|
||||
active = "1";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
isContainer = "0";
|
||||
internalName = "blendHeightBaseSliderCtrl";
|
||||
canSave = "1";
|
||||
canSaveDynamicFields = "0";
|
||||
};
|
||||
new GuiTextCtrl() {
|
||||
text = "Blend Height";
|
||||
maxLength = "1024";
|
||||
margin = "0 0 0 0";
|
||||
padding = "0 0 0 0";
|
||||
anchorTop = "1";
|
||||
anchorBottom = "0";
|
||||
anchorLeft = "1";
|
||||
anchorRight = "0";
|
||||
position = "115 61";
|
||||
extent = "58 15";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
visible = "1";
|
||||
active = "1";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
isContainer = "1";
|
||||
canSave = "1";
|
||||
canSaveDynamicFields = "0";
|
||||
};
|
||||
new GuiTextEditCtrl(TerrainMaterialDlgBlendHeightBaseTextEdit) {
|
||||
historySize = "0";
|
||||
tabComplete = "0";
|
||||
sinkAllKeyEvents = "0";
|
||||
password = "0";
|
||||
passwordMask = "*";
|
||||
text = "0.3";
|
||||
maxLength = "1024";
|
||||
margin = "0 0 0 0";
|
||||
padding = "0 0 0 0";
|
||||
anchorTop = "0";
|
||||
anchorBottom = "0";
|
||||
anchorLeft = "0";
|
||||
anchorRight = "0";
|
||||
position = "1 59";
|
||||
extent = "35 18";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
profile = "ToolsGuiTextEditProfile";
|
||||
visible = "1";
|
||||
active = "1";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
isContainer = "0";
|
||||
internalName = "blendHeightBaseTextEditCtrl";
|
||||
canSave = "1";
|
||||
canSaveDynamicFields = "0";
|
||||
};
|
||||
new GuiSliderCtrl(TerrainMaterialDlgBlendHeightContrastSlider) {
|
||||
range = "0.0 5.0";
|
||||
ticks = "0";
|
||||
snap = "0";
|
||||
value = "1.0";
|
||||
useFillBar = "0";
|
||||
fillBarColor = "255 255 255 255";
|
||||
renderTicks = "1";
|
||||
position = "39 81";
|
||||
extent = "70 14";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
profile = "ToolsGuiSliderProfile";
|
||||
visible = "1";
|
||||
active = "1";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
isContainer = "0";
|
||||
internalName = "blendHeightContrastSliderCtrl";
|
||||
canSave = "1";
|
||||
canSaveDynamicFields = "0";
|
||||
};
|
||||
new GuiTextCtrl() {
|
||||
text = "Blend Contrast";
|
||||
maxLength = "1024";
|
||||
margin = "0 0 0 0";
|
||||
padding = "0 0 0 0";
|
||||
anchorTop = "1";
|
||||
anchorBottom = "0";
|
||||
anchorLeft = "1";
|
||||
anchorRight = "0";
|
||||
position = "115 81";
|
||||
extent = "58 15";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
visible = "1";
|
||||
active = "1";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
isContainer = "1";
|
||||
canSave = "1";
|
||||
canSaveDynamicFields = "0";
|
||||
};
|
||||
new GuiTextEditCtrl(TerrainMaterialDlgBlendHeightContrastTextEdit) {
|
||||
historySize = "0";
|
||||
tabComplete = "0";
|
||||
sinkAllKeyEvents = "0";
|
||||
password = "0";
|
||||
passwordMask = "*";
|
||||
text = "0.3";
|
||||
maxLength = "1024";
|
||||
margin = "0 0 0 0";
|
||||
padding = "0 0 0 0";
|
||||
anchorTop = "0";
|
||||
anchorBottom = "0";
|
||||
anchorLeft = "0";
|
||||
anchorRight = "0";
|
||||
position = "1 79";
|
||||
extent = "35 18";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
profile = "ToolsGuiTextEditProfile";
|
||||
visible = "1";
|
||||
active = "1";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
isContainer = "0";
|
||||
internalName = "blendHeightContrastTextEditCtrl";
|
||||
canSave = "1";
|
||||
canSaveDynamicFields = "0";
|
||||
};
|
||||
};
|
||||
new GuiBitmapCtrl() {
|
||||
bitmap = "tools/gui/images/separator-v";
|
||||
color = "255 255 255 255";
|
||||
wrap = "0";
|
||||
position = "6 177";
|
||||
position = "6 222";
|
||||
extent = "175 2";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "width";
|
||||
|
|
@ -738,7 +888,7 @@
|
|||
anchorBottom = "0";
|
||||
anchorLeft = "1";
|
||||
anchorRight = "0";
|
||||
position = "6 184";
|
||||
position = "6 229";
|
||||
extent = "185 64";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "width";
|
||||
|
|
@ -781,7 +931,7 @@
|
|||
anchorLeft = "1";
|
||||
anchorRight = "0";
|
||||
position = "56 -3";
|
||||
extent = "60 18";
|
||||
extent = "64 18";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
|
|
@ -933,7 +1083,7 @@
|
|||
bitmap = "tools/gui/images/separator-v";
|
||||
color = "255 255 255 255";
|
||||
wrap = "0";
|
||||
position = "6 254";
|
||||
position = "6 299";
|
||||
extent = "175 2";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "width";
|
||||
|
|
@ -954,7 +1104,7 @@
|
|||
anchorBottom = "0";
|
||||
anchorLeft = "1";
|
||||
anchorRight = "0";
|
||||
position = "6 261";
|
||||
position = "6 306";
|
||||
extent = "185 72";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "width";
|
||||
|
|
@ -1438,7 +1588,7 @@
|
|||
bitmap = "tools/gui/images/separator-v";
|
||||
color = "255 255 255 255";
|
||||
wrap = "0";
|
||||
position = "6 336";
|
||||
position = "6 381";
|
||||
extent = "175 2";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "width";
|
||||
|
|
@ -1459,7 +1609,7 @@
|
|||
anchorBottom = "0";
|
||||
anchorLeft = "1";
|
||||
anchorRight = "0";
|
||||
position = "6 343";
|
||||
position = "6 388";
|
||||
extent = "185 72";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "width";
|
||||
|
|
@ -1766,7 +1916,7 @@
|
|||
};
|
||||
new GuiControl() {
|
||||
position = "6 42";
|
||||
extent = "189 435";
|
||||
extent = "189 455";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "width";
|
||||
vertSizing = "height";
|
||||
|
|
@ -1831,7 +1981,7 @@
|
|||
canRenameObjects = "1";
|
||||
renameInternal = "0";
|
||||
position = "1 1";
|
||||
extent = "8 2";
|
||||
extent = "136 798";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
|
|
@ -1853,7 +2003,7 @@
|
|||
groupNum = "-1";
|
||||
buttonType = "PushButton";
|
||||
useMouseEvents = "0";
|
||||
position = "202 456";
|
||||
position = "202 476";
|
||||
extent = "98 22";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "left";
|
||||
|
|
@ -1873,7 +2023,7 @@
|
|||
groupNum = "-1";
|
||||
buttonType = "PushButton";
|
||||
useMouseEvents = "0";
|
||||
position = "307 456";
|
||||
position = "307 476";
|
||||
extent = "80 22";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "left";
|
||||
|
|
@ -1893,7 +2043,7 @@
|
|||
color = "255 255 255 255";
|
||||
wrap = "0";
|
||||
position = "199 23";
|
||||
extent = "190 329";
|
||||
extent = "190 349";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "left";
|
||||
vertSizing = "height";
|
||||
|
|
|
|||
|
|
@ -0,0 +1,309 @@
|
|||
//--- OBJECT WRITE BEGIN ---
|
||||
%guiContent = new GuiControl(TerrainTextureSettingsDlg, EditorGuiGroup) {
|
||||
position = "0 0";
|
||||
extent = "1024 768";
|
||||
minExtent = "8 2";
|
||||
horizSizing = "right";
|
||||
vertSizing = "bottom";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
visible = "1";
|
||||
active = "1";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
isContainer = "1";
|
||||
canSave = "1";
|
||||
canSaveDynamicFields = "1";
|
||||
|
||||
new GuiWindowCtrl() {
|
||||
canSaveDynamicFields = "0";
|
||||
internalName = "TerrainTextureSettings";
|
||||
Enabled = "1";
|
||||
isContainer = "1";
|
||||
Profile = "ToolsGuiWindowProfile";
|
||||
position = "342 184";
|
||||
extent = "340 400";
|
||||
minExtent = "340 400";
|
||||
horizSizing = "center";
|
||||
vertSizing = "center";
|
||||
canSave = "1";
|
||||
isDecoy = "0";
|
||||
Visible = "1";
|
||||
tooltipprofile = "ToolsGuiToolTipProfile";
|
||||
hovertime = "1000";
|
||||
Margin = "0 0 0 0";
|
||||
Padding = "0 0 0 0";
|
||||
AnchorTop = "1";
|
||||
AnchorBottom = "1";
|
||||
AnchorLeft = "1";
|
||||
AnchorRight = "1";
|
||||
resizeWidth = "1";
|
||||
resizeHeight = "0";
|
||||
canMove = "1";
|
||||
canClose = "1";
|
||||
canMinimize = "0";
|
||||
canMaximize = "0";
|
||||
minSize = "4 4";
|
||||
closeCommand = "TerrainTextureSettingsDlg.cancel();";
|
||||
EdgeSnap = "0";
|
||||
text = "Global Terrain Texture Settings";
|
||||
|
||||
new GuiCheckBoxCtrl() {
|
||||
internalName = "lerpBlendCheckBox";
|
||||
text = "LerpBlend";
|
||||
profile = "ToolsGuiCheckBoxProfile";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
tooltip = "If enabled, terrain textures will use a simple linear interpolation blending method.";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
|
||||
position = "20 40";
|
||||
extent = "300 20";
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 70";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "Global Blend Depth:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
tooltipProfile = "ToolsGuiToolTipProfile";
|
||||
tooltip = "Controls the general level of bleding across all textures, has no effect if Lerp Blend is enabled.";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiSliderCtrl() {
|
||||
internalName = "blendDepthSlider";
|
||||
profile = "ToolsGuiSliderProfile";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
altCommand = "TerrainTextureSettingsDlg.updateBlendDepth();";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
|
||||
range = "0.01 1.0";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 100";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "Detail Texture Size:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiTextEditCtrl() {
|
||||
internalName = "detailTextureSizeTextEdit";
|
||||
profile = "ToolsGuiTextEditProfile";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 130";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "Detail Texture Format:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiPopUpMenuCtrl() {
|
||||
internalName = "detailTextureFormatPopUpMenu";
|
||||
profile = "ToolsGuiPopUpMenuProfile";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 160";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "Macro Texture Size:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiTextEditCtrl() {
|
||||
internalName = "macroTextureSizeTextEdit";
|
||||
profile = "ToolsGuiTextEditProfile";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 190";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "Macro Texture Format:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiPopUpMenuCtrl() {
|
||||
internalName = "macroTextureFormatPopUpMenu";
|
||||
profile = "ToolsGuiPopUpMenuProfile";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 220";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "Normal Texture Size:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiTextEditCtrl() {
|
||||
internalName = "normalTextureSizeTextEdit";
|
||||
profile = "ToolsGuiTextEditProfile";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 250";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "Normal Texture Format:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiPopUpMenuCtrl() {
|
||||
internalName = "normalTextureFormatPopUpMenu";
|
||||
profile = "ToolsGuiPopUpMenuProfile";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.apply();";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 280";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "ORM Texture Size:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiTextEditCtrl() {
|
||||
internalName = "ormTextureSizeTextEdit";
|
||||
profile = "ToolsGuiTextEditProfile";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 310";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 20";
|
||||
|
||||
new GuiTextCtrl() {
|
||||
text = "ORM Texture Format:";
|
||||
profile = "ToolsGuiTextProfile";
|
||||
|
||||
position = "0 0";
|
||||
extent = "120 20";
|
||||
};
|
||||
|
||||
new GuiPopUpMenuCtrl() {
|
||||
internalName = "ormTextureFormatPopUpMenu";
|
||||
profile = "ToolsGuiPopUpMenuProfile";
|
||||
|
||||
position = "130 0";
|
||||
extent = "170 20";
|
||||
};
|
||||
};
|
||||
|
||||
new GuiControl() {
|
||||
position = "20 350";
|
||||
profile = "ToolsGuiDefaultProfile";
|
||||
extent = "300 30";
|
||||
|
||||
new GuiButtonCtrl() {
|
||||
text = "Apply & Save";
|
||||
profile = "ToolsGuiButtonProfile";
|
||||
position = "0 0";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.applyAndSave();";
|
||||
|
||||
extent = "145 30";
|
||||
};
|
||||
|
||||
new GuiButtonCtrl() {
|
||||
text = "Cancel";
|
||||
profile = "ToolsGuiButtonProfile";
|
||||
position = "155 0";
|
||||
|
||||
command = "TerrainTextureSettingsDlg.cancel();";
|
||||
|
||||
extent = "145 30";
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
//--- OBJECT WRITE END ---
|
||||
|
|
@ -119,7 +119,8 @@ function EditorGui::init(%this)
|
|||
}
|
||||
|
||||
exec("~/worldEditor/gui/guiTerrainMaterialDlg.ed.gui");
|
||||
exec("~/worldEditor/gui/TerrainBrushSoftnessCurveDlg.ed.gui");
|
||||
exec("~/worldEditor/gui/TerrainBrushSoftnessCurveDlg.ed.gui");
|
||||
exec("~/worldEditor/gui/guiTerrainTextureSettingsDlg.ed.gui");
|
||||
}
|
||||
if ( !isObject( %this-->TerrainPainterToolbar) )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -443,6 +443,14 @@ function TerrainMaterialDlg::setActiveMaterial( %this, %mat )
|
|||
%this-->detDistanceCtrl.setText( %mat.detailDistance );
|
||||
%this-->sideProjectionCtrl.setValue( %mat.useSideProjection );
|
||||
%this-->parallaxScaleCtrl.setText( %mat.parallaxScale );
|
||||
|
||||
%blendHeightBase = mFloor(%mat.blendHeightBase * 1000)/1000;
|
||||
%this-->blendHeightBaseTextEditCtrl.setText( %blendHeightBase );
|
||||
%this-->blendHeightBaseSliderCtrl.setValue( %mat.blendHeightBase );
|
||||
|
||||
%blendHeightContrast = mFloor(%mat.blendHeightContrast * 1000)/1000;
|
||||
%this-->blendHeightContrastTextEditCtrl.setText( %blendHeightContrast );
|
||||
%this-->blendHeightContrastSliderCtrl.setValue( %mat.blendHeightContrast );
|
||||
|
||||
%this-->macroSizeCtrl.setText( %mat.macroSize );
|
||||
%this-->macroStrengthCtrl.setText( %mat.macroStrength );
|
||||
|
|
@ -504,6 +512,8 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
|
|||
%detailDistance = %this-->detDistanceCtrl.getText();
|
||||
%useSideProjection = %this-->sideProjectionCtrl.getValue();
|
||||
%parallaxScale = %this-->parallaxScaleCtrl.getText();
|
||||
%blendHeightBase = %this-->blendHeightBaseTextEditCtrl.getText();
|
||||
%blendHeightContrast = %this-->blendHeightContrastTextEditCtrl.getText();
|
||||
|
||||
%macroSize = %this-->macroSizeCtrl.getText();
|
||||
%macroStrength = %this-->macroStrengthCtrl.getText();
|
||||
|
|
@ -529,11 +539,13 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
|
|||
%mat.macroSize == %macroSize &&
|
||||
%mat.macroStrength == %macroStrength &&
|
||||
%mat.macroDistance == %macroDistance &&
|
||||
%mat.parallaxScale == %parallaxScale &&
|
||||
%mat.parallaxScale == %parallaxScale &&
|
||||
%mat.blendHeightBase == %blendHeightBase &&
|
||||
%mat.blendHeightContrast == %blendHeightContrast &&
|
||||
%mat.isSRGB == %isSRGB &&
|
||||
%mat.invertRoughness == %invertRoughness)
|
||||
%mat.invertRoughness == %invertRoughness && false)
|
||||
return;
|
||||
|
||||
|
||||
// Make sure the material name is unique.
|
||||
|
||||
if( %mat.internalName !$= %newName )
|
||||
|
|
@ -567,6 +579,8 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
|
|||
%mat.macroDistance = %macroDistance;
|
||||
%mat.useSideProjection = %useSideProjection;
|
||||
%mat.parallaxScale = %parallaxScale;
|
||||
%mat.blendHeightBase = %blendHeightBase;
|
||||
%mat.blendHeightContrast = %blendHeightContrast;
|
||||
%mat.isSRGB = %isSRGB;
|
||||
%mat.invertRoughness = %invertRoughness;
|
||||
|
||||
|
|
@ -619,6 +633,8 @@ function TerrainMaterialDlg::snapshotMaterials( %this )
|
|||
macroDistance = %mat.macroDistance;
|
||||
useSideProjection = %mat.useSideProjection;
|
||||
parallaxScale = %mat.parallaxScale;
|
||||
blendHeightBase = %mat.blendHeightBase;
|
||||
blendHeightContrast = %mat.blendHeightContrast;
|
||||
isSRGB = %mat.isSRGB;
|
||||
invertRoughness = %mat.invertRoughness;
|
||||
};
|
||||
|
|
@ -656,6 +672,8 @@ function TerrainMaterialDlg::restoreMaterials( %this )
|
|||
%mat.macroDistance = %obj.macroDistance;
|
||||
%mat.useSideProjection = %obj.useSideProjection;
|
||||
%mat.parallaxScale = %obj.parallaxScale;
|
||||
%mat.blendHeightBase = %obj.blendHeightBase;
|
||||
%mat.blendHeightContrast = %obj.blendHeightContrast;
|
||||
%mat.isSRGB = %obj.isSRGB;
|
||||
%mat.invertRoughness = %obj.invertRoughness;
|
||||
}
|
||||
|
|
@ -693,3 +711,31 @@ function TerrainMaterialDlg::_selectTextureFileDialog( %this, %defaultFileName )
|
|||
|
||||
return %file;
|
||||
}
|
||||
|
||||
function TerrainMaterialDlgBlendHeightBaseSlider::onMouseDragged(%this)
|
||||
{
|
||||
%value = mFloor(%this.value * 1000)/1000;
|
||||
TerrainMaterialDlgBlendHeightBaseTextEdit.setText(%value);
|
||||
TerrainMaterialDlg.activeMat.blendHeightBase = %this.value;
|
||||
|
||||
}
|
||||
|
||||
function TerrainMaterialDlgBlendHeightBaseTextEdit::onValidate(%this)
|
||||
{
|
||||
TerrainMaterialDlgBlendHeightBaseSlider.setValue(%this.getText());
|
||||
TerrainMaterialDlg.activeMat.blendHeightBase = %this.getText();
|
||||
}
|
||||
|
||||
function TerrainMaterialDlgBlendHeightContrastSlider::onMouseDragged(%this)
|
||||
{
|
||||
%value = mFloor(%this.value * 1000)/1000;
|
||||
TerrainMaterialDlgBlendHeightContrastTextEdit.setText(%value);
|
||||
TerrainMaterialDlg.activeMat.blendHeightContrast = %this.value;
|
||||
|
||||
}
|
||||
|
||||
function TerrainMaterialDlgBlendHeightContrastTextEdit::onValidate(%this)
|
||||
{
|
||||
TerrainMaterialDlgBlendHeightContrastSlider.setValue(%this.getText());
|
||||
TerrainMaterialDlg.activeMat.blendHeightContrast = %this.getText();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,158 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
$TerrainTextureSettingsDlg::TerrainTextureFormat =
|
||||
"R8G8B8 10" TAB
|
||||
"R8G8B8_SRGB 11" TAB
|
||||
"R8G8B8A8 12" TAB
|
||||
"R8G8B8A8_SRGB 15" TAB
|
||||
"BC5 33";
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
function TerrainTextureSettingsDlg::show( %this )
|
||||
{
|
||||
Canvas.pushDialog( %this );
|
||||
}
|
||||
|
||||
function TerrainTextureSettingsDlg::onWake( %this ) {
|
||||
%this-->lerpBlendCheckBox.setStateOn(ProjectSettings.value("Terrain/LerpBlend"));
|
||||
%this-->blendDepthSlider.setValue(ProjectSettings.value("Terrain/BlendDepth"));
|
||||
|
||||
%this-->detailTextureFormatPopUpMenu.clear();
|
||||
%this-->macroTextureFormatPopUpMenu.clear();
|
||||
%this-->normalTextureFormatPopUpMenu.clear();
|
||||
%this-->ormTextureFormatPopUpMenu.clear();
|
||||
|
||||
for(%i = 0; %i < getFieldCount($TerrainTextureSettingsDlg::TerrainTextureFormat); %i++) {
|
||||
%field = getField($TerrainTextureSettingsDlg::TerrainTextureFormat, %i);
|
||||
|
||||
%this-->detailTextureFormatPopUpMenu.add(getWord(%field, 0), getWord(%field, 1));
|
||||
%this-->macroTextureFormatPopUpMenu.add(getWord(%field, 0), getWord(%field, 1));
|
||||
%this-->normalTextureFormatPopUpMenu.add(getWord(%field, 0), getWord(%field, 1));
|
||||
%this-->ormTextureFormatPopUpMenu.add(getWord(%field, 0), getWord(%field, 1));
|
||||
}
|
||||
|
||||
%this-->detailTextureFormatPopUpMenu.setSelected(ProjectSettings.value("Terrain/DetailTextureFormat", 12), false);
|
||||
%this-->macroTextureFormatPopUpMenu.setSelected(ProjectSettings.value("Terrain/MacroTextureFormat", 12), false);
|
||||
%this-->normalTextureFormatPopUpMenu.setSelected(ProjectSettings.value("Terrain/NormalTextureFormat", 12), false);
|
||||
%this-->ormTextureFormatPopUpMenu.setSelected(ProjectSettings.value("Terrain/OrmTextureFormat", 12), false);
|
||||
|
||||
%this-->detailTextureSizeTextEdit.setText(ProjectSettings.value("Terrain/DetailTextureSize"));
|
||||
%this-->macroTextureSizeTextEdit.setText(ProjectSettings.value("Terrain/MacroTextureSize"));
|
||||
%this-->normalTextureSizeTextEdit.setText(ProjectSettings.value("Terrain/NormalTextureSize"));
|
||||
%this-->ormTextureSizeTextEdit.setText(ProjectSettings.value("Terrain/OrmTextureSize"));
|
||||
}
|
||||
|
||||
function TerrainTextureSettingsDlg::updateBlendDepth( %this ) {
|
||||
$Terrain::BlendDepth = %this-->blendDepthSlider.getValue();
|
||||
}
|
||||
|
||||
function TerrainTextureSettingsDlg::apply( %this ) {
|
||||
$Terrain::LerpBlend = %this-->lerpBlendCheckBox.isStateOn();
|
||||
$Terrain::BlendDepth = %this-->blendDepthSlider.getValue();
|
||||
|
||||
$Terrain::DetailTextureFormat = %this-->detailTextureFormatPopUpMenu.getSelected();
|
||||
$Terrain::MacroTextureFormat = %this-->macroTextureFormatPopUpMenu.getSelected();
|
||||
$Terrain::NormalTextureFormat = %this-->normalTextureFormatPopUpMenu.getSelected();
|
||||
$Terrain::OrmTextureFormat = %this-->ormTextureFormatPopUpMenu.getSelected();
|
||||
|
||||
if (%this-->detailTextureSizeTextEdit.getText() $= "" || mIsPow2(%this-->detailTextureSizeTextEdit.getText())) {
|
||||
$Terrain::DetailTextureSize = %this-->detailTextureSizeTextEdit.getText();
|
||||
}
|
||||
if (%this-->macroTextureSizeTextEdit.getText() $= "" || mIsPow2(%this-->macroTextureSizeTextEdit.getText())) {
|
||||
$Terrain::MacroTextureSize = %this-->macroTextureSizeTextEdit.getText();
|
||||
}
|
||||
if (%this-->normalTextureSizeTextEdit.getText() $= "" || mIsPow2(%this-->normalTextureSizeTextEdit.getText())) {
|
||||
$Terrain::NormalTextureSize = %this-->normalTextureSizeTextEdit.getText();
|
||||
}
|
||||
if (%this-->ormTextureSizeTextEdit.getText() $= "" || mIsPow2(%this-->ormTextureSizeTextEdit.getText())) {
|
||||
$Terrain::OrmTextureSize = %this-->ormTextureSizeTextEdit.getText();
|
||||
}
|
||||
|
||||
ETerrainEditor.getActiveTerrain().getClientObject().setMaterialsDirty();
|
||||
}
|
||||
|
||||
|
||||
function TerrainTextureSettingsDlg::validate( %this ) {
|
||||
if (%this-->detailTextureSizeTextEdit.getText() !$= "" && !mIsPow2(%this-->detailTextureSizeTextEdit.getText())) {
|
||||
toolsMessageBoxOK("Detail Texture Error!", "Detail texture resolution must be a power of 2");
|
||||
return false;
|
||||
}
|
||||
if (%this-->macroTextureSizeTextEdit.getText() !$= "" && !mIsPow2(%this-->macroTextureSizeTextEdit.getText())) {
|
||||
toolsMessageBoxOK("Macro Texture Error!", "Macro texture resolution must be a power of 2");
|
||||
return false;
|
||||
}
|
||||
if (%this-->normalTextureSizeTextEdit.getText() !$= "" && !mIsPow2(%this-->normalTextureSizeTextEdit.getText())) {
|
||||
toolsMessageBoxOK("Normal Texture Error!", "Normal texture resolution must be a power of 2");
|
||||
return false;
|
||||
}
|
||||
if (%this-->ormTextureSizeTextEdit.getText() !$= "" && !mIsPow2(%this-->ormTextureSizeTextEdit.getText())) {
|
||||
toolsMessageBoxOK("ORM Texture Error!", "ORM texture resolution must be a power of 2");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
function TerrainTextureSettingsDlg::cancel( %this ) {
|
||||
$Terrain::LerpBlend = ProjectSettings.value("Terrain/LerpBlend");
|
||||
$Terrain::BlendDepth = ProjectSettings.value("Terrain/BlendDepth");
|
||||
|
||||
$Terrain::DetailTextureFormat = ProjectSettings.value("Terrain/DetailTextureFormat");
|
||||
$Terrain::MacroTextureFormat = ProjectSettings.value("Terrain/MacroTextureFormat");
|
||||
$Terrain::NormalTextureFormat = ProjectSettings.value("Terrain/NormalTextureFormat");
|
||||
$Terrain::OrmTextureFormat = ProjectSettings.value("Terrain/OrmTextureFormat");
|
||||
|
||||
$Terrain::DetailTextureSize = ProjectSettings.value("Terrain/DetailTextureSize");
|
||||
$Terrain::MacroTextureSize = ProjectSettings.value("Terrain/MacroTextureSize");
|
||||
$Terrain::NormalTextureSize = ProjectSettings.value("Terrain/NormalTextureSize");
|
||||
$Terrain::OrmTextureSize = ProjectSettings.value("Terrain/OrmTextureSize");
|
||||
|
||||
ETerrainEditor.getActiveTerrain().getClientObject().setMaterialsDirty();
|
||||
Canvas.popDialog(%this);
|
||||
}
|
||||
|
||||
function TerrainTextureSettingsDlg::applyAndSave( %this ) {
|
||||
if (!%this.validate()) {
|
||||
return;
|
||||
}
|
||||
%this.apply();
|
||||
|
||||
ProjectSettings.setValue("Terrain/LerpBlend", $Terrain::LerpBlend);
|
||||
ProjectSettings.setValue("Terrain/BlendDepth", $Terrain::BlendDepth);
|
||||
|
||||
ProjectSettings.setValue("Terrain/DetailTextureFormat", $Terrain::DetailTextureFormat);
|
||||
ProjectSettings.setValue("Terrain/MacroTextureFormat", $Terrain::MacroTextureFormat);
|
||||
ProjectSettings.setValue("Terrain/NormalTextureFormat", $Terrain::NormalTextureFormat);
|
||||
ProjectSettings.setValue("Terrain/OrmTextureFormat", $Terrain::OrmTextureFormat);
|
||||
|
||||
ProjectSettings.setValue("Terrain/DetailTextureSize", $Terrain::DetailTextureSize);
|
||||
ProjectSettings.setValue("Terrain/MacroTextureSize", $Terrain::MacroTextureSize);
|
||||
ProjectSettings.setValue("Terrain/NormalTextureSize", $Terrain::NormalTextureSize);
|
||||
ProjectSettings.setValue("Terrain/OrmTextureSize", $Terrain::OrmTextureSize);
|
||||
|
||||
ProjectSettings.write();
|
||||
|
||||
Canvas.popDialog(%this);
|
||||
}
|
||||
Loading…
Reference in a new issue