Quadrotor

////////////////////////////////////////////////////////////////////////////

//        File:                GLTestWnd.cpp

//        Author:                Changchang Wu

//        Description : implementation of the GLTestWnd class.

//

//

//

//        Copyright (c) 2007 University of North Carolina at Chapel Hill

//        All Rights Reserved

//

//        Permission to use, copy, modify and distribute this software and its

//        documentation for educational, research and non-profit purposes, without

//        fee, and without a written agreement is hereby granted, provided that the

//        above copyright notice and the following paragraph appear in all copies.

//        

//        The University of North Carolina at Chapel Hill make no representations

//        about the suitability of this software for any purpose. It is provided

//        'as is' without express or implied warranty. 

//

//        Please send BUG REPORTS to ccwu@cs.unc.edu

//

////////////////////////////////////////////////////////////////////////////

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#include <windowsx.h>

#include "GL/gl.h"

#include <stdlib.h>

/////////////////////////

#include "BasicTestWin.h"

#include "GLTestWnd.h"

#ifdef _WINDOWS

int APIENTRY WinMain(HINSTANCE hInstance,   HINSTANCE hPrevInstance,

                     LPSTR     lpCmdLine,   int       nCmdShow)

{

    //////////////////////////////////////////

        //create a window

        GLTestWnd win(lpCmdLine);

#else

int main(int argc, char** argv)

{

    GLTestWnd win(argc, argv);

#endif

    ///////////////////////////////////////    

    MSG msg;    //

        while (GetMessage(&msg, NULL, 0, 0)) 

        {

                TranslateMessage(&msg);

                DispatchMessage(&msg);        

        //on idle

                if(PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE)==0)SendMessage(GetActiveWindow(), WM_MY_IDLE, 0, 0);

        }

        return (int) msg.wParam;

}

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

GLTestWnd::GLTestWnd(LPSTR cmd)

{

        ///////////////////////

        //Parse Command Line

        if(cmd) ParseCommandLine(cmd);

        //////////////////////

        //create the window

    CreateWindowGL();

}

GLTestWnd::GLTestWnd(int argc, char**argv)

{

        BasicTestWin::ParseSiftParam(argc, argv);

    CreateWindowGL();

}

GLTestWnd::~GLTestWnd()

{

}

void GLTestWnd::CreateWindowGL()

{

        _hWndMain = NULL;

    RegisterWindowClass();

        HWND hWnd = CreateWindow("SIFT_GPU_WND", "SIFT_GPU", 

                WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN,

                CW_USEDEFAULT,  CW_USEDEFAULT, 

                600, 450,         NULL, NULL,  NULL,         this);

        ShowWindow(hWnd,  SW_SHOW);

        UpdateWindow(hWnd);

}

LRESULT CALLBACK GLTestWnd::___WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

        static int nWnd=0;

        GLTestWnd *pWnd;

        if(message==WM_CREATE)

        {

        LPCREATESTRUCT cs = (LPCREATESTRUCT)lParam;

                pWnd = (GLTestWnd*)cs->lpCreateParams;

                pWnd->_hWndMain = hWnd;

                SetWindowLong(hWnd,0,(long)(pWnd));

                nWnd++;

        }else if(message== WM_DESTROY)

        {

                pWnd=(GLTestWnd*)GetWindowLong(hWnd,0);

                delete pWnd;

                SetWindowLong(hWnd,0,0);

                nWnd--;

                if(nWnd==0)

                        PostQuitMessage(0);

                pWnd = NULL;

        }else

        {

                pWnd=(GLTestWnd*)GetWindowLong(hWnd,0);

        }

        if(pWnd)

                return pWnd->_WndProc(message,wParam,lParam);

        else

                return DefWindowProc(hWnd, message, wParam, lParam);

}

void GLTestWnd::RegisterWindowClass()

{

    static int registered = 0;

    if(registered) return;

        WNDCLASSEX wcex;

        wcex.cbSize                        = sizeof(WNDCLASSEX); 

        wcex.style                        = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

        wcex.lpfnWndProc        = (WNDPROC)___WndProc;

        wcex.cbClsExtra                = 0;

        wcex.cbWndExtra                = 4;

        wcex.hInstance                = 0;

        wcex.hIcon                        = NULL;

        wcex.hCursor                = LoadCursor(NULL, IDC_ARROW);

        wcex.hbrBackground        = (HBRUSH)(COLOR_WINDOW+1);

        wcex.lpszMenuName        = NULL;;

        wcex.lpszClassName        = "SIFT_GPU_WND";

        wcex.hIconSm                = NULL;

        RegisterClassEx(&wcex);

        registered = 1;

}

