tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/wwphys/projectile.cpp

647 lines
18 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : WWPhys *
* *
* $Archive:: /Commando/Code/wwphys/projectile.cpp $*
* *
* Author:: Greg_h *
* *
* $Modtime:: 12/20/01 5:14p $*
* *
* $Revision:: 60 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "projectile.h"
#include "pscene.h"
#include "lineseg.h"
#include "physcon.h"
#include "physcoltest.h"
#include "rendobj.h"
#include "persistfactory.h"
#include "wwphysids.h"
#include "simpledefinitionfactory.h"
#include "wwdebug.h"
#include "wwhack.h"
#include "wwprofile.h"
DECLARE_FORCE_LINK(projectile);
/***********************************************************************************************
**
** ProjectileClass Implementation
**
***********************************************************************************************/
/*
** Declare a PersistFactory for ProjectileClasses
*/
SimplePersistFactoryClass<ProjectileClass,PHYSICS_CHUNKID_PROJECTILE> _ProjectileFactory;
/*
** ChunkID's used by ProjectileClass
*/
enum
{
PROJECTILE_CHUNK_MOVEABLEPHYS = 0x03308765, // parent class data
PROJECTILE_CHUNK_VARIABLES,
PROJECTILE_VARIABLE_POSITION = 0x00,
PROJECTILE_VARIABLE_VELOCITY,
PROJECTILE_VARIABLE_COLLIDESONMOVE,
PROJECTILE_VARIABLE_ORIENTATIONMODE,
PROJECTILE_VARIABLE_TUMBLEAXIS,
PROJECTILE_VARIABLE_TUMBLERATE,
PROJECTILE_VARIABLE_LIFETIME,
PROJECTILE_VARIABLE_BOUNCECOUNT,
};
ProjectileClass::ProjectileClass(void) :
CollidesOnMove(true),
OrientationMode(ORIENTATION_ALIGNED),
TumbleAxis(1,0,0),
TumbleRate(DEG_TO_RADF(10.0f)),
Lifetime(2.0f),
BounceCount(0)
{
State.Position.Set(0,0,0);
State.Velocity.Set(0,0,0);
// turn off lighting for all projectiles
Enable_Is_Pre_Lit(true);
}
void ProjectileClass::Init(const ProjectileDefClass & def)
{
MoveablePhysClass::Init(def);
CollidesOnMove = def.CollidesOnMove;
OrientationMode = def.OrientationMode;
TumbleAxis = def.TumbleAxis;
TumbleRate = def.TumbleRate;
Lifetime = def.Lifetime;
BounceCount = def.BounceCount;
State.Position.Set(0,0,0);
State.Velocity.Set(0,0,0);
if (TumbleAxis.Length2() == 0.0f) {
TumbleAxis.Set(0,0,1);
} else {
TumbleAxis.Normalize();
}
// turn off lighting for all projectiles
Enable_Is_Pre_Lit(true);
}
ProjectileClass::~ProjectileClass(void)
{
}
const AABoxClass & ProjectileClass::Get_Bounding_Box(void) const
{
assert(Model);
return Model->Get_Bounding_Box();
}
const Matrix3D & ProjectileClass::Get_Transform(void) const
{
assert(Model);
return Model->Get_Transform();
}
void ProjectileClass::Set_Transform(const Matrix3D & tm)
{
tm.Get_Translation(&State.Position);
assert(Model);
Model->Set_Transform(tm);
// TODO: don't use the actual bounds? Just use the position and a pre-calced extent
Update_Cull_Box();
}
void ProjectileClass::Set_Orientation_Mode_Tumbling(void)
{
OrientationMode = ORIENTATION_TUMBLING;
TumbleAxis.Set(0,0,0);
while (TumbleAxis.Length() <= 0.001f) {
TumbleAxis.X = WWMath::Random_Float();
TumbleAxis.Y = WWMath::Random_Float();
TumbleAxis.Z = WWMath::Random_Float();
}
TumbleAxis.Normalize();
TumbleRate = WWMath::Random_Float((float)DEG_TO_RAD(2.0f),(float)DEG_TO_RAD(10.0f));
}
void ProjectileClass::Set_Orientation_Mode_Tumbling(const Vector3 & axis,float rate)
{
OrientationMode = ORIENTATION_TUMBLING;
TumbleAxis = axis;
TumbleAxis.Normalize();
TumbleRate = rate;
}
void ProjectileClass::Set_Orientation_Mode_Aligned_Fixed(void)
{
OrientationMode = ORIENTATION_ALIGNED_FIXED;
if (OrientationMode == ORIENTATION_ALIGNED_FIXED) {
Matrix3D tm;
tm.Obj_Look_At(State.Position,State.Position + State.Velocity,0.0f);
Model->Set_Transform(tm);
}
}
void ProjectileClass::Set_Lifetime( float time )
{
Lifetime = time;
}
float ProjectileClass::Get_Lifetime( void )
{
return Lifetime;
}
void ProjectileClass::Set_Bounce_Count(int count)
{
BounceCount = count;
}
int ProjectileClass::Get_Bounce_Count(void)
{
return BounceCount;
}
void ProjectileClass::Integrate(float dt)
{
float accel = PhysicsConstants::GravityAcceleration.Z * GravScale;
State.Position.X += State.Velocity.X * dt;
State.Position.Y += State.Velocity.Y * dt;
State.Position.Z += 0.5f * accel * dt * dt + State.Velocity.Z * dt;
State.Velocity.Z += accel * dt;
}
void ProjectileClass::Timestep(float dt)
{
WWPROFILE("Projectile::Timestep");
const int MAX_BUMPS = 5;
if (Is_User_Control_Enabled()) {
return;
}
if (dt == 0.0f) {
return;
}
WWASSERT(State.Position.Is_Valid());
WWASSERT(State.Velocity.Is_Valid());
if ( CollidesOnMove ) {
WWPROFILE("Move and Collide");
/*
** Repeat until we eat all of the time
*/
float remaining_time = dt;
float timestep;
int bumps = 0;
/*
** This is that last object we choose to ignore
*/
PhysClass *blocker = NULL;
while ((remaining_time > 0.0f) && (bumps < MAX_BUMPS) && (BounceCount >= 0)) {
timestep = remaining_time;
bumps++;
/*
** Integrate the state of the object for some amount
** of time: timestep
*/
ProjectileStateStruct oldstate = State;
Integrate(timestep);
/*
** Check for collisions in the path of the object
*/
CastResultStruct res;
LineSegClass ray(oldstate.Position,State.Position);
PhysRayCollisionTestClass raytest(ray,&res,Get_Collision_Group(),COLLISION_TYPE_PROJECTILE);
{
WWPROFILE("Raycast");
Inc_Ignore_Counter();
PhysicsSceneClass::Get_Instance()->Cast_Ray(raytest);
Dec_Ignore_Counter();
}
/*
** If the result was a "startbad", just do the whole step
*/
if (raytest.Result->StartBad) {
remaining_time -= timestep;
} else {
/*
** If there was a collision, cut the timestep so that
** we integrate right up to the collision
*/
if (raytest.Result->Fraction < 1.0f) {
timestep = raytest.Result->Fraction * timestep;
remaining_time -= timestep;
/*
** Compute the point of collision, stored in ContactPoint of the CastResStruct
** so that observers have it.
*/
ray.Compute_Point(raytest.Result->Fraction,&(raytest.Result->ContactPoint));
/*
** Reset and integrate up to that point
*/
State = oldstate;
Integrate(0.99f * timestep);
/*
** Notify the parties involved
*/
WWASSERT(raytest.CollidedPhysObj != NULL);
CollisionReactionType reaction = COLLISION_REACTION_DEFAULT;
CollisionEventClass event;
event.CollisionResult = raytest.Result;
event.CollidedRenderObj = raytest.CollidedRenderObj;
{
WWPROFILE("Callbacks");
event.OtherObj = raytest.CollidedPhysObj;
reaction |= Collision_Occurred(event);
event.OtherObj = this;
reaction |= raytest.CollidedPhysObj->Collision_Occurred(event);
}
if ( !(reaction & COLLISION_REACTION_NO_BOUNCE) ) {
/*
** Perform collision processing and loop
*/
float dot = Vector3::Dot_Product(State.Velocity,raytest.Result->Normal);
State.Velocity -= (1.0f + Elasticity)*dot*raytest.Result->Normal;
/*
** If we are using ORIENTATION_MODE_ALIGNED_FIXED, update the
** transform whenever we bounce
*/
if (OrientationMode == ORIENTATION_ALIGNED_FIXED) {
Matrix3D tm;
tm.Obj_Look_At(State.Position,State.Position + State.Velocity,0.0f);
Model->Set_Transform(tm);
}
/*
** Decrement the bounce count!
*/
BounceCount--;
} else {
/*
** We were requested to fly through. Mark the current blocker as ignore
** so we collide with him no more this pass
*/
Integrate(0.02*timestep);
if ( blocker ) { // Stop ignoring the last blocker
blocker->Dec_Ignore_Counter();
}
blocker = raytest.CollidedPhysObj;
if ( blocker ) { // Start ignoring this blocker
blocker->Inc_Ignore_Counter();
}
}
/*
** If requested to stop, progress no more
*/
if ( reaction & COLLISION_REACTION_STOP_MOTION ) {
remaining_time = 0;
State.Velocity = Vector3(0,0,0);
}
} else {
remaining_time -= timestep;
}
}
}
if ( blocker ) { // Stop ignoring the last blocker
blocker->Dec_Ignore_Counter();
}
} else {
Integrate(dt);
}
Update_Transform(dt);
Update_Cull_Box();
DEBUG_RENDER_AXES(Get_Transform(),Vector3(1.0f,1.0f,1.0f));
/*
** Decrement our life, check our bounce count
*/
Lifetime -= dt;
if ((Lifetime < 0.0f) || (BounceCount < 0)) {
Expire();
}
}
bool ProjectileClass::Cast_Ray(PhysRayCollisionTestClass & raytest)
{
assert(Model);
if (Model->Cast_Ray(raytest)) {
raytest.CollidedPhysObj = this;
return true;
}
return false;
}
void ProjectileClass::Update_Transform(float dt)
{
WWASSERT(Model);
// Update the cached transformation matrix
Matrix3D tm;
switch(OrientationMode) {
case ORIENTATION_ALIGNED:
// compute a matrix aligned to the path
tm.Obj_Look_At(State.Position,State.Position + State.Velocity,0.0f);
Model->Set_Transform(tm);
break;
case ORIENTATION_ALIGNED_FIXED:
case ORIENTATION_FIXED:
// just update the position
Model->Set_Position(State.Position);
break;
case ORIENTATION_TUMBLING:
// update the position, tumble a little
tm = Model->Get_Transform();
tm.Set_Translation(State.Position);
Matrix3D::Multiply(tm,Matrix3D(TumbleAxis,TumbleRate*dt),&tm);
Model->Set_Transform(tm);
break;
};
Update_Visibility_Status();
}
const PersistFactoryClass & ProjectileClass::Get_Factory (void) const
{
return _ProjectileFactory;
}
bool ProjectileClass::Save (ChunkSaveClass &csave)
{
csave.Begin_Chunk(PROJECTILE_CHUNK_MOVEABLEPHYS);
MoveablePhysClass::Save(csave);
csave.End_Chunk();
csave.Begin_Chunk(PROJECTILE_CHUNK_VARIABLES);
WRITE_MICRO_CHUNK(csave,PROJECTILE_VARIABLE_POSITION,State.Position);
WRITE_MICRO_CHUNK(csave,PROJECTILE_VARIABLE_VELOCITY,State.Velocity);
WRITE_MICRO_CHUNK(csave,PROJECTILE_VARIABLE_COLLIDESONMOVE,CollidesOnMove);
WRITE_MICRO_CHUNK(csave,PROJECTILE_VARIABLE_ORIENTATIONMODE,OrientationMode);
WRITE_MICRO_CHUNK(csave,PROJECTILE_VARIABLE_TUMBLEAXIS,TumbleAxis);
WRITE_MICRO_CHUNK(csave,PROJECTILE_VARIABLE_TUMBLERATE,TumbleRate);
WRITE_MICRO_CHUNK(csave,PROJECTILE_VARIABLE_LIFETIME,Lifetime);
WRITE_MICRO_CHUNK(csave,PROJECTILE_VARIABLE_BOUNCECOUNT,BounceCount);
csave.End_Chunk();
return true;
}
bool ProjectileClass::Load (ChunkLoadClass &cload)
{
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID())
{
case PROJECTILE_CHUNK_MOVEABLEPHYS:
MoveablePhysClass::Load(cload);
break;
case PROJECTILE_CHUNK_VARIABLES:
while (cload.Open_Micro_Chunk()) {
switch(cload.Cur_Micro_Chunk_ID()) {
READ_MICRO_CHUNK(cload,PROJECTILE_VARIABLE_POSITION,State.Position);
READ_MICRO_CHUNK(cload,PROJECTILE_VARIABLE_VELOCITY,State.Velocity);
READ_MICRO_CHUNK(cload,PROJECTILE_VARIABLE_COLLIDESONMOVE,CollidesOnMove);
READ_MICRO_CHUNK(cload,PROJECTILE_VARIABLE_ORIENTATIONMODE,OrientationMode);
READ_MICRO_CHUNK(cload,PROJECTILE_VARIABLE_TUMBLEAXIS,TumbleAxis);
READ_MICRO_CHUNK(cload,PROJECTILE_VARIABLE_TUMBLERATE,TumbleRate);
READ_MICRO_CHUNK(cload,PROJECTILE_VARIABLE_LIFETIME,Lifetime);
READ_MICRO_CHUNK(cload,PROJECTILE_VARIABLE_BOUNCECOUNT,BounceCount);
}
cload.Close_Micro_Chunk();
}
break;
default:
WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
break;
}
cload.Close_Chunk();
}
return true;
}
/***********************************************************************************************
**
** ProjectileDefClass Implementation
**
***********************************************************************************************/
/*
** Declare a PersistFactory for ProjectileDefClasses, this allows them to save and load
*/
SimplePersistFactoryClass<ProjectileDefClass,PHYSICS_CHUNKID_PROJECTILEDEF> _ProjectileDefFactory;
/*
** Declare a definition factory. This exposes ProjectileDef to the editor.
*/
DECLARE_DEFINITION_FACTORY(ProjectileDefClass, CLASSID_PROJECTILEDEF, "Projectile") _ProjectileDefDefFactory;
/*
** Chunk ID's used by MoveablePhysDefClass
*/
enum
{
PROJECTILEDEF_CHUNK_MOVEABLEPHYSDEF = 0x01210011, // (parent class)
PROJECTILEDEF_CHUNK_VARIABLES,
PROJECTILEDEF_VARIABLE_COLLIDESONMOVE = 0x00,
PROJECTILEDEF_VARIABLE_ORIENTATIONMODE,
PROJECTILEDEF_VARIABLE_TUMBLEAXIS,
PROJECTILEDEF_VARIABLE_TUMBLERATE,
PROJECTILEDEF_VARIABLE_LIFETIME,
PROJECTILEDEF_VARIABLE_BOUNCECOUNT,
};
ProjectileDefClass::ProjectileDefClass(void) :
CollidesOnMove(true),
OrientationMode(ProjectileClass::ORIENTATION_ALIGNED),
TumbleAxis(1,2,1),
TumbleRate(DEG_TO_RADF(10.0f)),
Lifetime(2.0f),
BounceCount(0)
{
#ifdef PARAM_EDITING_ON
// make our parameters editable!
EDITABLE_PARAM(ProjectileDefClass, ParameterClass::TYPE_BOOL, CollidesOnMove);
EnumParameterClass *param = new EnumParameterClass(&OrientationMode);
param->Set_Name ("OrientationMode");
param->Add_Value("ALIGNED",ProjectileClass::ORIENTATION_ALIGNED);
param->Add_Value("FIXED",ProjectileClass::ORIENTATION_FIXED);
param->Add_Value("TUMBLE",ProjectileClass::ORIENTATION_TUMBLING);
GENERIC_EDITABLE_PARAM(ProjectileDefClass,param)
FLOAT_EDITABLE_PARAM(ProjectileDefClass, TumbleAxis.X, 0.0f, 10.0f);
FLOAT_EDITABLE_PARAM(ProjectileDefClass, TumbleAxis.Y, 0.0f, 10.0f);
FLOAT_EDITABLE_PARAM(ProjectileDefClass, TumbleAxis.Z, 0.0f, 10.0f);
ANGLE_EDITABLE_PARAM(ProjectileDefClass, TumbleRate, DEG_TO_RADF(0.1f), DEG_TO_RADF(90.0f));
FLOAT_EDITABLE_PARAM(ProjectileDefClass, Lifetime, 0.01f, 100.0f);
INT_EDITABLE_PARAM(ProjectileDefClass, BounceCount, 0, 32);
#endif
}
const PersistFactoryClass & ProjectileDefClass::Get_Factory (void) const
{
return _ProjectileDefFactory;
}
uint32 ProjectileDefClass::Get_Class_ID (void) const
{
return CLASSID_PROJECTILEDEF;
}
PersistClass * ProjectileDefClass::Create(void) const
{
ProjectileClass * obj = NEW_REF(ProjectileClass,());
obj->Init(*this);
return obj;
}
bool ProjectileDefClass::Save(ChunkSaveClass &csave)
{
csave.Begin_Chunk(PROJECTILEDEF_CHUNK_MOVEABLEPHYSDEF);
MoveablePhysDefClass::Save(csave);
csave.End_Chunk();
csave.Begin_Chunk(PROJECTILEDEF_CHUNK_VARIABLES);
WRITE_MICRO_CHUNK(csave,PROJECTILEDEF_VARIABLE_COLLIDESONMOVE,CollidesOnMove);
WRITE_MICRO_CHUNK(csave,PROJECTILEDEF_VARIABLE_ORIENTATIONMODE,OrientationMode);
WRITE_MICRO_CHUNK(csave,PROJECTILEDEF_VARIABLE_TUMBLEAXIS,TumbleAxis);
WRITE_MICRO_CHUNK(csave,PROJECTILEDEF_VARIABLE_TUMBLERATE,TumbleRate);
WRITE_MICRO_CHUNK(csave,PROJECTILEDEF_VARIABLE_LIFETIME,Lifetime);
WRITE_MICRO_CHUNK(csave,PROJECTILEDEF_VARIABLE_BOUNCECOUNT,BounceCount);
csave.End_Chunk();
return true;
}
bool ProjectileDefClass::Load(ChunkLoadClass &cload)
{
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case PROJECTILEDEF_CHUNK_MOVEABLEPHYSDEF:
MoveablePhysDefClass::Load(cload);
break;
case PROJECTILEDEF_CHUNK_VARIABLES:
while (cload.Open_Micro_Chunk()) {
switch(cload.Cur_Micro_Chunk_ID()) {
READ_MICRO_CHUNK(cload,PROJECTILEDEF_VARIABLE_COLLIDESONMOVE,CollidesOnMove);
READ_MICRO_CHUNK(cload,PROJECTILEDEF_VARIABLE_ORIENTATIONMODE,OrientationMode);
READ_MICRO_CHUNK(cload,PROJECTILEDEF_VARIABLE_TUMBLEAXIS,TumbleAxis);
READ_MICRO_CHUNK(cload,PROJECTILEDEF_VARIABLE_TUMBLERATE,TumbleRate);
READ_MICRO_CHUNK(cload,PROJECTILEDEF_VARIABLE_LIFETIME,Lifetime);
READ_MICRO_CHUNK(cload,PROJECTILEDEF_VARIABLE_BOUNCECOUNT,BounceCount);
}
cload.Close_Micro_Chunk();
}
break;
default:
WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
break;
}
cload.Close_Chunk();
}
return true;
}
bool ProjectileDefClass::Is_Type(const char * type_name)
{
if (stricmp(type_name,ProjectileDefClass::Get_Type_Name()) == 0) {
return true;
} else {
return MoveablePhysDefClass::Is_Type(type_name);
}
}
Reference in a new issue View git blame Copy permalink