Subversion Repository Public Repository

Divide-Framework

This repository has no backups
This repository's network speed is throttled to 100KB/sec

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
/*
   Copyright (c) 2013 DIVIDE-Studio
   Copyright (c) 2009 Ionut Cava

   This file is part of DIVIDE Framework.
   
   Permission is hereby granted, free of charge, to any person obtaining a copy of this software
   and associated documentation files (the "Software"), to deal in the Software without restriction,
   including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
   and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, 
   subject to the following conditions:

   The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
   INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
   OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

#ifndef _HARDWARE_VIDEO_GFX_DEVICE_H_
#define _HARDWARE_VIDEO_GFX_DEVICE_H_

#include "Hardware/Video/OpenGL/Headers/GLWrapper.h"
#include "Hardware/Video/Direct3D/Headers/DXWrapper.h"
#include "Managers/Headers/RenderPassManager.h" ///<For GFX_RENDER_BIN_SIZE
#include "Rendering/Headers/Renderer.h"

#ifdef FORCE_NV_OPTIMUS_HIGHPERFORMANCE
extern "C" {
	_declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
}
#endif

enum RenderStage;
enum SceneNodeType;

class Light;
class Camera;
class Object3D;
class Framerate;
class SceneRenderState;
///Rough around the edges Adapter pattern
DEFINE_SINGLETON_EXT1(GFXDevice,RenderAPIWrapper)
friend class Frustum; ///< For matrix recovery operations

public:

	void setApi(const RenderAPI& api);

	inline RenderAPI        getApi()        {return _api.getId(); }
	inline RenderAPIVersion getApiVersion() {return _api.getVersionId();}
	inline GPUVendor        getGPUVendor()  {return _api.getGPUVendor();}

	inline I8   initHardware(const vec2<U16>& resolution, I32 argc, char **argv){return _api.initHardware(resolution,argc,argv);}

	inline void registerKernel(Kernel* const kernel)     {_kernel = kernel;}
	inline void initDevice(U32 targetFrameRate)          {_api.initDevice(targetFrameRate);}
	inline void changeResolution(U16 w, U16 h)           {_api.changeResolution(w,h);}
	inline void setWindowPos(U16 w, U16 h)      const    {_api.setWindowPos(w,h);}

	inline void exitRenderLoop(const bool killCommand = false) {_api.exitRenderLoop(killCommand);}
	       void closeRenderingApi();

	inline void beginFrame() {_api.beginFrame();}
	inline void endFrame()   {_api.endFrame();  }
	inline void idle()       {_api.idle();}
	inline void flush()      {_api.flush();}
	
	inline Shader*             newShader(const std::string& name,
		                                 const  ShaderType& type, 
								         const bool optimise = false)                 {return _api.newShader(name,type,optimise); }
	inline FrameBufferObject*  newFBO(const FBOType& type = FBO_2D_COLOR)             {return _api.newFBO(type); }
	inline VertexBufferObject* newVBO(const PrimitiveType& type = TRIANGLES)          {return _api.newVBO(type); }
	inline PixelBufferObject*  newPBO(const PBOType& type = PBO_TEXTURE_2D)           {return _api.newPBO(type); }
	inline Texture2D*          newTexture2D(const bool flipped = false)               {return _api.newTexture2D(flipped);}
	inline TextureCubemap*     newTextureCubemap(const bool flipped = false)          {return _api.newTextureCubemap(flipped);}
	inline ShaderProgram*      newShaderProgram(const bool optimise = false)          {return _api.newShaderProgram(optimise); }

    ///Hardware specific shader preps (e.g.: OpenGL: init/deinit GLSL-OPT and GLSW)
    inline bool            initShaders()                                        {return _api.initShaders();}
    inline bool            deInitShaders()                                      {return _api.deInitShaders();}

	void enableFog(FogMode mode, F32 density, const vec3<F32>& color, F32 startDist, F32 endDist);

	inline void toggle2D(bool _2D)  {_api.toggle2D(_2D);}
	inline void lookAt(const mat4<F32>& viewMatrix, const vec3<F32>& viewDirection)	{ _api.lookAt(viewMatrix, viewDirection); }
	inline void lookAt(const vec3<F32>& eye, const vec3<F32>& target, const vec3<F32>& up = WORLD_Y_AXIS) {_api.lookAt(eye,target,up);}
    ///Usually, after locking and releasing our matrices we want to revert to the View matrix to render geometry
    inline void lockMatrices(const MATRIX_MODE& setCurrentMatrix = VIEW_MATRIX, bool lockView = true, bool lockProjection = true)          {_api.lockMatrices(setCurrentMatrix,lockView,lockProjection);}
    inline void releaseMatrices(const MATRIX_MODE& setCurrentMatrix = VIEW_MATRIX, bool releaseView = true, bool releaseProjection = true) {_api.releaseMatrices(setCurrentMatrix,releaseView,releaseProjection);}
	///sets an ortho projection, updating any listeners if needed
    inline void setOrthoProjection(const vec4<F32>& rect, const vec2<F32>& planes){_api.setOrthoProjection(rect,planes);}
    ///sets a perspective projection, updating any listeners if needed
	inline void setPerspectiveProjection(F32 FoV,F32 aspectRatio, const vec2<F32>& planes) { _api.setPerspectiveProjection(FoV,aspectRatio,planes);}
	///sets the view frustum to either the left or right eye position for anaglyph rendering
	inline void setAnaglyphFrustum(F32 camIOD, bool rightFrustum = false)  {_api.setAnaglyphFrustum(camIOD,rightFrustum);}
			///sets a new horizontal FoV
			void setHorizontalFoV(I32 newFoV);
	inline void renderInViewport(const vec4<U32>& rect, boost::function0<void> callback)  {_api.renderInViewport(rect,callback);}
	//returns an immediate mode emulation buffer that can be used to construct geometry in a vertex by vertex manner. 
	//allowPrimitiveRecycle = do not reause old primitives and do not delete it after x-frames. (Don't use the primitive zombie feature)
    inline IMPrimitive* createPrimitive(bool allowPrimitiveRecycle = true) { return _api.createPrimitive(allowPrimitiveRecycle); }

	inline void drawDebugAxis(const bool state)       {_drawDebugAxis = state;}
    inline bool drawDebugAxis()                 const {return _drawDebugAxis;}
	inline void debugDraw()                           {_api.debugDraw();}

	inline void drawBox3D(const vec3<F32>& min,const vec3<F32>& max, const mat4<F32>& globalOffset) {_api.drawBox3D(min,max,globalOffset);}
	inline void drawLines(const vectorImpl<vec3<F32> >& pointsA,
				          const vectorImpl<vec3<F32> >& pointsB,
				          const vectorImpl<vec4<U8> >& colors, 
				          const mat4<F32>& globalOffset,
				          const bool orthoMode = false,
				          const bool disableDepth = false) {_api.drawLines(pointsA,pointsB,colors,globalOffset,orthoMode,disableDepth);}
    ///Usefull to perform pre-draw operations on the model if it's drawn outside the scenegraph
	void renderInstance(RenderInstance* const instance);
	void renderBuffer(VertexBufferObject* const vbo, Transform* const vboTransform = NULL);
	void renderGUIElement(GUIElement* const guiElement,ShaderProgram* const guiShader);
	///The render callback must update all visual information and populate the "RenderBin"'s!
	///Use the sceneGraph::update callback as default using the macro SCENE_GRAPH_UPDATE(pointer)
	///pointer = a pointer to the sceneGraph instance used for rendering
	void render(boost::function0<void> renderFunction, const SceneRenderState& sceneRenderState);
	///Update light properties internally in the Rendering API
	inline void setLight(Light* const light)           {_api.setLight(light);}
	///Sets the current render stage.
	///@param stage Is used to inform the rendering pipeline what we are rendering. Shadows? reflections? etc
	inline void  setRenderStage(RenderStage stage) {_prevRenderStage = _renderStage; _renderStage = stage;}
	///Restores the render stage to the previous one calling it multiple times will ping-pong between stages
	inline void  setPreviousRenderStage()          {setRenderStage(_prevRenderStage);}
    ///Checks if the current rendering stage is any of the stages defined in renderStageMask
	///@param renderStageMask Is a bitmask of the stages we whish to check if active
		   bool         isCurrentRenderStage(U16 renderStageMask);
 	inline RenderStage  getRenderStage()                 {return _renderStage;}
	inline void         setPrevShaderId(const U32& id)   {_prevShaderId = id;}
	inline U32          getPrevShaderId()                {return _prevShaderId;}
	inline void         setPrevTextureId(const U32& id)  {_prevTextureId = id;}
	inline U32          getPrevTextureId()               {return _prevTextureId;}
	inline Renderer*    getRenderer()                    {assert(_renderer != NULL); return _renderer;}
	       void         setRenderer(Renderer* const renderer);
		   void         closeRenderer();

	/*
	/* Clipping plane management. All the clipping planes are handled by shader programs only!
	*/
	///enable-disable HW clipping
	inline void updateClipPlanes() {_api.updateClipPlanes(); }
	/// add a new clipping plane. This will be limited by the actual shaders (how many planes they use)
	/// this function returns the newly added clip plane's index in the vector
	inline I32 addClipPlane(const Plane<F32>& p);
	/// add a new clipping plane defined by it's equation's coefficients
	inline I32 addClipPlane(F32 A, F32 B, F32 C, F32 D);
	/// remove a clip plane by index
	inline bool removeClipPlane(U32 index);
	/// disable a clip plane by index
	inline bool disableClipPlane(U32 index);
	/// enable a clip plane by index
	inline bool enableClipPlane(U32 index);
	/// modify a single clip plane by index
	inline void setClipPlane(U32 index, const Plane<F32>& p);
	/// set a new list of clipping planes. The old one is discarded
	inline void setClipPlanes(const PlaneList& clipPlanes);
	/// clear all clipping planes
	inline void resetClipPlanes();
	/// have the clipping planes changed?
	inline bool clippingPlanesDirty()           const {return _clippingPlanesDirty;}
	/// get the entire list of clipping planes
	inline const PlaneList& getClippingPlanes() const {return _clippingPlanes;}
	///Save a screenshot in TGA format
	inline void Screenshot(char *filename, const vec4<F32>& rect){_api.Screenshot(filename,rect);}
	/// Some Scene Node Types are excluded from certain operations (lights triggers, etc)
	bool excludeFromStateChange(const SceneNodeType& currentType);
	///Creates a new API dependend stateblock based on the received description
	///Calls newRenderStateBlock and also saves the new block in the state block map
	RenderStateBlock* createStateBlock(const RenderStateBlockDescriptor& descriptor);
	///Sets the current state block to the one passed as a param
	///It is not set immediately, but a call to "updateStates" is required
    RenderStateBlock* setStateBlock(RenderStateBlock* block, bool forceUpdate = false);
	///Same as setStateBlock(RenderStateBlock* block), but uses a blank description
    RenderStateBlock* setStateBlockByDesc(const RenderStateBlockDescriptor &desc);
	///Set previous state block - (deep, I know -Ionut)
    inline RenderStateBlock* setPreviousStateBlock(bool forceUpdate = false) {assert(_previousStateBlock != NULL);return setStateBlock(_previousStateBlock,forceUpdate);}
	///Sets a standard state block
	inline RenderStateBlock* setDefaultStateBlock(bool forceUpdate = false) {assert(_defaultStateBlock != NULL);return setStateBlock(_defaultStateBlock,forceUpdate);}
	///Update the graphics pipeline using the current rendering API with the state block passed
	inline void updateStateInternal(RenderStateBlock* block, bool force = false) {_api.updateStateInternal(block,force);}
	///If a new state has been set, update the Graphics pipeline
		   void updateStates(bool force = false);
	/*//Render State Management */

	///Generate a cubemap from the given position
	///It renders the entire scene graph (with culling) as default
	///use the callback param to override the draw function
	void  generateCubeMap(FrameBufferObject& cubeMap,
						  const vec3<F32>& pos,
						  boost::function0<void> callback = 0,
						  const RenderStage& renderStage = ENVIRONMENT_MAPPING_STAGE);

	inline bool loadInContext(const CurrentContext& context, boost::function0<void> callback) {return _api.loadInContext(context, callback);}
	inline void getMatrix(const MATRIX_MODE& mode, mat4<F32>& mat)       {_api.getMatrix(mode, mat);}
    inline void getMatrix(const EXTENDED_MATRIX& mode, mat4<F32>& mat)   {_api.getMatrix(mode, mat);}
    inline void getMatrix(const EXTENDED_MATRIX& mode, mat3<F32>& mat)   {_api.getMatrix(mode, mat);}

