XBE Step by Step
Once you have properly installed the Xbox SDK, you can start developing Xbox titles. The steps below will take you through the process of creating and running an XBE.

Set up the Development Environment
As long as you have properly installed the Xbox SDK on your development system and used the recovery CD to image your target machine, there is nothing further to install. Make sure that you have set your target system's machine name (per the XDK Launcher topic) so that your development system can find your target system on the network.

Create the Xbox Game Project
Launch the Visual C++ IDE on your development system and create a new Xbox Game project. Select File / New / Projects / Xbox Game from the Visual C++ IDE menu. Enter "first" for the Project Name, enter "C:\first" for the Location, select OK, and then click OK again. You now have a new Xbox Game project.

Write Some Code
You will need some source code to compile. To save time, just add the Vertices tutorial source to your project by selecting Project / Add to Project / Files. Navigate to the "\Samples\Xbox\Graphics\Tutorials\Tut02_Vertices" directory (under the Xbox SDK directory) and select "Vertices.cpp". Click OK to add the file to your project.

The Vertices tutorial relies on d3d8d.lib. To make sure that library gets linked into your program, you'll need to change the project settings. Select Project / Link from the Visual C++ IDE menu and add "d3d8d.lib" to the Object/Library Modules. Before you click OK to accept the changes, you'll need to edit a few more settings.

Click the Xbox Image tab of the Project Settings dialog box. Select Title Info for the Category. Enter "0x00000001" for Title ID, enter "My First XBE" for Title Name, and enter "Joe Publisher" for Publisher Name.

That's it. You can now click OK and accept these project settings.

Build the XBE
Select Build / Build first.xbe from the Visual C++ IDE menu to build your XBE. You should have 0 errors and 0 warnings.

Copy the XBE to the Target System
Assuming the machine name of your target system is "xdk-target", you can copy your XBE to the target system by opening a Windows command prompt and issuing the following commands:

xbmkdir -x xdk-target xE:\first
xbcp C:\first\Debug\first.xbe xE:\first
xbreboot

The call to XbReboot is optional—if the XDK Launcher is running on the target system, you don't need to do a remote reboot.

Launch the XBE
On the target system, navigate to your newly created XBE ("My First XBE (FIRST)") in the XDK Launcher and select it by pressing the A button on the controller. You should see a colorful triangle. You have just created your first Xbox executable.

"Select Project / Link from the Visual C++ IDE menu and add "d3d8d.lib" to the Object/Library Modules."

There is no "Link" option under "Project"

------ Build started: Project: Try 3, Configuration: Debug Xbox ------
Project up-to-date
---------------------- Done ----------------------

Build: 1 succeeded, 0 failed, 0 skipped

------ Rebuild All started: Project: Try 3, Configuration: Debug Xbox ------
Deleting intermediate files and output files for project 'Try 3', configuration 'Debug|Xbox'.
Compiling...
vertices.cpp
Linking...
Creating Xbox Image...
IMAGEBLD : warning IM1040: mismatched map file 'c:\Builds\First\Try 3\Debug\Try 3.map'
Copying files to the Xbox...

Build log was saved at "file://c:\Builds\First\Try 3\Debug\BuildLog.htm"
Try 3 - 0 error(s), 1 warning(s)
---------------------- Done ----------------------

Rebuild All: 1 succeeded, 0 failed, 0 skipped

//-----------------------------------------------------------------------------
// 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 viewport coordinates) and lit (meaning we are not
// using Direct3D lighting, but are supplying our own colors).
//
// Copyright © Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include <xtl.h>




//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
LPDIRECT3D8 g_pD3D = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE8 g_pd3dDevice = NULL; // Our rendering device
LPDIRECT3DVERTEXBUFFER8 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()
{
// Create the D3D object.
if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
return E_FAIL;

// Set up the structure used to create the D3DDevice.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.BackBufferWidth = 640;
d3dpp.BackBufferHeight = 480;
d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
d3dpp.BackBufferCount = 1;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

// Create the Direct3D device.
if( FAILED( g_pD3D->CreateDevice( 0, D3DDEVTYPE_HAL, NULL,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
return E_FAIL;

// After creating the device, initial 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 the ycan 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 g_Vertices[] =
{
{ 320.0f, 150.0f, 0.5f, 1.0f, 0xffff0000, }, // x, y, z, rhw, color
{ 420.0f, 330.0f, 0.5f, 1.0f, 0xff00ff00, },
{ 220.0f, 330.0f, 0.5f, 1.0f, 0xff00ffff, },
};

// 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),
D3DUSAGE_WRITEONLY,
D3DFVF_CUSTOMVERTEX,
D3DPOOL_MANAGED, &g_pVB ) ) )
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 because vertex
// buffers may be in device memory.
CUSTOMVERTEX* pVertices;
if( FAILED( g_pVB->Lock( 0, 0, (BYTE**)&pVertices, 0 ) ) )
return E_FAIL;
memcpy( pVertices, g_Vertices, 3*sizeof(CUSTOMVERTEX) );
g_pVB->Unlock();

return S_OK;
}




//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Draws the scene
//-----------------------------------------------------------------------------
VOID Render()
{
// Clear the backbuffer to a blue color
g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB(0,0,255), 1.0f, 0L );

// 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 many 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, sizeof(CUSTOMVERTEX) );
g_pd3dDevice->SetVertexShader( D3DFVF_CUSTOMVERTEX );
g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 1 );
}




//-----------------------------------------------------------------------------
// Name: main()
// Desc: The application's entry point
//-----------------------------------------------------------------------------
void __cdecl main()
{
// Initialize Direct3D
if( FAILED( InitD3D() ) )
return;

// Initialize the vertex buffer
InitVB();

while( TRUE )
{
// Render the scene
Render();

// Present the backbuffer contents to the display
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
}