← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to intern/ghost/test/gears/GHOST_Test.cpp

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/ghost/test/gears/GHOST_Test.cpp
1
 
/**
 
1
/*
2
2
 * ***** BEGIN GPL LICENSE BLOCK *****
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or
26
26
 */
27
27
 
28
28
/**
29
 
 
30
29
 * Copyright (C) 2001 NaN Technologies B.V.
31
30
 * Simple test file for the GHOST library.
32
31
 * The OpenGL gear code is taken from the Qt sample code which,
33
32
 * in turn, is probably taken from somewhere as well.
34
 
 * @author      Maarten Gribnau
35
 
 * @date        May 31, 2001
 
33
 * \author      Maarten Gribnau
 
34
 * \date        May 31, 2001
36
35
 * Stereo code by Raymond de Vries, januari 2002
37
36
 */
38
37
 
40
39
#include <math.h>
41
40
 
42
41
#if defined(WIN32) || defined(__APPLE__)
43
 
        #ifdef WIN32
44
 
                #include <windows.h>
45
 
                #include <atlbase.h>
 
42
#  ifdef WIN32
 
43
#    include <windows.h>
 
44
#    include <atlbase.h>
46
45
 
47
 
                #include <GL/gl.h>
48
 
        #else // WIN32
49
 
                // __APPLE__ is defined
50
 
                #include <AGL/gl.h>
51
 
        #endif // WIN32
 
46
#    include <GL/gl.h>
 
47
#  else // WIN32
 
48
          // __APPLE__ is defined
 
49
#    include <AGL/gl.h>
 
50
#  endif // WIN32
52
51
#else // defined(WIN32) || defined(__APPLE__)
53
 
        #include <GL/gl.h>
 
52
#  include <GL/gl.h>
54
53
#endif // defined(WIN32) || defined(__APPLE__)
55
54
 
56
55
#include "STR_String.h"
66
65
 
67
66
static bool nVidiaWindows;  // very dirty but hey, it's for testing only
68
67
 
69
 
static void gearsTimerProc(GHOST_ITimerTask* task, GHOST_TUns64 time);
 
68
static void gearsTimerProc(GHOST_ITimerTask *task, GHOST_TUns64 time);
70
69
 
71
 
static class Application* fApp;
72
 
static GLfloat view_rotx=20.0, view_roty=30.0, view_rotz=0.0;
 
70
static class Application * fApp;
 
71
static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
73
72
static GLfloat fAngle = 0.0;
74
 
static GHOST_ISystem* fSystem = 0;
 
73
static GHOST_ISystem *fSystem = 0;
75
74
 
76
75
 
77
76
void StereoProjection(float left, float right, float bottom, float top, float nearplane, float farplane,
78
 
                float zero_plane, float dist,
79
 
                float eye);
80
 
 
81
 
 
82
 
static void testTimerProc(GHOST_ITimerTask* /*task*/, GHOST_TUns64 time)
 
77
                      float zero_plane, float dist,
 
78
                      float eye);
 
79
 
 
80
 
 
81
static void testTimerProc(GHOST_ITimerTask * /*task*/, GHOST_TUns64 time)
83
82
{
84
83
        std::cout << "timer1, time=" << (int)time << "\n";
85
84
}
93
92
        GLfloat u, v, len;
94
93
 
95
94
        r0 = inner_radius;
96
 
        r1 = outer_radius - tooth_depth/2.0;
97
 
        r2 = outer_radius + tooth_depth/2.0;
 
95
        r1 = outer_radius - tooth_depth / 2.0;
 
96
        r2 = outer_radius + tooth_depth / 2.0;
98
97
 
99
98
        const double pi = 3.14159264;
100
 
        da = 2.0*pi / teeth / 4.0;
 
99
        da = 2.0 * pi / teeth / 4.0;
101
100
 
102
101
        glShadeModel(GL_FLAT);
103
102
        glNormal3f(0.0, 0.0, 1.0);
104
103
 
105
104
        /* draw front face */
106
105
        glBegin(GL_QUAD_STRIP);
