DirectX - Surface



  • Hi @all,

    ich habe schon in den ersten kleinen Schritten einige Probleme mit Direct3D. Ich bekomm zwar kein Kompilier- oder Linkfehler, aber beim Auffruf (Ausführung der exe) eines Direct3D-Fensters mit einem Surface-Objekt kommt einen Fehlermeldung ala "Die Anweisung kann auf Speicher nicht zugreifen" Mit dem Debugger kam ich darauf, das die Funktion CreateImageSurface fehlerhaft ist. Hier mein Code:

    Main.cpp

    #include "mrWindow.h"
    #include <math.h>
    #include <d3d8.h>
    
    class D3DWindow : public mrWindow
    {
    
    	LPDIRECT3D8 m_pD3D;
    	LPDIRECT3DDEVICE8 m_pD3DDevice;
    	LPDIRECT3DSURFACE8 m_pD3DSurface;
    	mrUInt32 m_iD3DFormat;
    
    public:
    
    	D3DWindow (void) {};
    	~D3DWindow (void) {};
    
    	HRESULT SetupDirect3D (void);
    	HRESULT KillDirect3D (void);
    
    	mrBool32 Frame (void);
    };
    
    HRESULT D3DWindow::SetupDirect3D (void)
    {
    
    	if (NULL == (m_pD3D = Direct3DCreate8 (D3D_SDK_VERSION)))
    	{
    		return E_FAIL;
    	}
    
    	D3DDISPLAYMODE d3ddm;
    
    	if (FAILED (m_pD3D->GetAdapterDisplayMode (D3DADAPTER_DEFAULT, &d3ddm)))
    	{
    		return E_FAIL;
    	}
    
    	D3DPRESENT_PARAMETERS d3dpp;
    	ZeroMemory( &d3dpp, sizeof(d3dpp) );
    	d3dpp.Windowed = TRUE;
    	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    	d3dpp.BackBufferFormat = d3ddm.Format;
    
    	if (FAILED (m_pD3DDevice->CreateImageSurface (256, 256, (D3DFORMAT) m_iD3DFormat, &m_pD3DSurface )))
    	{
    		return E_FAIL;
    	}
    
    	D3DLOCKED_RECT kLockedRect;
    	m_pD3DSurface->LockRect (&kLockedRect, NULL, 0);
    
    	DWORD * piSurfaceBuffer = (DWORD *) kLockedRect.pBits;
    	if (FAILED(m_pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL, m_hWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &m_pD3DDevice )))
    	{
    		return E_FAIL;
    	} 
    
    	int iX, iY;
    
    	for (iY=0; iY<256; iY++)
    	{
    
    		for (iX=0; iX<256; iX++)
    		{
    			int iPower = (int)(sin (iY * iX) * 128 + cos (iY * -iX) * 128);
    			piSurfaceBuffer [iX + iY* (kLockedRect.Pitch >> 2)] = D3DCOLOR_XRGB (iPower, iPower, iPower);
    		}
    	}
    
    	m_pD3DSurface->UnlockRect ();
    
    return D3D_OK;
    }
    
    HRESULT D3DWindow::KillDirect3D (void)
    {
    
    	if (NULL != m_pD3D)
    	{
    		m_pD3D->Release ();
    	}
    
    	if (NULL != m_pD3DDevice)
    	{
    		m_pD3DDevice->Release ();
    	}
    
    	if (NULL != m_pD3DSurface)
    	{
    		m_pD3DSurface->Release ();
    	}
    
    return D3D_OK;
    }
    
    mrBool32 D3DWindow::Frame (void)
    {
    	m_pD3DDevice->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB (0,0,255), 1.0f, 0);
    
    	LPDIRECT3DSURFACE8 pBackBuffer;
    	m_pD3DDevice->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
    
    	m_pD3DDevice->BeginScene();
    
    	m_pD3DDevice->CopyRects (m_pD3DSurface, NULL, 0, pBackBuffer, NULL);
    
    	m_pD3DDevice->EndScene();
    
    	m_pD3DDevice->Present (NULL, NULL, NULL, NULL);
    
    	pBackBuffer->Release ();
    
    return mrTrue;
    }
    
    int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nShowCmd)
    {
    
    	D3DWindow kWindow;
    	kWindow.Create (hInstance, "D3D Demo");
    	kWindow.SetupDirect3D ();
    	kWindow.Run ();
    	kWindow.KillDirect3D ();
    
    return 0;
    }
    

    mrWindow:

    #include "mrDataTypes.h"
    #include "mrError.h"
    #include <windows.h>
    
    #pragma once
    
    class mrWindow
    {
    protected:
    	WNDCLASS	m_kWndClass;
    	HWND		m_hWindow;
    	MSG			m_kMessage;
    
    public:
    
    	mrWindow (void);
    	~mrWindow (void);
    
    	mrError32 Create (HINSTANCE hInstance, LPSTR szTitle, mrInt iWidth = CW_USEDEFAULT, mrInt iHeight = CW_USEDEFAULT, 
    					  mrUInt32 iStyle = WS_OVERLAPPEDWINDOW | WS_VISIBLE);
    
    	static LRESULT CALLBACK WndProc (HWND hWindow, UINT iMessage, WPARAM wParam, LPARAM lParam);
    
    	void Run (void);
    
    	virtual mrBool32 MessageHandler (UINT iMessage, WPARAM wParam, LPARAM lParam);
    	virtual mrBool32 Frame (void) = 0;
    };
    
    mrWindow::mrWindow (void)
    {
    
    }
    
    mrWindow::~mrWindow (void)
    {
    
    }
    
    mrError32 mrWindow::Create (HINSTANCE hInstance, LPSTR szTitle, mrInt iWidth, mrInt iHeight, mrUInt32 iStyle)
    {
    	m_kWndClass.hCursor = LoadCursor (NULL, IDC_ARROW);
    	m_kWndClass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    	m_kWndClass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);
    
    	m_kWndClass.hInstance = hInstance;
    	m_kWndClass.lpfnWndProc = WndProc;
    	m_kWndClass.lpszClassName = "Mirus Window";
    
    	m_kWndClass.lpszMenuName = NULL;
    	m_kWndClass.cbClsExtra = NULL;
    	m_kWndClass.cbWndExtra = NULL;
    	m_kWndClass.style = NULL;
    
    	if (!RegisterClass (&m_kWndClass))
    	{
    		return SomeError;
    	}
    
    	m_hWindow = CreateWindow ("Mirus Window", szTitle, iStyle, CW_USEDEFAULT, CW_USEDEFAULT, iWidth, iHeight, NULL, NULL, hInstance,
    							  (void *) this);
    
    	SetWindowText (m_hWindow, szTitle);
    
    return mrNoError;
    }
    
    LRESULT CALLBACK mrWindow::WndProc (HWND hWindow, UINT iMessage, WPARAM wParam, LPARAM lParam)
    {
    	mrWindow * pkWindow = NULL;
    	mrBool32 bProcessed = mrFalse;
    
    	switch (iMessage)
    	{
    
    		case WM_NCCREATE:
    		SetWindowLong (hWindow, GWL_USERDATA, (long)((LPCREATESTRUCT(lParam))->lpCreateParams));
    		break;
    
    		default:
    		pkWindow = (mrWindow *) GetWindowLong (hWindow, GWL_USERDATA);
    
    		if (NULL != pkWindow)
    		{
    			bProcessed = pkWindow->MessageHandler (iMessage, wParam, lParam);
    		}
    		break;
    	}
    
    	if (mrFalse == bProcessed)
    	{
    		return DefWindowProc (hWindow, iMessage, wParam, lParam);
    	}
    
    return 0;
    }
    
    void mrWindow::Run (void)
    {
    	while (1)
    	{
    
    		if (PeekMessage (&m_kMessage, m_hWindow, 0, 0, PM_REMOVE))
    		{
    
    			if (WM_QUIT == m_kMessage.message)
    			{
    				break;
    			}
    			else
    			{
    				TranslateMessage (&m_kMessage);
    				DispatchMessage (&m_kMessage);
    			}
    		}
    		else
    		{
    			Frame ();
    		}
    	}
    }
    
    mrBool32 mrWindow::MessageHandler (UINT iMessage, WPARAM wParam, LPARAM lParam)
    {
    	switch (iMessage)
    	{
    
    		case WM_CLOSE:
    		PostQuitMessage (0);
    		return mrTrue;
    		break;
    
    		default:
    		return mrFalse;
    		break;
    	}
    }
    


  • Croon1337 schrieb:

    Mit dem Debugger kam ich darauf, das die Funktion CreateImageSurface fehlerhaft ist.

    Die Funktion CreateImageSurface ist ziemlich wahrscheinlich nicht fehlerhaft. Es wird schon an dir liegen. Wo initialisierst du denn m_iD3DFormat?
    btw:
    CreateImageSurface verlangt einen Wert vom Typ D3DFORMAT. Den solltest du ihm auch so geben, die int <-> enum Geschichten sind nicht wirklich toll.



  • Croon1337 schrieb:

    Mit dem Debugger kam ich darauf, das die Funktion CreateImageSurface fehlerhaft ist.

    Tja, dann hast du wohl Pech gehabt und kannst die Funktion nicht benutzen.

    Bye, TGGC (Der Held bei Dir!)



  • Hi, könnte es vielleicht daran liegen das CreateImageSurface veraltet ist und in DirectX 8 SDK Verwendung fand und nicht mehr in der DirectX 9 SDK? Dafür gibt es glaube ich wohl CreateOffscreenPlainSurface, aber sollte nicht DirectX abwärts kompatibel sein?



  • Croon1337 schrieb:

    Hi, könnte es vielleicht daran liegen das CreateImageSurface veraltet ist und in DirectX 8 SDK Verwendung fand und nicht mehr in der DirectX 9 SDK? Dafür gibt es glaube ich wohl CreateOffscreenPlainSurface, aber sollte nicht DirectX abwärts kompatibel sein?

    COM!?


Log in to reply