gmueller/bluecore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

implemented application and scenegraph

Browse Source
This commit is contained in:
cirdan 2008-01-20 10:16:37 +00:00
parent 77504c68f3
commit 2373b382f1
29 changed files with 2196 additions and 2076 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
engine/Application.cpp Normal file
View File

@ -0,0 +1,220 @@
#include "Application.h"
#include "Utilities/CfgParser.h"
#include "Utilities/Log.h"
#include "ScriptSystem_Application.h"
#include "ScriptSystem_Camera.h"
#include "ScriptSystem_Font.h"
#include "ScriptSystem_Image.h"
#include "ScriptSystem_Math.h"
#include "ScriptSystem_RigidBody.h"
namespace BlueCore
{
void Application::KeySlot(int key, int action)
{
if (key == GLFW_KEY_ESC && action == GLFW_RELEASE)
quit();
}
void Application::MouseMoveSlot(int x, int y)
{
_CameraPhi += (x - _LastMouseX) / 200.0;
_LastMouseX = x;
_CameraTheta += (y - _LastMouseY) / 200.0;
_LastMouseY = y;
}
void Application::MouseWheelSlot(int z)
{
if ((z - _LastWheel) < 0)
_CameraRadius *= 2.0;
else
_CameraRadius *= 0.5;
if (_CameraRadius < 1.0)
_CameraRadius = 1.0;
_LastWheel = z;
}
bool Application::initialize()
{
CfgParser cfg;
cfg.parseFile("options.cfg");
int width = cfg.get("width", 640);
int height = cfg.get("height", 480);
bool fullscreen = cfg.get("fullscreen", false);
_Window = new RenderWindow();
if (_Window->create(width, height, 0, 0, 0, fullscreen) == false)
return false;
_Device = new RenderDevice(_Window);
_FontManager = new FontManager(_Device);
_MeshManager = new MeshManager(_Device);
_TextureManager = new TextureManager();
_ScriptSystem = new ScriptSystem();
_ShaderManager = new ShaderManager(_Window);
_Simulation = new RigidBodySimulation(_ScriptSystem);
_ModelManager = new ModelManager (_TextureManager, _ShaderManager, _MeshManager);
_RenderQueue = new RenderQueue();
setupScriptSystem_Application(_ScriptSystem, this);
setupScriptSystem_Camera(_ScriptSystem);
setupScriptSystem_Font(_ScriptSystem, _FontManager);
setupScriptSystem_Image(_ScriptSystem, _TextureManager, _Device);
setupScriptSystem_Math(_ScriptSystem);
setupScriptSystem_RigidBody(_ScriptSystem, _Simulation);
if (_ScriptSystem->loadScript("main") == false)
return false;
_ScriptSystem->callFunction("Initialize");
_Window->KeySignal.connect(this, &Application::KeySlot);
_Window->MouseMoveSignal.connect(this, &Application::MouseMoveSlot);
_Window->MouseWheelSignal.connect(this, &Application::MouseWheelSlot);
_Running = true;
return true;
}
void Application::shutdown()
{
_ScriptSystem->callFunction("Shutdown");
}
void Application::quit()
{
_Running = false;
}
void Application::run()
{
clog << "--- starting main loop..."<< endlog;
_SimulationTime = 0.0;
_StartTime = glfwGetTime();
_LastTime = _StartTime;
double delta = 0.0;
_Paused = false;
_Running = true;
while (_Window->isOpen() && _Running)
{
double now = glfwGetTime();
delta = now - _LastTime;
_LastTime = now;
_ScriptSystem->callFunction("OnFrame", delta, now - _StartTime);
_Device->clear();
//Quaternion q(-_CameraPhi, 0.0, -_CameraTheta);
//camera->setPosition(q.apply(Vector3(0.0, 0.0, _CameraRadius)));
//camera->setRotation(q);
//pos += 5 * _DeltaTime;
if (_SceneGraph.valid())
{
_SceneGraph->queue(_RenderQueue);
_RenderQueue->render(_Device);
}
/*
{
_Device->begin3D(_Camera);
_Device->setAmbientLight(1.0, 1.0, 1.0);
_RenderQueue->clear();
_RenderQueue->addOpaqueItem(model, Vector3(0.0, 0.0, 0.0),
Quaternion());
_RenderQueue->render(_Device);
_Device->end3D();
}
*/
/*
device->pushAbsoluteTransformation(Vector3(), camera->getRotation());
class RenderState
{
bool _Blending;
GLint _BlendFuncSrc;
GLint _BlendFuncDest;
bool _DepthTest;
bool _DepthMask;
bool _Lighting;
};
GLfloat mat_specular[] =
{ 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] =
{ 2.0 };
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_specular);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_specular);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_LIGHTING);
glColor4d( 1.0f, 1.0f, 1.0f, 1.0f);
device->setTexture(0, starTexture, true);
starMesh->render();
glDisable(GL_BLEND);
device->popTransformation();
*/
// device->useShader (program);
// device->setTexture (stage, name, texture)
// device->clearTextures (stage+1);
//glEnable (GL_TEXTURE_2D);
//glEnable (GL_LIGHTING);
//glBindTexture (GL_TEXTURE_2D, texture->getId() );
// device->
//device->
//model->render();
if (_Paused == false)
{
_Simulation->saveStates();
_Simulation->updateSteps(delta);
while (_Simulation->getSteps() > 0)
{
_ScriptSystem->callFunction("OnStep",
_Simulation->getStepSize(), _SimulationTime);
_SimulationTime += _Simulation->getStepSize();
_Simulation->step();
}
}
_Device->begin2D();
_ScriptSystem->callFunction("OnOverlay", delta, now - _StartTime);
_Device->end2D();
_Device->swap();
}
clog << "--- main loop finished..."<< endlog;
}
void Application::setSceneGraph(SceneGraph *graph)
{
_SceneGraph = graph;
}
void Application::togglePause()
{
_Paused = !_Paused;
}
}

60
engine/Application.h Normal file
View File

@ -0,0 +1,60 @@
#ifndef BLUECORE_APPLICATION_H
#define BLUECORE_APPLICATION_H
#include "RenderWindow.h"
#include "RenderDevice.h"
#include "FontManager.h"
#include "MeshManager.h"
#include "TextureManager.h"
#include "ShaderManager.h"
#include "ModelManager.h"
#include "TextureImage.h"
#include "ScriptSystem.h"
#include "RigidBodySimulation.h"
#include "SceneGraph.h"
namespace BlueCore
{
class Application : public Referenced, public sigslot::has_slots<>
{
bool _Running;
bool _Paused;
double _SimulationTime;
double _StartTime;
double _LastTime;
double _CameraPhi, _CameraTheta, _CameraRadius;
int _LastMouseX, _LastMouseY, _LastWheel;
ref_ptr<RenderWindow> _Window;
ref_ptr<RenderDevice> _Device;
ref_ptr<FontManager> _FontManager;
ref_ptr<MeshManager> _MeshManager;
ref_ptr<TextureManager> _TextureManager;
ref_ptr<ScriptSystem> _ScriptSystem;
ref_ptr<ShaderManager> _ShaderManager;
ref_ptr<RigidBodySimulation> _Simulation;
ref_ptr<ModelManager> _ModelManager;
ref_ptr<RenderQueue> _RenderQueue;
ref_ptr<SceneGraph> _SceneGraph;
void KeySlot(int key, int action);
void MouseMoveSlot(int x, int y);
void MouseWheelSlot(int z);
public:
bool initialize();
void shutdown();
void quit();
void run();
void togglePause();
void setSceneGraph (SceneGraph *scenegraph);
};
}
#endif /*APPLICATION_H_*/

98
engine/Camera.cpp
View File

@ -7,44 +7,36 @@
namespace BlueCore namespace BlueCore
{ {
Camera::Camera() :
Camera::Camera() _LookAt (false), _FoV(45.0), _NearPlane(1.0), _FarPlane(15000.0)
{ {
} }
Camera::~Camera() Camera::~Camera()
{ {
} }
void Camera::setFoV(Scalar fov) void Camera::setFoV(Scalar fov)
{ {
_FoV = fov; _FoV = fov;
} }
void Camera::setAspectRatio(Scalar aspect)
{
_AspectRatio = aspect;
}
void Camera::setNearPlane(Scalar near) void Camera::setNearPlane(Scalar near)
{ {
_NearPlane = near; _NearPlane = near;
} }
void Camera::setFarPlane(Scalar far) void Camera::setFarPlane(Scalar far)
{ {
_FarPlane = far; _FarPlane = far;
} }
void Camera::setPosition(const Vector3& position) void Camera::setPosition(const Vector3& position)
{ {
_Position = position; _Position = position;
if (_LookAt)
updateLookAtRotation();
} }
const Vector3& Camera::getPosition() const Vector3& Camera::getPosition()
@ -52,7 +44,6 @@ const Vector3& Camera::getPosition()
return _Position; return _Position;
} }
void Camera::setRotation(const Quaternion& rotation) void Camera::setRotation(const Quaternion& rotation)
{ {
_Rotation = rotation; _Rotation = rotation;
@ -63,69 +54,6 @@ const Quaternion& Camera::getRotation()
return _Rotation; return _Rotation;
} }
#if 0
void Camera::setupProjectionMatrix()
{
Scalar fW, fH;
fH = tan ( (_FoV / 2) / 180* Pi ) * _NearPlane;
fW = fH * _AspectRatio;
// setup projectiom matrix
glMatrixMode (GL_PROJECTION );
glLoadIdentity();
glFrustum ( -fW, fW, -fH, fH, _NearPlane, _FarPlane );
// save variables for frustum culling
/*
_near = nearZ;
_far = farZ;
_hNear = tan ( ( fov / 2 ) / 180 * Pi ) * nearZ;
_wNear = _hNear * aspect;
_hFar = tan ( ( fov / 2 ) / 180 * Pi ) * farZ;
_wFar = _hFar * aspect;
*/
}
void Camera::setupViewMatrix()
{
// set the view matrix
glMatrixMode (GL_MODELVIEW );
glLoadIdentity();
Matrix4x4 m(_Rotation, _Rotation.applyInversed(_Position * -1.0) );
glMultMatrixd ( ( GLdouble * ) &m.m );
/*
// calculate frustum planes
Vector3 up = q.apply ( Vector3 ( 0.0, 1.0, 0.0 ) );
Vector3 right = q.apply ( Vector3 ( 1.0, 0.0, 0.0 ) );
Vector3 d = q.apply ( Vector3 ( 0.0, 0.0, -1.0 ) );
Vector3 fc = p + d * _far;
Vector3 ftl = fc + ( up * _hFar ) - ( right * _wFar );
Vector3 ftr = fc + ( up * _hFar ) + ( right * _wFar );
Vector3 fbl = fc - ( up * _hFar ) - ( right * _wFar );
Vector3 fbr = fc - ( up * _hFar ) + ( right * _wFar );
Vector3 nc = p + d * _near;
Vector3 ntl = nc + ( up * _hNear ) - ( right * _wNear );
Vector3 ntr = nc + ( up * _hNear ) + ( right * _wNear );
Vector3 nbl = nc - ( up * _hNear ) - ( right * _wNear );
Vector3 nbr = nc - ( up * _hNear ) + ( right * _wNear );
_frustumPlanes[RightPlane] = Plane ( nbr, fbr, ntr );
_frustumPlanes[LeftPlane] = Plane ( ntl, fbl, nbl );
_frustumPlanes[BottomPlane] = Plane ( nbl, fbr, nbr );
_frustumPlanes[TopPlane] = Plane ( ntr, ftl, ntl );
_frustumPlanes[FarPlane] = Plane ( ftl, ftr, fbl );
_frustumPlanes[NearPlane] = Plane ( ntl, nbl, ntr );
*/
}
#endif
Scalar Camera::getNearPlane() const Scalar Camera::getNearPlane() const
{ {
return _NearPlane; return _NearPlane;
@ -141,5 +69,19 @@ Scalar Camera::getFov() const
return _FoV; return _FoV;
} }
} // namespace BlueCore void Camera::lookAt(const Vector3 &point)
{
_LookAt = true;
_LookAtPoint = point;
_LookAtUp = Vector3(0.0, 1.0, 0.0);
updateLookAtRotation();
}
void Camera::updateLookAtRotation()
{
Matrix3x3 m (_LookAtPoint - _Position, _LookAtUp);
_Rotation = m.toQuaternion().inversed();
}
} // namespace BlueCore

