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/ww3d2/hanim.h

265 lines
9.5 KiB
C++

/*
** 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/>.
*/
/* $Header: /Commando/Code/ww3d2/hanim.h 3 12/13/01 7:01p Patrick $ */
/***********************************************************************************************
*** Confidential - Westwood Studios ***
***********************************************************************************************
* *
* Project Name : Commando / G 3D Library *
* *
* $Archive:: /Commando/Code/ww3d2/hanim.h $*
* *
* Author:: Greg_h *
* *
* $Modtime:: 12/13/01 6:54p $*
* *
* $Revision:: 3 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef HANIM_H
#define HANIM_H
#include "always.h"
#include "quat.h"
#include "refcount.h"
#include "w3d_file.h"
#include "hash.h"
#include "mempool.h"
#include <refcount.h>
#include <slist.h>
#include <vector.h>
struct NodeMotionStruct;
class MotionChannelClass;
class BitChannelClass;
class HTreeClass;
class ChunkLoadClass;
class ChunkSaveClass;
class HTreeClass;
/**********************************************************************************
HAnimClass
This is the base class for all animation formats used in W3D. It
contains the virtual interface that all animations must support.
**********************************************************************************/
class HAnimClass : public RefCountClass, public HashableClass
{
public:
HAnimClass(void) :
HasEmbeddedSounds (false) { }
virtual ~HAnimClass(void) { }
virtual const char * Get_Name(void) const = 0;
virtual const char * Get_HName(void) const = 0;
virtual const char * Get_Key( void ) { return Get_Name(); }
virtual int Get_Num_Frames(void) = 0;
virtual float Get_Frame_Rate() = 0;
virtual float Get_Total_Time() = 0;
// virtual Vector3 Get_Translation(int pividx,float frame) = 0;
// virtual Quaternion Get_Orientation(int pividx,float frame) = 0;
// Jani: Changed to pass in reference of destination to avoid copying
virtual void Get_Translation(int pividx,float frame) {} // todo: remove
virtual void Get_Orientation(int pividx,float frame) {} // todo: remove
virtual void Get_Translation(Vector3& translation, int pividx,float frame) const = 0;
virtual void Get_Orientation(Quaternion& orientation, int pividx,float frame) const = 0;
virtual void Get_Transform(Matrix3D&, int pividx, float frame) const = 0;
virtual bool Get_Visibility(int pividx,float frame) = 0;
virtual int Get_Num_Pivots(void) const = 0;
virtual bool Is_Node_Motion_Present(int pividx) = 0;
// Methods that test the presence of a certain motion channel.
virtual bool Has_X_Translation (int pividx) { return true; }
virtual bool Has_Y_Translation (int pividx) { return true; }
virtual bool Has_Z_Translation (int pividx) { return true; }
virtual bool Has_Rotation (int pividx) { return true; }
virtual bool Has_Visibility (int pividx) { return true; }
// Animated sound-triggering support
virtual bool Has_Embedded_Sounds (void) const { return HasEmbeddedSounds; }
virtual void Set_Has_Embedded_Sounds (bool onoff) { HasEmbeddedSounds = onoff; }
protected:
bool HasEmbeddedSounds;
};
/*
** The PivotMapClass is used by the HAnimComboDataClass (sometimes) to keep track of animation
** weights per-pivot point.
*/
class NamedPivotMapClass;
class PivotMapClass : public DynamicVectorClass<float>, public RefCountClass
{
public:
virtual NamedPivotMapClass * As_Named_Pivot_Map() { return 0; }
};
/*
** The NamedPivotMapClass allows us to create HAnimComboDataClass objects with pivot maps without
** having to have the HAnim available. Later, when an HAnim is retrieved from the asset manager,
** the pivot map can be updated to produce the correct map.
*/
class NamedPivotMapClass : public PivotMapClass
{
public:
~NamedPivotMapClass(void);
virtual NamedPivotMapClass * As_Named_Pivot_Map() { return this; }
// add a name & weight to the arrays
void Add(const char *Name, float Weight);
// configure the base pivot map using the specified tree
void Update_Pivot_Map(const HTreeClass *Tree);
private:
// This info is packaged into a struct to minimize DynamicVectorClass overhead
struct WeightInfoStruct {
WeightInfoStruct() : Name(0) {}
~WeightInfoStruct() { if(Name) delete [] Name; }
char *Name;
float Weight;
// operators required for the DynamicVectorClass
WeightInfoStruct & operator = (WeightInfoStruct const &that);
bool operator == (WeightInfoStruct const &that) const { return &that == this; }
bool operator != (WeightInfoStruct const &that) const { return &that != this; }
};
DynamicVectorClass<WeightInfoStruct> WeightInfo;
};
/*
** The HAnimComboDataClass is used by the new HAnimComboClass to allow for a mix of shared/unshared data
** which will allow us to have the anim combo refer to data whereever we wish to put it.
*/
class HAnimComboDataClass : public AutoPoolClass<HAnimComboDataClass,256> {
public:
HAnimComboDataClass(bool shared = false);
HAnimComboDataClass(const HAnimComboDataClass &);
~HAnimComboDataClass(void);
void Copy(const HAnimComboDataClass *);
void Clear(void);
void Set_HAnim(HAnimClass *motion);
void Give_HAnim(HAnimClass *motion) { if(HAnim) HAnim->Release_Ref(); HAnim = motion; } // used for giving this object the reference
void Set_Frame(float frame) { PrevFrame = Frame; Frame = frame; }
void Set_Prev_Frame(float frame) { PrevFrame = frame; }
void Set_Weight(float weight) { Weight = weight; }
void Set_Pivot_Map(PivotMapClass *map);
HAnimClass * Peek_HAnim(void) const { return HAnim; } // note: does not add reference
HAnimClass * Get_HAnim(void) const { if(HAnim) HAnim->Add_Ref(); return HAnim; } // note: does not add reference
float Get_Frame(void) const { return Frame; }
float Get_Prev_Frame(void) const { return PrevFrame; }
float Get_Weight(void) const { return Weight; }
PivotMapClass * Peek_Pivot_Map(void) const { return PivotMap; }
PivotMapClass * Get_Pivot_Map(void) const { if(PivotMap) PivotMap->Add_Ref(); return PivotMap; }
bool Is_Shared(void) const { return Shared; }
void Build_Active_Pivot_Map(void);
private:
HAnimClass *HAnim;
float Frame;
float PrevFrame;
float Weight;
PivotMapClass * PivotMap;
bool Shared; // this is set to false when the HAnimCombo allocates it
};
/*
** defines a combination of animations for blending/mixing
*/
class HAnimComboClass {
public:
HAnimComboClass(void);
HAnimComboClass( int num_animations ); // allocates specified number of channels and sets then all to not-shared
~HAnimComboClass(void);
void Clear( void ); // zeros all data
void Reset( void ); // empties the dynamic vector
bool Normalize_Weights(void); // Normalizes all weights (returns true if succeeded)
int Get_Num_Anims( void ) { return HAnimComboData.Count(); }
void Set_Motion( int indx, HAnimClass *motion );
HAnimClass *Get_Motion( int indx );
HAnimClass *Peek_Motion( int indx );
void Set_Frame( int indx, float frame );
void Set_Prev_Frame( int indx, float frame );
float Get_Frame( int indx );
float Get_Prev_Frame( int indx );
void Set_Weight( int indx, float weight );
float Get_Weight( int indx );
void Set_Pivot_Weight_Map( int indx, PivotMapClass * map );
PivotMapClass * Get_Pivot_Weight_Map( int indx );
PivotMapClass * Peek_Pivot_Weight_Map( int indx );
// add an entry to the dynamic vector
void Append_Anim_Combo_Data(HAnimComboDataClass * AnimComboData);
// remove an entry from the vector
void Remove_Anim_Combo_Data(HAnimComboDataClass * AnimComboData);
// retrieve a specific combo data
HAnimComboDataClass * Peek_Anim_Combo_Data(int index) { return HAnimComboData[index]; }
protected:
DynamicVectorClass<HAnimComboDataClass *> HAnimComboData;
};
#endif