C:/Users/thebigMuh/Documents/Visual Studio 2005/Projects/Volumizer/Volumizer/RayWnd.cpp

Go to the documentation of this file.

#include "Volumizer.h"

HDC             rayHdc;
HGLRC   rayHglrc;

camera  cam;            
vect    ldir;           
vect    lpos;           

void InitCam()
{
        cam.rotx = 0.0f;
        cam.roty = 0.6f;

        cam.org.x = (float)(volx / 2);
        cam.org.y = (float)(voly / 2);
        cam.org.z = (float)(volz / 2);

        cam.pos.x = cam.org.x + (float)volx * 2.0f;
        cam.pos.y = cam.org.y;
        cam.pos.z = cam.org.z;

        cam.up.x = 0.0f;
        cam.up.y = 0.0f;
        cam.up.z = 1.0f;
}

void InitLight()
{
        lpos.x = 0.625f;
        lpos.y = 0.25f;

        ldir.x = ldir.z = -1.0f;
        ldir.y = 1.0f;

        normalize(ldir);
}

ATOM RegisterRayClass(HINSTANCE hInstance)
{
        WNDCLASSEX wcex;

        wcex.cbSize = sizeof(WNDCLASSEX);

        wcex.style                      = CS_HREDRAW | CS_VREDRAW;
        wcex.lpfnWndProc        = RayProc;
        wcex.cbClsExtra         = 0;
        wcex.cbWndExtra         = 0;
        wcex.hInstance          = hInstance;
        wcex.hIcon                      = NULL;
        wcex.hCursor            = LoadCursor(NULL, IDC_ARROW);
        wcex.hbrBackground      = NULL;
        wcex.lpszMenuName       = NULL;
        wcex.lpszClassName      = L"RayWnd";
        wcex.hIconSm            = NULL;

        return RegisterClassEx(&wcex);
}

void InitRay()
{
        rayHdc = GetDC(wnd_3d);

        PIXELFORMATDESCRIPTOR pfd = { 
    sizeof(PIXELFORMATDESCRIPTOR),    // size of this pfd 
    1,                                // version number 
    PFD_DRAW_TO_WINDOW |              // support window 
    PFD_SUPPORT_OPENGL |              // support OpenGL 
    PFD_DOUBLEBUFFER,                 // double buffered 
    PFD_TYPE_RGBA,                    // RGBA type 
    32,                               // 32-bit 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,                       // accum bits ignored 
    32,                               // 32-bit z-buffer     
    0,                                // no stencil buffer 
    0,                                // no auxiliary buffer 
    PFD_MAIN_PLANE,                   // main layer 
    0,                                // reserved 
    0, 0, 0                           // layer masks ignored 
        }; 
        
        int  iPixelFormat; 

// TODO: Insert better pfd selecting code... too lazy now. //
        

        // get the device context's best, available pixel format match 
        iPixelFormat = ChoosePixelFormat(rayHdc, &pfd); 
 
        // make that match the device context's current pixel format 
        SetPixelFormat(rayHdc, iPixelFormat, &pfd); 

    if (rayHglrc = wglCreateContext( rayHdc ) ) 
        { 
        // try to make it the thread's current rendering context 
        wglMakeCurrent(rayHdc, rayHglrc) ; 
    } 

// All the basic things that never change //

        glEnable(GL_DEPTH_TEST);
        glEnable(GL_POINT_SMOOTH);
        glEnable(GL_LINE_SMOOTH);
        glEnable(GL_TEXTURE_2D);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);

        glDepthFunc(GL_LEQUAL);

        glClearColor(0.0f,0.0f,0.0f,0.0f);

        glLineWidth(1.0f);

        // init our font display lists
        HFONT neuro;

        neuro = CreateFontW(0, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_TT_ONLY_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_DONTCARE, L"Arial");

        SelectObject(rayHdc, neuro);

        wglUseFontOutlines(rayHdc, 0, 255, 1000, 0.0f, 0.0f,  
                WGL_FONT_LINES, NULL); 
}

