Messed up direct draw surface fliping.

This is a discussion on Messed up direct draw surface fliping. within the Game Programming forums, part of the General Programming Boards category; Heres my program for some reason the pixels are alternating what surface they are being writen to could someone tell ...

  1. #1
    bobish
    Guest

    Messed up direct draw surface fliping.

    Heres my program for some reason the pixels are alternating what surface they are being writen to
    could someone tell me whats wrong. The debuger told me that there was an error releasing the secondary surface. I am useing ms vc++ 6
    // PROG8_3.CPP - Creates a DirectDraw object and changes display

    // INCLUDES ///////////////////////////////////////////////
    #define WIN32_LEAN_AND_MEAN

    #include <windows.h> // include important windows stuff
    #include <windowsx.h>
    #include <mmsystem.h>
    #include <winbase.h>
    #include <iostream.h> // include important C/C++ stuff
    #include <fstream.h>
    #include <conio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #include <memory.h>
    #include <string.h>
    #include <stdarg.h>
    #include <stdio.h>
    #include <math.h>
    #include <io.h>
    #include <fcntl.h>

    #include <ddraw.h> // directX includes

    ofstream * debugStream; // debuging stuff

    // DEFINES ////////////////////////////////////////////////
    // converts pallets to 16bit rgb
    #define _RGB16BIT(r,g,b) ((b%32)+((g%32)<<5)+((r%32)<<10))

    // defines for windows
    #define WINDOW_CLASS_NAME "WINXCLASS" // class name

    // MACROS /////////////////////////////////////////////////

    // these read the keyboard asynchronously
    #define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
    #define KEY_UP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

    // PROTOTYPES /////////////////////////////////////////////

    int Game_Init(void *parms=NULL);
    int Game_Shutdown(void *parms=NULL);
    int Game_Main(void *parms=NULL);
    // GLOBALS ////////////////////////////////////////////////

    HWND main_window_handle = NULL; // save the window handle
    HINSTANCE main_instance = NULL; // save the instance
    char buffer[80]; // used to print text
    LPDIRECTDRAW lpdd; // pointer to direct draw object
    LPDIRECTDRAWSURFACE lpddsprimary = NULL; // dd primary surface
    LPDIRECTDRAWSURFACE lpddsback = NULL; // dd back surface
    LPDIRECTDRAWPALETTE lpddpal = NULL; // a pointer to the created dd palette
    DDSURFACEDESC ddsd; // a direct draw surface description struct
    DDSCAPS ddscaps; // a direct draw surface capabilities struct
    HRESULT ddrval; // result back from dd calls
    //
    int xdrawlocationrr=50;
    int ydrawlocationrr=50;
    // FUNCTIONS //////////////////////////////////////////////

    LRESULT CALLBACK WindowProc(HWND hwnd,
    UINT msg,
    WPARAM wparam,
    LPARAM lparam)
    {
    // this is the main message handler of the system
    PAINTSTRUCT ps; // used in WM_PAINT
    HDC hdc; // handle to a device context

    // what is the message
    switch(msg)
    {
    case WM_CREATE:
    {
    // do initialization stuff here
    return(0);
    } break;

    case WM_PAINT:
    {
    // start painting
    hdc = BeginPaint(hwnd,&ps);

    // end painting
    EndPaint(hwnd,&ps);
    return(0);
    } break;

    case WM_DESTROY:
    {
    // kill the application
    PostQuitMessage(0);
    return(0);
    } break;

    default:break;

    } // end switch

    // process any messages that we didn't take care of
    return (DefWindowProc(hwnd, msg, wparam, lparam));

    } // end WinProc

    // WINMAIN ////////////////////////////////////////////////

    int WINAPI WinMain( HINSTANCE hinstance,
    HINSTANCE hprevinstance,
    LPSTR lpcmdline,
    int ncmdshow)
    {
    //for debuging
    debugStream = new ofstream("c:\\debugdump.txt");
    *debugStream << "Program execution begun" <<endl<<flush;

    WNDCLASS winclass; // this will hold the class we create
    HWND hwnd; // generic window handle
    MSG msg; // generic message
    HDC hdc; // generic dc
    PAINTSTRUCT ps; // generic paintstruct

    // first fill in the window class stucture
    winclass.style = CS_DBLCLKS | CS_OWNDC |
    CS_HREDRAW | CS_VREDRAW;
    winclass.lpfnWndProc = WindowProc;
    winclass.cbClsExtra = 0;
    winclass.cbWndExtra = 0;
    winclass.hInstance = hinstance;
    winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    winclass.lpszMenuName = NULL;
    winclass.lpszClassName = WINDOW_CLASS_NAME;

    // register the window class
    if (!RegisterClass(&winclass))
    return(0);

    // create the window
    if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME, // class
    "Pixel Drawer", // title
    WS_POPUP | WS_VISIBLE,
    0,0, // x,y
    320, // width
    200, // height
    NULL, // handle to parent
    NULL, // handle to menu
    hinstance,// instance
    NULL))) // creation parm
    return(0);

    // save the window handle and instance in a global
    main_window_handle = hwnd;
    main_instance = hinstance;

    // perform all game console specific initialization
    Game_Init();

    // enter main event loop
    while(1)
    {
    if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
    {
    // test if this is a quit
    if (msg.message == WM_QUIT)
    break;

    // translate any accelerator keys
    TranslateMessage(&msg);

    // send the message to the window proc
    DispatchMessage(&msg);
    } // end if

    // main game processing goes here
    Game_Main();

    } // end while

    // shutdown game and release all resources
    Game_Shutdown();

    // return to Windows like this
    return(msg.wParam);

    } // end WinMain

    // WINX GAME PROGRAMMING CONSOLE FUNCTIONS ////////////////

    int Game_Init(void *parms)
    {

    *debugStream << "createing DD obj" <<endl<<flush;
    // create object and test for error
    if (DirectDrawCreate(NULL,&lpdd,NULL)!=DD_OK)
    return(0);

    // set cooperation level to windowed mode normal
    *debugStream << "seting cooperation level to windowed mode normal" <<endl<<flush;
    if (lpdd->SetCooperativeLevel(main_window_handle,
    DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
    DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)!=DD_OK)
    return(0);

    // set the display mode
    if (lpdd->SetDisplayMode(800,600,16)!=DD_OK)
    return(0);

    memset(&ddsd,0,sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);
    ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
    ddsd.dwBackBufferCount = 1;

    // create the surface and check for an error
    if (lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL)!=DD_OK)
    return(0);
    // query back buffer
    ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
    // get surface
    lpddsprimary->GetAttachedSurface(&ddscaps,&lpddsback);

    // clean up secondary surface///////
    lpddsback->Lock(NULL,&ddsd,
    DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);

    memset((USHORT *)ddsd.lpSurface,0,800*1200);

    lpddsback->Unlock((USHORT *)ddsd.lpSurface);
    while(lpddsprimary->Flip(NULL, DDFLIP_WAIT)!=DD_OK); //flip surfaces
    return(0);
    // stop cleaning


    // return success
    return(1);
    } // end Game_Init

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

    int Game_Shutdown(void *parms)
    {
    // this function is where you shutdown your game and
    // release all resources that you allocated

    if (lpddsprimary!=NULL)
    lpddsprimary->Release();
    if (lpddsback!=NULL)
    lpddsback->Release();
    // release the directdraw object
    if (lpdd!=NULL)
    lpdd->Release();

    // return success
    return(1);
    } // end Game_Shutdown

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

    int Game_Main(void *parms)
    {
    USHORT *video_buffer;

    // check of user is trying to exit
    if (KEY_DOWN(VK_ESCAPE)){
    PostMessage(main_window_handle, WM_DESTROY,0,0);
    }
    // set up the surface description to lock the surface
    memset(&ddsd,0,sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);

    if (KEY_DOWN(VK_SPACE))
    {
    //lock surface
    lpddsback->Lock(NULL,&ddsd,
    DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);

    //get video pointer
    video_buffer = (USHORT *)ddsd.lpSurface;

    video_buffer[xdrawlocationrr + (ydrawlocationrr*ddsd.lPitch >> 1)]=
    _RGB16BIT(rand()%256,rand()%256,255);

    lpddsback->Unlock(video_buffer);

    //flip surfaces
    while(lpddsprimary->Flip(NULL, DDFLIP_WAIT)!=DD_OK)
    {*debugStream << "flipfailed" <<endl<<flush;}


    if (ydrawlocationrr<500)
    {
    ydrawlocationrr++;
    }
    else if(xdrawlocationrr<700)
    {
    xdrawlocationrr++;
    }
    else
    {
    ydrawlocationrr=50;
    }
    Sleep(1); //using sleep because accuracy doesn't matter here
    }

    return(1); // return success
    } // end Game_Main

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

  2. #2
    Registered User
    Join Date
    Sep 2001
    Posts
    164
    I can't pin point the error there but you should remove '%256' and change the last argument for RGB16BIT in the pixelplotting code to 31. Each channel in 16-bit mode has 32 levels (0-31).

    You shouldn't use the macro _RGB16BIT either because practically no graphics cards use this format anymore. You have to detect the format the graphics card uses before you can blit to it.
    // Gliptic

  3. #3
    bobish
    Guest
    Okay how do i detect the graphics card. Also why should i take out %256 there are 256 shades of red
    green and blue in 16 bit aren't there. In short how do i do the changes you've segested im new to this.

  4. #4
    Registered User
    Join Date
    Sep 2001
    Posts
    412
    No. 256 colors = 8 bits * 3 colors = 24 bits. So 24 or 32 bit color has 256 shades of each.

    16 bit color VARIES depending on mode. Popular representations are 5-5-5 (where each is 5 bits or 32 gradations) but 5-6-5 is also widely used (there are 32 gradations for red and blue, and 64 for green).

  5. #5
    Bobish
    Guest
    oops well it didn't matter if it was to high it would just go back to 0. But any way does any one know what the problem is. It seems that I make a mistake at every step in my code.

  6. #6
    Bobish
    Guest
    can someone answer me?

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Please help with my game
    By jjj93421 in forum Game Programming
    Replies: 10
    Last Post: 04-12-2004, 11:38 PM
  2. Direct Draw: Rotating a bitmap
    By Diamonds in forum Game Programming
    Replies: 6
    Last Post: 09-08-2003, 01:36 PM
  3. Game update...
    By jdinger in forum Game Programming
    Replies: 14
    Last Post: 11-08-2002, 06:10 AM
  4. Direct Draw weird stuff
    By Magos in forum C++ Programming
    Replies: 6
    Last Post: 04-24-2002, 04:39 AM
  5. Direct Draw problem
    By morbuz in forum Game Programming
    Replies: 5
    Last Post: 10-08-2001, 06:14 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21