Juegos en 3D

necesitaria ayuda con un codigo se trata del ejemplo del directx sdk
december 2006, vertices, el del triangulo. La cosa es que he añadido otro
triangulo, para hacer un rectangulo y he usado un indice, y no me muestra
nada.

Adjunto codigo.

//--

// 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.

//--

#define D3D_DEBUG_INFO

#include <d3d9.h>

#include <d3dx9.h>

#pragma warning( disable : 4996 ) // disable deprecated warning

#include <strsafe.h>

#pragma warning( default : 4996 )







//--

// 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

LPDIRECT3DINDEXBUFFER9 m_pIB = NULL;



// 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_HARDWARE_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()

{

CUSTOMVERTEX vertices[]
{ { -50,-50,0.5, 1.0f, 0xffff0000, }, // x, y, z, rhw, tu, tv

{ -50,50,0.5, 1.0f, 0xffff0000,},

{ 50,50,0.5, 1.0f, 0xffff0000,},

{ 50,-50,0.5 , 1.0f, 0xffff0000,},

{ -50,-50,0.5, 1.0f, 0xffff0000,},

{ 50,50,0.5, 1.0f, 0xffff0000, }

};



// Create the vertex buffer

if( FAILED( g_pd3dDevice->CreateVertexBuffer(sizeof(vertices), 0,
D3DFVF_CUSTOMVERTEX, D3DPOOL_MANAGED, &g_pVB,NULL ) ) )

return E_FAIL;

VOID* pVertices;

if( FAILED( g_pVB->Lock( 0, sizeof(vertices), (void**)&pVertices, 0 ) ) )
return E_FAIL;

memcpy( pVertices, vertices, sizeof(vertices)); g_pVB->Unlock(); //
Initialize the Index buffer

WORD dwIndices[] = {0, 1, 2, 0, 2, 3};

if( FAILED( g_pd3dDevice->CreateIndexBuffer( sizeof(dwIndices), 0,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &m_pIB ,NULL) ) ) return E_FAIL;

VOID* pIndices;

if( FAILED( m_pIB->Lock( 0, sizeof(dwIndices), (void**)&pIndices, 0 ) ) )
return E_FAIL;

memcpy( pIndices, dwIndices, sizeof(dwIndices) );

m_pIB->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,0), 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, // PrimitiveType

0, // StartVertex

2 ); // PrimitiveCount





LPD3DXFONT m_font;

// Create a D3DX font object

D3DXCreateFont( g_pd3dDevice, 20, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
TEXT("Arial"), &m_font );

D3DCOLOR fontColor = D3DCOLOR_ARGB(255,0,0,255);

// Create a rectangle to indicate where on the screen it should be drawn

RECT rct;

rct.left=2;

rct.rightx0;

rct.top;

rct.bottom=rct.top+20;


// Draw some text

m_font->DrawText(NULL, "Uoooooooooooooooooooooo mi primer texto con los
directx", -1, &rct, 0, fontColor );



// 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", "Modelador",

WS_MAXIMIZE, 100, 100, 300, 300,

NULL, NULL, wc.hInstance, NULL );

// Initialize Direct3D

if( SUCCEEDED( InitD3D( hWnd ) ) )

{

// Create the vertex buffer

if( SUCCEEDED( InitVB() ) )

{

// Show the window

ShowWindow( hWnd, SW_MAXIMIZE );

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;

}

//--

// 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.

//--

#define D3D_DEBUG_INFO

#include <d3d9.h>

#include <d3dx9.h>

#pragma warning( disable : 4996 ) // disable deprecated warning

#include <strsafe.h>

#pragma warning( default : 4996 )







//--

// 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

LPDIRECT3DINDEXBUFFER9 m_pIB = NULL;



// 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_HARDWARE_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()

{

CUSTOMVERTEX vertices[]
{ { -50,-50,0.5, 1.0f, 0xffff0000, }, // x, y, z, rhw, tu, tv

{ -50,50,0.5, 1.0f, 0xffff0000,},

{ 50,50,0.5, 1.0f, 0xffff0000,},

{ 50,-50,0.5 , 1.0f, 0xffff0000,},

{ -50,-50,0.5, 1.0f, 0xffff0000,},

{ 50,50,0.5, 1.0f, 0xffff0000, }

};



// Create the vertex buffer

if( FAILED( g_pd3dDevice->CreateVertexBuffer(sizeof(vertices), 0,
D3DFVF_CUSTOMVERTEX, D3DPOOL_MANAGED, &g_pVB,NULL ) ) )

return E_FAIL;

VOID* pVertices;

if( FAILED( g_pVB->Lock( 0, sizeof(vertices), (void**)&pVertices, 0 ) ) )
return E_FAIL;

memcpy( pVertices, vertices, sizeof(vertices)); g_pVB->Unlock(); //
Initialize the Index buffer

WORD dwIndices[] = {0, 1, 2, 0, 2, 3};

if( FAILED( g_pd3dDevice->CreateIndexBuffer( sizeof(dwIndices), 0,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &m_pIB ,NULL) ) ) return E_FAIL;

VOID* pIndices;

if( FAILED( m_pIB->Lock( 0, sizeof(dwIndices), (void**)&pIndices, 0 ) ) )
return E_FAIL;

memcpy( pIndices, dwIndices, sizeof(dwIndices) );

m_pIB->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,0), 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, // PrimitiveType

0, // StartVertex

2 ); // PrimitiveCount





