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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
|
#include <windows.h> // Header File For Windows
#include <iostream>
#include <fstream>
#include <stdarg.h> // Header File For Variable Argument Routines
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <gl\gl.h> // Header File For The OpenGL32 Library
#include <gl\glu.h>
// Header File For The GLu32 Library
#include <gl\glaux.h> // Header File For The Glaux Library
using namespace std;
HDC hDC=NULL; // Private GDI Device Context
HGLRC hRC=NULL; // Permanent Rendering Context
HWND hWnd=NULL; // Holds Our Window Handle
HINSTANCE hInstance; // Holds The Instance Of The Application
bool keys[256]; // Array Used For The Keyboard Routine
bool active=TRUE; // Window Active Flag Set To TRUE By Default
bool fullscreen=false; // Fullscreen Flag Set To Fullscreen Mode By Default
bool bKeyUp, bKeyDown; // Determines if a key is pressed
#define RX 200 // Room dimensions
#define RY 150
GLuint base; // Base Display List For The Font
GLvoid glPrint(const char *fmt, ...) // Custom GL "Print" Routine
{
char text[256]; // Holds Our String
va_list ap; // Pointer To List Of Arguments
if (fmt == NULL) // If There’s No Text
return; // Do Nothing
va_start(ap, fmt); // Parses The String For Variables
vsprintf(text, fmt, ap); // And Converts Symbols To Actual Numbers
va_end(ap); // Results Are Stored In Text
glPushAttrib(GL_LIST_BIT); // Pushes The Display List Bits
glListBase(base - 32); // Sets The Base Character to 32
glCallLists(strlen(text), GL_UNSIGNED_BYTE, text); // Draws The Display List Text
glPopAttrib(); // Pops The Display List Bits
}
GLvoid BuildFont() // Build Our Bitmap Font
{
HFONT font; // Windows Font ID
HFONT oldfont; // Used For Good House Keeping
base = glGenLists(96); // Storage For 96 Characters
font = CreateFont( -12, // Height Of Font
0, // Width Of Font
0, // Angle Of Escapement
0, // Orientation Angle
FW_BOLD, // Font Weight
FALSE, // Italic
FALSE, // Underline
FALSE, // Strikeout
ANSI_CHARSET, // Character Set Identifier
OUT_TT_PRECIS, // Output Precision
CLIP_DEFAULT_PRECIS, // Clipping Precision
ANTIALIASED_QUALITY, // Output Quality
FF_DONTCARE|DEFAULT_PITCH, // Family And Pitch
"Arial"); // Font Name
oldfont = (HFONT)SelectObject(hDC, font); // Selects The Font We Want
wglUseFontBitmaps(hDC, 32, 96, base); // Builds 96 Characters Starting At Character 32
SelectObject(hDC, oldfont); // Selects The Font We Want
DeleteObject(font); // Delete The Font
}
GLvoid KillFont(GLvoid) // Delete The Font From Memory
{
glDeleteLists(base,256); // Delete All 256 Display Lists
}
class Vector4 { // Vector class
public:
Vector4::Vector4()
{
return;
};
Vector4::Vector4(float tx, float ty, float tz, float tw)
{
v1 = tx;
v2 = ty;
v3 = tz;
v4 = tw;
return;
};
float Vector4::getV1() { return (v1); };
float Vector4::getV2() { return (v2); };
float Vector4::getV3() { return (v3); };
float Vector4::getV4() { return (v4); };
void Vector4::setV1(float t) { v1 = t; };
void Vector4::setV2(float t) { v2 = t; };
void Vector4::setV3(float t) { v3 = t; };
void Vector4::setV4(float t) { v4 = t; };
private:
float v1,v2,v3,v4;
};
class Source { // Source class
public:
Source::Source(int tx, int ty, float tamp, float tfreq) // Creates a source
{
x = tx;
y = ty;
amp = tamp;
freq = tfreq;
return;
};
void Source::setAmp(float t) { amp = t; }; // Set/get the different values of a source
void Source::setFreq(float t) { freq = t; };
void Source::setX(int t) { x = t; };
void Source::setY(int t) { y = t; };
int Source::getX() { return (x); };
int Source::getY() { return (y); };
float Source::getFreq() { return (freq); };
float Source::getAmp() { return (amp); };
private:
int x, y;
float amp, freq;
};
class Node { // Node Class
public:
Node::Node() // Creates a node with standard wall coefficient
{
in.setV1(0.0f);
in.setV2(0.0f);
in.setV3(0.0f);
in.setV4(0.0f);
out.setV1(0.0f);
out.setV2(0.0f);
out.setV3(0.0f);
out.setV4(0.0f);
setR(0.3f);
setG(0.3f);
setB(0.3f);
return;
};
Node::Node(float w) // Creates a node
{
wall = w;
in.setV1(0.0f);
in.setV2(0.0f);
in.setV3(0.0f);
in.setV4(0.0f);
out.setV1(0.0f);
out.setV2(0.0f);
out.setV3(0.0f);
out.setV4(0.0f);
setR(0.7f);
setG(0.7f);
setB(0.7f);
return;
};
float Node::getR() { return (r); }; // Read and set the color coefficients
float Node::getG() { return (g); };
float Node::getB() { return (b); };
void Node::setR(float t) { r = t; };
void Node::setG(float t) { g = t; };
void Node::setB(float t) { b = t; };
Vector4 Node::getIn() {return (in); }; // Read the energy vectors
Vector4 Node::getOut() {return (out); };
void Node::setW(float t) { wall = t; }; // Set and receiv the wall coefficient
float Node::getW() { return (wall); };
void Node::setIn(Vector4 t) { // Set the enrgy vectors
in.setV1(t.getV1());
in.setV2(t.getV2());
in.setV3(t.getV3());
in.setV4(t.getV4());
}
void Node::setOut(Vector4 t) {
out.setV1(t.getV1());
out.setV2(t.getV2());
out.setV3(t.getV3());
out.setV4(t.getV4());
}
float Node::sumIn() { return (in.getV1() + in.getV2() + in.getV3() + in.getV4()); };
// Sumarizes the total engry presint in a node
void Node::scatter() { // Scatters the energy from a node to another
if(this->getW()>0) {
this->out.setV1(this->in.getV1() * this->getW());
this->out.setV2(this->in.getV2() * this->getW());
this->out.setV3(this->in.getV3() * this->getW());
this->out.setV4(this->in.getV4() * this->getW());
}
else
{
this->out.setV1(0.5f*(-this->in.getV1() + this->in.getV2() + this->in.getV3() + this->in.getV4()));
this->out.setV2(0.5f*(this->in.getV1() - this->in.getV2() + this->in.getV3() + this->in.getV4()));
this->out.setV3(0.5f*(this->in.getV1() + this->in.getV2() - this->in.getV3() + this->in.getV4()));
this->out.setV4(0.5f*(this->in.getV1() + this->in.getV2() + this->in.getV3() - this->in.getV4()));
}
this->in.setV1(0.0f);
this->in.setV2(0.0f);
this->in.setV3(0.0f);
this->in.setV4(0.0f);
};
private:
Vector4 in, out; // Vectors for the energy
float r, g, b; // The colour of a node
float wall; // Wall Coefficient. If 0 the node is not a wall, if 1 the node is a perfectly reflecting wall
};
class Room { // Room class
public:
Room::Room(float tc, float tw, float tb) { // Creates a room with a grid of nodes
c = tc;
time = 0;
tb=tb/2;
for(int i=0; i<RX; i++)
{
for(int j=0; j<RY; j++)
{
if(i<1 || i>RX-2 || j<1 || j>RY-2 ) // Creates the nodes and set the edge nodes as walls
grid[i][j] = Node(tw);
else
grid[i][j] = Node(0.0f);
if(i==130 && (j<(75-tb) || j>(75+tb))) // Adds the wall between the rooms
grid[i][j].setW(tw);
}
}
return;
};
void Room::setC(float t) { c = t; }; // Set/get the values of a room
float Room::getTime() { return (time); };
void Room::setTime(float t) { time = t; };
float Room::getFps() { return (fps); };
void Room::drawRoom() { // Draws the room and sets the colours
for(int x=0; x < RX; x++)
{
for(int y=0; y < RY; y++)
{
if(grid[x][y].getW()>0)
glColor3f(0.0f, 0.0f, 0.0f); // Wall colour
else
glColor3f(grid[x][y].getR(),grid[x][y].getG(),grid[x][y].getB()); // Regular node color
glBegin(GL_QUADS);
glVertex2i(2*x, 2*y); // Left And Up 1 Unit (Top Left)
glVertex2i(2*(x+1), 2*y); // Right And Up 1 Unit (Top Right)
glVertex2i(2*(x+1),2*(y+1)); // Right And Down One Unit (Bottom Right)
glVertex2i(2*x,2*(y+1)); // Left And Down One Unit (Bottom Left)
glEnd();
}
}
};
void Room::collect() { // Collects the incomming energy
for(int i=0; i<RX; i++)
{
for(int j=0; j<RY; j++)
{
if(grid[i][j].getOut().getV1() > 0)
grid[i][j-1].setIn(Vector4(grid[i][j-1].getIn().getV1(), grid[i][j-1].getIn().getV2(),
grid[i][j].getOut().getV1(), grid[i][j-1].getIn().getV4()));
if(grid[i][j].getOut().getV2() > 0)
grid[i-1][j].setIn(Vector4(grid[i-1][j].getIn().getV1(), grid[i-1][j].getIn().getV2(), grid[i-
1][j].getIn().getV3(), grid[i][j].getOut().getV2()));
if(grid[i][j].getOut().getV3() > 0)
grid[i][j+1].setIn(Vector4(grid[i][j].getOut().getV3(), grid[i][j+1].getIn().getV2(),
grid[i][j+1].getIn().getV3(), grid[i][j+1].getIn().getV4()));
if(grid[i][j].getOut().getV4() > 0)
grid[i+1][j].setIn(Vector4(grid[i+1][j].getIn().getV1(), grid[i][j].getOut().getV4(),
grid[i+1][j].getIn().getV3(), grid[i+1][j].getIn().getV4()));
grid[i][j].setOut(Vector4(0.0f, 0.0f, 0.0f, 0.0f));
}
}
};
void Room::scatterNodes() { // Loops through the nodes and calls scatter() in the node class
for(int i=0; i<RX; i++)
{
for(int j=0; j<RY; j++)
{
grid[i][j].scatter();
}
}
};
void Room::setColors() { // Determines the correct color depending on the total energy in a node
for(int i=0; i<RX; i++)
{
for(int j=0; j<RY; j++)
{
float sum = grid[i][j].sumIn();
grid[i][j].setR(0.3f + sum);
grid[i][j].setG(0.3f + sum);
grid[i][j].setB(0.3f + sum);
}
}
};
void Room::addSource(Source t, float time) // Adds the energy from a source to the receiving node
{
grid[t.getX()][t.getY()].setIn(Vector4(grid[t.getX()][t.getY()].getIn().getV1() + (t.getAmp()*sinf(t.getFreq()*time))/4,
grid[t.getX()][t.getY()].getIn().getV2() + (t.getAmp()*sinf(t.getFreq()*time))/4, grid[t.getX()][t.getY()].getIn().getV3() +
(t.getAmp()*sinf(t.getFreq()*time))/4, grid[t.getX()][t.getY()].getIn().getV4() + (t.getAmp()*sinf(t.getFreq()*time))/4 ));
};
void Room::setWallUp() // Increases the wall coefficient
{
for(int i=0; i<RX; i++)
{
for(int j=0; j<RY; j++)
{
if(grid[i][j].getW()>0 && grid[i][j].getW()<1)
grid[i][j].setW(grid[i][j].getW()+0.1f);
}
}
};
void Room::setWallDown() // Decreases the wall coefficient
{
for(int i=0; i<RX; i++)
{
for(int j=0; j<RY; j++)
{
if(grid[i][j].getW()>0.1f)
grid[i][j].setW(grid[i][j].getW()-0.1f);
}
}
};
void Room::microphone(int x, int y, Source t) // Write the results of the microphone to a textfile
{
ofstream debug("microphone.txt", ios::app);
//debug << getTime() << ":" << grid[x][y].sumIn() << "\n";
debug << getTime() << ":" << t.getAmp()*sinf(t.getFreq()*time)/4 << "\n";
debug.close();
};
void Room::calculateFrameRate() // Calculates the frame rate
{
static float framesPerSecond = 0.0f; // This will store our fps
static float lastTime = 0.0f; // This will hold the time from the last frame
float currentTime = GetTickCount() * 0.001f;
++framesPerSecond;
if( currentTime - lastTime > 1.0f )
{
lastTime = currentTime;
fps = framesPerSecond;
framesPerSecond = 0;
}
};
void Room::drawInfo(Source s) { // Draws the info on the screen
glColor3f(1.0f, 1.0f, 1.0f);
glTranslatef(0.0f,0.0f,-1.0f);
glRasterPos2f(420.0f, 290.0f);
glPrint("FPS %7.2f", fps); // Print GL Text To The Screen
glRasterPos2f(420.0f, 270.0f);
glPrint("Time %7.2f", time);
glRasterPos2f(420.0f, 250.0f);
glPrint("Walls %7.2f", grid[0][0].getW()); // Print GL Text To The Screen
glRasterPos2f(420.0f, 230.0f);
glPrint("w %7.2f", s.getFreq()); // Print GL Text To The Screen
glRasterPos2f(420.0f, 210.0f);
glPrint("Amp %7.2f", s.getAmp()); // Print GL Text To The Screen
};
private:
float c, fps; // Speed of sound
float time; // The total running time
Node grid[RX][RY]; // Grid of nodes
};
Room r(340.0f, 1.0f, 20.0f); // Creates a room
Source s(40, 75, 8, 5); // Adds a Source
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc
GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window
{
if (height==0) // Prevent A Divide By Zero By
{
height=1; // Making Height Equal One
}
glViewport(0,0,width,height); // Reset The Current Viewport
glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix
gluOrtho2D(0.0,(GLdouble) 540,0.0,(GLdouble) 320);
glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix
}
int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.5f, 0.5f, 0.5f, 0.5f); // Black Background
BuildFont();
return TRUE;
}
int DrawGLScene(GLvoid) // Here’s Where We Do All The Drawing
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer
glLoadIdentity(); // Resets the view matrix
glTranslatef(10.0f, 10.0f, 0.0f); // Moves the view
r.setTime(r.getTime() + 0.1f); // Increases the time
r.addSource(s, r.getTime()); // Adds the source
r.scatterNodes(); // Scatters the pressure
r.collect(); // Collects the pressure
r.setColors(); // Set the color
//r.microphone(49, 50, s); // Add a microphone at a node
r.drawRoom(); // Draw the room
r.calculateFrameRate(); // Calculate the frame rate
r.drawInfo(s); // Draw the info on the screen
return TRUE; // Keep Going
}
//STANDARD WINDOW CODE, not implemented in this project.
GLvoid KillGLWindow(GLvoid) // Properly Kill The Window
{
if (fullscreen) // Are We In Fullscreen Mode?
{
ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
ShowCursor(TRUE); // Show Mouse Pointer
}
if (hRC) // Do We Have A Rendering Context?
{
if (!wglMakeCurrent(NULL,NULL)) // Are We Able To Release The DC And RC Contexts?
{
MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK |
MB_ICONINFORMATION);
}
if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC?
{
MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK |
MB_ICONINFORMATION);
}
hRC=NULL; // Set RC To NULL
}
if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able To Release The DC
{
MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hDC=NULL; // Set DC To NULL
}
if (hWnd && !DestroyWindow(hWnd)) // Are We Able To Destroy The Window?
{
MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hWnd=NULL; // Set hWnd To NULL
}
if (!UnregisterClass("OpenGL",hInstance)) // Are We Able To Unregister Class
{
MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hInstance=NULL; // Set hInstance To NULL
}
KillFont();
}
/* This Code Creates Our OpenGL Window. Parameters Are: *
* title - Title To Appear At The Top Of The Window *
* width - Width Of The GL Window Or Fullscreen Mode *
* height - Height Of The GL Window Or Fullscreen Mode *
* bits - Number Of Bits To Use For Color (8/16/24/32) *
* fullscreenflag - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE) */
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
GLuint PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
WindowRect.left=(long)0; // Set Left Value To 0
WindowRect.right=(long)width; // Set Right Value To Requested Width
WindowRect.top=(long)0; // Set Top Value To 0
WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height
fullscreen=fullscreenflag; // Set The Global Fullscreen Flag
hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
// Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don’t Want A Menu
wc.lpszClassName = "OpenGL"; // Set The Class Name
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (fullscreen) // Attempt Fullscreen Mode?
{
DEVMODE dmScreenSettings; // Device Mode
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory’s Cleared
dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
dmScreenSettings.dmPelsWidth = width; // Selected Screen Width
dmScreenSettings.dmPelsHeight = height; // Selected Screen Height
dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
// If The Mode Fails, Offer Two Options. Quit Or Use Windowed Mode.
if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
{
fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE
}
else
{
// Pop Up A Message Box Letting User Know The Program Is Closing.
MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
return FALSE; // Return FALSE
}
}
}
if (fullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
}
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
"OpenGL", // Class Name
title, // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
hInstance, // Instance
NULL))) // Dont Pass Anything To
WM_CREATE;
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
bits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can’t Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can’t Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can’t Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can’t Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can’t Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
ShowWindow(hWnd,SW_SHOW); // Show The Window
SetForegroundWindow(hWnd); // Slightly Higher Priority
SetFocus(hWnd); // Sets Keyboard Focus To The Window
ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen
if (!InitGL()) // Initialize Our Newly Created GL Window
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
return TRUE; // Success
}
LRESULT CALLBACK WndProc( HWND hWnd, // Handle For This Window
UINT uMsg, // Message For This Window
WPARAM wParam, // Additional Message Information
LPARAM lParam) // Additional Message Information
{
switch (uMsg) // Check For Windows Messages
{
case WM_ACTIVATE: // Watch For Window Activate Message
{
if (!HIWORD(wParam)) // Check Minimization State
{
active=TRUE; // Program Is Active
}
else
{
active=FALSE; // Program Is No Longer Active
}
return 0; // Return To The Message Loop
}
case WM_SYSCOMMAND: // Intercept System Commands
{
switch (wParam) // Check System Calls
{
case SC_SCREENSAVE: // Screensaver Trying To Start?
case SC_MONITORPOWER: // Monitor Trying To Enter Powersave?
return 0; // Prevent From Happening
}
break; // Exit
}
case WM_CLOSE: // Did We Receive A Close Message?
{
PostQuitMessage(0); // Send A Quit Message
return 0; // Jump Back
}
case WM_KEYDOWN: // Is A Key Being Held Down?
{
keys[wParam] = TRUE; // If So, Mark It As TRUE
return 0; // Jump Back
}
case WM_KEYUP: // Has A Key Been Released?
{
keys[wParam] = FALSE; // If So, Mark It As FALSE
return 0; // Jump Back
}
case WM_SIZE: // Resize The OpenGL Window
{
ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height
return 0; // Jump Back
}
}
// Pass All Unhandled Messages To DefWindowProc
return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
int WINAPI WinMain( HINSTANCE hInstance, // Instance
HINSTANCE hPrevInstance, // Previous Instance
LPSTR lpCmdLine, // Command Line Parameters
int nCmdShow) // Window Show State
{
MSG msg; // Windows Message Structure
BOOL done=FALSE; // Bool Variable To Exit Loop
// Ask The User Which Screen Mode They Prefer
//if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
//{
// fullscreen=FALSE; // Windowed Mode
//}
// Create Our OpenGL Window
if (!CreateGLWindow("Room Acoustics",540,320,16,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
while(!done) // Loop That Runs While done=FALSE
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
{
if (msg.message==WM_QUIT) // Have We Received A Quit Message?
{
done=TRUE; // If So done=TRUE
}
else // If Not, Deal With Window Messages
{
TranslateMessage(&msg); // Translate The Message
DispatchMessage(&msg); // Dispatch The Message
}
}
else // If There Are No Messages
{
// Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene()
if (active) // Program Active?
{
if (keys[VK_ESCAPE]) // Was ESC Pressed?
{
done=TRUE; // ESC Signalled A Quit
}
else // Not Time To Quit, Update Screen
{
DrawGLScene(); // Draw The Scene
SwapBuffers(hDC); // Swap Buffers (Double Buffering)
}
}
if (keys[VK_F1]) // Is F1 Being Pressed?
{
keys[VK_F1]=FALSE; // If So Make Key FALSE
KillGLWindow(); // Kill Our Current Window
fullscreen=!fullscreen; // Toggle Fullscreen / Windowed Mode
// Recreate Our OpenGL Window ( Modified )
if (!CreateGLWindow("Room Acoustics",420,320,16,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
}
if (keys[VK_UP] && !bKeyUp)
{
r.setWallUp();
}
if (!keys[VK_UP]) bKeyUp=false;
if (keys[VK_DOWN] && !bKeyDown)
{
r.setWallDown();
}
if (!keys[VK_DOWN]) bKeyDown=false;
}
}
// Shutdown
KillGLWindow(); // Kill The Window
return (msg.wParam); // Exit The Program
} |
