celestia/src/celengine/command.h

700 lines
13 KiB
C++

// command.h
//
// Copyright (C) 2001 Chris Laurel <claurel@shatters.net>
//
// 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 2
// of the License, or (at your option) any later version.
#ifndef _COMMAND_H_
#define _COMMAND_H_
#define MAX_CONSTELLATIONS 100
#include <iostream>
#include <celutil/color.h>
#include <celengine/execenv.h>
#include <celengine/astro.h>
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif
class Command
{
public:
Command() {};
virtual ~Command() {};
virtual void process(ExecutionEnvironment&, double t, double dt) = 0;
virtual double getDuration() const = 0;
};
typedef std::vector<Command*> CommandSequence;
class InstantaneousCommand : public Command
{
public:
InstantaneousCommand() {};
virtual ~InstantaneousCommand() {};
virtual double getDuration() const { return 0.0; };
virtual void process(ExecutionEnvironment&) = 0;
void process(ExecutionEnvironment& env, double /*t*/, double /*dt*/)
{
process(env);
};
};
class TimedCommand : public Command
{
public:
TimedCommand(double _duration) : duration(_duration) {};
virtual ~TimedCommand() {};
double getDuration() const { return duration; };
private:
double duration;
};
class CommandWait : public TimedCommand
{
public:
CommandWait(double _duration);
~CommandWait();
void process(ExecutionEnvironment&, double t, double dt);
};
class CommandSelect : public InstantaneousCommand
{
public:
CommandSelect(std::string _target);
~CommandSelect();
void process(ExecutionEnvironment&);
private:
std::string target;
};
class CommandGoto : public InstantaneousCommand
{
public:
CommandGoto(double t, double dist,
Vec3f _up, ObserverFrame::CoordinateSystem _upFrame);
~CommandGoto();
void process(ExecutionEnvironment&);
private:
double gotoTime;
double distance;
Vec3f up;
ObserverFrame::CoordinateSystem upFrame;
};
class CommandGotoLongLat : public InstantaneousCommand
{
public:
CommandGotoLongLat(double t,
double dist,
float _longitude, float _latitude,
Vec3f _up);
~CommandGotoLongLat();
void process(ExecutionEnvironment&);
private:
double gotoTime;
double distance;
float longitude;
float latitude;
Vec3f up;
};
class CommandGotoLocation : public InstantaneousCommand
{
public:
CommandGotoLocation(double t,
const Point3d& translation, const Quatf& rotation);
~CommandGotoLocation();
void process(ExecutionEnvironment&);
private:
double gotoTime;
Point3d translation;
Quatf rotation;
};
class CommandSetUrl : public InstantaneousCommand
{
public:
CommandSetUrl(const std::string& _url);
void process(ExecutionEnvironment&);
private:
std::string url;
};
class CommandCenter : public InstantaneousCommand
{
public:
CommandCenter(double t);
~CommandCenter();
void process(ExecutionEnvironment&);
private:
double centerTime;
};
class CommandFollow : public InstantaneousCommand
{
public:
CommandFollow();
void process(ExecutionEnvironment&);
private:
int dummy; // Keep the class from having zero size
};
class CommandSynchronous : public InstantaneousCommand
{
public:
CommandSynchronous();
void process(ExecutionEnvironment&);
private:
int dummy; // Keep the class from having zero size
};
class CommandLock : public InstantaneousCommand
{
public:
CommandLock();
void process(ExecutionEnvironment&);
private:
int dummy;
};
class CommandChase : public InstantaneousCommand
{
public:
CommandChase();
void process(ExecutionEnvironment&);
private:
int dummy;
};
class CommandTrack : public InstantaneousCommand
{
public:
CommandTrack();
void process(ExecutionEnvironment&);
private:
int dummy;
};
class CommandSetFrame : public InstantaneousCommand
{
public:
CommandSetFrame(ObserverFrame::CoordinateSystem,
const std::string&, const std::string&);
void process(ExecutionEnvironment&);
private:
ObserverFrame::CoordinateSystem coordSys;
std::string refObjectName;
std::string targetObjectName;
};
class CommandSetSurface : public InstantaneousCommand
{
public:
CommandSetSurface(const std::string&);
void process(ExecutionEnvironment&);
private:
std::string surfaceName;
};
class CommandCancel : public InstantaneousCommand
{
public:
CommandCancel();
void process(ExecutionEnvironment&);
private:
int dummy; // Keep the class from having zero size
};
class CommandExit : public InstantaneousCommand
{
public:
CommandExit();
void process(ExecutionEnvironment&);
private:
int dummy; // Keep the class from having zero size
};
class CommandPrint : public InstantaneousCommand
{
public:
CommandPrint(std::string, int horig, int vorig, int hoff, int voff,
double duration);
void process(ExecutionEnvironment&);
private:
std::string text;
int hOrigin;
int vOrigin;
int hOffset;
int vOffset;
double duration;
};
class CommandClearScreen : public InstantaneousCommand
{
public:
CommandClearScreen();
void process(ExecutionEnvironment&);
private:
int dummy; // Keep the class from having zero size
};
class CommandSetTime : public InstantaneousCommand
{
public:
CommandSetTime(double _jd);
void process(ExecutionEnvironment&);
private:
double jd;
};
class CommandSetTimeRate : public InstantaneousCommand
{
public:
CommandSetTimeRate(double);
void process(ExecutionEnvironment&);
private:
double rate;
};
class CommandChangeDistance : public TimedCommand
{
public:
CommandChangeDistance(double duration, double rate);
void process(ExecutionEnvironment&, double t, double dt);
private:
double rate;
};
class CommandOrbit : public TimedCommand
{
public:
CommandOrbit(double _duration, const Vec3f& axis, float rate);
void process(ExecutionEnvironment&, double t, double dt);
private:
Vec3f spin;
};
class CommandRotate : public TimedCommand
{
public:
CommandRotate(double _duration, const Vec3f& axis, float rate);
void process(ExecutionEnvironment&, double t, double dt);
private:
Vec3f spin;
};
class CommandMove : public TimedCommand
{
public:
CommandMove(double _duration, const Vec3d& _velocity);
void process(ExecutionEnvironment&, double t, double dt);
private:
Vec3d velocity;
};
class CommandSetPosition : public InstantaneousCommand
{
public:
CommandSetPosition(const UniversalCoord&);
void process(ExecutionEnvironment&);
private:
UniversalCoord pos;
};
class CommandSetOrientation : public InstantaneousCommand
{
public:
CommandSetOrientation(const Vec3f&, float);
void process(ExecutionEnvironment&);
private:
Vec3f axis;
float angle;
};
class CommandLookBack : public InstantaneousCommand
{
public:
CommandLookBack();
void process(ExecutionEnvironment&);
private:
int dummy; // Keep the class from having zero size
};
class CommandRenderFlags : public InstantaneousCommand
{
public:
CommandRenderFlags(int _setFlags, int _clearFlags);
void process(ExecutionEnvironment&);
private:
int setFlags;
int clearFlags;
};
class CommandConstellations : public InstantaneousCommand
{
public:
CommandConstellations();
void process(ExecutionEnvironment&);
void setValues(string cons, int act);
std::string constellation[MAX_CONSTELLATIONS];
int active[MAX_CONSTELLATIONS];
int numConstellations;
int all;
int none;
};
class CommandConstellationColor : public InstantaneousCommand
{
public:
CommandConstellationColor();
void process(ExecutionEnvironment&);
void setConstellations(string cons);
void setColor(float r, float g, float b);
void unsetColor();
std::string constellation[MAX_CONSTELLATIONS];
Color rgb;
int unset;
int numConstellations;
int all;
int none;
};
class CommandLabels : public InstantaneousCommand
{
public:
CommandLabels(int _setFlags, int _clearFlags);
void process(ExecutionEnvironment&);
private:
int setFlags;
int clearFlags;
};
class CommandOrbitFlags : public InstantaneousCommand
{
public:
CommandOrbitFlags(int _setFlags, int _clearFlags);
void process(ExecutionEnvironment&);
private:
int setFlags;
int clearFlags;
};
class CommandSetVisibilityLimit : public InstantaneousCommand
{
public:
CommandSetVisibilityLimit(double);
void process(ExecutionEnvironment&);
private:
double magnitude;
};
class CommandSetFaintestAutoMag45deg : public InstantaneousCommand
{
public:
CommandSetFaintestAutoMag45deg(double);
void process(ExecutionEnvironment&);
private:
double magnitude;
};
class CommandSetAmbientLight : public InstantaneousCommand
{
public:
CommandSetAmbientLight(float);
void process(ExecutionEnvironment&);
private:
float lightLevel;
};
class CommandSetGalaxyLightGain : public InstantaneousCommand
{
public:
CommandSetGalaxyLightGain(float);
void process(ExecutionEnvironment&);
private:
float lightGain;
};
class CommandSet : public InstantaneousCommand
{
public:
CommandSet(const std::string&, double);
void process(ExecutionEnvironment&);
private:
std::string name;
double value;
};
class CommandPreloadTextures : public InstantaneousCommand
{
public:
CommandPreloadTextures(const std::string&);
void process(ExecutionEnvironment&);
private:
std::string name;
};
class CommandMark : public InstantaneousCommand
{
public:
CommandMark(const std::string&, MarkerRepresentation, bool);
void process(ExecutionEnvironment&);
private:
std::string target;
MarkerRepresentation rep;
bool occludable;
};
class CommandUnmark : public InstantaneousCommand
{
public:
CommandUnmark(const std::string&);
void process(ExecutionEnvironment&);
private:
std::string target;
};
class CommandUnmarkAll : public InstantaneousCommand
{
public:
CommandUnmarkAll();
void process(ExecutionEnvironment&);
private:
int dummy; // Keep the class from having zero size
};
class CommandCapture : public InstantaneousCommand
{
public:
CommandCapture(const std::string&, const std::string&);
void process(ExecutionEnvironment&);
private:
std::string type;
std::string filename;
};
class CommandSetTextureResolution : public InstantaneousCommand
{
public:
CommandSetTextureResolution(unsigned int);
void process(ExecutionEnvironment&);
private:
unsigned int res;
};
class CommandRenderPath : public InstantaneousCommand
{
public:
CommandRenderPath(GLContext::GLRenderPath);
void process(ExecutionEnvironment&);
private:
GLContext::GLRenderPath path;
};
class CommandSplitView : public InstantaneousCommand
{
public:
CommandSplitView(unsigned int, const std::string&, double);
void process(ExecutionEnvironment&);
private:
unsigned int view;
std::string splitType;
double splitPos;
};
class CommandDeleteView : public InstantaneousCommand
{
public:
CommandDeleteView(unsigned int);
void process(ExecutionEnvironment&);
private:
unsigned int view;
};
class CommandSingleView : public InstantaneousCommand
{
public:
CommandSingleView();
void process(ExecutionEnvironment&);
};
class CommandSetActiveView : public InstantaneousCommand
{
public:
CommandSetActiveView(unsigned int);
void process(ExecutionEnvironment&);
private:
unsigned int view;
};
class CommandSetRadius : public InstantaneousCommand
{
public:
CommandSetRadius(const std::string&, double);
void process(ExecutionEnvironment&);
private:
std::string object;
double radius;
};
class CommandSetLineColor : public InstantaneousCommand
{
public:
CommandSetLineColor(const std::string&, Color);
void process(ExecutionEnvironment&);
private:
std::string item;
Color color;
};
class CommandSetLabelColor : public InstantaneousCommand
{
public:
CommandSetLabelColor(const std::string&, Color);
void process(ExecutionEnvironment&);
private:
std::string item;
Color color;
};
class CommandSetTextColor : public InstantaneousCommand
{
public:
CommandSetTextColor(Color);
void process(ExecutionEnvironment&);
private:
Color color;
};
class Execution;
class RepeatCommand : public Command
{
public:
RepeatCommand(CommandSequence* _body, int _repeatCount);
~RepeatCommand();
void process(ExecutionEnvironment&, double t, double dt) = 0;
virtual double getDuration() const;
private:
CommandSequence* body;
double bodyDuration;
int repeatCount;
Execution* execution;
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // _COMMAND_H_