splines.h

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code 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.

Quake III Arena source code 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 Foobar; 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

extern "C" {
#ifdef Q3RADIANT
#include "../qgl.h"
#else
#include "../renderer/qgl.h"
#endif
}
#include "util_list.h"
#include "util_str.h"
#include "math_vector.h"

typedef int fileHandle_t;

extern void glBox(idVec3_t &color, idVec3_t &point, float size);
extern void glLabeledPoint(idVec3_t &color, idVec3_t &point, float size, const char *label);

static vec4_t blue(0, 0, 1, 1);
static vec4_t red(1, 0, 0, 1);

class idPointListInterface {
public:
    idPointListInterface() {
        selectedPoints.Clear();
    };
    ~idPointListInterface() {};
    
    virtual int numPoints() {
        return 0;
    }
    
    virtual void addPoint(const float x, const float y, const float z) {}
    virtual void addPoint(const idVec3_t &v) {}
    virtual void removePoint(int index) {}
    virtual idVec3_t *getPoint(int index) { return NULL; }
    
    int selectPointByRay(float ox, float oy, float oz, float dx, float dy, float dz, bool single) {
        idVec3_t origin(ox, oy, oz);
        idVec3_t dir(dx, dy, dz);
        return selectPointByRay(origin, dir, single);
    }

    int selectPointByRay(const idVec3_t origin, const idVec3_t direction, bool single) {
        int     i, besti, count;
        float   d, bestd;
        idVec3_t    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_t *getSelectedPoint(int index) {
        assert(index >= 0 && index < numSelectedPoints());
        return getPoint(selectedPoints[index]);
    }
    
    virtual void updateSelection(float x, float y, float z) {
        idVec3_t move(x, y, z);
        updateSelection(move);
    }

    virtual void updateSelection(const idVec3_t &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.025;
        pathColor.set(1.0, 0.5, 0.0);
        controlColor.set(0.7, 0.0, 1.0);
        segmentColor.set(0.0, 0.0, 1.0);
        activeColor.set(1.0, 0.0, 0.0);
    }

    void initPosition(long startTime, long totalTime);
    const idVec3_t *getPosition(long time);


    void draw(bool editMode);
    void addToRenderer();

    void setSelectedPoint(idVec3_t *p);
    idVec3_t *getSelectedPoint() {
      return selected;
    }

    void addPoint(const idVec3_t &v) {
        controlPoints.Append(new idVec3_t(v));
        dirty = true;
    }

    void addPoint(float x, float y, float z) {
        controlPoints.Append(new idVec3_t(x, y, z));
        dirty = true;
    }

    void updateSelection(const idVec3_t &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_t *getPoint(int index) {
        assert(index >= 0 && index < controlPoints.Num());
        return controlPoints[index];
    }

    idVec3_t *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 splineTime[index];
    }
    void addSegmentTime(int index, int time) {
        assert(index >= 0 && index < splinePoints.Num());
        splineTime[index] += time;
    }

    float totalDistance();

    static idVec3_t 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_t &path, idVec3_t &segment, idVec3_t &control, idVec3_t &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_t*> controlPoints;
    idList<idVec3_t*> splinePoints;
    idList<float> splineTime;
    idVec3_t *selected;
    idVec3_t 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 clear() {
        editMode = false;
        for (int i = 0; i < velocities.Num(); i++) {
            delete velocities[i];
            velocities[i] = NULL;
        }
        velocities.Clear();
    }

    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 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_t *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 startEdit() {
        editMode = true;
    }

    virtual 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_t p) : idCameraPosition() {
        init();
        pos = p;
    }

    virtual void addPoint(const idVec3_t &v) {
        pos = v;
    }
    
    virtual void addPoint(const float x, const float y, const float z) {
        pos.set(x, y, z);
    }


    ~idFixedPosition() {
    }

    virtual const idVec3_t *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_t *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_t pos;
};

class idInterpolatedPosition : public idCameraPosition {
public:

    void init() {
        type = idCameraPosition::INTERPOLATED;
        first = true;
        startPos.Zero();
        endPos.Zero();
    }
    
    idInterpolatedPosition() : idCameraPosition() {
        init();
    }
    
    idInterpolatedPosition(idVec3_t start, idVec3_t end, long time) : idCameraPosition(time) {
        init();
        startPos = start;
        endPos = end;
    }

    ~idInterpolatedPosition() {
    }

    virtual const idVec3_t *getPosition(long t);

    void parse(const char *(*text));
    void write(fileHandle_t file, const char *name);

    virtual int numPoints() {
        return 2;
    }

    virtual idVec3_t *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_t &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");
        qglBegin(GL_LINES);
        qglVertex3fv(startPos);
        qglVertex3fv(endPos);
        qglEnd();
    }

    virtual void start(long t) {
        idCameraPosition::start(t);
        lastTime = startTime;
        distSoFar = 0.0;
        idVec3_t temp = startPos;
        temp -= endPos;
        calcVelocity(temp.Length());
    }

protected:
    bool first;
    idVec3_t startPos;
    idVec3_t 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);
        calcVelocity(target.totalDistance());
    }

    virtual const idVec3_t *getPosition(long t) { 
        return target.getPosition(t);
    }

    //virtual const idVec3_t *getPosition(long t) const { 

    void addControlPoint(idVec3_t &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_t *getPoint(int index) {
        return target.getPoint(index);
    }

    virtual void addPoint(const idVec3_t &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_t &move) {
        idCameraPosition::updateSelection(move);
        target.buildSpline();
    }

protected:
    idSplineList target;
};

class idCameraFOV {
public:
    
    idCameraFOV() {
        time = 0;
        fov = 90;
    }

    idCameraFOV(int v) {
        time = 0;
        fov = v;
    }

    idCameraFOV(int s, int e, long t) {
        startFOV = s;
        endFOV = e;
        time = t;
    }


    ~idCameraFOV(){}

    void setFOV(float f) {
        fov = f;
    }

    float getFOV(long t) {
        if (time) {
            assert(startTime);
            float percent = t / startTime;
            float temp = startFOV - endFOV;
            temp *= percent;
            fov = startFOV + temp;
        }
        return fov;
    }

    int start(long t) {
        startTime = t;
    }

    void parse(const char *(*text));
    void write(fileHandle_t file, const char *name);

protected:
    float fov;
    float startFOV;
    float endFOV;
    int startTime;
    int time;
};




class idCameraEvent {
public:
    enum eventType {
        EVENT_NA = 0x00,
        EVENT_WAIT,
        EVENT_TARGETWAIT,
        EVENT_SPEED,
        EVENT_TARGET,
        EVENT_SNAPTARGET,
        EVENT_FOV,
        EVENT_SCRIPT,
        EVENT_TRIGGER,
        EVENT_STOP,
        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() {
        clear();
    }

    ~idCameraDef() {
        clear();
    }

    void addEvent(idCameraEvent::eventType t, const char *param, long time);

    void addEvent(idCameraEvent *event);

    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();
        };
        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 (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_t &origin, idVec3_t &direction, float *fv);

    bool getCameraInfo(long time, idVec3_t &origin, idVec3_t &direction, float *fv);
    bool getCameraInfo(long time, float *origin, float *direction, float *fv) {
        idVec3_t 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_t *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_t 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

---