Thread: OpenGL rendering problem

Hey all, I want to know how I can create a window and use OpenGL only in a certain portion of the window(The rendering area, not just the viewport.) Meaning if I created a window, I want the window background to show on half the screen and the OpenGL rendering planes and screen on the other half. How would I go about doing this?

All you need to do is call glViewPort before each render call. The first x and y coordinates specify the lower left corner, the next specify the dimensions of the window.

will that limit the actual size of the openGL drawing state. Meaning, if I call glViewport(which I have) will it be visible without drawing that it will not fill the entire window. Will the Clear screen color still be spanned across the window?

It will draw to the viewport defined by glViewport without drawing on the rest of the window. You've said you've already done it, so why are you re-asking me?

Hmm.. Let me try to explain this.. I've used GlViewport and the results do only draw on the specified portion of the window yes, however the black/whatever color background remains the same. I want to display a portion of the windows backcolor while the entire opengl portion of the window is on the other side. The current way I use GlViewport or any other way I use it doesn't affect the entire OpenGL portion of the window.

Originally Posted by indigo0086

You'd have to do something like

Code:

glViewport(0, 0, w/2, h);
.
.
.//projection and rendering settings for first half of window
glViewport(w/2, 0, w, h);
.
.
.//projection and rendering settings for second half.

You're essentially telling OpenGL to draw two viewports in one window, each taking half of the screen's width. You'd have to give each one a projection setting and rendering settings. I'm not sure if you can connect one viewport with another, i.e. have one viewport project one angle of a scene while the other projects another.

I appreciate your response, however I don't think you have understood what I want to do. I'm creating an editor for some levels for a game I'm making. However the only area I want to be OpenGL used is the center left side of the screen. I want the entire right side of the window to basically be window controls(Text boxes, etc..) If you've seen a modeling program, that's basically what I want. Rendering in one portion. Window background with windows texts and controls in the other.
I've already got menus, however I think if i put any controls, they will just be hidden due to OpenGLs background clearscreen color.

Maybe my code will help explain what I want to do:

Code:

#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN

#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>

#include "MenuIds.h"

bool exiting = false;
long windowWidth = 800;
long windowHeight = 600;
long windowBits = 32;
bool fullscreen = false;
HDC hDC;

char ClassName[] = {"WindowsClassName1"};

void SetupPixelFormat(HDC hDC)
{
    int pixelFormat;

    PIXELFORMATDESCRIPTOR pfd =
    {   
        sizeof(PIXELFORMATDESCRIPTOR),  // size
            1,                          // version
            PFD_SUPPORT_OPENGL |        // OpenGL window
            PFD_DRAW_TO_WINDOW |        // render to window
            PFD_DOUBLEBUFFER,           // support double-buffering
            PFD_TYPE_RGBA,              // color type
            32,                         // prefered color depth
            0, 0, 0, 0, 0, 0,           // color bits (ignored)
            0,                          // no alpha buffer
            0,                          // alpha bits (ignored)
            0,                          // no accumulation buffer
            0, 0, 0, 0,                 // accum bits (ignored)
            16,                         // depth buffer
            0,                          // no stencil buffer
            0,                          // no auxiliary buffers
            PFD_MAIN_PLANE,             // main layer
            0,                          // reserved
            0, 0, 0,                    // no layer, visible, damage masks
    };

    pixelFormat = ChoosePixelFormat(hDC, &pfd);
    SetPixelFormat(hDC, pixelFormat, &pfd);
}