void DeInitRay()
{
// Kill the context & free it //
    if(rayHglrc = wglGetCurrentContext()) { 
 
        // obtain its associated device context 
        rayHdc = wglGetCurrentDC() ; 
 
        // make the rendering context not current 
        wglMakeCurrent(NULL, NULL) ; 
 
        // release the device context 
        ReleaseDC(wnd_3d, rayHdc) ; 
 
        // delete the rendering context 
        wglDeleteContext(rayHglrc); 
    } 
}

void DrawGrid()
{
        glLineWidth(0.3f);

        glColor3f(0.5f, 0.5f, 0.5f);

        glBegin(GL_LINES);

        for (unsigned int x = 0; x <= volx; x += 10)
        {
                glVertex3i(x, 0, 0);
                glVertex3i(x, voly, 0);

                glVertex3i(x, 0, 0);
                glVertex3i(x, 0, volz);
        }

        for (unsigned int y = 0; y <= voly; y += 10)
        {
                glVertex3i(0, y, 0);
                glVertex3i(volx, y, 0);

                glVertex3i(0, y, 0);
                glVertex3i(0, y, volz);
        }

        for (unsigned int z = 0; z <= volz; z += 10)
        {
                glVertex3i(0, 0, z);
                glVertex3i(0, voly, z);

                glVertex3i(0, 0, z);
                glVertex3i(volx, 0, z);
        }

        glColor3f(1.0f, 0.0f, 0.0f);
        glVertex3f(0, 0, 0);
        glVertex3f((float)volx, 0, 0);

        glColor3f(0.0f, 1.0f, 0.0f);
        glVertex3f(0, 0, 0);
        glVertex3f(0, (float)voly, 0);

        glColor3f(0.0f, 0.0f, 1.0f);
        glVertex3f(0, 0, 0);
        glVertex3f(0, 0, (float)volz);

        glEnd();
}

void DrawLight()
{
        glLineWidth(3.0f);
        glBegin(GL_LINES);
                glColor3f(1.0f, 1.0f, 0.0f);
                glVertex3f(ldir.x * -50.0f, ldir.y * -50.0f, ldir.z * -50.0f);

                glColor3f(0.5f, 0.5f, 0.0f);
                glVertex3f(0.0f, 0.0f, 0.0f);
        glEnd();
        glLineWidth(1.0f);
}

void DrawRay()
{
        wglMakeCurrent(rayHdc, rayHglrc);

        RECT clientRect;
        GetClientRect(wnd_3d, &clientRect);

        glViewport(0, 0, clientRect.right, clientRect.bottom);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        float windowaspect = (float)clientRect.right / (float)clientRect.bottom;

        gluPerspective(60.0, windowaspect, 1.0, 10000.0);

        vect dir;
        dir.x = cam.org.x - cam.pos.x;
        dir.y = cam.org.y - cam.pos.y;
        dir.z = cam.org.z - cam.pos.z;

        normalize(dir);

        vect up;
        up.x = 0.0f;
        up.y = 0.0f;
        up.z = 1.0f;

        vect right;
        right = cross(dir, up);
        normalize(right);

        cam.up = cross(right, dir);

        gluLookAt((double)cam.pos.x, (double)cam.pos.y, (double)cam.pos.z, 
                (double)cam.org.x, (double)cam.org.y, (double)cam.org.z,
                cam.up.x, cam.up.y, cam.up.z);

        glMatrixMode(GL_MODELVIEW);
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        DrawGrid();

        DrawLight();

        glFinish();

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        gluOrtho2D(0, clientRect.right, clientRect.bottom, 0.0f);

        glMatrixMode(GL_MODELVIEW);

        glClear(GL_DEPTH_BUFFER_BIT);

        glFinish();

        SwapBuffers(rayHdc);
}

