bool VolumetricFogRTManager::Init()
{
if (mIsInitialized)
{
Con::errorf("VolumetricFogRTManager allready initialized!!");
return true;
}
GuiCanvas* cv = dynamic_cast<GuiCanvas*>(Sim::findObject("Canvas"));
if (cv == NULL)
{
Con::errorf("VolumetricFogRTManager::Init() - Canvas not found!!");
return false;
}
mPlatformWindow = cv->getPlatformWindow();
mPlatformWindow->getScreenResChangeSignal().notify(this,&VolumetricFogRTManager::ResizeRT);
if (mTargetScale < 1 || GFX->getAdapterType() == Direct3D11)
mTargetScale = 1;
mWidth = mFloor(mPlatformWindow->getClientExtent().x / mTargetScale);
mHeight = mFloor(mPlatformWindow->getClientExtent().y / mTargetScale);
mDepthBuffer = GFXTexHandle(mWidth, mHeight, GFXFormatR32F,
&GFXRenderTargetProfile, avar("%s() - mDepthBuffer (line %d)", __FUNCTION__, __LINE__));
if (!mDepthBuffer.isValid())
{
Con::errorf("VolumetricFogRTManager Fatal Error: Unable to create Depthbuffer");
return false;
}
if (!mDepthTarget.registerWithName("volfogdepth"))
{
Con::errorf("VolumetricFogRTManager Fatal Error : Unable to register Depthbuffer");
return false;
}
mDepthTarget.setTexture(mDepthBuffer);
mFrontBuffer = GFXTexHandle(mWidth, mHeight, GFXFormatR32F,
&GFXRenderTargetProfile, avar("%s() - mFrontBuffer (line %d)", __FUNCTION__, __LINE__));
if (!mFrontBuffer.isValid())
{
Con::errorf("VolumetricFogRTManager Fatal Error: Unable to create front buffer");
return false;
}
if (!mFrontTarget.registerWithName("volfogfront"))
{
Con::errorf("VolumetricFogRTManager Fatal Error : Unable to register Frontbuffer");
return false;
}
mFrontTarget.setTexture(mFrontBuffer);
Con::setVariable("$VolumetricFog::density", "0.0");
mIsInitialized = true;
return true;
}
U32 GuiImageList::Insert( const char* texturePath, GFXTextureProfile *Type )
{
TextureEntry *t = new TextureEntry;
if ( ! t ) return -1;
t->TexturePath = StringTable->insert(texturePath);
if ( *t->TexturePath )
{
t->Handle = GFXTexHandle(t->TexturePath, Type, avar("%s() - t->Handle (line %d)", __FUNCTION__, __LINE__));
if ( t->Handle )
{
t->id = ++mUniqueId;
mTextures.push_back( t );
return t->id;
}
}
// Free Texture Entry.
delete t;
// Return Failure.
return -1;
}
void TerrainBlock::_updateMaterials()
{
mBaseTextures.setSize( mFile->mMaterials.size() );
mMaxDetailDistance = 0.0f;
for ( U32 i=0; i < mFile->mMaterials.size(); i++ )
{
TerrainMaterial *mat = mFile->mMaterials[i];
if( !mat->getDiffuseMap().isEmpty() )
mBaseTextures[i].set( mat->getDiffuseMap(),
&GFXDefaultStaticDiffuseProfile,
"TerrainBlock::_updateMaterials() - DiffuseMap" );
else
mBaseTextures[ i ] = GFXTexHandle();
// Find the maximum detail distance.
if ( mat->getDetailMap().isNotEmpty() &&
mat->getDetailDistance() > mMaxDetailDistance )
mMaxDetailDistance = mat->getDetailDistance();
if ( mat->getMacroMap().isNotEmpty() &&
mat->getMacroDistance() > mMaxDetailDistance )
mMaxDetailDistance = mat->getMacroDistance();
}
if ( mCell )
mCell->deleteMaterials();
}
bool ParticleData::reload(char errorBuffer[256])
{
bool error = false;
if (textureName && textureName[0])
{
textureHandle = GFXTexHandle(textureName, &GFXDefaultStaticDiffuseProfile, avar("%s() - textureHandle (line %d)", __FUNCTION__, __LINE__));
if (!textureHandle)
{
dSprintf(errorBuffer, 256, "Missing particle texture: %s", textureName);
error = true;
}
}
/*
numFrames = 0;
for( int i=0; i<PDC_MAX_TEX; i++ )
{
if( textureNameList[i] && textureNameList[i][0] )
{
textureList[i] = TextureHandle( textureNameList[i], MeshTexture );
if (!textureList[i].getName())
{
dSprintf(errorBuffer, 256, "Missing particle texture: %s", textureNameList[i]);
error = true;
}
numFrames++;
}
}
*/
return !error;
}
void afxZodiacData::unpackData(BitStream* stream)
{
Parent::unpackData(stream);
txr_name = stream->readSTString();
txr = GFXTexHandle();
stream->read(&radius_xy);
stream->read(&vert_range.x);
stream->read(&vert_range.y);
stream->read(&grade_range.x);
stream->read(&grade_range.y);
stream->read(&start_ang);
stream->read(&ang_per_sec);
stream->read(&grow_in_time);
stream->read(&shrink_out_time);
stream->read(&growth_rate);
stream->read(&color);
stream->read(&zflags);
stream->read(&altitude_max);
stream->read(&altitude_falloff);
altitude_shrinks = stream->readFlag();
altitude_fades = stream->readFlag();
stream->read(&distance_max);
stream->read(&distance_falloff);
expand_zflags();
}
bool LightningData::preload(bool server, String &errorStr)
{
if (Parent::preload(server, errorStr) == false)
return false;
dQsort(thunderSounds, MaxThunders, sizeof(SFXTrack*), cmpSounds);
for (numThunders = 0; numThunders < MaxThunders && thunderSounds[numThunders] != NULL; numThunders++) {
//
}
if (server == false)
{
String sfxErrorStr;
for (U32 i = 0; i < MaxThunders; i++) {
if( !sfxResolve( &thunderSounds[ i ], sfxErrorStr ) )
Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Invalid packet: %s", sfxErrorStr.c_str());
}
if( !sfxResolve( &strikeSound, sfxErrorStr ) )
Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Invalid packet: %s", sfxErrorStr.c_str());
for (U32 i = 0; i < MaxTextures; i++)
{
if (strikeTextureNames[i][0])
strikeTextures[i] = GFXTexHandle(strikeTextureNames[i], &GFXDefaultStaticDiffuseProfile, avar("%s() - strikeTextures[%d] (line %d)", __FUNCTION__, i, __LINE__));
}
}
return true;
}
bool VolumetricFogRTManager::Resize()
{
if (mTargetScale < 1 || GFX->getAdapterType() == Direct3D11)
mTargetScale = 1;
mWidth = mFloor(mPlatformWindow->getClientExtent().x / mTargetScale);
mHeight = mFloor(mPlatformWindow->getClientExtent().y / mTargetScale);
if (mWidth < 16 || mHeight < 16)
return false;
if (mFrontTarget.isRegistered())
mFrontTarget.setTexture(NULL);
if (mDepthTarget.isRegistered())
mDepthTarget.setTexture(NULL);
if (mDepthBuffer.isValid())
mDepthBuffer->kill();
if (mFrontBuffer.isValid())
mFrontBuffer->kill();
mFrontBuffer = GFXTexHandle(mWidth, mHeight, GFXFormatR32F,
&GFXRenderTargetProfile, avar("%s() - mFrontBuffer (line %d)", __FUNCTION__, __LINE__));
if (!mFrontBuffer.isValid())
{
Con::errorf("VolumetricFogRTManager::Resize() Fatal Error: Unable to create front buffer");
return false;
}
mFrontTarget.setTexture(mFrontBuffer);
mDepthBuffer = GFXTexHandle(mWidth, mHeight, GFXFormatR32F,
&GFXRenderTargetProfile, avar("%s() - mDepthBuffer (line %d)", __FUNCTION__, __LINE__));
if (!mDepthBuffer.isValid())
{
Con::errorf("VolumetricFogRTManager::Resize() Fatal Error: Unable to create Depthbuffer");
return false;
}
mDepthTarget.setTexture(mDepthBuffer);
return true;
}
//--------------------------------------------------------------------------
// Preload data - load resources
//--------------------------------------------------------------------------
bool SplashData::preload(bool server, String &errorStr)
{
if (Parent::preload(server, errorStr) == false)
return false;
if (!server)
{
S32 i;
for( i=0; i<NUM_EMITTERS; i++ )
{
if( !emitterList[i] && emitterIDList[i] != 0 )
{
if( Sim::findObject( emitterIDList[i], emitterList[i] ) == false)
{
Con::errorf( ConsoleLogEntry::General, "SplashData::onAdd: Invalid packet, bad datablockId(particle emitter): 0x%x", emitterIDList[i] );
}
}
}
for( i=0; i<NUM_TEX; i++ )
{
if (textureName[i] && textureName[i][0])
{
textureHandle[i] = GFXTexHandle(textureName[i], &GFXDefaultStaticDiffuseProfile, avar("%s() - textureHandle[%d] (line %d)", __FUNCTION__, i, __LINE__) );
}
}
}
if( !explosion && explosionId != 0 )
{
if( !Sim::findObject(explosionId, explosion) )
{
Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Invalid packet, bad datablockId(explosion): %d", explosionId);
}
}
return true;
}
GFXTexHandle ReflectionManager::allocRenderTarget( const Point2I &size )
{
return GFXTexHandle( size.x, size.y, mReflectFormat,
&ReflectRenderTargetProfile,
avar("%s() - mReflectTex (line %d)", __FUNCTION__, __LINE__) );
}
//-----------------------------------------------------------------------------
// preload
//-----------------------------------------------------------------------------
bool ParticleData::preload(bool server, String &errorStr)
{
if (Parent::preload(server, errorStr) == false)
return false;
bool error = false;
if(!server)
{
// Here we attempt to load the particle's texture if specified. An undefined
// texture is *not* an error since the emitter may provide one.
if (textureName && textureName[0])
{
textureHandle = GFXTexHandle(textureName, &GFXDefaultStaticDiffuseProfile, avar("%s() - textureHandle (line %d)", __FUNCTION__, __LINE__));
if (!textureHandle)
{
errorStr = String::ToString("Missing particle texture: %s", textureName);
error = true;
}
}
if (animateTexture)
{
// Here we parse animTexFramesString into byte-size frame numbers in animTexFrames.
// Each frame token must be separated by whitespace.
// A frame token must be a positive integer frame number or a range of frame numbers
// separated with a '-'.
// The range separator, '-', cannot have any whitspace around it.
// Ranges can be specified to move through the frames in reverse as well as forward.
// Frame numbers exceeding the number of tiles will wrap.
// example:
// "0-16 20 19 18 17 31-21"
S32 n_tiles = animTexTiling.x * animTexTiling.y;
AssertFatal(n_tiles > 0 && n_tiles <= 256, "Error, bad animTexTiling setting." );
animTexFrames.clear();
char* tokCopy = new char[dStrlen(animTexFramesString) + 1];
dStrcpy(tokCopy, animTexFramesString);
char* currTok = dStrtok(tokCopy, " \t");
while (currTok != NULL)
{
char* minus = dStrchr(currTok, '-');
if (minus)
{
// add a range of frames
*minus = '\0';
S32 range_a = dAtoi(currTok);
S32 range_b = dAtoi(minus+1);
if (range_b < range_a)
{
// reverse frame range
for (S32 i = range_a; i >= range_b; i--)
animTexFrames.push_back((U8)(i % n_tiles));
}
else
{
// forward frame range
for (S32 i = range_a; i <= range_b; i++)
animTexFrames.push_back((U8)(i % n_tiles));
}
}
else
{
// add one frame
animTexFrames.push_back((U8)(dAtoi(currTok) % n_tiles));
}
currTok = dStrtok(NULL, " \t");
}
// Here we pre-calculate the UVs for each frame tile, which are
// tiled inside the UV region specified by texCoords. Since the
// UVs are calculated using bilinear interpolation, the texCoords
// region does *not* have to be an axis-aligned rectangle.
if (animTexUVs)
delete [] animTexUVs;
animTexUVs = new Point2F[(animTexTiling.x+1)*(animTexTiling.y+1)];
// interpolate points on the left and right edge of the uv quadrangle
Point2F lf_pt = texCoords[0];
Point2F rt_pt = texCoords[3];
// per-row delta for left and right interpolated points
Point2F lf_d = (texCoords[1] - texCoords[0])/(F32)animTexTiling.y;
Point2F rt_d = (texCoords[2] - texCoords[3])/(F32)animTexTiling.y;
S32 idx = 0;
for (S32 yy = 0; yy <= animTexTiling.y; yy++)
{
Point2F p = lf_pt;
Point2F dp = (rt_pt - lf_pt)/(F32)animTexTiling.x;
for (S32 xx = 0; xx <= animTexTiling.x; xx++)
{
animTexUVs[idx++] = p;
p += dp;
}
lf_pt += lf_d;
rt_pt += rt_d;
}
// cleanup
delete [] tokCopy;
numFrames = animTexFrames.size();
}
}
return !error;
}
void ClipMapBlenderCache::initialize( ClipMap *cm )
{
mOwningClipMap = cm;
mClipMapSize = cm->mClipMapSize;
mLightmapScratchTextures.push_back(GFXTexHandle( mClipMapSize, mClipMapSize, GFXFormatR8G8B8X8, &ClipMapTextureProfile, avar("%s() - mLightmapScratchTextures (line %d)", __FUNCTION__, __LINE__), 1 ));
if (GFX->getPixelShaderVersion() == 0.0f)
{
mFixedfunction = true;
// Fixed function stateblock
GFXStateBlockDesc sbFF;
sbFF.samplersDefined = true;
sbFF.samplers[0] = GFXSamplerStateDesc::getClampLinear();
sbFF.samplers[0].textureColorOp = GFXTOPSelectARG1;
sbFF.samplers[0].colorArg1 = GFXTATexture;
sbFF.samplers[1] = GFXSamplerStateDesc::getWrapLinear();
mFFBaseLayerSB = GFX->createStateBlock(sbFF);
sbFF.setBlend(true, GFXBlendOne, GFXBlendOne);
mFFAdditionalLayersSB = GFX->createStateBlock(sbFF);
sbFF.setBlend(true, GFXBlendDestColor, GFXBlendSrcColor);
sbFF.samplers[1].textureColorOp = GFXTOPDisable;
mFFLightmapSB = GFX->createStateBlock(sbFF);
}
else
{
mFixedfunction = false;
// Find and init shaders.
ShaderData *sd = NULL;
if(GFX->getPixelShaderVersion() >= 2.0f)
{
if(!Sim::findObject( ( mLM1 ? "AtlasBlender20ShaderLM1" : "AtlasBlender20Shader" ), sd) || (sd->mShader == NULL))
{
Con::errorf("ClipMapBlenderCache::initialize - "
"Couldn't find shader 'AtlasBlender20Shader'! Terrain will not blend properly on SM2.0 cards!");
}
else
{
mOnePass = sd->mShader;
if (mOnePass)
mShaderConsts = mOnePass->allocConstBuffer();
if (mShaderConsts)
sd->mapSamplerNames(mShaderConsts);
}
}
else
{
if(!Sim::findObject( ( mLM1 ? "AtlasBlender11AShaderLM1" : "AtlasBlendeer11AShader" ), sd) || (sd->mShader == NULL))
{
Con::errorf("ClipMapBlenderCache::initialize - "
"Couldn't find shader 'AtlasBlender11AShader'! Terrain will not blend properly on SM1.0 cards!");
}
else
{
mTwoPass[0] = sd->mShader;
if (mTwoPass[0])
mShaderConsts = mTwoPass[0]->allocConstBuffer();
if (mShaderConsts)
sd->mapSamplerNames(mShaderConsts);
}
if(!Sim::findObject( ( mLM1 ? "AtlasBlender11BShaderLM1" : "AtlasBlender11BShader" ), sd) || (sd->mShader == NULL))
{
Con::errorf("ClipMapBlenderCache::initialize - "
"Couldn't find shader 'AtlasBlender11BShader'! Terrain will not blend properly on SM1.0 cards!");
}
else
{
mTwoPass[1] = sd->mShader;
}
}
if (mShaderConsts)
{
mModelViewProjSC = mShaderConsts->getShader()->getShaderConstHandle(ShaderGenVars::modelview);
mOpacityMapSC = mShaderConsts->getShader()->getShaderConstHandle("$opacity");
mLightMapSC = mShaderConsts->getShader()->getShaderConstHandle("$lightMap");
mTex1SC = mShaderConsts->getShader()->getShaderConstHandle("$tex1");
mTex2SC = mShaderConsts->getShader()->getShaderConstHandle("$tex2");
mTex3SC = mShaderConsts->getShader()->getShaderConstHandle("$tex3");
mTex4SC = mShaderConsts->getShader()->getShaderConstHandle("$tex4");
mSourceTexScalesSC = mShaderConsts->getShader()->getShaderConstHandle("$sourceTexScales");
}
// Init state blocks
GFXStateBlockDesc sbd;
sbd.setCullMode(GFXCullNone);
sbd.setZEnable(false);
sbd.zWriteEnable = false;
sbd.samplersDefined = true;
sbd.samplers[0] = GFXSamplerStateDesc::getClampLinear();
sbd.samplers[1] = GFXSamplerStateDesc::getClampLinear();
sbd.samplers[2] = GFXSamplerStateDesc::getWrapLinear();
sbd.samplers[3] = GFXSamplerStateDesc::getWrapLinear();
sbd.samplers[4] = GFXSamplerStateDesc::getWrapLinear();
sbd.samplers[5] = GFXSamplerStateDesc::getWrapLinear();
mOnePassSB = GFX->createStateBlock(sbd);
sbd.setBlend(true, GFXBlendOne, GFXBlendOne);
mTwoPassSB = GFX->createStateBlock(sbd);
}
createOpacityScratchTextures();
}
GFXTexHandle ProcessedMaterial::_createTexture( const char* filename, GFXTextureProfile *profile)
{
return GFXTexHandle( _getTexturePath(filename), profile, avar("%s() - NA (line %d)", __FUNCTION__, __LINE__) );
}
