void RigidBody::setRenderPosition(const Point3F& pos, const QuatF& rot)
{
MatrixF mat;
rot.setMatrix(&mat);
mat.setColumn(3,pos);
setRenderTransform(mat);
}
void SceneObject::setTransform( const MatrixF& mat )
{
// This test is a bit expensive so turn it off in release.
#ifdef TORQUE_DEBUG
//AssertFatal( mat.isAffine(), "SceneObject::setTransform() - Bad transform (non affine)!" );
#endif
PROFILE_SCOPE( SceneObject_setTransform );
// Update the transforms.
mObjToWorld = mWorldToObj = mat;
mWorldToObj.affineInverse();
// Update the world-space AABB.
resetWorldBox();
// If we're in a SceneManager, sync our scene state.
if( mSceneManager != NULL )
mSceneManager->notifyObjectDirty( this );
setRenderTransform( mat );
}
bool SceneObject::onAdd()
{
if ( !Parent::onAdd() )
return false;
mIsScopeAlways = mNetFlags.test( ScopeAlways );
mWorldToObj = mObjToWorld;
mWorldToObj.affineInverse();
resetWorldBox();
setRenderTransform(mObjToWorld);
resolveMountPID();
smSceneObjectAdd.trigger(this);
//.logicking guidebot >>
if (isServerObject())
createWorldObject();
//.logicking guidebot <<
return true;
return true;
}
bool VolumetricFog::onAdd()
{
if (!Parent::onAdd())
return false;
if (!VFRTM->IsInitialized())
{
Con::errorf("No VolumetricFogRTManager present!!");
return false;
}
resetWorldBox();
mShapeLoaded = LoadShape();
setRenderTransform(mObjToWorld);
addToScene();
ColBox.set(getTransform(), (mObjBox.getExtents() * getScale() * COLBOX_SCALE));
mObjSize = mWorldBox.getGreatestDiagonalLength();
mObjScale = getScale();
mTexTiles = mAbs(mTexTiles);
mSpeed.set(mSpeed1.x, mSpeed1.y, mSpeed2.x, mSpeed2.y);
mInvScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z));
if (isClientObject())
{
InitTexture();
return setupRenderer();
}
VFRTM->IncFogObjects();
return true;
}
void Projectile::interpolateTick(F32 delta)
{
Parent::interpolateTick(delta);
if( mHasExploded )
return;
Point3F interpPos = mCurrDeltaBase + mCurrBackDelta * delta;
Point3F dir = mCurrVelocity;
if(dir.isZero())
dir.set(0,0,1);
else
dir.normalize();
MatrixF xform(true);
xform = MathUtils::createOrientFromDir(dir);
xform.setPosition(interpPos);
setRenderTransform(xform);
// fade out the projectile image
S32 time = (S32)(mCurrTick - delta);
if(time > mDataBlock->fadeDelay)
{
F32 fade = F32(time - mDataBlock->fadeDelay);
mFadeValue = 1.0 - (fade / F32(mDataBlock->lifetime));
}
else
mFadeValue = 1.0;
updateSound();
}
void afxMooring::unpackUpdate(NetConnection * conn, BitStream * stream)
{
Parent::unpackUpdate(conn, stream);
// InitialUpdate
if (stream->readFlag())
{
stream->read(&chor_id);
ghost_cons_name = stream->readSTString();
if (chor_id != 0 && ghost_cons_name != ST_NULLSTRING)
hookup_with_chor = true;
}
if (stream->readFlag())
{
if (mDataBlock->track_pos_only)
{
Point3F pos;
mathRead(*stream, &pos);
setPosition(pos);
}
else
{
MatrixF mat;
stream->readAffineTransform(&mat);
setTransform(mat);
setRenderTransform(mat);
}
}
}
bool VolumetricFog::onAdd()
{
if (!Parent::onAdd())
return false;
if (!VFRTM->IsInitialized())
{
Con::errorf("No VolumetricFogRTManager present!!");
return false;
}
resetWorldBox();
mShapeLoaded = LoadShape();
setRenderTransform(mObjToWorld);
addToScene();
ColBox.set(getTransform(), (mObjBox.getExtents() * getScale() * COLBOX_SCALE));
mObjSize = mWorldBox.getGreatestDiagonalLength();
mObjScale = getScale();
mTexTiles = mAbs(mTexTiles);
mSpeed.set(mSpeed1.x, mSpeed1.y, mSpeed2.x, mSpeed2.y);
mInvScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z));
if (isClientObject())
{
conn = GameConnection::getConnectionToServer();
if (!conn)
{
Con::errorf("VolumetricFog::onAdd - No Serverconnection");
return false;
}
glowFX = static_cast<PostEffect*>(Sim::findObject("VolFogGlowPostFx"));
mOldLightRayStrength = Con::getFloatVariable("$LightRayPostFX::brightScalar",1.0f);
GuiCanvas* cv = dynamic_cast<GuiCanvas*>(Sim::findObject("Canvas"));
if (cv == NULL)
{
Con::errorf("VolumetricFog::onAdd - Canvas not found!!");
return false;
}
mPlatformWindow = cv->getPlatformWindow();
VolumetricFogRTManager::getVolumetricFogRTMResizeSignal().notify(this, &VolumetricFog::handleResize);
GuiCanvas::getCanvasSizeChangeSignal().notify(this, &VolumetricFog::handleCanvasResize);
InitTexture();
return setupRenderer();
}
VFRTM->IncFogObjects();
return true;
}
void Item::interpolateTick(F32 dt)
{
Parent::interpolateTick(dt);
// Client side interpolation
Point3F pos = delta.pos + delta.posVec * dt;
MatrixF mat = mRenderObjToWorld;
mat.setColumn(3,pos);
setRenderTransform(mat);
delta.dt = dt;
}
void TSStatic::setTransform(const MatrixF & mat)
{
Parent::setTransform(mat);
setMaskBits( TransformMask );
if ( mPhysicsRep )
mPhysicsRep->setTransform( mat );
// Since this is a static it's render transform changes 1
// to 1 with it's collision transform... no interpolation.
setRenderTransform(mat);
}
bool TSStatic::onAdd()
{
PROFILE_SCOPE(TSStatic_onAdd);
if ( isServerObject() )
{
// Handle the old "usePolysoup" field
SimFieldDictionary* fieldDict = getFieldDictionary();
if ( fieldDict )
{
StringTableEntry slotName = StringTable->insert( "usePolysoup" );
SimFieldDictionary::Entry * entry = fieldDict->findDynamicField( slotName );
if ( entry )
{
// Was "usePolysoup" set?
bool usePolysoup = dAtob( entry->value );
// "usePolysoup" maps to the new VisibleMesh type
if ( usePolysoup )
mCollisionType = VisibleMesh;
// Remove the field in favor on the new "collisionType" field
fieldDict->setFieldValue( slotName, "" );
}
}
}
if ( !Parent::onAdd() )
return false;
// Setup the shape.
if ( !_createShape() )
{
Con::errorf( "TSStatic::onAdd() - Shape creation failed!" );
return false;
}
setRenderTransform(mObjToWorld);
// Register for the resource change signal.
ResourceManager::get().getChangedSignal().notify( this, &TSStatic::_onResourceChanged );
addToScene();
_updateShouldTick();
return true;
}
bool SceneObject::onAdd()
{
if ( !Parent::onAdd() )
return false;
mIsScopeAlways = mNetFlags.test( ScopeAlways );
mWorldToObj = mObjToWorld;
mWorldToObj.affineInverse();
resetWorldBox();
setRenderTransform(mObjToWorld);
resolveMountPID();
smSceneObjectAdd.trigger(this);
return true;
}
bool DecalRoad::onAdd()
{
if ( !Parent::onAdd() )
return false;
// DecalRoad is at position zero when created,
// it sets its own position to the first node inside
// _generateEdges but until it has at least one node
// it will be at 0,0,0.
MatrixF mat(true);
Parent::setTransform( mat );
// The client side calculates bounds based on clipped geometry. It would
// be wasteful for the server to do this so the server uses global bounds.
if ( isServerObject() )
{
setGlobalBounds();
resetWorldBox();
}
// Set the Render Transform.
setRenderTransform(mObjToWorld);
// Add to Scene.
addToScene();
if ( isServerObject() )
getServerSet()->addObject( this );
//
TerrainBlock::smUpdateSignal.notify( this, &DecalRoad::_onTerrainChanged );
//
if ( isClientObject() )
_initMaterial();
_generateEdges();
_captureVerts();
return true;
}
//--------------------------------------------------------------------------
bool VehicleBlocker::onAdd()
{
if(!Parent::onAdd())
return false;
mObjBox.minExtents.set(-mDimensions.x, -mDimensions.y, 0);
mObjBox.maxExtents.set( mDimensions.x, mDimensions.y, mDimensions.z);
if( !mObjBox.isValidBox() )
{
Con::errorf("VehicleBlocker::onAdd - Fail - No valid object box");
return false;
}
resetWorldBox();
setRenderTransform(mObjToWorld);
addToScene();
return true;
}
bool fxShapeReplicator::onAdd()
{
if(!Parent::onAdd())
return(false);
// Add the Replicator to the Replicator Set.
dynamic_cast<SimSet*>(Sim::findObject("fxReplicatorSet"))->addObject(this);
// Set Default Object Box.
mObjBox.minExtents.set( -0.5, -0.5, -0.5 );
mObjBox.maxExtents.set( 0.5, 0.5, 0.5 );
resetWorldBox();
// Add to Scene.
setRenderTransform(mObjToWorld);
addToScene();
// Register for notification when GhostAlways objects are done loading
NetConnection::smGhostAlwaysDone.notify( this, &fxShapeReplicator::onGhostAlwaysDone );
return true;
}
bool Sun::onAdd()
{
if ( !Parent::onAdd() )
return false;
// Register as listener to TimeOfDay update events
TimeOfDay::getTimeOfDayUpdateSignal().notify( this, &Sun::_updateTimeOfDay );
// Make this thing have a global bounds so that its
// always returned from spatial light queries.
setGlobalBounds();
resetWorldBox();
setRenderTransform( mObjToWorld );
addToScene();
_initCorona();
// Update the light parameters.
_conformLights();
return true;
}
void WaterPlane::innerRender( SceneRenderState *state )
{
GFXDEBUGEVENT_SCOPE( WaterPlane_innerRender, ColorI( 255, 0, 0 ) );
const Point3F &camPosition = state->getCameraPosition();
Point3F rvec, fvec, uvec, pos;
const MatrixF &objMat = getTransform(); //getRenderTransform();
const MatrixF &camMat = state->getCameraTransform();
MatrixF renderMat( true );
camMat.getColumn( 1, &fvec );
uvec.set( 0, 0, 1 );
rvec = mCross( fvec, uvec );
rvec.normalize();
fvec = mCross( uvec, rvec );
pos = camPosition;
pos.z = objMat.getPosition().z;
renderMat.setColumn( 0, rvec );
renderMat.setColumn( 1, fvec );
renderMat.setColumn( 2, uvec );
renderMat.setColumn( 3, pos );
setRenderTransform( renderMat );
// Setup SceneData
SceneData sgData = setupSceneGraphInfo( state );
// set the material
S32 matIdx = getMaterialIndex( camPosition );
if ( !initMaterial( matIdx ) )
return;
BaseMatInstance *mat = mMatInstances[matIdx];
WaterMatParams matParams = mMatParamHandles[matIdx];
// render the geometry
if ( mat )
{
// setup proj/world transform
mMatrixSet->restoreSceneViewProjection();
mMatrixSet->setWorld(getRenderTransform());
setShaderParams( state, mat, matParams );
while( mat->setupPass( state, sgData ) )
{
mat->setSceneInfo(state, sgData);
mat->setTransforms(*mMatrixSet, state, sgData);
setCustomTextures( matIdx, mat->getCurPass(), matParams );
// set vert/prim buffer
GFX->setVertexBuffer( mVertBuff );
GFX->setPrimitiveBuffer( mPrimBuff );
GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, mVertCount, 0, mPrimCount );
}
}
}
