1141 lines
21 KiB
C++
1141 lines
21 KiB
C++
/*
|
|
Copyright (C) 1999-2006 Id Software, Inc. and contributors.
|
|
For a list of contributors, see the accompanying CONTRIBUTORS file.
|
|
|
|
This file is part of GtkRadiant.
|
|
|
|
GtkRadiant 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 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifndef __SPLINES_H
|
|
#define __SPLINES_H
|
|
|
|
#define GTKRADIANT
|
|
|
|
#ifdef GTKRADIANT
|
|
#include "igl.h"
|
|
#endif
|
|
|
|
#include "util_list.h"
|
|
#include "util_str.h"
|
|
#include "math_vector.h"
|
|
|
|
typedef int fileHandle_t;
|
|
|
|
extern void glBox( idVec3 &color, idVec3 &point, float size );
|
|
extern void glLabeledPoint( idVec3 &color, idVec3 &point, float size, const char *label );
|
|
|
|
static idVec4 blue( 0, 0, 1, 1 );
|
|
static idVec4 red( 1, 0, 0, 1 );
|
|
|
|
class idPointListInterface {
|
|
public:
|
|
idPointListInterface() {
|
|
selectedPoints.Clear();
|
|
};
|
|
virtual ~idPointListInterface() {
|
|
};
|
|
|
|
virtual int numPoints() {
|
|
return 0;
|
|
}
|
|
|
|
virtual void addPoint( const float x, const float y, const float z ) {
|
|
}
|
|
virtual void addPoint( const idVec3 &v ) {
|
|
}
|
|
virtual void removePoint( int index ) {
|
|
}
|
|
virtual idVec3 *getPoint( int index ) {
|
|
return NULL;
|
|
}
|
|
|
|
int selectPointByRay( float ox, float oy, float oz, float dx, float dy, float dz, bool single ) {
|
|
idVec3 origin( ox, oy, oz );
|
|
idVec3 dir( dx, dy, dz );
|
|
return selectPointByRay( origin, dir, single );
|
|
}
|
|
|
|
int selectPointByRay( const idVec3 origin, const idVec3 direction, bool single ) {
|
|
int i, besti, count;
|
|
float d, bestd;
|
|
idVec3 temp, temp2;
|
|
|
|
// find the point closest to the ray
|
|
besti = -1;
|
|
bestd = 8;
|
|
count = numPoints();
|
|
|
|
for ( i = 0; i < count; i++ ) {
|
|
temp = *getPoint( i );
|
|
temp2 = temp;
|
|
temp -= origin;
|
|
d = DotProduct( temp, direction );
|
|
__VectorMA( origin, d, direction, temp );
|
|
temp2 -= temp;
|
|
d = temp2.Length();
|
|
if ( d <= bestd ) {
|
|
bestd = d;
|
|
besti = i;
|
|
}
|
|
}
|
|
|
|
if ( besti >= 0 ) {
|
|
selectPoint( besti, single );
|
|
}
|
|
|
|
return besti;
|
|
}
|
|
|
|
int isPointSelected( int index ) {
|
|
int count = selectedPoints.Num();
|
|
for ( int i = 0; i < count; i++ ) {
|
|
if ( selectedPoints[i] == index ) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int selectPoint( int index, bool single ) {
|
|
if ( index >= 0 && index < numPoints() ) {
|
|
if ( single ) {
|
|
deselectAll();
|
|
}
|
|
else {
|
|
if ( isPointSelected( index ) >= 0 ) {
|
|
selectedPoints.Remove( index );
|
|
}
|
|
}
|
|
return selectedPoints.Append( index );
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void selectAll() {
|
|
selectedPoints.Clear();
|
|
for ( int i = 0; i < numPoints(); i++ ) {
|
|
selectedPoints.Append( i );
|
|
}
|
|
}
|
|
|
|
void deselectAll() {
|
|
selectedPoints.Clear();
|
|
}
|
|
|
|
int numSelectedPoints();
|
|
|
|
idVec3 *getSelectedPoint( int index ) {
|
|
assert( index >= 0 && index < numSelectedPoints() );
|
|
return getPoint( selectedPoints[index] );
|
|
}
|
|
|
|
virtual void updateSelection( float x, float y, float z ) {
|
|
idVec3 move( x, y, z );
|
|
updateSelection( move );
|
|
}
|
|
|
|
virtual void updateSelection( const idVec3 &move ) {
|
|
int count = selectedPoints.Num();
|
|
for ( int i = 0; i < count; i++ ) {
|
|
*getPoint( selectedPoints[i] ) += move;
|
|
}
|
|
}
|
|
|
|
void drawSelection() {
|
|
int count = selectedPoints.Num();
|
|
for ( int i = 0; i < count; i++ ) {
|
|
glBox( red, *getPoint( selectedPoints[i] ), 4 );
|
|
}
|
|
}
|
|
|
|
protected:
|
|
idList<int> selectedPoints;
|
|
|
|
};
|
|
|
|
|
|
class idSplineList {
|
|
|
|
public:
|
|
|
|
idSplineList() {
|
|
clear();
|
|
}
|
|
|
|
idSplineList( const char *p ) {
|
|
clear();
|
|
name = p;
|
|
};
|
|
|
|
~idSplineList() {
|
|
clear();
|
|
};
|
|
|
|
void clearControl() {
|
|
for ( int i = 0; i < controlPoints.Num(); i++ ) {
|
|
delete controlPoints[i];
|
|
}
|
|
controlPoints.Clear();
|
|
}
|
|
|
|
void clearSpline() {
|
|
for ( int i = 0; i < splinePoints.Num(); i++ ) {
|
|
delete splinePoints[i];
|
|
}
|
|
splinePoints.Clear();
|
|
}
|
|
|
|
void parse( const char *( *text ) );
|
|
void write( fileHandle_t file, const char *name );
|
|
|
|
void clear() {
|
|
clearControl();
|
|
clearSpline();
|
|
splineTime.Clear();
|
|
selected = NULL;
|
|
dirty = true;
|
|
activeSegment = 0;
|
|
granularity = 0.025f;
|
|
pathColor.set( 1.0f, 0.5f, 0.0f );
|
|
controlColor.set( 0.7f, 0.0f, 1.0f );
|
|
segmentColor.set( 0.0f, 0.0f, 1.0f );
|
|
activeColor.set( 1.0f, 0.0f, 0.0f );
|
|
}
|
|
|
|
void initPosition( long startTime, long totalTime );
|
|
const idVec3 *getPosition( long time );
|
|
|
|
|
|
void draw( bool editMode );
|
|
void addToRenderer();
|
|
|
|
void setSelectedPoint( idVec3 *p );
|
|
idVec3 *getSelectedPoint() {
|
|
return selected;
|
|
}
|
|
|
|
void addPoint( const idVec3 &v ) {
|
|
controlPoints.Append( new idVec3( v ) );
|
|
dirty = true;
|
|
}
|
|
|
|
void addPoint( float x, float y, float z ) {
|
|
controlPoints.Append( new idVec3( x, y, z ) );
|
|
dirty = true;
|
|
}
|
|
|
|
void updateSelection( const idVec3 &move );
|
|
|
|
void startEdit() {
|
|
editMode = true;
|
|
}
|
|
|
|
void stopEdit() {
|
|
editMode = false;
|
|
}
|
|
|
|
void buildSpline();
|
|
|
|
void setGranularity( float f ) {
|
|
granularity = f;
|
|
}
|
|
|
|
float getGranularity() {
|
|
return granularity;
|
|
}
|
|
|
|
int numPoints() {
|
|
return controlPoints.Num();
|
|
}
|
|
|
|
idVec3 *getPoint( int index ) {
|
|
assert( index >= 0 && index < controlPoints.Num() );
|
|
return controlPoints[index];
|
|
}
|
|
|
|
idVec3 *getSegmentPoint( int index ) {
|
|
assert( index >= 0 && index < splinePoints.Num() );
|
|
return splinePoints[index];
|
|
}
|
|
|
|
|
|
void setSegmentTime( int index, int time ) {
|
|
assert( index >= 0 && index < splinePoints.Num() );
|
|
splineTime[index] = time;
|
|
}
|
|
|
|
int getSegmentTime( int index ) {
|
|
assert( index >= 0 && index < splinePoints.Num() );
|
|
return (int)splineTime[index];
|
|
}
|
|
void addSegmentTime( int index, int time ) {
|
|
assert( index >= 0 && index < splinePoints.Num() );
|
|
splineTime[index] += time;
|
|
}
|
|
|
|
float totalDistance();
|
|
|
|
static idVec3 zero;
|
|
|
|
int getActiveSegment() {
|
|
return activeSegment;
|
|
}
|
|
|
|
void setActiveSegment( int i ) {
|
|
//assert(i >= 0 && (splinePoints.Num() > 0 && i < splinePoints.Num()));
|
|
activeSegment = i;
|
|
}
|
|
|
|
int numSegments() {
|
|
return splinePoints.Num();
|
|
}
|
|
|
|
void setColors( idVec3 &path, idVec3 &segment, idVec3 &control, idVec3 &active ) {
|
|
pathColor = path;
|
|
segmentColor = segment;
|
|
controlColor = control;
|
|
activeColor = active;
|
|
}
|
|
|
|
const char *getName() {
|
|
return name.c_str();
|
|
}
|
|
|
|
void setName( const char *p ) {
|
|
name = p;
|
|
}
|
|
|
|
bool validTime() {
|
|
if ( dirty ) {
|
|
buildSpline();
|
|
}
|
|
// gcc doesn't allow static casting away from bools
|
|
// why? I've no idea...
|
|
return (bool)( splineTime.Num() > 0 && splineTime.Num() == splinePoints.Num() );
|
|
}
|
|
|
|
void setTime( long t ) {
|
|
time = t;
|
|
}
|
|
|
|
void setBaseTime( long t ) {
|
|
baseTime = t;
|
|
}
|
|
|
|
protected:
|
|
idStr name;
|
|
float calcSpline( int step, float tension );
|
|
idList<idVec3*> controlPoints;
|
|
idList<idVec3*> splinePoints;
|
|
idList<double> splineTime;
|
|
idVec3 *selected;
|
|
idVec3 pathColor, segmentColor, controlColor, activeColor;
|
|
float granularity;
|
|
bool editMode;
|
|
bool dirty;
|
|
int activeSegment;
|
|
long baseTime;
|
|
long time;
|
|
friend class idCamera;
|
|
};
|
|
|
|
// time in milliseconds
|
|
// velocity where 1.0 equal rough walking speed
|
|
struct idVelocity {
|
|
idVelocity( long start, long duration, float s ) {
|
|
startTime = start;
|
|
time = duration;
|
|
speed = s;
|
|
}
|
|
long startTime;
|
|
long time;
|
|
float speed;
|
|
};
|
|
|
|
// can either be a look at or origin position for a camera
|
|
//
|
|
class idCameraPosition : public idPointListInterface {
|
|
public:
|
|
|
|
virtual void clearVelocities() {
|
|
for ( int i = 0; i < velocities.Num(); i++ ) {
|
|
delete velocities[i];
|
|
velocities[i] = NULL;
|
|
}
|
|
velocities.Clear();
|
|
}
|
|
|
|
virtual void clear() {
|
|
editMode = false;
|
|
clearVelocities();
|
|
}
|
|
|
|
idCameraPosition( const char *p ) {
|
|
name = p;
|
|
}
|
|
|
|
idCameraPosition() {
|
|
time = 0;
|
|
name = "position";
|
|
}
|
|
|
|
idCameraPosition( long t ) {
|
|
time = t;
|
|
}
|
|
|
|
virtual ~idCameraPosition() {
|
|
clear();
|
|
}
|
|
|
|
|
|
// this can be done with RTTI syntax but i like the derived classes setting a type
|
|
// makes serialization a bit easier to see
|
|
//
|
|
enum positionType {
|
|
FIXED = 0x00,
|
|
INTERPOLATED,
|
|
SPLINE,
|
|
POSITION_COUNT
|
|
};
|
|
|
|
|
|
virtual void start( long t ) {
|
|
startTime = t;
|
|
}
|
|
|
|
long getTime() {
|
|
return time;
|
|
}
|
|
|
|
virtual void setTime( long t ) {
|
|
time = t;
|
|
}
|
|
|
|
float getBaseVelocity() {
|
|
return baseVelocity;
|
|
}
|
|
|
|
float getVelocity( long t ) {
|
|
long check = t - startTime;
|
|
for ( int i = 0; i < velocities.Num(); i++ ) {
|
|
if ( check >= velocities[i]->startTime && check <= velocities[i]->startTime + velocities[i]->time ) {
|
|
return velocities[i]->speed;
|
|
}
|
|
}
|
|
return baseVelocity;
|
|
}
|
|
|
|
void addVelocity( long start, long duration, float speed ) {
|
|
velocities.Append( new idVelocity( start, duration, speed ) );
|
|
}
|
|
|
|
virtual const idVec3 *getPosition( long t ) {
|
|
assert( true );
|
|
return NULL;
|
|
}
|
|
|
|
virtual void draw( bool editMode ) {
|
|
};
|
|
|
|
virtual void parse( const char *( *text ) ) {
|
|
};
|
|
virtual void write( fileHandle_t file, const char *name );
|
|
virtual bool parseToken( const char *key, const char *( *text ) );
|
|
|
|
const char *getName() {
|
|
return name.c_str();
|
|
}
|
|
|
|
void setName( const char *p ) {
|
|
name = p;
|
|
}
|
|
|
|
virtual void startEdit() {
|
|
editMode = true;
|
|
}
|
|
|
|
virtual void stopEdit() {
|
|
editMode = false;
|
|
}
|
|
|
|
virtual void draw() {
|
|
};
|
|
|
|
const char *typeStr() {
|
|
return positionStr[static_cast<int>( type )];
|
|
}
|
|
|
|
void calcVelocity( float distance ) {
|
|
float secs = (float)time / 1000;
|
|
baseVelocity = distance / secs;
|
|
}
|
|
|
|
protected:
|
|
static const char* positionStr[POSITION_COUNT];
|
|
long startTime;
|
|
long time;
|
|
idCameraPosition::positionType type;
|
|
idStr name;
|
|
bool editMode;
|
|
idList<idVelocity*> velocities;
|
|
float baseVelocity;
|
|
};
|
|
|
|
class idFixedPosition : public idCameraPosition {
|
|
public:
|
|
|
|
void init() {
|
|
pos.Zero();
|
|
type = idCameraPosition::FIXED;
|
|
}
|
|
|
|
idFixedPosition() : idCameraPosition() {
|
|
init();
|
|
}
|
|
|
|
idFixedPosition( idVec3 p ) : idCameraPosition() {
|
|
init();
|
|
pos = p;
|
|
}
|
|
|
|
virtual void addPoint( const idVec3 &v ) {
|
|
pos = v;
|
|
}
|
|
|
|
virtual void addPoint( const float x, const float y, const float z ) {
|
|
pos.set( x, y, z );
|
|
}
|
|
|
|
|
|
~idFixedPosition() {
|
|
}
|
|
|
|
virtual const idVec3 *getPosition( long t ) {
|
|
return &pos;
|
|
}
|
|
|
|
void parse( const char *( *text ) );
|
|
void write( fileHandle_t file, const char *name );
|
|
|
|
virtual int numPoints() {
|
|
return 1;
|
|
}
|
|
|
|
virtual idVec3 *getPoint( int index ) {
|
|
if ( index != 0 ) {
|
|
assert( true );
|
|
}
|
|
;
|
|
return &pos;
|
|
}
|
|
|
|
virtual void draw( bool editMode ) {
|
|
glLabeledPoint( blue, pos, ( editMode ) ? 5 : 3, "Fixed point" );
|
|
}
|
|
|
|
protected:
|
|
idVec3 pos;
|
|
};
|
|
|
|
class idInterpolatedPosition : public idCameraPosition {
|
|
public:
|
|
|
|
void init() {
|
|
type = idCameraPosition::INTERPOLATED;
|
|
first = true;
|
|
startPos.Zero();
|
|
endPos.Zero();
|
|
}
|
|
|
|
idInterpolatedPosition() : idCameraPosition() {
|
|
init();
|
|
}
|
|
|
|
idInterpolatedPosition( idVec3 start, idVec3 end, long time ) : idCameraPosition( time ) {
|
|
init();
|
|
startPos = start;
|
|
endPos = end;
|
|
}
|
|
|
|
~idInterpolatedPosition() {
|
|
}
|
|
|
|
virtual const idVec3 *getPosition( long t );
|
|
|
|
void parse( const char *( *text ) );
|
|
void write( fileHandle_t file, const char *name );
|
|
|
|
virtual int numPoints() {
|
|
return 2;
|
|
}
|
|
|
|
virtual idVec3 *getPoint( int index ) {
|
|
assert( index >= 0 && index < 2 );
|
|
if ( index == 0 ) {
|
|
return &startPos;
|
|
}
|
|
return &endPos;
|
|
}
|
|
|
|
virtual void addPoint( const float x, const float y, const float z ) {
|
|
if ( first ) {
|
|
startPos.set( x, y, z );
|
|
first = false;
|
|
}
|
|
else {
|
|
endPos.set( x, y, z );
|
|
first = true;
|
|
}
|
|
}
|
|
|
|
virtual void addPoint( const idVec3 &v ) {
|
|
if ( first ) {
|
|
startPos = v;
|
|
first = false;
|
|
}
|
|
else {
|
|
endPos = v;
|
|
first = true;
|
|
}
|
|
}
|
|
|
|
virtual void draw( bool editMode ) {
|
|
glLabeledPoint( blue, startPos, ( editMode ) ? 5 : 3, "Start interpolated" );
|
|
glLabeledPoint( blue, endPos, ( editMode ) ? 5 : 3, "End interpolated" );
|
|
glBegin( GL_LINES );
|
|
glVertex3fv( startPos );
|
|
glVertex3fv( endPos );
|
|
glEnd();
|
|
}
|
|
|
|
virtual void start( long t ) {
|
|
idCameraPosition::start( t );
|
|
lastTime = startTime;
|
|
distSoFar = 0.0;
|
|
idVec3 temp = startPos;
|
|
temp -= endPos;
|
|
calcVelocity( temp.Length() );
|
|
}
|
|
|
|
protected:
|
|
bool first;
|
|
idVec3 startPos;
|
|
idVec3 endPos;
|
|
long lastTime;
|
|
float distSoFar;
|
|
};
|
|
|
|
class idSplinePosition : public idCameraPosition {
|
|
public:
|
|
|
|
void init() {
|
|
type = idCameraPosition::SPLINE;
|
|
}
|
|
|
|
idSplinePosition() : idCameraPosition() {
|
|
init();
|
|
}
|
|
|
|
idSplinePosition( long time ) : idCameraPosition( time ) {
|
|
init();
|
|
}
|
|
|
|
~idSplinePosition() {
|
|
}
|
|
|
|
virtual void start( long t ) {
|
|
idCameraPosition::start( t );
|
|
target.initPosition( t, time );
|
|
lastTime = startTime;
|
|
distSoFar = 0.0;
|
|
calcVelocity( target.totalDistance() );
|
|
}
|
|
|
|
//virtual const idVec3 *getPosition(long t) {
|
|
// return target.getPosition(t);
|
|
//}
|
|
virtual const idVec3 *getPosition( long t );
|
|
|
|
|
|
//virtual const idVec3 *getPosition(long t) const {
|
|
|
|
void addControlPoint( idVec3 &v ) {
|
|
target.addPoint( v );
|
|
}
|
|
|
|
void parse( const char *( *text ) );
|
|
void write( fileHandle_t file, const char *name );
|
|
|
|
virtual int numPoints() {
|
|
return target.numPoints();
|
|
}
|
|
|
|
virtual idVec3 *getPoint( int index ) {
|
|
return target.getPoint( index );
|
|
}
|
|
|
|
virtual void addPoint( const idVec3 &v ) {
|
|
target.addPoint( v );
|
|
}
|
|
|
|
virtual void addPoint( const float x, const float y, const float z ) {
|
|
target.addPoint( x, y, z );
|
|
}
|
|
|
|
virtual void draw( bool editMode ) {
|
|
target.draw( editMode );
|
|
}
|
|
|
|
virtual void updateSelection( const idVec3 &move ) {
|
|
idCameraPosition::updateSelection( move );
|
|
target.buildSpline();
|
|
}
|
|
|
|
protected:
|
|
idSplineList target;
|
|
long lastTime;
|
|
float distSoFar;
|
|
};
|
|
|
|
class idCameraFOV {
|
|
public:
|
|
|
|
idCameraFOV() {
|
|
time = 0;
|
|
length = 0;
|
|
fov = 90;
|
|
}
|
|
|
|
idCameraFOV( int v ) {
|
|
time = 0;
|
|
length = 0;
|
|
fov = v;
|
|
}
|
|
|
|
idCameraFOV( int s, int e, long t ) {
|
|
startFOV = s;
|
|
endFOV = e;
|
|
length = t;
|
|
}
|
|
|
|
|
|
~idCameraFOV(){
|
|
}
|
|
|
|
void setFOV( float f ) {
|
|
fov = f;
|
|
}
|
|
|
|
float getFOV( long t ) {
|
|
if ( length ) {
|
|
float percent = ( t - startTime ) / length;
|
|
if ( percent < 0.0 ) {
|
|
percent = 0.0;
|
|
}
|
|
else if ( percent > 1.0 ) {
|
|
percent = 1.0;
|
|
}
|
|
float temp = endFOV - startFOV;
|
|
temp *= percent;
|
|
fov = startFOV + temp;
|
|
|
|
if ( percent == 1.0 ) {
|
|
length = 0.0;
|
|
}
|
|
}
|
|
return fov;
|
|
}
|
|
|
|
void start( long t ) {
|
|
startTime = t;
|
|
}
|
|
|
|
void reset( float startfov, float endfov, int start, float len ) {
|
|
startFOV = startfov;
|
|
endFOV = endfov;
|
|
startTime = start;
|
|
length = len * 1000;
|
|
}
|
|
|
|
void parse( const char *( *text ) );
|
|
void write( fileHandle_t file, const char *name );
|
|
|
|
protected:
|
|
float fov;
|
|
float startFOV;
|
|
float endFOV;
|
|
int startTime;
|
|
int time;
|
|
float length;
|
|
};
|
|
|
|
|
|
|
|
|
|
class idCameraEvent {
|
|
public: // parameters
|
|
enum eventType {
|
|
EVENT_NA = 0x00,
|
|
EVENT_WAIT, //
|
|
EVENT_TARGETWAIT, //
|
|
EVENT_SPEED, //
|
|
EVENT_TARGET, // char(name)
|
|
EVENT_SNAPTARGET, //
|
|
EVENT_FOV, // int(time), int(targetfov)
|
|
EVENT_CMD, //
|
|
EVENT_TRIGGER, //
|
|
EVENT_STOP, //
|
|
EVENT_CAMERA, //
|
|
EVENT_FADEOUT, // int(time)
|
|
EVENT_FADEIN, // int(time)
|
|
EVENT_FEATHER, //
|
|
EVENT_COUNT
|
|
};
|
|
|
|
static const char* eventStr[EVENT_COUNT];
|
|
|
|
idCameraEvent() {
|
|
paramStr = "";
|
|
type = EVENT_NA;
|
|
time = 0;
|
|
}
|
|
|
|
idCameraEvent( eventType t, const char *param, long n ) {
|
|
type = t;
|
|
paramStr = param;
|
|
time = n;
|
|
}
|
|
|
|
~idCameraEvent() {
|
|
};
|
|
|
|
eventType getType() {
|
|
return type;
|
|
}
|
|
|
|
const char *typeStr() {
|
|
return eventStr[static_cast<int>( type )];
|
|
}
|
|
|
|
const char *getParam() {
|
|
return paramStr.c_str();
|
|
}
|
|
|
|
long getTime() {
|
|
return time;
|
|
}
|
|
|
|
void setTime( long n ) {
|
|
time = n;
|
|
}
|
|
|
|
void parse( const char *( *text ) );
|
|
void write( fileHandle_t file, const char *name );
|
|
|
|
void setTriggered( bool b ) {
|
|
triggered = b;
|
|
}
|
|
|
|
bool getTriggered() {
|
|
return triggered;
|
|
}
|
|
|
|
protected:
|
|
eventType type;
|
|
idStr paramStr;
|
|
long time;
|
|
bool triggered;
|
|
|
|
};
|
|
|
|
class idCameraDef {
|
|
public:
|
|
|
|
void clear() {
|
|
currentCameraPosition = 0;
|
|
cameraRunning = false;
|
|
lastDirection.Zero();
|
|
baseTime = 30;
|
|
activeTarget = 0;
|
|
name = "camera01";
|
|
fov.setFOV( 90 );
|
|
int i;
|
|
for ( i = 0; i < targetPositions.Num(); i++ ) {
|
|
delete targetPositions[i];
|
|
}
|
|
for ( i = 0; i < events.Num(); i++ ) {
|
|
delete events[i];
|
|
}
|
|
delete cameraPosition;
|
|
cameraPosition = NULL;
|
|
events.Clear();
|
|
targetPositions.Clear();
|
|
}
|
|
|
|
idCameraPosition *startNewCamera( idCameraPosition::positionType type ) {
|
|
clear();
|
|
if ( type == idCameraPosition::SPLINE ) {
|
|
cameraPosition = new idSplinePosition();
|
|
}
|
|
else if ( type == idCameraPosition::INTERPOLATED ) {
|
|
cameraPosition = new idInterpolatedPosition();
|
|
}
|
|
else {
|
|
cameraPosition = new idFixedPosition();
|
|
}
|
|
return cameraPosition;
|
|
}
|
|
|
|
idCameraDef() {
|
|
cameraPosition = NULL;
|
|
clear();
|
|
}
|
|
|
|
~idCameraDef() {
|
|
clear();
|
|
}
|
|
|
|
void addEvent( idCameraEvent::eventType t, const char *param, long time );
|
|
|
|
void addEvent( idCameraEvent *event );
|
|
|
|
void removeEvent( int index );
|
|
|
|
static int sortEvents( const void *p1, const void *p2 );
|
|
|
|
int numEvents() {
|
|
return events.Num();
|
|
}
|
|
|
|
idCameraEvent *getEvent( int index ) {
|
|
assert( index >= 0 && index < events.Num() );
|
|
return events[index];
|
|
}
|
|
|
|
void parse( const char *( *text ) );
|
|
bool load( const char *filename );
|
|
void save( const char *filename );
|
|
|
|
void buildCamera();
|
|
|
|
//idSplineList *getcameraPosition() {
|
|
// return &cameraPosition;
|
|
//}
|
|
|
|
static idCameraPosition *newFromType( idCameraPosition::positionType t ) {
|
|
switch ( t ) {
|
|
case idCameraPosition::FIXED: return new idFixedPosition();
|
|
case idCameraPosition::INTERPOLATED: return new idInterpolatedPosition();
|
|
case idCameraPosition::SPLINE: return new idSplinePosition();
|
|
default:
|
|
break;
|
|
};
|
|
return NULL;
|
|
}
|
|
|
|
void addTarget( const char *name, idCameraPosition::positionType type );
|
|
|
|
idCameraPosition *getActiveTarget() {
|
|
if ( targetPositions.Num() == 0 ) {
|
|
addTarget( NULL, idCameraPosition::FIXED );
|
|
}
|
|
return targetPositions[activeTarget];
|
|
}
|
|
|
|
idCameraPosition *getActiveTarget( int index ) {
|
|
if ( targetPositions.Num() == 0 ) {
|
|
addTarget( NULL, idCameraPosition::FIXED );
|
|
return targetPositions[0];
|
|
}
|
|
return targetPositions[index];
|
|
}
|
|
|
|
int numTargets() {
|
|
return targetPositions.Num();
|
|
}
|
|
|
|
|
|
void setActiveTargetByName( const char *name ) {
|
|
for ( int i = 0; i < targetPositions.Num(); i++ ) {
|
|
if ( Q_stricmp( name, targetPositions[i]->getName() ) == 0 ) {
|
|
setActiveTarget( i );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void setActiveTarget( int index ) {
|
|
assert( index >= 0 && index < targetPositions.Num() );
|
|
activeTarget = index;
|
|
}
|
|
|
|
void setRunning( bool b ) {
|
|
cameraRunning = b;
|
|
}
|
|
|
|
void setBaseTime( float f ) {
|
|
baseTime = f;
|
|
}
|
|
|
|
float getBaseTime() {
|
|
return baseTime;
|
|
}
|
|
|
|
float getTotalTime() {
|
|
return totalTime;
|
|
}
|
|
|
|
void startCamera( long t );
|
|
void stopCamera() {
|
|
cameraRunning = true;
|
|
}
|
|
void getActiveSegmentInfo( int segment, idVec3 &origin, idVec3 &direction, float *fv );
|
|
|
|
bool getCameraInfo( long time, idVec3 &origin, idVec3 &direction, float *fv );
|
|
bool getCameraInfo( long time, float *origin, float *direction, float *fv ) {
|
|
idVec3 org, dir;
|
|
org[0] = origin[0];
|
|
org[1] = origin[1];
|
|
org[2] = origin[2];
|
|
dir[0] = direction[0];
|
|
dir[1] = direction[1];
|
|
dir[2] = direction[2];
|
|
bool b = getCameraInfo( time, org, dir, fv );
|
|
origin[0] = org[0];
|
|
origin[1] = org[1];
|
|
origin[2] = org[2];
|
|
direction[0] = dir[0];
|
|
direction[1] = dir[1];
|
|
direction[2] = dir[2];
|
|
return b;
|
|
}
|
|
|
|
void draw( bool editMode ) {
|
|
// gcc doesn't allow casting away from bools
|
|
// why? I've no idea...
|
|
if ( cameraPosition ) {
|
|
cameraPosition->draw( (bool)( ( editMode || cameraRunning ) && cameraEdit ) );
|
|
int count = targetPositions.Num();
|
|
for ( int i = 0; i < count; i++ ) {
|
|
targetPositions[i]->draw( (bool)( ( editMode || cameraRunning ) && i == activeTarget && !cameraEdit ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
int numSegments() {
|
|
if (cameraEdit) {
|
|
return cameraPosition.numSegments();
|
|
}
|
|
return getTargetSpline()->numSegments();
|
|
}
|
|
|
|
int getActiveSegment() {
|
|
if (cameraEdit) {
|
|
return cameraPosition.getActiveSegment();
|
|
}
|
|
return getTargetSpline()->getActiveSegment();
|
|
}
|
|
|
|
void setActiveSegment(int i) {
|
|
if (cameraEdit) {
|
|
cameraPosition.setActiveSegment(i);
|
|
} else {
|
|
getTargetSpline()->setActiveSegment(i);
|
|
}
|
|
}
|
|
*/
|
|
int numPoints() {
|
|
if ( cameraEdit ) {
|
|
return cameraPosition->numPoints();
|
|
}
|
|
return getActiveTarget()->numPoints();
|
|
}
|
|
|
|
const idVec3 *getPoint( int index ) {
|
|
if ( cameraEdit ) {
|
|
return cameraPosition->getPoint( index );
|
|
}
|
|
return getActiveTarget()->getPoint( index );
|
|
}
|
|
|
|
void stopEdit() {
|
|
editMode = false;
|
|
if ( cameraEdit ) {
|
|
cameraPosition->stopEdit();
|
|
}
|
|
else {
|
|
getActiveTarget()->stopEdit();
|
|
}
|
|
}
|
|
|
|
void startEdit( bool camera ) {
|
|
cameraEdit = camera;
|
|
if ( camera ) {
|
|
cameraPosition->startEdit();
|
|
for ( int i = 0; i < targetPositions.Num(); i++ ) {
|
|
targetPositions[i]->stopEdit();
|
|
}
|
|
}
|
|
else {
|
|
getActiveTarget()->startEdit();
|
|
cameraPosition->stopEdit();
|
|
}
|
|
editMode = true;
|
|
}
|
|
|
|
bool waitEvent( int index );
|
|
|
|
const char *getName() {
|
|
return name.c_str();
|
|
}
|
|
|
|
void setName( const char *p ) {
|
|
name = p;
|
|
}
|
|
|
|
idCameraPosition *getPositionObj() {
|
|
if ( cameraPosition == NULL ) {
|
|
cameraPosition = new idFixedPosition();
|
|
}
|
|
return cameraPosition;
|
|
}
|
|
|
|
protected:
|
|
idStr name;
|
|
int currentCameraPosition;
|
|
idVec3 lastDirection;
|
|
bool cameraRunning;
|
|
idCameraPosition *cameraPosition;
|
|
idList<idCameraPosition*> targetPositions;
|
|
idList<idCameraEvent*> events;
|
|
idCameraFOV fov;
|
|
int activeTarget;
|
|
float totalTime;
|
|
float baseTime;
|
|
long startTime;
|
|
|
|
bool cameraEdit;
|
|
bool editMode;
|
|
};
|
|
|
|
extern bool g_splineMode;
|
|
|
|
extern idCameraDef *g_splineList;
|
|
|
|
|
|
#endif
|