User forums > General (but related to Code::Blocks)

Need help defining member function arguments please

(1/2) > >>

pghtech:
This is sort of confusing for me to Post, so I'll do my best and show all my code.  I have two .cpp files, one that includes the other's .h file.  I have defined the following member variables:

--- Code: ---private:
        bool m_fullscreen

--- End code ---

And three public member functions:

--- Code: ---void CGfxOpenGL::SetScreenMode(bool x)
{
m_fullscreen = x;
}

bool CGfxOpenGL::GetScreenMode()
{
return m_fullscreen;
}

void CGfxOpenGL::QuestionScreenMode()
{
if (MessageBox(NULL,
"Do you want to run in Fullscreen",
"FullScreen Mode",
MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON1) == IDYES)
{
SetScreenMode(true);
return;
}
else
{
SetScreenMode(false);
return;
}
}

--- End code ---

In the winmain.cpp source file I have created an object of the class CGfxOpenGL called <setOpenGL> and I wanted to run an IF statement in winmain.cpp that checks if the app is running in fullscreen (which calls to see if the user wants it to run in fullscreen) and if so apply the proceding settings, but I wanted to do the if statement like so:

--- Code: ---if (setOpenGL.GetScreenMode(setOpenGl.SetScreenMode()))
...
...

--- End code ---

But I am having the problem that I am obviously defining GetScreenMode with no arguments.  So I tried specifying it as <GetScreenMode(CGfxOpenGL a)> so I could pass the function in the other function (CGfxOpenGl.GetScreenMode(
Thanks in advance

but I get an error
error C2664: 'GetScreenMode' : cannot convert parameter 1 from 'void' to 'class CGfxOpenGL

How do I have to set the passing argements?

Thanks

rcoll:
I'm not exactly sure what you are trying to do, but wouldn't it be something like:

if (setOpenGL.GetScreenMode()) {
    setOpenGl.SetScreenMode(true);
}

or similar?

thomas:
No offense, but you are aware that our forum deals with topics related to Code::Blocks, aren't you?
 ;)

This is the 3rd or 4th topic of yours which would be placed better in a general programming forum.

rcoll:
Maybe he feels the concentration of expertise (parts-per-million ?) is
higher here than on UseNet ?

Cheers,
Ron

pghtech:
Well it currently is in "general" and I am pretty sure (though I don't have a receipt) that i have been placing them in General, as the "code::blocks" form states "about code::blocks" when actually I am not using code::blocks.  But if I haven't I'll make sure that I am.

To answer the first reply, what I want to do is:  in the IF statement, call the function to get the value of m_fullscreen, but the GetScreenMode() function takes and argument which is another function of the same class QuestionScreenMode().   Therefore what i am trying to accomplish is in IF statement condition, it will call GetScreenMode() which calls QuestionsScreenMode Which then ask the user if they want to run in fullscreen or not, their return value ends up in SetScreenMode and so GetScreenMode ends up pulling what QuestionScreenMode passed it.

Therefore in one statement I am asking the question, posting to a member variable, and retrieving that value.

The following is the FULL code to both winmain.cpp and CGfxOpenGL.cpp

WINMAIN.CPP

--- Code: ---#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN

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

#include "CGfxOpenGL.h"

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

CGfxOpenGL *g_glRender = NULL;
CGfxOpenGL setOpenGL;

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);
        //SetupPalette();
        hRC = wglCreateContext(hDC);
        wglMakeCurrent(hDC, hRC);
        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:
        height = HIWORD(lParam);        // retrieve width and height
        width = LOWORD(lParam);

        g_glRender->SetupProjection(width, height);

        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:
        int fwKeys;
        LPARAM keyData;
        fwKeys = (int)wParam;    // virtual-key code
        keyData = lParam;          // key data

        switch(fwKeys)
        {
        case VK_ESCAPE:
            PostQuitMessage(0);
            break;
        default:
            break;
        }

        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;

    g_glRender = new CGfxOpenGL;

    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   = "GLClass";
    windowClass.hIconSm         = LoadIcon(NULL, IDI_WINLOGO);      // windows logo small icon

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

/*
if (MessageBox(NULL,
"Do you want to run in Fullscreen",
"FullScreen Mode",
MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON1) == IDYES)
{

fullscreen = true;
}
else
{
fullscreen = false;
}
*/




[highlight]
    if (setOpenGL.GetScreenMode(setOpenGL.QuestionScreenMode()) == true)                             // fullscreen?)
[/highlight]
    {
        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);
            setOpenGL.SetScreenMode(false);
        }
    }

    if (setOpenGL.GetScreenMode())                             // 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
        "GLClass",                          // class name
        "BOGLGP - Chapter 2 - OpenGL Application",      // 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;

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

    g_glRender->Init();

    while (!exiting)
    {
        g_glRender->Prepare(0.0f);
        g_glRender->Render();
        SwapBuffers(hDC);

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

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

    delete g_glRender;

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

    return (int)msg.wParam;
}

--- End code ---

CGfxOpenGL.CPP

--- Code: ---#ifdef _WINDOWS
#include <windows.h>
#endif

#include <gl/gl.h>
#include <gl/glu.h>
#include <math.h>
#include "CGfxOpenGL.h"

// disable implicit float-double casting
#pragma warning(disable:4305)

CGfxOpenGL::CGfxOpenGL()
{
}

CGfxOpenGL::~CGfxOpenGL()
{
}

bool CGfxOpenGL::Init()
{   
    // clear to black background
    glClearColor(0.0, 0.0, 0.0, 0.0);

    m_angle = 0.0f;

    return true;
}

bool CGfxOpenGL::Shutdown()
{
    return true;
}

void CGfxOpenGL::SetupProjection(int width, int height)
{
    if (height == 0)                    // don't want a divide by zero
    {
        height = 1;                 
    }

    glViewport(0, 0, width, height);        // 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)width/(GLfloat)height,1.0f,1000.0f);

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

    m_windowWidth = width;
    m_windowHeight = height;
}

void CGfxOpenGL::Prepare(float dt)
{
    m_angle += 0.1f;
}

void CGfxOpenGL::Render()
{
    // clear screen and depth buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     
    glLoadIdentity();

    // move back 5 units and rotate about all 3 axes
    glTranslatef(0.0, 0.0, -5.0f);
    glRotatef(m_angle, 1.0f, 0.0f, 0.0f);
    glRotatef(m_angle, 0.0f, 1.0f, 0.0f);
    glRotatef(m_angle, 0.0f, 0.0f, 1.0f);

    // lime greenish color
    glColor3f(0.7f, 1.0f, 0.3f);

    // draw the triangle such that the rotation point is in the center
    glBegin(GL_TRIANGLES);
        glVertex3f(1.0f, -1.0f, 0.0f);
        glVertex3f(-1.0f, -1.0f, 0.0f);
        glVertex3f(0.0f, 1.0f, 0.0f);
    glEnd();
}

[highlight]
void CGfxOpenGL::SetScreenMode(bool x)
{
m_fullscreen = x;
}

bool CGfxOpenGL::GetScreenMode(void)
{
return m_fullscreen;
}

void CGfxOpenGL::QuestionScreenMode()
{
if (MessageBox(NULL,
"Do you want to run in Fullscreen",
"FullScreen Mode",
MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON1) == IDYES)
{
SetScreenMode(true);
return;
}
else
{
SetScreenMode(false);
return;
}
}
[/highlight]

--- End code ---

Navigation

[0] Message Index

[#] Next page