LRESULT CALLBACK MainWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    static HDC hDC;
    static HGLRC hRC;
    int height, width;

    // dispatch messages
    switch (uMsg)
    {   
    case WM_CREATE:         // window creation
        hDC = GetDC(hWnd);
        
        SetupPixelFormat(hDC);
        
        hRC = wglCreateContext(hDC);
        
        wglMakeCurrent(hDC, hRC);
                            
        HMENU MainMenu;
        HMENU FileMenu;
                
        MainMenu=CreateMenu();  
        FileMenu=CreateMenu();  
        AppendMenu(FileMenu,MF_STRING,ID_New,"&New");  
        AppendMenu(FileMenu,MF_STRING,ID_Load,"&Load");  
        AppendMenu(FileMenu,MF_STRING,ID_Close,"&Close");
        AppendMenu(FileMenu,MF_STRING,ID_Save, "&Save");
        AppendMenu(FileMenu,MF_STRING,ID_SaveAs, "S&ave As..");
        AppendMenu(FileMenu,MF_SEPARATOR,0,"");  
        AppendMenu(FileMenu,MF_STRING,ID_Exit,"E&xit"); 
        InsertMenu(MainMenu,ID_File,MF_POPUP,(UINT)FileMenu,"File");  
                
        HMENU SubMenus;
        SubMenus = CreateMenu();
                
        AppendMenu(SubMenus,MF_STRING,ID_Wall,"&Wall");  
        AppendMenu(SubMenus,MF_STRING,ID_Floor,"&Floor");  
        AppendMenu(SubMenus,MF_STRING,ID_Stair,"&Stair");
        InsertMenu(MainMenu,ID_Create,MF_POPUP,(UINT)SubMenus,"Create");  
                
        HMENU SubMenus2;
        SubMenus2 = CreateMenu();
                
        AppendMenu(SubMenus2,MF_STRING,ID_Undo,"&Undo");  
        AppendMenu(SubMenus2,MF_STRING,ID_Redo,"&Redo");
        AppendMenu(SubMenus2,MF_SEPARATOR,0,"");
        AppendMenu(SubMenus2,MF_STRING,ID_Properties,"&Properties");
        InsertMenu(MainMenu,ID_Edit,MF_POPUP,(UINT)SubMenus2,"Edit"); 
                
        HMENU SubMenus3;
        SubMenus3 = CreateMenu();
                
        AppendMenu(SubMenus3,MF_STRING,ID_Wireframe,"&Wireframe");  
        AppendMenu(SubMenus3,MF_STRING | MF_CHECKED,ID_Textured,"&Textured");  
        AppendMenu(SubMenus3,MF_STRING,ID_Regular,"&Regular");
        AppendMenu(SubMenus3,MF_SEPARATOR,0,"");  
        AppendMenu(SubMenus3,MF_STRING,ID_ResetView,"R&eset View"); 
        AppendMenu(SubMenus3,MF_SEPARATOR,0,"");   
        AppendMenu(SubMenus3,MF_STRING,ID_TopView,"&Top View");  
        AppendMenu(SubMenus3,MF_STRING,ID_XView,"&X View");
        AppendMenu(SubMenus3,MF_STRING,ID_ZView,"&Z View");
        InsertMenu(MainMenu,ID_View,MF_POPUP,(UINT)SubMenus3,"View");   
                
        HMENU SubMenus4;
        SubMenus4 = CreateMenu();
                
        AppendMenu(SubMenus4,MF_STRING,ID_Overview,"&Overview");  
        InsertMenu(MainMenu,ID_Help,MF_POPUP,(UINT)SubMenus4,"Help"); 
                
        if (!SetMenu(hWnd,MainMenu)) {    return FALSE; }
        
        break;

    case WM_DESTROY:            // window destroy
    case WM_QUIT:
    case WM_CLOSE:                  // windows is closing

        // deselect rendering context and delete it
        wglMakeCurrent(hDC, NULL);
        wglDeleteContext(hRC);

        // send WM_QUIT to message queue
        PostQuitMessage(0);
        break;

    case WM_SIZE:
        windowHeight = HIWORD(lParam);        // retrieve width and height
        windowWidth = LOWORD(lParam);
        
        >>>>> Does not solve problem >>> glViewport(0, 0, windowWidth - 300, windowHeight);        // reset the viewport to new dimensions
        glMatrixMode(GL_PROJECTION);            // set projection matrix current matrix
        glLoadIdentity();                       // reset projection matrix

        // calculate aspect ratio of window
        gluPerspective(52.0f,(GLfloat)windowWidth/(GLfloat)windowHeight,1.0f,1000.0f);

        break;

    case WM_ACTIVATEAPP:        // activate app
        break;

    case WM_PAINT:              // paint
        PAINTSTRUCT ps;
        BeginPaint(hWnd, &ps);
        EndPaint(hWnd, &ps);
        break;

    case WM_LBUTTONDOWN:        // left mouse button
        break;

    case WM_RBUTTONDOWN:        // right mouse button
        break;

    case WM_MOUSEMOVE:          // mouse movement
        break;

    case WM_LBUTTONUP:          // left button release
        break;

    case WM_RBUTTONUP:          // right button release
        break;

    case WM_KEYUP:
        break;

    case WM_KEYDOWN:

        break;

    default:
        break;
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    WNDCLASSEX windowClass;     // window class
    HWND       hwnd;            // window handle
    MSG        msg;             // message
    DWORD      dwExStyle;       // Window Extended Style
    DWORD      dwStyle;         // Window Style
    RECT       windowRect;

    windowRect.left=(long)0;                        // Set Left Value To 0
    windowRect.right=(long)windowWidth; // Set Right Value To Requested Width
    windowRect.top=(long)0;                         // Set Top Value To 0
    windowRect.bottom=(long)windowHeight;   // Set Bottom Value To Requested Height

    // fill out the window class structure
    windowClass.cbSize          = sizeof(WNDCLASSEX);
    windowClass.style           = CS_HREDRAW | CS_VREDRAW;
    windowClass.lpfnWndProc     = MainWindowProc;
    windowClass.cbClsExtra      = 0;
    windowClass.cbWndExtra      = 0;
    windowClass.hInstance       = hInstance;
    windowClass.hIcon           = LoadIcon(NULL, IDI_APPLICATION);  // default icon
    windowClass.hCursor         = LoadCursor(NULL, IDC_ARROW);      // default arrow
    windowClass.hbrBackground   = NULL;                             // don't need background
    windowClass.lpszMenuName    = NULL;                             // no menu
    windowClass.lpszClassName   = ClassName;
    windowClass.hIconSm         = LoadIcon(NULL, IDI_WINLOGO);      // windows logo small icon

    // register the windows class
    if (!RegisterClassEx(&windowClass))
        return 0;

    if (fullscreen)                             // fullscreen?
    {
        DEVMODE dmScreenSettings;                   // device mode
        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
        dmScreenSettings.dmSize = sizeof(dmScreenSettings); 
        dmScreenSettings.dmPelsWidth = windowWidth;         // screen width
        dmScreenSettings.dmPelsHeight = windowHeight;           // screen height
        dmScreenSettings.dmBitsPerPel = windowBits;             // bits per pixel
        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

        // 
        if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
        {
            // setting display mode failed, switch to windowed
            MessageBox(NULL, "Display mode failed", NULL, MB_OK);
            fullscreen = 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

    // class registered, so now create our window
    hwnd = CreateWindowEx(NULL,                                 // extended style
        ClassName,                          // class name
        "Level Designer",      // app name
        dwStyle | WS_CLIPCHILDREN |
        WS_CLIPSIBLINGS,
        0, 0,                               // x,y coordinate
        windowRect.right - windowRect.left,
        windowRect.bottom - windowRect.top, // width, height
        NULL,                               // handle to parent
        NULL,                               // handle to menu
        hInstance,                          // application instance
        NULL);                              // no extra params

    hDC = GetDC(hwnd);

    // check if window creation failed (hwnd would equal NULL)
    if (!hwnd)
        return 0;
    
    >> Does not solve problem >> glViewport(0, 0, windowWidth - 500, windowHeight);        // reset the viewport to new   dimensions
    glMatrixMode(GL_PROJECTION);            // set projection matrix current matrix
    glLoadIdentity();                       // reset projection matrix

    // calculate aspect ratio of window
    gluPerspective(52.0f,(GLfloat)windowWidth/(GLfloat)windowHeight,1.0f,1000.0f);

    glMatrixMode(GL_MODELVIEW);             // set modelview matrix
    glLoadIdentity();                       // reset modelview matrix

    ShowWindow(hwnd, SW_SHOW);          // display the window
    UpdateWindow(hwnd);                 // update the window

    while (!exiting)
    {
        SwapBuffers(hDC);

        while (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
        {
            if (!GetMessage (&msg, NULL, 0, 0))
            {
                exiting = true;
                break;
            }

            TranslateMessage (&msg);
            DispatchMessage (&msg);
        }
    }

    if (fullscreen)
    {
        ChangeDisplaySettings(NULL,0);          // If So Switch Back To The Desktop
        ShowCursor(TRUE);                       // Show Mouse Pointer
    }

    return (int)msg.wParam;
}

That's the main source file obviously

I've already got menus, however I think if i put any controls, they will just be hidden due to OpenGLs background clearscreen color.

Why don't you try it out? I remember writing chemistry programs that have had buttons on the right side of the screen that showed up even though OpenGL was actually being rendered to the entire background, and I don't believe I did anything special for it. I believe we have given you the answer already, and that is you simply need to call glViewport when setting up OpenGL with dimensions smaller than the size of the Win32 window you are drawing on. This will limit anything OpenGL wants to do to that portion of the screen.

EDIT:
If it does not work you will need to create a parent window that is purely for Windows, and then create a child window which uses OpenGL. You have the code for doing that above.

Well, using gl Viewport, I still do not receive the results I strived for, if that's the only answer that can be given, which won't work. I guess I just have live without it. Thanks for your input all. If you still think you can get it to work, please let me know.