5
engine/Camera.h
View File

@ -19,12 +19,14 @@ private:
Vector3 _LookAtPoint; Vector3 _LookAtPoint;
Vector3 _LookAtUp; Vector3 _LookAtUp;
bool _LookAt; bool _LookAt;
Scalar _NearPlane, _FarPlane, _FoV, _AspectRatio; Scalar _FoV, _NearPlane, _FarPlane;
//Frustum _Frustum; //Frustum _Frustum;
Vector3 _Position; Vector3 _Position;
Quaternion _Rotation; Quaternion _Rotation;
void updateLookAtRotation();
public: public:
Camera(); Camera();
@ -35,7 +37,6 @@ public:
void lookStraight(); void lookStraight();
void setFoV(Scalar fov); void setFoV(Scalar fov);
void setAspectRatio(Scalar aspect);
void setNearPlane(Scalar near); void setNearPlane(Scalar near);
void setFarPlane(Scalar far); void setFarPlane(Scalar far);

1337
engine/Math/Matrix.h
View File

File diff suppressed because it is too large Load Diff

504
engine/Math/Quaternion.h
View File

@ -5,362 +5,234 @@
namespace BlueCore namespace BlueCore
{ {
template <class T> template<class T> class QuaternionTemplate
class QuaternionTemplate {
public:
T w, x, y, z;
inline QuaternionTemplate()
{ {
public: w = static_cast<T>(1.0);
T w, x, y, z; x = static_cast<T>(0.0);
y = static_cast<T>(0.0);
z = static_cast<T>(0.0);
}
template<class S> inline QuaternionTemplate(S w, S x, S y, S z)
{
this->w = static_cast<T>(w);
this->x = static_cast<T>(x);
this->y = static_cast<T>(y);
this->z = static_cast<T>(z);
}
/** template<class S> inline QuaternionTemplate(Vector3Template<S> axis, S angle)
* constructor {
*/ T half_angle = static_cast<T>(angle)/static_cast<T>(2.0);
inline QuaternionTemplate() T sin_half_angle = static_cast<T>(sin(half_angle) );
{
w = static_cast<T>(1.0);
x = static_cast<T>(0.0);
y = static_cast<T>(0.0);
z = static_cast<T>(0.0);
}
w = static_cast<T>(cos(half_angle) );
x = sin_half_angle * static_cast<T>(axis.x);
y = sin_half_angle * static_cast<T>(axis.y);
z = sin_half_angle * static_cast<T>(axis.z);
}
/** template<class S> inline QuaternionTemplate(S h, S a, S b)
* contructor {
*/ T c1 = static_cast<T>(cos(h / 2.0) );
template <class S> T c2 = static_cast<T>(cos(a / 2.0) );
inline QuaternionTemplate( S w, S x, S y, S z ) T c3 = static_cast<T>(cos(b / 2.0) );
{ T s1 = static_cast<T>(sin(h / 2.0) );
this->w = static_cast<T>(w); T s2 = static_cast<T>(sin(a / 2.0) );
this->x = static_cast<T>(x); T s3 = static_cast<T>(sin(b / 2.0) );
this->y = static_cast<T>(y);
this->z = static_cast<T>(z);
}
w = c1 * c2 * c3 - s1 * s2 * s3;
x = s1 * s2 * c3 + c1 * c2 * s3;
y = s1 * c2 * c3 + c1 * s2 * s3;
z = c1 * s2 * c3 - s1 * c2 * s3;
}
/** inline void identity()
* contructor {
*/ w = static_cast<T>(1.0);
template <class S> x = static_cast<T>(0.0);
inline QuaternionTemplate( Vector3Template<S> axis, S angle ) y = static_cast<T>(0.0);
{ z = static_cast<T>(0.0);
T half_angle = static_cast<T>(angle)/static_cast<T>(2.0); }
T sin_half_angle = static_cast<T>( sin( half_angle ) );
w = static_cast<T>( cos( half_angle ) ); template<class S> inline QuaternionTemplate<T> operator +(
x = sin_half_angle * static_cast<T>(axis.x); const QuaternionTemplate<S> &a) const
y = sin_half_angle * static_cast<T>(axis.y); {
z = sin_half_angle * static_cast<T>(axis.z); return QuaternionTemplate<T>(w + static_cast<T>(a.w), x
} + static_cast<T>(a.x), y + static_cast<T>(a.y), z
+ static_cast<T>(a.z) );
}
template<class S> inline QuaternionTemplate<T> &operator +=(
const QuaternionTemplate<S> &a)
{
w += static_cast<T>(a.w);
x += static_cast<T>(a.x);
y += static_cast<T>(a.y);
z += static_cast<T>(a.z);
/** return *this;
* contructor }
*/
template <class S>
inline QuaternionTemplate( S h, S a, S b )
{
T c1 = static_cast<T>( cos(h / 2.0) );
T c2 = static_cast<T>( cos(a / 2.0) );
T c3 = static_cast<T>( cos(b / 2.0) );
T s1 = static_cast<T>( sin(h / 2.0) );
T s2 = static_cast<T>( sin(a / 2.0) );
T s3 = static_cast<T>( sin(b / 2.0) );
w = c1 * c2 * c3 - s1 * s2 * s3; template<class S> inline QuaternionTemplate<T> operator -(
x = s1 * s2 * c3 + c1 * c2 * s3; const QuaternionTemplate<S> &a) const
y = s1 * c2 * c3 + c1 * s2 * s3; {
z = c1 * s2 * c3 - s1 * c2 * s3; return QuaternionTemplate<T>(w - static_cast<T>(a.w), x
} - static_cast<T>(a.x), y - static_cast<T>(a.y), z
- static_cast<T>(a.z) );
}
template<class S> inline QuaternionTemplate<T> operator *(
const QuaternionTemplate<S> &a) const
{
return QuaternionTemplate<T>(w * static_cast<T>(a.w) - x
* static_cast<T>(a.x) - y * static_cast<T>(a.y) - z
* static_cast<T>(a.z), w * static_cast<T>(a.x) + x
* static_cast<T>(a.w) + y * static_cast<T>(a.z) - z
* static_cast<T>(a.y), w * static_cast<T>(a.y) - x
* static_cast<T>(a.z) + y * static_cast<T>(a.w) + z
* static_cast<T>(a.x), w * static_cast<T>(a.z) + x
* static_cast<T>(a.y) - y * static_cast<T>(a.x) + z
* static_cast<T>(a.w) );
}
/** template<class S> inline QuaternionTemplate<T> &operator *=(
* identity const QuaternionTemplate<S> &a)
*/ {
inline void identity() w = w * static_cast<T>(a.w) - x * static_cast<T>(a.x) - y
{ * static_cast<T>(a.y) - z * static_cast<T>(a.z);
w = static_cast<T>(1.0); x = w * static_cast<T>(a.x) + x * static_cast<T>(a.w) + y
x = static_cast<T>(0.0); * static_cast<T>(a.z) - z * static_cast<T>(a.y);
y = static_cast<T>(0.0); y = w * static_cast<T>(a.y) - x * static_cast<T>(a.z) + y
z = static_cast<T>(0.0); * static_cast<T>(a.w) + z * static_cast<T>(a.x);
} z = w * static_cast<T>(a.z) + x * static_cast<T>(a.y) - y
* static_cast<T>(a.x) + z * static_cast<T>(a.w);
return *this;
}
/** template<class S> inline QuaternionTemplate<T> &operator -=(
* operator + const QuaternionTemplate<S> &a)
*/ {
template <class S> w -= static_cast<T>(a.w);
inline QuaternionTemplate<T> operator + ( x -= static_cast<T>(a.x);
const QuaternionTemplate<S> &a ) const y -= static_cast<T>(a.y);
{ z -= static_cast<T>(a.z);
return QuaternionTemplate<T>(
w + static_cast<T>(a.w),
x + static_cast<T>(a.x),
y + static_cast<T>(a.y),
z + static_cast<T>(a.z) );
}
return *this;
}
/** template<class S> inline QuaternionTemplate<T> &operator =(
* operator += const QuaternionTemplate<S> &a)
*/ {
template <class S> w = static_cast<T>(a.w);
inline QuaternionTemplate<T> &operator += ( x = static_cast<T>(a.x);
const QuaternionTemplate<S> &a ) y = static_cast<T>(a.y);
{ z = static_cast<T>(a.z);
w += static_cast<T>(a.w);
x += static_cast<T>(a.x);
y += static_cast<T>(a.y);
z += static_cast<T>(a.z);
return *this; return *this;
} }
inline QuaternionTemplate<T> unit() const
{
T d = 1/sqrt(w*w + x*x + y*y + z*z);
return QuaternionTemplate<T>(w * d, x * d, y * d, z * d);
}
/** inline QuaternionTemplate<T> inversed() const
* operator - {
*/ return QuaternionTemplate<T>(w, -x, -y, -z);
template <class S> }
inline QuaternionTemplate<T> operator - (
const QuaternionTemplate<S> &a ) const
{
return QuaternionTemplate<T>(
w - static_cast<T>(a.w),
x - static_cast<T>(a.x),
y - static_cast<T>(a.y),
z - static_cast<T>(a.z) );
}
inline void inverse()
{
x = -x;
y = -y;
z = -z;
}
/** inline QuaternionTemplate<T> &normalize()
* operator * {
*/ T d = 1/sqrt(w*w + x*x + y*y + z*z);
template <class S> w *= d;
inline QuaternionTemplate<T> operator * ( x *= d;
const QuaternionTemplate<S> &a ) const y *= d;
{ z *= d;
return QuaternionTemplate<T>(
w * static_cast<T>(a.w) -
x * static_cast<T>(a.x) -
y * static_cast<T>(a.y) -
z * static_cast<T>(a.z),
w * static_cast<T>(a.x) +
x * static_cast<T>(a.w) +
y * static_cast<T>(a.z) -
z * static_cast<T>(a.y),
w * static_cast<T>(a.y) -
x * static_cast<T>(a.z) +
y * static_cast<T>(a.w) +
z * static_cast<T>(a.x),
w * static_cast<T>(a.z) +
x * static_cast<T>(a.y) -
y * static_cast<T>(a.x) +
z * static_cast<T>(a.w) );
}
return *this;
}
/** template<class S> inline const Vector3Template<T> apply(
* operator *= const Vector3Template<S> &a) const
*/ {
template <class S> T xx = x*x, xy = x*y, xz = x*z, xw = x*w, yy = y*y, yz = y*z, yw = y*w,
inline QuaternionTemplate<T> &operator *=(
const QuaternionTemplate<S> &a )
{
w = w * static_cast<T>(a.w) - x * static_cast<T>(a.x) -
y * static_cast<T>(a.y) - z * static_cast<T>(a.z);
x = w * static_cast<T>(a.x) + x * static_cast<T>(a.w) +
y * static_cast<T>(a.z) - z * static_cast<T>(a.y);
y = w * static_cast<T>(a.y) - x * static_cast<T>(a.z) +
y * static_cast<T>(a.w) + z * static_cast<T>(a.x);
z = w * static_cast<T>(a.z) + x * static_cast<T>(a.y) -
y * static_cast<T>(a.x) + z * static_cast<T>(a.w);
return *this;
}
/**
* operator -=
*/
template <class S>
inline QuaternionTemplate<T> &operator -= (
const QuaternionTemplate<S> &a )
{
w -= static_cast<T>(a.w);
x -= static_cast<T>(a.x);
y -= static_cast<T>(a.y);
z -= static_cast<T>(a.z);
return *this;
}
/**
* operator =
*/
template <class S>
inline QuaternionTemplate<T> &operator = (
const QuaternionTemplate<S> &a )
{
w = static_cast<T>(a.w);
x = static_cast<T>(a.x);
y = static_cast<T>(a.y);
z = static_cast<T>(a.z);
return *this;
}
/**
* unit
*/
inline QuaternionTemplate<T> unit() const
{
T d = 1/sqrt( w*w + x*x + y*y + z*z );
return QuaternionTemplate<T>( w * d, x * d, y * d, z * d );
}
/**
* inversed
*/
inline QuaternionTemplate<T> inversed() const
{
return QuaternionTemplate<T>( w, -x, -y, -z );
}
/**
* inversed
*/
inline void inverse()
{
x = -x;
y = -y;
z = -z;
}
/**
* normalize
*/
inline QuaternionTemplate<T> &normalize()
{
T d = 1/sqrt( w*w + x*x + y*y + z*z );
w *= d;
x *= d;
y *= d;
z *= d;
return *this;
}
/**
* apply
*/
template <class S>
inline const Vector3Template<T> apply(
const Vector3Template<S> &a ) const
{
T xx = x*x, xy = x*y, xz = x*z, xw = x*w,
yy = y*y, yz = y*z, yw = y*w,
zz = z*z, zw = z*w; zz = z*z, zw = z*w;
return Vector3Template<T>( return Vector3Template<T>( 2.0 * ( static_cast<T>(a.x) * ( 0.5 - yy
2.0 * ( static_cast<T>(a.x) * ( 0.5 - yy - zz ) + - zz ) + static_cast<T>(a.y) * (xy - zw ) + static_cast<T>(a.z)
static_cast<T>(a.y) * ( xy - zw ) + * (xz + yw ) ),
static_cast<T>(a.z) * ( xz + yw ) ),
2.0 * ( static_cast<T>(a.x) * ( xy + zw ) + 2.0 * ( static_cast<T>(a.x) * (xy + zw ) + static_cast<T>(a.y) * ( 0.5
static_cast<T>(a.y) * ( 0.5 - xx - zz ) + - xx - zz ) + static_cast<T>(a.z) * (yz - xw ) ),
static_cast<T>(a.z) * ( yz - xw ) ),
2.0 * ( static_cast<T>(a.x) * ( xz - yw ) + 2.0 * ( static_cast<T>(a.x) * (xz - yw ) + static_cast<T>(a.y) * (yz
static_cast<T>(a.y) * ( yz + xw ) + + xw ) + static_cast<T>(a.z) * ( 0.5 - xx - yy ) ));
static_cast<T>(a.z) * ( 0.5 - xx - yy ) ) ); }
}
template<class S> inline const Vector3Template<T> operator *(
/** const Vector3Template<S> &a) const
* apply {
*/ T xx = x*x, xy = x*y, xz = x*z, xw = x*w, yy = y*y, yz = y*z, yw = y*w,
template <class S>
inline const Vector3Template<T> operator * (
const Vector3Template<S> &a ) const
{
T xx = x*x, xy = x*y, xz = x*z, xw = x*w,
yy = y*y, yz = y*z, yw = y*w,
zz = z*z, zw = z*w; zz = z*z, zw = z*w;
return Vector3Template<T>( return Vector3Template<T>( 2.0 * ( static_cast<T>(a.x) * ( 0.5 - yy
2.0 * ( static_cast<T>(a.x) * ( 0.5 - yy - zz ) + - zz ) + static_cast<T>(a.y) * (xy - zw ) + static_cast<T>(a.z)
static_cast<T>(a.y) * ( xy - zw ) + * (xz + yw ) ),
static_cast<T>(a.z) * ( xz + yw ) ),
2.0 * ( static_cast<T>(a.x) * ( xy + zw ) + 2.0 * ( static_cast<T>(a.x) * (xy + zw ) + static_cast<T>(a.y) * ( 0.5
static_cast<T>(a.y) * ( 0.5 - xx - zz ) + - xx - zz ) + static_cast<T>(a.z) * (yz - xw ) ),
static_cast<T>(a.z) * ( yz - xw ) ),
2.0 * ( static_cast<T>(a.x) * ( xz - yw ) + 2.0 * ( static_cast<T>(a.x) * (xz - yw ) + static_cast<T>(a.y) * (yz
static_cast<T>(a.y) * ( yz + xw ) + + xw ) + static_cast<T>(a.z) * ( 0.5 - xx - yy ) ));
static_cast<T>(a.z) * ( 0.5 - xx - yy ) ) ); }
}
template<class S> inline Vector3Template<T> applyInversed(
const Vector3Template<S> &a) const
{
T xx = x*x, xy = x*y, xz = x*z, xw = -x*w, yy = y*y, yz = y*z, yw = -y
*w, zz = z*z, zw = -z*w;
/** return Vector3Template<T>( 2.0 * ( static_cast<T>(a.x) * ( 0.5 - yy
* applyInversed - zz ) + static_cast<T>(a.y) * (xy - zw ) + static_cast<T>(a.z)
*/ * (xz + yw ) ),
template <class S>
inline Vector3Template<T> applyInversed(
const Vector3Template<S> &a ) const
{
T xx = x*x, xy = x*y, xz = x*z, xw = -x*w,
yy = y*y, yz = y*z, yw = -y*w,
zz = z*z, zw = -z*w;
return Vector3Template<T>( 2.0 * ( static_cast<T>(a.x) * (xy + zw ) + static_cast<T>(a.y) * ( 0.5
2.0 * ( static_cast<T>(a.x) * ( 0.5 - yy - zz ) + - xx - zz ) + static_cast<T>(a.z) * (yz - xw ) ),
static_cast<T>(a.y) * ( xy - zw ) +
static_cast<T>(a.z) * ( xz + yw ) ),
2.0 * ( static_cast<T>(a.x) * ( xy + zw ) + 2.0 * ( static_cast<T>(a.x) * (xz - yw ) + static_cast<T>(a.y) * (yz
static_cast<T>(a.y) * ( 0.5 - xx - zz ) + + xw ) + static_cast<T>(a.z) * ( 0.5 - xx - yy ) ));
static_cast<T>(a.z) * ( yz - xw ) ), }
2.0 * ( static_cast<T>(a.x) * ( xz - yw ) + inline QuaternionTemplate<T> slerp(const QuaternionTemplate<T> &q,
static_cast<T>(a.y) * ( yz + xw ) + const Scalar &t)
static_cast<T>(a.z) * ( 0.5 - xx - yy ) ) ); {
} T phi = acos(w*q.w + x*q.x + y*q.y + z*q.z);
T s = 1 / sin(phi);
T a = sin(phi*(1-t)) * s;
T b = sin(phi*t) * s;
/** return QuaternionTemplate<T>(a*w+b*q.w, a*x+b*q.x, a*y+b*q.y, a*z+b*q.z);
* transform from ode to gl coodinates }
*/ };
inline QuaternionTemplate<T> toGl() const
{
return QuaternionTemplate<T>( w, x, z, -y );
}
/** typedef QuaternionTemplate<float> QuaternionFloat;
* transform from gl to ode coodinates typedef QuaternionTemplate<double> QuaternionDouble;
*/ typedef QuaternionTemplate<Scalar> Quaternion;
inline QuaternionTemplate<T> toOde() const
{
return QuaternionTemplate<T>( w, x, -z, y );
}
inline QuaternionTemplate<T> slerp( const QuaternionTemplate<T> &q, const Scalar &t )
{
Scalar phi = acos(w*q.w + x*q.x + y*q.y + z*q.z);
Scalar s = 1 / sin(phi);
Scalar a = sin(phi*(1-t)) * s;
Scalar b = sin(phi*t) * s;
return QuaternionTemplate<T>( a*w+b*q.w, a*x+b*q.x, a*y+b*q.y, a*z+b*q.z );
}
};
typedef QuaternionTemplate<float> QuaternionFloat;
typedef QuaternionTemplate<double> QuaternionDouble;
typedef QuaternionTemplate<Scalar> Quaternion;
} }
#endif #endif

