Jeff Molofee - NeHe's OpenGL Tutorials

// 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

}

}

}

WinMain() starts out the same as always. Ask the user if they want fullscreen or not, then start the loop.

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("Andreas Löffler, Rob Fletcher & NeHe's Blitter & Raw Image Loading Tutorial", 640, 480, 32, 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

}

}

I have made some changes to the code below. If the program is not active (minimized) we wait for a message with the command WaitMessage(). Everything stops until the program receives a message (usually maximizing the window). What this means is that the program no longer hogs the processor while it's minimized. Thanks to Jim Strong for the suggestion.

if (!active) // Program Inactive?

{

WaitMessage(); // Wait For A Message / Do Nothing (NEW … Thanks Jim Strong)

}

if (keys[VK_ESCAPE]) // Was Escape Pressed?

{

done=TRUE; // ESC Signalled A Quit

}

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

if (!CreateGLWindow("Andreas Löffler, Rob Fletcher & NeHe's Blitter & Raw Image Loading Tutorial", 640, 480, 16, fullscreen)) {

return 0; // Quit If Window Was Not Created

}

}

DrawGLScene(); // Draw The Scene

SwapBuffers(hDC); // Swap Buffers (Double Buffering)

}

// Shutdown

KillGLWindow(); // Kill The Window

return (msg.wParam); // Exit The Program

}

Well, that_s it! Now the doors are open for creating some very cool blending effects for your games, engines or even applications. With texture buffers we used in this tutorial you could do more cool effects like real-time plasma or water. When combining these effects all together you_re able to do nearly photo-realistic terrain. If something doesn_t work in this tutorial or you have suggestions how to do it better, then please don_t hesitate to E-Mail me. Thank you for reading and good luck in creating your own special effects!

Some information about Andreas: I'm an 18 years old pupil who is currently studying to be a software engineer. I_ve been programming for nearly 10 years now. I've been programming in OpenGL for about 1.5 years.

* DOWNLOAD Visual C++Code For This Lesson.

* DOWNLOAD Linux/GLXCode For This Lesson. (Conversion by Rodolphe Suescun)

Collision Detection and Physically Based Modeling Tutorial by Dimitrios Christopoulos (christop@fhw.gr).

The source code upon which this tutorial is based, is from an older contest entry of mine (at OGLchallenge.dhs.org). The theme was Collision Crazy and my entry (which by the way took the 1st place :)) was called Magic Room. It features collision detection, physically based modeling and effects.

A difficult subject and to be honest as far as I have seen up until now, there has been no easy solution for it. For every application there is a different way of finding and testing for collisions. Of course there are brute force algorithms which are very general and would work with any kind of objects, but they are expensive.

We are going to investigate algorithms which are very fast, easy to understand and to some extent quite flexible. Furthermore importance must be given on what to do once a collision is detected and how to move the objects, in accordance to the laws of physics. We have a lot stuff to cover. Lets review what we are going to learn:

1) Collision Detection

• Moving Sphere — Plane

• Moving Sphere — Cylinder

• Moving Sphere — Moving Sphere

2) Physically Based Modeling

• Collision Response

• Moving Under Gravity Using Euler Equations

3) Special Effects

• Explosion Modeling Using A Fin-Tree Billboard Method

• Sounds Using The Windows Multimedia Library (Windows Only)

4) Explanation Of The Code

• The Code Is Divided Into 5 Files

Lesson30.cpp: Main Code For This Tutorial

Image.cpp, Image.h: Code To Load Bitmaps

Tmatrix.cpp, Tmatrix.h: Classes To Handle Rotations

Tray.cpp, Tray.h: Classes To Handle Ray Operations

Tvector.cpp, Tvector.h: Classes To Handle Vector Operations

A lot of handy code! The Vector, Ray and Matrix classes are very useful. I used them until now for personal projects of my own.

For the collision detection we are going to use algorithms which are mostly used in ray tracing. Lets first define a ray.

A ray using vector representation is represented using a vector which denotes the start and a vector (usually normalized) which is the direction in which the ray travels. Essentially a ray starts from the start point and travels in the direction of the direction vector. So our ray equation is:

PointOnRay = Raystart + t * Raydirection

t is a float which takes values from [0, infinity).

With 0 we get the start point and substituting other values we get the corresponding points along the ray. PointOnRay, Raystart, Raydirection, are 3D Vectors with values (x,y,z). Now we can use this ray representation and calculate the intersections with plane or cylinders.