#if defined(OS_WINDOWS)
	HWND getHWND() {return _api.getHWND();}
#elif defined(OS_APPLE)
	??
#else //Linux
	Display* getDisplay() {return _api.getDisplay();}
	GLXDrawable getDrawSurface() {return _api.getDrawSurface();}
#endif

protected:
	friend class Kernel;
	friend class Application;
	inline void setMousePosition(D32 x, D32 y) const {_api.setMousePosition(x,y);}

private:

	GFXDevice();

	///Returns an API dependend stateblock based on the description
	inline RenderStateBlock* newRenderStateBlock(const RenderStateBlockDescriptor& descriptor) { return _api.newRenderStateBlock(descriptor); }

    inline void drawText(const std::string& text, const I32 width, const std::string& fontName, const F32 fontSize) {_api.drawText(text,width,fontName,fontSize);}
	inline void drawText(const std::string& text, const I32 width, const vec2<I32> position, const std::string& fontName, const F32 fontSize) {_api.drawText(text,width,position,fontName,fontSize);}

private:
	RenderAPIWrapper& _api;
	bool _deviceStateDirty;
	RenderStage _renderStage, _prevRenderStage;
    U32  _prevShaderId,  _prevTextureId;
    bool _drawDebugAxis;

protected:
	friend class GL_API;
	friend class DX_API;
	Renderer* _renderer;
	/*State management */
	typedef Unordered_map<I64, RenderStateBlock* > RenderStateMap;
	RenderStateMap _stateBlockMap;
    bool _stateBlockDirty;
	bool _stateBlockByDescription;
	RenderStateBlock* _currentStateBlock;
    RenderStateBlock* _newStateBlock;
	RenderStateBlock* _previousStateBlock;
	RenderStateBlock* _defaultStateBlock;
	///Pointer to current kernel
	Kernel* _kernel;
	PlaneList _clippingPlanes;
	bool      _clippingPlanesDirty;