18
engine/ModelManager.cpp
View File

@ -20,25 +20,21 @@ namespace BlueCore
void Model::render(RenderDevice *device) const void Model::render(RenderDevice *device) const
{ {
ModelMesh->render(); ModelMesh->render();
//glEnable(GL_LIGHTING); /*
//glDepthFunc ( GL_LEQUAL ); glEnable(GL_LIGHTING);
//glEnable ( GL_DEPTH_TEST ); glDepthFunc ( GL_LEQUAL );
//glDepthMask ( GL_TRUE ); glEnable ( GL_DEPTH_TEST );
glDepthMask ( GL_TRUE );
*/
/* /*
glEnableClientState (GL_VERTEX_ARRAY ); glEnableClientState (GL_VERTEX_ARRAY );
glEnableClientState (GL_TEXTURE_COORD_ARRAY ); glEnableClientState (GL_TEXTURE_COORD_ARRAY );
glEnableClientState (GL_NORMAL_ARRAY ); glEnableClientState (GL_NORMAL_ARRAY );
glMatrixMode (GL_MODELVIEW );
glPushMatrix();
Matrix4x4 m(_AbsoluteRotation, _AbsoluteTranslation);
glMultMatrixd ( ( GLdouble * ) &m.m );
mesh->vertex_buffer.bind(); mesh->vertex_buffer.bind();
mesh->index_buffer.bind(); mesh->index_buffer.bind();
*/ */
/* /*
glMaterialfv (GL_FRONT, GL_SHININESS, &pass.Shininess); glMaterialfv (GL_FRONT, GL_SHININESS, &pass.Shininess);
glMaterialfv (GL_FRONT, GL_SPECULAR, ( GLfloat * ) &pass.Specular ); glMaterialfv (GL_FRONT, GL_SPECULAR, ( GLfloat * ) &pass.Specular );

8
engine/RenderDevice.cpp
View File

@ -137,10 +137,12 @@ void RenderDevice::setupProjectionMatrix()
void RenderDevice::setupViewMatrix() void RenderDevice::setupViewMatrix()
{ {
if (_Camera.valid()) if (_Camera.valid())
{
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
Matrix4x4 m(_Camera->getRotation(), _Camera->getRotation().applyInversed(_Camera->getPosition() * -1.0) ); Matrix4x4 m(_Camera->getRotation(), _Camera->getRotation().applyInversed(_Camera->getPosition() * -1.0) );
glMultMatrixd( ( GLdouble * ) &m.m ); glMultMatrixd( ( GLdouble * ) &m.m );
}
} }
void RenderDevice::pushTransformation(const Vector3& position, void RenderDevice::pushTransformation(const Vector3& position,

1
engine/RigidBodySimulation.cpp
View File

@ -545,7 +545,6 @@ bool RigidBodySimulation::step()
{ {
if (_steps > 0) if (_steps > 0)
{ {
_ScriptSystem->callFunction("OnStep", _stepSize);
dSpaceCollide(_space, 0, &nearCallback); dSpaceCollide(_space, 0, &nearCallback);
dWorldQuickStep(_world, _stepSize); dWorldQuickStep(_world, _stepSize);
StepSignal(_stepSize); StepSignal(_stepSize);

2
engine/RigidBodySimulation.h
View File

@ -25,7 +25,7 @@ namespace BlueCore
{ {
class RigidBodySimulation; class RigidBodySimulation;
class RigidBody class RigidBody : public Referenced
{ {
Vector3 _Position; Vector3 _Position;
Quaternion _Orientation; Quaternion _Orientation;

35
engine/SceneGraph.cpp Normal file
View File

@ -0,0 +1,35 @@
#include "SceneGraph.h"
namespace BlueCore
{
SceneGraph::SceneGraph()
{
_RootNode = new SceneNode();
}
SceneGraph::~SceneGraph()
{
}
SceneNode* SceneGraph::getRootNode()
{
return _RootNode.pointer();
}
void SceneGraph::setCamera(Camera *camera)
{
_Camera = camera;
}
void SceneGraph::update(Scalar time)
{
_RootNode->update (time);
}
void SceneGraph::queue (RenderQueue *queue)
{
_RootNode->queue (queue, _Camera);
}
}

29
engine/SceneGraph.h Normal file
View File

@ -0,0 +1,29 @@
#ifndef BLUECORE_SCENEGRAPH_H
#define BLUECORE_SCENEGRAPH_H
#include "SceneNode.h"
namespace BlueCore
{
class SceneGraph : public Referenced
{
ref_ptr<SceneNode> _RootNode;
ref_ptr<Camera> _Camera;
public:
SceneGraph();
~SceneGraph();
SceneNode* getRootNode();
void setCamera(Camera *camera);
void update(Scalar time);
void queue (RenderQueue *queue);
};
}
#endif /*SCENEGRAPH_H_*/

136
engine/SceneNode.cpp
View File

@ -1,162 +1,150 @@
#include "SceneNode.h" #include "SceneNode.h"
namespace BlueCore { namespace BlueCore
{
#define DEBUG_SCENEGRAPH #define DEBUG_SCENEGRAPH
//------------------------------------------------------------------------------
SceneNode::SceneNode() : SceneNode::SceneNode() :
Named("unnamed SceneNode"), _Parent(0) Named("unnamed SceneNode"), _Parent(0)
{ {
#ifdef DEBUG_SCENEGRAPH #ifdef DEBUG_SCENEGRAPH
clog << "SceneNode 'Unnamed SceneNode' created." << endline; clog << "SceneNode 'Unnamed SceneNode' created." << endline;
#endif #endif
} }
//------------------------------------------------------------------------------
SceneNode::SceneNode(const std::string &name) : SceneNode::SceneNode(const std::string &name) :
Named(name), _Parent(0) Named(name), _Parent(0)
{ {
#ifdef DEBUG_SCENEGRAPH #ifdef DEBUG_SCENEGRAPH
clog << "SceneNode '" << name << "' created." << endline; clog << "SceneNode '" << name << "' created." << endline;
#endif #endif
} }
//------------------------------------------------------------------------------
SceneNode::~SceneNode() SceneNode::~SceneNode()
{ {
detachAll(); detachAll();
#ifdef DEBUG_SCENEGRAPH #ifdef DEBUG_SCENEGRAPH
clog << "SceneNode '" << getName() << "' deleted." << endline; clog << "SceneNode '" << getName() << "' deleted." << endline;
#endif #endif
} }
//------------------------------------------------------------------------------
void SceneNode::attach(SceneNode *node) void SceneNode::attach(SceneNode *node)
{ {
if (node == 0) if (node == 0)
return; return;
_Children.push_back(node ); _Children.push_back(node);
node->_Parent = this; node->_Parent = this;
node->addReference(); node->addReference();
#ifdef DEBUG_SCENEGRAPH #ifdef DEBUG_SCENEGRAPH
clog << "SceneNode '" << node->getName() << "' attached to '" << this->getName() << "'" << endline; clog << "SceneNode '" << node->getName() << "' attached to '"
<< this->getName() << "'" << endline;
#endif #endif
} }
//------------------------------------------------------------------------------
void SceneNode::detach(SceneNode *node) void SceneNode::detach(SceneNode *node)
{ {
node->_Parent = 0; node->_Parent = 0;
node->removeReference(); node->removeReference();
_Children.remove(node ); _Children.remove(node);
#ifdef DEBUG_SCENEGRAPH #ifdef DEBUG_SCENEGRAPH
clog << "SceneNode '" << node->getName() << "' detach from '" << this->getName() << "'" << endline; clog << "SceneNode '" << node->getName() << "' detach from '"
<< this->getName() << "'" << endline;
#endif #endif
} }
//------------------------------------------------------------------------------
void SceneNode::detachAll() void SceneNode::detachAll()
{ {
SceneNodeList::iterator i; SceneNodeList::iterator i;
for (i = _Children.begin(); i != _Children.end(); i++) for (i = _Children.begin(); i != _Children.end(); i++)
{ {
( *i )->_Parent = 0; ( *i )->_Parent = 0;
( *i )->removeReference(); ( *i )->removeReference();
} }
_Children.clear(); _Children.clear();
} }
//------------------------------------------------------------------------------
SceneNode *SceneNode::getParent() const SceneNode *SceneNode::getParent() const
{ {
return _Parent; return _Parent;
} }
//------------------------------------------------------------------------------
void SceneNode::detachFromParent() void SceneNode::detachFromParent()
{ {
if (_Parent ) if (_Parent)
_Parent->detach( this); _Parent->detach( this);
} }
//------------------------------------------------------------------------------ const SceneNode::SceneNodeList& SceneNode::getChildren() const
const SceneNode::SceneNodeList& SceneNode::getChildren () const
{ {
return _Children; return _Children;
} }
//------------------------------------------------------------------------------
void SceneNode::update(Scalar time) void SceneNode::update(Scalar time)
{ {
updateAbsoluteTransformation(); updateAbsoluteTransformation();
// if (isActive() ) // if (isActive() )
{ {
SceneNodeList::iterator i; SceneNodeList::iterator i;
for (i = _Children.begin(); i != _Children.end(); i++) for (i = _Children.begin(); i != _Children.end(); i++)
( *i )->update(time ); ( *i )->update(time);
} }
} }
//------------------------------------------------------------------------------ void SceneNode::queue(RenderQueue *queue, Camera *camera)
void SceneNode::render(RenderDevice *device, Camera *camera)
{ {
if (isActive() ) if (isActive())
{ {
SceneNodeList::iterator i; SceneNodeList::iterator i;
for (i = _Children.begin(); i != _Children.end(); i++) for (i = _Children.begin(); i != _Children.end(); i++)
{ {
( *i )->render(device, camera); ( *i )->queue(queue, camera);
} }
} }
} }
//------------------------------------------------------------------------------
const Transformation& SceneNode::getRelativeTransformation() const Transformation& SceneNode::getRelativeTransformation()
{ {
return _RelativeTransformation; return _RelativeTransformation;
} }
const Transformation& SceneNode::getAbsoluteTransformation() const Transformation& SceneNode::getAbsoluteTransformation()
{ {
return _AbsoluteTransformation; return _AbsoluteTransformation;
} }
//------------------------------------------------------------------------------
void SceneNode::setRelativeTranslation(const Vector3 &translation) void SceneNode::setRelativeTranslation(const Vector3 &translation)
{ {
_RelativeTransformation.translation = translation; _RelativeTransformation.translation = translation;
} }
//------------------------------------------------------------------------------ void SceneNode::setRelativeRotation(const Quaternion &rotation)
void SceneNode::setRelativeRotation (const Quaternion &rotation)
{ {
_RelativeTransformation.rotation = rotation; _RelativeTransformation.rotation = rotation;
} }
//------------------------------------------------------------------------------
void SceneNode::updateAbsoluteTransformation() void SceneNode::updateAbsoluteTransformation()
{ {
/* /*
if (_Parent ) if (_Parent )
_AbsoluteTranslation = _Parent->getAbsoluteTranslation() _AbsoluteTranslation = _Parent->getAbsoluteTranslation()
+_Parent->getAbsoluteRotation().inversed() * _RelativeTranslation; +_Parent->getAbsoluteRotation().inversed() * _RelativeTranslation;
else else
_AbsoluteTranslation = _RelativeTranslation; _AbsoluteTranslation = _RelativeTranslation;
*/ */
} }
} // namespace BlueCore } // namespace BlueCore

9
engine/SceneNode.h
View File

@ -2,7 +2,9 @@
#define BLUECORE_SCENE_NODE_H #define BLUECORE_SCENE_NODE_H
#include "Camera.h" #include "Camera.h"
#include "RenderDevice.h" #include "RenderQueue.h"
#include "RigidBodySimulation.h"
#include "ModelManager.h"
#include "Utilities/Referenced.h" #include "Utilities/Referenced.h"
#include "Utilities/Named.h" #include "Utilities/Named.h"
@ -30,6 +32,9 @@ class SceneNode : public Referenced, public Named, public Activated
Transformation _RelativeTransformation; Transformation _RelativeTransformation;
Transformation _AbsoluteTransformation; Transformation _AbsoluteTransformation;
weak_ptr<RigidBody> _RigidBody;
weak_ptr<Model> _Model;
public: public:
SceneNode(); SceneNode();
@ -45,7 +50,7 @@ class SceneNode : public Referenced, public Named, public Activated
void detachFromParent(); void detachFromParent();
virtual void update(Scalar time); virtual void update(Scalar time);
virtual void render (RenderDevice *device, Camera *camera); virtual void queue (RenderQueue *queue, Camera *camera);
const Transformation& getRelativeTransformation(); const Transformation& getRelativeTransformation();
const Transformation& getAbsoluteTransformation(); const Transformation& getAbsoluteTransformation();

16
engine/ScriptSystem.cpp
View File

@ -200,4 +200,20 @@ void ScriptSystem::callFunction(const std::string &name, double value)
} }
sq_pop(_VM, 1); sq_pop(_VM, 1);
} }
void ScriptSystem::callFunction(const std::string &name, double value1, double value2)
{
sq_pushroottable(_VM);
sq_pushstring(_VM, name.c_str(), -1);
if (SQ_SUCCEEDED(sq_get(_VM, -2)) )
{
sq_pushroottable(_VM);
sq_pushfloat(_VM, value1);
sq_pushfloat(_VM, value2);
sq_call(_VM, 3, SQFalse, SQTrue);
sq_pop(_VM, 1);
}
sq_pop(_VM, 1);
}
} }