107
 
        for (i=0;i<=teeth;i++) {
108
 
                angle = i * 2.0*pi / teeth;
109
 
                glVertex3f(r0*cos(angle), r0*sin(angle), width*0.5);
110
 
                glVertex3f(r1*cos(angle), r1*sin(angle), width*0.5);
111
 
                glVertex3f(r0*cos(angle), r0*sin(angle), width*0.5);
112
 
                glVertex3f(r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5);
 
106
        for (i = 0; i <= teeth; i++) {
 
107
                angle = i * 2.0 * pi / teeth;
 
108
                glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
 
109
                glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
 
110
                glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
 
111
                glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
113
112
        }
114
113
        glEnd();
115
114
 
116
115
        /* draw front sides of teeth */
117
116
        glBegin(GL_QUADS);
118
 
        da = 2.0*pi / teeth / 4.0;
119
 
        for (i=0;i<teeth;i++) {
120
 
                angle = i * 2.0*pi / teeth;
121
 
                glVertex3f(r1*cos(angle),      r1*sin(angle),      width*0.5);
122
 
                glVertex3f(r2*cos(angle+da),   r2*sin(angle+da),   width*0.5);
123
 
                glVertex3f(r2*cos(angle+2*da), r2*sin(angle+2*da), width*0.5);
124
 
                glVertex3f(r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5);
 
117
        da = 2.0 * pi / teeth / 4.0;
 
118
        for (i = 0; i < teeth; i++) {
 
119
                angle = i * 2.0 * pi / teeth;
 
120
                glVertex3f(r1 * cos(angle),      r1 * sin(angle),      width * 0.5);
 
121
                glVertex3f(r2 * cos(angle + da),   r2 * sin(angle + da),   width * 0.5);
 
122
                glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
 
123
                glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
125
124
        }
126
125
        glEnd();
127
126
 
129
128
 
130
129
        /* draw back face */
131
130
        glBegin(GL_QUAD_STRIP);
132
 
        for (i=0;i<=teeth;i++) {
133
 
                angle = i * 2.0*pi / teeth;
134
 
                glVertex3f(r1*cos(angle), r1*sin(angle), -width*0.5);
135
 
                glVertex3f(r0*cos(angle), r0*sin(angle), -width*0.5);
136
 
                glVertex3f(r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5);
137
 
                glVertex3f(r0*cos(angle), r0*sin(angle), -width*0.5);
 
131
        for (i = 0; i <= teeth; i++) {
 
132
                angle = i * 2.0 * pi / teeth;
 
133
                glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
 
134
                glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
 
135
                glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
 
136
                glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
138
137
        }
139
138
        glEnd();
140
139
 
141
140
        /* draw back sides of teeth */
142
141
        glBegin(GL_QUADS);
143
 
        da = 2.0*pi / teeth / 4.0;
144
 
        for (i=0;i<teeth;i++) {
145
 
                angle = i * 2.0*pi / teeth;
146
 
                glVertex3f(r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5);
147
 
                glVertex3f(r2*cos(angle+2*da), r2*sin(angle+2*da), -width*0.5);
148
 
                glVertex3f(r2*cos(angle+da),   r2*sin(angle+da),          -width*0.5);
149
 
                glVertex3f(r1*cos(angle),      r1*sin(angle),     -width*0.5);
 
142
        da = 2.0 * pi / teeth / 4.0;
 
143
        for (i = 0; i < teeth; i++) {
 
144
                angle = i * 2.0 * pi / teeth;
 
145
                glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
 
146
                glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
 
147
                glVertex3f(r2 * cos(angle + da),   r2 * sin(angle + da),      -width * 0.5);
 
148
                glVertex3f(r1 * cos(angle),      r1 * sin(angle),     -width * 0.5);
150
149
        }
151
150
        glEnd();
152
151
 
153
152
        /* draw outward faces of teeth */
154
153
        glBegin(GL_QUAD_STRIP);
155
 
        for (i=0;i<teeth;i++) {
156
 
                angle = i * 2.0*pi / teeth;
157
 
                glVertex3f(r1*cos(angle),      r1*sin(angle),      width*0.5);
158
 
                glVertex3f(r1*cos(angle),      r1*sin(angle),     -width*0.5);
159
 
                u = r2*cos(angle+da) - r1*cos(angle);
160
 
                v = r2*sin(angle+da) - r1*sin(angle);
161
 
                len = sqrt(u*u + v*v);
 
154
        for (i = 0; i < teeth; i++) {
 
155
                angle = i * 2.0 * pi / teeth;
 
156
                glVertex3f(r1 * cos(angle),      r1 * sin(angle),      width * 0.5);
 
157
                glVertex3f(r1 * cos(angle),      r1 * sin(angle),     -width * 0.5);
 
158
                u = r2 * cos(angle + da) - r1 *cos(angle);
 
159
                v = r2 * sin(angle + da) - r1 *sin(angle);
 
160
                len = sqrt(u * u + v * v);
162
161
                u /= len;
163
162
                v /= len;
164
163
                glNormal3f(v, -u, 0.0);
165
 
                glVertex3f(r2*cos(angle+da),   r2*sin(angle+da),           width*0.5);
166
 
                glVertex3f(r2*cos(angle+da),   r2*sin(angle+da),          -width*0.5);
 
164
                glVertex3f(r2 * cos(angle + da),   r2 * sin(angle + da),       width * 0.5);
 
165
                glVertex3f(r2 * cos(angle + da),   r2 * sin(angle + da),      -width * 0.5);
167
166
                glNormal3f(cos(angle), sin(angle), 0.0);
168
 
                glVertex3f(r2*cos(angle+2*da), r2*sin(angle+2*da),  width*0.5);
169
 
                glVertex3f(r2*cos(angle+2*da), r2*sin(angle+2*da), -width*0.5);
170
 
                u = r1*cos(angle+3*da) - r2*cos(angle+2*da);
171
 
                v = r1*sin(angle+3*da) - r2*sin(angle+2*da);
 
167
                glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),  width * 0.5);
 
168
                glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
 
169
                u = r1 * cos(angle + 3 * da) - r2 *cos(angle + 2 * da);
 
170
                v = r1 * sin(angle + 3 * da) - r2 *sin(angle + 2 * da);
172
171
                glNormal3f(v, -u, 0.0);
173
 
                glVertex3f(r1*cos(angle+3*da), r1*sin(angle+3*da),  width*0.5);
174
 
                glVertex3f(r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5);
 
172
                glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),  width * 0.5);
 
173
                glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
175
174
                glNormal3f(cos(angle), sin(angle), 0.0);
176
 
                }
177
 
        glVertex3f(r1*cos(0.0), r1*sin(0.0), width*0.5);
178
 
        glVertex3f(r1*cos(0.0), r1*sin(0.0), -width*0.5);
 
175
        }
 
