curve.cpp

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(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 : WWMath                                                       *
 *                                                                                             *
 *                     $Archive:: /VSS_Sync/wwmath/curve.cpp                                  $*
 *                                                                                             *
 *              Original Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                      $Author:: Vss_sync                                                    $*
 *                                                                                             *
 *                     $Modtime:: 6/13/01 2:18p                                               $*
 *                                                                                             *
 *                    $Revision:: 9                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 
#include "curve.h"
#include "wwdebug.h"
#include "persistfactory.h"
#include "wwmathids.h"
#include "wwhack.h"
 
/*
** Force-Link this module because the linker can't detect that we actually need it...
*/
DECLARE_FORCE_LINK(curve);
 
/*
** Persist factories and chunk-id's used to save and load.
*/
SimplePersistFactoryClass<LinearCurve3DClass,WWMATH_CHUNKID_LINEARCURVE3D>    _LinearCurve3DFactory;
SimplePersistFactoryClass<LinearCurve1DClass,WWMATH_CHUNKID_LINEARCURVE1D>    _LinearCurve1DFactory;
 
enum 
{
    // ID's used by Curve3D
    CURVE3D_CHUNK_VARIABLES                  = 0x00020651,           
    CURVE3D_CHUNK_KEYS,           
 
    CURVE3D_VARIABLE_ISLOOPING                = 0x00,
    CURVE3D_VARIABLE_KEYCOUNT,
 
    // ID's used by LinearCurve3D
    LINEARCURVE3D_CHUNK_CURVE3D          = 0x00020653,
 
    // ID's used by Curve1D
    CURVE1D_CHUNK_VARIABLES                  = 0x00020655,           
    CURVE1D_CHUNK_KEYS,           
 
    CURVE1D_VARIABLE_ISLOOPING                = 0x00,
    CURVE1D_VARIABLE_KEYCOUNT,
 
    // ID's used by LinearCurve1D
    LINEARCURVE1D_CHUNK_CURVE1D          = 0x00020657,
 
};
 
 
/***********************************************************************************************
**
** Curve3DCLass Implementation
**
***********************************************************************************************/
Curve3DClass::Curve3DClass(void) :
    IsLooping(false)
{
}
 
Curve3DClass::Curve3DClass(const Curve3DClass & that)
{
    *this = that;
}
 
Curve3DClass::~Curve3DClass(void)
{
}
 
Curve3DClass & Curve3DClass::operator = (const Curve3DClass & that)
{
    IsLooping = that.IsLooping;
    Keys = that.Keys;
    return *this;
}
 
bool Curve3DClass::Is_Looping(void)
{
    return IsLooping;
}
 
void Curve3DClass::Set_Looping(bool onoff)
{
    IsLooping = onoff;
}
 
float Curve3DClass::Get_Start_Time(void)
{
    if (Keys.Count() > 0) {
        return Keys[0].Time;
    } else {
        return 0.0f;
    }
}
 
float Curve3DClass::Get_End_Time(void)
{
    if (Keys.Count() > 0) {
        return Keys[Keys.Count() - 1].Time;
    } else {
        return 0.0f;
    }
}
 
int Curve3DClass::Key_Count(void)
{
    return Keys.Count();
}
 
void Curve3DClass::Get_Key(int i,Vector3 * set_point,float * set_t)
{
    assert(i >= 0);
    assert(i < Keys.Count());
    if (set_point != NULL) {
        *set_point = Keys[i].Point;
    }
    if (set_t != NULL) {
        *set_t = Keys[i].Time;
    }
}
 
void Curve3DClass::Set_Key(int i,const Vector3 & point)
{
    assert(i >= 0);
    assert(i < Keys.Count());
    Keys[i].Point = point;
}   
 
 
int Curve3DClass::Add_Key(const Vector3 & point,float t)
{
    int idx = 0;
    while (idx < Keys.Count() && Keys[idx].Time < t) {
        idx++;
    }
 
    KeyClass newkey;
    newkey.Point = point;
    newkey.Time = t;
 
    Keys.Insert(idx,newkey);
    return idx;
}   
 
void Curve3DClass::Remove_Key(int i)
{
    assert(i >= 0);
    assert(i < Keys.Count());
    Keys.Delete(i); 
}
 
void Curve3DClass::Clear_Keys(void)
{
    Keys.Clear();
}
 
void Curve3DClass::Find_Interval(float time,int * i0,int * i1,float * t)
{
    WWASSERT(time >= Keys[0].Time);
    WWASSERT(time <= Keys[Keys.Count()-1].Time);
 
    int i=0;
    while (time > Keys[i+1].Time) {
        i++;
    }
    *i0 = i;
    *i1 = i+1;
    *t = (time - Keys[i].Time) / (Keys[i+1].Time - Keys[i].Time);
}
 
bool Curve3DClass::Save(ChunkSaveClass & csave)
{
    int keycount = Keys.Count();
    csave.Begin_Chunk(CURVE3D_CHUNK_VARIABLES);
    WRITE_MICRO_CHUNK(csave,CURVE3D_VARIABLE_ISLOOPING,IsLooping);
    WRITE_MICRO_CHUNK(csave,CURVE3D_VARIABLE_KEYCOUNT,keycount);
    csave.End_Chunk();
 
    // Saving the keys, Note that if the format of a key changes we'll
    // need a new chunk. (I didn't wrap each variable in its own chunk)
    csave.Begin_Chunk(CURVE3D_CHUNK_KEYS);         
    for (int i=0; i<keycount; i++) {
        csave.Write(&(Keys[i].Point),sizeof(Keys[i].Point));
        csave.Write(&(Keys[i].Time),sizeof(Keys[i].Time));
    }
    csave.End_Chunk();
    return true;
}
 
bool Curve3DClass::Load(ChunkLoadClass & cload)
{
    int i;
    int keycount = 0;
    KeyClass newkey;
 
    // reset the curve
    Keys.Delete_All();
 
    // read in the chunks
    while (cload.Open_Chunk()) {
        
        switch(cload.Cur_Chunk_ID()) 
        {
            case CURVE3D_CHUNK_VARIABLES:
            
                while (cload.Open_Micro_Chunk()) {
                    switch(cload.Cur_Micro_Chunk_ID()) {
                        READ_MICRO_CHUNK(cload,CURVE3D_VARIABLE_ISLOOPING,IsLooping);
                        READ_MICRO_CHUNK(cload,CURVE3D_VARIABLE_KEYCOUNT,keycount);
                    }
                    cload.Close_Micro_Chunk(); 
                }
                break;
 
            case CURVE3D_CHUNK_KEYS:
                for (i=0; i<keycount; i++) {
                    cload.Read(&(newkey.Point),sizeof(newkey.Point));
                    cload.Read(&(newkey.Time),sizeof(newkey.Time));
                    Keys.Add(newkey);
                }
                break;
 
            default:
                WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",__FILE__,__LINE__));
                break;
        }
        cload.Close_Chunk();
    }
 
    return true;
}
 
 
 
/***********************************************************************************************
**
** LinearCurve3DClass Implementation
** Linear curve, linearly interpolates the keys
**
***********************************************************************************************/
void LinearCurve3DClass::Evaluate(float time,Vector3 * set_val)
{
    if (time < Keys[0].Time) {
        *set_val = Keys[0].Point;
        return;
    }
 
    if (time >= Keys[Keys.Count() - 1].Time) {
        *set_val = Keys[Keys.Count() - 1].Point;
        return;
    }
 
    int i0,i1;
    float t;
    Find_Interval(time,&i0,&i1,&t);
 
    *set_val = Keys[i0].Point + t * (Keys[i1].Point - Keys[i0].Point);
}
 
const PersistFactoryClass & LinearCurve3DClass::Get_Factory(void) const
{
    return _LinearCurve3DFactory;
}
 
bool LinearCurve3DClass::Save(ChunkSaveClass & csave)
{
    csave.Begin_Chunk(LINEARCURVE3D_CHUNK_CURVE3D);
    Curve3DClass::Save(csave);
    csave.End_Chunk();
    return true;
}
 
bool LinearCurve3DClass::Load(ChunkLoadClass & cload)
{
    while (cload.Open_Chunk()) {
        
        switch(cload.Cur_Chunk_ID()) 
        {
            case LINEARCURVE3D_CHUNK_CURVE3D:
                Curve3DClass::Load(cload);
                break;
 
            default:
                WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",__FILE__,__LINE__));
                break;
        }
        cload.Close_Chunk();
    }
 
    return true;
}
 
 
/***********************************************************************************************
**
** Curve1DClass
**
***********************************************************************************************/
Curve1DClass::Curve1DClass(void) :
    IsLooping(false)
{
}
 
Curve1DClass::Curve1DClass(const Curve1DClass & that)
{
    *this = that;
}
 
Curve1DClass::~Curve1DClass(void)
{
}
 
Curve1DClass & Curve1DClass::operator = (const Curve1DClass & that)
{
    IsLooping = that.IsLooping;
    Keys = that.Keys;
    return *this;
}
 
bool Curve1DClass::Is_Looping(void)
{
    return IsLooping;
}
 
void Curve1DClass::Set_Looping(bool onoff)
{
    IsLooping = onoff;
}
 
float Curve1DClass::Get_Start_Time(void)
{
    if (Keys.Count() > 0) {
        return Keys[0].Time;
    } else {
        return 0.0f;
    }
}
 
float Curve1DClass::Get_End_Time(void)
{
    if (Keys.Count() > 0) {
        return Keys[Keys.Count() - 1].Time;
    } else {
        return 0.0f;
    }
}
 
int Curve1DClass::Key_Count(void)
{
    return Keys.Count();
}
 
void Curve1DClass::Get_Key(int i,float * set_point,float * set_t,unsigned int * extra)
{
    assert(i >= 0);
    assert(i < Keys.Count());
    if (set_point != NULL) {
        *set_point = Keys[i].Point;
    }
    if (set_t != NULL) {
        *set_t = Keys[i].Time;
    }
    if (extra != NULL) {
        *extra = Keys[i].Extra;
    }
}
 
void Curve1DClass::Set_Key(int i,float point,unsigned int extra)
{
    assert(i >= 0);
    assert(i < Keys.Count());
    Keys[i].Point = point;
    Keys[i].Extra = extra;
}   
 
 
int Curve1DClass::Add_Key(float point,float t,unsigned int extra)
{
    int idx = 0;
    while (idx < Keys.Count() && Keys[idx].Time < t) {
        idx++;
    }
 
    KeyClass newkey;
    newkey.Point = point;
    newkey.Time = t;
    newkey.Extra = extra;
 
    Keys.Insert(idx,newkey);
    return idx;
}   
 
void Curve1DClass::Remove_Key(int i)
{
    assert(i >= 0);
    assert(i < Keys.Count());
    Keys.Delete(i); 
}
 
void Curve1DClass::Clear_Keys(void)
{
    Keys.Clear();
}
 
void Curve1DClass::Find_Interval(float time,int * i0,int * i1,float * t)
{
    if (IsLooping) {
        if (time < Keys[0].Time) {
            *i0 = Keys.Count() - 1;
            *i1 = 0;
            float interval = 1.0f - Keys[*i0].Time + Keys[*i1].Time;
            *t = (1.0f - Keys[*i0].Time + time) / interval;
            return;
        }
        else if (time > Keys[Keys.Count() - 1].Time) {
            *i0 = Keys.Count() - 1;
            *i1 = 0;
            float interval = 1.0f - Keys[*i0].Time + Keys[*i1].Time;
            *t = (time - Keys[*i0].Time) / interval;
            return;
        }
    }
    else {
        WWASSERT(time >= Keys[0].Time);
        WWASSERT(time <= Keys[Keys.Count()-1].Time);
    }
 
    int i=0;
    while (time > Keys[i+1].Time) {
        i++;
    }
    *i0 = i;
    *i1 = i+1;
    *t = (time - Keys[i].Time) / (Keys[i+1].Time - Keys[i].Time);
}
 
bool Curve1DClass::Save(ChunkSaveClass & csave)
{
    int keycount = Keys.Count();
    csave.Begin_Chunk(CURVE1D_CHUNK_VARIABLES);
    WRITE_MICRO_CHUNK(csave,CURVE1D_VARIABLE_ISLOOPING,IsLooping);
    WRITE_MICRO_CHUNK(csave,CURVE1D_VARIABLE_KEYCOUNT,keycount);
    csave.End_Chunk();
 
    // Saving the keys, Note that if the format of a key changes we'll
    // need a new chunk. (I didn't wrap each variable in its own chunk)
    csave.Begin_Chunk(CURVE1D_CHUNK_KEYS);
    for (int i=0; i<keycount; i++) {
        csave.Write(&(Keys[i].Point),sizeof(Keys[i].Point));
        csave.Write(&(Keys[i].Time),sizeof(Keys[i].Time));
        csave.Write(&(Keys[i].Extra),sizeof(Keys[i].Extra));
    }
    csave.End_Chunk();
    return true;
}
 
bool Curve1DClass::Load(ChunkLoadClass & cload)
{
    int i;
    int keycount = 0;
    KeyClass newkey;
 
    // reset the curve
    Keys.Delete_All();
 
    // read in the chunks
    while (cload.Open_Chunk()) {
        
        switch(cload.Cur_Chunk_ID()) 
        {
            case CURVE1D_CHUNK_VARIABLES:
            
                while (cload.Open_Micro_Chunk()) {
                    switch(cload.Cur_Micro_Chunk_ID()) {
                        READ_MICRO_CHUNK(cload,CURVE1D_VARIABLE_ISLOOPING,IsLooping);
                        READ_MICRO_CHUNK(cload,CURVE1D_VARIABLE_KEYCOUNT,keycount);
                    }
                    cload.Close_Micro_Chunk(); 
                }
                break;
 
            case CURVE1D_CHUNK_KEYS:
                for (i=0; i<keycount; i++) {
                    cload.Read(&(newkey.Point),sizeof(newkey.Point));
                    cload.Read(&(newkey.Time),sizeof(newkey.Time));
                    cload.Read(&(newkey.Extra),sizeof(newkey.Extra));
                    Keys.Add(newkey);
                }
                break;
 
            default:
                WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",__FILE__,__LINE__));
                break;
        }
        cload.Close_Chunk();
    }
 
    return true;
}
 
/***********************************************************************************************
**
** LinearCurve1DClass, linearly interpolates the keys
**
***********************************************************************************************/
void LinearCurve1DClass::Evaluate(float time,float * set_val)
{
    if (!IsLooping) {
        if (time < Keys[0].Time) {
            *set_val = Keys[0].Point;
            return;
        }
 
        if (time >= Keys[Keys.Count() - 1].Time) {
            *set_val = Keys[Keys.Count() - 1].Point;
            return;
        }
    }
 
    int i0,i1;
    float t;
    Find_Interval(time,&i0,&i1,&t);
 
    *set_val = Keys[i0].Point + t * (Keys[i1].Point - Keys[i0].Point);
}
 
const PersistFactoryClass & LinearCurve1DClass::Get_Factory(void) const
{
    return _LinearCurve1DFactory;
}
 
bool LinearCurve1DClass::Save(ChunkSaveClass & csave)
{
    csave.Begin_Chunk(LINEARCURVE1D_CHUNK_CURVE1D);
    Curve1DClass::Save(csave);
    csave.End_Chunk();
    return true;
}
 
bool LinearCurve1DClass::Load(ChunkLoadClass & cload)
{
    while (cload.Open_Chunk()) {
        
        switch(cload.Cur_Chunk_ID()) 
        {
            case LINEARCURVE1D_CHUNK_CURVE1D:
                Curve1DClass::Load(cload);
                break;
 
            default:
                WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",__FILE__,__LINE__));
                break;
        }
        cload.Close_Chunk();
    }
 
    return true;
}