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/Combat/animcontrol.h

311 lines
10 KiB
C
Raw Permalink Normal View 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/>.
*/
/***********************************************************************************************
*** Confidential - Westwood Studios ***
***********************************************************************************************
* *
* Project Name : Commando *
* *
* $Archive:: /Commando/Code/Combat/animcontrol.h $*
* *
* $Author:: Byon_g $*
* *
* $Modtime:: 1/04/02 10:33a $*
* *
* $Revision:: 36 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#ifndef ANIMCONTROL_H
#define ANIMCONTROL_H
#ifndef ALWAYS_H
#include "always.h"
#endif
#ifndef HANIM_H
#include "hanim.h"
#endif
#ifndef VECTOR_H
#include "vector.h"
#endif
#include "wwstring.h"
/*
**
*/
class RenderObjClass;
typedef enum {
ANIM_MODE_ONCE,
ANIM_MODE_LOOP,
ANIM_MODE_STOP,
ANIM_MODE_TARGET
} AnimMode;
/*
** AnimationDataRecord
*/
struct AnimationDataRecord {
HAnimClass *Animation;
float Frame;
float Weight;
bool operator == (AnimationDataRecord const & rec) const { return false; }
bool operator != (AnimationDataRecord const & rec) const { return true; }
};
typedef DynamicVectorClass<AnimationDataRecord> AnimationDataList;
/*
** AnimChannelClass
*/
class AnimChannelClass {
public:
// Constructor and Destructor
AnimChannelClass( void );
AnimChannelClass(const AnimChannelClass &);
AnimChannelClass & operator = (const AnimChannelClass &);
~AnimChannelClass(void);
virtual bool Save( ChunkSaveClass & csave );
virtual bool Load( ChunkLoadClass & cload );
// Set Animation
void Set_Animation( const char *name );
void Set_Animation( const HAnimClass *anim );
HAnimClass *Peek_Animation( void ) { return Animation; }
// Set Mode
void Set_Mode( AnimMode mode, float frame = -1 );
AnimMode Get_Mode( void ) { return Mode; }
bool Is_Complete( void ) { return (Animation == NULL) || ((Mode == ANIM_MODE_ONCE) && (Frame == NumFrames-1)) || ((Mode == ANIM_MODE_TARGET) && (Frame == TargetFrame)); }
const char *Get_Animation_Name( void ) { return Animation ? Animation->Get_Name() : ""; }
// Frame
void Set_Frame( float frame ) { Frame = frame; }
float Get_Frame( void ) { return Frame; }
float Get_Progress( void ) { return NumFrames ? Frame / NumFrames : 0; }
void Set_Target_Frame( float frame ) { TargetFrame = frame; }
float Get_Target_Frame( void ) { return TargetFrame; }
// Update the animation
void Update( float dtime );
// Get Animation Data
void Get_Animation_Data( AnimationDataList & list, float weight = 1.0f );
// Update Model
void Update_Model( RenderObjClass *anim_model );
private:
HAnimClass * Animation;
float Frame;
float NumFrames;
float TargetFrame;
AnimMode Mode;
};
/*
** BlendableAnimChannelClass
*/
class BlendableAnimChannelClass {
public:
// Constructor
BlendableAnimChannelClass( void );
virtual bool Save( ChunkSaveClass & csave );
virtual bool Load( ChunkLoadClass & cload );
// Set Animation
void Set_Animation( const char *name, float blendtime = 0.0f, float start_frame = 0.0f );
void Set_Animation( const HAnimClass * anim, float blendtime = 0.0f, float start_frame = 0.0f );
void Set_Mode( AnimMode mode, float frame = -1 ) { NewChannel.Set_Mode( mode, frame ); }
AnimMode Get_Mode( void ) { return NewChannel.Get_Mode(); }
bool Is_Complete( void ) { return NewChannel.Is_Complete(); }
const char *Get_Animation_Name( void ) { return NewChannel.Get_Animation_Name(); }
void Set_Target_Frame( float frame ) { NewChannel.Set_Target_Frame ( frame ); }
float Get_Target_Frame( void ) { return NewChannel.Get_Target_Frame(); }
HAnimClass *Peek_Animation( void ) { return NewChannel.Peek_Animation (); }
// Update the animation
void Update( float dtime );
// Get Animation Data
void Get_Animation_Data( AnimationDataList & list, float weight = 1.0f );
// Update Model
void Update_Model( RenderObjClass *anim_model );
// Data Access
float Get_Frame( void ) { return NewChannel.Get_Frame(); }
float Get_Progress( void ) { return NewChannel.Get_Progress(); }
private:
AnimChannelClass NewChannel;
AnimChannelClass OldChannel;
float BlendTimer; // in seconds
float BlendTotal; // in seconds
};
/*
** AnimControlClass
*/
class AnimControlClass {
public:
// Constructor and Destructor
AnimControlClass( void );
virtual ~AnimControlClass( void );
virtual bool Save( ChunkSaveClass & csave );
virtual bool Load( ChunkLoadClass & cload );
// Set Model
virtual void Set_Model( RenderObjClass *anim_model );
virtual RenderObjClass *Peek_Model( void ) { return Model; }
// Set Animation
virtual void Set_Animation( const char *name, float blendtime = 0.0f, float start_frame = 0.0f ) = 0;
virtual void Set_Animation( const HAnimClass * anim, float blendtime = 0.0f, float start_frame = 0.0f ) = 0;
virtual void Set_Mode( AnimMode mode, float frame = -1 ) = 0;
virtual AnimMode Get_Mode( void ) = 0;
virtual bool Is_Complete( void ) = 0;
virtual const char *Get_Animation_Name( void ) = 0;
virtual void Set_Target_Frame( float frame ) = 0;
virtual float Get_Target_Frame( void ) = 0;
virtual float Get_Current_Frame( void ) = 0;
virtual HAnimClass * Peek_Animation( void ) { return NULL; }
// Update the animation
virtual void Update( float dtime ) = 0;
protected:
RenderObjClass *Model;
};
/*
** SimpleAnimControlClass
*/
class SimpleAnimControlClass : public AnimControlClass {
public:
// Constructor and Destructor
SimpleAnimControlClass( void );
~SimpleAnimControlClass( void );
virtual bool Save( ChunkSaveClass & csave );
virtual bool Load( ChunkLoadClass & cload );
// Set Animation
virtual void Set_Animation( const char *name, float blendtime = 0.0f, float start_frame = 0.0f );
virtual void Set_Animation( const HAnimClass * anim, float blendtime = 0.0f, float start_frame = 0.0f );
virtual void Set_Mode( AnimMode mode, float frame = -1 ) { Channel.Set_Mode( mode, frame ); }
virtual AnimMode Get_Mode( void ) { return Channel.Get_Mode(); }
virtual bool Is_Complete( void ) { return Channel.Is_Complete(); }
virtual const char *Get_Animation_Name( void ) { return Channel.Get_Animation_Name(); }
virtual void Set_Target_Frame( float frame ) { Channel.Set_Target_Frame( frame ); }
virtual float Get_Target_Frame( void ) { return Channel.Get_Target_Frame(); }
virtual float Get_Current_Frame( void ) { return Channel.Get_Frame(); }
// Update the animation
virtual void Update( float dtime );
private:
BlendableAnimChannelClass Channel;
};
/*
** HumanAnimControlClass
*/
class HumanAnimControlClass : public AnimControlClass {
public:
// Constructor and Destructor
HumanAnimControlClass( void );
~HumanAnimControlClass( void );
virtual bool Save( ChunkSaveClass & csave );
virtual bool Load( ChunkLoadClass & cload );
virtual void Set_Model( RenderObjClass *anim_model );
// Set Animation
virtual void Set_Animation( const char *name, float blendtime = 0.0f, float start_frame = 0.0f );
virtual void Set_Animation( const HAnimClass * anim, float blendtime = 0.0f, float start_frame = 0.0f );
virtual void Set_Animation( const char *name1, const char * name2, float ratio, float blendtime = 0.0f );
virtual void Set_Mode( AnimMode mode, float frame = -1 );
virtual AnimMode Get_Mode( void ) { return Channel1.Get_Mode(); }
virtual bool Is_Complete( void ) { return Channel1.Is_Complete(); }
virtual const char *Get_Animation_Name( void ) { return Channel1.Get_Animation_Name(); }
virtual float Get_Frame( void ) { return Channel1.Get_Frame(); }
virtual float Get_Progress( void ) { return Channel1.Get_Progress(); }
virtual void Set_Target_Frame( float frame ) { Channel1.Set_Target_Frame( frame ); }
virtual float Get_Target_Frame( void ) { return Channel1.Get_Target_Frame(); }
virtual float Get_Current_Frame( void ) { return Channel1.Get_Frame(); }
virtual void Set_Anim_Speed_Scale( float speed ) { AnimSpeedScale = speed; }
virtual void Update( float dtime );
virtual HAnimClass * Peek_Animation( void ) { return Channel1.Peek_Animation(); }
void Get_Information( StringClass & string );
char Get_Skeleton( void ) { return Skeleton; }
private:
BlendableAnimChannelClass Channel1;
BlendableAnimChannelClass Channel2;
float Channel2Ratio;
float AnimSpeedScale;
AnimationDataList DataList;
HAnimComboClass AnimCombo;
char Skeleton;
void Build_Skeleton_Anim_Name( StringClass& new_name, const char * name );
};
#endif // ANIMCONTROL_H