-
sparker
thiago
Manta Interactive Ray Tracer Development Mailing List
Text archives Help
- From: cgribble@sci.utah.edu
- To: manta@sci.utah.edu
- Subject: [MANTA] r1182 - in trunk: Engine/Control Interface UserInterface
- Date: Wed, 16 Aug 2006 18:42:27 -0600 (MDT)
Author: cgribble
Date: Wed Aug 16 18:42:26 2006
New Revision: 1182
Added:
trunk/Interface/CallbackHandle.h
Modified:
trunk/Engine/Control/RTRT.cc
trunk/Engine/Control/RTRT.h
trunk/Interface/CMakeLists.txt
trunk/Interface/CallbackHelpers.h
trunk/Interface/CameraPath.cc
trunk/Interface/CameraPath.h
trunk/Interface/MantaInterface.h
trunk/Interface/SetupCallback.h
trunk/UserInterface/XWindowUI.cc
trunk/UserInterface/XWindowUI.h
Log:
UserInterface/XWindowUI.cc
UserInterface/XWindowUI.h
Added functions to start/stop and reset camera path interpolation
Spacebar toggles path animation
"r" resets to the first frame along the path
Interface/MantaInterface.h
Interface/CallbackHandle.h
Interface/SetupCallback.h
Interface/CallbackHelpers.h
Interface/CMakeLists.txt
Added ability to unregister callbacks using callback handles
register*(...) function now return a CallbackHandle*
User is responsible for storing the handle, which can be passed to
unregisterCallback(...) to remove the callback
Added virtual base class CallbackHandle, SetupCallback and
CallbackBase_*Data
now derive from CallbackHandle to allow unregistration
Interface/CameraPath.h
Interface/CameraPath.cc
Added flags to control behavior (looping, frame counting, etc.)
If not looping and end of path is reached, CameraPath::interpolate(...)
function is unregistered
Added animate/reset function to start/stop/reset camera path animation
Engine/Control/RTRT.h
Engine/Control/RTRT.cc
Reflect changes to MantaInterface: register*(...) functions now return a
CallbackHandle*
Added implementation of unregisterCallback(...): search vectors of
callbacks
to find match and remove it
Modified: trunk/Engine/Control/RTRT.cc
==============================================================================
--- trunk/Engine/Control/RTRT.cc (original)
+++ trunk/Engine/Control/RTRT.cc Wed Aug 16 18:42:26 2006
@@ -4,6 +4,8 @@
#include <Interface/AmbientLight.h>
#include <Interface/Background.h>
#include <Interface/Callback.h>
+#include <Interface/CallbackHandle.h>
+#include <Interface/CallbackHelpers.h>
#include <Interface/Context.h>
#include <Interface/IdleMode.h>
#include <Interface/Image.h>
@@ -131,6 +133,7 @@
return workersWanted;
}
+
void RTRT::addOneShotCallback(Whence whence, long frame,
CallbackBase_2Data<int, int>* callback)
{
@@ -163,45 +166,148 @@
}
-void RTRT::registerSetupCallback(SetupCallback* callback)
+CallbackHandle* RTRT::registerSetupCallback(SetupCallback* callback)
{
setupCallbacks.push_back(callback);
+ return callback;
}
-void RTRT::registerParallelAnimationCallback(CallbackBase_3Data<int, int,
bool&>* cb)
+CallbackHandle*
RTRT::registerParallelAnimationCallback(CallbackBase_3Data<int, int, bool&>*
cb)
{
callbackLock.writeLock();
parallelAnimationCallbacks.push_back(cb);
callbackLock.writeUnlock();
+ return cb;
}
-void RTRT::registerSerialAnimationCallback(CallbackBase_3Data<int, int,
bool&>* cb)
+CallbackHandle*
RTRT::registerSerialAnimationCallback(CallbackBase_3Data<int, int, bool&>* cb)
{
callbackLock.writeLock();
serialAnimationCallbacks.push_back(cb);
callbackLock.writeUnlock();
+ return cb;
}
-void RTRT::registerSerialPreRenderCallback(CallbackBase_2Data<int, int>* cb)
+CallbackHandle*
RTRT::registerSerialPreRenderCallback(CallbackBase_2Data<int, int>* cb)
{
callbackLock.writeLock();
serialPreRenderCallbacks.push_back(cb);
callbackLock.writeUnlock();
+ return cb;
}
-void RTRT::registerParallelPreRenderCallback(CallbackBase_2Data<int, int>*
cb)
+CallbackHandle*
RTRT::registerParallelPreRenderCallback(CallbackBase_2Data<int, int>* cb)
{
callbackLock.writeLock();
parallelPreRenderCallbacks.push_back(cb);
callbackLock.writeUnlock();
+ return cb;
}
-void RTRT::registerTerminationCallback( CallbackBase_1Data< MantaInterface
*> *cb ) {
+CallbackHandle* RTRT::registerTerminationCallback( CallbackBase_1Data<
MantaInterface *> *cb ) {
callbackLock.writeLock();
terminationCallbacks.push_back(cb);
callbackLock.writeUnlock();
+ return cb;
}
+void RTRT::unregisterCallback(CallbackHandle* callback)
+{
+ callbackLock.writeLock();
+
+ // Search setup callbacks
+ {
+ SetupCallback* cb=dynamic_cast<SetupCallback*>(callback);
+ if (cb) {
+ vector<SetupCallback*>::iterator iter;
+ iter=find(setupCallbacks.begin(), setupCallbacks.end(), cb);
+ if (iter != setupCallbacks.end()) {
+ setupCallbacks.erase(iter);
+ callbackLock.writeUnlock();
+ return;
+ }
+ }
+ }
+
+ // Search serial animation callbacks
+ {
+ typedef CallbackBase_3Data<int, int, bool&> callback_t;
+ callback_t* cb=dynamic_cast<callback_t*>(callback);
+ if (cb) {
+ vector<callback_t*>::iterator iter;
+ iter=find(serialAnimationCallbacks.begin(),
serialAnimationCallbacks.end(), cb);
+ if (iter != serialAnimationCallbacks.end()) {
+ serialAnimationCallbacks.erase(iter);
+ callbackLock.writeUnlock();
+ return;
+ }
+ }
+ }
+
+ // Search parallel animation callbacks
+ {
+ typedef CallbackBase_3Data<int, int, bool&> callback_t;
+ callback_t* cb=dynamic_cast<callback_t*>(callback);
+ if (cb) {
+ vector<callback_t*>::iterator iter;
+ iter=find(parallelAnimationCallbacks.begin(),
parallelAnimationCallbacks.end(), cb);
+ if (iter != parallelAnimationCallbacks.end()) {
+ parallelAnimationCallbacks.erase(iter);
+ callbackLock.writeUnlock();
+ return;
+ }
+ }
+ }
+
+ // Search serial prerender callbacks
+ {
+ typedef CallbackBase_2Data<int, int> callback_t;
+ callback_t* cb=dynamic_cast<callback_t*>(callback);
+ if (cb) {
+ vector<callback_t*>::iterator iter;
+ iter=find(serialPreRenderCallbacks.begin(),
serialPreRenderCallbacks.end(), cb);
+ if (iter != serialPreRenderCallbacks.end()) {
+ serialPreRenderCallbacks.erase(iter);
+ callbackLock.writeUnlock();
+ return;
+ }
+ }
+ }
+
+ // Search parallel prerender callbacks
+ {
+ typedef CallbackBase_2Data<int, int> callback_t;
+ callback_t* cb=dynamic_cast<callback_t*>(callback);
+ if (cb) {
+ vector<callback_t*>::iterator iter;
+ iter=find(parallelPreRenderCallbacks.begin(),
parallelPreRenderCallbacks.end(), cb);
+ if (iter != parallelPreRenderCallbacks.end()) {
+ parallelPreRenderCallbacks.erase(iter);
+ callbackLock.writeUnlock();
+ return;
+ }
+ }
+ }
+
+ // Search termination callbacks
+ {
+ typedef CallbackBase_1Data<MantaInterface*> callback_t;
+ callback_t* cb=dynamic_cast<callback_t*>(callback);
+ if (cb) {
+ vector<callback_t*>::iterator iter;
+ iter=find(terminationCallbacks.begin(), terminationCallbacks.end(),
cb);
+ if (iter != terminationCallbacks.end()) {
+ terminationCallbacks.erase(iter);
+ callbackLock.writeUnlock();
+ return;
+ }
+ }
+ }
+
+ // Callback not found (!)
+
+ callbackLock.writeUnlock();
+}
void RTRT::setTimeMode(TimeMode /*tm*/, double /*rate*/)
{
Modified: trunk/Engine/Control/RTRT.h
==============================================================================
--- trunk/Engine/Control/RTRT.h (original)
+++ trunk/Engine/Control/RTRT.h Wed Aug 16 18:42:26 2006
@@ -24,6 +24,7 @@
namespace Manta {
using namespace std;
+ class CallbackHandle;
class Camera;
class Image;
class Scene;
@@ -107,15 +108,16 @@
// Callbacks
virtual void addOneShotCallback(Whence whence, long frame,
- CallbackBase_2Data<int, int>* callback);
+ CallbackBase_2Data<int, int>* callback);
virtual void addParallelOneShotCallback(Whence whence, long frame,
- CallbackBase_2Data<int, int>* callback);
- virtual void registerSetupCallback(SetupCallback*);
- virtual void registerSerialAnimationCallback(CallbackBase_3Data<int,
int, bool&>*);
- virtual void registerParallelAnimationCallback(CallbackBase_3Data<int,
int, bool&>*);
- virtual void registerSerialPreRenderCallback(CallbackBase_2Data<int,
int>*);
- virtual void registerParallelPreRenderCallback(CallbackBase_2Data<int,
int>*);
- virtual void registerTerminationCallback( CallbackBase_1Data<
MantaInterface *> *);
+ CallbackBase_2Data<int, int>*
callback);
+ virtual CallbackHandle* registerSetupCallback(SetupCallback*);
+ virtual CallbackHandle*
registerSerialAnimationCallback(CallbackBase_3Data<int, int, bool&>*);
+ virtual CallbackHandle*
registerParallelAnimationCallback(CallbackBase_3Data<int, int, bool&>*);
+ virtual CallbackHandle*
registerSerialPreRenderCallback(CallbackBase_2Data<int, int>*);
+ virtual CallbackHandle*
registerParallelPreRenderCallback(CallbackBase_2Data<int, int>*);
+ virtual CallbackHandle* registerTerminationCallback( CallbackBase_1Data<
MantaInterface *> *);
+ virtual void unregisterCallback(CallbackHandle*);
// Control of time/animation
virtual void setTimeMode(TimeMode tm, double rate);
Modified: trunk/Interface/CMakeLists.txt
==============================================================================
--- trunk/Interface/CMakeLists.txt (original)
+++ trunk/Interface/CMakeLists.txt Wed Aug 16 18:42:26 2006
@@ -55,6 +55,7 @@
XWindow.h
Callback.h
CallbackHelpers.h
+ CallbackHandle.h
)
TARGET_LINK_LIBRARIES(Manta_Interface SCIRun_Core Manta_Core)
Added: trunk/Interface/CallbackHandle.h
==============================================================================
--- (empty file)
+++ trunk/Interface/CallbackHandle.h Wed Aug 16 18:42:26 2006
@@ -0,0 +1,13 @@
+
+#ifndef Manta_Interface_CallbackHandle_h
+#define Manta_Interface_CallbackHandle_h
+
+namespace Manta
+{
+ class CallbackHandle {
+ protected:
+ virtual ~CallbackHandle(void) { }
+ };
+}
+
+#endif // Manta_Interface_CallbackHandle_h
Modified: trunk/Interface/CallbackHelpers.h
==============================================================================
--- trunk/Interface/CallbackHelpers.h (original)
+++ trunk/Interface/CallbackHelpers.h Wed Aug 16 18:42:26 2006
@@ -2,6 +2,8 @@
#ifndef Manta_Interface_CallbackHelpers_h
#define Manta_Interface_CallbackHelpers_h
+#include <Interface/CallbackHandle.h>
+
// You should not use these directly - use Callback::create instead
namespace Manta {
////////////////////////////////////////////////////////////
@@ -10,7 +12,7 @@
//
// 0 Data
- class CallbackBase_0Data {
+ class CallbackBase_0Data : public CallbackHandle {
public:
CallbackBase_0Data()
{
@@ -26,7 +28,7 @@
// 1 Data
template<typename Data1>
- class CallbackBase_1Data {
+ class CallbackBase_1Data : public CallbackHandle {
public:
CallbackBase_1Data()
{
@@ -42,7 +44,7 @@
// 2 Data
template<typename Data1, typename Data2>
- class CallbackBase_2Data {
+ class CallbackBase_2Data : public CallbackHandle {
public:
CallbackBase_2Data()
{
@@ -58,7 +60,7 @@
// 3 Data
template<typename Data1, typename Data2, typename Data3>
- class CallbackBase_3Data {
+ class CallbackBase_3Data : public CallbackHandle {
public:
CallbackBase_3Data()
{
@@ -74,7 +76,7 @@
// 4 Data
template<typename Data1, typename Data2, typename Data3, typename Data4>
- class CallbackBase_4Data {
+ class CallbackBase_4Data : public CallbackHandle {
public:
CallbackBase_4Data()
{
@@ -90,7 +92,7 @@
// 5 Data
template<typename Data1, typename Data2, typename Data3, typename Data4,
typename Data5>
- class CallbackBase_5Data {
+ class CallbackBase_5Data : public CallbackHandle {
public:
CallbackBase_5Data()
{
@@ -106,7 +108,7 @@
// 6 Data
template<typename Data1, typename Data2, typename Data3, typename Data4,
typename Data5, typename Data6>
- class CallbackBase_6Data {
+ class CallbackBase_6Data : public CallbackHandle {
public:
CallbackBase_6Data()
{
Modified: trunk/Interface/CameraPath.cc
==============================================================================
--- trunk/Interface/CameraPath.cc (original)
+++ trunk/Interface/CameraPath.cc Wed Aug 16 18:42:26 2006
@@ -2,6 +2,7 @@
#include <Core/Exceptions/InputError.h>
#include <Core/Exceptions/OutputError.h>
#include <Interface/CameraPath.h>
+#include <Interface/MantaInterface.h>
#include <fstream>
#include <iostream>
@@ -9,16 +10,12 @@
using namespace Manta;
CameraPath::CameraPath(MantaInterface* interface, string const& fname,
- Mode mode) :
- interface(interface), fname(fname)
+ Mode mode, bool loop, int offset) :
+ interface(interface), fname(fname), loop(loop), offset(offset), handle(0),
+ frame(0), max_frame(0), anim(false)
{
- if (mode==ReadKnots) {
- // Read control points
+ if (mode==ReadKnots)
readKnots();
-
- // Register interpolate function
- interface->registerSerialAnimationCallback(Callback::create(this,
&CameraPath::interpolate));
- }
}
CameraPath::~CameraPath(void)
@@ -32,20 +29,46 @@
void CameraPath::interpolate(int, int, bool&)
{
- // Serial animation callback to update camera parameters
- int frame=interface->getCurrentFrame();
- int time=frame%max_frame;
- Camera* camera=interface->getCamera(0);
- camera->reset(eyes.interpolate(time), ups.interpolate(time),
- lookats.interpolate(time), fovs.interpolate(time));
+ if (loop && frame >= max_frame)
+ frame=0;
+
+ if (frame<max_frame) {
+ Camera* camera=interface->getCamera(0);
+ camera->reset(eyes.interpolate(frame), ups.interpolate(frame),
+ lookats.interpolate(frame), fovs.interpolate(frame));
+ ++frame;
+ } else {
+ anim=false;
+ interface->unregisterCallback(handle);
+ cerr<<"Reached end of camera path\n";
+ }
}
-void CameraPath::addKnot(Real const time, BasicCameraData const& data)
+void CameraPath::animate(void)
+{
+ anim = !anim;
+
+ if (anim)
+ handle=interface->registerSerialAnimationCallback(Callback::create(this,
&CameraPath::interpolate));
+ else
+ interface->unregisterCallback(handle);
+}
+
+void CameraPath::addKnot(Real const frame, BasicCameraData const& data)
{
Knot knot;
- knot.time=time;
+ knot.frame=frame;
knot.data=data;
+ // Force a control point at frame zero (prevents camera from going berzerk
+ // on playback)
+ if (knots.size() == 0) {
+ Knot first;
+ first.frame=0;
+ first.data=data;
+ knots.push_back(first);
+ }
+
knots.push_back(knot);
}
@@ -56,7 +79,7 @@
if (!in)
throw InputError("Failed to open \"" + fname + "\" for reading");
- // Read data
+ // Read control point data
unsigned int total_knots;
in>>total_knots;
@@ -69,7 +92,11 @@
Real ux, uy, uz;
Real fov;
+ // Frame number (+/- offset)
in>>frame;
+ frame += offset;
+
+ // Camera parameters
in>>ex>>ey>>ez;
in>>lx>>ly>>lz;
in>>ux>>uy>>uz;
@@ -107,7 +134,7 @@
// Write data
out<<knots.size()<<'\n';
for (unsigned int i=0; i<knots.size(); ++i) {
- out<<knots[i].time<<' '
+ out<<knots[i].frame<<' '
<<knots[i].data.eye<<' '
<<knots[i].data.lookat<<' '
<<knots[i].data.up<<' '
Modified: trunk/Interface/CameraPath.h
==============================================================================
--- trunk/Interface/CameraPath.h (original)
+++ trunk/Interface/CameraPath.h Wed Aug 16 18:42:26 2006
@@ -4,35 +4,46 @@
#include <Core/Math/Spline.h>
#include <Interface/Camera.h>
-#include <Interface/MantaInterface.h>
#include <string>
#include <vector>
namespace Manta
{
+ class BasicCameraData;
+ class CallbackHandle;
+ class MantaInterface;
+
class CameraPath
{
public:
typedef enum { ReadKnots, WriteKnots } Mode;
CameraPath(MantaInterface* interface, string const& fname,
- Mode mode=WriteKnots);
+ Mode mode=WriteKnots, bool loop=false, int offset=0);
~CameraPath(void);
void interpolate(int, int, bool&);
+ void animate(void);
+ void reset(void) { frame=0; }
- void addKnot(Real const time, BasicCameraData const& data);
+ void addKnot(Real const frame, BasicCameraData const& data);
void readKnots(void);
void writeKnots(void) const;
private:
MantaInterface* interface;
std::string fname;
+ bool loop;
+ int offset;
+ CallbackHandle* handle;
+ bool anim;
+ unsigned int frame;
+ unsigned int max_frame;
struct Knot
{
- Real time;
+ Real frame;
BasicCameraData data;
};
std::vector<Knot> knots;
@@ -41,7 +52,6 @@
Spline<Vector> lookats;
Spline<Vector> ups;
Spline<Real> fovs;
- int max_frame;
};
}
Modified: trunk/Interface/MantaInterface.h
==============================================================================
--- trunk/Interface/MantaInterface.h (original)
+++ trunk/Interface/MantaInterface.h Wed Aug 16 18:42:26 2006
@@ -132,16 +132,17 @@
Absolute, Relative
};
virtual void addOneShotCallback(Whence whence, long frame,
- CallbackBase_2Data<int, int>* callback) =
0;
+ CallbackBase_2Data<int, int>* callback)
= 0;
virtual void addParallelOneShotCallback(Whence whence, long frame,
- CallbackBase_2Data<int, int>* callback) = 0;
- virtual void registerSetupCallback(SetupCallback*) = 0;
- virtual void registerSerialAnimationCallback(CallbackBase_3Data<int,
int, bool&>*) = 0;
- virtual void registerParallelAnimationCallback(CallbackBase_3Data<int,
int, bool&>*) = 0;
- virtual void registerSerialPreRenderCallback(CallbackBase_2Data<int,
int>*) = 0;
- virtual void registerParallelPreRenderCallback(CallbackBase_2Data<int,
int>*) = 0;
- virtual void registerTerminationCallback( CallbackBase_1Data<
MantaInterface *> *) = 0;
-
+ CallbackBase_2Data<int, int>*
callback) = 0;
+ virtual CallbackHandle* registerSetupCallback(SetupCallback*) = 0;
+ virtual CallbackHandle*
registerSerialAnimationCallback(CallbackBase_3Data<int, int, bool&>*) = 0;
+ virtual CallbackHandle*
registerParallelAnimationCallback(CallbackBase_3Data<int, int, bool&>*) = 0;
+ virtual CallbackHandle*
registerSerialPreRenderCallback(CallbackBase_2Data<int, int>*) = 0;
+ virtual CallbackHandle*
registerParallelPreRenderCallback(CallbackBase_2Data<int, int>*) = 0;
+ virtual CallbackHandle* registerTerminationCallback( CallbackBase_1Data<
MantaInterface *> *) = 0;
+ virtual void unregisterCallback(CallbackHandle*) = 0;
+
// Settings
enum TimeMode {
RealTime, FixedRate, Static, FixedSamplingRate
Modified: trunk/Interface/SetupCallback.h
==============================================================================
--- trunk/Interface/SetupCallback.h (original)
+++ trunk/Interface/SetupCallback.h Wed Aug 16 18:42:26 2006
@@ -2,9 +2,11 @@
#ifndef Manta_Interface_SetupCallback_h
#define Manta_Interface_SetupCallback_h
+#include <Interface/CallbackHandle.h>
+
namespace Manta {
class SetupContext;
- class SetupCallback {
+ class SetupCallback : public CallbackHandle {
public:
virtual ~SetupCallback();
virtual void setupBegin(const SetupContext&, int numChannels) = 0;
Modified: trunk/UserInterface/XWindowUI.cc
==============================================================================
--- trunk/UserInterface/XWindowUI.cc (original)
+++ trunk/UserInterface/XWindowUI.cc Wed Aug 16 18:42:26 2006
@@ -68,23 +68,34 @@
: rtrt_interface(rtrt_interface), xlock("XWindowUI display lock"),
xsema("XWindowUI semaphore", 0), path( 0 )
{
+ bool loop=false;
+ int offset=0;
+ string fname="";
+ CameraPath::Mode mode;
// Parse command line args.
for (int i=0;i<args.size();++i) {
const string &arg = args[i];
- if (arg=="-opath") {
- string fname;
+ if (arg=="-loop") {
+ loop=true;
+ } else if (arg=="-offset") {
+ if (!getIntArg(i, args, offset))
+ throw IllegalArgument("XWindowUI -offset", i, args);
+ } else if (arg=="-opath") {
if (!getStringArg(i, args, fname))
- throw IllegalArgument("scene dynplt -path", i, args);
- path = new CameraPath(rtrt_interface, fname, CameraPath::WriteKnots);
+ throw IllegalArgument("XWindowUI -opath", i, args);
+ mode=CameraPath::WriteKnots;
} else if (arg=="-path") {
- string fname;
if (!getStringArg(i, args, fname))
- throw IllegalArgument("scene dynplt -path", i, args);
- path = new CameraPath(rtrt_interface, fname, CameraPath::ReadKnots);
+ throw IllegalArgument("XWindowUI -path", i, args);
+ mode=CameraPath::ReadKnots;
}
}
+ // Create a CameraPath (if necessary)
+ if (fname != "")
+ path = new CameraPath(rtrt_interface, fname, mode, loop, offset);
+
fov_speed = 10;
translate_speed = 1;
dolly_speed = 5;
@@ -457,6 +468,12 @@
register_key(0, XStringToKeysym("K"),
"write knots",
Callback::create(this, &XWindowUI::write_knots));
+ register_key(0, XK_space,
+ "animate path",
+ Callback::create(this, &XWindowUI::animate_path));
+ register_key(0, XStringToKeysym("r"),
+ "reset path",
+ Callback::create(this, &XWindowUI::reset_path));
register_key(0, XStringToKeysym("c"),
"output camera",
Callback::create(this, &XWindowUI::output_camera));
@@ -571,6 +588,24 @@
return;
path->writeKnots();
+}
+
+void XWindowUI::animate_path(unsigned int, unsigned long, int channel)
+{
+ if (!path)
+ return;
+
+ rtrt_interface->addTransaction("animate path",
+ Callback::create(path,
&CameraPath::animate));
+}
+
+void XWindowUI::reset_path(unsigned int, unsigned long, int channel)
+{
+ if (!path)
+ return;
+
+ rtrt_interface->addTransaction("reset path",
+ Callback::create(path, &CameraPath::reset));
}
void XWindowUI::output_camera(unsigned int, unsigned long, int channel)
Modified: trunk/UserInterface/XWindowUI.h
==============================================================================
--- trunk/UserInterface/XWindowUI.h (original)
+++ trunk/UserInterface/XWindowUI.h Wed Aug 16 18:42:26 2006
@@ -82,6 +82,8 @@
void add_bookmark(unsigned int, unsigned long, int);
void add_knot(unsigned int, unsigned long, int);
void write_knots(unsigned int, unsigned long, int);
+ void animate_path(unsigned int, unsigned long, int);
+ void reset_path(unsigned int, unsigned long, int);
void output_camera(unsigned int, unsigned long, int);
void mouse_fov(unsigned int, unsigned int, int, int, int, int);
- [MANTA] r1182 - in trunk: Engine/Control Interface UserInterface, cgribble, 08/16/2006
Archive powered by MHonArc 2.6.16.