176
        glVertex3f(r1 * cos(0.0), r1 * sin(0.0), width * 0.5);
 
177
        glVertex3f(r1 * cos(0.0), r1 * sin(0.0), -width * 0.5);
179
178
        glEnd();
180
179
 
181
180
        glShadeModel(GL_SMOOTH);
182
181
 
183
182
        /* draw inside radius cylinder */
184
183
        glBegin(GL_QUAD_STRIP);
185
 
        for (i=0;i<=teeth;i++) {
186
 
                angle = i * 2.0*pi / teeth;
 
184
        for (i = 0; i <= teeth; i++) {
 
185
                angle = i * 2.0 * pi / teeth;
187
186
                glNormal3f(-cos(angle), -sin(angle), 0.0);
188
 
                glVertex3f(r0*cos(angle), r0*sin(angle), -width*0.5);
189
 
                glVertex3f(r0*cos(angle), r0*sin(angle), width*0.5);
 
187
                glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
 
188
                glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
190
189
        }
191
190
        glEnd();
192
191
}
208
207
 
209
208
        switch (id)
210
209
        {
211
 
        case 1:
212
 
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ared);
213
 
                gearGL(1.0f, 4.0f, 1.0f, 20, 0.7f);
214
 
                break;
215
 
        case 2:
216
 
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, agreen);
217
 
                gearGL(0.5f, 2.0f, 2.0f, 10, 0.7f);
218
 
                break;
219
 
        case 3:
220
 
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ablue);
221
 
                gearGL(1.3f, 2.0f, 0.5f, 10, 0.7f);
222
 
                break;
223
 
        default:
224
 
                break;
 
210
                case 1:
 
211
                        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ared);
 
212
                        gearGL(1.0f, 4.0f, 1.0f, 20, 0.7f);
 
213
                        break;
 
214
                case 2:
 
215
                        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, agreen);
 
216
                        gearGL(0.5f, 2.0f, 2.0f, 10, 0.7f);
 
217
                        break;
 
218
                case 3:
 
219
                        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ablue);
 
220
                        gearGL(1.3f, 2.0f, 0.5f, 10, 0.7f);
 
221
                        break;
 
222
                default:
 
223
                        break;
225
224
        }
226
225
        glEnable(GL_NORMALIZE);
227
226
}
229
228
 
230
229
void RenderCamera()
231
230
{
232
 
    glRotatef(view_rotx, 1.0, 0.0, 0.0);
233
 
    glRotatef(view_roty, 0.0, 1.0, 0.0);
234
 
    glRotatef(view_rotz, 0.0, 0.0, 1.0);
 
231
        glRotatef(view_rotx, 1.0, 0.0, 0.0);
 
232
        glRotatef(view_roty, 0.0, 1.0, 0.0);
 
233
        glRotatef(view_rotz, 0.0, 0.0, 1.0);
235
234
}
236
235
 
237
236
 
258
257
}
259
258
 
260
259
 
261
 
static void View(GHOST_IWindow* window, bool stereo, int eye = 0)
 