2
engine/ScriptSystem.h
View File

@ -31,6 +31,8 @@ class ScriptSystem : public Referenced
void callFunction(const std::string &name); void callFunction(const std::string &name);
void callFunction(const std::string &name, double value); void callFunction(const std::string &name, double value);
void callFunction(const std::string &name, double value1, double value2);
void callFunction(const std::string &name, double value1, double value2, double value3);
}; };
} // namespace BlueCore } // namespace BlueCore

59
engine/ScriptSystem_Application.cpp Normal file
View File

@ -0,0 +1,59 @@
#include "Application.h"
namespace BlueCore
{
static weak_ptr<Application> gApplication;
static SQInteger _quit(HSQUIRRELVM v)
{
if (gApplication.valid())
gApplication->quit();
return 0;
}
static SQInteger _toggle_pause(HSQUIRRELVM v)
{
if (gApplication.valid())
gApplication->togglePause();
return 0;
}
static SQInteger _setscenegraph(HSQUIRRELVM v)
{
SceneGraph *scenegraph = 0;
sq_getinstanceup(v, -1, ( void ** ) &scenegraph, 0);
gApplication->setSceneGraph(scenegraph);
return 0;
}
void setupScriptSystem_Application(ScriptSystem* scriptsystem,
Application* application)
{
if (application == 0)
return;
gApplication = application;
HSQUIRRELVM vm = scriptsystem->getVM();
sq_pushroottable(vm);
sq_pushstring(vm, "quit", -1);
sq_newclosure(vm, _quit, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, "togglePause", -1);
sq_newclosure(vm, _toggle_pause, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, "setSceneGraph", -1);
sq_newclosure(vm, _setscenegraph, 0);
sq_newslot(vm, -3, false);
sq_pop(vm, 1);
}
}

11
engine/ScriptSystem_Application.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef BLUECORE_SCRIPTING_APPLICATION_H
#define BLUECORE_SCRIPTING_APPLICATION_H
#include "Application.h"
namespace BlueCore
{
void setupScriptSystem_Application(ScriptSystem* scriptsystem, Application* application);
}
#endif

125
engine/ScriptSystem_Camera.cpp Normal file
View File

@ -0,0 +1,125 @@
#include "ScriptSystem_Camera.h"
#include "ScriptSystem_Math.h"
#include "Camera.h"
namespace BlueCore
{
static SQInteger _camera_releasehook(SQUserPointer p, SQInteger size)
{
Camera *camera = (Camera *)p;
if (camera)
camera->removeReference();
return 1;
}
static SQInteger _camera_constructor(HSQUIRRELVM vm)
{
SQInteger argc = sq_gettop(vm);
if (argc < 1)
return 0;
Camera *camera = new Camera();
camera->addReference();
sq_setinstanceup(vm, 1, (void *)camera );
sq_setreleasehook(vm, 1, _camera_releasehook);
return 0;
}
static SQInteger _camera_setposition(HSQUIRRELVM v)
{
Camera *camera = 0;
sq_getinstanceup(v, 1, ( void ** ) &camera, 0);
if (camera)
{
Vector3 position;
int argc = sq_gettop(v);
if (argc == 2)
{
_getvectorvalues(v, 2, position.x, position.y, position.z);
}
else if (argc == 4)
{
sq_getfloat(v, 2, &position.x);
sq_getfloat(v, 3, &position.y);
sq_getfloat(v, 4, &position.z);
}
camera->setPosition(position);
}
return 0;
}
static SQInteger _camera_lookat(HSQUIRRELVM v)
{
Camera *camera = 0;
sq_getinstanceup(v, 1, ( void ** ) &camera, 0);
if (camera)
{
Vector3 position;
int argc = sq_gettop(v);
if (argc == 2)
{
_getvectorvalues(v, 2, position.x, position.y, position.z);
}
else if (argc == 4)
{
sq_getfloat(v, 2, &position.x);
sq_getfloat(v, 3, &position.y);
sq_getfloat(v, 4, &position.z);
}
camera->lookAt(position);
}
return 0;
}
void setupScriptSystem_Camera(ScriptSystem* scriptsystem)
{
if (scriptsystem == 0)
return;
HSQUIRRELVM vm = scriptsystem->getVM();
sq_pushroottable(vm);
// push class
sq_pushstring(vm, "Camera", -1);
if (SQ_SUCCEEDED(sq_newclass(vm, SQFalse) ) )
{
// register constructor
sq_pushstring(vm, "constructor", -1);
sq_newclosure(vm, _camera_constructor, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, "setPosition", -1);
sq_newclosure(vm, _camera_setposition, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, "lookAt", -1);
sq_newclosure(vm, _camera_lookat, 0);
sq_newslot(vm, -3, false);
// create class
sq_newslot(vm, -3, false);
}
sq_poptop(vm);
}
}

11
engine/ScriptSystem_Camera.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef BLUECORE_SCRIPTING_CAMERA_H
#define BLUECORE_SCRIPTING_CAMERA_H
#include "ScriptSystem.h"
namespace BlueCore
{
void setupScriptSystem_Camera(ScriptSystem* scriptsystem);
}
#endif

144
engine/ScriptSystem_Font.cpp
View File

