Creating a 3d camera with c++ and directx

#ifndef DEMOCAMERA_INCLUDED
#define DEMOCAMERA_INCLUDED
 
#include "geo.h"
 
class DemoCamera
{
public:
    DemoCamera( bool blnPerspectiveView, const vector &pos, float angle_x, float angle_y );
    ~DemoCamera();
 
    // apply camera to opengl
    void                applyCamera();
 
    const matrix&       getWorld2CameraMatrix() const   { return m_CameraMatrix; }
 
    // glut - callbacks
    // glut glutMouseFunc - callback
    // button:
    //  GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, GLUT_RIGHT_BUTTON
    // state:
    //  GLUT_UP 1, GLUT_DOWN 0
    static void         callback_mouse(int button, int state, int x, int y);
    // glut glutMotionFunc - callback
    static void         callback_mouse_motion(int x, int y);
    // glut glutReshapeFunc - callback
    static void         callback_resize(int width, int height);
 
private:
    void                mouse(int button, int state, int x, int y);
    void                mouse_motion(int x, int y);
    void                resize(int width, int height);
 
    // calculate matrix if needed
    void                update();
 
private:
    bool        m_blnPerspectiveView;
    int         m_screen_width;
    int         m_screen_height;
    vector      m_pos;
    float       m_angle_x;
    float       m_angle_y;
    bool        m_blnMatrixDirty;
    matrix      m_CameraMatrix;
 
    struct MouseMoveCache
    {
        int mouse_button;
        int x_start, y_start;
        float angle_x_start, angle_y_start, distance_start;
    };
 
    MouseMoveCache  m_MouseMoveCache;
 
    static DemoCamera   *ms_pSingleton;
};
 
DemoCamera*   DemoCamera::ms_pSingleton = NULL;
 
inline
DemoCamera::DemoCamera( bool blnPerspectiveView, const vector &pos, float angle_x, float angle_y )
: 
  m_blnPerspectiveView( blnPerspectiveView ),
  m_screen_width( 0 ),
  m_screen_height( 0 ),
  m_pos( pos ),
  m_angle_x( angle_x ),
  m_angle_y( angle_y ),
  m_blnMatrixDirty( true ),
  m_CameraMatrix(),
  m_MouseMoveCache()
{
    assert( !ms_pSingleton );
    ms_pSingleton = this;
}
 
inline
DemoCamera::~DemoCamera()
{
    ms_pSingleton = NULL;
}
 
inline
void               
DemoCamera::applyCamera()
{
    update();
    glLoadIdentity();
    glMultMatrixf( (const GLfloat*)getWorld2CameraMatrix().data_ptr() );
}
 
inline
void        
DemoCamera::update()
{
    if( m_blnMatrixDirty )
    {
        m_CameraMatrix = matrix::translate( -m_pos ) * 
                         matrix::rotate_y( gdeg2rad( m_angle_y ) ) * 
                         matrix::rotate_x( gdeg2rad( m_angle_x ) );
        m_blnMatrixDirty = false;
    }
}
 
inline
void        
DemoCamera::mouse(int button, int state, int x, int y)
{
    printf( "button: %d  state: %d  x: %d  y: %d\n", button, state, x, y );
 
    if( state == 0 )
    {
        m_MouseMoveCache.mouse_button = button;
        m_MouseMoveCache.x_start = x;
        m_MouseMoveCache.y_start = y;
        m_MouseMoveCache.angle_x_start = m_angle_x;
        m_MouseMoveCache.angle_y_start = m_angle_y;
        m_MouseMoveCache.distance_start = m_pos[2];
    }
}
 
// glut glutMotionFunc - callback
inline
void 
DemoCamera::mouse_motion(int x, int y)
{
    const float DISTANCE_SCALE = m_blnPerspectiveView ? 0.25f : 0.025f;
 
    switch( m_MouseMoveCache.mouse_button )
    {
    case 0:
        m_angle_y = m_MouseMoveCache.angle_y_start + x-m_MouseMoveCache.x_start;
        m_angle_x = m_MouseMoveCache.angle_x_start + y-m_MouseMoveCache.y_start;
        m_blnMatrixDirty = true;
        break;
    case 2:
        m_pos[2] = m_MouseMoveCache.distance_start + (y-m_MouseMoveCache.y_start)*DISTANCE_SCALE;
        if( !m_blnPerspectiveView ) resize( m_screen_width, m_screen_height );
        m_blnMatrixDirty = true;
        break;
    }
    
}
 
inline
void 
DemoCamera::callback_mouse(int button, int state, int x, int y)
{
    if( ms_pSingleton ) ms_pSingleton->mouse( button, state, x, y );
}
 
inline
void 
DemoCamera::callback_mouse_motion(int x, int y)
{
    if( ms_pSingleton ) ms_pSingleton->mouse_motion( x, y );
}
 
inline
void 
DemoCamera::callback_resize(int width, int height)
{
    if( ms_pSingleton ) ms_pSingleton->resize( width, height );
}
 
inline
void 
DemoCamera::resize(int width, int height)
{
	if( height == 0 ) height = 1;
 
    m_screen_width = width;
    m_screen_height = height;
 
	glViewport( 0, 0, m_screen_width, m_screen_height );
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
    if( m_blnPerspectiveView )
    {
    	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
    }
    else
    {
        float left, right, bottom, top;
        float aspect = (GLfloat)width/(GLfloat)height;
        if( m_screen_width > m_screen_height )
        {
            left =   -m_pos[2] * aspect;
            right =   m_pos[2] * aspect;
            top =     m_pos[2];
            bottom = -m_pos[2];
        }
        else
        {
            left =   -m_pos[2];
            right =   m_pos[2];
            top =     m_pos[2] * aspect;
            bottom = -m_pos[2] * aspect;    
        }
        glOrtho( left, right, bottom, top, -100.0f, +100.0f );
    }
 
	glMatrixMode(GL_MODELVIEW);							// Select The Modelview Matrix
	glLoadIdentity();
}
 
 
 
 
 
 
 
 
 
 
#endif // #ifndef DEMOCAMERA_INCLUDED
                                              

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: