void CloudLayer::renderObject( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *mi )
{
GFXTransformSaver saver;
const Point3F &camPos = state->getCameraPosition();
MatrixF xfm(true);
xfm.setPosition(camPos);
GFX->multWorld(xfm);
if ( state->isReflectPass() )
GFX->setProjectionMatrix( state->getSceneManager()->getNonClipProjection() );
GFX->setShader( mShader );
GFX->setShaderConstBuffer( mShaderConsts );
GFX->setStateBlock( mStateblock );
// Set all the shader consts...
MatrixF xform(GFX->getProjectionMatrix());
xform *= GFX->getViewMatrix();
xform *= GFX->getWorldMatrix();
mShaderConsts->setSafe( mModelViewProjSC, xform );
mShaderConsts->setSafe( mEyePosWorldSC, camPos );
LightInfo *lightinfo = LIGHTMGR->getSpecialLight(LightManager::slSunLightType);
const ColorF &sunlight = state->getAmbientLightColor();
Point3F ambientColor( sunlight.red, sunlight.green, sunlight.blue );
mShaderConsts->setSafe( mAmbientColorSC, ambientColor );
const ColorF &sunColor = lightinfo->getColor();
Point3F data( sunColor.red, sunColor.green, sunColor.blue );
mShaderConsts->setSafe( mSunColorSC, data );
mShaderConsts->setSafe( mSunVecSC, lightinfo->getDirection() );
for ( U32 i = 0; i < TEX_COUNT; i++ )
mShaderConsts->setSafe( mTexOffsetSC[i], mTexOffset[i] );
Point3F scale( mTexScale[0], mTexScale[1], mTexScale[2] );
mShaderConsts->setSafe( mTexScaleSC, scale );
Point3F color;
color.set( mBaseColor.red, mBaseColor.green, mBaseColor.blue );
mShaderConsts->setSafe( mBaseColorSC, color );
mShaderConsts->setSafe( mCoverageSC, mCoverage );
mShaderConsts->setSafe( mExposureSC, mExposure );
GFX->setTexture( mNormalHeightMapSC->getSamplerRegister(), mTexture );
GFX->setVertexBuffer( mVB );
GFX->setPrimitiveBuffer( mPB );
GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, smVertCount, 0, smTriangleCount );
}
void Frustum::setNearFarDist( F32 nearDist, F32 farDist )
{
if( mNearDist == nearDist && mFarDist == farDist )
return;
// Recalculate the frustum.
MatrixF xfm( mTransform );
set( mIsOrtho, getFov(), getAspectRatio(), nearDist, farDist, xfm );
}
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 supersample(const image *src,
const image *dst,
const pattern *pat,
const float *rot,
filter fil, to_img img, to_env env, int f, int i, int j)
{
int F;
float I;
float J;
int k;
int c = 0;
float *p = dst[f].p + dst[f].c * (dst[f].w * i + j);
/* For each sample of the supersampling pattern... */
for (k = 0; k < pat->n; k++)
{
const float ii = pat->p[k].i + i;
const float jj = pat->p[k].j + j;
/* Project and unproject giving the source location. Sample there. */
float v[3];
if (env( f, ii, jj, dst->h, dst->w, v) && xfm(rot, v) &&
img(&F, &I, &J, src->h, src->w, v))
{
#if 1
fil(src + F, I, J, p);
#else
p[0] = (v[0] + 1.0f) / 2.0f;
p[1] = (v[1] + 1.0f) / 2.0f;
p[2] = (v[2] + 1.0f) / 2.0f;
#endif
c++;
}
}
/* Normalize the sample. */
for (k = 0; k < dst->c; k++)
p[k] /= c;
}
void BasicClouds::renderObject( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *mi )
{
GFXTransformSaver saver;
Point3F camPos = state->getCameraPosition();
MatrixF xfm(true);
xfm.setPosition(camPos);
GFX->multWorld(xfm);
if ( state->isReflectPass() )
GFX->setProjectionMatrix( state->getSceneManager()->getNonClipProjection() );
GFX->setShader( mShader );
GFX->setShaderConstBuffer( mShaderConsts );
GFX->setStateBlock( mStateblock );
MatrixF xform(GFX->getProjectionMatrix());
xform *= GFX->getViewMatrix();
xform *= GFX->getWorldMatrix();
mShaderConsts->setSafe( mModelViewProjSC, xform );
mShaderConsts->setSafe( mTimeSC, (F32)Sim::getCurrentTime() / 1000.0f );
GFX->setPrimitiveBuffer( mPB );
for ( U32 i = 0; i < TEX_COUNT; i++ )
{
if ( !mLayerEnabled[i] )
continue;
mShaderConsts->setSafe( mTexScaleSC, mTexScale[i] );
mShaderConsts->setSafe( mTexDirectionSC, mTexDirection[i] * mTexSpeed[i] );
mShaderConsts->setSafe( mTexOffsetSC, mTexOffset[i] );
GFX->setTexture( mDiffuseMapSC->getSamplerRegister(), mTexture[i] );
GFX->setVertexBuffer( mVB[i] );
GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, smVertCount, 0, smTriangleCount );
}
}
void ConvexShape::_updateCollision()
{
SAFE_DELETE( mPhysicsRep );
if ( !PHYSICSMGR )
return;
PhysicsCollision *colShape = PHYSICSMGR->createCollision();
// We need the points untransformed!
Vector<Point3F> rawPoints;
MatrixF xfm( getWorldTransform() );
xfm.setPosition( Point3F::Zero );
for ( U32 i=0; i < mGeometry.points.size(); i++ )
{
Point3F p = mGeometry.points[i];
xfm.mulP( p );
rawPoints.push_back( p );
}
// The convex generation from a point cloud
// can fail at times... give up in that case.
if ( !colShape->addConvex( mGeometry.points.address(),
mGeometry.points.size(),
MatrixF::Identity ) )
{
delete colShape;
return;
}
PhysicsWorld *world = PHYSICSMGR->getWorld( isServerObject() ? "server" : "client" );
mPhysicsRep = PHYSICSMGR->createBody();
mPhysicsRep->init( colShape, 0, 0, this, world );
mPhysicsRep->setTransform( getTransform() );
}
void ScatterSky::_render( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat )
{
if ( overrideMat || (!mShader && !_initShader()) )
return;
GFXTransformSaver saver;
if ( mVB.isNull() || mPrimBuffer.isNull() )
_initVBIB();
GFX->setShader( mShader );
GFX->setShaderConstBuffer( mShaderConsts );
Point4F sphereRadii( mSphereOuterRadius, mSphereOuterRadius * mSphereOuterRadius,
mSphereInnerRadius, mSphereInnerRadius * mSphereInnerRadius );
Point4F scatteringCoeffs( mRayleighScattering * mSkyBrightness, mRayleighScattering4PI,
mMieScattering * mSkyBrightness, mMieScattering4PI );
Point4F invWavelength( 1.0f / mWavelength4[0],
1.0f / mWavelength4[1],
1.0f / mWavelength4[2], 1.0f );
Point3F camPos( 0, 0, smViewerHeight );
Point4F miscParams( camPos.z, camPos.z * camPos.z, mScale, mScale / mRayleighScaleDepth );
Frustum frust = state->getFrustum();
frust.setFarDist( smEarthRadius + smAtmosphereRadius );
MatrixF proj( true );
frust.getProjectionMatrix( &proj );
Point3F camPos2 = state->getCameraPosition();
MatrixF xfm(true);
xfm.setPosition(camPos2);//-Point3F( 0, 0, 200000.0f));
GFX->multWorld(xfm);
MatrixF xform(proj);//GFX->getProjectionMatrix());
xform *= GFX->getViewMatrix();
xform *= GFX->getWorldMatrix();
mShaderConsts->setSafe( mModelViewProjSC, xform );
mShaderConsts->setSafe( mMiscSC, miscParams );
mShaderConsts->setSafe( mSphereRadiiSC, sphereRadii );
mShaderConsts->setSafe( mScatteringCoefficientsSC, scatteringCoeffs );
mShaderConsts->setSafe( mCamPosSC, camPos );
mShaderConsts->setSafe( mLightDirSC, mLightDir );
mShaderConsts->setSafe( mSunDirSC, mSunDir );
mShaderConsts->setSafe( mNightColorSC, mNightColor );
mShaderConsts->setSafe( mInverseWavelengthSC, invWavelength );
mShaderConsts->setSafe( mNightInterpolantAndExposureSC, Point2F( mExposure, mNightInterpolant ) );
mShaderConsts->setSafe( mColorizeSC, mColorize*mColorizeAmt );
if ( GFXDevice::getWireframe() )
{
GFXStateBlockDesc desc( mStateBlock->getDesc() );
desc.setFillModeWireframe();
GFX->setStateBlockByDesc( desc );
}
else
GFX->setStateBlock( mStateBlock );
if ( mUseNightCubemap && mNightCubemap )
{
mShaderConsts->setSafe( mUseCubemapSC, 1.0f );
if ( !mNightCubemap->mCubemap )
mNightCubemap->createMap();
GFX->setCubeTexture( 0, mNightCubemap->mCubemap );
}
else
{
GFX->setCubeTexture( 0, NULL );
mShaderConsts->setSafe( mUseCubemapSC, 0.0f );
}
GFX->setPrimitiveBuffer( mPrimBuffer );
GFX->setVertexBuffer( mVB );
GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, mVertCount, 0, mPrimCount );
}
void ConvexShape::_renderDebug( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *mat )
{
GFXDrawUtil *drawer = GFX->getDrawUtil();
GFX->setTexture( 0, NULL );
// Render world box.
if ( false )
{
Box3F wbox( mWorldBox );
//if ( getServerObject() )
// Box3F wbox = static_cast<ConvexShape*>( getServerObject() )->mWorldBox;
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
desc.setFillModeWireframe();
drawer->drawCube( desc, wbox, ColorI::RED );
}
const Vector< Point3F > &pointList = mGeometry.points;
const Vector< ConvexShape::Face > &faceList = mGeometry.faces;
// Render Edges.
if ( false )
{
GFXTransformSaver saver;
//GFXFrustumSaver fsaver;
MatrixF xfm( getRenderTransform() );
xfm.scale( getScale() );
GFX->multWorld( xfm );
GFXStateBlockDesc desc;
desc.setZReadWrite( true, false );
desc.setBlend( true );
GFX->setStateBlockByDesc( desc );
//MathUtils::getZBiasProjectionMatrix( 0.01f, state->getFrustum(), )
const Point3F &camFvec = state->getCameraTransform().getForwardVector();
for ( S32 i = 0; i < faceList.size(); i++ )
{
const ConvexShape::Face &face = faceList[i];
const Vector< ConvexShape::Edge > &edgeList = face.edges;
const Vector< U32 > &facePntList = face.points;
PrimBuild::begin( GFXLineList, edgeList.size() * 2 );
PrimBuild::color( ColorI::WHITE * 0.8f );
for ( S32 j = 0; j < edgeList.size(); j++ )
{
PrimBuild::vertex3fv( pointList[ facePntList[ edgeList[j].p0 ] ] - camFvec * 0.001f );
PrimBuild::vertex3fv( pointList[ facePntList[ edgeList[j].p1 ] ] - camFvec * 0.001f );
}
PrimBuild::end();
}
}
ColorI faceColorsx[4] =
{
ColorI( 255, 0, 0 ),
ColorI( 0, 255, 0 ),
ColorI( 0, 0, 255 ),
ColorI( 255, 0, 255 )
};
MatrixF objToWorld( mObjToWorld );
objToWorld.scale( mObjScale );
// Render faces centers/colors.
if ( false )
{
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
Point3F size( 0.1f );
for ( S32 i = 0; i < faceList.size(); i++ )
{
ColorI color = faceColorsx[ i % 4 ];
S32 div = ( i / 4 ) * 4;
if ( div > 0 )
color /= div;
color.alpha = 255;
Point3F pnt;
objToWorld.mulP( faceList[i].centroid, &pnt );
drawer->drawCube( desc, size, pnt, color, NULL );
}
}
// Render winding order.
if ( false )
{
GFXStateBlockDesc desc;
desc.setCullMode( GFXCullNone );
desc.setZReadWrite( true, false );
GFX->setStateBlockByDesc( desc );
U32 pointCount = 0;
for ( S32 i = 0; i < faceList.size(); i++ )
pointCount += faceList[i].winding.size();
PrimBuild::begin( GFXLineList, pointCount * 2 );
for ( S32 i = 0; i < faceList.size(); i++ )
{
for ( S32 j = 0; j < faceList[i].winding.size(); j++ )
{
Point3F p0 = pointList[ faceList[i].points[ faceList[i].winding[j] ] ];
Point3F p1 = p0 + mSurfaces[ faceList[i].id ].getUpVector() * 0.75f * ( Point3F::One / mObjScale );
objToWorld.mulP( p0 );
objToWorld.mulP( p1 );
ColorI color = faceColorsx[ j % 4 ];
S32 div = ( j / 4 ) * 4;
if ( div > 0 )
color /= div;
color.alpha = 255;
PrimBuild::color( color );
PrimBuild::vertex3fv( p0 );
PrimBuild::color( color );
PrimBuild::vertex3fv( p1 );
}
}
PrimBuild::end();
}
// Render Points.
if ( false )
{
/*
GFXTransformSaver saver;
MatrixF xfm( getRenderTransform() );
xfm.scale( getScale() );
GFX->multWorld( xfm );
GFXStateBlockDesc desc;
Point3F size( 0.05f );
*/
}
// Render surface transforms.
if ( false )
{
GFXStateBlockDesc desc;
desc.setBlend( false );
desc.setZReadWrite( true, true );
Point3F scale(mNormalLength);
for ( S32 i = 0; i < mSurfaces.size(); i++ )
{
MatrixF objToWorld( mObjToWorld );
objToWorld.scale( mObjScale );
MatrixF renderMat;
renderMat.mul( objToWorld, mSurfaces[i] );
renderMat.setPosition( renderMat.getPosition() + renderMat.getUpVector() * 0.001f );
drawer->drawTransform( desc, renderMat, &scale, NULL );
}
}
}
void TSStatic::prepRenderImage( SceneRenderState* state )
{
if( !mShapeInstance )
return;
Point3F cameraOffset;
getRenderTransform().getColumn(3,&cameraOffset);
cameraOffset -= state->getDiffuseCameraPosition();
F32 dist = cameraOffset.len();
if (dist < 0.01f)
dist = 0.01f;
F32 invScale = (1.0f/getMax(getMax(mObjScale.x,mObjScale.y),mObjScale.z));
if ( mForceDetail == -1 )
mShapeInstance->setDetailFromDistance( state, dist * invScale );
else
mShapeInstance->setCurrentDetail( mForceDetail );
if ( mShapeInstance->getCurrentDetail() < 0 )
return;
GFXTransformSaver saver;
// Set up our TS render state.
TSRenderState rdata;
rdata.setSceneState( state );
rdata.setFadeOverride( 1.0f );
rdata.setOriginSort( mUseOriginSort );
// If we have submesh culling enabled then prepare
// the object space frustum to pass to the shape.
Frustum culler;
if ( mMeshCulling )
{
culler = state->getFrustum();
MatrixF xfm( true );
xfm.scale( Point3F::One / getScale() );
xfm.mul( getRenderWorldTransform() );
xfm.mul( culler.getTransform() );
culler.setTransform( xfm );
rdata.setCuller( &culler );
}
// We might have some forward lit materials
// so pass down a query to gather lights.
LightQuery query;
query.init( getWorldSphere() );
rdata.setLightQuery( &query );
MatrixF mat = getRenderTransform();
mat.scale( mObjScale );
GFX->setWorldMatrix( mat );
mShapeInstance->animate();
mShapeInstance->render( rdata );
if ( mRenderNormalScalar > 0 )
{
ObjectRenderInst *ri = state->getRenderPass()->allocInst<ObjectRenderInst>();
ri->renderDelegate.bind( this, &TSStatic::_renderNormals );
ri->type = RenderPassManager::RIT_Editor;
state->getRenderPass()->addInst( ri );
}
}