LRESULT GLTestWnd::_WndProc(UINT message, WPARAM wParam, LPARAM lParam)

{

        switch (message) 

        {

                case WM_CREATE:

                        {

                if(_win_x !=-1)

                {

                    LPCREATESTRUCT cs = (LPCREATESTRUCT)lParam;

                    MoveWindow(_hWndMain, _win_x, _win_y, cs->cx, cs->cy, 0);

                }

                                SetDisplaySize(600, 450);

                                HDC hdc        =        GetDC(_hWndMain);

                                glCreateRC(hdc);

                                if(_hglrc == NULL) exit(0);

                                ReleaseDC(_hWndMain,hdc);

                        }

                        break;

                case WM_SIZE:

                        {

                                glResize(LOWORD(lParam),HIWORD(lParam));

                        }

                        break;

                case WM_PAINT:

                        {

                                PAINTSTRUCT ps;

                                HDC hdc = BeginPaint(_hWndMain, &ps);

                                ///

                                glPaint(hdc);

                                ///

                                EndPaint(_hWndMain, &ps);

                        }

                        break;

                case WM_CHAR:

                        KeyInput((int) wParam);

                        InvalidateRect(_hWndMain, NULL, FALSE);

                        break;

                case WM_LBUTTONDOWN:

                        {

                                int xPos = GET_X_LPARAM(lParam); 

                                int yPos = GET_Y_LPARAM(lParam); 

                                StartMotion(xPos, yPos);

                        }

                        break;

                case WM_LBUTTONUP:

                        EndMotion();

                        break;

                case WM_MOUSEMOVE:

                        if( wParam & MK_LBUTTON)

                        {

                                int xPos = GET_X_LPARAM(lParam); 

                                int yPos = GET_Y_LPARAM(lParam); 

                                MoveMouse(xPos, yPos);

                        }

                case WM_ERASEBKGND:

                        return TRUE;

                case WM_MY_IDLE:

                        OnIdle();

                        return TRUE;

                case WM_DESTROY:

                        PostQuitMessage(0);

                        break;

                default:

                        return DefWindowProc(_hWndMain, message, wParam, lParam);

        }

        return 0;

}

void GLTestWnd::glCreateRC(HDC hdc)

{

    int pixelformat;

        PIXELFORMATDESCRIPTOR pfd = 

        {

        sizeof(PIXELFORMATDESCRIPTOR),1,                             

        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER,                

        PFD_TYPE_RGBA,24,0, 0, 0, 0, 0, 0,0,0,0,0, 0, 0, 0,16,0,0,                          

        PFD_MAIN_PLANE,0,0, 0, 0                     

    };

    if ((pixelformat = ChoosePixelFormat(hdc, &pfd)) ==0)return ;

    if (SetPixelFormat(hdc, pixelformat, &pfd) == FALSE)return ;

        pixelformat =::GetPixelFormat(hdc);

        ::DescribePixelFormat(hdc, pixelformat, sizeof(pfd), &pfd);

        //

    _hglrc = wglCreateContext(hdc);

        wglMakeCurrent(hdc, _hglrc);

        glMatrixMode(GL_MODELVIEW);

        glLoadIdentity();

        RunSiftGPU();

        wglMakeCurrent(NULL, NULL);

}

void GLTestWnd::glResize(int w, int h)

{

        ReShape(w, h);

}

void GLTestWnd::glPaint(HDC hdc)

{

        wglMakeCurrent(hdc,HGLRC(_hglrc));

        Display();

        SwapBuffers(hdc);

}

void GLTestWnd::ParseCommandLine(LPSTR cmd)

{

        int argc=0;

        char**argv = new char*[256];

        if(*cmd == 0) return;

        do

        {

                while(*cmd ==' ') cmd++;

                if(*cmd)

                {

                        argv[argc++] = cmd;

                }

                while(*cmd && *cmd != ' ') cmd++;

                if(*cmd==' ')        *cmd++ = 0;

        }while(*cmd && argc <256);

        BasicTestWin::ParseSiftParam(argc, argv);

}

void GLTestWnd::SetDisplaySize(int w, int h)

{

        RECT rc;        int dw,  dh;

        GetClientRect(_hWndMain, &rc);

        dw = w - rc.right;

        dh = h - rc.bottom;

        GetWindowRect(_hWndMain, &rc);

        MoveWindow(_hWndMain, rc.left, rc.top, rc.right - rc.left + dw,

                rc.bottom - rc.top + dh, TRUE);

}

void GLTestWnd::SetWindowTitle(char *title)

{

        SetWindowText(_hWndMain, title);

}

void GLTestWnd::UpdateDisplay()

{

        InvalidateRect(_hWndMain, NULL,0);

}