Classes

Hi all.
I have been reading a book lately called Introduction to Game Programming with DirectX 9.0.

When i look at the code from there i don't see any classes or anything to lay out the program if you get my meaning.

But when i look at the posts people post on here i see that they have all of their functions inside classes and other things.

Can anyone give any hints on how to make my own class similar.

Tell me if i need to post my code.

I'd recommend getting information on basic object-oriented design. There's nothing special about games, except that in cases where there is a trade-off with speed, speed has somewhat greater weight than in other applications.

I can already create classes, i just don't quite know how to make a class with all of the DirectX info in if you get my meaning.

As I said, object-oriented design. Think about what you have to do now, then combine that with knowledge of how to design classes. (Not just creating. Designing.)

I have tried and tried but still no avail... Can someone please not help me?

First put the code in exactly as the book shows. Most of us, however, read that book long after we understood C++ and OO design (or at least thought we did). So for me I did not enter the code as is because I figured out a framework of classes while reading the book.

You don't have to have classes for the code to work, but it makes things so much easier when you work with objects instead of just functions sitting out in open space with no relation to each other whatsoever.

Showing you my framework won't help you because you may approach it differently than I. I recommend getting a book on object oriented design methods to help you.

Right. By the way Bubba, did you get my P.M?

the directx stuff will just be like how other functions go in the class as members ,,,

Code:

---

class Dx
{
public:
HRESULT InitDirectX();
};

HRESULT Dx::InitDirectX()
{

}

---

just because a book shows you without classes it dosent mean it wont allow it...
the book probably didnt do it in clasess's as that book wasnt about c++ so there for just did it in global functions etc..

Hi again.
I have a class called CRenderDevice. It's not completed yet. But i'm thinking that i may need this as a base class. So i thought i would post here to see what variables i might need.

