Enter your search terms GNU-Darwin Web Submit search form

camera.h /* Copyright (C) 1998-2001 by Jorrit Tyberghein This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __CS_CAMERA_H__ #define __CS_CAMERA_H__ #include "csutil/scf.h" #include "csgeom/transfrm.h" #include "iengine/camera.h" #include "csengine/sector.h" #include "csengine/polygon.h" class csSector; class csPolygon3D; class Vertex; class csEngine; class csCamera : public csOrthoTransform, public iBase { private: csSector* sector; bool mirror; bool only_portals; csPlane3 *fp; int aspect; static int default_aspect; float inv_aspect; static float default_inv_aspect; float shift_x; float shift_y; float fov_angle; static float default_fov_angle; void ComputeAngle (int width); static void ComputeDefaultAngle (int width); long cameranr; static long cur_cameranr; public: csCamera (); csCamera (csCamera* c); csCamera (const csCamera& c); virtual ~csCamera (); long GetCameraNumber () const { return cameranr; } csPolygon3D* GetHit (csVector3& v); static void SetDefaultFOV (int fov, int width) { default_aspect = fov; default_inv_aspect = 1.0f / default_aspect; ComputeDefaultAngle (width); } static int GetDefaultFOV () { return default_aspect; } static float GetDefaultInvFOV () { return default_inv_aspect; } static float GetDefaultFOVAngle () { return default_fov_angle; } void SetFOV (int a, int width) { aspect = a; inv_aspect = 1.0f / a; ComputeAngle (width); } int GetFOV () const { return aspect; } float GetInvFOV () const { return inv_aspect; } void SetFOVAngle (float a, int width); float GetFOVAngle () const { return fov_angle; } float GetShiftX () const { return shift_x; } float GetShiftY () const { return shift_y; } void SetFarPlane (const csPlane3* farplane); csPlane3* GetFarPlane () const { return fp; } void SetSector (csSector *s) { sector = s; cameranr = cur_cameranr++; } csSector* GetSector () const { return sector; } bool IsMirrored () const { return mirror; } void SetMirrored (bool m) { if (mirror != m) cameranr = cur_cameranr++; mirror = m; } virtual void SetO2T (const csMatrix3& m) { csOrthoTransform::SetO2T (m); cameranr = cur_cameranr++; } virtual void SetT2O (const csMatrix3& m) { csOrthoTransform::SetT2O (m); cameranr = cur_cameranr++; } virtual void SetO2TTranslation (const csVector3& v) { csOrthoTransform::SetO2TTranslation (v); cameranr = cur_cameranr++; } virtual void SetPosition (const csVector3& v) { SetOrigin (v); } inline void SetW2C (const csMatrix3& m) { SetO2T (m); } inline void SetC2W (const csMatrix3& m) { SetT2O (m); } inline csMatrix3 GetW2C () const { return GetO2T (); } inline csMatrix3 GetC2W () const { return GetT2O (); } inline csVector3 GetW2CTranslation () const { return GetO2TTranslation (); } inline csVector3 World2Camera (const csVector3& v) const { return Other2This (v); } inline csVector3 Camera2World (const csVector3& v) const { return This2Other (v); } inline csVector3 Camera2WorldRelative (const csVector3& v) const { return This2OtherRelative (v); } virtual void MoveWorld (const csVector3& v, bool cd = true); virtual void Move (const csVector3& v, bool cd = true) { MoveWorld (m_t2o * v, cd); } virtual void MoveWorldUnrestricted (const csVector3& v) { Translate (v); } virtual void MoveUnrestricted (const csVector3& v) { Translate (m_t2o * v); } void Correct (int n); void SetPerspectiveCenter (float x, float y) { shift_x = x; shift_y = y; } void Perspective (const csVector3& v, csVector2& p) const { float iz = aspect / v.z; p.x = v.x * iz + shift_x; p.y = v.y * iz + shift_y; } void InvPerspective (const csVector2& p, float z, csVector3& v) const { v.z = z; v.x = (p.x - shift_x) * z * inv_aspect; v.y = (p.y - shift_y) * z * inv_aspect; } SCF_DECLARE_IBASE; //------------------------ iCamera implementation ------------------------ struct Camera : public iCamera { SCF_DECLARE_EMBEDDED_IBASE (csCamera); virtual iCamera *Clone () const { return &(new csCamera (*scfParent))->scfiCamera; } virtual int GetFOV () const { return scfParent->GetFOV (); } virtual float GetInvFOV () const { return scfParent->GetInvFOV (); } virtual float GetFOVAngle () const { return scfParent->GetFOVAngle (); } virtual void SetFOV (int a, int width) { scfParent->SetFOV (a, width); } virtual void SetFOVAngle (float a, int width) { scfParent->SetFOVAngle (a, width); } virtual float GetShiftX () const { return scfParent->GetShiftX (); } virtual float GetShiftY () const { return scfParent->GetShiftY (); } virtual void SetPerspectiveCenter (float x, float y) { scfParent->SetPerspectiveCenter (x, y); } virtual csOrthoTransform& GetTransform () { return *(csOrthoTransform*)scfParent; } virtual const csOrthoTransform& GetTransform () const { return *(csOrthoTransform*)scfParent; } virtual void SetTransform (const csOrthoTransform& tr) { *(csOrthoTransform*)scfParent = tr; scfParent->cameranr = scfParent->cur_cameranr++; } virtual void MoveWorld (const csVector3& v, bool cd = true) { scfParent->MoveWorld (v, cd); } virtual void Move (const csVector3& v, bool cd = true) { scfParent->Move (v, cd); } virtual void MoveWorldUnrestricted (const csVector3& v) { scfParent->MoveWorldUnrestricted (v); } virtual void MoveUnrestricted (const csVector3& v) { scfParent->MoveUnrestricted (v); } virtual iSector* GetSector () const { return scfParent->GetSector() ? &scfParent->GetSector()->scfiSector : NULL; } virtual void SetSector (iSector *s) { scfParent->SetSector (s->GetPrivateObject ()); } virtual iPolygon3D* GetHit (csVector3& v) { csPolygon3D* poly = scfParent->GetHit (v); return poly ? &(poly->scfiPolygon3D) : NULL; } virtual void Correct (int n) { scfParent->Correct (n); } virtual bool IsMirrored () const { return scfParent->IsMirrored (); } virtual void SetMirrored (bool m) { scfParent->SetMirrored (m); } virtual csPlane3* GetFarPlane () const { return scfParent->GetFarPlane (); } virtual void SetFarPlane (csPlane3* fp) { scfParent->SetFarPlane (fp); } virtual long GetCameraNumber () const { return scfParent->GetCameraNumber (); } virtual void Perspective (const csVector3& v, csVector2& p) const { scfParent->Perspective (v, p); } virtual void InvPerspective (const csVector2& p, float z, csVector3& v) const { scfParent->InvPerspective (p, z, v); } virtual void OnlyPortals (bool hop) { scfParent->only_portals = hop; } virtual bool GetOnlyPortals () { return scfParent->only_portals; } } scfiCamera; friend struct Camera; private: void Correct (int n, float* vals[]); }; #endif // __CS_CAMERA_H__ Generated for Crystal Space by doxygen 1.2.5 written by Dimitri van Heesch, ©1997-2000