LRESULT CALLBACK RayProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        PAINTSTRUCT ps;
        HDC hdc;

        static POINT spos;

        switch (message)
        {
        case WM_LBUTTONDOWN:
        case WM_MBUTTONDOWN:
        case WM_RBUTTONDOWN:
                SetCapture(hWnd);
                GetCursorPos(&spos);
                break;
        case WM_LBUTTONUP:
        case WM_MBUTTONUP:
        case WM_RBUTTONUP:
                ReleaseCapture();

                RayRender();

                break;
        case WM_MOUSEMOVE:
                POINT mpos;

                if (GetCapture() == hWnd)
                {
                        GetCursorPos(&mpos);
                        
                        if ((wParam & MK_LBUTTON) && (wParam & MK_RBUTTON))
                        {
                                lpos.x -= (float)(mpos.x - spos.x) / 500.0f;
                                lpos.y += (float)(mpos.y - spos.y) / 500.0f;

                                if (lpos.y >= 0.99f)
                                        lpos.y = 0.99f;

                                if (lpos.y <= 0.01f)
                                        lpos.y = 0.01f;

                                float t = 2.0f * lpos.y - 1.0f;

                                float st = sqrt(1.0f - t*t);

                                float phirad = (float)fmod(lpos.x, 1.0f) * -2.0f * (float)M_PI;

                                ldir.x = st * cos(phirad);
                                ldir.y = st * sin(phirad);
                                ldir.z = t;

                                normalize(ldir);
                        }
                        else if (wParam & MK_LBUTTON)
                        {
                                cam.rotx += (float)(mpos.x - spos.x) / 500.0f;
                                cam.roty += (float)(mpos.y - spos.y) / 500.0f;

                                if (cam.roty >= 0.99f)
                                        cam.roty = 0.99f;

                                if (cam.roty <= 0.01f)
                                        cam.roty = 0.01f;

                                float t, st, phirad, dist;

                                vect dir;
                                dir.x = cam.org.x - cam.pos.x;
                                dir.y = cam.org.y - cam.pos.y;
                                dir.z = cam.org.z - cam.pos.z;

                                dist = norm(dir);

                                t = 2.0f * cam.roty - 1.0f;
                                
                                st = sqrt(1.0f - t*t);
                                
                                phirad = (float)fmod(cam.rotx, 1.0f) * -2.0f * (float)M_PI;

                                cam.pos.x = cam.org.x + (st * cos(phirad)) * dist;
                                cam.pos.y = cam.org.y + (st * sin(phirad)) * dist;
                                cam.pos.z = cam.org.z + t * dist;
                        }
                        else if (wParam & MK_RBUTTON)
                        {
                                vect dir;
                                dir.x = cam.org.x - cam.pos.x;
                                dir.y = cam.org.y - cam.pos.y;
                                dir.z = cam.org.z - cam.pos.z;

                                float dy = (float)(mpos.y - spos.y);

                                cam.pos.x += dir.x * dy / 100.0f;
                                cam.pos.y += dir.y * dy / 100.0f;
                                cam.pos.z += dir.z * dy / 100.0f;
                        }
                        else if (wParam & MK_MBUTTON)
                        {
                                vect dir;
                                dir.x = cam.org.x - cam.pos.x;
                                dir.y = cam.org.y - cam.pos.y;
                                dir.z = cam.org.z - cam.pos.z;

                                vect right = cross(cam.up, dir);
                                normalize(right);

                                vect up = cross(dir, right);
                                normalize(up);

                                right.x *= (float)(mpos.x - spos.x) / 5.0f;
                                right.y *= (float)(mpos.x - spos.x) / 5.0f;
                                right.z *= (float)(mpos.x - spos.x) / 5.0f;

                                up.x *= (float)(mpos.y - spos.y) / 5.0f;
                                up.y *= (float)(mpos.y - spos.y) / 5.0f;
                                up.z *= (float)(mpos.y - spos.y) / 5.0f;

                                cam.pos.x += right.x + up.x;
                                cam.pos.y += right.y + up.y;
                                cam.pos.z += right.z + up.z;

                                cam.org.x += right.x + up.x;
                                cam.org.y += right.y + up.y;
                                cam.org.z += right.z + up.z;
                        }

                        DrawRay();

                        spos = mpos;
                }
                break;
        case WM_PAINT:
                hdc = BeginPaint(hWnd, &ps);
                DrawRay();
                EndPaint(hWnd, &ps);
                break;
        case WM_SHOWWINDOW:
                InitRay();
                break;
        case WM_DESTROY:
                DeInitRay();
                PostQuitMessage(0);
                break;
        default:
                return DefWindowProc(hWnd, message, wParam, lParam);
        }
        return 0;
}

---