Extras/CDTestFramework/Camera.cpp

   1 /*
   2 CDTestFramework http://codercorner.com
   3 Copyright (c) 2007-2008 Pierre Terdiman,  pierre@codercorner.com
   4
   5 This software is provided 'as-is', without any express or implied warranty.
   6 In no event will the authors be held liable for any damages arising from the use of this software.
   7 Permission is granted to anyone to use this software for any purpose,
   8 including commercial applications, and to alter it and redistribute it freely,
   9 subject to the following restrictions:
  10
  11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  13 3. This notice may not be removed or altered from any source distribution.
  14 */
  15
  16 #include "stdafx.h"
  17 #include "Camera.h"
  18
  19 static const float gCamSpeed = 1.0f;
  20 //static Point gEye(3.0616338f, 1.1985892f, 2.5769043f);
  21 //static Point gDir(-0.66853905,-0.14004262,-0.73037237);
  22 static Point gEye(240, 205, 205);
  23 static Point gDir(-1,-1,-1);
  24 static Point gN;
  25 static float gFOV = 60.0f;
  26
  27 const Point& GetCameraPos()
  28 {
  29         return gEye;
  30 }
  31
  32 const Point& GetCameraDir()
  33 {
  34         return gDir;
  35 }
  36
  37 void MoveCameraForward()
  38 {
  39         gEye += gDir * gCamSpeed;
  40 }
  41
  42 void MoveCameraBackward()
  43 {
  44         gEye -= gDir * gCamSpeed;
  45 }
  46
  47 void MoveCameraRight()
  48 {
  49         gEye -= gN * gCamSpeed;
  50 }
  51
  52 void MoveCameraLeft()
  53 {
  54         gEye += gN * gCamSpeed;
  55 }
  56
  57         static const float NxPiF32      = 3.141592653589793f;
  58
  59         float degToRad(float a)
  60                 {
  61                 return (float)0.01745329251994329547 * a;
  62                 }
  63
  64         class NxQuat
  65                 {
  66                 public:
  67                 NxQuat(){}
  68
  69                 NxQuat(const float angle, const Point & axis)
  70                 {
  71                 x = axis.x;
  72                 y = axis.y;
  73                 z = axis.z;
  74
  75                 const float i_length =  1.0f / sqrtf( x*x + y*y + z*z );
  76                 x = x * i_length;
  77                 y = y * i_length;
  78                 z = z * i_length;
  79
  80                 float Half = degToRad(angle * 0.5f);
  81
  82                 w = cosf(Half);
  83                 const float sin_theta_over_two = sinf(Half );
  84                 x = x * sin_theta_over_two;
  85                 y = y * sin_theta_over_two;
  86                 z = z * sin_theta_over_two;
  87                 }
  88
  89         void NxQuat::multiply(const NxQuat& left, const Point& right)
  90                 {
  91                 float a,b,c,d;
  92
  93                 a = - left.x*right.x - left.y*right.y - left.z *right.z;
  94                 b =   left.w*right.x + left.y*right.z - right.y*left.z;
  95                 c =   left.w*right.y + left.z*right.x - right.z*left.x;
  96                 d =   left.w*right.z + left.x*right.y - right.x*left.y;
  97
  98                 w = a;
  99                 x = b;
 100                 y = c;
 101                 z = d;
 102                 }
 103
 104         void NxQuat::rotate(Point & v) const
 105                 {
 106                 NxQuat myInverse;
 107                 myInverse.x = -x;
 108                 myInverse.y = -y;
 109                 myInverse.z = -z;
 110                 myInverse.w =  w;
 111
 112                 NxQuat left;
 113                 left.multiply(*this,v);
 114                 v.x = left.w*myInverse.x + myInverse.w*left.x + left.y*myInverse.z - myInverse.y*left.z;
 115                 v.y = left.w*myInverse.y + myInverse.w*left.y + left.z*myInverse.x - myInverse.z*left.x;
 116                 v.z = left.w*myInverse.z + myInverse.w*left.z + left.x*myInverse.y - myInverse.x*left.y;
 117                 }
 118
 119                 float x,y,z,w;
 120                 };
 121
 122 void RotateCamera(int dx, int dy)
 123 {
 124         gDir = gDir.Normalize();
 125         gN = gDir ^ Point(0,1,0);
 126
 127         NxQuat qx(NxPiF32 * dx * 20/ 180.0f, Point(0,1,0));
 128         qx.rotate(gDir);
 129         NxQuat qy(NxPiF32 * dy * 20/ 180.0f, gN);
 130         qy.rotate(gDir);
 131 }
 132
 133 void SetupCameraMatrix()
 134 {
 135         glLoadIdentity();
 136         gluPerspective(gFOV, ((float)glutGet(GLUT_WINDOW_WIDTH))/((float)glutGet(GLUT_WINDOW_HEIGHT)), 1.0f, 10000.0f);
 137         gluLookAt(gEye.x, gEye.y, gEye.z, gEye.x + gDir.x, gEye.y + gDir.y, gEye.z + gDir.z, 0.0f, 1.0f, 0.0f);
 138 }
 139
 140 Point ComputeWorldRay(int xs, int ys)
 141 {
 142         GLint viewPort[4];
 143         GLdouble modelMatrix[16];
 144         GLdouble projMatrix[16];
 145         glGetIntegerv(GL_VIEWPORT, viewPort);
 146         glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
 147         glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
 148         ys = viewPort[3] - ys - 1;
 149         GLdouble wx0, wy0, wz0;
 150         gluUnProject((GLdouble) xs, (GLdouble) ys, 0.0, modelMatrix, projMatrix, viewPort, &wx0, &wy0, &wz0);
 151         GLdouble wx1, wy1, wz1;
 152         gluUnProject((GLdouble) xs, (GLdouble) ys, 1.0, modelMatrix, projMatrix, viewPort, &wx1, &wy1, &wz1);
 153         Point tmp(float(wx1-wx0), float(wy1-wy0), float(wz1-wz0));
 154         tmp.Normalize();
 155         return tmp;
 156 }