prefect
09b87e84ec
close #141 The problem was that the shadow matrices were setup in BeginFrame, but GraphicsView calls SetCamera after BeginFrame. The solution was to move the shadow matrix setup into CRenderer::SetCamera. This caused a second problem because RenderReflections/RenderRefractions used SetCamera to change the OpenGL matrices. Solved this problem by distinguishing explicitly between the camera used for the scene as a whole and the camera used to configure OpenGL. The latter can be a virtual camera for shadow or reflection rendering and similar render-to-texture effects. This was SVN commit r4330.
123 lines
4.0 KiB
C++
123 lines
4.0 KiB
C++
//***********************************************************
|
|
//
|
|
// Name: Camera.H
|
|
// Last Update: 24/2/02
|
|
// Author: Poya Manouchehri
|
|
//
|
|
// Description: CCamera holds a view and a projection matrix.
|
|
// It also has a frustum which can be used to
|
|
// cull objects for rendering.
|
|
//
|
|
//***********************************************************
|
|
|
|
#ifndef CAMERA_H
|
|
#define CAMERA_H
|
|
|
|
#include "Frustum.h"
|
|
#include "maths/Matrix3D.h"
|
|
|
|
extern int g_mouse_x, g_mouse_y;
|
|
|
|
// view port
|
|
struct SViewPort
|
|
{
|
|
unsigned int m_X;
|
|
unsigned int m_Y;
|
|
unsigned int m_Width;
|
|
unsigned int m_Height;
|
|
};
|
|
|
|
|
|
class CCamera
|
|
{
|
|
public:
|
|
CCamera ();
|
|
~CCamera ();
|
|
|
|
// Methods for projection
|
|
void SetProjection (CMatrix3D *proj) { m_ProjMat = *proj; }
|
|
void SetProjection (float nearp, float farp, float fov);
|
|
void SetProjectionTile (int tiles, int tile_x, int tile_y);
|
|
CMatrix3D& GetProjection () { return m_ProjMat; }
|
|
const CMatrix3D& GetProjection () const { return m_ProjMat; }
|
|
|
|
// Updates the frustum planes. Should be called
|
|
// everytime the view or projection matrices are
|
|
// altered.
|
|
void UpdateFrustum ();
|
|
CFrustum GetFrustum () { return m_ViewFrustum; }
|
|
|
|
void SetViewPort (SViewPort *viewport);
|
|
const SViewPort& GetViewPort () const { return m_ViewPort; }
|
|
|
|
// getters
|
|
float GetNearPlane() const { return m_NearPlane; }
|
|
float GetFarPlane() const { return m_FarPlane; }
|
|
float GetFOV() const { return m_FOV; }
|
|
|
|
// calculate and return the position of the 8 points of the frustum in world space
|
|
void GetFrustumPoints(CVector3D pts[8]) const;
|
|
|
|
// return four points in camera space at given distance from camera
|
|
void GetCameraPlanePoints(float dist,CVector3D pts[4]) const;
|
|
|
|
// Build a ray passing through the screen coordinate (px, py) and the camera
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// BuildCameraRay: calculate origin and ray direction of a ray through
|
|
// the pixel (px,py) on the screen
|
|
void BuildCameraRay(int px, int py, CVector3D& origin, CVector3D& dir);
|
|
// BuildCameraRay: as previous, using global mouse position
|
|
void BuildCameraRay(CVector3D& origin, CVector3D& dir)
|
|
{
|
|
BuildCameraRay(g_mouse_x, g_mouse_y, origin, dir);
|
|
}
|
|
|
|
// General helpers that seem to fit here
|
|
|
|
// Get the screen-space coordinates corresponding to a given world-space position
|
|
void GetScreenCoordinates(const CVector3D& world, float& x, float& y) const;
|
|
|
|
// Get the point on the terrain corresponding to pixel (px,py) (or the mouse coordinates)
|
|
// The aboveWater parameter determines whether we want to stop at the water plane or also get underwater points
|
|
CVector3D GetWorldCoordinates(int px, int py, bool aboveWater=false);
|
|
CVector3D GetWorldCoordinates(bool aboveWater=false)
|
|
{ return GetWorldCoordinates(g_mouse_x, g_mouse_y, aboveWater); }
|
|
// Get the point on the plane at height h corresponding to pixel (px,py)
|
|
CVector3D GetWorldCoordinates(int px, int py, float h);
|
|
// Get the point on the terrain the camera is pointing towards
|
|
CVector3D GetFocus();
|
|
|
|
// Build an orientation matrix from camera position, camera focus point, and up-vector
|
|
void LookAt(const CVector3D& camera, const CVector3D& orientation, const CVector3D& up);
|
|
|
|
// Build an orientation matrix from camera position, camera orientation, and up-vector
|
|
void LookAlong(CVector3D camera, CVector3D focus, CVector3D up);
|
|
|
|
/**
|
|
* Render: Renders the camera's frustum in world space.
|
|
* The caller should set the color using glColorXy before calling Render.
|
|
*
|
|
* @param intermediates determines how many intermediate distance planes should
|
|
* be hinted at between the near and far planes
|
|
*/
|
|
void Render(uint intermediates = 0) const;
|
|
|
|
public:
|
|
// This is the orientation matrix. The inverse of this
|
|
// is the view matrix
|
|
CMatrix3D m_Orientation;
|
|
|
|
// Should not be tweaked externally if possible
|
|
CMatrix3D m_ProjMat;
|
|
|
|
private:
|
|
float m_NearPlane;
|
|
float m_FarPlane;
|
|
float m_FOV;
|
|
SViewPort m_ViewPort;
|
|
|
|
CFrustum m_ViewFrustum;
|
|
};
|
|
|
|
#endif
|