Well then Wik, sorry to use your thread for my own gain for a bit but I just can't figure this one out...
//-----------------------------------------------------------------------------
// File: Vertices.cpp
//
// Desc: In this tutorial, we are rendering some vertices. This introduces the
// concept of the vertex buffer, a Direct3D object used to store
// vertices. Vertices can be defined any way we want by defining a
// custom structure and a custom FVF (flexible vertex format). In this
// tutorial, we are using vertices that are transformed (meaning they
// are already in 2D window coordinates) and lit (meaning we are not
// using Direct3D lighting, but are supplying our own colors).
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include <d3d9.h>
#include <iostream>
float VertexDataArray[3][3];
VertexDataArray[0][0] = 150.0;
VertexDataArray[0][1] = 50.0;
VertexDataArray[0][2] = 0.5;
//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
LPDIRECT3D9 g_pD3D = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE9 g_pd3dDevice = NULL; // Our rendering device
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL; // Buffer to hold vertices
// A structure for our custom vertex type
struct CUSTOMVERTEX
{
FLOAT x, y, z, rhw; // The transformed position for the vertex
DWORD color; // The vertex color
};
// Our custom FVF, which describes our custom vertex structure
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
// Create the D3D object.
if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;
// Set up the structure used to create the D3DDevice
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
// Create the D3DDevice
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
{
return E_FAIL;
}
// Device state would normally be set here
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: InitVB()
// Desc: Creates a vertex buffer and fills it with our vertices. The vertex
// buffer is basically just a chuck of memory that holds vertices. After
// creating it, we must Lock()/Unlock() it to fill it. For indices, D3D
// also uses index buffers. The special thing about vertex and index
// buffers is that they can be created in device memory, allowing some
// cards to process them in hardware, resulting in a dramatic
// performance gain.
//-----------------------------------------------------------------------------
HRESULT InitVB()
{
// Initialize three vertices for rendering a triangle
CUSTOMVERTEX vertices[] =
{
{ VertexDataArray[0][0], VertexDataArray[0][1], VertexDataArray[0][2], 1.0f, 0xffffff00, }, // x, y, z, rhw, color
{ 250.0f, 250.0f, 0.5f, 1.0f, 0xff00ffff, },
{ 50.0f, 250.0f, 0.5f, 1.0f, 0xffff00ff, },
};
// Create the vertex buffer. Here we are allocating enough memory
// (from the default pool) to hold all our 3 custom vertices. We also
// specify the FVF, so the vertex buffer knows what data it contains.
if( FAILED( g_pd3dDevice->CreateVertexBuffer( 3*sizeof(CUSTOMVERTEX),
0, D3DFVF_CUSTOMVERTEX,
D3DPOOL_DEFAULT, &g_pVB, NULL ) ) )
{
return E_FAIL;
}
// Now we fill the vertex buffer. To do this, we need to Lock() the VB to
// gain access to the vertices. This mechanism is required becuase vertex
// buffers may be in device memory.
VOID* pVertices;
if( FAILED( g_pVB->Lock( 0, sizeof(vertices), (void**)&pVertices, 0 ) ) )
return E_FAIL;
memcpy( pVertices, vertices, sizeof(vertices) );
g_pVB->Unlock();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
if( g_pVB != NULL )
g_pVB->Release();
if( g_pd3dDevice != NULL )
g_pd3dDevice->Release();
if( g_pD3D != NULL )
g_pD3D->Release();
}
//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Draws the scene
//-----------------------------------------------------------------------------
VOID Render()
{
// Clear the backbuffer to a blue color
g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );
// Begin the scene
if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
{
// Draw the triangles in the vertex buffer. This is broken into a few
// steps. We are passing the vertices down a "stream", so first we need
// to specify the source of that stream, which is our vertex buffer. Then
// we need to let D3D know what vertex shader to use. Full, custom vertex
// shaders are an advanced topic, but in most cases the vertex shader is
// just the FVF, so that D3D knows what type of vertices we are dealing
// with. Finally, we call DrawPrimitive() which does the actual rendering
// of our geometry (in this case, just one triangle).
g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(CUSTOMVERTEX) );
g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 1 );
// End the scene
g_pd3dDevice->EndScene();
}
// Present the backbuffer contents to the display
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: The window's message handler
//-----------------------------------------------------------------------------
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
switch( msg )
{
case WM_DESTROY:
Cleanup();
PostQuitMessage( 0 );
return 0;
}
return DefWindowProc( hWnd, msg, wParam, lParam );
}
//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: The application's entry point
//-----------------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
// Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
"D3D Tutorial", NULL };
RegisterClassEx( &wc );
// Create the application's window
HWND hWnd = CreateWindow( "D3D Tutorial", "D3D Tutorial 02: Vertices",
WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,
GetDesktopWindow(), NULL, wc.hInstance, NULL );
// Initialize Direct3D
if( SUCCEEDED( InitD3D( hWnd ) ) )
{
// Create the vertex buffer
if( SUCCEEDED( InitVB() ) )
{
// Show the window
ShowWindow( hWnd, SW_SHOWDEFAULT );
UpdateWindow( hWnd );
// Enter the message loop
MSG msg;
ZeroMemory( &msg, sizeof(msg) );
while( msg.message!=WM_QUIT )
{
if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
else
Render();
}
}
}
UnregisterClass( "D3D Tutorial", wc.hInstance );
return 0;
}
Modified a bit from the DirectX 9.0 SDK's Vertices Tutorial. I'm trying to use global multi-dimensional arrays to store data for one vertex. But whenever I try to store a value to a few spots in the the array and I build the exe, I get this:
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(19): error C2466: cannot allocate an array of constant size 0
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(19): error C2466: cannot allocate an array of constant size 0
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(19): error C2087: 'VertexDataArray' : missing subscript
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(19): error C2501: 'VertexDataArray' : missing storage-class or type specifiers
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(19): error C2440: 'initializing' : cannot convert from 'double' to 'int [][1]'
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(20): error C2466: cannot allocate an array of constant size 0
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(20): error C2501: 'VertexDataArray' : missing storage-class or type specifiers
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(20): error C2369: 'VertexDataArray' : redefinition; different subscripts
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(20): error C2440: 'initializing' : cannot convert from 'double' to 'int [][1]'
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(21): error C2466: cannot allocate an array of constant size 0
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(21): error C2501: 'VertexDataArray' : missing storage-class or type specifiers
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(21): error C2369: 'VertexDataArray' : redefinition; different subscripts
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(21): error C2440: 'initializing' : cannot convert from 'double' to 'int [][2]'
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(92): error C3861: 'VertexDataArray': identifier not found, even with argument-dependent lookup
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(92): error C3861: 'VertexDataArray': identifier not found, even with argument-dependent lookup
c:\DXSDK\Samples\C++\Direct3D\Tutorials\Tut02_Vertices\Vertices.cpp(92): error C3861: 'VertexDataArray': identifier not found, even with argument-dependent lookup
So its basically re creating the array, but I dont want it to do that. Any thoughts?
@Ge3ri: Amazon.com, great place to find some books of any kind, then theres always Barnes and Nobles you can turn too, as well as Walden Books.
Cheers,
Preston
Intel Celeron 1.3 Ghrz 512MB Ram NVIDIA GeForceFX 5200 128MB