falso
/
The-Simpsons-Hit-and-Run
mirror of https://github.com/Svxy/The-Simpsons-Hit-and-Run.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
The-Simpsons-Hit-and-Run/game/code/worldsim/redbrick/geometryvehicle.cpp

3385 lines
107 KiB
C++
Raw Permalink Blame History

/*===========================================================================
geometryvehicle.cpp
created Dec 7, 2001
by Greg Mayer
Copyright (c) 2001 Radical Entertainment, Inc.
All rights reserved.
===========================================================================*/
#include <camera/supercammanager.h>
#include <contexts/bootupcontext.h>
#include <worldsim/character/characterrenderable.h>
#include <worldsim/redbrick/geometryvehicle.h>
#include <worldsim/redbrick/vehicle.h>
#include <worldsim/redbrick/wheel.h>
#include <worldsim/avatar.h>
#include <worldsim/avatarmanager.h>
#include <worldsim/vehiclecentral.h>
#include <render/RenderManager/RenderManager.h>
#include <p3d/anim/compositedrawable.hpp>
#include <p3d/billboardobject.hpp>
#include <p3d/anim/multicontroller.hpp>
#include <p3d/anim/poseanimation.hpp>
#include <p3d/camera.hpp>
#include <p3d/directionallight.hpp>
#include <p3d/light.hpp>
#include <p3d/matrixstack.hpp>
#include <p3d/shadow.hpp>
#include <p3d/view.hpp>
#include <p3d/effects/particlesystem.hpp>
#include <pddi/pddi.hpp>
#include <p3d/utility.hpp>
#include <typeinfo>
#include <p3d/anim/visibilityanimation.hpp>
#include <raddebug.hpp>
#include <raddebugwatch.hpp>
#include <mission/statepropcollectible.h>
#include <memory/srrmemory.h>
#include <mission/gameplaymanager.h>
#include <render/particles/particlemanager.h>
#include <radmath/util.hpp>
#include <debug/debuginfo.h>
#include <worldsim/redbrick/trafficbodydrawable.h>
#include <worldsim/coins/sparkle.h>
//#define SHADOW_EDITTING
const int TYPICAL_NUMBER_OF_FRAME_CONTROLLERS = 16;
// this is by artist design... the value is between 0 and 255
static const int INCAR_ROOF_ALPHA = 100;
// The velocity at which variable emission particle systems
// reach their peak (13.5 meters/second ~ 50 kph)
static const float PARTICLE_SYSTEM_MAX_VELOCITY = 13.5f;
static const float MAX_Y_OFFSET = 0.25f; // Max distance the shadow will raise to avoid Z Chew.
// Listing of special frame controllers
// This list might be best moved into some sort of script file or data chunk
// rather than being hardcoded if many more get added
// Currently its got framecontrollers for the flame effects on the hoverbike
static const GeometryVehicle::VehicleFrameController FRAME_CONTROLLER_DATA[] =
{
// These are reversable framecontrollers
{ "BQG_flame4Shape", NULL, true, eNone, 0, 1.0f, 0, 0 },
{ "BQG_flame3Shape", NULL, true, eNone, 0, 1.0f, 0, 0 },
{ "BQG_flame2Shape", NULL, true, eNone, 1.0f, 0, 0, 0 },
{ "BQG_flame1Shape", NULL, true, eNone, 1.0f, 0, 0, 0 },
{ "BQG_flame5Shape", NULL, true, eNone, 1.0f, 0, 0, 0 },
{ "BQG_flame6Shape", NULL, true, eNone, 1.0f, 0, 0, 0 },
{ "EFX_backfireSystShape", NULL, false, eBackfire, 0,0,0, 0 },
{ "BQG_backfireflashGroupShape", NULL, false, eBackfire, 0,0,0 },
{ "PTRN_ship", NULL, false, eNone, 0, 0, 1.0f/25.0f, 0 },
{ "PTRN_redbrick", NULL, false, eNone, 0, 0, 0.08f, 5.0f }
//,
// { "PTRN_ship", NULL, false, eNone, 2.0f,-2.0f,0,0 }
};
const rmt::Vector BARRACUDA_COLLECTIBLE_POS( 0, 0.4f, -3.0f );
const rmt::Vector JEEP_COLLECTIBLE_POS( -0.237f, 0.216f, -2.243f );
const rmt::Vector DUNE_COLLECTIBLE_ROT( rmt::DegToRadian( -90 ), rmt::DegToRadian( 0 ), rmt::DegToRadian( 0 ));
const rmt::Vector DUNE_COLLECTIBLE_POS( 0, 0.714f, 0);
const float BARREL_RADIUS = 0.351f;
const rmt::Vector WITCH_COLLECTIBLE_POS( 0, 0.4f, -1.31f - BARREL_RADIUS );
const rmt::Vector COFFIN_COLLECTIBLE_POS( 0, 0.4f, -1.59f - BARREL_RADIUS );
const rmt::Vector HALLO_COLLECTIBLE_POS( 0, 0.4f, -3.467f - BARREL_RADIUS );
const rmt::Matrix DEFAULT_COLLECTIBLE_TRANSFORM( 0.9219f, -0.3875f, 0.0f, 0.0f,
0.3797f, 0.9034f, -0.1994f, 0.0f,
0.0773f, 0.1838f, 0.9799f, 0.0f,
0.0f, 0.1270f, -2.6610f, 1.0f );
static const int NUM_FRAME_CONTROLLERS = sizeof( FRAME_CONTROLLER_DATA ) / sizeof( FRAME_CONTROLLER_DATA[0] );
static bool sbDrawVehicle = true;
static float refractiveIndex = 10.0f;
//------------------------------------------------------------------------
GeometryVehicle::GeometryVehicle():
m_Collectible( NULL ),
m_EnvRef( 0x40 )
{
mCompositeDrawable = 0;
mChassisGeometry = 0;
mAnim = 0;
mAnimRevPerSecondBase = 1.0f;
mVehicleOwner = 0;
//mRevMult = 0.5f;
//mRevMult = 0.4f;
mRevMult = 0.1f; // good for frink - anyone else need this?
mHoodShader = 0;
mTrunkShader = 0;
mDoorPShader = 0;
mDoorDShader = 0;
mHoodTextureDam = 0;
mTrunkTextureDam = 0;
mDoorPTextureDam = 0;
mDoorDTextureDam = 0;
mHoodTextureNorm = 0;
mTrunkTextureNorm = 0;
mDoorPTextureNorm = 0;
mDoorDTextureNorm = 0;
mChassisShader = 0;
mChassisTextureNorm = 0;
mChassisTextureDam = 0;
mParticleEmitter = 0;
mVariableEmissionParticleSystem = 0;
mEngineParticleAttr.mType = ParticleEnum::eNull;
mLeftWheelParticleAttr.mType = ParticleEnum::eNull;
mRightWheelParticleAttr.mType = ParticleEnum::eNull;
mTailPipeParticleAttr.mType = ParticleEnum::eNull;
mSkidMarkGenerator = 0;
mSpecialEffect = ParticleEnum::eNull;
mLastPosition = rmt::Vector (0.0f, 0.0f, 0.0f);
mCurEnvMapRotation = 0.0f;
mBrakeLightJoints[0] = -1;
mBrakeLightJoints[1] = -1;
mBrakeLightJoints[2] = -1;
mBrakeLightJoints[3] = -1;
mReverseLightJoints[0] = -1;
mReverseLightJoints[1] = -1;
mReverseLightJoints[2] = -1;
mReverseLightJoints[3] = -1;
mTrafficBodyDrawable = NULL;
mTrafficDoorDrawable = NULL;
for( int i = 0; i < 4; ++i )
{
mShadowPointAdjustments[ i ][ 0 ] = 0.0f;
mShadowPointAdjustments[ i ][ 1 ] = 0.0f;
}
mFadeAlpha = 255;
for( int i=0; i<NUM_BRAKELIGHT_BBQS; i++ )
{
mBrakeLights[i] = NULL;
}
#ifdef RAD_WIN32
mFrinkArc = NULL;
#endif
mUsingTrafficModel = false;
/*
for( int i=0; i<NUM_HEADLIGHT_BBQGS; i++ )
{
mHeadLights[i] = NULL;
}
*/
mHasGhostGlow = false;
for( int i=0; i<NUM_GHOSTGLOW_BBQGS; i++ )
{
mGhostGlows[i] = NULL;
}
mHasNukeGlow = false;
for( int i=0; i<NUM_NUKEGLOW_BBQGS; i++ )
{
mNukeGlows[i] = NULL;
}
mBrakeLightsOn = false;
mBrakeLightScale = 0.0f;
mHeadLightScale = 0.0f;
mEnableLights = true; // sets visibility on headlights and brakelights
mLightsOffDueToDamage = false;
mRoofShader = NULL;
mRoofAlpha = 255;
mRoofTargetAlpha = 255;
mRoofOpacShape = NULL;
mRoofAlphaShape = NULL;
for( int i = 0; i < MAX_REFRACTION_SHADERS; ++i )
{
mRefractionShader[ i ] = NULL;
}
// Lets make a collectible transform
// Hard code it for now. Later use car specific ones from Kevin
m_CollectibleTransform = DEFAULT_COLLECTIBLE_TRANSFORM;
mFrameControllers.reserve( TYPICAL_NUMBER_OF_FRAME_CONTROLLERS );
//
// Add refractive index to the watcher
//
static bool refractiveIndexAdded = false;
if( !refractiveIndexAdded )
{
radDbgWatchAddFloat( &refractiveIndex, "RefractionShader", "RefraciveIndex", 0, 0, -20.0f, 20.0f );
refractiveIndexAdded = true;
}
}
//------------------------------------------------------------------------
GeometryVehicle::~GeometryVehicle()
{
#ifdef SHADOW_EDITTING
for( int i = 0; i < 4; ++i )
{
radDbgWatchDelete( &(mShadowPointAdjustments[ i ][ 0 ]) );
radDbgWatchDelete( &(mShadowPointAdjustments[ i ][ 1 ]) );
}
#endif
if(mCompositeDrawable)
{
GetRenderManager()->mEntityDeletionList.Add((tRefCounted*&)mCompositeDrawable);
mCompositeDrawable = 0;
}
if(mVariableEmissionParticleSystem)
{
GetRenderManager()->mEntityDeletionList.Add((tRefCounted*&)mVariableEmissionParticleSystem);
mVariableEmissionParticleSystem = 0;
}
if(mChassisGeometry)
{
mChassisGeometry->Release();
mChassisGeometry = 0;
}
if(mAnim)
{
mAnim->Release();
mAnim = 0;
}
for( int i = 0; i < MAX_REFRACTION_SHADERS; ++i )
{
tRefCounted::Release( mRefractionShader[ i ] );
mRefractionShader[ i ] = 0;
}
// damage state crapola
if(mHoodShader) mHoodShader->Release();
if(mTrunkShader) mTrunkShader->Release();
if(mDoorPShader) mDoorPShader->Release();
if(mDoorDShader) mDoorDShader->Release();
if(mHoodTextureNorm) mHoodTextureNorm->Release();
if(mTrunkTextureNorm) mTrunkTextureNorm->Release();
if(mDoorPTextureNorm) mDoorPTextureNorm->Release();
if(mDoorDTextureNorm) mDoorDTextureNorm->Release();
if(mHoodTextureDam) mHoodTextureDam->Release();
if(mTrunkTextureDam) mTrunkTextureDam->Release();
if(mDoorPTextureDam) mDoorPTextureDam->Release();
if(mDoorDTextureDam) mDoorDTextureDam->Release();
if(mChassisShader) mChassisShader->Release();
if(mChassisTextureNorm) mChassisTextureNorm->Release();
if(mChassisTextureDam) mChassisTextureDam->Release();
delete mParticleEmitter;
if ( mSpecialEffect != ParticleEnum::eNull )
{
GetParticleManager()->DeleteSystem( mSpecialEffect );
}
if ( mVariableEmissionParticleSystem != 0 )
{
mVariableEmissionParticleSystem->ReleaseParticles();
mVariableEmissionParticleSystem = 0;
}
if(mSkidMarkGenerator)
{
delete mSkidMarkGenerator;
}
if( mTrafficBodyDrawable )
{
mTrafficBodyDrawable->Release();
mTrafficBodyDrawable = NULL;
}
if( mTrafficDoorDrawable )
{
mTrafficDoorDrawable->Release();
mTrafficDoorDrawable = NULL;
}
for( int i=0; i<NUM_BRAKELIGHT_BBQS; i++ )
{
if( mBrakeLights[i] )
{
mBrakeLights[i]->Release();
mBrakeLights[i] = NULL;
}
}
#ifdef RAD_WIN32
if( mFrinkArc )
{
mFrinkArc->Release();
mFrinkArc = NULL;
}
#endif
/*
for( int i=0; i<NUM_HEADLIGHT_BBQGS; i++ )
{
if( mHeadLights[i] )
{
mHeadLights[i]->Release();
mHeadLights[i] = NULL;
}
}
*/
for( int i=0; i<NUM_GHOSTGLOW_BBQGS; i++ )
{
if( mGhostGlows[i] )
{
mGhostGlows[i]->Release();
mGhostGlows[i] = NULL;
}
}
for( int i=0; i<NUM_NUKEGLOW_BBQGS; i++ )
{
if( mNukeGlows[i] )
{
mNukeGlows[i]->Release();
mNukeGlows[i] = NULL;
}
}
if( mRoofShader )
{
mRoofShader->Release();
mRoofShader = NULL;
}
if( mRoofOpacShape )
{
mRoofOpacShape = NULL;
}
if( mRoofAlphaShape )
{
mRoofAlphaShape = NULL;
}
for ( unsigned int fc = 0 ; fc < mFrameControllers.size() ; fc++ )
{
mFrameControllers[fc].frameController->Release();
}
if ( m_Collectible != NULL )
{
m_Collectible->Release();
m_Collectible = NULL;
}
}
//------------------------------------------------------------------------
bool GeometryVehicle::Init( const char* name, Vehicle* owner, int num)
{
#ifdef SHADOW_EDITTING
for( int i = 0; i < 4; ++i )
{
mShadowPointAdjustments[ i ][ 0 ] = 0.0f;
mShadowPointAdjustments[ i ][ 1 ] = 0.0f;
char text[ 128 ];
sprintf( text, "%s Shadow point %d X", name, i );
radDbgWatchAddFloat( &(mShadowPointAdjustments[ i ][ 0 ]), text, "VehicleShadow", 0, 0, -5.0f, 5.0f );
sprintf( text, "%s Shadow point %d Y", name, i );
radDbgWatchAddFloat( &(mShadowPointAdjustments[ i ][ 1 ]), text, "VehicleShadow", 0, 0, -5.0f, 5.0f );
}
#endif
mVehicleOwner = owner;
mCurEnvMapRotation = 0.0f;
return GetArt(name);
}
//=============================================================================
// GeometryVehicle::InitSkidMarks
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::InitSkidMarks()
{
// called from vehicle Init
// only for user vehicles
GameMemoryAllocator gma = GetGameplayManager()->GetCurrentMissionHeap();
mSkidMarkGenerator = new(gma)SkidMarkGenerator;
int i;
for(i = 0; i < 4; i++)
{
// initial value
rmt::Vector offset = mVehicleOwner->mSuspensionRestPoints[i];
offset.y -= mVehicleOwner->mWheels[i]->mRadius;
mSkidMarkGenerator->SetWheelOffset(i, offset); // need to do this everyframe
float length = mVehicleOwner->mWheels[i]->mRadius * 0.6f;
//float width = mVehicleOwner->mWheels[i]->mRadius * 0.5f; //??
float width = mVehicleOwner->mWheels[i]->mRadius * 0.8f; //??
mSkidMarkGenerator->SetWheelDimensions(i, width, length);
//void GenerateSkid( int wheel, const SkidData& );
//void Update();
}
}
//=============================================================================
// GeometryVehicle::InitParticles
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::InitParticles()
{
MEMTRACK_PUSH_GROUP( "GeometryVehicle" );
GameMemoryAllocator gma = GetGameplayManager()->GetCurrentMissionHeap();
mParticleEmitter = new(gma)VehicleParticleEmitter;
rmt::Vector smokeOffset = mVehicleOwner->GetSmokeOffset();
mParticleEmitter->SetPartLocation(VehicleParticleEmitter::eEngine, smokeOffset);
rmt::Vector wheelOffset = mVehicleOwner->GetWheel0Offset();
mParticleEmitter->SetPartLocation(VehicleParticleEmitter::eRightBackTire, wheelOffset);
wheelOffset = mVehicleOwner->GetWheel1Offset();
mParticleEmitter->SetPartLocation(VehicleParticleEmitter::eLeftBackTire, wheelOffset);
MEMTRACK_POP_GROUP("GeometryVehicle");
}
//=============================================================================
// GeometryVehicle::GetHeadlightScale
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: float
//
//=============================================================================
float GeometryVehicle::GetHeadlightScale()
{
return mHeadLightScale;
}
//=============================================================================
// GeometryVehicle::SetHeadlightScale
//=============================================================================
// Description: Comment
//
// Parameters: ( float scale )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetHeadlightScale( float scale )
{
rAssert( 0.0f <= scale );
this->mHeadLightScale = scale;
}
//=============================================================================
// GeometryVehicle::AttachCollectible
//=============================================================================
// Description: Comment
//
// Parameters: ( StatePropCollectible* drawable )
//
// Return: bool
//
//=============================================================================
bool GeometryVehicle::AttachCollectible( StatePropCollectible* drawable )
{
bool wasAttached;
// We only have one slot for a collectible per vehicle
// check that this vehicle's slot is currently empty
if ( m_Collectible == NULL )
{
tRefCounted::Assign( m_Collectible, drawable );
rmt::Matrix identity;
identity.Identity();
drawable->SetTransform( identity );
m_Collectible->EnableCollisionVolume( false );
m_Collectible->SetState( 1 );
m_Collectible->RemoveFromDSG();
m_Collectible->EnableHudIcon( false );
m_Collectible->EnableCollisionTesting( false );
wasAttached = true;
}
else
{
wasAttached = false;
}
return wasAttached;
}
//=============================================================================
// GeometryVehicle::GetAttachedCollectible
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: StatePropCollectible
//
//=============================================================================
StatePropCollectible* GeometryVehicle::GetAttachedCollectible()
{
return m_Collectible;
}
//=============================================================================
// GeometryVehicle::DetachCollectible
//=============================================================================
// Description: Comment
//
// Parameters: ( const rmt::Vector& velocity, bool explode )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::DetachCollectible( const rmt::Vector& velocity, bool explode )
{
if ( m_Collectible )
{
m_Collectible->EnableHudIcon( false );
m_Collectible->EnableCollisionVolume( false );
m_Collectible->SetState( 0 );
sim::SimState* sim = m_Collectible->GetSimState();
if ( sim )
{
sim->ResetVelocities();
}
m_Collectible->AddToDSG();
// Lets set the transform to have no rotation, but position remains the same
rmt::Matrix transform;
transform.Identity();
transform.FillTranslate( m_CollectibleTransform.Row(3) + mVehicleOwner->GetPosition() );
m_Collectible->SetTransform(transform);
m_Collectible->Release();
if ( explode )
m_Collectible->Explode();
m_Collectible = NULL;
}
}
//=============================================================================
// GeometryVehicle::Display
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::Display()
{
BEGIN_PROFILE("GeometryVehicle::Display SetUp")
rmt::Vector pos = mVehicleOwner->GetPosition ();
rmt::Vector movement = pos - mLastPosition;
bool smokeFirst = true; // Used to fix draw order problem with the smoke and a vehicle's windshield.
tCamera* camera = p3d::context->GetView()->GetCamera();
rAssert( camera );
const rmt::Matrix& camTrans = camera->GetCameraToWorldMatrix();
if( mVehicleOwner->mVehicleType == VT_USER )
{
// Set the rotation vector on all the car's shaders.
// Base the rotation on how far the car has moved in the last known direction,
// so that the reflection map moves across the car when the car moves. -- jdy
//
bool fucked = false;
if ( mLastPosition.MagnitudeSqr() != 0.0f &&
( rmt::Fabs( movement.x ) > 1000.0f ||
rmt::Fabs( movement.y ) > 1000.0f ||
rmt::Fabs( movement.z ) > 1000.0f ) )
{
//TODO: What the hell is causing this?
//mVehicleOwner position and facing are fucked.
//We've moved too far. Clamp.
pos = mLastPosition;
fucked = true;
}
if ( !fucked )
{
float distance = movement.DotProduct( mVehicleOwner->GetFacing() );
rAssert( !rmt::IsNan( distance ) );
if( rmt::IsNan( distance ) )
{
distance = 0.0f;
}
if( rmt::Fabs( distance ) > 0.01f && rmt::Fabs( distance ) < 50.0f ) // Car must move at least 1 cm for an adjustment to be made
{
// Find the normal of the plane defined by the direction of movement and the camera facing.
//This will be the axis we rotate around.
// Note that the reflection map is relative to the object so we need to transform everything
//into the object's space.
rmt::Matrix carOri = mVehicleOwner->GetTransform();
carOri.Invert();
carOri.FillTranslate( rmt::Vector( 0.0f, 0.0f, 0.0f ) );
rmt::Vector camRelCar;
carOri.Transform( camTrans.Row( 2 ), &camRelCar );
rmt::Vector carRelMovement;
carOri.Transform( movement, &carRelMovement );
rmt::Vector axis;
float camMovementFacing = carRelMovement.Dot( camRelCar );
if( camMovementFacing < 0.0f )
{
axis.CrossProduct(camRelCar, carRelMovement);
}
else
{
axis.CrossProduct(carRelMovement, camRelCar);
}
// Check if the car is moving towards or away from the camera.
mCurEnvMapRotation += distance * 0.05f;
while( mCurEnvMapRotation >= rmt::PI_2 )
{
mCurEnvMapRotation -= rmt::PI_2;
}
while( mCurEnvMapRotation < 0.0f )
{
mCurEnvMapRotation += rmt::PI_2;
}
float mag;
float angle;
CartesianToPolar( axis.x, axis.y, &mag, &angle );
tShaderVectorBroadcast cbPos( PDDI_SP_ROTVEC, rmt::Vector( mCurEnvMapRotation, 0.0f, -angle ) );
int count = mCompositeDrawable->GetNumDrawableElement ();
for (int i = 0; i < count; i++)
{
tCompositeDrawable::DrawableElement* pElement = mCompositeDrawable->GetDrawableElement( i );
tDrawable* pDrawable = pElement->GetDrawable();
pDrawable->ProcessShaders( cbPos );
}
}
// Remember the position of the car for next time
//
mLastPosition = pos;
}
}
else
{
mLastPosition = pos;
}
rmt::Vector vehicleVelocity;
mVehicleOwner->GetVelocity( &vehicleVelocity );
if(mEngineParticleAttr.mType != ParticleEnum::eNull)
{
// Figure out which to draw first, the smoke or the car.
//We do this by transforming the SmokeOffset into world space and then dot product with the
//the camera's facing vector. If it is towards the camera we draw the smoke after the car.
//Crude, but quick and hopefully there won't be too many visual artifacts.
rmt::Matrix facing = mVehicleOwner->mTransform;
facing.FillTranslate( rmt::Vector( 0.0f, 0.0f, 0.0f ) );
rmt::Vector smoke = mVehicleOwner->GetSmokeOffset();
facing.Transform( smoke, &smoke );
float dot = smoke.DotProduct( camTrans.Row( 2 ) );
smokeFirst = dot > 0.6f;
if( ( mEngineParticleAttr.mType == ParticleEnum::eEngineSmokeLight ) ||
( mEngineParticleAttr.mType == ParticleEnum::eEngineSmokeMedium ) )
{
GetSparkleManager()->AddSmoke( mVehicleOwner->mTransform, mVehicleOwner->GetSmokeOffset(), movement, ( ( 0.4f - mVehicleOwner->GetVehicleLifePercentage( mVehicleOwner->mHitPoints ) ) * 2.5f ) );
}
else
{
// draw some particles
//mEngineParticleAttr.mVelocity = vehicleVelocity / 45.0f;
mParticleEmitter->Generate( VehicleParticleEmitter::eEngine,
mEngineParticleAttr, mVehicleOwner->mTransform);
// TODO - HOW ABOUT TRAFFIC - WITH THE ONE-TIME POOF!! DON'T DRAW CONTINUOUSLY
}
}
if ( mSpecialEffect != ParticleEnum::eNull )
{
ParticleAttributes attr;
attr.mType = mSpecialEffect;
mParticleEmitter->Generate( VehicleParticleEmitter::eSpecialEmitter,
attr, mVehicleOwner->mTransform);
}
// If this vehicle has tailpipe particles, generate them, always
// 31.25 (trails too long)
//mTailPipeParticleAttr.mVelocity = vehicleVelocity / 29.0f;
if ( mTailPipeParticleAttr.mType != ParticleEnum::eNull )
{
mParticleEmitter->Generate( VehicleParticleEmitter::eRightTailPipe,
mTailPipeParticleAttr, mVehicleOwner->mTransform );
mParticleEmitter->Generate( VehicleParticleEmitter::eLeftTailPipe,
mTailPipeParticleAttr, mVehicleOwner->mTransform );
}
if(mLeftWheelParticleAttr.mType != ParticleEnum::eNull)
{
mParticleEmitter->Generate( VehicleParticleEmitter::eLeftBackTire,
mLeftWheelParticleAttr, mVehicleOwner->mTransform);
}
if(mRightWheelParticleAttr.mType != ParticleEnum::eNull)
{
mParticleEmitter->Generate( VehicleParticleEmitter::eRightBackTire,
mRightWheelParticleAttr, mVehicleOwner->mTransform);
}
// if( mVehicleOwner->mVehicleType == VT_USER )
{
// Change the vehicle environment reflection
//depending on if it is interior or damaged.
unsigned char blend;
if( !mVehicleOwner->mInterior )
{
blend = m_EnvRef;
}
else
{
blend = m_EnvRef >> 2; // Quarter value for interior.
}
float damage = mVehicleOwner->GetVehicleLifePercentage(mVehicleOwner->mHitPoints);
damage = rmt::Clamp( ( damage * 0.75f ) + 0.25f, 0.0f, 1.0f );
blend = (unsigned char)( blend * damage );
tShaderColourBroadcast envBlend( PDDI_SP_ENVBLEND, tColour( blend, blend, blend ) );
int count = mCompositeDrawable->GetNumDrawableElement ();
for (int i = 0; i < count; i++)
{
tCompositeDrawable::DrawableElement* pElement = mCompositeDrawable->GetDrawableElement (i);
tDrawable* pDrawable = pElement->GetDrawable ();
pDrawable->ProcessShaders( envBlend );
}
}
END_PROFILE("GeometryVehicle::Display SetUp")
BEGIN_PROFILE("GeometryVehicle::Display Render")
if( mUsingTrafficModel )
{
if( mTrafficBodyDrawable != NULL )
{
if( mFadeAlpha != 255 )
{
mTrafficBodyDrawable->mFading = true;
}
else
{
mTrafficBodyDrawable->mFading = false;
}
mTrafficBodyDrawable->mFadeAlpha = mFadeAlpha;
}
if( mTrafficDoorDrawable != NULL )
{
if( mFadeAlpha != 255 )
{
mTrafficDoorDrawable->mFading = true;
}
else
{
mTrafficDoorDrawable->mFading = false;
}
mTrafficDoorDrawable->mFadeAlpha = mFadeAlpha;
}
// NOTE:
// This is a big cause for major grievances. It will force the blend mode of
// all the shaders of the compositedrawable's elements to be BLEND_ALPHA...
// bad news for billboards that are BLEND_NONE or BLEND_ADD...
//
tShaderIntBroadcast blendModeAlpha( PDDI_SP_BLENDMODE, PDDI_BLEND_ALPHA );
mCompositeDrawable->ProcessShaders( blendModeAlpha );
tShaderIntBroadcast emissiveAlpha( PDDI_SP_EMISSIVEALPHA, mFadeAlpha );
mCompositeDrawable->ProcessShaders( emissiveAlpha );
}
#ifdef RAD_WIN32
const tName& name = mVehicleOwner->GetNameObject();
if( name == "frink_v" )
{
float topSpeed = mVehicleOwner->GetTopSpeed();
float percentOfTopSpeed = vehicleVelocity.Magnitude() / topSpeed;
float refraction = percentOfTopSpeed;
refraction = rmt::Clamp( refraction, 0.0f, 1.0f );
int emissiveAlpha = (int)( 255.0f * (1.0f - refraction) );
tShaderIntBroadcast blendMode( PDDI_SP_BLENDMODE, PDDI_BLEND_ALPHA );
tShaderIntBroadcast emissive( PDDI_SP_EMISSIVEALPHA, emissiveAlpha );
int count = mCompositeDrawable->GetNumDrawableElement ();
for (int j = 0; j < count; j++)
{
tCompositeDrawable::DrawableElement* pElement = mCompositeDrawable->GetDrawableElement( j );
tDrawable* pDrawable = pElement->GetDrawable();
pDrawable->ProcessShaders( blendMode );
pDrawable->ProcessShaders( emissive );
}
// so since we just made EVERY SHADER alpha blend, we need to take
// care of the BBQGs (that need to be additive blended)
if( mFrinkArc )
{
tColour arcColour;
for( int j=0; j< NUM_FRINKARC_BBQS; j++ )
{
tBillboardQuad* bbq = mFrinkArc->GetQuad(j);
rAssert( bbq );
arcColour.Set(
rmt::Clamp( (int)(mOriginalFrinkArcColour[j].Red()*(1.0f - refraction)), 0, 255 ),
rmt::Clamp( (int)(mOriginalFrinkArcColour[j].Green()*(1.0f - refraction)), 0, 255 ),
rmt::Clamp( (int)(mOriginalFrinkArcColour[j].Blue()*(1.0f - refraction)), 0, 255 ),
rmt::Clamp( (int)(mOriginalFrinkArcColour[j].Alpha()*(1.0f - refraction)), 0, 255 )
);
bbq->SetColour( arcColour );
}
mFrinkArc->GetShader()->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_ADD );
}
}
#endif
tColour brakecolour;
// if not turning on brakelights, we need to take into account the daytime
// running lights settings
float dayReduce = 2.5f; // by default, if braking is on, we magnify this value
if( !mBrakeLightsOn )
{
dayReduce = mBrakeLightScale;
}
float fadeFactor = mFadeAlpha / 255.0f;
BEGIN_PROFILE("GeometryVehicle::Breaklights")
for( int i=0; i<NUM_BRAKELIGHT_BBQS; i++ )
{
if( mBrakeLights[i] != NULL )
{
brakecolour.Set(
rmt::Clamp( (int)(mOriginalBrakeLightColours[i].Red()*fadeFactor*dayReduce), 0, 255 ),
rmt::Clamp( (int)(mOriginalBrakeLightColours[i].Green()*fadeFactor*dayReduce), 0, 255 ),
rmt::Clamp( (int)(mOriginalBrakeLightColours[i].Blue()*fadeFactor*dayReduce), 0, 255 ),
rmt::Clamp( (int)(mOriginalBrakeLightColours[i].Alpha()*fadeFactor*dayReduce), 0, 255 )
);
for( int j=0; j<mBrakeLights[i]->GetNumQuads(); j++ )
{
tBillboardQuad* bbq = mBrakeLights[i]->GetQuad( j );
rAssert( bbq != NULL );
bbq->SetColour( brakecolour );
bbq->SetVisibility( mEnableLights );
}
// ProcessShaders screwed us by causing us to lose the additive blend for
// brakelights... We set it back.
mBrakeLights[i]->GetShader()->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_ADD );
}
}
END_PROFILE("GeometryVehicle::Breaklights")
BEGIN_PROFILE("GeometryVehicle::Headlights")
tColour headlightcolour;
int count = 0;
for( int i=0; i<VehicleCentral::NUM_HEADLIGHT_BBQGS; i++ )
{
if( GetVehicleCentral()->mHeadLights[i] != NULL )
{
for( int j=0; j<GetVehicleCentral()->mHeadLights[i]->GetNumQuads(); j++ )
{
headlightcolour.Set(
rmt::Clamp( (int)(GetVehicleCentral()->mOriginalHeadLightColours[count].Red()*fadeFactor*mHeadLightScale), 0, 255 ),
rmt::Clamp( (int)(GetVehicleCentral()->mOriginalHeadLightColours[count].Green()*fadeFactor*mHeadLightScale), 0, 255 ),
rmt::Clamp( (int)(GetVehicleCentral()->mOriginalHeadLightColours[count].Blue()*fadeFactor*mHeadLightScale), 0, 255 ),
rmt::Clamp( (int)(GetVehicleCentral()->mOriginalHeadLightColours[count].Alpha()*fadeFactor*mHeadLightScale), 0, 255 )
);
tBillboardQuad* bbq = GetVehicleCentral()->mHeadLights[i]->GetQuad( j );
rAssert( bbq != NULL );
bbq->SetColour( headlightcolour );
bbq->SetVisibility( mEnableLights );
count++;
}
// ProcessShaders screwed us by causing us to lose the additive blend
// We set it back.
GetVehicleCentral()->mHeadLights[i]->GetShader()->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_ADD );
}
}
END_PROFILE("GeometryVehicle::Headlights")
BEGIN_PROFILE("GeometryVehicle::Ghost")
// this means we're the ghost pirate ship... The glow must be ADDITIVE as well...
if( mHasGhostGlow )
{
count = 0;
tColour glowcolour;
for( int i=0; i<NUM_GHOSTGLOW_BBQGS; i++ )
{
if( mGhostGlows[i] != NULL )
{
for( int j=0; j<mGhostGlows[i]->GetNumQuads(); j++ )
{
glowcolour.Set(
rmt::Clamp( (int)(mOriginalGhostGlowColours[count].Red()*fadeFactor), 0, 255 ),
rmt::Clamp( (int)(mOriginalGhostGlowColours[count].Green()*fadeFactor), 0, 255 ),
rmt::Clamp( (int)(mOriginalGhostGlowColours[count].Blue()*fadeFactor), 0, 255 ),
rmt::Clamp( (int)(mOriginalGhostGlowColours[count].Alpha()*fadeFactor), 0, 255 )
);
tBillboardQuad* bbq = mGhostGlows[i]->GetQuad( j );
rAssert( bbq != NULL );
bbq->SetColour( glowcolour );
count++;
}
// ProcessShaders screwed us by causing us to lose the additive blend
// We set it back.
mGhostGlows[i]->GetShader()->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_ADD );
}
}
}
END_PROFILE("GeometryVehicle::Ghost")
// this means we're the ghost pirate ship... The glow must be ADDITIVE as well...
if( mHasNukeGlow )
{
count = 0;
tColour glowcolour;
for( int i=0; i<NUM_NUKEGLOW_BBQGS; i++ )
{
if( mNukeGlows[i] != NULL )
{
for( int j=0; j<mNukeGlows[i]->GetNumQuads(); j++ )
{
glowcolour.Set(
rmt::Clamp( (int)(mOriginalNukeGlowColours[count].Red()*fadeFactor), 0, 255 ),
rmt::Clamp( (int)(mOriginalNukeGlowColours[count].Green()*fadeFactor), 0, 255 ),
rmt::Clamp( (int)(mOriginalNukeGlowColours[count].Blue()*fadeFactor), 0, 255 ),
rmt::Clamp( (int)(mOriginalNukeGlowColours[count].Alpha()*fadeFactor), 0, 255 )
);
tBillboardQuad* bbq = mNukeGlows[i]->GetQuad( j );
rAssert( bbq != NULL );
bbq->SetColour( glowcolour );
count++;
}
// ProcessShaders screwed us by causing us to lose the additive blend
// We set it back.
mNukeGlows[i]->GetShader()->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_ADD );
}
}
}
// fade roof...
if( mRoofShader )
{
if( mRoofAlpha > mRoofTargetAlpha )
{
mRoofAlpha--;
}
else if( mRoofAlpha < mRoofTargetAlpha )
{
mRoofAlpha++;
}
//mRoofShader->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_ALPHA );
mRoofShader->SetInt( PDDI_SP_EMISSIVEALPHA, mRoofAlpha );
if( mRoofOpacShape && mRoofAlphaShape )
{
if( mRoofAlpha == 255 )
{
mRoofOpacShape->SetVisibility( true );
mRoofAlphaShape->SetVisibility( false );
}
else
{
mRoofOpacShape->SetVisibility( false );
mRoofAlphaShape->SetVisibility( true );
}
}
}
BEGIN_PROFILE("GeometryVehicle::CompDraw->Disp")
if( smokeFirst )
{
GetSparkleManager()->Render( Sparkle::SRM_SortedOnly );
}
if( sbDrawVehicle )
{
mCompositeDrawable->Display();
}
if( !smokeFirst )
{
GetSparkleManager()->Render( Sparkle::SRM_SortedOnly );
}
if( m_Collectible )
{
rmt::Matrix transform = mVehicleOwner->GetTransform();
p3d::stack->PushMultiply( transform );
p3d::stack->PushMultiply( m_CollectibleTransform );
m_Collectible->Display();
p3d::stack->Pop();
p3d::stack->Pop();
}
END_PROFILE("GeometryVehicle::CompDraw->Disp")
END_PROFILE("GeometryVehicle::Display Render")
}
//=============================================================================
// GeometryVehicle::DisplaySkids
//=============================================================================
// Description: Comment
//
// Parameters: void GeometryVehicle::DisplaySkids(int wheel
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetSkidValues(int wheel, float intensity, rmt::Vector& groundPlaneNormal, eTerrainType terrainType )
{
// if this got called, intensity is > 0.0
if(mSkidMarkGenerator)// && mDrawSkids) // test here though this should only be getting called for vehicles that have it... ie. VT_USER
{
/*
struct SkidData
{
// Direction that the vehicle is moving
rmt::Vector velocityDirection;
// Orientation and position of the vehicle
rmt::Matrix transform;
// Other data?????
float intensity; // 1 most intense, 0 nonexistent skid
};
*/
rmt::Vector offset = mVehicleOwner->mSuspensionRestPoints[wheel];
offset.y -= mVehicleOwner->mWheels[wheel]->mRadius;
offset.y += mVehicleOwner->mWheels[wheel]->mYOffset; // hmmm....
//if(mVehicleOwner->mWheels[wheel]->mYOffset != 0.0f)
//{
// int stophere = 1;
//}
mSkidMarkGenerator->SetWheelOffset(wheel, offset); // need to do this everyframe
SkidMarkGenerator::SkidData sd;
sd.intensity = intensity;
sd.transform = mVehicleOwner->mTransform;
sd.terrainType = terrainType;
sd.groundPlaneNormal = groundPlaneNormal;
rmt::Vector velocityDir = mVehicleOwner->mVelocityCM;
velocityDir.NormalizeSafe();
// TODO
// Michael - would this blow up if I passed in 0,0,0 ?
sd.velocityDirection = velocityDir;
mSkidMarkGenerator->GenerateSkid(wheel, sd);
}
}
//=============================================================================
// GeometryVehicle::DisplaySkids
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::UpdateSkids()
{
if(mSkidMarkGenerator)
{
mSkidMarkGenerator->Update();
}
}
//////////////////////////////////////////////////////////////////////////
int GeometryVehicle::CastsShadow()
{
return 2;
}
//------------------------------------------------------------------------
void GeometryVehicle::DisplayShadow( BlobShadowParams* BlobParams )
{
BEGIN_PROFILE("GeometryVehicle::DisplayShadow")
rAssert(BlobParams);
tColour OutsideColour, insideColour;
// Hack for brightly colored shadows for special game mode
rmt::Vector camPos;
tCamera* camera = p3d::context->GetView()->GetCamera();
rAssert(camera);
camera->GetWorldPosition( &camPos );
camPos.Sub( BlobParams->GroundPos );
float yOffset = 0.0f; // Move the shadow up a bit with distance to avoid Z chew.
if( ::GetGameplayManager()->GetGameType() == GameplayManager::GT_SUPERSPRINT )
{
rAssert( mVehicleOwner );
Avatar* avatar = ::GetAvatarManager()->GetAvatarForVehicle( mVehicleOwner );
OutsideColour.Set( 0, 0, 0, 0 ); // black outline
insideColour.Set( 0, 0, 0 ); // default black if no Avatar
if( avatar )
{
int id = avatar->GetPlayerId();
if ( this->mVehicleOwner->mNumTurbos > 0 )
{
insideColour = ::GetGameplayManager()->GetControllerColour( id );
}
else
{
insideColour = tColour( 0, 0, 0 );
}
}
}
else
{
// Camera culling.
float camDirDot = camPos.DotProduct( camera->GetCameraToWorldMatrix().Row( 2 ) );
// Note that the camPos vector is towards the camera so the camDirDot will be negative when the camera is facing
//the object. So if it's positive then we can assume it's behind the camera.
if( camDirDot > 0.0f )
{
END_PROFILE("GeometryVehicle::DisplayShadow")
return;
}
// Blobby shadow for vehicle.
OutsideColour.Set( 255, 255, 255, 255 );
const int Inside = 128;
float fadeFactor = 1.0f;
if( mVehicleOwner->mVehicleType == VT_TRAFFIC &&
mFadeAlpha != 255 )
{
fadeFactor = 1.0f - (mFadeAlpha/255.0f);
}
else
{
fadeFactor = 1.0f - BlobParams->ShadowAlpha;
}
// DistanceAlpha: over 30 is 1, under 10 is 0, linear between.
float distanceAlpha = rmt::Clamp((camPos.Magnitude() - 10.0f) * 0.05f, 0.0f, 1.0f);
fadeFactor *= 1.0f - distanceAlpha;
int c = rmt::Clamp( int( Inside + ( 255 - Inside ) * fadeFactor ), 0, 255 );
if( c == 255)
{
return;
}
insideColour.Set( c, c, c, c );
yOffset = MAX_Y_OFFSET * distanceAlpha;
}
const int NumPoints = 6;
const float BlobLength = 2.2f;
const float BlobWidth = 1.2f;
const float BlobCant = 0.2f;
const float BlobFade = 0.4f;
static float Points[ NumPoints ][ 2 ];
static float Fades[ NumPoints ][ 2 ];
static bool DoOnce = true;
if( DoOnce )
{
DoOnce = false;
/* Here are the points we'll use for the car:
....----0
. 1
. |
. |
. + 2
. 3
. |
. 4
....----5
We'll mirror the blob along the Z axis.
The shadow point adjusts work like this:
0 - affects points 0 and 1, the top corner.
1 - affects point 2, the position for the top division.
2 - affects point 3, the position for the bottom division.
3 - affects point 4 and 5, the bottom corner.
*/
Points[ 0 ][ 0 ] = BlobWidth - BlobCant;
Points[ 0 ][ 1 ] = BlobLength;
Points[ 1 ][ 0 ] = BlobWidth;
Points[ 1 ][ 1 ] = BlobLength - BlobCant;
Points[ 2 ][ 0 ] = BlobWidth;
Points[ 2 ][ 1 ] = BlobCant;
Points[ 3 ][ 0 ] = BlobWidth;
Points[ 3 ][ 1 ] = -BlobCant;
Points[ 4 ][ 0 ] = BlobWidth;
Points[ 4 ][ 1 ] = -BlobLength + BlobCant;
Points[ 5 ][ 0 ] = BlobWidth - BlobCant;
Points[ 5 ][ 1 ] = -BlobLength;
Fades[ 0 ][ 0 ] = 0.5f * BlobFade; // Sin( 30 )
Fades[ 0 ][ 1 ] = 0.866f * BlobFade; // Cos( 30 )
Fades[ 1 ][ 0 ] = 0.866f * BlobFade; // Sin( 60 )
Fades[ 1 ][ 1 ] = 0.5f * BlobFade; // Cos( 60 )
Fades[ 2 ][ 0 ] = 0.866f * BlobFade; // Sin( 60 )
Fades[ 2 ][ 1 ] = 0.5f * BlobFade; // Cos( 60 )
Fades[ 3 ][ 0 ] = 0.866f * BlobFade; // Sin( 60 )
Fades[ 3 ][ 1 ] = 0.5f * BlobFade; // Cos( 60 )
Fades[ 4 ][ 0 ] = 0.866f * BlobFade; // Sin( 120 )
Fades[ 4 ][ 1 ] = -0.5f * BlobFade; // Cos( 120 )
Fades[ 5 ][ 0 ] = 0.5f * BlobFade; // Sin( 150 )
Fades[ 5 ][ 1 ] = -0.866f * BlobFade; // Cos( 150 )
}
camPos.Normalize();
rmt::Matrix transform;
transform.Identity();
transform.FillTranslate( BlobParams->GroundPos );
transform.FillHeading( BlobParams->GroundNormal, BlobParams->ShadowFacing );
transform.Row( 3 ).Add( camPos );
transform.Row(3).y += yOffset;
p3d::stack->PushMultiply( transform );
pddiShader* blobShader = BootupContext::GetInstance()->GetSharedShader();
if( ::GetGameplayManager()->GetGameType() == GameplayManager::GT_SUPERSPRINT )
{
blobShader->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_NONE );
}
else
{
blobShader->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_MODULATE );
}
blobShader->SetInt( PDDI_SP_ISLIT, 0 );
blobShader->SetInt( PDDI_SP_ALPHATEST, 0 );
blobShader->SetInt( PDDI_SP_SHADEMODE, PDDI_SHADE_GOURAUD );
pddiPrimStream* blob = p3d::pddi->BeginPrims( blobShader, PDDI_PRIM_TRIANGLES, PDDI_V_C, 6 * NumPoints );
for( int i = 0; i < NumPoints * 2; ++i )
{
int index = i;
int nextIndex = ( i + 1 ) % ( NumPoints * 2 );
int mirrorX = int( ( index * ( 1.0f / NumPoints ) ) );
int nextMirrorX = int( ( nextIndex * ( 1.0f / NumPoints ) ) );
index %= NumPoints;
nextIndex %= NumPoints;
index = rmt::Abs( ( mirrorX * 5 ) - index );
nextIndex = rmt::Abs( ( nextMirrorX * 5 ) - nextIndex );
mirrorX = 1 - ( mirrorX * 2 );
nextMirrorX = 1 - ( nextMirrorX * 2 );
int adjust = rmt::Clamp( index - 1, 0, NumPoints - 3 );
int nextAdjust = rmt::Clamp( nextIndex - 1, 0, NumPoints - 3 );
float x, y;
blob->Colour( insideColour );
blob->Coord( 0.0f, 0.0f, 0.0f );
x = ( Points[ nextIndex ][ 0 ] + mShadowPointAdjustments[ nextAdjust ][ 0 ] ) * BlobParams->ShadowScale;
y = ( Points[ nextIndex ][ 1 ] + mShadowPointAdjustments[ nextAdjust ][ 1 ] ) * BlobParams->ShadowScale;
blob->Colour( insideColour );
blob->Coord( x * nextMirrorX, y, 0.0f );
x = ( Points[ index ][ 0 ] + mShadowPointAdjustments[ adjust ][ 0 ] ) * BlobParams->ShadowScale;
y = ( Points[ index ][ 1 ] + mShadowPointAdjustments[ adjust ][ 1 ] ) * BlobParams->ShadowScale;
blob->Colour( insideColour );
blob->Coord( x * mirrorX, y, 0.0f );
}
p3d::pddi->EndPrims( blob );
// How the soft edge.
blob = p3d::pddi->BeginPrims( blobShader, PDDI_PRIM_TRISTRIP, PDDI_V_C, ( ( 2 * NumPoints ) + 1 ) * 2 );
for( int i = 0; i <= NumPoints * 2; ++i )
{
int index = i;
int mirrorX = int( ( index * ( 1.0f / NumPoints ) ) ) % 2;
index %= NumPoints;
index = rmt::Abs( ( mirrorX * 5 ) - index );
mirrorX = 1 - ( mirrorX * 2 );
int adjust = rmt::Clamp( index - 1, 0, NumPoints - 3 );
float inX, inY;
float outX, outY;
inX = ( Points[ index ][ 0 ] + mShadowPointAdjustments[ adjust ][ 0 ] ) * BlobParams->ShadowScale;
inY = ( Points[ index ][ 1 ] + mShadowPointAdjustments[ adjust ][ 1 ] ) * BlobParams->ShadowScale;
inX *= mirrorX;
outX = inX + ( Fades[ index ][ 0 ] * mirrorX * BlobParams->ShadowScale );
outY = inY + ( Fades[ index ][ 1 ] * BlobParams->ShadowScale );
blob->Colour( OutsideColour );
blob->Coord( outX, outY, 0.0f );
blob->Colour( insideColour );
blob->Coord( inX, inY, 0.0f );
}
p3d::pddi->EndPrims( blob );
p3d::stack->Pop();
END_PROFILE("GeometryVehicle::DisplayShadow")
}
//=============================================================================
// GeometryVehicle::DisplayLights
//=============================================================================
// Description: Comment
//
// Parameters: rmt::Vector& GroundPos - Position of car.
// rmt::Vector& GroundNormal - Ground normal at car position.
// rmt::Vector& GroundUp - Up direction at ground position
//
// Return: void
//
//=============================================================================
void GeometryVehicle::DisplayLights( const HeadLightParams& LightParams )
{
BEGIN_PROFILE("GeometryVehicle::DisplayLights")
const int NumPoints = 20;
const float LightXSize = 1.0f;
const float LightZSize = 0.125f;
const float FadeSize = 0.3f;
const float LightLength = NumPoints * LightZSize;
static bool DoOnce = true;
static float PointsX[ NumPoints ];
static tColour Colours[ NumPoints ];
static float FadePoints[ NumPoints ][ 2 ];
const tColour Colour( 65, 70, 46 );
const tColour Black( 0, 0, 0 );
if( DoOnce )
{
DoOnce = false;
// The light cone is made of of two tri strips one is the inner bright parabula
// which fades out with distance, and the other is the soft edge around it.
for( int i = 0; i < NumPoints; ++i )
{
float z = ( i + 1 ) * LightZSize;
float x = rmt::Sqrt( ( i + 1 ) * 0.5f );
PointsX[ i ] = x;
z -= LightLength;
float mag = rmt::Sqrt( ( x * x ) + ( z * z ) );
mag = ( ( mag != 0.0f ) ? 1.0f / mag : 0.0f ) * FadeSize;
x *= mag;
z *= mag;
FadePoints[ i ][ 0 ] = x;
FadePoints[ i ][ 1 ] = z;
float colourScale = ( 1.0f - ( (float)i / (float)NumPoints ) );
int red = rmt::Clamp( int( Colour.Red() * colourScale ), 0, 255 );
int green = rmt::Clamp( int( Colour.Green() * colourScale ), 0, 255 );
int blue = rmt::Clamp( int( Colour.Blue() * colourScale ), 0, 255 );
Colours[ i ].Set( red, green, blue );
}
// Now calculate the offset for the fade points.
}
float xScale = 1.0f;
float zScale = 1.0f;
float scale = 1.0f;
scale = LightParams.LightReach;
float offset = ( 1.0f - LightParams.LightReach ) * LightLength;
rmt::Vector camPos;
rmt::Vector groundPos = LightParams.GroundPos;
groundPos.ScaleAdd( offset, LightParams.VehicleHeading );
tCamera* camera = p3d::context->GetView()->GetCamera();
rAssert( camera );
camera->GetWorldPosition( &camPos );
camPos.Sub( groundPos );
float cameraToLight = camPos.Magnitude();
camPos.Normalize();
rmt::Matrix toCamera;
toCamera.Identity();
toCamera.FillTranslate( camPos );
rmt::Matrix transform;
transform.Identity();
transform.FillTranslate( groundPos );
transform.FillHeading( LightParams.GroundNormal, LightParams.VehicleHeading );
transform.Mult( toCamera );
p3d::stack->PushMultiply( transform );
float dist = LightParams.VehicleHeading.Dot( LightParams.GroundNormal );
rmt::Vector groundByVehicle( LightParams.GroundNormal );
if( dist != 0.0f )
{
groundByVehicle.ScaleAdd( -dist, LightParams.VehicleHeading );
groundByVehicle.Normalize();
}
float vehicleRoll = groundByVehicle.Dot( LightParams.VehicleUp );
vehicleRoll *= vehicleRoll;
#ifdef RAD_DEBUG
if( this->mVehicleOwner->mVehicleType != VT_TRAFFIC )
{
char text[128];
sprintf( text, "Ground to vehicle ratio: %.4f", vehicleRoll );
DebugInfo::GetInstance()->Push( "Vehicle lights" );
DebugInfo::GetInstance()->AddScreenText( text );
DebugInfo::GetInstance()->Pop();
}
#endif
xScale *= scale * LightXSize * vehicleRoll;
zScale *= scale * LightZSize;
pddiShader* lightShader = BootupContext::GetInstance()->GetSharedShader();
lightShader->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_ADD );
lightShader->SetInt( PDDI_SP_ISLIT, 0 );
lightShader->SetInt( PDDI_SP_ALPHATEST, 0 );
lightShader->SetInt( PDDI_SP_SHADEMODE, PDDI_SHADE_GOURAUD );
// Center light.
pddiPrimStream* light = p3d::pddi->BeginPrims( lightShader, PDDI_PRIM_TRISTRIP, PDDI_V_C, ( NumPoints << 1 ) + 1 );
light->Colour( Colour );
light->Coord( 0.0f, 0.0f, 0.0f );
for( int i = 0; i < NumPoints; ++i )
{
float inX = PointsX[ i ] * xScale;
float inZ = ( i + 1 ) * zScale;
light->Colour( Colours[ i ] );
light->Coord( inX, inZ, 0.0f );
light->Colour( Colours[ i ] );
light->Coord( -inX, inZ, 0.0f );
}
p3d::pddi->EndPrims( light );
// Fade on the negative side.
pddiPrimStream* nFade = p3d::pddi->BeginPrims( lightShader, PDDI_PRIM_TRISTRIP, PDDI_V_C, ( NumPoints + 1 ) << 1 );
nFade->Colour( Black );
nFade->Coord( 0.0f, -FadeSize, 0.0f );
nFade->Colour( Colour);
nFade->Coord( 0.0f, 0.0f, 0.0f );
for( int i = 0; i < NumPoints; ++i )
{
float inX = -PointsX[ i ] * xScale;
float inZ = ( i + 1 ) * zScale;
float outX = inX - FadePoints[ i ][ 0 ];
float outZ = inZ + FadePoints[ i ][ 1 ];
nFade->Colour( Black );
nFade->Coord( outX, outZ, 0.0f );
nFade->Colour( Colours[ i ] );
nFade->Coord( inX, inZ, 0.0f );
}
p3d::pddi->EndPrims( nFade );
// Fade on the positive side.
pddiPrimStream* pFade = p3d::pddi->BeginPrims( lightShader, PDDI_PRIM_TRISTRIP, PDDI_V_C, ( NumPoints + 1 ) << 1 );
pFade->Colour( Colour);
pFade->Coord( 0.0f, 0.0f, 0.0f );
pFade->Colour( Black );
pFade->Coord( 0.0f, -FadeSize, 0.0f );
for( int i = 0; i < NumPoints; ++i )
{
float inX = PointsX[ i ] * xScale;
float inZ = ( i + 1 ) * zScale;
float outX = inX + FadePoints[ i ][ 0 ];
float outZ = inZ + FadePoints[ i ][ 1 ];
pFade->Colour( Colours[ i ] );
pFade->Coord( inX, inZ, 0.0f );
pFade->Colour( Black );
pFade->Coord( outX, outZ, 0.0f );
}
p3d::pddi->EndPrims( pFade );
p3d::stack->Pop();
END_PROFILE("GeometryVehicle::DisplayLights")
}
//=============================================================================
// GeometryVehicle::FindAndTurnOffWheels
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FindAndTurnOffWheels()
{
int i;
for(i = 0; i < 4; i++)
{
tPose* p3dPose = mCompositeDrawable->GetPose();
char buffy[128];
sprintf(buffy, "w%d", i);
int jointIndex = p3dPose->FindJointIndex(buffy);
int j;
for(j = 0; j < mCompositeDrawable->GetNumDrawableElement(); j++)
{
tCompositeDrawable::DrawablePropElement* prop = (tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(j));
if(prop && prop->GetPoseIndex() == jointIndex)
{
prop->SetVisibility(false);
}
}
}
}
//=============================================================================
// GeometryVehicle::FindAndTurnOffFrontWheelsOnly
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FindAndTurnOffFrontWheelsOnly()
{
int i;
for(i = 2; i < 4; i++)
{
tPose* p3dPose = mCompositeDrawable->GetPose();
char buffy[128];
sprintf(buffy, "w%d", i);
int jointIndex = p3dPose->FindJointIndex(buffy);
int j;
for(j = 0; j < mCompositeDrawable->GetNumDrawableElement(); j++)
{
tCompositeDrawable::DrawablePropElement* prop = (tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(j));
if(prop && prop->GetPoseIndex() == jointIndex)
{
prop->SetVisibility(false);
}
}
}
}
//=============================================================================
// GeometryVehicle::FindHeadLightBillboardJoints
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FindHeadLightBillboardJoints()
{
// grab the pose
tPose* p3dPose = mCompositeDrawable->GetPose();
// grab the headlight bbqgs from common section
// put in left headlight
char buffy[128];
sprintf( buffy, "hll" );
int left = p3dPose->FindJointIndex( buffy );
if( left >= 0 )
{
for( int i=0; i<VehicleCentral::NUM_HEADLIGHT_BBQGS; i++ )
{
rAssert( GetVehicleCentral()->mHeadLights[i] );
mCompositeDrawable->AddProp( GetVehicleCentral()->mHeadLights[i], left );
}
}
// now the right side
sprintf( buffy, "hlr" );
int right = p3dPose->FindJointIndex( buffy );
if( right >= 0 )
{
for( int i=0; i<VehicleCentral::NUM_HEADLIGHT_BBQGS; i++ )
{
rAssert( GetVehicleCentral()->mHeadLights[i] );
mCompositeDrawable->AddProp( GetVehicleCentral()->mHeadLights[i], right );
}
}
}
//=============================================================================
// GeometryVehicle::FindBrakeLightBillboardJoints
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FindBrakeLightBillboardJoints()
{
int i;
for(i = 1; i < 5; i++) // 'cause Kevin starts counting at 1, not 0
{
tPose* p3dPose = mCompositeDrawable->GetPose();
char buffy[128];
sprintf(buffy, "brake%d", i);
int jointIndex = p3dPose->FindJointIndex(buffy);
int j;
for(j = 0; j < mCompositeDrawable->GetNumDrawableElement(); j++)
{
tCompositeDrawable::DrawablePropElement* prop = (tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(j));
if(prop && prop->GetPoseIndex() == jointIndex)
{
//mBrakeLights[i - 1] = (tBillboardQuadGroup*) prop->GetDrawable();
tBillboardQuadGroup* bbqg = dynamic_cast<tBillboardQuadGroup*>( prop->GetDrawable() );
if( bbqg != NULL )
{
tRefCounted::Assign( mBrakeLights[i - 1], bbqg );
// the structure for storing the original colors only supports 1 quad per quadgroup
rAssert( mBrakeLights[i-1]->GetNumQuads() == 1 );
tBillboardQuad* quad = mBrakeLights[i-1]->GetQuad( 0 );
mOriginalBrakeLightColours[i-1] = quad->GetColour();
mBrakeLightJoints[i - 1] = jointIndex;
}
}
}
}
for(i = 1; i < 5; i++) // 'cause Kevin starts counting at 1, not 0
{
tPose* p3dPose = mCompositeDrawable->GetPose();
char buffy[128];
sprintf(buffy, "rev%d", i);
int jointIndex = p3dPose->FindJointIndex(buffy);
int j;
for(j = 0; j < mCompositeDrawable->GetNumDrawableElement(); j++)
{
tCompositeDrawable::DrawablePropElement* prop = (tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(j));
if(prop && prop->GetPoseIndex() == jointIndex)
{
prop->SetVisibility(false);
mReverseLightJoints[i - 1] = jointIndex;
}
}
}
}
//=============================================================================
// GeometryVehicle::FindGhostGlowBillboards
//=============================================================================
// Description: Comment
//
// Parameters: ( const char* model )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FindGhostGlowBillboards( const char* model )
{
int count = 0;
for( int i = 0; i<NUM_GHOSTGLOW_BBQGS; i++ )
{
char name[64];
sprintf( name, "%sGlow%dShape", model, i+1 );
tUID test = tEntity::MakeUID( name );
for( int j=0; j<mCompositeDrawable->GetNumDrawableElement(); j++ )
{
tCompositeDrawable::DrawablePropElement* prop =
(tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(j));
if( prop && prop->GetUID() == test )
{
tBillboardQuadGroup* bbqg = dynamic_cast<tBillboardQuadGroup*>( prop->GetDrawable() );
if( bbqg != NULL )
{
tRefCounted::Assign( mGhostGlows[i], bbqg );
for( int j=0; j<mGhostGlows[i]->GetNumQuads(); j++ )
{
tBillboardQuad* quad = mGhostGlows[i]->GetQuad( j );
rAssert( quad );
mOriginalGhostGlowColours[count] = quad->GetColour();
count++;
}
}
}
}
}
}
//=============================================================================
// GeometryVehicle::FindNukeGlowBillboards
//=============================================================================
// Description: Comment
//
// Parameters: ( const char* model )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FindNukeGlowBillboards( const char* model )
{
int count = 0;
for( int i = 0; i<NUM_NUKEGLOW_BBQGS; i++ )
{
char name[64];
sprintf( name, "nucGlowGroupShape" );
tUID test = tEntity::MakeUID( name );
for( int j=0; j<mCompositeDrawable->GetNumDrawableElement(); j++ )
{
tCompositeDrawable::DrawablePropElement* prop =
(tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(j));
if( prop && prop->GetUID() == test )
{
tBillboardQuadGroup* bbqg = dynamic_cast<tBillboardQuadGroup*>( prop->GetDrawable() );
if( bbqg != NULL )
{
tRefCounted::Assign( mNukeGlows[i], bbqg );
for( int j=0; j<mNukeGlows[i]->GetNumQuads(); j++ )
{
tBillboardQuad* quad = mNukeGlows[i]->GetQuad( j );
rAssert( quad );
mOriginalNukeGlowColours[count] = quad->GetColour();
count++;
}
}
}
}
}
}
//=============================================================================
// GeometryVehicle::SetCollectibleHardpointPosition
//=============================================================================
// Description: Comment
//
// Parameters: ( const rmt::Vector& position )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetCollectibleHardpointPosition( const rmt::Vector& position )
{
// Use the default orientation, but replace the translational compoonent
m_CollectibleTransform = DEFAULT_COLLECTIBLE_TRANSFORM;
m_CollectibleTransform.FillTranslate( position );
}
//=============================================================================
// GeometryVehicle::SetCollectibleHardpointTransform
//=============================================================================
// Description: Comment
//
// Parameters: ( float rotx ,float roty ,float rotz, const rmt::Vector& position )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetCollectibleHardpointTransform( float rotx ,float roty ,float rotz,
const rmt::Vector& position )
{
m_CollectibleTransform.Identity();
m_CollectibleTransform.FillRotateXYZ( rotx, roty, rotz );
m_CollectibleTransform.FillTranslate( position );
}
//=============================================================================
// GeometryVehicle::ShowBrakeLights
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::ShowBrakeLights()
{
mBrakeLightsOn = true;
/*
int i;
for(i = 0; i < 4; i++)
{
if(mBrakeLightJoints[i] != -1)
{
this->HideFlappingPiece(mBrakeLightJoints[i], false);
}
}
*/
}
//=============================================================================
// GeometryVehicle::HideBrakeLights
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::HideBrakeLights()
{
mBrakeLightsOn = false;
/*
int i;
for(i = 0; i < 4; i++)
{
if(mBrakeLightJoints[i] != -1)
{
this->HideFlappingPiece(mBrakeLightJoints[i], true);
}
}
*/
}
//=============================================================================
// GeometryVehicle::ShowReverseLights
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::ShowReverseLights()
{
int i;
for(i = 0; i < 4; i++)
{
if(mReverseLightJoints[i] != -1)
{
this->HideFlappingPiece(mReverseLightJoints[i], false);
}
}
}
//=============================================================================
// GeometryVehicle::HideReverseLights
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void GeometryVehicle::HideReverseLights()
{
int i;
for(i = 0; i < 4; i++)
{
if(mReverseLightJoints[i] != -1)
{
this->HideFlappingPiece(mReverseLightJoints[i], true);
}
}
}
//=============================================================================
// GeometryVehicle::GetArt
//=============================================================================
// Description: Comment
//
// Parameters: (char* name)
//
// Return: bool
//
//=============================================================================
bool GeometryVehicle::GetArt( const char* name)
{
// expect a composite drawable named "name" in the file.
tCompositeDrawable* master = p3d::find<tCompositeDrawable>(name);
rTuneAssert( master != NULL );
#ifndef FINAL
if (master == NULL)
{
char buffer [255];
sprintf(buffer,"Script ERROR: Can't Find Vehicle:%s Make sure you loaded it!\n",name);
rTuneAssertMsg(0,buffer);
}
#endif
mCompositeDrawable = master->Clone();
//mCompositeDrawable = p3d::find<tCompositeDrawable>(name);
rAssert(mCompositeDrawable);
mCompositeDrawable->AddRef();
{
char controllerName[255];
strcpy( controllerName, "EFX_" );
strcat( controllerName, name );
strcat( controllerName, "velocpartSystShape" );
tEffectController* particleSysController = p3d::find < tEffectController >( controllerName );
if ( particleSysController != NULL )
{
tEffect* effect = particleSysController->GetEffect();
rAssert( dynamic_cast< tParticleSystem* >( effect ) != NULL );
tParticleSystem* particleSystem = static_cast< tParticleSystem* > ( effect );
mVariableEmissionParticleSystem = particleSystem;
mVariableEmissionParticleSystem->AddRef();
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Traffic "swatches" (in a sense)
// Any car using traffic model (regardless of whether they are in fact traffic cars)
// Must contain a trafficbodydrawable so that it will render correctly (due to fading
// and swatch tricks done for traffic models).
if( IsTrafficModel() )
{
mUsingTrafficModel = true;
// Grab the shader to be used for swatches
char shadername[64];
sprintf( shadername, "%s_m", name );
tShader* bodyShade = p3d::find<tShader>( shadername );
// Find the body prop in compositedrawable's list of elements by name
// e.g. compactAShape
char propname[64];
sprintf( propname, "%sShape", name );
tUID uid = tEntity::MakeUID(propname);
int poseIndex = -1;
tCompositeDrawable::DrawablePropElement* body = NULL;
for( int i=0; i<mCompositeDrawable->GetNumDrawableElement(); i++ )
{
body = (tCompositeDrawable::DrawablePropElement*) (mCompositeDrawable->GetDrawableElement(i));
if( body != NULL )
{
if( body->GetDrawable()->GetUID() == uid )
{
poseIndex = i;
break;
}
}
}
if( poseIndex > -1 && body != NULL )
{
// create a trafficbodydrawable
tRefCounted::Assign( mTrafficBodyDrawable, new TrafficBodyDrawable() );
rAssert( mTrafficBodyDrawable );
// store away the body prop's old drawable
rAssert( body->GetDrawable() != NULL );
mTrafficBodyDrawable->SetBodyPropDrawable( body->GetDrawable() );
// Grab the shader for the vehicle chassis and store it too
if( bodyShade == NULL )
{
rDebugPrintf( "Warning: Couldn't find shader \"%s\" for traffic vehicle %s. Chassis color randomization will not apply to this vehicle.\n",
shadername, name );
}
mTrafficBodyDrawable->SetBodyShader( bodyShade );
// make the new traffic body drawable the drawable for the body prop
body->SetDrawable( mTrafficBodyDrawable );
}
else
{
rDebugPrintf( "Warning: Couldn't find tCompositeDrawable prop \"%s\" for traffic vehicle %s. Chassis color randomization will not apply to this vehicle.\n",
propname, name );
}
// Find the door prop in compositedrawable's list of elements by name
// e.g. compactAShape
sprintf( propname, "doorPRotShape" );
uid = tEntity::MakeUID(propname);
poseIndex = -1;
body = NULL;
for( int i=0; i<mCompositeDrawable->GetNumDrawableElement(); i++ )
{
body = (tCompositeDrawable::DrawablePropElement*)
(mCompositeDrawable->GetDrawableElement(i));
if( body != NULL )
{
if( body->GetDrawable()->GetUID() == uid )
{
poseIndex = i;
break;
}
}
}
if( poseIndex > -1 && body != NULL )
{
// create a trafficbodydrawable
tRefCounted::Assign( mTrafficDoorDrawable, new TrafficBodyDrawable() );
rAssert( mTrafficDoorDrawable );
// store away the body prop's old drawable
rAssert( body->GetDrawable() != NULL );
mTrafficDoorDrawable->SetBodyPropDrawable( body->GetDrawable() );
// Grab the shader for the vehicle chassis and store it too
if( bodyShade == NULL )
{
rDebugPrintf( "Warning: Couldn't find shader \"%s\" for traffic vehicle %s. Chassis color randomization will not apply to this vehicle.\n",
shadername, name );
}
mTrafficDoorDrawable->SetBodyShader( bodyShade );
// make the new traffic body drawable the drawable for the body prop
body->SetDrawable( mTrafficDoorDrawable );
}
else
{
rDebugPrintf( "Warning: Couldn't find tCompositeDrawable prop \"%s\" for traffic vehicle %s. Chassis color randomization will not apply to this vehicle.\n",
propname, name );
}
}
// is this ok for release?
// I think so
// little hack just for frink
// no wheels
if( strcmp(name, "frink_v") == 0 || strcmp(name, "honor_v") == 0 || strcmp(name, "hbike_v") == 0 ||
strcmp(name, "witchcar") == 0 || strcmp(name, "ship") == 0 || strcmp(name, "mono_v") == 0 )
{
FindAndTurnOffWheels();
}
if( strcmp( name, "frink_v" ) == 0 )
{
int count = 0;
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "special_m" ) ); //must be first
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vInt_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vTrim_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vDoorPNorm_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vExtras_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vHoodNorm_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vVent_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vcoil_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "BottomA_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vDoorDNorm_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "engine_m" ) );
tRefCounted::Assign( mRefractionShader[ count++ ], p3d::find< tShader >( "frink_vBackNorm_m" ) );
int size = count;
int i;
for( i = 0; i < size; ++i )
{
rAssert( mRefractionShader[ i ] != NULL );
}
#ifdef RAD_WIN32
tPose* p3dPose = mCompositeDrawable->GetPose();
char buffy[128];
sprintf(buffy, "frinkArcGroup", i);
int jointIndex = p3dPose->FindJointIndex(buffy);
for(int j = 0; j < mCompositeDrawable->GetNumDrawableElement(); j++)
{
tCompositeDrawable::DrawablePropElement* prop = (tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(j));
if(prop && prop->GetPoseIndex() == jointIndex)
{
tBillboardQuadGroup* bbqg = dynamic_cast<tBillboardQuadGroup*>( prop->GetDrawable() );
if( bbqg )
{
tRefCounted::Assign( mFrinkArc, bbqg );
for( int k = 0; k < NUM_FRINKARC_BBQS; k++ )
{
tBillboardQuad* quad = mFrinkArc->GetQuad( k );
mOriginalFrinkArcColour[k] = quad->GetColour();
}
}
}
}
#endif
}
if(strcmp(name, "rocke_v") == 0)
{
this->FindAndTurnOffFrontWheelsOnly();
}
// store brake light joint indices
FindBrakeLightBillboardJoints();
FindHeadLightBillboardJoints();
if( GetGameplayManager()->GetGameType() == GameplayManager::GT_SUPERSPRINT )
{
mHeadLightScale = 1.0f;
mBrakeLightScale = 0.4f;
if( mVehicleOwner->mVehicleType == VT_USER || mVehicleOwner->mVehicleType == VT_AI )
{
EnableLights( true );
}
}
else
{
// if we are on a level other than 4 or 7, we want to turn the headlights off
if( GetGameplayManager()->GetCurrentLevelIndex() == RenderEnums::L1 || // BROAD DAYLIGHT
GetGameplayManager()->GetCurrentLevelIndex() == RenderEnums::L2 )
{
// Which values should we use for headlights and brakelights
// when we just have running lights (when not braking)
mHeadLightScale = 0.0f;
mBrakeLightScale = 0.0f;//0.4f;
}
else if( GetGameplayManager()->GetCurrentLevelIndex() == RenderEnums::L3 ) // SUNSET
{
mHeadLightScale = 0.2f;
mBrakeLightScale = 0.3f;
}
else if( GetGameplayManager()->GetCurrentLevelIndex() == RenderEnums::L5 ) // DUSK
{
mHeadLightScale = 0.4f;
mBrakeLightScale = 0.4f;
}
else if( GetGameplayManager()->GetCurrentLevelIndex() == RenderEnums::L6 ) // TWILIGHT
{
mHeadLightScale = 0.4f;
mBrakeLightScale = 0.4f;
}
else if( GetGameplayManager()->GetCurrentLevelIndex() == RenderEnums::L4 || // NIGHT
GetGameplayManager()->GetCurrentLevelIndex() == RenderEnums::L7 )
{
// full headlights on night levels
mHeadLightScale = 0.6f;
mBrakeLightScale = 0.4f;
}
if( mVehicleOwner->mVehicleType == VT_USER )
{
EnableLights( false );
}
}
// hack for ghost ship
if( strcmp(name, "ship") == 0 )
{
mHasGhostGlow = true;
FindGhostGlowBillboards( name );
}
if( strcmp( name, "nuctruck" ) == 0 )
{
mHasNukeGlow = true;
FindNukeGlowBillboards( name );
}
// TODO - might need to clone this too
// mAnimController = p3d::find<tPoseAnimationController>(buffy);
// We will advance the multicontroller, not just the posecontroller
FindAnimationControllers( name );
char buffy[128];
sprintf(buffy, "PTRN_%s", name);
tPoseAnimationController* poseController = p3d::find<tPoseAnimationController>(buffy);
// only play an anim if it's there:
if( poseController )
{
poseController->SetPose(mCompositeDrawable->GetPose());
// TODO
// cast here might be unsafe in the general case
//mAnim = (tPoseAnimation*)(poseController->GetAnimation());
mAnim = poseController->GetAnimation();
mAnim->AddRef(); // ? already addref'd by controller?
mAnim->SetCyclic(true);
float numFrames = mAnim->GetNumFrames();
float speed = mAnim->GetSpeed();
rAssert( numFrames != 0 );
mAnimRevPerSecondBase = speed / (float)numFrames;
}
char roofShaderName[64];
sprintf( roofShaderName, "%sRoof_m", name );
tRefCounted::Assign( mRoofShader, p3d::find<tShader>( tEntity::MakeUID( roofShaderName ) ) );
FindRoofGeometry( name );
if( mRoofOpacShape && mRoofAlphaShape )
{
mRoofOpacShape->SetVisibility( true );
mRoofAlphaShape->SetVisibility( false );
}
if ( mVehicleOwner->GetNameObject() == "gramR_v" )
{
SetCollectibleHardpointPosition( JEEP_COLLECTIBLE_POS );
}
else if ( mVehicleOwner->GetNameObject() == "homer_v" )
{
SetCollectibleHardpointPosition( BARRACUDA_COLLECTIBLE_POS );
}
else if ( mVehicleOwner->GetNameObject() == "dune_v" )
{
SetCollectibleHardpointTransform( DUNE_COLLECTIBLE_ROT.x,
DUNE_COLLECTIBLE_ROT.y,
DUNE_COLLECTIBLE_ROT.z,
DUNE_COLLECTIBLE_POS);
}
else if ( mVehicleOwner->GetNameObject() == "hallo" )
{
SetCollectibleHardpointPosition( HALLO_COLLECTIBLE_POS );
}
else if ( mVehicleOwner->GetNameObject() == "coffin" )
{
SetCollectibleHardpointPosition( COFFIN_COLLECTIBLE_POS );
}
else if ( mVehicleOwner->GetNameObject() == "witchcar" )
{
SetCollectibleHardpointPosition( WITCH_COLLECTIBLE_POS );
}
if(mVehicleOwner->mVehicleType == VT_USER)
{
tCompositeDrawable::DrawableElement* agnes = mCompositeDrawable->FindNode("agnusGeoShape");
if(agnes)
{
if(GetVehicleCentral()->IsDriverSuppressed("skinner"))
{
agnes->SetVisibility(false);
}
}
}
//THERE'S AN UNTRACKED ALLOCATION HERE!
HeapMgr()->PushHeap( GMA_LEVEL_OTHER );
HeapMgr()->PopHeap(GMA_LEVEL_OTHER);
return FindDamageShadersAndTextures(name);
//return true;
}
//=============================================================================
// GeometryVehicle::FindDamageShadersAndTextures
//=============================================================================
// Description: Comment
//
// Parameters: (char* name)
//
// Return: void
//
//=============================================================================
bool GeometryVehicle::FindDamageShadersAndTextures( const char* carname)
{
// names we expect to have:
//
// for shaders
// <carname>DoorDNorm_m
// <carname>DoorPNorm_m
// <carname>HoodNorm_m
// <carname>BackNorm_m
// for normal textures:
// <carname>DoorDNorm.bmp
// <carname>DoorPNorm.bmp
// <carname>HoodNorm.bmp
// <carname>BackNorm.bmp current: BarTrunk.bmp
// for damage textures:
// <carname>DoorPDam.bmp current: BarracudaDoorPDam.bmp
// <carname>HoodDam.bmp current: BarracudaHoodDam.bmp
// <carname>DoorDDam.bmp current: BarracudaDoorDDam.bmp
// <carname>BackDam.bmp current: BarracudaBackDam.bmp
// !!
// TODO - search a particular inventory section only?
char buffy[128];
// change logic here - if we find at least one set of shader, normal texture, damage texture
// return true.
bool result = false;
bool doorD = true;
bool doorP = true;
bool hood = true;
bool trunk = true;
//-------
//shaders
//-------
sprintf(buffy, "%sDoorDNorm_m", carname);
mDoorDShader = p3d::find<tShader>(buffy);
if(mDoorDShader)
{
mDoorDShader->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
doorD = false;
}
sprintf(buffy, "%sDoorPNorm_m", carname);
mDoorPShader = p3d::find<tShader>(buffy);
if(mDoorPShader)
{
mDoorPShader->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
doorP = false;
}
sprintf(buffy, "%sHoodNorm_m", carname);
mHoodShader = p3d::find<tShader>(buffy);
if(mHoodShader)
{
mHoodShader->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
hood = false;
}
sprintf(buffy, "%sBackNorm_m", carname);
mTrunkShader = p3d::find<tShader>(buffy);
if(mTrunkShader)
{
mTrunkShader->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
trunk = false;
}
//----------------
// normal textures
//----------------
sprintf(buffy, "%sDoorDNorm.bmp", carname);
mDoorDTextureNorm = p3d::find<tTexture>(buffy);
if(mDoorDTextureNorm)
{
mDoorDTextureNorm->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
doorD = false;
}
sprintf(buffy, "%sDoorPNorm.bmp", carname);
mDoorPTextureNorm = p3d::find<tTexture>(buffy);
if(mDoorPTextureNorm)
{
mDoorPTextureNorm->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
doorP = false;
}
sprintf(buffy, "%sHoodNorm.bmp", carname);
mHoodTextureNorm = p3d::find<tTexture>(buffy);
if(mHoodTextureNorm)
{
mHoodTextureNorm->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
hood = false;
}
sprintf(buffy, "%sBackNorm.bmp", carname);
mTrunkTextureNorm = p3d::find<tTexture>(buffy);
if(mTrunkTextureNorm)
{
mTrunkTextureNorm->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
trunk = false;
}
//----------------
// damage textures
//----------------
sprintf(buffy, "%sDoorDDam.bmp", carname);
mDoorDTextureDam = p3d::find<tTexture>(buffy);
if(mDoorDTextureDam)
{
mDoorDTextureDam->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
doorD = false;
}
sprintf(buffy, "%sDoorPDam.bmp", carname);
mDoorPTextureDam = p3d::find<tTexture>(buffy);
if(mDoorPTextureDam)
{
mDoorPTextureDam->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
doorP = false;
}
sprintf(buffy, "%sHoodDam.bmp", carname);
mHoodTextureDam = p3d::find<tTexture>(buffy);
if(mHoodTextureDam)
{
mHoodTextureDam->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
hood = false;
}
sprintf(buffy, "%sBackDam.bmp", carname);
mTrunkTextureDam = p3d::find<tTexture>(buffy);
if(mTrunkTextureDam)
{
mTrunkTextureDam->AddRef();
}
else
{
rTunePrintf("vehicle damage: cant find %s\n", buffy);
//result = false;
trunk = false;
}
// now if any of doorD, doorP, hood, or trunk are true - return true
result = doorD | doorP | hood | trunk;
//----------------------------------------------------
// all of the above was if we are a type 1 or 2 damage
//
// for type 3 we just expect the following:
//----------------------------------------------------
//-------
// shader
//-------
/*
// ancient fucking history
sprintf(buffy, "%sChassisNorm_m", carname);
mChassisShader = p3d::find<tShader>(buffy);
if(mChassisShader)
{
mChassisShader->AddRef();
}
//---------------
// normal texture
//---------------
sprintf(buffy, "%sChassisNorm.bmp", carname);
mChassisTextureNorm = p3d::find<tTexture>(buffy);
if(mChassisTextureNorm)
{
mChassisTextureNorm->AddRef();
}
//---------------
// damage texture
//---------------
sprintf(buffy, "%sChassisDam.bmp", carname);
mChassisTextureDam = p3d::find<tTexture>(buffy);
if(mChassisTextureDam)
{
mChassisTextureDam->AddRef();
}
*/
return result;
}
//=============================================================================
// GeometryVehicle::SetSmoke
//=============================================================================
// Description: Comment
//
// Parameters: (ParticleEnum::ParticleID pid)
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetEngineSmoke(ParticleEnum::ParticleID pid)
{
mEngineParticleAttr.mType = pid;
}
/*
ParticleEnum::ParticleID mType;
// only one bias so far, the emission bias
// other biases would be simple to put in
// NumParticles/Life/Speed/Weight/Gravity/Drag/Size/Spin
float mEmissionBias;
*/
//=============================================================================
// GeometryVehicle::SetWheelSmoke
//=============================================================================
// Description: Comment
//
// Parameters: (ParticleEnum::ParticleID pid, float bias)
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetWheelSmoke( int wheel, ParticleEnum::ParticleID pid, float bias)
{
switch( wheel )
{
case 0:
mRightWheelParticleAttr.mType = pid;
mRightWheelParticleAttr.mEmissionBias = bias;
break;
case 1:
mLeftWheelParticleAttr.mType = pid;
mLeftWheelParticleAttr.mEmissionBias = bias;
break;
default:
mRightWheelParticleAttr.mType = pid;
mRightWheelParticleAttr.mEmissionBias = bias;
mLeftWheelParticleAttr.mType = pid;
mLeftWheelParticleAttr.mEmissionBias = bias;
break;
};
}
//=============================================================================
// GeometryVehicle::DamageTextureChassis
//=============================================================================
// Description: Comment
//
// Parameters: (bool on)
//
// Return: void
//
//=============================================================================
void GeometryVehicle::DamageTextureChassis(bool on)
{
rAssert(0); // this is fucking history
if(mChassisShader)
{
if(on)
{
mChassisShader->SetTexture(PDDI_SP_BASETEX, mChassisTextureDam);
}
else
{
mChassisShader->SetTexture(PDDI_SP_BASETEX, mChassisTextureNorm);
}
}
}
//=============================================================================
// GeometryVehicle::DamageTextureTrunk
//=============================================================================
// Description: Comment
//
// Parameters: (bool on)
//
// Return: void
//
//=============================================================================
void GeometryVehicle::DamageTextureTrunk(bool on)
{
if(mTrunkShader && mTrunkTextureDam && mTrunkTextureNorm)
{
if(on)
{
mTrunkShader->SetTexture(PDDI_SP_BASETEX, mTrunkTextureDam);
}
else
{
mTrunkShader->SetTexture(PDDI_SP_BASETEX, mTrunkTextureNorm);
}
}
}
//=============================================================================
// GeometryVehicle::DamageTextureHood
//=============================================================================
// Description: Comment
//
// Parameters: (bool on)
//
// Return: void
//
//=============================================================================
void GeometryVehicle::DamageTextureHood(bool on)
{
if(mHoodShader && mHoodTextureDam && mHoodTextureNorm)
{
if(on)
{
mHoodShader->SetTexture(PDDI_SP_BASETEX, mHoodTextureDam);
}
else
{
mHoodShader->SetTexture(PDDI_SP_BASETEX, mHoodTextureNorm);
}
}
}
//=============================================================================
// GeometryVehicle::DamageTextureDoorP
//=============================================================================
// Description: Comment
//
// Parameters: (bool on)
//
// Return:
//
//=============================================================================
void GeometryVehicle::DamageTextureDoorP(bool on)
{
if(mDoorPShader && mDoorPTextureDam && mDoorPTextureNorm)
{
if(on)
{
mDoorPShader->SetTexture(PDDI_SP_BASETEX, mDoorPTextureDam);
}
else
{
mDoorPShader->SetTexture(PDDI_SP_BASETEX, mDoorPTextureNorm);
}
}
}
//=============================================================================
// GeometryVehicle::DamageTextureDoorD
//=============================================================================
// Description: Comment
//
// Parameters: (bool on)
//
// Return: void
//
//=============================================================================
void GeometryVehicle::DamageTextureDoorD(bool on)
{
if(mDoorDShader && mDoorDTextureDam && mDoorDTextureNorm)
{
if(on)
{
mDoorDShader->SetTexture(PDDI_SP_BASETEX, mDoorDTextureDam);
}
else
{
mDoorDShader->SetTexture(PDDI_SP_BASETEX, mDoorDTextureNorm);
}
}
}
//=============================================================================
// GeometryVehicle::HideFlappingPiece
//=============================================================================
// Description: Comment
//
// Parameters: (int jointindex)
//
// Return: void
//
//=============================================================================
void GeometryVehicle::HideFlappingPiece(int jointindex, bool doit)
{
//tCompositeDrawable::DrawablePropElement* prop = (tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(jointindex));
int i;
for(i = 0; i < mCompositeDrawable->GetNumDrawableElement(); i++)
{
tCompositeDrawable::DrawablePropElement* prop = (tCompositeDrawable::DrawablePropElement*)(mCompositeDrawable->GetDrawableElement(i));
if(prop && prop->GetPoseIndex() == jointindex)
{
//prop->SetVisibility(false);
prop->SetVisibility(!doit);
}
}
}
//------------------------------------------------------------------------
void GeometryVehicle::Update(float dt)
{
AdvanceAnimationControllers( dt * 1000.0f );
rmt::Vector vehicleVelocity;
mVehicleOwner->GetVelocity( &vehicleVelocity );
// Certain animations and particle systems are scaled by the velocity
// Calculate what % the scalar should be
float animationSpeedBias = vehicleVelocity.Magnitude() / PARTICLE_SYSTEM_MAX_VELOCITY;
animationSpeedBias = animationSpeedBias > 1.0f ? 1.0f : animationSpeedBias;
animationSpeedBias = animationSpeedBias < 0.0f ? 0.0f : animationSpeedBias;
if ( mVariableEmissionParticleSystem != NULL )
{
mVariableEmissionParticleSystem->SetBias( p3dParticleSystemConstants::EmitterBias::EMISSION, animationSpeedBias );
}
//
// Vary prof frink's refraction shader every frame
//
const tName& name = mVehicleOwner->GetNameObject();
if( name == "frink_v" )
{
float topSpeed = mVehicleOwner->GetTopSpeed();
float percentOfTopSpeed = vehicleVelocity.Magnitude() / topSpeed;
float refraction = percentOfTopSpeed;
refraction = rmt::Clamp( refraction, 0.0f, 1.0f );
/*
//we adjust the refractive index based on distance from the camera
rmt::Vector pos = mVehicleOwner->GetPosition ();
rmt::Vector cameraPosition;
unsigned int index = GetSuperCamManager()->GetSCC( 0 )->GetActiveSuperCamIndex();
SuperCam* camera = GetSuperCamManager()->GetSCC( 0 )->GetSuperCam( index );
camera->GetPosition( &cameraPosition );
float distance = ( pos - cameraPosition ).Magnitude();
float refractionAmount = refractiveIndex;
//if( distance > 20 )
{
refractionAmount *= 5;
refractionAmount /= distance;
}
*/
//
// special case for the windshield shader
//
if( mRefractionShader[ 0 ] != NULL )
{
#ifdef RAD_GAMECUBE
float adjustedRefraction = refraction;
#else
float adjustedRefraction = 0.5f + (0.5f * refraction);
#endif
#ifndef RAD_WIN32
mRefractionShader[ 0 ]->SetFloat( PDDI_SP_REFRACTBLEND, adjustedRefraction );
mRefractionShader[ 0 ]->SetFloat( PDDI_SP_REFRACTINDEX, refractiveIndex );
#endif
}
//
// all other shaders
//
int i;
for( i = 1; i < MAX_REFRACTION_SHADERS; ++i )
{
if( mRefractionShader[ i ] != NULL )
{
#ifndef RAD_WIN32
mRefractionShader[ i ]->SetFloat( PDDI_SP_REFRACTBLEND, refraction );
mRefractionShader[ i ]->SetFloat( PDDI_SP_REFRACTINDEX, refractiveIndex );
#endif
}
}
}
// Update the collectible's position
if ( m_Collectible != NULL )
{
rmt::Matrix collectibleTransform;
collectibleTransform.Mult( m_CollectibleTransform, mVehicleOwner->mTransform );
m_Collectible->SetTransform( collectibleTransform );
}
}
//=============================================================================
// GeometryVehicle::SetTrafficBodyColour
//=============================================================================
// Description: Comment
//
// Parameters: ( pddiColour colour )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetTrafficBodyColour( pddiColour colour )
{
if( mVehicleOwner->mVehicleType == VT_TRAFFIC || mVehicleOwner->mVehicleType == VT_USER )
{
if( mTrafficBodyDrawable != NULL )
{
mTrafficBodyDrawable->SetDesiredColour( colour );
}
if( mTrafficDoorDrawable != NULL )
{
mTrafficDoorDrawable->SetDesiredColour( colour );
}
}
}
//=============================================================================
// GeometryVehicle::GetP3DPose
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: tPose
//
//=============================================================================
tPose* GeometryVehicle::GetP3DPose()
{
if(mCompositeDrawable)
{
return mCompositeDrawable->GetPose();
}
else
{
return 0;
}
}
//=============================================================================
// GeometryVehicle::SetShadowAdjustments
//=============================================================================
// Description: Comment
//
// Parameters: ( float Adjustments[ 4 ][ 2 ] )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetShadowAdjustments( float Adjustments[ 4 ][ 2 ] )
{
for( int i = 0; i < 4; ++i )
{
mShadowPointAdjustments[ i ][ 0 ] = Adjustments[ i ][ 0 ];
mShadowPointAdjustments[ i ][ 1 ] = Adjustments[ i ][ 1 ];
}
}
//=============================================================================
// GeometryVehicle::SetFadeAlpha
//=============================================================================
// Description: Comment
//
// Parameters: ( int fade )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::SetFadeAlpha( int fade )
{
rAssert( 0 <= fade && fade <= 255 );
mFadeAlpha = fade;
}
// Hack:
// We hard code the traffic models so we can tell which vehicle
// needs special treatment in terms of fading... Be sure to add
// any new traffic models here or they won't fade properly.
//
// The problem is that the intbroadcast on all the shaders in
// this composite drawable is going to reset everyone's blend
// mode to BLEND_ALPHA... Brakelights, however, need BLEND_ADDITIVE
// and some cars (cCells, cPolice) have special light effects that
// have similar problems. Setting these all to BLEND_ALPHA will
// cause the billboards to not display properly, so we make sure
// we do an intbroadcast (using ProcessShaders()) only for cars
// that are using traffic models (including non-traffic cars such
// as mission AI cars).
//
// The alternative to this is to avoid using ProcessShaders() and
// set the appropriate shader for each composite drawable's element
// that need to fade independently... Could be messy...
// This hard-coded list is not so bad..
//
//=============================================================================
// GeometryVehicle::IsTrafficModel
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: bool
//
//=============================================================================
bool GeometryVehicle::IsTrafficModel()
{
rAssert( mVehicleOwner );
VehicleEnum::VehicleID ID = mVehicleOwner->mVehicleID;
if( ID == VehicleEnum::HUSKA ||
ID == VehicleEnum::COMPACTA ||
ID == VehicleEnum::PICKUPA ||
ID == VehicleEnum::MINIVANA ||
ID == VehicleEnum::SUVA ||
ID == VehicleEnum::SPORTSA ||
ID == VehicleEnum::SPORTSB ||
ID == VehicleEnum::SEDANA ||
ID == VehicleEnum::SEDANB ||
ID == VehicleEnum::TAXIA ||
ID == VehicleEnum::WAGONA ||
ID == VehicleEnum::COFFIN ||
ID == VehicleEnum::HALLO ||
ID == VehicleEnum::WITCHCAR ||
ID == VehicleEnum::SHIP ||
ID == VehicleEnum::AMBUL ||
ID == VehicleEnum::BURNSARM ||
ID == VehicleEnum::FISHTRUC ||
ID == VehicleEnum::GARBAGE ||
ID == VehicleEnum::ICECREAM ||
ID == VehicleEnum::ISTRUCK ||
ID == VehicleEnum::NUCTRUCK ||
ID == VehicleEnum::PIZZA ||
ID == VehicleEnum::SCHOOLBU ||
ID == VehicleEnum::VOTETRUC ||
ID == VehicleEnum::GLASTRUC )
{
return true;
}
return false;
}
//=============================================================================
// GeometryVehicle::FadeRoof
//=============================================================================
// Description: Comment
//
// Parameters: ( bool fade )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FadeRoof( bool fade )
{
rAssert( 0 <= INCAR_ROOF_ALPHA && INCAR_ROOF_ALPHA <= 255 );
mRoofTargetAlpha = (fade)? INCAR_ROOF_ALPHA : 255;
}
//=============================================================================
// GeometryVehicle::FindRoofGeometry
//=============================================================================
// Description: Comment
//
// Parameters: ( const char* model )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FindRoofGeometry( const char* model )
{
char opac[64];
sprintf(opac, "%sRoofOpacShape", model );
tUID opacID = tEntity::MakeUID( opac );
char alpha[64];
sprintf(alpha, "%sRoofAlphaShape", model );
tUID alphaID = tEntity::MakeUID( alpha );
for( int j = 0; j < mCompositeDrawable->GetNumDrawableElement(); j++)
{
tCompositeDrawable::DrawablePropElement* prop =
(tCompositeDrawable::DrawablePropElement*)
(mCompositeDrawable->GetDrawableElement(j));
if( prop )
{
tUID uid = prop->GetUID();
if( uid == opacID )
{
mRoofOpacShape = prop;
}
else if( uid == alphaID )
{
mRoofAlphaShape = prop;
}
}
}
}
//=============================================================================
// GeometryVehicle::EnableLights
//=============================================================================
// Description: Comment
//
// Parameters: ( bool enable )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::EnableLights( bool enable )
{
mEnableLights = enable;
}
//=============================================================================
// GeometryVehicle::GetVehicleColour
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: tColour
//
//=============================================================================
tColour GeometryVehicle::GetVehicleColour()const
{
if ( mTrafficBodyDrawable != NULL )
{
return mTrafficBodyDrawable->GetDesiredColour();
}
else
{
const tColour DEFAULT_COLOUR( 128,128,128 );
return DEFAULT_COLOUR;
}
}
//=============================================================================
// GeometryVehicle::FindAnimationControllers
//=============================================================================
// Description: Comment
//
// Parameters: ( const char* multicontrollername )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::FindAnimationControllers( const char* multicontrollername )
{
tMultiController* mc = p3d::find< tMultiController >( multicontrollername );
if( mc == NULL )
return;
HeapMgr()->PushHeap(GMA_LEVEL_OTHER);
// Iterate through the frame controllers and add them to our own list
for ( unsigned int i = 0 ; i < mc->GetNumTracks() ; i++ )
{
tFrameController* fc = mc->GetTrack( i )->Clone();
VehicleFrameController vfc;
vfc.trigger = eNone;
vfc.brakeBias = vfc.gasBias = vfc.speedBias = 0;
vfc.timeBias = 1.0f;
vfc.frameSetter = false;
GetSpecialController( fc->GetUID(), &vfc );
vfc.frameController = fc;
vfc.frameController->AddRef();
vfc.frameController->Reset();
vfc.frameController->SetCycleMode( FORCE_CYCLIC );
// What kind of animation controller are we dealing with?
// Possibly a pose controller?
tPoseAnimationController* poseController = dynamic_cast< tPoseAnimationController* >( vfc.frameController );
if ( poseController )
{
// The compositeDrawble::clone function allocates a brand new pose
// set the frame controller that this pose is the one to update upon
// Advance()
poseController->SetPose( mCompositeDrawable->GetPose() );
}
mFrameControllers.push_back( vfc );
}
HeapMgr()->PopHeap(GMA_LEVEL_OTHER);
}
//=============================================================================
// GeometryVehicle::GetSpecialController
//=============================================================================
// Description: Comment
//
// Parameters: ( tUID name, VehicleFrameController* outSpecialController )
//
// Return: bool
//
//=============================================================================
bool GeometryVehicle::GetSpecialController( tUID name, VehicleFrameController* outSpecialController )
{
bool wasFound = false;
// iterate through the preset "special" controllers and find any with the same name
for ( int i = 0 ; i < NUM_FRAME_CONTROLLERS ; i++ )
{
if ( name == tName::MakeUID( FRAME_CONTROLLER_DATA[i].name ) )
{
*outSpecialController = FRAME_CONTROLLER_DATA[i];
wasFound = true;
break;
}
}
return wasFound;
}
//=============================================================================
// GeometryVehicle::AdvanceAnimationControllers
//=============================================================================
// Description: Comment
//
// Parameters: ( float deltaTime )
//
// Return: void
//
//=============================================================================
void GeometryVehicle::AdvanceAnimationControllers( float deltaTime )
{
int numFCs = mFrameControllers.size();
float gas = mVehicleOwner->GetGas();
float speed = mVehicleOwner->GetSpeedKmh();
float brake = mVehicleOwner->GetBrake();
if ( mVehicleOwner->IsMovingBackward() )
speed *= -1;
FCTrigger trigger = eNone;
if ( mVehicleOwner->GetDeltaGas() > 0.001f )
{
trigger = eBackfire;
}
for ( int i = 0 ; i < numFCs ; i++ )
{
VehicleFrameController& vfc = mFrameControllers[i];
if ( vfc.frameSetter )
{
// This thing doesn't ever run linearly, it only sets the frame
// it uses specifically.
// Figure out which frame to set based upon vehicle attributes
float relativeframe;
float numFrames = vfc.frameController->GetNumFrames();
relativeframe = vfc.brakeBias * brake + vfc.gasBias * gas +
vfc.speedBias * speed;
vfc.frameController->SetFrame( relativeframe * numFrames );
vfc.frameController->Advance( 0.0f );
}
else
{
// Is the animation triggered by something?
// Check to see if it is or isn't
if ( trigger != eNone && trigger == vfc.trigger )
{
// Its a triggered animation thats been triggered
// If the animation isnt playing already then restart it
if ( vfc.frameController->GetRelativeSpeed() < 0.001f )
{
vfc.frameController->Reset();
vfc.frameController->SetRelativeSpeed( 1.0f );
}
if ( vfc.frameController->LastFrameReached() )
{
vfc.frameController->SetRelativeSpeed( 0 );
}
}
// Standard animation, apply biases and play
float advanceTime = vfc.timeBias * deltaTime;
if ( advanceTime < 0 ) advanceTime = 0;
float advanceGas = gas * vfc.gasBias * deltaTime;
if ( advanceGas < 0 ) advanceGas = 0;
float advanceBrake = brake * vfc.brakeBias * deltaTime;
if ( advanceBrake < 0 ) advanceBrake = 0;
float advanceSpeed = speed * vfc.speedBias * deltaTime;
if ( advanceSpeed < 0 ) advanceSpeed = 0;
float totalAdvanceTime = advanceTime + advanceGas - advanceBrake + advanceSpeed;
vfc.frameController->Advance( totalAdvanceTime );
}
}
}
Reference in New Issue View Git Blame Copy Permalink