END_SINGLETON

#include "GFXDevice-Inl.h"

#endif

Commits for Divide-Framework/trunk/Source Code/Hardware/Video/Headers/GFXDevice.h

Diff revisions: vs.
Revision Author Commited Message
168 Diff Diff k1ngp1n picture k1ngp1n Sat 26 Oct, 2013 19:03:21 +0000

- Reworked the Camera class[[BR]]
— Now fully quaternion based [[BR]]
— Basic camera types added but not used yet (third person, first person, orbit) [[BR]]
- Cleaned up Material and Texture handling [[BR]]
- Added clipping plane support [[BR]]
— Similar to OpenGL fixed-function clip planes but fully shader driven [[BR]]
— Added a new class, “Plane”, that helps define clip planes [[BR]]
- Optimized the Singleton class to allow faster “getInstance” calls without performance penalties [[BR]]
-- “createInstance” must be called for each singleton class before usage. Or “gerOrCreateInstance” can be used, which is basically the former “getInstance” implementation [[BR]]
- Improved console logging by changing some heap allocations to stack and removing dependencies on the std::string class [[BR]]
- Added a lot of performance optimizations related to coding standards and redundant calculations [[BR]]
— e.g. Frustum AABB check didn’t need to recompute the AABB points as they were calculated already [[BR]]
— e.g. A vector did not need to be set to 0 on initialization as that is already it’s default state on creation [[BR]]
— e.g. Faster Framerate and Timing calculations by using less member variables that are not needed outsied of calling functions [[BR]]
- The SceneState now contains the SceneRenderState and is passed on to the SceneGraph’s update calls [[BR]]
- Better material export/import to/from XML format [[BR]]
- More bug fixes and cleanups [[BR]]

163 Diff Diff k1ngp1n picture k1ngp1n Thu 18 Jul, 2013 12:24:26 +0000

[Ionut] [[BR]]
- Fixed a rendering bug with the previous terrain rendering system (number of strips was not calculated correctly. had to add the primitive restart indices to the list as well) [[BR]]
- Fixed a rendering bug with the previous double sided Quad3D patch (water planes should not be double sided. The first parameter of the bool mask of the resource descriptor for water planes now controls whether the Quad will be single or double sided) [[BR]]
- NavMesh debug draw now uses a caching system for rendering instead of re-submitting the same geometry every frame [[BR]]
— Fixed a bug that prevented GLIM primitives to be cached if they had “canZombify” set to false [[BR]]
- Navigation meshes are now saved and loaded from file on creation. Delete the “nm” file from the navMeshes subfolder to recreate a navigation mesh for a scene. [[BR]]
- LightManager is now a FrameListener. ShadowMap generation is called with the “FramePreRenderEnd” event [[BR]]
- Terrain NavMesh uses the lowest LoD possible for now to improve creation times until all bugs are resolved [[BR]]
- Geometry importer now uses the “replace” operation for the base texture of objects [[BR]]
- glUniformBufferObjects are now a little less dependent on the GLM library [[BR]]
- Primitive restart is now toggled on or off at each VAO draw call [[BR]]
- Some GFXDevice inlining [[BR]]

160 Diff Diff k1ngp1n picture k1ngp1n Wed 10 Jul, 2013 17:07:04 +0000

[Ionut] [[BR]]
- Changed licensing from LGPL to the MIT license [[BR]]
— Code can now be used in non-commercial or commercial closed or open source projects [[BR]]

156 Diff Diff k1ngp1n picture k1ngp1n Thu 04 Jul, 2013 21:50:54 +0000

[Ionut] [[BR]]
- More work on Navigation Mesh creation [[BR]]
- IMEmulation primitives were not recycled properly (old, unused primitives were saved, new ones were deleted and recreated – behavior reversed ) [[BR]]

154 Diff Diff k1ngp1n picture k1ngp1n Sun 23 Jun, 2013 23:39:07 +0000

[Ionut] [[BR]]
- Changed math computation for: Matrix multiplication, Normal and Tangent calculation, Quaternion to Matrix conversion and more [[BR]]
- Removed useless UBO classes and extended the functionality of the base UBO class [[BR]]
- Changed lighting shaders to be more streamlined [[BR]]
- Added full shader based fog [[BR]]
— Added per-scene optional fog settings [[BR]]
- Re-enabled sorting by shader program for Mesh Delegate Bin (was set to Front to Back for debugging purposes and forgotten there) [[BR]]

153 Diff Diff k1ngp1n picture k1ngp1n Fri 21 Jun, 2013 14:06:55 +0000

[Ionut] [[BR]]
- Small fix to resolution changing system [[BR]]

152 Diff Diff k1ngp1n picture k1ngp1n Thu 20 Jun, 2013 14:23:31 +0000

[Ionut] [[BR]]
- New rendering pipeline (experimental and unstable): [[BR]]
— OpenGL 3.x clean context (glLight commands are still used for now, but UBO support is there, but not used yet) [[BR]]
— Custom matrix stacks and UBO based shader data (UBOs cause some link errors on some nVidia cards)[[BR]]
— Multi-threaded texture loading and shader compilation (mt shader compilation disabled for now. needs more tests) [[BR]]
— VAO rendering is self contained (no more enable/disable calls before a draw request) [[BR]]
— Render instance class used for rendering information [[BR]]
[[BR]]
- New unique ID generation base class: GUIDWrapper. Each class that derives from this, gets an application wide unique id on construction [[BR]]
- Added base code for an in-game editor using CEGUI [[BR]]
- Replaced some mutex locks with lockless data structures or atomic data [[BR]]
- CEGUI 0.8.2, FTGL-GL3 and GLIM 0.4 modified to support GLEW_MX if defined [[BR]]
- Dropped VS2008 support [[BR]]
- Networking library, server framework and ReCast files are now projects inside the Divide Framework solution [[BR]]
- New console command “setFov” that modifies the horizontal FoV value in realtime [[BR]]
- New console command “recompileShader” that reparses shader files, recompiles shaders and relinks shader programs who’s names match or contain the argument string [[BR]]
- New debug utility: axis angle drawn in corner of the screen if needed [[BR]]
- More ‘const’-s pasted around the code, more loop performance tweaks (allocations before a loop, tighter loops, etc), more utility member functions added to various classes [[BR]]

151 Diff Diff k1ngp1n picture k1ngp1n Tue 07 May, 2013 00:00:52 +0000

[Ionut] [[BR]]
- Better ReCast integration [[BR]]
— Any entity can be used as an obstacle in the NavMesh if that’s specified in each scene’s assets.xml file for said entity [[BR]]
— New console command, “createNavMesh”, that passes geometry data to ReCast [[BR]]
-— NavMesh generation is not yet complete [[BR]]
- Better PhysX integration [[BR]]
— Each scene passes data to and gets data from the Physics API better and safer[[BR]]
- Multi-threaded support extended: [[BR]]
— Event class replaced with Task [[BR]]
— Kernel uses a threadpool for scene tasks [[BR]]
— Each task can be added to a different threadpool if needed [[BR]]
— Most critical sections use the new boost::atomic wrapper for thread safety [[BR]]
- Rendering system updated [[BR]]
— VBO’s keep track of the geometry type internally [[BR]]
— Rendering by specific element list is internal to the VBO [[BR]]
— VBO’s can draw a “lite” version that doesn’t send Tangent, BiTangent and TexCoord data for depth rendering (disabled) [[BR]]
- Reflectors now offer a preview of the generated reflective texture if needed [[BR]]
- Buttons are now added and rendered by CEGUI [[BR]]
[[BR]]
Deprecation: [[BR]]
- Removed fixed pipeline material system [[BR]]
- Removed BoundingBox late update system [[BR]]
- Shadow references in the material system are now depth references [[BR]]
[[BR]]
Bug fixes: [[BR]]
- Problematic FBO double bind check removed [[BR]]
- Faster terrain rendering via chunk size selection through each scene’s terrain.xml[[BR]]
- Rendering is paused when the window is minimized [[BR]]
- CEGUI and impostors now render properly in deferred rendering mode [[BR]]
- Fixed various level 4 (VS2008) warnings [[BR]]
- Better state management and cleaning [[BR]]
- Better SceneGraph node management and trasformation/AABB update calls [[BR]]
- AITenisScene has proper collisions now [[BR]]

146 Diff Diff k1ngp1n picture k1ngp1n Wed 10 Apr, 2013 13:20:15 +0000

[Ionut] [[BR]]
*Final LightBranch updates 2/3 : Main trunk merge and build test (VC90, VC100, gDebugger) [[BR]]
-Merged light branch with trunk [[BR]]
-Deleted light branch [[BR]]

141 k1ngp1n picture k1ngp1n Wed 30 Jan, 2013 19:35:31 +0000

[Ionut] [[BR]]
-Updated to boost 1.52 and CEGUI 0.7.9 [[BR]]
-Updated to PhysX 3.2 [[BR]]
-Updated copyright notices [[BR]]