LPD3DXFONT m_font;

// Create a D3DX font object

D3DXCreateFont( g_pd3dDevice, 20, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
TEXT("Arial"), &m_font );

D3DCOLOR fontColor = D3DCOLOR_ARGB(255,0,0,255);

// Create a rectangle to indicate where on the screen it should be drawn

RECT rct;

rct.left=2;

rct.rightx0;

rct.top;

rct.bottom=rct.top+20;


// Draw some text

m_font->DrawText(NULL, "Uoooooooooooooooooooooo mi primer texto con los
directx", -1, &rct, 0, fontColor );



// 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", "Modelador",

WS_MAXIMIZE, 100, 100, 300, 300,

NULL, NULL, wc.hInstance, NULL );

// Initialize Direct3D

if( SUCCEEDED( InitD3D( hWnd ) ) )

{

// Create the vertex buffer

if( SUCCEEDED( InitVB() ) )

{

// Show the window

ShowWindow( hWnd, SW_MAXIMIZE );

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;

}

"RFOG" escribió en el mensaje
news:

La misma, la misma, está claro que no.

Hazte cuenta que el DOOM original está portado a C# (o a C++ manejado, no
recuerdo ahora).

El lenguaje no creo que tenga limitaciones, podrías tener un problema de
rendimiento en el sentido de que en C++ con DirectX podrías tener 6000
polígonos por frame sin problema, y en C# con DirectX, pues 5000 (son
datos de ejemplo, nada más). O en C++ 60 frames por segundo y en C# 40.

Y si no tienes que hacer "cosas raras" yo creo que el C# llega sin
problemas, pero no deja de ser una opinión personal.


It happens that Paul P. Garcia formulated :

Hola.

Parece que ya esta disponible DirectX10.
Quisiera desarrollar un juego como The Moon Project o WarCraft 3 (jejeje)
por lo menos estar seguro que el lenguaje de programacion no tiene
restrincion para desarrollar un juego de esta magnitud.
Eso quiere decir que debo usar puro DirectX ??
No me animo a usar C++ es muy complicado... nunca logre dominarlo
sera posible tener la misma potencia con C# o VB.net ??

Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación

y piensa que incluso algunas rutinas de calculo tengas q ayudarte un poco de
ensamblador.


"Jordi Maycas" escribió en el mensaje
news:

necesitaria ayuda con un codigo se trata del ejemplo del directx sdk
december 2006, vertices, el del triangulo. La cosa es que he añadido otro
triangulo, para hacer un rectangulo y he usado un indice, y no me muestra
nada.

Adjunto codigo.

//--

// 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.

//--

#define D3D_DEBUG_INFO

#include <d3d9.h>

#include <d3dx9.h>

#pragma warning( disable : 4996 ) // disable deprecated warning

#include <strsafe.h>

#pragma warning( default : 4996 )







//--

// 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

LPDIRECT3DINDEXBUFFER9 m_pIB = NULL;



// 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_HARDWARE_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()

{

CUSTOMVERTEX vertices[] >
{ { -50,-50,0.5, 1.0f, 0xffff0000, }, // x, y, z, rhw, tu, tv

{ -50,50,0.5, 1.0f, 0xffff0000,},

{ 50,50,0.5, 1.0f, 0xffff0000,},

{ 50,-50,0.5 , 1.0f, 0xffff0000,},

{ -50,-50,0.5, 1.0f, 0xffff0000,},

{ 50,50,0.5, 1.0f, 0xffff0000, }

};



// Create the vertex buffer

if( FAILED( g_pd3dDevice->CreateVertexBuffer(sizeof(vertices), 0,
D3DFVF_CUSTOMVERTEX, D3DPOOL_MANAGED, &g_pVB,NULL ) ) )

return E_FAIL;

VOID* pVertices;

if( FAILED( g_pVB->Lock( 0, sizeof(vertices), (void**)&pVertices, 0 ) ) )
return E_FAIL;

memcpy( pVertices, vertices, sizeof(vertices)); g_pVB->Unlock(); //
Initialize the Index buffer

WORD dwIndices[] = {0, 1, 2, 0, 2, 3};

if( FAILED( g_pd3dDevice->CreateIndexBuffer( sizeof(dwIndices), 0,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &m_pIB ,NULL) ) ) return E_FAIL;

VOID* pIndices;

if( FAILED( m_pIB->Lock( 0, sizeof(dwIndices), (void**)&pIndices, 0 ) ) )
return E_FAIL;

memcpy( pIndices, dwIndices, sizeof(dwIndices) );

m_pIB->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,0), 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, // PrimitiveType

0, // StartVertex

2 ); // PrimitiveCount





LPD3DXFONT m_font;

// Create a D3DX font object

D3DXCreateFont( g_pd3dDevice, 20, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
TEXT("Arial"), &m_font );