260
static void View(GHOST_IWindow *window, bool stereo, int eye = 0)
262
261
{
263
262
        window->activateDrawingContext();
264
263
        GHOST_Rect bnds;
270
269
        window->getClientBounds(bnds);
271
270
 
272
271
        // viewport
273
 
        if(stereo)
 
272
        if (stereo)
274
273
        {
275
 
                if(nVidiaWindows)
 
274
                if (nVidiaWindows)
276
275
                { 
277
276
                        // handled by nVidia driver so act as normal (explicitly put here since
278
277
                        // it -is- stereo)
279
278
                        glViewport(0, 0, bnds.getWidth(), bnds.getHeight());
280
279
                }
281
 
                else
282
 
                {  // generic cross platform above-below stereo
 
280
                else { // generic cross platform above-below stereo
283
281
                        noOfScanlines = (bnds.getHeight() - verticalBlankingInterval) / 2;
284
 
                        switch(eye)
 
282
                        switch (eye)
285
283
                        {
286
284
                                case LEFT_EYE:
287
285
                                        // upper half of window
294
292
                        }
295
293
                }
296
294
        }
297
 
        else
298
 
        {
 
295
        else {
299
296
                noOfScanlines = bnds.getHeight();
300
297
                lowerScanline = 0;
301
298
        }
310
307
        nearplane = 5.0;
311
308
        farplane = 60.0;
312
309
 
313
 
        if(stereo)
 
310
        if (stereo)
314
311
        {
315
312
                zeroPlane = 0.0;
316
313
                distance = 14.5;
317
 
                switch(eye)
 
314
                switch (eye)
318
315
                {
319
316
                        case LEFT_EYE:
320
317
                                StereoProjection(left, right, bottom, top, nearplane, farplane, zeroPlane, distance, -eyeSeparation / 2.0);
324
321
                                break;
325
322
                }
326
323
        }
327
 
        else
328
 
        {
 
324
        else {
329
325
//              left = -w;
330
326
//              right = w;
331
327
//              bottom = -h;
339
335
 
340
336
        }
341
337
 
342
 
        glClearColor(.2f,0.0f,0.0f,0.0f);
 
338
        glClearColor(.2f, 0.0f, 0.0f, 0.0f);
343
339
}
344
340
 
345
341
 
347
343
                float zero_plane, float dist,
348
344
                float eye)
349
345
/* Perform the perspective projection for one eye's subfield.
350
 
The projection is in the direction of the negative z axis.
351
 
 
352
 
-6.0, 6.0, -4.8, 4.8,
353
 
left, right, bottom, top = the coordinate range, in the plane of zero
354
 
parallax setting, which will be displayed on the screen.  The
355
 
ratio between (right-left) and (top-bottom) should equal the aspect
356
 
ratio of the display.
357
 
 
358
 
6.0, -6.0,
359
 
near, far = the z-coordinate values of the clipping planes.
360
 
 
361
 
0.0,
362
 
zero_plane = the z-coordinate of the plane of zero parallax setting.
363
 
 
364
 
14.5,
365
 
dist = the distance from the center of projection to the plane
366
 
of zero parallax.
367
 
 
368
 
-0.31
369
 
eye = half the eye separation; positive for the right eye subfield,
370
 
negative for the left eye subfield.
371
 
*/
 
346
 * The projection is in the direction of the negative z axis.
 
347
 *
 
348
 * -6.0, 6.0, -4.8, 4.8,
 
349
 * left, right, bottom, top = the coordinate range, in the plane of zero
 
350
 * parallax setting, which will be displayed on the screen.  The
 
351
 * ratio between (right-left) and (top-bottom) should equal the aspect
 
352
 * ratio of the display.
 
353
 *
 
354
 * 6.0, -6.0,
 
355
 * near, far = the z-coordinate values of the clipping planes.
 
356
 *
 
357
 * 0.0,
 
358
 * zero_plane = the z-coordinate of the plane of zero parallax setting.
 
359
 *
 
360
 * 14.5,
 
361
 * dist = the distance from the center of projection to the plane
 
362
 * of zero parallax.
 
363
 *
 
364
 * -0.31
 
365
 * eye = half the eye separation; positive for the right eye subfield,
 
366
 * negative for the left eye subfield.
 
367
 */
372
368
{
373
369
        float xmid, ymid, clip_near, clip_far, topw, bottomw, leftw, rightw,
374
 
        dx, dy, n_over_d;
 
370
              dx, dy, n_over_d;
375
371
 
376
372
        dx = right - left;
377
373
        dy = top - bottom;
387
383
        topw = n_over_d * dy / 2.0;
388
384
        bottomw = -topw;
389
385
        rightw = n_over_d * (dx / 2.0 - eye);
390
 
        leftw  = n_over_d *(-dx / 2.0 - eye);
 
386
        leftw  = n_over_d * (-dx / 2.0 - eye);
391
387
 
392
388
        /* Need to be in projection mode for this. */
393
389
        glLoadIdentity();
400
396
 
401
397
class Application : public GHOST_IEventConsumer {
402
398
public:
403
 
        Application(GHOST_ISystem* system);
 
399
        Application(GHOST_ISystem *system);
404
400
        ~Application(void);
405
 
        virtual bool processEvent(GHOST_IEvent* event);
 
401
        virtual bool processEvent(GHOST_IEvent *event);
406
402
 
407
 
        GHOST_ISystem* m_system;
408
 
        GHOST_IWindow* m_mainWindow;
409
 
        GHOST_IWindow* m_secondaryWindow;
410
 
        GHOST_IWindow* m_fullScreenWindow;
411
 
        GHOST_ITimerTask* m_gearsTimer, *m_testTimer;
 
403
        GHOST_ISystem *m_system;
 
404
        GHOST_IWindow *m_mainWindow;
 
405
        GHOST_IWindow *m_secondaryWindow;
 
406
        GHOST_IWindow *m_fullScreenWindow;
 
407
        GHOST_ITimerTask *m_gearsTimer, *m_testTimer;
412
408
        GHOST_TStandardCursor m_cursor;
413
409
        bool m_exitRequested;
414
410
 
416
412
};
417
413
 
418
414
 
419
 
Application::Application(GHOST_ISystem* system)
 
415
Application::Application(GHOST_ISystem *system)
420
416
        : m_system(system), m_mainWindow(0), m_secondaryWindow(0), m_fullScreenWindow(0),
421
 
          m_gearsTimer(0), m_testTimer(0), m_cursor(GHOST_kStandardCursorFirstCursor),
422
 
          m_exitRequested(false), stereo(false)
 
417
        m_gearsTimer(0), m_testTimer(0), m_cursor(GHOST_kStandardCursorFirstCursor),
 
418
        m_exitRequested(false), stereo(false)
423
419
{
424
420
        fApp = this;
425
421
 
426
422
        // Create the main window
427
 
        STR_String title1 ("gears - main window");
 
423
        STR_String title1("gears - main window");
428
424
        m_mainWindow = system->createWindow(title1, 10, 64, 320, 200, GHOST_kWindowStateNormal,
429
 
                GHOST_kDrawingContextTypeOpenGL, false, false);
 
425
                                            GHOST_kDrawingContextTypeOpenGL, false, false);
430
426
 
431
 
    if (!m_mainWindow) {
 
427
        if (!m_mainWindow) {
432
428
                std::cout << "could not create main window\n";
433
429
                exit(-1);
434
 
    }
 
430
        }
435
431
 
436
432
        // Create a secondary window
437
 
        STR_String title2 ("gears - secondary window");
 
433
        STR_String title2("gears - secondary window");
438
434
        m_secondaryWindow = system->createWindow(title2, 340, 64, 320, 200, GHOST_kWindowStateNormal,
439
 
                GHOST_kDrawingContextTypeOpenGL, false, false);
 
435
                                                 GHOST_kDrawingContextTypeOpenGL, false, false);
440
436
        if (!m_secondaryWindow) {
441
 
                cout << "could not create secondary window\n";
 
437
                std::cout << "could not create secondary window\n";
442
438
                exit(-1);
443
439
        }
444
440
 
445
441
        // Install a timer to have the gears running
446
 
        m_gearsTimer = system->installTimer(0 /*delay*/, 20/*interval*/, gearsTimerProc, m_mainWindow);
 
442
        m_gearsTimer = system->installTimer(0 /*delay*/, 20 /*interval*/, gearsTimerProc, m_mainWindow);
447
443
}
448
444
 
449
445
 
459
455
}
460
456
 