@ -20,107 +20,107 @@ static SQInteger _font_releasehook(SQUserPointer p, SQInteger size)
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _font_constructor(HSQUIRRELVM vm) static SQInteger _font_constructor(HSQUIRRELVM vm)
{ {
SQInteger argc = sq_gettop (vm ); SQInteger argc = sq_gettop(vm);
Font *font = 0; Font *font = 0;
if (argc < 3) if (argc < 3)
{ {
if (gFontManager.valid()) if (gFontManager.valid())
font = gFontManager->getDefaultFont(); font = gFontManager->getDefaultFont();
} }
else else
{ {
const SQChar *name = 0; const SQChar *name = 0;
SQInteger size = 1; SQInteger size = 1;
SQBool hinting = SQFalse; SQBool hinting = SQFalse;
sq_getstring (vm, 2, &name ); sq_getstring(vm, 2, &name);
sq_getinteger (vm, 3, &size ); sq_getinteger(vm, 3, &size);
if (argc > 3) if (argc > 3)
sq_getbool(vm, 4, &hinting ); sq_getbool(vm, 4, &hinting);
if (gFontManager.valid()) if (gFontManager.valid())
{ {
font = gFontManager->loadFont(name, size, hinting == SQTrue ); font = gFontManager->loadFont(name, size, hinting == SQTrue);
if (font) if (font)
font->addReference(); font->addReference();
} }
} }
sq_setinstanceup(vm, 1, (void *)font ); sq_setinstanceup(vm, 1, (void *)font );
sq_setreleasehook (vm, 1, _font_releasehook ); sq_setreleasehook(vm, 1, _font_releasehook);
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _font_print(HSQUIRRELVM vm) static SQInteger _font_print(HSQUIRRELVM vm)
{ {
int argc = sq_gettop (vm ); int argc = sq_gettop(vm);
if (argc < 4) if (argc < 4)
return 0; return 0;
const Font *font = 0; const Font *font = 0;
sq_getinstanceup (vm, 1, ( void ** ) &font, 0); sq_getinstanceup(vm, 1, ( void ** ) &font, 0);
if (font) if (font)
{ {
SQFloat x, y; SQFloat x, y;
const char *text; const char *text;
SQInteger halign = 0, valign = 0; SQInteger halign = 0, valign = 0;
sq_getfloat (vm, 2, &x ); sq_getfloat(vm, 2, &x);
sq_getfloat (vm, 3, &y ); sq_getfloat(vm, 3, &y);
sq_getstring(vm, 4, &text); sq_getstring(vm, 4, &text);
if (argc > 4) if (argc > 4)
{ {
sq_getinteger(vm, 5, &halign ); sq_getinteger(vm, 5, &halign);
} }
if (argc > 5) if (argc > 5)
{ {
sq_getinteger(vm, 6, &valign ); sq_getinteger(vm, 6, &valign);
} }
font->print( (float)x, (float)y, text, halign, valign ); font->print( (float)x, (float)y, text, halign, valign);
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void setupScriptSystem_Font (ScriptSystem* scriptsystem, FontManager* fontmanager) void setupScriptSystem_Font(ScriptSystem* scriptsystem, FontManager* fontmanager)
{ {
if (scriptsystem && fontmanager) if (scriptsystem && fontmanager)
{ {
HSQUIRRELVM vm = scriptsystem->getVM(); HSQUIRRELVM vm = scriptsystem->getVM();
gFontManager = fontmanager; gFontManager = fontmanager;
sq_pushroottable (vm ); sq_pushroottable(vm);
// push class // push class
sq_pushstring (vm, "Font", -1); sq_pushstring(vm, "Font", -1);
if (SQ_SUCCEEDED (sq_newclass (vm, SQFalse ) ) ) if (SQ_SUCCEEDED(sq_newclass(vm, SQFalse) ) )
{ {
// register constructor // register constructor
sq_pushstring (vm, "constructor", -1); sq_pushstring(vm, "constructor", -1);
sq_newclosure (vm, _font_constructor, 0); sq_newclosure(vm, _font_constructor, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "print", -1); sq_pushstring(vm, "print", -1);
sq_newclosure (vm, _font_print, 0); sq_newclosure(vm, _font_print, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
// create class // create class
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
} }
sq_poptop (vm ); sq_poptop(vm);
} }
} }
} }

684
engine/ScriptSystem_RigidBody.cpp
View File

@ -11,532 +11,532 @@ static weak_ptr<RigidBodySimulation> gRigidBodySimulation;
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_getposition(HSQUIRRELVM v) static SQInteger _rigidbody_getposition(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
Vector3 position; Vector3 position;
if (sq_gettop (v ) == 1) if (sq_gettop(v) == 1)
{ {
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
} }
if (body ) if (body)
{ {
position = body->getPosition(); position = body->getPosition();
_pushvector (v, position.x, position.y, position.z); _pushvector(v, position.x, position.y, position.z);
return 1; return 1;
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_getrotation(HSQUIRRELVM v) static SQInteger _rigidbody_getrotation(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
Quaternion q; Quaternion q;
if (sq_gettop (v ) == 1) if (sq_gettop(v) == 1)
{ {
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
} }
if (body ) if (body)
{ {
q = body->getOrientation(); q = body->getOrientation();
_pushquaternion (v, q.w, q.x, q.y, q.z); _pushquaternion(v, q.w, q.x, q.y, q.z);
return 1; return 1;
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_getangularvelocity(HSQUIRRELVM v) static SQInteger _rigidbody_getangularvelocity(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
Vector3 velocity; Vector3 velocity;
if (sq_gettop (v ) == 1) if (sq_gettop(v) == 1)
{ {
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
} }
if (body ) if (body)
{ {
velocity = body->getAngularVelocity(); velocity = body->getAngularVelocity();
_pushvector (v, velocity.x, velocity.y, velocity.z); _pushvector(v, velocity.x, velocity.y, velocity.z);
return 1; return 1;
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_getlinearvelocity(HSQUIRRELVM v) static SQInteger _rigidbody_getlinearvelocity(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
Vector3 velocity; Vector3 velocity;
if (sq_gettop (v ) == 1) if (sq_gettop(v) == 1)
{ {
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
} }
if (body ) if (body)
{ {
velocity = body->getLinearVelocity(); velocity = body->getLinearVelocity();
_pushvector (v, velocity.x, velocity.y, velocity.z); _pushvector(v, velocity.x, velocity.y, velocity.z);
return 1; return 1;
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_setposition(HSQUIRRELVM v) static SQInteger _rigidbody_setposition(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
Vector3 position; Vector3 position;
int argc = sq_gettop (v ); int argc = sq_gettop(v);
if (argc == 2) if (argc == 2)
{ {
_getvectorvalues (v, 2, position.x, position.y, position.z); _getvectorvalues(v, 2, position.x, position.y, position.z);
} }
else if (argc == 4) else if (argc == 4)
{ {
sq_getfloat (v, 2, &position.x); sq_getfloat(v, 2, &position.x);
sq_getfloat (v, 3, &position.y); sq_getfloat(v, 3, &position.y);
sq_getfloat (v, 4, &position.z); sq_getfloat(v, 4, &position.z);
} }
body->setPosition(position ); body->setPosition(position);
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_setlinearvelocity(HSQUIRRELVM v) static SQInteger _rigidbody_setlinearvelocity(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
Vector3 velocity; Vector3 velocity;
int argc = sq_gettop (v ); int argc = sq_gettop(v);
if (argc == 2) if (argc == 2)
{ {
_getvectorvalues (v, 2, velocity.x, velocity.y, velocity.z); _getvectorvalues(v, 2, velocity.x, velocity.y, velocity.z);
} }
else if (argc == 4) else if (argc == 4)
{ {
sq_getfloat (v, 2, &velocity.x); sq_getfloat(v, 2, &velocity.x);
sq_getfloat (v, 3, &velocity.y); sq_getfloat(v, 3, &velocity.y);
sq_getfloat (v, 4, &velocity.z); sq_getfloat(v, 4, &velocity.z);
} }
body->setLinearVelocity(velocity ); body->setLinearVelocity(velocity);
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_setrotation(HSQUIRRELVM v) static SQInteger _rigidbody_setrotation(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
Quaternion q; Quaternion q;
int argc = sq_gettop (v ); int argc = sq_gettop(v);
if (argc == 2) if (argc == 2)
{ {
_getquaternionvalues (v, 2, q.w, q.x, q.y, q.z); _getquaternionvalues(v, 2, q.w, q.x, q.y, q.z);
} }
else if (argc == 5) else if (argc == 5)
{ {
sq_getfloat (v, 2, &q.w); sq_getfloat(v, 2, &q.w);
sq_getfloat (v, 3, &q.x); sq_getfloat(v, 3, &q.x);
sq_getfloat (v, 4, &q.y); sq_getfloat(v, 4, &q.y);
sq_getfloat (v, 5, &q.z); sq_getfloat(v, 5, &q.z);
} }
body->setOrientation(q ); body->setOrientation(q);
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_applylocalforce(HSQUIRRELVM v) static SQInteger _rigidbody_applylocalforce(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
int argc = sq_gettop (v ); int argc = sq_gettop(v);
if (argc == 2) if (argc == 2)
{ {
Vector3 force; Vector3 force;
_getvectorvalues (v, 2, force.x, force.y, force.z); _getvectorvalues(v, 2, force.x, force.y, force.z);
body->applyLocalForce(force ); body->applyLocalForce(force);
} }
else if (argc == 3) else if (argc == 3)
{ {
Vector3 force, point; Vector3 force, point;
_getvectorvalues (v, 2, force.x, force.y, force.z); _getvectorvalues(v, 2, force.x, force.y, force.z);
_getvectorvalues (v, 3, point.x, point.y, point.z); _getvectorvalues(v, 3, point.x, point.y, point.z);
body->applyLocalForce(force, point ); body->applyLocalForce(force, point);
} }
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_applyglobalforce(HSQUIRRELVM v) static SQInteger _rigidbody_applyglobalforce(HSQUIRRELVM v)
{ {
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
int argc = sq_gettop (v ); int argc = sq_gettop(v);
if (argc == 2) if (argc == 2)
{ {
Vector3 force; Vector3 force;
_getvectorvalues (v, 2, force.x, force.y, force.z); _getvectorvalues(v, 2, force.x, force.y, force.z);
body->applyGlobalForce(force ); body->applyGlobalForce(force);
} }
else if (argc == 3) else if (argc == 3)
{ {
Vector3 force, point; Vector3 force, point;
_getvectorvalues (v, 2, force.x, force.y, force.z); _getvectorvalues(v, 2, force.x, force.y, force.z);
_getvectorvalues (v, 3, point.x, point.y, point.z); _getvectorvalues(v, 3, point.x, point.y, point.z);
body->applyGlobalForce(force, point ); body->applyGlobalForce(force, point);
} }
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_addcollisionmesh(HSQUIRRELVM v) static SQInteger _rigidbody_addcollisionmesh(HSQUIRRELVM v)
{ {
SQInteger argc = sq_gettop (v ); SQInteger argc = sq_gettop(v);
if (argc < 3) if (argc < 3)
{ {
sq_pushinteger (v, 0); sq_pushinteger(v, 0);
return 1; return 1;
} }
RigidBody *body = 0; RigidBody *body = 0;
const SQChar *meshname = 0; const SQChar *meshname = 0;
SQFloat density = 1.0; SQFloat density = 1.0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
sq_getstring (v, 2, &meshname ); sq_getstring(v, 2, &meshname);
sq_getfloat (v, 3, &density ); sq_getfloat(v, 3, &density);
if (body ) if (body)
{ {
sq_pushinteger (v, body->addCollisionMesh(meshname, density ) ); sq_pushinteger(v, body->addCollisionMesh(meshname, density) );
} }
else else
sq_pushinteger (v, 0); sq_pushinteger(v, 0);
return 1; return 1;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_setcollisionmeshposition(HSQUIRRELVM v) static SQInteger _rigidbody_setcollisionmeshposition(HSQUIRRELVM v)
{ {
int argc = sq_gettop (v ); int argc = sq_gettop(v);
// need at least geom + vector // need at least geom + vector
if (argc < 3) if (argc < 3)
return 0; return 0;
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
SQInteger geom = 0; SQInteger geom = 0;
sq_getinteger (v, 2, &geom ); sq_getinteger(v, 2, &geom);
Vector3 position; Vector3 position;
if (argc == 3) if (argc == 3)
{ {
_getvectorvalues (v, 3, position.x, position.y, position.z); _getvectorvalues(v, 3, position.x, position.y, position.z);
} }
else if (argc == 5) else if (argc == 5)
{ {
sq_getfloat (v, 3, &position.x); sq_getfloat(v, 3, &position.x);
sq_getfloat (v, 4, &position.y); sq_getfloat(v, 4, &position.y);
sq_getfloat (v, 5, &position.z); sq_getfloat(v, 5, &position.z);
} }
body->setCollisionMeshPosition(geom, position ); body->setCollisionMeshPosition(geom, position);
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_disablecollisionmesh(HSQUIRRELVM v) static SQInteger _rigidbody_disablecollisionmesh(HSQUIRRELVM v)
{ {
int argc = sq_gettop (v ); int argc = sq_gettop(v);
// need at least geom // need at least geom
if (argc < 2) if (argc < 2)
return 0; return 0;
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
SQInteger geom = 0; SQInteger geom = 0;
sq_getinteger (v, 2, &geom ); sq_getinteger(v, 2, &geom);
body->disableCollisionMesh(geom ); body->disableCollisionMesh(geom);
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_enablecollisionmesh(HSQUIRRELVM v) static SQInteger _rigidbody_enablecollisionmesh(HSQUIRRELVM v)
{ {
int argc = sq_gettop (v ); int argc = sq_gettop(v);
// need at least geom // need at least geom
if (argc < 2) if (argc < 2)
return 0; return 0;
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
SQInteger geom = 0; SQInteger geom = 0;
sq_getinteger (v, 2, &geom ); sq_getinteger(v, 2, &geom);
body->enableCollisionMesh(geom ); body->enableCollisionMesh(geom);
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_setcollisionmeshrotation(HSQUIRRELVM v) static SQInteger _rigidbody_setcollisionmeshrotation(HSQUIRRELVM v)
{ {
int argc = sq_gettop (v ); int argc = sq_gettop(v);
// need at least geom + quaternion // need at least geom + quaternion
if (argc < 3) if (argc < 3)
return 0; return 0;
RigidBody *body = 0; RigidBody *body = 0;
sq_getinstanceup (v, 1, ( void ** ) &body, 0); sq_getinstanceup(v, 1, ( void ** ) &body, 0);
if (body ) if (body)
{ {
SQInteger geom = 0; SQInteger geom = 0;
sq_getinteger (v, 2, &geom ); sq_getinteger(v, 2, &geom);
Quaternion rotation; Quaternion rotation;
if (argc == 3) if (argc == 3)
{ {
_getquaternionvalues (v, 3, rotation.w, rotation.x, rotation.y, _getquaternionvalues(v, 3, rotation.w, rotation.x, rotation.y,
rotation.z); rotation.z);
} }
else if (argc == 4) else if (argc == 4)
{ {
Vector3 axis; Vector3 axis;
SQFloat angle; SQFloat angle;
_getvectorvalues (v, 3, axis.x, axis.y, axis.z); _getvectorvalues(v, 3, axis.x, axis.y, axis.z);
sq_getfloat (v, 5, &angle ); sq_getfloat(v, 5, &angle);
rotation = Quaternion (axis, angle ); rotation = Quaternion(axis, angle);
} }
else if (argc == 5) else if (argc == 5)
{ {
SQFloat h, a, b; SQFloat h, a, b;
sq_getfloat (v, 3, &h ); sq_getfloat(v, 3, &h);
sq_getfloat (v, 4, &a ); sq_getfloat(v, 4, &a);
sq_getfloat (v, 5, &b ); sq_getfloat(v, 5, &b);
rotation = Quaternion (h, a, b ); rotation = Quaternion(h, a, b);
} }
body->setCollisionMeshRotation(geom, rotation ); body->setCollisionMeshRotation(geom, rotation);
} }
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_releasehook(SQUserPointer p, SQInteger size) static SQInteger _rigidbody_releasehook(SQUserPointer p, SQInteger size)
{ {
if (gRigidBodySimulation.valid()) if (gRigidBodySimulation.valid())
{ {
RigidBody *self = ( RigidBody* ) p; RigidBody *self = ( RigidBody* ) p;
gRigidBodySimulation->deleteRigidBody(self ); gRigidBodySimulation->deleteRigidBody(self);
} }
return 1; return 1;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static SQInteger _rigidbody_constructor(HSQUIRRELVM v) static SQInteger _rigidbody_constructor(HSQUIRRELVM v)
{ {
RigidBody *body = gRigidBodySimulation->createRigidBody(); RigidBody *body = gRigidBodySimulation->createRigidBody();
if (SQ_FAILED (sq_setinstanceup (v, 1, body ) ) ) if (SQ_FAILED(sq_setinstanceup(v, 1, body) ) )
{ {
gRigidBodySimulation->deleteRigidBody(body ); gRigidBodySimulation->deleteRigidBody(body);
return 0; return 0;
} }
HSQOBJECT obj; HSQOBJECT obj;
sq_getstackobj (v, 2, &obj ); sq_getstackobj(v, 2, &obj);
body->setCollisionHandler(obj ); body->setCollisionHandler(obj);
sq_setreleasehook (v, 1, _rigidbody_releasehook ); sq_setreleasehook(v, 1, _rigidbody_releasehook);
return 0; return 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void setupScriptSystem_RigidBody(ScriptSystem *scriptsystem, void setupScriptSystem_RigidBody(ScriptSystem *scriptsystem,
RigidBodySimulation *simulation) RigidBodySimulation *simulation)
{ {
gRigidBodySimulation = simulation; gRigidBodySimulation = simulation;
HSQUIRRELVM vm = scriptsystem->getVM(); HSQUIRRELVM vm = scriptsystem->getVM();
sq_pushroottable(vm ); sq_pushroottable(vm);
sq_pushstring (vm, "RigidBody", -1); sq_pushstring(vm, "RigidBody", -1);
if (SQ_SUCCEEDED (sq_newclass (vm, SQFalse ) ) ) if (SQ_SUCCEEDED(sq_newclass(vm, SQFalse) ) )
{ {
// register rigidbody functions // register rigidbody functions
sq_pushstring (vm, "constructor", -1); sq_pushstring(vm, "constructor", -1);
sq_newclosure (vm, _rigidbody_constructor, 0); sq_newclosure(vm, _rigidbody_constructor, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "setPosition", -1); sq_pushstring(vm, "setPosition", -1);
sq_newclosure (vm, _rigidbody_setposition, 0); sq_newclosure(vm, _rigidbody_setposition, 0);
//sq_setparamscheck( vm, 2, "xx" ); //sq_setparamscheck( vm, 2, "xx" );
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "getPosition", -1); sq_pushstring(vm, "getPosition", -1);
sq_newclosure (vm, _rigidbody_getposition, 0); sq_newclosure(vm, _rigidbody_getposition, 0);
sq_setparamscheck (vm, 1, "x"); sq_setparamscheck(vm, 1, "x");
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "setRotation", -1); sq_pushstring(vm, "setRotation", -1);
sq_newclosure (vm, _rigidbody_setrotation, 0); sq_newclosure(vm, _rigidbody_setrotation, 0);
//sq_setparamscheck( vm, 2, "xx" ); //sq_setparamscheck( vm, 2, "xx" );
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "getRotation", -1); sq_pushstring(vm, "getRotation", -1);
sq_newclosure (vm, _rigidbody_getrotation, 0); sq_newclosure(vm, _rigidbody_getrotation, 0);
sq_setparamscheck (vm, 1, "x"); sq_setparamscheck(vm, 1, "x");
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "getLinearVelocity", -1); sq_pushstring(vm, "getLinearVelocity", -1);
sq_newclosure (vm, _rigidbody_getlinearvelocity, 0); sq_newclosure(vm, _rigidbody_getlinearvelocity, 0);
sq_setparamscheck (vm, 1, "x"); sq_setparamscheck(vm, 1, "x");
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "setLinearVelocity", -1); sq_pushstring(vm, "setLinearVelocity", -1);
sq_newclosure (vm, _rigidbody_setlinearvelocity, 0); sq_newclosure(vm, _rigidbody_setlinearvelocity, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "getAngularVelocity", -1); sq_pushstring(vm, "getAngularVelocity", -1);
sq_newclosure (vm, _rigidbody_getangularvelocity, 0); sq_newclosure(vm, _rigidbody_getangularvelocity, 0);
sq_setparamscheck (vm, 1, "x"); sq_setparamscheck(vm, 1, "x");
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "applyLocalForce", -1); sq_pushstring(vm, "applyLocalForce", -1);
sq_newclosure (vm, _rigidbody_applylocalforce, 0); sq_newclosure(vm, _rigidbody_applylocalforce, 0);
//sq_setparamscheck (vm, 3, "xxx"); //sq_setparamscheck (vm, 3, "xxx");
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "applyGlobalForce", -1); sq_pushstring(vm, "applyGlobalForce", -1);
sq_newclosure (vm, _rigidbody_applyglobalforce, 0); sq_newclosure(vm, _rigidbody_applyglobalforce, 0);
sq_setparamscheck (vm, 3, "xxx"); sq_setparamscheck(vm, 3, "xxx");
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "addCollisionMesh", -1); sq_pushstring(vm, "addCollisionMesh", -1);
sq_newclosure (vm, _rigidbody_addcollisionmesh, 0); sq_newclosure(vm, _rigidbody_addcollisionmesh, 0);
sq_setparamscheck (vm, 3, "xsn"); sq_setparamscheck(vm, 3, "xsn");
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "setCollisionMeshPosition", -1); sq_pushstring(vm, "setCollisionMeshPosition", -1);
sq_newclosure (vm, _rigidbody_setcollisionmeshposition, 0); sq_newclosure(vm, _rigidbody_setcollisionmeshposition, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "setCollisionMeshRotation", -1); sq_pushstring(vm, "setCollisionMeshRotation", -1);
sq_newclosure (vm, _rigidbody_setcollisionmeshrotation, 0); sq_newclosure(vm, _rigidbody_setcollisionmeshrotation, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "getCollisionMeshPosition", -1); sq_pushstring(vm, "getCollisionMeshPosition", -1);
sq_newclosure (vm, _rigidbody_setcollisionmeshposition, 0); sq_newclosure(vm, _rigidbody_setcollisionmeshposition, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "getCollisionMeshRotation", -1); sq_pushstring(vm, "getCollisionMeshRotation", -1);
sq_newclosure (vm, _rigidbody_setcollisionmeshrotation, 0); sq_newclosure(vm, _rigidbody_setcollisionmeshrotation, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "disableCollisionMesh", -1); sq_pushstring(vm, "disableCollisionMesh", -1);
sq_newclosure (vm, _rigidbody_disablecollisionmesh, 0); sq_newclosure(vm, _rigidbody_disablecollisionmesh, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_pushstring (vm, "enableCollisionMesh", -1); sq_pushstring(vm, "enableCollisionMesh", -1);
sq_newclosure (vm, _rigidbody_enablecollisionmesh, 0); sq_newclosure(vm, _rigidbody_enablecollisionmesh, 0);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
sq_newslot (vm, -3, false); sq_newslot(vm, -3, false);
} }
sq_poptop (vm ); sq_poptop(vm);
} }
} // namespace BlueCore } // namespace BlueCore

81
engine/ScriptSystem_SceneGraph.cpp Normal file
View File

@ -0,0 +1,81 @@
#include "ScriptSystem_Camera.h"
#include "ScriptSystem_Math.h"
#include "SceneGraph.h"
namespace BlueCore
{
static SQInteger _scenegraph_releasehook(SQUserPointer p, SQInteger size)
{
SceneGraph *scenegraph = (SceneGraph *)p;
if (scenegraph)
scenegraph->removeReference();
return 1;
}
static SQInteger _scenegraph_constructor(HSQUIRRELVM vm)
{
SQInteger argc = sq_gettop(vm);
if (argc < 1)
return 0;
SceneGraph *scenegraph = new SceneGraph();
scenegraph->addReference();
sq_setinstanceup(vm, 1, (void *)scenegraph );
sq_setreleasehook(vm, 1, _scenegraph_releasehook);
return 0;
}
static SQInteger _set_camera(HSQUIRRELVM v)
{
SceneGraph *scenegraph = 0;
sq_getinstanceup(v, 1, ( void ** ) &scenegraph, 0);
if (scenegraph)
{
Camera *camera;
sq_getinstanceup (v, 2, ( void ** ) &camera, 0);
scenegraph->setCamera(camera);
}
return 0;
}
void setupScriptSystem_SceneGraph(ScriptSystem* scriptsystem)
{
if (scriptsystem == 0)
return;
HSQUIRRELVM vm = scriptsystem->getVM();
sq_pushroottable(vm);
// push class
sq_pushstring(vm, "SceneGraph", -1);
if (SQ_SUCCEEDED(sq_newclass(vm, SQFalse) ) )
{
// register constructor
sq_pushstring(vm, "constructor", -1);
sq_newclosure(vm, _scenegraph_constructor, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, "setCamera", -1);
sq_newclosure(vm, _set_camera, 0);
sq_newslot(vm, -3, false);
// create class
sq_newslot(vm, -3, false);
}
sq_poptop(vm);
}
}

11
engine/ScriptSystem_SceneGraph.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef BLUECORE_SCRIPTING_CAMERA_H
#define BLUECORE_SCRIPTING_CAMERA_H
#include "ScriptSystem.h"
namespace BlueCore
{
void setupScriptSystem_SceneGraph(ScriptSystem* scriptsystem);
}
#endif

227
engine/Utilities/CfgParser.cpp
View File

@ -5,194 +5,191 @@
using namespace std; using namespace std;
namespace BlueCore { namespace BlueCore
void CfgParser::parseFile (const std::string& filename)
{ {
ifstream file (filename.c_str(), ios::in);
std::string line;
while (file.good()) void CfgParser::parseFile(const std::string& filename)
{ {
getline (file, line); ifstream file(filename.c_str(), ios::in);
parseLine (line); std::string line;
}
while (file.good())
{
getline(file, line);
parseLine(line);
}
} }
void CfgParser::parseLine(const std::string& line)
void CfgParser::parseLine (const std::string& line)
{ {
std::string::size_type i (line.find_first_of ('=')); std::string::size_type i(line.find_first_of('='));
if (i == std::string::npos) if (i == std::string::npos)
return; return;
std::string key = trim (string (line, 0, i-1)); std::string key = trim(string(line, 0, i-1));
std::string value = trim (string (line, i+1)); std::string value = trim(string(line, i+1));
_Pairs[key] = value; _Pairs[key] = value;
} }
void CfgParser::parse(const char* buffer, unsigned int length)
void CfgParser::parse (const char* buffer, unsigned int length)
{ {
const char* ptr = buffer; const char* ptr = buffer;
const char* end = buffer + length; const char* end = buffer + length;
unsigned int l = 0; unsigned int l = 0;
while (ptr < end) while (ptr < end)
{ {
// find end of line // find end of line
while (ptr[l] != '\n') while (ptr[l] != '\n')
{ {
l++; l++;
if (ptr + l >= end) if (ptr + l >= end)
break; break;
} }
parseLine (string(ptr, l)); parseLine(string(ptr, l));
ptr += l+1; ptr += l+1;
l = 0; l = 0;
} }
} }
double CfgParser::get(const std::string& key, double defaultValue)
double CfgParser::get (const std::string& key, double defaultValue)
{ {
double value; double value;
if (getDouble (key, value) == false) if (getDouble(key, value) == false)
return defaultValue; return defaultValue;
else else
return value; return value;
} }
bool CfgParser::getDouble(const std::string& key, double& value)
bool CfgParser::getDouble (const std::string& key, double& value)
{ {
std::map<std::string, std::string>::const_iterator result; std::map<std::string, std::string>::const_iterator result;
result = _Pairs.find (key); result = _Pairs.find(key);
if (result != _Pairs.end()) if (result != _Pairs.end())
{ {
value = atof (result->second.c_str()); value = atof(result->second.c_str());
return true; return true;
} }
else else
return false; return false;
} }
int CfgParser::get(const std::string& key, int defaultValue)
int CfgParser::get (const std::string& key, int defaultValue)
{ {
int value; int value;
if (getInteger (key, value) == false) if (getInteger(key, value) == false)
return defaultValue; return defaultValue;
else else
return value; return value;
} }
bool CfgParser::getInteger(const std::string& key, int& value)
bool CfgParser::getInteger (const std::string& key, int& value)
{ {
std::map<std::string, std::string>::const_iterator result; std::map<std::string, std::string>::const_iterator result;
result = _Pairs.find (key); result = _Pairs.find(key);
if (result != _Pairs.end()) if (result != _Pairs.end())
{ {
value = atoi (result->second.c_str()); value = atoi(result->second.c_str());
return true; return true;
} }
else else
return false; return false;
} }
bool CfgParser::get(const std::string& key, bool defaultValue)
bool CfgParser::get (const std::string& key, bool defaultValue)
{ {
bool value; bool value;
if (getBoolean (key, value) == false) if (getBoolean(key, value) == false)
return defaultValue; return defaultValue;
else else
return value; return value;
} }
bool CfgParser::getBoolean(const std::string& key, bool& value)
bool CfgParser::getBoolean (const std::string& key, bool& value)
{ {
std::map<std::string, std::string>::const_iterator result; std::map<std::string, std::string>::const_iterator result;
result = _Pairs.find (key); result = _Pairs.find(key);
if (result != _Pairs.end()) if (result != _Pairs.end())
{ {
value = false; value = false;
if (result->second == "true") if (result->second == "true")
value = true; value = true;
else if (result->second == "1") else if (result->second == "1")
value = true; value = true;
else if (result->second == "yes") else if (result->second == "yes")
value = true; value = true;
return true; return true;
} }
else else
return false; return false;
} }
std::string CfgParser::get(const std::string& key, std::string defaultValue)
std::string CfgParser::get (const std::string& key, std::string defaultValue)
{ {
std::string value; std::string value;
if (getString (key, value) == false) if (getString(key, value) == false)
return defaultValue; return defaultValue;
else else
return value; return value;
} }
bool CfgParser::getString(const std::string& key, std::string& value)
bool CfgParser::getString (const std::string& key, std::string& value)
{ {
std::map<std::string, std::string>::const_iterator result; std::map<std::string, std::string>::const_iterator result;
result = _Pairs.find (key); result = _Pairs.find(key);
if (result != _Pairs.end()) if (result != _Pairs.end())
{ {
value = result->second; value = result->second;
return true; return true;
} }
else else
return false; return false;
} }
bool CfgParser::getStrings(const std::string& key, std::vector<string>& strings)
bool CfgParser::getStrings (const std::string& key, std::vector<string>& strings)
{ {
std::map<std::string, std::string>::const_iterator result; std::map<std::string, std::string>::const_iterator result;
result = _Pairs.find (key); result = _Pairs.find(key);
if (result != _Pairs.end()) if (result != _Pairs.end())
{ {
explode (result->second, strings, true, ","); explode(result->second, strings, true, ",");
return true; return true;
} }
else else
return false; return false;
} }
bool CfgParser::getDoubles(const std::string& key, std::vector<double>& doubles)
{
std::map<std::string, std::string>::const_iterator result;
result = _Pairs.find(key);
if (result != _Pairs.end())
{
std::vector<std::string> strings;
explode(result->second, strings, true, ",");
std::vector<std::string>::iterator i;
for (i = strings.begin(); i != strings.end(); i++)
doubles.push_back(atof((*i).c_str()));
return true;
}
else
return false;
}
} // namespace BlueCore } // namespace BlueCore

2
engine/Utilities/CfgParser.h
View File

@ -28,6 +28,8 @@ public:
bool getStrings (const std::string& key, std::vector<std::string>& strings); bool getStrings (const std::string& key, std::vector<std::string>& strings);
bool getDoubles (const std::string& key, std::vector<double>& doubles);
private: private:
std::map<std::string, std::string> _Pairs; std::map<std::string, std::string> _Pairs;

44
engine/data/main.nut
View File

@ -71,16 +71,26 @@ lastFPS <- 0;
frameCount <- 0; frameCount <- 0;
FPS <- 1; FPS <- 1;
body <- null; body <- null;
camera <- null;
mainSceneGraph <- null;
function Initialize() function Initialize()
{ {
::font = Font();//Font ("DejaVuSans.ttf", 24, 1 ); ::font = Font();//Font ("DejaVuSans.ttf", 24, 1 );
::logo = Image ("image.png", 0.0, 0.0, 1.0, 1.0); ::logo = Image ("image.png", 0.0, 0.0, 1.0, 1.0);
::body = RigidBody(); ::body = RigidBody();
::camera = Camera();
::mainSceneGraph = SceneGraph();
::camera.lookAt (0.0, 0.0, 0.0);
::mainSceneGraph.setCamera (::camera);
} }
function OnFrame( delta ) function OnFrame (delta, total)
{
::camera.setPosition (::body.getPosition());
}
function OnOverlay (delta, total)
{ {
::frameCount += 1 ::frameCount += 1
::lastFPS += delta; ::lastFPS += delta;
@ -92,21 +102,31 @@ function OnFrame( delta )
::lastFPS -= 0.1; ::lastFPS -= 0.1;
} }
if (::FPS > 0) if (total < 2.0)
::logo.draw (0.5, 0.5);
else
{ {
local fps = "FPS: " + FPS + " / " + (1.0/::FPS)*1000.0 + " ms"; v <- ::body.getPosition();
::font.print( 10, 10, fps, 1, 1 ); ::font.print(10, 40, "Position: " + v.x + ", " + v.y + ", " + v.z, 1, 1 );
}
// ::logo.draw (0.5, 0.5);
v <- ::body.getPosition(); local seconds = floor(total % 60);
::font.print(10, 40, "Position: " + v.x + ", " + v.y + ", " + v.z, 1, 1 ); if (seconds < 10)
::font.print(10, 70, "Time: " + floor(total / 60.0) + ":0" + seconds, 1, 1 );
else
::font.print(10, 70, "Time: " + floor(total / 60.0) + ":" + seconds, 1, 1 );
if (::FPS > 0)
{
local fps = "FPS: " + FPS + " / " + (1.0/::FPS)*1000.0 + " ms";
::font.print( 10, 10, fps, 1, 1 );
}
}
} }
function OnStep( delte ) function OnStep (delta, total)
{ {
::body.applyLocalForce( Vector(0.0, 0.0, 1.0) ); ::body.applyLocalForce( Vector(1.0, 0.0, 1.0) );
} }
function Shutdown() function Shutdown()
{ {

207
engine/main.cpp
View File

@ -1,26 +1,5 @@
#include "GL/glew.h" #include "Application.h"
#include "RenderWindow.h"
#include "RenderDevice.h"
#include "FontManager.h"
#include "MeshManager.h"
#include "TextureManager.h"
#include "ShaderManager.h"
#include "ModelManager.h"
#include "TextureImage.h"
#include "ScriptSystem.h"
#include "ScriptSystem_Font.h"
#include "ScriptSystem_Image.h"
#include "ScriptSystem_Math.h"
#include "ScriptSystem_RigidBody.h"
#include "RigidBodySimulation.h"
#include "Camera.h"
#include "SceneNode.h"
#include "Utilities/CfgParser.h"
#include "Utilities/Log.h" #include "Utilities/Log.h"
#include "Utilities/Kernel.h"
#include "physfs.h" #include "physfs.h"
@ -65,193 +44,17 @@ void shutdownPhysfs()
PHYSFS_deinit(); PHYSFS_deinit();
} }
class Application : public sigslot::has_slots<>
{
bool _Running;
double _DeltaTime;
double _LastTime;
void KeySlot(int key, int action)
{
if (key == GLFW_KEY_ESC && action == GLFW_RELEASE)
quit();
}
ref_ptr<RenderWindow> _Window;
ref_ptr<RenderDevice> _Device;
ref_ptr<FontManager> _FontManager;
ref_ptr<MeshManager> _MeshManager;
ref_ptr<TextureManager> _TextureManager;
ref_ptr<ScriptSystem> _ScriptSystem;
ref_ptr<ShaderManager> _ShaderManager;
ref_ptr<RigidBodySimulation> _Simulation;
ref_ptr<ModelManager> _ModelManager;
ref_ptr<Camera> _Camera;
ref_ptr<RenderQueue> _RenderQueue;
public:
bool initialize()
{
CfgParser cfg;
cfg.parseFile("options.cfg");
int width = cfg.get("width", 640);
int height = cfg.get("height", 480);
bool fullscreen = cfg.get("fullscreen", false);
_Window = new RenderWindow();
if (_Window->create(width, height, 0, 0, 0, fullscreen) == false)
return false;
_Device = new RenderDevice(_Window);
_FontManager = new FontManager(_Device);
_MeshManager = new MeshManager(_Device);
_TextureManager = new TextureManager();
_ScriptSystem = new ScriptSystem();
_ShaderManager = new ShaderManager(_Window);
_Simulation = new RigidBodySimulation(_ScriptSystem);
_ModelManager = new ModelManager (_TextureManager, _ShaderManager, _MeshManager);
_Camera = new Camera();
_RenderQueue = new RenderQueue();
setupScriptSystem_Font(_ScriptSystem, _FontManager);
setupScriptSystem_Image(_ScriptSystem, _TextureManager, _Device);
setupScriptSystem_Math(_ScriptSystem);
setupScriptSystem_RigidBody(_ScriptSystem, _Simulation);
_ScriptSystem->loadScript("main");
_ScriptSystem->callFunction("Initialize");
_Window->KeySignal.connect(this, &Application::KeySlot);
_Running = true;
return true;
}
/*
if (window.valid() && device.valid())
{
camera->setFoV(45.0);
camera->setAspectRatio((double)width/(double)height);
camera->setNearPlane(1.0);
camera->setFarPlane(15000.0);
camera->setPosition(Vector3(0.0, 0.0, 20.0));
device->setAmbientLight(1.0, 1.0, 1.0);
//ref_ptr<SceneNode> rootnode(new SceneNode("root node"));
ref_ptr<Model> model = modelmanager->loadModel("combat");
}
*/
void shutdown()
{
_ScriptSystem->callFunction("Shutdown");
}
void quit()
{
_Running = false;
}
void run()
{
clog << "--- starting main loop..."<< endlog;
_DeltaTime = 0;
_LastTime = glfwGetTime();
while (_Window->isOpen() && _Running)
{
double time = glfwGetTime();
_DeltaTime = time - _LastTime;
_LastTime = time;
_Device->clear();
/*
camera->setRotation(Quaternion(Vector3(0.0, 1.0, 0.0), fmod(time
/5.0, 6.2)));
device->begin3D(camera);
queue->clear();
queue->addOpaqueItem(model, Vector3(10.0, 0.0, 0.0), Quaternion());
queue->render(device);
device->pushAbsoluteTransformation(Vector3(), camera->getRotation());
class RenderState
{
bool _Blending;
GLint _BlendFuncSrc;
GLint _BlendFuncDest;
bool _DepthTest;
bool _DepthMask;
bool _Lighting;
};
GLfloat mat_specular[] =
{ 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] =
{ 2.0 };
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_specular);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_specular);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_LIGHTING);
glColor4d( 1.0f, 1.0f, 1.0f, 1.0f);
device->setTexture(0, starTexture, true);
starMesh->render();
glDisable(GL_BLEND);
device->popTransformation();
*/
// device->useShader (program);
// device->setTexture (stage, name, texture)
// device->clearTextures (stage+1);
//glEnable (GL_TEXTURE_2D);
//glEnable (GL_LIGHTING);
//glBindTexture (GL_TEXTURE_2D, texture->getId() );
// device->
//device->
//model->render();
_Simulation->saveStates();
_Simulation->updateSteps(_DeltaTime);
while (_Simulation->step())
;
_ScriptSystem->callFunction("OnFrame", _DeltaTime);
_Device->swap();
}
clog << "--- main loop finished..."<< endlog;
}
};
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
initializePhysfs(argv[0]); initializePhysfs(argv[0]);
Application app; ref_ptr<Application> app = new Application();
if (app.initialize()) if (app->initialize())
{ {
app.run(); app->run();
} }
app.shutdown(); app->shutdown();
shutdownPhysfs(); shutdownPhysfs();
} }

8
engine/todo.txt
View File

@ -7,10 +7,16 @@ Scripting
--------- ---------
* make event based input available * make event based input available
* make font height available
SceneGraph
----------
* create scene graph
* make ShaderProgram a class * make ShaderProgram a class
* create RenderSet AND/OR RenderQueue * create RenderSet AND/OR RenderQueue
* RenderQueueVisitor
#if 0 #if 0
/* /*