D3DCOLOR fontColor = D3DCOLOR_ARGB(255,0,0,255);

// Create a rectangle to indicate where on the screen it should be drawn

RECT rct;

rct.left=2;

rct.rightx0;

rct.top;

rct.bottom=rct.top+20;


// Draw some text

m_font->DrawText(NULL, "Uoooooooooooooooooooooo mi primer texto con los
directx", -1, &rct, 0, fontColor );



// 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", "Modelador",

WS_MAXIMIZE, 100, 100, 300, 300,

NULL, NULL, wc.hInstance, NULL );

// Initialize Direct3D

if( SUCCEEDED( InitD3D( hWnd ) ) )

{

// Create the vertex buffer

if( SUCCEEDED( InitVB() ) )

{

// Show the window

ShowWindow( hWnd, SW_MAXIMIZE );

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;

}

//--

// 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.

//--

#define D3D_DEBUG_INFO

#include <d3d9.h>

#include <d3dx9.h>

#pragma warning( disable : 4996 ) // disable deprecated warning

#include <strsafe.h>

#pragma warning( default : 4996 )







//--

// 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

LPDIRECT3DINDEXBUFFER9 m_pIB = NULL;



// 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_HARDWARE_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()

{

CUSTOMVERTEX vertices[] >
{ { -50,-50,0.5, 1.0f, 0xffff0000, }, // x, y, z, rhw, tu, tv

{ -50,50,0.5, 1.0f, 0xffff0000,},

{ 50,50,0.5, 1.0f, 0xffff0000,},

{ 50,-50,0.5 , 1.0f, 0xffff0000,},

{ -50,-50,0.5, 1.0f, 0xffff0000,},

{ 50,50,0.5, 1.0f, 0xffff0000, }

};



// Create the vertex buffer

if( FAILED( g_pd3dDevice->CreateVertexBuffer(sizeof(vertices), 0,
D3DFVF_CUSTOMVERTEX, D3DPOOL_MANAGED, &g_pVB,NULL ) ) )

return E_FAIL;

VOID* pVertices;

if( FAILED( g_pVB->Lock( 0, sizeof(vertices), (void**)&pVertices, 0 ) ) )
return E_FAIL;

memcpy( pVertices, vertices, sizeof(vertices)); g_pVB->Unlock(); //
Initialize the Index buffer

WORD dwIndices[] = {0, 1, 2, 0, 2, 3};

if( FAILED( g_pd3dDevice->CreateIndexBuffer( sizeof(dwIndices), 0,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &m_pIB ,NULL) ) ) return E_FAIL;

VOID* pIndices;

if( FAILED( m_pIB->Lock( 0, sizeof(dwIndices), (void**)&pIndices, 0 ) ) )
return E_FAIL;

memcpy( pIndices, dwIndices, sizeof(dwIndices) );

m_pIB->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,0), 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, // PrimitiveType

0, // StartVertex

2 ); // PrimitiveCount





LPD3DXFONT m_font;

// Create a D3DX font object

D3DXCreateFont( g_pd3dDevice, 20, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
TEXT("Arial"), &m_font );

D3DCOLOR fontColor = D3DCOLOR_ARGB(255,0,0,255);

// Create a rectangle to indicate where on the screen it should be drawn

RECT rct;

rct.left=2;

rct.rightx0;

rct.top;

rct.bottom=rct.top+20;


// Draw some text

m_font->DrawText(NULL, "Uoooooooooooooooooooooo mi primer texto con los
directx", -1, &rct, 0, fontColor );



// 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", "Modelador",

WS_MAXIMIZE, 100, 100, 300, 300,

NULL, NULL, wc.hInstance, NULL );

// Initialize Direct3D

if( SUCCEEDED( InitD3D( hWnd ) ) )

{

// Create the vertex buffer

if( SUCCEEDED( InitVB() ) )

{

// Show the window

ShowWindow( hWnd, SW_MAXIMIZE );

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;

}

"RFOG" escribió en el mensaje
news:

La misma, la misma, está claro que no.

Hazte cuenta que el DOOM original está portado a C# (o a C++ manejado, no
recuerdo ahora).

El lenguaje no creo que tenga limitaciones, podrías tener un problema de
rendimiento en el sentido de que en C++ con DirectX podrías tener 6000
polígonos por frame sin problema, y en C# con DirectX, pues 5000 (son
datos de ejemplo, nada más). O en C++ 60 frames por segundo y en C# 40.

Y si no tienes que hacer "cosas raras" yo creo que el C# llega sin
problemas, pero no deja de ser una opinión personal.


It happens that Paul P. Garcia formulated :

Hola.

Parece que ya esta disponible DirectX10.
Quisiera desarrollar un juego como The Moon Project o WarCraft 3
(jejeje) por lo menos estar seguro que el lenguaje de programacion no
tiene restrincion para desarrollar un juego de esta magnitud.
Eso quiere decir que debo usar puro DirectX ??
No me animo a usar C++ es muy complicado... nunca logre dominarlo
sera posible tener la misma potencia con C# o VB.net ??

Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación