Merge pull request #435 from wivlaro/camera-frustum-and-projection-cleanup

Added frustum support from Camera. Cleaned up projection code a bit.

Core/Contents/Include/PolyCamera.h

@@ -39,6 +39,24 @@ namespace Polycode {
 	class _PolyExport Camera : public Entity {
 		public:
 			
+			/** ProjectionMode: Orthographic projection, with manually set size. */
+			static const int ORTHO_SIZE_MANUAL = 0;
+
+			/** ProjectionMode: Orthographic projection, with height specified used and width scaled proportionally . */
+			static const int ORTHO_SIZE_LOCK_HEIGHT = 1;
+
+			/** ProjectionMode: Orthographic projection, with width specified used and height scaled proportionally. */
+			static const int ORTHO_SIZE_LOCK_WIDTH = 2;
+
+			/** ProjectionMode: Orthographic projection, scaled to viewport backing resolution. */
+			static const int ORTHO_SIZE_VIEWPORT = 3;
+
+			/** ProjectionMode: Perspective projection, with field of view specified. */
+			static const int PERSPECTIVE_FOV = 4;
+
+			/** ProjectionMode: Perspective projection, with bounds set by edges of frustum. */
+			static const int PERSPECTIVE_FRUSTUM = 5;
+
 			/**
 			* Constructor.
 			* @param parentScene Scene to add the camera to.
@@ -75,11 +93,19 @@ namespace Polycode {
 
 			void setOrthoSize(Number orthoSizeX, Number orthoSizeY);
 			
+			/** Switches into frustum mode and sets up the planes. */
+			void setFrustumMode(Number left, Number right, Number bottom, Number top, Number front, Number back);
+
 			/**
 			* Returns true if camera is in orthographic projection mode.
 			* @return True if camera is orthographic, false if otherwise.
 			*/
-			bool getOrthoMode();
+			bool getOrthoMode() {
+				return projectionMode == ORTHO_SIZE_MANUAL ||
+						projectionMode == ORTHO_SIZE_LOCK_HEIGHT ||
+						projectionMode == ORTHO_SIZE_LOCK_WIDTH ||
+						projectionMode == ORTHO_SIZE_VIEWPORT;
+			}
 			
 			/**
 			* Returns the width of the camera's orthographic frustum.
@@ -103,13 +129,15 @@ namespace Polycode {
 			* Returns the current FOV value for the camera.
 			* @return Current FOV value for the camera.
 			*/			
-			Number getFOV();
+			Number getFOV() {
+				return fov;
+			}
 			
 			void setClippingPlanes(Number nearClipPlane, Number farClipPlane);
         
         
-            Number getNearClipppingPlane();
-            Number getFarClipppingPlane();
+			Number getNearClippingPlane();
+			Number getFarClippingPlane();
         
 			void setParentScene(Scene *parentScene);
             Scene *getParentScene() const;
@@ -124,13 +152,17 @@ namespace Polycode {
 			* Sets the exposure for the camera. The exposure value can be passed to a shader for HDR rendering.
 			* @param level The new exposure value.
 			*/						
-			void setExposureLevel(Number level);
+			void setExposureLevel(Number level) {
+				exposureLevel = level;
+			}
 			
 			/**
 			* Returns the camera's exposure value.
 			* @return Current exposure value.
 			*/									
-			Number getExposureLevel();
+			Number getExposureLevel() {
+				return exposureLevel;
+			}
 
 			/**
 			* Sets the post-processing shader for the camera.
@@ -179,30 +211,35 @@ namespace Polycode {
             */
 			Vector2 cameraShift;
 		      
-            void setOrthoSizeMode(int orthoSizeMode);
-            int getOrthoSizeMode() const;
-        
-            static const int ORTHO_SIZE_MANUAL = 0;
-			static const int ORTHO_SIZE_LOCK_HEIGHT = 1;
-			static const int ORTHO_SIZE_LOCK_WIDTH = 2;
-			static const int ORTHO_SIZE_VIEWPORT = 3;
-		
+			/** @deprecated use setProjectionMode(ProjectionMode mode) */
+			void setOrthoSizeMode(int orthoSizeMode) { setProjectionMode(orthoSizeMode); }
+			/** @deprecated use getProjectionMode() */
+			int getOrthoSizeMode() const { return projectionMode; }
+
+			void setProjectionMode(int mode);
+			int getProjectionMode() const { return projectionMode; }
+
+
 		protected:
-        
-            int orthoSizeMode;
-		
+
+			int projectionMode;
+
 			Matrix4 projectionMatrix;
+
 			Polycode::Rectangle viewport;
 			Number orthoSizeX;
 			Number orthoSizeY;
-			
+
 			Number nearClipPlane;
 			Number farClipPlane;
 								
 			Number exposureLevel;
-			bool orthoMode;
 			Number fov;
+
+			Number leftFrustum,rightFrustum,topFrustum,bottomFrustum;
+
 			Number frustumPlanes[6][4];
+
 			Scene *parentScene;
 
 			Material *filterShaderMaterial;			

Core/Contents/Include/PolyGLRenderer.h

@@ -131,8 +131,8 @@ namespace Polycode {
 		void setRenderArrayData(RenderDataArray *array, Number *arrayData);
 		void drawArrays(int drawType);		
 				
-		void setOrthoMode(Number xSize=0.0f, Number ySize=0.0f, bool centered = false);
-		void setPerspectiveMode();
+		void setProjectionOrtho(Number xSize=0.0f, Number ySize=0.0f, Number near=-256.0f, Number far=256.0f, bool centered = false);
+		void setPerspectiveDefaults();
 		
 		void enableBackfaceCulling(bool val);
 		
@@ -184,8 +184,9 @@ namespace Polycode {
 		void enableDepthTest(bool val);
 		void enableDepthWrite(bool val);
 				
-		void setClippingPlanes(Number nearPlane_, Number farPlane_);
-				
+		void setProjectionFromFrustum(Number left, Number right, Number bottom, Number top, Number near, Number far);
+		void setProjectionFromFoV(Number fov, Number near, Number far);
+
 		void clearBuffer(bool colorBuffer, bool depthBuffer);	
 		void drawToColorBuffer(bool val);
 		
@@ -203,9 +204,6 @@ namespace Polycode {
 	protected:
 		void initOSSpecific();
 		
-		Number nearPlane;
-		Number farPlane;
-		
 		int verticesToDraw;
 		
 		GLdouble sceneProjectionMatrix[16];

Core/Contents/Include/PolyRenderer.h

@@ -111,16 +111,14 @@ namespace Polycode {
 		virtual Image *renderScreenToImage() = 0;
 		virtual Image *renderBufferToImage(Texture *texture) = 0;
 		
-		void setFOV(Number fov);		
 		void setViewportSize(int w, int h);
-		void setViewportSizeAndFOV(int w, int h, Number fov);
 		virtual void resetViewport() = 0;
 		
 		virtual Polycode::Rectangle getViewport() = 0;
 				
 		virtual void loadIdentity() = 0;		
-		virtual void setOrthoMode(Number xSize=0.0f, Number ySize=0.0f, bool centered = false) = 0;
-		virtual void setPerspectiveMode() = 0;
+		virtual void setProjectionOrtho(Number xSize=0.0f, Number ySize=0.0f, Number near=-256.0f, Number far=256.0f, bool centered = false) = 0;
+		virtual void setPerspectiveDefaults() = 0;
 		
 		virtual void setTexture(Texture *texture) = 0;		
 		virtual void enableBackfaceCulling(bool val) = 0;
@@ -188,21 +186,20 @@ namespace Polycode {
 		void billboardMatrixWithScale(Vector3 scale);
 		
 		void setTextureFilteringMode(int mode);
-		
+
 		/**
-		 * Set the near and far clipping planes for the visible frustum.
+		 * Set the frustum clipping planes.
 		 *
 		 * Please check the supplied external links for more information
 		 * about the problems of a high farPlane/nearPlane setting.
 		 *
-		 * @param nearPlane The new near clipping plane.
-		 * @param farPlane The new far clipping plane.
-		 *
-		 * @see http://en.wikipedia.org/wiki/Viewing_frustum
 		 * @see http://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml
 		 */
-		virtual void setClippingPlanes(Number nearPlane, Number farPlane) = 0;
-		
+		virtual void setProjectionFromFrustum(Number left, Number right, Number bottom, Number top, Number front, Number back) = 0;
+
+
+		virtual void setProjectionFromFoV(Number fov, Number near, Number far) = 0;
+
 		/**
 		 * Enable/disable alpha tests.
 		 *
@@ -356,13 +353,8 @@ namespace Polycode {
 		
 		bool shadersEnabled;
 		Number fov;
-		
-		Number orthoSizeX;
-		Number orthoSizeY;
 				
 		bool lightingEnabled;
-		
-		bool orthoMode;
 	
 		int xRes;
 		int yRes;

Core/Contents/Source/PolyCamera.cpp

@@ -34,10 +34,10 @@
 using namespace Polycode;
 			
 Camera::Camera(Scene *parentScene) : Entity() {
+	projectionMode = PERSPECTIVE_FOV;
 	renderer = CoreServices::getInstance()->getRenderer();
 	setParentScene(parentScene);
-	orthoMode = false;
-	fov = 45.0f;
+	setFOV(45.0f);
 	filterShaderMaterial = NULL;
 	originalSceneTexture = NULL;
 	zBufferSceneTexture = NULL;
@@ -48,8 +48,7 @@ Camera::Camera(Scene *parentScene) : Entity() {
 	farClipPlane = 1000.0;
 	topLeftOrtho = false;
     orthoSizeX = 1.0;
-    orthoSizeY = 1.0;
-    orthoSizeMode = Camera::ORTHO_SIZE_LOCK_HEIGHT;
+	orthoSizeY = 1.0;
 }
 
 Camera::~Camera() {	
@@ -66,25 +65,11 @@ void Camera::setClippingPlanes(Number nearClipPlane, Number farClipPlane) {
 	this->farClipPlane = farClipPlane;	
 }
 
-
-void Camera::setExposureLevel(Number level) {
-	exposureLevel = level;
-}
-
-Number Camera::getExposureLevel() {
-	return exposureLevel;
-}
-
-
 void Camera::setFOV(Number fov) {
+	setProjectionMode(PERSPECTIVE_FOV);
 	this->fov = fov;
 }
 
-Number Camera::getFOV() {
-	return fov;
-}
-
-
 bool Camera::isSphereInFrustum(Vector3 pos, Number fRadius) {
 	if(!frustumCulling)
 		return true;
@@ -106,11 +91,23 @@ void Camera::setOrthoSize(Number orthoSizeX, Number orthoSizeY) {
 }
 
 void Camera::setOrthoMode(bool mode) {
-	orthoMode = mode;
+	if (mode && !getOrthoMode()) {
+		setProjectionMode(ORTHO_SIZE_LOCK_HEIGHT);
+	}
+	else if (!mode && getOrthoMode()) {
+		setProjectionMode(PERSPECTIVE_FOV);
+	}
 }			
 
-bool Camera::getOrthoMode() {
-	return orthoMode;
+
+void Camera::setFrustumMode(Number left, Number right, Number bottom, Number top, Number front, Number back) {
+	setProjectionMode(PERSPECTIVE_FRUSTUM);
+	leftFrustum = left;
+	rightFrustum = right;
+	bottomFrustum = bottom;
+	topFrustum = top;
+	nearClipPlane = front;
+	farClipPlane = back;
 }
 
 Number Camera::getOrthoSizeX() {
@@ -278,11 +275,12 @@ void Camera::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) co
     Entity::applyClone(clone, deepClone, ignoreEditorOnly);
     
     Camera *cloneCamera = (Camera*) clone;
-    cloneCamera->setFOV(fov);
-    cloneCamera->setOrthoMode(orthoMode);
-    cloneCamera->setOrthoSizeMode(orthoSizeMode);
-    cloneCamera->setOrthoSize(orthoSizeX, orthoSizeY);
-    cloneCamera->setClippingPlanes(nearClipPlane, farClipPlane);
+	cloneCamera->projectionMatrix = Matrix4(projectionMatrix.ml);
+	cloneCamera->fov = fov;
+	cloneCamera->viewport = viewport;
+	cloneCamera->setOrthoSize(orthoSizeX, orthoSizeY);
+	cloneCamera->projectionMode = projectionMode;
+	cloneCamera->setClippingPlanes(nearClipPlane, farClipPlane);
     cloneCamera->setExposureLevel(exposureLevel);
 }
 
@@ -421,46 +419,44 @@ Polycode::Rectangle Camera::getViewport() {
 	return viewport;
 }
 
-Number Camera::getNearClipppingPlane() {
+Number Camera::getNearClippingPlane() {
     return nearClipPlane;
 }
 
-Number Camera::getFarClipppingPlane() {
+Number Camera::getFarClippingPlane() {
     return farClipPlane;
 }
 
-void Camera::setOrthoSizeMode(int orthoSizeMode) {
-    this->orthoSizeMode = orthoSizeMode;
-}
-
-int Camera::getOrthoSizeMode() const {
-    return orthoSizeMode;
+void Camera::setProjectionMode(int mode) {
+	projectionMode = mode;
 }
 
 void Camera::doCameraTransform() {
-	renderer->setClippingPlanes(nearClipPlane, farClipPlane);
 	
     viewport = renderer->getViewport();
-    
-	if(!orthoMode) {
-		renderer->setViewportShift(cameraShift.x, cameraShift.y);
-		renderer->setFOV(fov);
-		renderer->setPerspectiveMode();		
-	} else {
-        switch(orthoSizeMode) {
-            case ORTHO_SIZE_MANUAL:
-                renderer->setOrthoMode(orthoSizeX, orthoSizeY, !topLeftOrtho);
-            break;
-            case ORTHO_SIZE_LOCK_HEIGHT:
-                renderer->setOrthoMode(orthoSizeY * (viewport.w/viewport.h), orthoSizeY, !topLeftOrtho);
-            break;
-            case ORTHO_SIZE_LOCK_WIDTH:
-                renderer->setOrthoMode(orthoSizeX, orthoSizeX * (viewport.h/viewport.w), !topLeftOrtho);
-            break;
-            case ORTHO_SIZE_VIEWPORT:
-                renderer->setOrthoMode(viewport.w / renderer->getBackingResolutionScaleX(), viewport.h / renderer->getBackingResolutionScaleY(), !topLeftOrtho);
-            break;
-        }
+
+	switch (projectionMode) {
+		case PERSPECTIVE_FOV:
+			renderer->setViewportShift(cameraShift.x, cameraShift.y);
+			renderer->setProjectionFromFoV(fov, nearClipPlane, farClipPlane);
+			renderer->setPerspectiveDefaults();
+		break;
+		case PERSPECTIVE_FRUSTUM:
+			renderer->setProjectionFromFrustum(leftFrustum, rightFrustum, bottomFrustum, topFrustum, nearClipPlane, farClipPlane);
+			renderer->setPerspectiveDefaults();
+		break;
+		case ORTHO_SIZE_MANUAL:
+			renderer->setProjectionOrtho(orthoSizeX, orthoSizeY, nearClipPlane, farClipPlane, !topLeftOrtho);
+		break;
+		case ORTHO_SIZE_LOCK_HEIGHT:
+			renderer->setProjectionOrtho(orthoSizeY * (viewport.w/viewport.h), orthoSizeY, nearClipPlane, farClipPlane, !topLeftOrtho);
+		break;
+		case ORTHO_SIZE_LOCK_WIDTH:
+			renderer->setProjectionOrtho(orthoSizeX, orthoSizeX * (viewport.h/viewport.w), nearClipPlane, farClipPlane, !topLeftOrtho);
+		break;
+		case ORTHO_SIZE_VIEWPORT:
+			renderer->setProjectionOrtho(viewport.w / renderer->getBackingResolutionScaleX(), viewport.h / renderer->getBackingResolutionScaleY(), !topLeftOrtho);
+		break;
 	}
 	renderer->setExposureLevel(exposureLevel);
 

Core/Contents/Source/PolyCoreServices.cpp

@@ -174,7 +174,7 @@ void CoreServices::Render() {
 	if(renderer->doClearBuffer)		
 		renderer->clearScreen();
 
-	renderer->setPerspectiveMode();
+	renderer->setPerspectiveDefaults();
 	sceneManager->renderVirtual();
 	sceneManager->Render();
 	renderer->clearLights();

Core/Contents/Source/PolyGLRenderer.cpp

@@ -86,17 +86,10 @@ using namespace Polycode;
 
 OpenGLRenderer::OpenGLRenderer() : Renderer() {
 
-	nearPlane = 0.1f;
-	farPlane = 100.0f;
 	verticesToDraw = 0;
 
 }
 
-void OpenGLRenderer::setClippingPlanes(Number nearPlane_, Number farPlane_) {
-	nearPlane = nearPlane_;
-	farPlane = farPlane_;
-}
-
 bool OpenGLRenderer::Init() {
 	if(!Renderer::Init())
 		return false;
@@ -163,7 +156,6 @@ void OpenGLRenderer::Resize(int xRes, int yRes) {
 	glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
 	glClearDepth(1.0f);
 
-	glMatrixMode(GL_MODELVIEW);
 	glLineWidth(1);
 	glDepthFunc( GL_LEQUAL );
 	
@@ -211,19 +203,29 @@ void OpenGLRenderer::setLineSmooth(bool val) {
 		glDisable(GL_LINE_SMOOTH);
 }
 
-void OpenGLRenderer::resetViewport() {
+void OpenGLRenderer::setProjectionFromFrustum(Number left, Number right, Number bottom, Number top, Number front, Number back) {
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
-	//gluPerspective(fov,(GLfloat)viewportWidth/(GLfloat)viewportHeight,nearPlane,farPlane);		
-    Number fW, fH;
-    fH = tan( fov / 360.0 * PI ) * nearPlane;
-    fW = fH * ((GLfloat)viewportWidth/(GLfloat)viewportHeight);
-	glFrustum(-fW + (viewportShift.x*fW*2.0), fW + (viewportShift.x*fW*2.0), -fH + (viewportShift.y*fH*2.0), fH + (viewportShift.y*fH*2.0), nearPlane, farPlane);
-	
+	glFrustum(left, right, bottom, top, front, back);
+	glMatrixMode(GL_MODELVIEW);
+	polycodeGLGetNumberv(GL_PROJECTION_MATRIX, sceneProjectionMatrix);
+
+}
+
+void OpenGLRenderer::setProjectionFromFoV(Number fov, Number near, Number far) {
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	Number fW, fH;
+	fH = tan( fov / 360.0 * PI ) * near;
+	fW = fH * ((GLfloat)viewportWidth/(GLfloat)viewportHeight);
+	glFrustum(-fW + (viewportShift.x*fW*2.0), fW + (viewportShift.x*fW*2.0), -fH + (viewportShift.y*fH*2.0), fH + (viewportShift.y*fH*2.0), near, far);
+	glMatrixMode(GL_MODELVIEW);
+	polycodeGLGetNumberv(GL_PROJECTION_MATRIX, sceneProjectionMatrix);
+}
+
+void OpenGLRenderer::resetViewport() {
 	glViewport(0, 0, viewportWidth*backingResolutionScaleX, viewportHeight*backingResolutionScaleY);
 	glScissor(0, 0,  viewportWidth*backingResolutionScaleX, viewportHeight*backingResolutionScaleY);
-	glMatrixMode(GL_MODELVIEW);	
-	glGetDoublev( GL_PROJECTION_MATRIX, sceneProjectionMatrix);
 }
 
 Vector3 OpenGLRenderer::Unproject(Number x, Number y, const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport) {
@@ -542,21 +544,17 @@ void OpenGLRenderer::setFogProperties(int fogMode, Color color, Number density,
 	glFogf(GL_FOG_END, endDepth);
 }
 
-void OpenGLRenderer::setOrthoMode(Number xSize, Number ySize, bool centered) {
-	this->orthoSizeX = xSize;
-	this->orthoSizeY = ySize;
-
+void OpenGLRenderer::setProjectionOrtho(Number xSize, Number ySize, Number near, Number far, bool centered) {
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 		
 	if(centered) {
-		glOrtho(-xSize*0.5,xSize*0.5,-ySize*0.5,ySize*0.5,nearPlane,farPlane);		
+		glOrtho(-xSize*0.5,xSize*0.5,-ySize*0.5,ySize*0.5,near,far);
 	} else {
-		glOrtho(0.0f,xSize,0,ySize,nearPlane,farPlane);
+		glOrtho(0.0f,xSize,0,ySize,near,far);
 	}
-	glGetDoublev( GL_PROJECTION_MATRIX, sceneProjectionMatrixOrtho);
-		
-	orthoMode = true;
+	polycodeGLGetNumberv( GL_PROJECTION_MATRIX, sceneProjectionMatrixOrtho);
+
 	glMatrixMode(GL_MODELVIEW);	
 	glLoadIdentity();
 }
@@ -568,16 +566,10 @@ void OpenGLRenderer::enableBackfaceCulling(bool val) {
 		glDisable(GL_CULL_FACE);
 }
 
-void OpenGLRenderer::setPerspectiveMode() {
-	if(orthoMode) {
-		if(lightingEnabled) {
-		}
-		glEnable (GL_DEPTH_TEST);
-		glEnable(GL_CULL_FACE);
-		glMatrixMode( GL_PROJECTION );
-		glMatrixMode( GL_MODELVIEW );
-		orthoMode = false;
-	}
+void OpenGLRenderer::setPerspectiveDefaults() {
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_CULL_FACE);
+	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
 	
 	glGetDoublev( GL_PROJECTION_MATRIX, sceneProjectionMatrix);
@@ -1014,7 +1006,11 @@ void OpenGLRenderer::drawArrays(int drawType) {
 }
 
 void OpenGLRenderer::drawScreenQuad(Number qx, Number qy) {
-	setOrthoMode();
+	glMatrixMode(GL_PROJECTION);
+	glPushMatrix();
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	setProjectionOrtho();
 	
 	Number xscale = qx/((Number)viewportWidth) * 2.0f;
 	Number yscale = qy/((Number)viewportHeight) * 2.0f;	
@@ -1034,7 +1030,12 @@ void OpenGLRenderer::drawScreenQuad(Number qx, Number qy) {
 		glTexCoord2f(1.0f, 1.0f);
 		glVertex2f(-1+(1.0f*xscale), -1+(1.0f*yscale));
 	glEnd();
-	setPerspectiveMode();
+
+	glMatrixMode(GL_PROJECTION);
+	glPopMatrix();
+	glMatrixMode(GL_MODELVIEW);
+	glPopMatrix();
+	setPerspectiveDefaults();
 }
 
 

Core/Contents/Source/PolyRenderer.cpp

@@ -28,7 +28,7 @@
 
 using namespace Polycode;
 
-Renderer::Renderer() : clearColor(0.2f, 0.2f, 0.2f, 0.0), currentTexture(NULL), lightingEnabled(false), orthoMode(false), xRes(0), yRes(0) {
+Renderer::Renderer() : clearColor(0.2, 0.2, 0.2, 0.0), currentTexture(NULL), lightingEnabled(false), xRes(0), yRes(0) {
 	anisotropy = 0;
 	textureFilteringMode = TEX_FILTERING_LINEAR;
 	currentMaterial = NULL;
@@ -42,7 +42,6 @@ Renderer::Renderer() : clearColor(0.2f, 0.2f, 0.2f, 0.0), currentTexture(NULL),
 	exposureLevel = 1;
 	shadersEnabled = true;
 	currentShaderModule = NULL;
-	fov = 45.0;
 	setAmbientColor(0.0,0.0,0.0);
 	cullingFrontFaces = false;
 	scissorEnabled = false;
@@ -326,24 +325,12 @@ void Renderer::setTextureFilteringMode(int mode) {
 	textureFilteringMode = mode;
 }
 
-void Renderer::setFOV(Number fov) {
-	this->fov = fov;
-	resetViewport();
-}
-
 void Renderer::setViewportSize(int w, int h) {
 	viewportWidth = w;
 	viewportHeight = h;
 	resetViewport();
 }
 
-void Renderer::setViewportSizeAndFOV(int w, int h, Number fov) {
-	this->fov = fov;
-	viewportWidth = w;
-	viewportHeight = h;
-	resetViewport();
-}
-
 Number Renderer::getViewportWidth() {
 	return viewportWidth;
 }

Core/Contents/Source/PolySceneEntityInstance.cpp

@@ -410,7 +410,7 @@ Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entit
             camera->setOrthoMode((*cameraEntry)["ortho"]->boolVal);
             
             if(camera->getOrthoMode()) {
-                camera->setOrthoSizeMode((*cameraEntry)["sizeMode"]->intVal);
+				camera->setOrthoSizeMode((*cameraEntry)["sizeMode"]->intVal);
                 camera->setOrthoSize((*cameraEntry)["orthoWidth"]->NumberVal, (*cameraEntry)["orthoHeight"]->NumberVal);
             } else {
                 camera->setFOV((*cameraEntry)["fov"]->NumberVal);
@@ -543,4 +543,4 @@ bool SceneEntityInstance::loadFromFile(const String& fileName) {
 	}
 	
 	return true;
-}
+}

Core/Contents/Source/PolySceneLight.cpp

@@ -125,19 +125,21 @@ unsigned int SceneLight::getShadowMapResolution() const {
 }
 
 void SceneLight::renderDepthMap(Scene *scene) {
-	CoreServices::getInstance()->getRenderer()->clearScreen();
-	CoreServices::getInstance()->getRenderer()->pushMatrix();
-	CoreServices::getInstance()->getRenderer()->loadIdentity();
+	Renderer* renderer = CoreServices::getInstance()->getRenderer();
+	renderer->clearScreen();
+	renderer->pushMatrix();
+	renderer->loadIdentity();
 
-	CoreServices::getInstance()->getRenderer()->setViewportSizeAndFOV(shadowMapRes, shadowMapRes, shadowMapFOV);	
-	CoreServices::getInstance()->getRenderer()->bindFrameBufferTexture(zBufferTexture);	
+	renderer->setViewportSize(shadowMapRes, shadowMapRes);
+	Camera* camera = scene->getActiveCamera();
+	renderer->setProjectionFromFoV(shadowMapFOV, camera->getNearClippingPlane(), camera->getFarClippingPlane());
+	renderer->bindFrameBufferTexture(zBufferTexture);
 
 	scene->RenderDepthOnly(spotCamera);
 		
-	lightViewMatrix = CoreServices::getInstance()->getRenderer()->getModelviewMatrix() *  CoreServices::getInstance()->getRenderer()->getProjectionMatrix();
-	CoreServices::getInstance()->getRenderer()->unbindFramebuffers();
-	CoreServices::getInstance()->getRenderer()->popMatrix();
-	CoreServices::getInstance()->getRenderer()->setViewportSizeAndFOV(CoreServices::getInstance()->getCore()->getXRes(), CoreServices::getInstance()->getCore()->getYRes(), 45.0f);
+	lightViewMatrix = renderer->getModelviewMatrix() *  renderer->getProjectionMatrix();
+	renderer->unbindFramebuffers();
+	renderer->popMatrix();
 }
 
 Entity *SceneLight::Clone(bool deepClone, bool ignoreEditorOnly) const {