void SkyBox::_initMaterial()
{
if ( mMatInstance )
SAFE_DELETE( mMatInstance );
if ( mMaterial )
mMatInstance = mMaterial->createMatInstance();
else
mMatInstance = MATMGR->createMatInstance( "WarningMaterial" );
// We want to disable culling and z write.
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
desc.setBlend( true );
desc.setZReadWrite( true, false );
mMatInstance->addStateBlockDesc( desc );
// Also disable lighting on the skybox material by default.
FeatureSet features = MATMGR->getDefaultFeatures();
features.removeFeature( MFT_RTLighting );
features.removeFeature( MFT_Visibility );
features.addFeature(MFT_SkyBox);
// Now initialize the material.
mMatInstance->init(features, getGFXVertexFormat<GFXVertexPNT>());
}
void ForestWindEmitter::_renderEmitterInfo( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat )
{
if ( overrideMat )
return;
GFXTransformSaver saver;
GFXDrawUtil *drawer = GFX->getDrawUtil();
AssertFatal( drawer, "Got NULL GFXDrawUtil!" );
const Point3F &pos = getPosition();
const VectorF &windVec = mWind->getDirection();
GFXStateBlockDesc desc;
desc.setBlend( true );
desc.setZReadWrite( true, false );
// Draw an arrow pointing
// in the wind direction.
drawer->drawArrow( desc, pos, pos + (windVec * mWindStrength), ColorI( 0, 0, 255, 255 ) );//Point3F( -235.214, 219.589, 34.0991 ), Point3F( -218.814, 244.731, 37.5587 ), ColorI( 255, 255, 0, 255 ) );//
drawer->drawArrow( desc, pos, pos + (mWind->getTarget() * mWindStrength ), ColorI( 255, 0, 0, 85 ) );
// Draw a 2D circle for the wind radius.
if ( isRadialEmitter() )
drawer->drawSphere( desc, mWindRadius, pos, ColorI( 255, 0, 0, 80 ) );
}
/// Creates the default state blocks for a list of render states
void ProcessedMaterial::_initRenderStateStateBlocks( RenderPassData *rpd )
{
GFXStateBlockDesc stateTranslucent;
GFXStateBlockDesc stateGlow;
GFXStateBlockDesc stateReflect;
GFXStateBlockDesc statePass;
_initStateBlockTemplates( stateTranslucent, stateGlow, stateReflect );
_initPassStateBlock( rpd, statePass );
// Ok, we've got our templates set up, let's combine them together based on state and
// create our state blocks.
for (U32 i = 0; i < RenderPassData::STATE_MAX; i++)
{
GFXStateBlockDesc stateFinal;
if (i & RenderPassData::STATE_REFLECT)
stateFinal.addDesc(stateReflect);
if (i & RenderPassData::STATE_TRANSLUCENT)
stateFinal.addDesc(stateTranslucent);
if (i & RenderPassData::STATE_GLOW)
stateFinal.addDesc(stateGlow);
stateFinal.addDesc(statePass);
if (i & RenderPassData::STATE_WIREFRAME)
stateFinal.fillMode = GFXFillWireframe;
GFXStateBlockRef sb = GFX->createStateBlock(stateFinal);
rpd->mRenderStates[i] = sb;
}
}
bool CloudLayer::onAdd()
{
if ( !Parent::onAdd() )
return false;
setGlobalBounds();
resetWorldBox();
addToScene();
if ( isClientObject() )
{
_initTexture();
_initBuffers();
// Find ShaderData
ShaderData *shaderData;
mShader = Sim::findObject( "CloudLayerShader", shaderData ) ?
shaderData->getShader() : NULL;
if ( !mShader )
{
Con::errorf( "CloudLayer::onAdd - could not find CloudLayerShader" );
return false;
}
// Create ShaderConstBuffer and Handles
mShaderConsts = mShader->allocConstBuffer();
mModelViewProjSC = mShader->getShaderConstHandle( "$modelView" );
mEyePosWorldSC = mShader->getShaderConstHandle( "$eyePosWorld" );
mSunVecSC = mShader->getShaderConstHandle( "$sunVec" );
mTexOffsetSC[0] = mShader->getShaderConstHandle( "$texOffset0" );
mTexOffsetSC[1] = mShader->getShaderConstHandle( "$texOffset1" );
mTexOffsetSC[2] = mShader->getShaderConstHandle( "$texOffset2" );
mTexScaleSC = mShader->getShaderConstHandle( "$texScale" );
mAmbientColorSC = mShader->getShaderConstHandle( "$ambientColor" );
mSunColorSC = mShader->getShaderConstHandle( "$sunColor" );
mCoverageSC = mShader->getShaderConstHandle( "$cloudCoverage" );
mExposureSC = mShader->getShaderConstHandle( "$cloudExposure" );
mBaseColorSC = mShader->getShaderConstHandle( "$cloudBaseColor" );
mNormalHeightMapSC = mShader->getShaderConstHandle( "$normalHeightMap" );
// Create StateBlocks
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
desc.setBlend( true );
desc.setZReadWrite( false, false );
desc.samplersDefined = true;
desc.samplers[0].addressModeU = GFXAddressWrap;
desc.samplers[0].addressModeV = GFXAddressWrap;
desc.samplers[0].addressModeW = GFXAddressWrap;
desc.samplers[0].magFilter = GFXTextureFilterLinear;
desc.samplers[0].minFilter = GFXTextureFilterLinear;
desc.samplers[0].mipFilter = GFXTextureFilterLinear;
desc.samplers[0].textureColorOp = GFXTOPModulate;
mStateblock = GFX->createStateBlock( desc );
}
return true;
}
void GuiGradientCtrl::onRender(Point2I offset, const RectI& updateRect)
{
if (mStateBlock.isNull())
{
GFXStateBlockDesc desc;
desc.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha);
desc.setZReadWrite(false);
desc.zWriteEnable = false;
desc.setCullMode(GFXCullNone);
mStateBlock = GFX->createStateBlock( desc );
}
RectI boundsRect(offset, getExtent());
renderColorBox(boundsRect);
if (mPositionChanged)
{
mPositionChanged = false;
// Now do onAction() if we are allowed
if (mActionOnMove)
onAction();
}
//render the children
renderChildControls( offset, updateRect);
}
void Trigger::renderObject( ObjectRenderInst *ri,
SceneRenderState *state,
BaseMatInstance *overrideMat )
{
if(overrideMat)
return;
GFXStateBlockDesc desc;
desc.setZReadWrite( true, false );
desc.setBlend( true );
// Trigger polyhedrons are set up with outward facing normals and CCW ordering
// so can't enable backface culling.
desc.setCullMode( GFXCullNone );
GFXTransformSaver saver;
MatrixF mat = getRenderTransform();
mat.scale( getScale() );
GFX->multWorld( mat );
GFXDrawUtil *drawer = GFX->getDrawUtil();
drawer->drawPolyhedron( desc, mTriggerPolyhedron, ColorI( 255, 192, 0, 45 ) );
// Render wireframe.
desc.setFillModeWireframe();
drawer->drawPolyhedron( desc, mTriggerPolyhedron, ColorI::BLACK );
}
void DecalRoad::_debugRender( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance* )
{
//if ( mStateBlock.isNull() )
// return;
GFX->enterDebugEvent( ColorI( 255, 0, 0 ), "DecalRoad_debugRender" );
GFXTransformSaver saver;
//GFX->setStateBlock( mStateBlock );
Point3F size(1,1,1);
ColorI color( 255, 0, 0, 255 );
GFXStateBlockDesc desc;
desc.setZReadWrite( true, false );
desc.setBlend( true );
desc.fillMode = GFXFillWireframe;
if ( smShowBatches )
{
for ( U32 i = 0; i < mBatches.size(); i++ )
{
const Box3F &box = mBatches[i].bounds;
GFX->getDrawUtil()->drawCube( desc, box, ColorI(255,100,100,255) );
}
}
//GFX->leaveDebugEvent();
}
void GuiColorPickerCtrl::onRender(Point2I offset, const RectI& updateRect)
{
if (mStateBlock.isNull())
{
GFXStateBlockDesc desc;
desc.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha);
desc.setZReadWrite(false);
desc.zWriteEnable = false;
desc.setCullMode(GFXCullNone);
mStateBlock = GFX->createStateBlock( desc );
}
RectI boundsRect(offset, getExtent());
renderColorBox(boundsRect);
if (mPositionChanged)
{
mPositionChanged = false;
Point2I extent = getRoot()->getExtent();
// If we are anything but a pallete, change the pick color
if (mDisplayMode != pPallet)
{
Point2I resolution = getRoot()->getExtent();
U32 buf_x = offset.x + mSelectorPos.x + 1;
U32 buf_y = ( extent.y - ( offset.y + mSelectorPos.y + 1 ) );
if(GFX->getAdapterType() != OpenGL)
buf_y = resolution.y - buf_y;
GFXTexHandle bb( resolution.x,
resolution.y,
GFXFormatR8G8B8A8, &GFXDefaultRenderTargetProfile, avar("%s() - bb (line %d)", __FUNCTION__, __LINE__) );
Point2I tmpPt( buf_x, buf_y );
GFXTarget *targ = GFX->getActiveRenderTarget();
targ->resolveTo( bb );
GBitmap bmp( bb.getWidth(), bb.getHeight() );
bb.copyToBmp( &bmp );
//bmp.writePNGDebug( "foo.png" );
ColorI tmp;
bmp.getColor( buf_x, buf_y, tmp );
mPickColor = (ColorF)tmp;
// Now do onAction() if we are allowed
if (mActionOnMove)
onAction();
}
}
//render the children
renderChildControls( offset, updateRect);
}
void Forest::_renderCellBounds( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat )
{
PROFILE_SCOPE( Forest_RenderCellBounds );
if ( overrideMat )
return;
GFXTransformSaver saver;
MatrixF projBias(true);
const Frustum frustum = GFX->getFrustum();
MathUtils::getZBiasProjectionMatrix( 0.001f, frustum, &projBias );
GFX->setProjectionMatrix( projBias );
VectorF extents;
Point3F pos;
// Get top level cells
Vector<ForestCell*> cellStack;
mData->getCells( &cellStack );
// Holds child cells we need to render as we encounter them.
Vector<ForestCell*> frontier;
GFXDrawUtil *drawer = GFX->getDrawUtil();
GFXStateBlockDesc desc;
desc.setZReadWrite( true, false );
desc.setBlend( true );
desc.setFillModeWireframe();
while ( !cellStack.empty() )
{
while ( !cellStack.empty() )
{
const ForestCell *cell = cellStack.last();
cellStack.pop_back();
Box3F box = cell->getBounds();
drawer->drawCube( desc, box, ColorI( 0, 255, 0 ) );
RectF rect = cell->getRect();
box.minExtents.set( rect.point.x, rect.point.y, box.minExtents.z );
box.maxExtents.set( rect.point.x + rect.extent.x, rect.point.y + rect.extent.y, box.minExtents.z );
drawer->drawCube( desc, box, ColorI::RED );
// If this cell has children, add them to the frontier.
if ( !cell->isLeaf() )
cell->getChildren( &frontier );
}
// Now the frontier becomes the cellStack and we empty the frontier.
cellStack = frontier;
frontier.clear();
}
}
void DebugDrawer::setupStateBlocks()
{
GFXStateBlockDesc d;
d.setCullMode(GFXCullNone);
mRenderZOnSB = GFX->createStateBlock(d);
d.setZReadWrite(false);
mRenderZOffSB = GFX->createStateBlock(d);
}
void TerrCell::renderBounds() const
{
ColorI color;
color.interpolate( ColorI::RED, ColorI::GREEN, (F32)mLevel / 3.0f );
GFXStateBlockDesc desc;
desc.setZReadWrite( true, false );
desc.fillMode = GFXFillWireframe;
GFX->getDrawUtil()->drawCube( desc, mBounds, color );
}
void TSShapeInstance::renderDebugNodes()
{
GFXDrawUtil *drawUtil = GFX->getDrawUtil();
ColorI color( 255, 0, 0, 255 );
GFXStateBlockDesc desc;
desc.setBlend( false );
desc.setZReadWrite( false, false );
for ( U32 i = 0; i < mNodeTransforms.size(); i++ )
drawUtil->drawTransform( desc, mNodeTransforms[i], NULL, NULL );
}
void PxCapsulePlayer::renderDebug( ObjectRenderInst *ri, SceneState *state, BaseMatInstance *overrideMat )
{
Point3F center = pxCast<Point3F>( mCapsuleController->getDebugPosition() );
F32 radius = mCapsuleController->getRadius();
F32 height = mCapsuleController->getHeight();
GFXStateBlockDesc desc;
desc.setBlend( true );
desc.setZReadWrite( true, false );
GFX->getDrawUtil()->drawCapsule( desc, center, radius, height, ColorI(100,100,200,160) );
}
void GuiDecalEditorCtrl::renderScene(const RectI & updateRect)
{
PROFILE_SCOPE( GuiDecalEditorCtrl_renderScene );
GFXTransformSaver saver;
RectI bounds = getBounds();
ColorI hlColor(0,255,0,255);
ColorI regColor(255,0,0,255);
ColorI selColor(0,0,255,255);
ColorI color;
GFXDrawUtil *drawUtil = GFX->getDrawUtil();
GFXStateBlockDesc desc;
desc.setBlend( true );
desc.setZReadWrite( true, false );
// Draw 3D stuff here.
if ( mSELDecal )
{
mGizmo->renderGizmo( mLastCameraQuery.cameraMatrix, mLastCameraQuery.fov );
mSELEdgeVerts.clear();
if ( gDecalManager->clipDecal( mSELDecal, &mSELEdgeVerts ) )
_renderDecalEdge( mSELEdgeVerts, ColorI( 255, 255, 255, 255 ) );
const F32 &decalSize = mSELDecal->mSize;
Point3F boxSize( decalSize, decalSize, decalSize );
MatrixF worldMat( true );
mSELDecal->getWorldMatrix( &worldMat, true );
drawUtil->drawObjectBox( desc, boxSize, mSELDecal->mPosition, worldMat, ColorI( 255, 255, 255, 255 ) );
}
if ( mHLDecal )
{
mHLEdgeVerts.clear();
if ( gDecalManager->clipDecal( mHLDecal, &mHLEdgeVerts ) )
_renderDecalEdge( mHLEdgeVerts, ColorI( 255, 255, 255, 255 ) );
const F32 &decalSize = mHLDecal->mSize;
Point3F boxSize( decalSize, decalSize, decalSize );
MatrixF worldMat( true );
mHLDecal->getWorldMatrix( &worldMat, true );
drawUtil->drawObjectBox( desc, boxSize, mHLDecal->mPosition, worldMat, ColorI( 255, 255, 255, 255 ) );
}
}
bool BasicClouds::onAdd()
{
if ( !Parent::onAdd() )
return false;
setGlobalBounds();
resetWorldBox();
addToScene();
if ( isClientObject() )
{
_initTexture();
_initBuffers();
// Find ShaderData
ShaderData *shaderData;
mShader = Sim::findObject( "BasicCloudsShader", shaderData ) ? shaderData->getShader() : NULL;
if ( !mShader )
{
Con::errorf( "BasicClouds::onAdd - could not find BasicCloudsShader" );
return false;
}
// Create ShaderConstBuffer and Handles
mShaderConsts = mShader->allocConstBuffer();
mModelViewProjSC = mShader->getShaderConstHandle( "$modelView" );
mTimeSC = mShader->getShaderConstHandle( "$accumTime" );
mTexScaleSC = mShader->getShaderConstHandle( "$texScale" );
mTexDirectionSC = mShader->getShaderConstHandle( "$texDirection" );
mTexOffsetSC = mShader->getShaderConstHandle( "$texOffset" );
mDiffuseMapSC = mShader->getShaderConstHandle( "$diffuseMap" );
// Create StateBlocks
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
desc.setBlend( true );
desc.setZReadWrite( false, false );
desc.samplersDefined = true;
desc.samplers[0].addressModeU = GFXAddressWrap;
desc.samplers[0].addressModeV = GFXAddressWrap;
desc.samplers[0].addressModeW = GFXAddressWrap;
desc.samplers[0].magFilter = GFXTextureFilterLinear;
desc.samplers[0].minFilter = GFXTextureFilterLinear;
desc.samplers[0].mipFilter = GFXTextureFilterLinear;
desc.samplers[0].textureColorOp = GFXTOPModulate;
mStateblock = GFX->createStateBlock( desc );
}
return true;
}
void Lightning::renderObject(ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance* overrideMat)
{
if (overrideMat)
return;
if (mLightningSB.isNull())
{
GFXStateBlockDesc desc;
desc.setBlend( true, GFXBlendSrcAlpha, GFXBlendOne);
desc.setCullMode(GFXCullNone);
desc.zWriteEnable = false;
desc.samplersDefined = true;
desc.samplers[0].magFilter = GFXTextureFilterLinear;
desc.samplers[0].minFilter = GFXTextureFilterLinear;
desc.samplers[0].addressModeU = GFXAddressWrap;
desc.samplers[0].addressModeV = GFXAddressWrap;
mLightningSB = GFX->createStateBlock(desc);
}
GFX->setStateBlock(mLightningSB);
Strike* walk = mStrikeListHead;
while (walk != NULL)
{
GFX->setTexture(0, mDataBlock->strikeTextures[0]);
for( U32 i=0; i<3; i++ )
{
if( walk->bolt[i].isFading )
{
F32 alpha = 1.0f - walk->bolt[i].percentFade;
if( alpha < 0.0f ) alpha = 0.0f;
PrimBuild::color4f( fadeColor.red, fadeColor.green, fadeColor.blue, alpha );
}
else
{
PrimBuild::color4f( color.red, color.green, color.blue, color.alpha );
}
walk->bolt[i].render( state->getCameraPosition() );
}
walk = walk->next;
}
//GFX->setZWriteEnable(true);
//GFX->setAlphaTestEnable(false);
//GFX->setAlphaBlendEnable(false);
}
void ConvexShape::renderFaceEdges( S32 faceid, const ColorI &color /*= ColorI::WHITE*/, F32 lineWidth /*= 1.0f */ )
{
const Vector< ConvexShape::Face > &faceList = mGeometry.faces;
if ( faceid >= faceList.size() )
return;
GFXTransformSaver saver;
MatrixF xfm( mObjToWorld );
xfm.scale( mObjScale );
GFX->multWorld( xfm );
GFXStateBlockDesc desc;
desc.setBlend( true );
GFX->setStateBlockByDesc( desc );
MatrixF projBias(true);
const Frustum& frustum = GFX->getFrustum();
MathUtils::getZBiasProjectionMatrix( 0.001f, frustum, &projBias );
GFX->setProjectionMatrix( projBias );
S32 s = faceid;
S32 e = faceid + 1;
if ( faceid == -1 )
{
s = 0;
e = faceList.size();
}
for ( S32 i = s; i < e; i++ )
{
const ConvexShape::Face &face = faceList[i];
const Vector< ConvexShape::Edge > &edgeList = face.edges;
const Vector< U32 > &facePntList = face.points;
const Vector< Point3F > &pointList = mGeometry.points;
PrimBuild::begin( GFXLineList, edgeList.size() * 2 );
PrimBuild::color( color );
for ( S32 j = 0; j < edgeList.size(); j++ )
{
PrimBuild::vertex3fv( pointList[ facePntList[ edgeList[j].p0 ] ] );
PrimBuild::vertex3fv( pointList[ facePntList[ edgeList[j].p1 ] ] );
}
PrimBuild::end();
}
}
void DecalRoad::_initMaterial()
{
SAFE_DELETE( mMatInst );
if ( mMaterial )
mMatInst = mMaterial->createMatInstance();
else
mMatInst = MATMGR->createMatInstance( "WarningMaterial" );
GFXStateBlockDesc desc;
desc.setZReadWrite( true, false );
mMatInst->addStateBlockDesc( desc );
mMatInst->init( MATMGR->getDefaultFeatures(), getGFXVertexFormat<GFXVertexPNTBT>() );
}
void NavMesh::render(ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat)
{
if(overrideMat)
return;
if(state->isReflectPass())
return;
PROFILE_SCOPE(NavMesh_Render);
GFXDrawUtil *drawer = GFX->getDrawUtil();
GFXStateBlockDesc desc;
desc.setZReadWrite(true, false);
desc.setBlend(true);
desc.setCullMode(GFXCullNone);
drawer->drawCube(desc, getWorldBox(), ColorI(136, 255, 228, 45));
desc.setFillModeWireframe();
drawer->drawCube(desc, getWorldBox(), ColorI::BLACK);
// Recast debug draw
duDebugDrawTorque dd;
NetObject *no = getServerObject();
if(no && isSelected())
{
NavMesh *n = static_cast<NavMesh*>(no);
RenderMode mode = mRenderMode;
bool build = n->mBuilding;
if(build)
{
mode = RENDER_NAVMESH;
dd.overrideColour(duRGBA(255, 0, 0, 80));
}
n->mNavMeshLock.lock();
switch(mode)
{
case RENDER_NAVMESH: if(n->nm) duDebugDrawNavMesh (&dd, *n->nm, 0); break;
case RENDER_CONTOURS: if(n->cs) duDebugDrawContours (&dd, *n->cs); break;
case RENDER_POLYMESH: if(n->pm) duDebugDrawPolyMesh (&dd, *n->pm); break;
case RENDER_DETAILMESH: if(n->pmd) duDebugDrawPolyMeshDetail (&dd, *n->pmd); break;
case RENDER_PORTALS: if(n->nm) duDebugDrawNavMeshPortals (&dd, *n->nm); break;
}
if(n->cs && mRenderConnections && !build) duDebugDrawRegionConnections(&dd, *n->cs);
if(n->mInPolys && mRenderInput && !build) n->mInPolys->render();
n->mNavMeshLock.unlock();
}
}
void ProcessedCustomMaterial::_initPassStateBlock( RenderPassData *rpd, GFXStateBlockDesc &result )
{
Parent::_initPassStateBlock( rpd, result );
if (mCustomMaterial->getStateBlockData())
result.addDesc(mCustomMaterial->getStateBlockData()->getState());
}
bool GuiRoadEditorCtrl::onAdd()
{
if( !Parent::onAdd() )
return false;
mRoadSet = DecalRoad::getServerSet();
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
desc.setBlend(false);
desc.setZReadWrite( false, false );
mZDisableSB = GFX->createStateBlock(desc);
return true;
}
GFXGLStateBlock::GFXGLStateBlock(const GFXStateBlockDesc& desc) :
mDesc(desc),
mCachedHashValue(desc.getHashValue())
{
if( !gglHasExtension(ARB_sampler_objects) )
return;
static Map<GFXSamplerStateDesc, U32> mSamplersMap;
for(int i = 0; i < TEXTURE_STAGE_COUNT; ++i)
{
GLuint &id = mSamplerObjects[i];
GFXSamplerStateDesc &ssd = mDesc.samplers[i];
Map<GFXSamplerStateDesc, U32>::Iterator itr = mSamplersMap.find(ssd);
if(itr == mSamplersMap.end())
{
glGenSamplers(1, &id);
glSamplerParameteri(id, GL_TEXTURE_MIN_FILTER, minificationFilter(ssd.minFilter, ssd.mipFilter, 1) );
glSamplerParameteri(id, GL_TEXTURE_MAG_FILTER, GFXGLTextureFilter[ssd.magFilter]);
glSamplerParameteri(id, GL_TEXTURE_WRAP_S, GFXGLTextureAddress[ssd.addressModeU]);
glSamplerParameteri(id, GL_TEXTURE_WRAP_T, GFXGLTextureAddress[ssd.addressModeV]);
glSamplerParameteri(id, GL_TEXTURE_WRAP_R, GFXGLTextureAddress[ssd.addressModeW]);
if(static_cast< GFXGLDevice* >( GFX )->supportsAnisotropic() )
glSamplerParameterf(id, GL_TEXTURE_MAX_ANISOTROPY_EXT, ssd.maxAnisotropy);
mSamplersMap[ssd] = id;
}
else
id = itr->value;
}
}
void ForestWindEmitter::_renderEmitterInfo( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat )
{
if ( overrideMat )
return;
GFXTransformSaver saver;
GFXDrawUtil *drawer = GFX->getDrawUtil();
AssertFatal( drawer, "Got NULL GFXDrawUtil!" );
const Point3F &pos = getPosition();
const VectorF &windVec = mWind->getDirection();
GFXStateBlockDesc desc;
desc.setBlend( true );
desc.setZReadWrite( true, false );
// Draw an arrow pointing
// in the wind direction.
drawer->drawArrow( desc, pos, pos + (windVec * mWindStrength), ColorI( 0, 0, 255, 255 ) );//Point3F( -235.214, 219.589, 34.0991 ), Point3F( -218.814, 244.731, 37.5587 ), ColorI( 255, 255, 0, 255 ) );//
drawer->drawArrow( desc, pos, pos + (mWind->getTarget() * mWindStrength ), ColorI( 255, 0, 0, 85 ) );
S32 useRadius = mWindRadius;
// Draw a 2D circle for the wind radius.
if ( isRadialEmitter() )
{
//WLE - Vince
//So the problem is that when your inside the sphere it won't render so it might make someone
//think that it's not working right. So what I did was determine if the camera is inside the sphere.
//If the camera is inside the sphere, then I find the distance from the center of the sphere to the camera
//Round down and use that as the radius to draw the sphere.
//That way if someone zooms in or out, their screen is still showing the sphere.
GameConnection * gc = GameConnection::getConnectionToServer();
GameBase* gb = gc->getCameraObject();
if (gb)
{
Point3F camPos = gb->getPosition();
if ( getPosition().isInsideSphere( camPos, mWindRadius ) )
useRadius = getPosition().distanceTo(camPos);
}
drawer->drawSphere( desc, useRadius, pos, ColorI( 255, 0, 0, 80 ) );
}
}
void PxCloth::_initMaterial()
{
SAFE_DELETE( mMatInst );
Material *material = NULL;
if (mMaterialName.isNotEmpty() )
Sim::findObject( mMaterialName, material );
if ( material )
mMatInst = material->createMatInstance();
else
mMatInst = MATMGR->createMatInstance( "WarningMaterial" );
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
mMatInst->addStateBlockDesc( desc );
mMatInst->init( MATMGR->getDefaultFeatures(), getGFXVertexFormat<GFXVertexPNTT>() );
}
bool GuiNavEditorCtrl::onAdd()
{
if(!Parent::onAdd())
return false;
GFXStateBlockDesc desc;
desc.fillMode = GFXFillSolid;
desc.setBlend(false);
desc.setZReadWrite(false, false);
desc.setCullMode(GFXCullNone);
mZDisableSB = GFX->createStateBlock(desc);
desc.setZReadWrite(true, true);
mZEnableSB = GFX->createStateBlock(desc);
SceneManager::getPreRenderSignal().notify(this, &GuiNavEditorCtrl::_prepRenderImage);
return true;
}
BaseMatInstance * MaterialManager::createWarningMatInstance()
{
Material *warnMat = static_cast<Material*>(Sim::findObject("WarningMaterial"));
BaseMatInstance *warnMatInstance = NULL;
if( warnMat != NULL )
{
warnMatInstance = warnMat->createMatInstance();
GFXStateBlockDesc desc;
desc.setCullMode(GFXCullNone);
warnMatInstance->addStateBlockDesc(desc);
warnMatInstance->init( getDefaultFeatures(),
getGFXVertexFormat<GFXVertexPNTTB>() );
}
return warnMatInstance;
}
void Sun::_initCorona()
{
if ( isServerObject() )
return;
// Load texture...
if ( mCoronaTextureName.isNotEmpty() )
mCoronaTexture.set( mCoronaTextureName, &GFXDefaultStaticDiffuseProfile, "CoronaTexture" );
// Make stateblock...
if ( mCoronaSB.isNull() )
{
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
desc.setAlphaTest( true, GFXCmpGreaterEqual, 1 );
desc.setZReadWrite( false, false );
desc.setBlend( true, GFXBlendSrcColor, GFXBlendOne );
desc.samplersDefined = true;
desc.samplers[0].textureColorOp = GFXTOPModulate;
desc.samplers[0].colorArg1 = GFXTATexture;
desc.samplers[0].colorArg2 = GFXTADiffuse;
desc.samplers[0].alphaOp = GFXTOPModulate;
desc.samplers[0].alphaArg1 = GFXTATexture;
desc.samplers[0].alphaArg2 = GFXTADiffuse;
mCoronaSB = GFX->createStateBlock(desc);
desc.setFillModeWireframe();
mCoronaWireframeSB = GFX->createStateBlock(desc);
}
}
void ForestWindEmitter::_renderEmitterInfo( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat )
{
if ( overrideMat )
return;
GFXTransformSaver saver;
GFXDrawUtil *drawer = GFX->getDrawUtil();
AssertFatal( drawer, "Got NULL GFXDrawUtil!" );
const Point3F &pos = getPosition();
const VectorF &windVec = mWind->getDirection();
GFXStateBlockDesc desc;
desc.setBlend( true );
desc.setZReadWrite( true, false );
// Draw an arrow pointing
// in the wind direction.
drawer->drawArrow( desc, pos, pos + (windVec * mWindStrength), ColorI( 0, 0, 255, 255 ) );//Point3F( -235.214, 219.589, 34.0991 ), Point3F( -218.814, 244.731, 37.5587 ), ColorI( 255, 255, 0, 255 ) );//
drawer->drawArrow( desc, pos, pos + (mWind->getTarget() * mWindStrength ), ColorI( 255, 0, 0, 85 ) );
S32 useRadius = mWindRadius;
// Draw a 2D circle for the wind radius.
if ( isRadialEmitter() )
{
// If the camera is close to the sphere, shrink the sphere so it remains visible.
GameConnection* gc = GameConnection::getConnectionToServer();
GameBase* gb;
if ( gc && (gb = gc->getCameraObject()) )
{
F32 camDist = (gb->getPosition() - getPosition()).len();
if ( camDist < mWindRadius )
useRadius = camDist;
}
drawer->drawSphere( desc, useRadius, pos, ColorI( 255, 0, 0, 80 ) );
}
}
GFXStateBlockRef GFXDevice::createStateBlock(const GFXStateBlockDesc& desc)
{
PROFILE_SCOPE( GFXDevice_CreateStateBlock );
U32 hashValue = desc.getHashValue();
if (mCurrentStateBlocks[hashValue])
return mCurrentStateBlocks[hashValue];
GFXStateBlockRef result = createStateBlockInternal(desc);
result->registerResourceWithDevice(this);
mCurrentStateBlocks[hashValue] = result;
return result;
}
void NavPath::renderSimple(ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat)
{
if(overrideMat)
return;
if(state->isReflectPass() || !(isSelected() || mAlwaysRender))
return;
GFXDrawUtil *drawer = GFX->getDrawUtil();
GFXStateBlockDesc desc;
desc.setZReadWrite(true, false);
desc.setBlend(true);
desc.setCullMode(GFXCullNone);
if(isSelected())
{
drawer->drawCube(desc, getWorldBox(), ColorI(136, 255, 228, 5));
desc.setFillModeWireframe();
drawer->drawCube(desc, getWorldBox(), ColorI::BLACK);
}
desc.setZReadWrite(!mXray, false);
ColorI pathColour(255, 0, 255);
if(!mIsLooping)
{
desc.setFillModeSolid();
if(mFromSet) drawer->drawCube(desc, Point3F(0.2f, 0.2f, 0.2f), mFrom, pathColour);
if(mToSet) drawer->drawCube(desc, Point3F(0.2f, 0.2f, 0.2f), mTo, pathColour);
}
GFXStateBlockRef sb = GFX->createStateBlock(desc);
GFX->setStateBlock(sb);
PrimBuild::color3i(pathColour.red, pathColour.green, pathColour.blue);
PrimBuild::begin(GFXLineStrip, mPoints.size());
for (U32 i = 0; i < mPoints.size(); i++)
PrimBuild::vertex3fv(mPoints[i]);
PrimBuild::end();
if(mRenderSearch && getServerObject())
{
NavPath *np = static_cast<NavPath*>(getServerObject());
if(np->mQuery && !dtStatusSucceed(np->mStatus))
{
duDebugDrawTorque dd;
dd.overrideColor(duRGBA(250, 20, 20, 255));
duDebugDrawNavMeshNodes(&dd, *np->mQuery);
dd.render();
}
}
}