Here is the code:
(Again, it's not completed)

Code:

---

class CRenderDevice
{
public:
        HRESULT CInitDirectX(
                HINSTANCE hInstance,
                int width, int height,
                bool windowed,
                D3DDEVTYPE deviceType,
                IDirect3DDevice9** device);
};

---

It's not much, but it's all i got.
Can someone help me please?

So, can no-one help me out or is it because you don't want to help me out?

Right i attempted it again and i think i got a bit further, but before i go any further.... i've got an error.

Code:

---

CInitDirectX.cpp(12) : error C2440: 'type cast' : cannot convert from 'overloaded-function' to 'WNDPROC'
None of the functions with this name in scope match the target type

---

I don't know how to fix this error... here is the code:

CRenderDevice.h

Code:

---

#include <d3dx9.h>

class CRenderDevice
{
public:
        HRESULT CInitDirectX(
            HINSTANCE hInstance,
                int width, int height,
                bool windowed,
                D3DDEVTYPE deviceType,
                IDirect3DDevice9** device);

        LRESULT CALLBACK WndProc(
                HWND hwnd,
                UINT Msg,
                WPARAM wParam,
                LPARAM lParam);

        template<class T>
        void Release(T t)
        {
                if(t)
                {
                        t->Release();
                        t = 0;
                }
        }

        template<class T>
        void Delete(T t)
        {
                if(t)
                {
                        delete t;
                        t = 0;
                }
        }

protected:
        int width;
        int height;
        int vp;
        bool windowed;
        D3DCAPS9 caps;
        IDirect3D9* d3d9;
        HRESULT hr;
        HINSTANCE hInstance;
        HWND hwnd;
        UINT Msg;
        D3DDEVTYPE deviceType;
        IDirect3DDevice9** device;
};

---

CInitDirectX.cpp

Code:

---

#include "CRenderDevice.h"

HRESULT CRenderDevice::CInitDirectX(
                HINSTANCE hInstance,
                int width, int height,
                bool windowed,
                D3DDEVTYPE deviceType,
                IDirect3DDevice9** device)
{
        WNDCLASS wc;
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = (WNDPROC)WndProc;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = 0;
        wc.hInstance = hInstance;
        wc.hIcon = LoadIcon(0, IDI_APPLICATION);
        wc.hCursor = LoadCursor(0, IDC_ARROW);
        wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
        wc.lpszMenuName = 0;
        wc.lpszClassName = "Direct3DApp";

        if(!RegisterClass(&wc))
        {
                MessageBox(0, "RgisterClass() - FAILED!", "Error", 0);
                return 0;
        }

        hwnd = CreateWindowEx(
                0,
                "Direct£DApp",
                "Direct3DApp",
                WS_OVERLAPPEDWINDOW,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                width,
                height,
                hwnd,
                NULL,
                hInstance,
                NULL);

        if(!hwnd)
        {
                MessageBox(0, "CreateWindowEx() - FAILED!", "Error", 0);
                return 0;
        }
        ShowWindow(hwnd, SW_SHOW);
        UpdateWindow(hwnd);

        d3d9 = Direct3DCreate9(D3D_SDK_VERSION);

        if(!d3d9)
        {
                MessageBox(0, "Direct3DCreate9() - FAILED!", "Error", 0);
                return 0;
        }

        d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, deviceType, &caps);

        if(caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
        {
                vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
        }
        else
        {
                vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
        }

        D3DPRESENT_PARAMETERS d3dpp;
        d3dpp.BackBufferWidth = width;
        d3dpp.BackBufferHeight = height;
        d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
        d3dpp.BackBufferCount = 1;
        d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
        d3dpp.MultiSampleQuality = 0;
        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
        d3dpp.hDeviceWindow = hwnd;
        d3dpp.Windowed = windowed;
        d3dpp.EnableAutoDepthStencil = true;
        d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
        d3dpp.Flags = 0;
        d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
        d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

        hr = d3d9->CreateDevice(
                D3DADAPTER_DEFAULT,
                deviceType,
                hwnd,
                vp,
                &d3dpp,
                device);

        if(FAILED(hr))
        {
                d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

        hr = d3d9->CreateDevice(
                    D3DADAPTER_DEFAULT,
                    deviceType,
                    hwnd,
                    vp,
                    &d3dpp,
                    device);
        }

        if(FAILED(hr))
        {
                d3d9->Release();
                MessageBox(0, "CreateDevice() - FAILED!", "Error", 0);
                return 0;
        }
        d3d9->Release();

        return 1;
}

---

WNDPROC is a pointer to a normal function, but you're trying to pass a member function for it. These two are fundamentally different.
Working around this problem is a common and interesting problem. There are many approaches to it, and I'm sure searching the Windows board for the topic will yield something useful.

Thanks..... I've fixed it... all i needed to do is declare it static.

Yes, but then you can't access the instance from it anymore. If you need that, you need to be trickier. (User data is the simplest way of implementing it.)

Here is how I worked around it. Note that you can approach this other ways.

Code:

---

int WINAPI WinMain(HINSTANCE hInstance,
                                  HINSTANCE prevInstance,
                                  PSTR cmdLine,
                                  int showCmd)
{
 
  //Create window for app
  if(!g_TerrainApp.InitD3D(hInstance,
                                        WIDTH,
                            HEIGHT,
                            false,
                            D3DDEVTYPE_HAL,
                            "Terrain app",true))
        {
                ::MessageBox(0, "InitD3D() - FAILED", 0, 0);
                return 0;
        }
       
  g_TerrainApp.Setup();
       
  g_TerrainApp.EnterMsgLoop();

       
  //We are done so clean up the memory and COM objects
  g_TerrainApp.Cleanup();
   
  return 0;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        switch( msg )
        {
    //case WM_PAINT: return(0);break;
    case WM_DESTROY:
                  ::PostQuitMessage(0);
                  return(0);
      break;
               
          case WM_KEYDOWN:
                  if( wParam == VK_ESCAPE )
                  {
                          g_TerrainApp.ShutDown();
                         
                          ::DestroyWindow(hwnd);
                       
                    return(0);
        break;
      }
         
  } 
   
  return ::DefWindowProc(hwnd, msg, wParam, lParam);
 
}

---

After this is executed it's all C++ objects from here on out. As you can see g_TerrainApp is the one and only global in the entire engine and while I dislike globals it seemed the easiest approach. CTerrainApp is derived from CD3DApp which is the main Direct3D application class. That base class sets up the sound (using CDXAudio), music system (CDXMusic), input (CDXInput,CMouse,CKeyboard, and CGameDevice). But there is a lot more going on like reading INI files for level data, reading in model/texture data, creating objects, etc, etc.

Once you get your basic framework down you should be able to derive from it's classes for just about all your projects. My base class framework is used in all of my projects.

Thanks Bubba. What did you make your g_TerrainApp an instance of?
Just curious.

Doesn't that also mean that you didn't declare your functions public?
Why not?

Sorry about all of the questions, i'm just curious and eager to learn.

Nothing, the g_ prefix indicates that it's a global variable.

But i thought that you only use the . operator to access member variables.

Code:

---

g_TerrainApp.Setup();

---

No, it's used to access all members. In this case, it's used to access the Setup member function of g_TerrainApp. That doesn't mean that g_TerrainApp has to be a member of anything. In fact, if it were, you'd need a . (or a ->) in front of it.

But i didn't say that g_TerrainApp wasn't global.
I asked if it was an instance of something, and what it was an instance of?

D'oh! I completely confused "instance" and "member" there. Sorry.

I can guess even this, though. g_TerrainApp is, guessing by the name, an instance of CTerrainApp, which derives from the CApp (or whatever his main application class is called) and introduces the functionality specific to this application. (Another guess: it's a terrain loader demo.)

Oh. So the profs like you and Bubba and other members of CBoard have Application classes also for your main windows.

Quote:

---

Originally Posted by CornedBee

WNDPROC is a pointer to a normal function, but you're trying to pass a member function for it. These two are fundamentally different.
Working around this problem is a common and interesting problem. There are many approaches to it, and I'm sure searching the Windows board for the topic will yield something useful.

---

So how would i approach it if i don't want to declare it static?

I have reformatted the code so here it is:

CDevice.h

Code:

---


#include <d3dx9.h>

class CDevice /*Create a new class called CDevice*/
{
public:
    CDevice(); /*Class constructor*/
    virtual ~CDevice(); /*Class destructor*/
protected:
    bool CInitD3D( /*Function to initialize Direct3D*/
        HINSTANCE hInstance, /*Application Instance*/
        int width, int height, /*Window width and height in pixels*/
        bool windowed, /*Windowed?*/
        D3DDEVTYPE DeviceType, /*HAL or REF?*/
        IDirect3DDevice9** Device); /*The Device*/

    int EnterMsgLoop(
        bool (*ptr_display)(float TimeDelta));

    LRESULT CALLBACK WndProc( /*Windows Procedure*/
        HWND hwnd, /*Application handle*/
        UINT Msg, /*Message handle*/
        WPARAM wParam,
        LPARAM lParam);

    bool CSetup(); /*Setup function*/

    void CCleanUp(); /*Cleanup function*/
};

---

CInitD3D.cpp

Code:

---

#include "CDevice.h"
/*Defining the function the Initializes D3D*/
bool CDevice::CInitD3D( /*The function that initializes D3D*/
        HINSTANCE hInstance, /*Application instance*/
        int width, int height, /*Window width and height in pixels*/
        bool windowed, /*Windowed?*/
        D3DDEVTYPE DeviceType, /*HAL or REF?*/
        IDirect3DDevice9** Device) /*The Device*/
{
        WNDCLASS wc; /*Make wc an instance of WNDCLASS*/
        /*Class style*/
        wc.style      = CS_HREDRAW | CS_VREDRAW;
        /*Pointer to Windows Procedure*/
      wc.lpfnWndProc = (WNDPROC)WndProc;
        return 1;
}

---

Thanks

Basically, you have to pass a global or static member function as the WNDPROC. There is no way around that.

Therefore, you need to make this WndProc a stub that somehow looks up the pointer to the controlling object and calls the real member WndProc on that.
As I said, there are various approaches to this. The easiest, and for simple cases probably the best, is to just pass the object pointer as the user data to CreateWindow, and in the stub intercept WM_NCCREATE, get the user data and store it in the per-window space - either in GWLP_USERDATA or in memory provided by cbWndExtra of the WNDCLASS struct.
The downside of this approach is that it only works for windows under your control, not for, e.g., any of the common controls. The reason is that you can't rely on the per-window space for these.
Libraries that have to work for anything therefore take different approaches. MFC keeps per-thread maps that map HWNDs to CWnds. It uses a window creation hook to make sure the mapping is created at the earliest possible time. ATL, I believe, uses thunks - it dynamically generates code for the WNDPROCs that has the CWindow pointer directly embedded. I'm not sure how it works exactly and how it handles multiple windows with the same class, though.

On a side note:

Quote:

---

wc.lpfnWndProc = (WNDPROC)WndProc;

---

Never cast function pointers. Either using it as-is works or not. If it doesn't, then casting will merely invoke undefined behaviour. There are very, very few exceptions to this.

CornedBee hit the nail on the head. I've used several of these approaches. For the DirectShow WndProc I used the cbWndExtra to hold a pointer (an address) and then I cast it to CDXShowWnd which then allows me access to my class. It's complicated and hard to explain how it works.

I've also used the message map approach and I must give tons of credit to Shakti for helping me on this one. We spent literally hours and hours on Teamspeak pouring over MFC source code figuring out how the message system works. We based our entire scripting engine on the message approach and it works like a charm.

The inherent problem is that you are trying to use C++ when Windows itself is really C and not C++. Even though Windows calls everything classes at random in their docs, in reality they are really C structs which are not pure C++ classes. So the goal is to get to C++ as quick as possible in a way that Windows won't puke on. You can use thunks, message maps, pointers, etc.

This took a long time to get past in my code and I struggled with the very same issue you are struggling with.


Samples of my approaches to the problem


Pointer approach - via [Get/Set]WindowLong
Here is a sample of how I approached this in CDXShowWnd which is a class that offers simple DirectShow support.

Code:

---

//Helper wnd proc for video windows
//Just calls user supplied version
LRESULT CALLBACK g_VideoWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{

  if (msg==WM_NCCREATE)
  {
                LPCREATESTRUCT cs = (LPCREATESTRUCT) lParam;
                SetWindowLong(hwnd, GWL_USERDATA, (long) cs->lpCreateParams);
  }

  CDXShowWnd *pDShow = (CDXShowWnd *) GetWindowLong(hwnd, GWL_USERDATA);

  if (pDShow)
  {
 
    return pDShow->VideoWndProc(hwnd,msg,wParam,lParam);
  }
  else
  {
   
    return ::DefWindowProc(hwnd,msg,wParam,lParam);
  }


}

---

And here is the CD3DApp.h sample:

Code:

---

#include "CKeyboard.h"
#include "CDXAudio.h"
#include "CDXShowWnd.h"




const float INFINITY = FLT_MAX;
const float EPSILON  = 0.001f;

LRESULT CALLBACK      g_WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
LRESULT CALLBACK      g_VideoWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
...

---

The WndProc functions are not part of a class and so they work with Windows. However notice what is going on in g_VideoWndProc. I'm saving a pointer on creation of the window and then retrieving the pointer via GetWindowLong and casting it to CDXShowWnd. This now allows me access to my class and if the DirectShow window is valid, I simply call CDXShowWnd::VideoWndProc(). This is the transfer from global g_VideoWndProc() to the class based VideoWndProc(). Now this approach allows me to receive messages from Windows in my class-based WNDPROC which allows me to do pretty much anything I need to. So if the user presses a key during the video playback or perhaps a mouse button I can respond to this in an organized fashion and without a lot of strange obfuscated code. GetWindowLong() is extremely helpful and this approach would not be possible without it.

Message based approach
This approach was chosen because of it's simplicity (after implementation that is) and flexibility. Since this class is designed to run a script while the game engine is running Shakti and I needed real time object-oriented control over events. I won't go into a huge explanation of the system here b/c it is quite confusing, but it works pretty much exactly like MFC does.

Code:

---

#pragma once

#include <vector>
#include <utility>
#include "CBaseObject.h"

/////////////////////////////////
//Script message map structures//
/////////////////////////////////

//Forward delcaration of CGameObject;
class CBaseObject;

//SCRIPT_MSG typedef
typedef void (CBaseObject::*SCRIPT_MSG)(void);

//SCRIPT_MSGMAP_ENTRY
struct SCRIPT_MSGMAP_ENTRY
{
  UINT nCommandID;
  UINT nFuncSig;
  SCRIPT_MSG pfn;
 
  //SCRIPT_MSGMAP_ENTRY(UINT nCommandID,UINT nFuncSig,SCRIPT_MSG pfn):
  //nCommandID(nCommandID),nFuncSig(nFuncSig),pfn(pfn) { }
};

//SCRIPT_MSGMAP
struct SCRIPT_MSGMAP
{
  const SCRIPT_MSGMAP *pBaseMap;
  std::vector<SCRIPT_MSGMAP_ENTRY *> vEntries;
   
};

enum SFuncSigs
{
  SFSig_Param0_n =0,
  SFSig_Param1_n,  //int fxn(DWORD)
  SFSig_Param2_n,  //int fxn(DWORD,DWORD)
  SFSig_Param3_n  //int fxn(DWORD,DWORD,DWORD)
};

union ScriptMsgMapFuncs
{
  SCRIPT_MSG pfn;
  UINT (CBaseObject::*pfnParam1_n)(void);
  UINT (CBaseObject::*pfnParam2_n)(DWORD);
  UINT (CBaseObject::*pfnParam3_n)(DWORD,DWORD);
};

#define DECLARE_SCRIPT_MSGMAP() \
protected: \
  static std::vector<SCRIPT_MSGMAP_ENTRY *> m_vEntries; \
  static CBaseObject *m_pParent; \
public: \
  static const void SetupMessageMap(void); \
  static const void AddHandler(UINT nCommandID,UINT nFuncSig,SCRIPT_MSG memberFxn); \
  static const void SetParent(CBaseObject *pParent);
 

#define BEGIN_SCRIPT_MSGMAP(theClass,baseClass) \
std::vector<SCRIPT_MSGMAP_ENTRY *> theClass::m_vEntries; \
CBaseObject *theClass::m_pParent=baseClass; \
const void theClass::AddHandler(UINT nCommandID,UINT nFuncSig,SCRIPT_MSG memberFxn) \
{ \
  SCRIPT_MSGMAP_ENTRY *pEntry=new SCRIPT_MSGMAP_ENTRY; \
  pEntry->nCommandID=nCommandID; \
  pEntry->nFuncSig=nFuncSig; \
  pEntry->pfn=memberFxn; \
  m_vEntries.push_back(pEntry); \
} \
const void theClass::SetupMessageMap(void) {

#define ON_SCRIPT_CMD1(id,memberFxn) \
  AddHandler(id,SFSig_Param1_n,(SCRIPT_MSG)memberFxn);

#define ON_SCRIPT_CMD2(id,memberFxn) \
  AddHandler(id,SFSig_Param2_n,(SCRIPT_MSG)memberFxn);

#define ON_SCRIPT_CMD3(id,memberFxn) \
  AddHandler(id,SFSig_Param3_n,(SCRIPT_MSG)memberFxn);

#define END_SCRIPT_MSGMAP }
 

/////////////////////
//Script structures//
/////////////////////

//Function structure filled out by script class

struct SCRIPTFUNC
{
  UINT nCommandID;  //Script command ID
  UINT nParam1;
  UINT nParam2;
  UINT nParam3;
  CString strDebugID;
};
 

//One command from script
struct ScriptCommand
{
  bool bExecuted;
  SCRIPTFUNC *pFuncInfo;
  ScriptCommand *pNext;
};

//One if block from script
struct ScriptIfBlock
{
  bool bExecuted;
  ScriptCommand *pCommands;
  ScriptIfBlock *pNestedIfs;
  ScriptIfBlock *pNext;
};

//One complete event from script
struct ScriptEvent
{
  bool bExecuted;
  ScriptIfBlock *pBlocks;
  ScriptEvent *pNestedEvents;
  ScriptEvent *pNext;
};

//One trigger from script
struct ScriptTrigger
{
  bool bExecuted;
  ScriptEvent *pEvents;
  ScriptTrigger *pNestedTriggers;
  ScriptTrigger *pNext;
};

//One quest from script
struct ScriptQuest
{
  ScriptTrigger *pTriggers;
  ScriptQuest *pNestedQuests;
  ScriptQuest *pNext;
};

//One type of attack from script
//An attack is a list of commands to be executed
struct AttackScript
{
  ScriptEvent *pAttack;
  AttackScript *pNestedAttacks;
  AttackScript *pNext;
};

---

This is our message map approach and it works quite well and is very fast. Since everything operates on messages in the engine, it is 100% ready for some multiplayer message code to be added. Just create a controlling class and some supporting classes and multiplayer is a simple addition to the system.

The script code is a nightmare and violates everything you know about writing good headers, but it is powerful once you get it working.

A note about the pointer approach: to make your code compatible with 64-bit systems, you should use [GS]etWindowLongPtr and the offset constant GWLP_USERDATA. You should also cast the pointer passed to SWLP to LONG_PTR instead of long. Everything else will truncate a 64-bit pointer to 32 bits and very likely lead to a crash.