461
457
 
462
 
bool Application::processEvent(GHOST_IEvent* event)
 
458
bool Application::processEvent(GHOST_IEvent *event)
463
459
{
464
 
        GHOST_IWindow* window = event->getWindow();
 
460
        GHOST_IWindow *window = event->getWindow();
465
461
        bool handled = true;
466
462
 
467
463
        switch (event->getType()) {
468
 
/*      case GHOST_kEventUnknown:
 
464
#if 0
 
465
        case GHOST_kEventUnknown:
469
466
                break;
470
467
        case GHOST_kEventCursorButton:
471
468
                std::cout << "GHOST_kEventCursorButton"; break;
472
469
        case GHOST_kEventCursorMove:
473
470
                std::cout << "GHOST_kEventCursorMove"; break;
474
 
*/
475
 
        case GHOST_kEventWheel:
476
 
                {
477
 
                GHOST_TEventWheelData* wheelData = (GHOST_TEventWheelData*) event->getData();
478
 
                if (wheelData->z > 0)
479
 
                {
480
 
                        view_rotz += 5.f;
481
 
                }
482
 
                else
483
 
                {
484
 
                        view_rotz -= 5.f;
485
 
                }
486
 
                }
487
 
                break;
488
 
 
489
 
        case GHOST_kEventKeyUp:
490
 
                break;
491
 
 
492
 
        case GHOST_kEventKeyDown:
493
 
                {
494
 
                GHOST_TEventKeyData* keyData = (GHOST_TEventKeyData*) event->getData();
495
 
                switch (keyData->key) {
496
 
                case GHOST_kKeyC:
497
 
                        {
498
 
                        int cursor = m_cursor;
499
 
                        cursor++;
500
 
                        if (cursor >= GHOST_kStandardCursorNumCursors) {
501
 
                                cursor = GHOST_kStandardCursorFirstCursor;
502
 
                        }
503
 
                        m_cursor = (GHOST_TStandardCursor)cursor;
504
 
                        window->setCursorShape(m_cursor);
505
 
                        }
506
 
                        break;
507
 
 
508
 
                case GHOST_kKeyE:
509
 
                        {
510
 
                        int x = 200, y= 200;
511
 
                        m_system->setCursorPosition(x,y);
512
 
                        break;
513
 
                        }
514
 
 
515
 
                case GHOST_kKeyF:
516
 
                        if (!m_system->getFullScreen()) {
517
 
                                // Begin fullscreen mode
518
 
                                GHOST_DisplaySetting setting;
519
 
                                
520
 
                                setting.bpp = 16;
521
 
                                setting.frequency = 50;
522
 
                                setting.xPixels = 640;
523
 
                                setting.yPixels = 480;
524
 
                                m_system->beginFullScreen(setting, &m_fullScreenWindow, false /* stereo flag */);
525
 
                        }
526
 
                        else {
527
 
                                m_system->endFullScreen();
528
 
                                m_fullScreenWindow = 0;
529
 
                        }
530
 
                        break;
531
 
 
532
 
                case GHOST_kKeyH:
533
 
                        window->setCursorVisibility(!window->getCursorVisibility());
534
 
                        break;
535
 
 
536
 
                case GHOST_kKeyM:
537
 
                        {
538
 
                                bool down = false;
539
 
                                m_system->getModifierKeyState(GHOST_kModifierKeyLeftShift,down);
540
 
                                if (down) {
541
 
                                        std::cout << "left shift down\n";
542
 
                                }
543
 
                                m_system->getModifierKeyState(GHOST_kModifierKeyRightShift,down);
544
 
                                if (down) {
545
 
                                        std::cout << "right shift down\n";                                                                                                                                                                                                                              }
546
 
                                m_system->getModifierKeyState(GHOST_kModifierKeyLeftAlt,down);
547
 
                                if (down) { 
548
 
                                        std::cout << "left Alt down\n";
549
 
                                }
550
 
                                m_system->getModifierKeyState(GHOST_kModifierKeyRightAlt,down);
551
 
                                if (down) {
552
 
                                        std::cout << "right Alt down\n";
553
 
                                }
554
 
                                m_system->getModifierKeyState(GHOST_kModifierKeyLeftControl,down);
555
 
                                if (down) {
556
 
                                        std::cout << "left control down\n";
557
 
                                }
558
 
                                m_system->getModifierKeyState(GHOST_kModifierKeyRightControl,down);
559
 
                                if (down) {
560
 
                                        std::cout << "right control down\n";
561
 
                                }
562
 
                        }
563
 
                        break;
564
 
 
565
 
                case GHOST_kKeyQ:
566
 
                        if (m_system->getFullScreen())
567
 
                        {
568
 
                                m_system->endFullScreen();
569
 
                                m_fullScreenWindow = 0;
570
 
                        }
571
 
                        m_exitRequested = true;
572
 
                        break;
573
 
 
574
 
                case GHOST_kKeyS:  // toggle mono and stereo
575
 
                        if(stereo)
576
 
                                stereo = false;
577
 
                        else
578
 
                                stereo = true;
579
 
                        break;
580
 
 
581
 
                case GHOST_kKeyT:
582
 
                        if (!m_testTimer) {
583
 
                                m_testTimer = m_system->installTimer(0, 1000, testTimerProc);
584
 
                        }
585
 
 
586
 
                        else {
587
 
                                m_system->removeTimer(m_testTimer);
588
 
                                m_testTimer = 0;
589
 
                        }
590
 
 
591
 
                        break;
592
 
 
593
 
                case GHOST_kKeyW:
594
 
                        if (m_mainWindow)
595
 
                        {
596
 
                                STR_String title;
597
 
                                m_mainWindow->getTitle(title);
598
 
                                title += "-";
599
 
                                m_mainWindow->setTitle(title);
600
 
 
601
 
                        }
602
 
                        break;
603
 
 
604
 
                default:
605
 
                        break;
606
 
                }
607
 
                }
608
 
                break;
609
 
 
610
 
        case GHOST_kEventWindowClose:
611
 
                {
612
 
                GHOST_IWindow* window2 = event->getWindow();
613
 
                if (window2 == m_mainWindow) {
614
 
                        m_exitRequested = true;
615
 
                }
616
 
                else {
617
 
                        m_system->disposeWindow(window2);
618
 
                }
619
 
                }
620
 
                break;
621
 
 
622
 
        case GHOST_kEventWindowActivate:
623
 
                handled = false;
624
 
                break;
625
 
 
626
 
        case GHOST_kEventWindowDeactivate:
627
 
                handled = false;
628
 
                break;
629
 
 
630
 
        case GHOST_kEventWindowUpdate:
631
 
                {
632
 
                        GHOST_IWindow* window2 = event->getWindow();
633
 
                        if(!m_system->validWindow(window2))
 
471
 #endif
 
472
                case GHOST_kEventWheel:
 
473
                {
 
474
                        GHOST_TEventWheelData *wheelData = (GHOST_TEventWheelData *) event->getData();
 
475
                        if (wheelData->z > 0)
 
476
                        {
 
477
                                view_rotz += 5.f;
 
478
                        }
 
479
                        else {
 
480
                                view_rotz -= 5.f;
 
481
                        }
 
482
                }
 
483
                break;
 
484
 
 
485
                case GHOST_kEventKeyUp:
 
486
                        break;
 
487
 
 
488
                case GHOST_kEventKeyDown:
 
489
                {
 
490
                        GHOST_TEventKeyData *keyData = (GHOST_TEventKeyData *) event->getData();
 
491
                        switch (keyData->key) {
 
492
                                case GHOST_kKeyC:
 
493
                                {
 
494
                                        int cursor = m_cursor;
 
495
                                        cursor++;
 
496
                                        if (cursor >= GHOST_kStandardCursorNumCursors) {
 
497
                                                cursor = GHOST_kStandardCursorFirstCursor;
 
498
                                        }
 
499
                                        m_cursor = (GHOST_TStandardCursor)cursor;
 
500
                                        window->setCursorShape(m_cursor);
 
501
                                }
 
502
                                break;
 
503
 
 
504
                                case GHOST_kKeyE:
 
505
                                {
 
506
                                        int x = 200, y = 200;
 
507
                                        m_system->setCursorPosition(x, y);
 
508
                                        break;
 
509
                                }
 
510
 
 
511
                                case GHOST_kKeyF:
 
512
                                        if (!m_system->getFullScreen()) {
 
513
                                                // Begin fullscreen mode
 
514
                                                GHOST_DisplaySetting setting;
 
515
 
 
516
                                                setting.bpp = 16;
 
517
                                                setting.frequency = 50;
 
518
                                                setting.xPixels = 640;
 
519
                                                setting.yPixels = 480;
 
520
                                                m_system->beginFullScreen(setting, &m_fullScreenWindow, false /* stereo flag */);
 
521
                                        }
 
522
                                        else {
 
523
                                                m_system->endFullScreen();
 
524
                                                m_fullScreenWindow = 0;
 
525
                                        }
 
526
                                        break;
 
527
 
 
528
                                case GHOST_kKeyH:
 
529
                                        window->setCursorVisibility(!window->getCursorVisibility());
 
530
                                        break;
 
531
 
 
532
                                case GHOST_kKeyM:
 
533
                                {
 
534
                                        bool down = false;
 
535
                                        m_system->getModifierKeyState(GHOST_kModifierKeyLeftShift, down);
 
536
                                        if (down) {
 
537
                                                std::cout << "left shift down\n";
 
538
                                        }
 
539
                                        m_system->getModifierKeyState(GHOST_kModifierKeyRightShift, down);
 
540
                                        if (down) {
 
541
                                                std::cout << "right shift down\n";
 
542
                                        }
 
543
                                        m_system->getModifierKeyState(GHOST_kModifierKeyLeftAlt, down);
 
544
                                        if (down) {
 
545
                                                std::cout << "left Alt down\n";
 
546
                                        }
 
547
                                        m_system->getModifierKeyState(GHOST_kModifierKeyRightAlt, down);
 
548
                                        if (down) {
 
549
                                                std::cout << "right Alt down\n";
 
550
                                        }
 
551
                                        m_system->getModifierKeyState(GHOST_kModifierKeyLeftControl, down);
 
552
                                        if (down) {
 
553
                                                std::cout << "left control down\n";
 
554
                                        }
 
555
                                        m_system->getModifierKeyState(GHOST_kModifierKeyRightControl, down);
 
556
                                        if (down) {
 
557
                                                std::cout << "right control down\n";
 
558
                                        }
 
559
                                }
 
560
                                break;
 
561
 
 
562
                                case GHOST_kKeyQ:
 
563
                                        if (m_system->getFullScreen())
 
564
                                        {
 
565
                                                m_system->endFullScreen();
 
566
                                                m_fullScreenWindow = 0;
 
567
                                        }
 
568
                                        m_exitRequested = true;
 
569
                                        break;
 
570
 
 
571
                                case GHOST_kKeyS: // toggle mono and stereo
 
572
                                        if (stereo)
 
573
                                                stereo = false;
 
574
                                        else
 
575
                                                stereo = true;
 
576
                                        break;
 
577
 
 
578
                                case GHOST_kKeyT:
 
579
                                        if (!m_testTimer) {
 
580
                                                m_testTimer = m_system->installTimer(0, 1000, testTimerProc);
 
581
                                        }
 
582
 
 
583
                                        else {
 
584
                                                m_system->removeTimer(m_testTimer);
 
585
                                                m_testTimer = 0;
 
586
                                        }
 
587
 
 
588
                                        break;
 
589
 
 
590
                                case GHOST_kKeyW:
 
591
                                        if (m_mainWindow)
 
592
                                        {
 
593
                                                STR_String title;
 
594
                                                m_mainWindow->getTitle(title);
 
595
                                                title += "-";
 
596
                                                m_mainWindow->setTitle(title);
 
597
 
 
598
                                        }
 
599
                                        break;
 
600
 
 
601
                                default:
 
602
                                        break;
 
603
                        }
 
604
                }
 
605
                break;
 
606
 
 
607
                case GHOST_kEventWindowClose:
 
608
                {
 
609
                        GHOST_IWindow *window2 = event->getWindow();
 
610
                        if (window2 == m_mainWindow) {
 
611
                                m_exitRequested = true;
 
612
                        }
 
613
                        else {
 
614
                                m_system->disposeWindow(window2);
 
615
                        }
 
616
                }
 
617
                break;
 
618
 
 
619
                case GHOST_kEventWindowActivate:
 
620
                        handled = false;
 
621
                        break;
 
622
 
 
623
                case GHOST_kEventWindowDeactivate:
 
624
                        handled = false;
 
625
                        break;
 
626
 
 
627
                case GHOST_kEventWindowUpdate:
 
628
                {
 
629
                        GHOST_IWindow *window2 = event->getWindow();
 
630
                        if (!m_system->validWindow(window2))
634
631
                                break;
635
632
 
636
633
                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
637
634
 
638
 
                        if(stereo)
 
635
                        if (stereo)
639
636
                        {
640
637
                                View(window2, stereo, LEFT_EYE);
641
638
                                glPushMatrix();
649
646
                                RenderScene();
650
647
                                glPopMatrix();
651
648
                        }
652
 
                        else
653
 
                        {
 
649
                        else {
654
650
                                View(window2, stereo);
655
651
                                glPushMatrix();
656
652
                                RenderCamera();
661
657
                }
662
658
                break;
663
659
                
664
 
        default:
665
 
                handled = false;
666
 
                break;
 
660
                default:
 
661
                        handled = false;
 
662
                        break;
667
663
        }
668
664
        return handled;
669
665
}
670
666
 
671
667
 
672
 
int main(int /*argc*/, char** /*argv*/)
 
668
int main(int /*argc*/, char ** /*argv*/)
673
669
{
674
670
        nVidiaWindows = false;
675
671
//      nVidiaWindows = true;
678
674
        /* Set a couple of settings in the registry for the nVidia detonator driver.
679
675
         * So this is very specific...
680
676
         */
681
 
        if(nVidiaWindows)
 
677
        if (nVidiaWindows)
682
678
        {
683
679
                LONG lresult;
684
680
                HKEY hkey = 0;
691
687
                lresult = regkey.Open(HKEY_LOCAL_MACHINE, "SOFTWARE\\NVIDIA Corporation\\Global\\Stereo3D\\StereoEnable",
692
688
                                      KEY_ALL_ACCESS);
693
689
 
694
 
                if(lresult == ERROR_SUCCESS)
 
690
                if (lresult == ERROR_SUCCESS)
695
691
                        printf("Succesfully opened key\n");
696
692
#if 0
697
693
                lresult = regkey.QueryValue(&keyValue, "StereoEnable");
698
 
                if(lresult == ERROR_SUCCESS)
 
694
                if (lresult == ERROR_SUCCESS)
699
695
                        printf("Succesfully queried key\n");
700
696
#endif
701
697
                lresult = regkey.SetValue(HKEY_LOCAL_MACHINE, "SOFTWARE\\NVIDIA Corporation\\Global\\Stereo3D\\StereoEnable",
702
 
                                "1");
703
 
                if(lresult == ERROR_SUCCESS)
 
698
                                          "1");
 
699
                if (lresult == ERROR_SUCCESS)
704
700
                        printf("Succesfully set value for key\n");
705
701
                regkey.Close();
706
 
                if(lresult == ERROR_SUCCESS)
 
702
                if (lresult == ERROR_SUCCESS)
707
703
                        printf("Succesfully closed key\n");
708
704
//              regkey.Write("2");
709
705
        }
715
711
 
716
712
        if (fSystem) {
717
713
                // Create an application object
718
 
                Application app (fSystem);
 
714
                Application app(fSystem);
719
715
 
720
716
                // Add the application as event consumer
721
717
                fSystem->addEventConsumer(&app);
722
718
                
723
719
                // Enter main loop
724
720
                while (!app.m_exitRequested) {
725
 
            //printf("main: loop\n");
 
721
                        //printf("main: loop\n");
726
722
                        fSystem->processEvents(true);
727
723
                        fSystem->dispatchEvents();
728
724
                }
735
731
}
736
732
 
737
733
 
738
 
static void gearsTimerProc(GHOST_ITimerTask* task, GHOST_TUns64 /*time*/)
 
734
static void gearsTimerProc(GHOST_ITimerTask *task, GHOST_TUns64 /*time*/)
739
735
{
740
 
    fAngle += 2.0;
741
 
    view_roty += 1.0;
742
 
        GHOST_IWindow* window = (GHOST_IWindow*)task->getUserData();
 
736
        fAngle += 2.0;
 
737
        view_roty += 1.0;
 
738
        GHOST_IWindow *window = (GHOST_IWindow *)task->getUserData();
743
739
        if (fApp->m_fullScreenWindow) {
744
740
                // Running full screen
745
741
                fApp->m_fullScreenWindow->invalidate();