487 lines
18 KiB
C++
487 lines
18 KiB
C++
// ---------------------------------------------------------------------------
|
|
//
|
|
// @file TwSimpleDX10.cpp
|
|
// @brief A simple example that uses AntTweakBar with DirectX10.
|
|
// This example draws a triangle and allow the user to tweak its
|
|
// vertex positions and colors.
|
|
//
|
|
// AntTweakBar: http://anttweakbar.sourceforge.net/doc
|
|
// DirectX: http://msdn.microsoft.com/directx
|
|
//
|
|
// @author Philippe Decaudin
|
|
//
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#include <AntTweakBar.h>
|
|
#include <cmath>
|
|
|
|
#include "d3d10vs2003.h" // workaround to include D3D10.h with VS2003
|
|
#include <d3d10.h>
|
|
|
|
|
|
// D3D interface pointers
|
|
ID3D10Device * g_D3DDevice = NULL;
|
|
IDXGISwapChain * g_SwapChain = NULL;
|
|
DXGI_SWAP_CHAIN_DESC g_SwapChainDesc;
|
|
ID3D10RenderTargetView *g_RenderTargetView = NULL;
|
|
ID3D10Effect * g_Effect = NULL;
|
|
ID3D10EffectTechnique * g_Technique = NULL;
|
|
ID3D10InputLayout * g_VertexLayout = NULL;
|
|
ID3D10Buffer * g_VertexBuffer = NULL;
|
|
ID3D10BlendState * g_BlendState = NULL;
|
|
ID3D10RasterizerState * g_RasterState = NULL;
|
|
|
|
const int NB_VERTS = 3;
|
|
|
|
|
|
// Forward declarations
|
|
HRESULT InitDevice(HWND wnd);
|
|
HRESULT InitScene();
|
|
void Cleanup();
|
|
LRESULT CALLBACK MessageProc(HWND, UINT, WPARAM, LPARAM);
|
|
void Render();
|
|
|
|
// Variables
|
|
int g_Angle = 0;
|
|
float g_Scale = 1;
|
|
struct Point { float X, Y; };
|
|
Point g_Positions[NB_VERTS] = { {0.0f, 0.5f}, {0.5f, -0.5f}, {-0.5f, -0.5f} };
|
|
float g_Colors[NB_VERTS][4] = { {0, 1, 1, 1}, {1, 0, 1, 1}, {1, 1, 0, 1} };
|
|
|
|
|
|
// Main
|
|
int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR, int cmdShow)
|
|
{
|
|
// Register our window class
|
|
WNDCLASSEX wcex = { sizeof(WNDCLASSEX), CS_HREDRAW|CS_VREDRAW, MessageProc,
|
|
0L, 0L, instance, NULL, NULL, NULL, NULL, L"TwDX10", NULL };
|
|
RegisterClassEx(&wcex);
|
|
|
|
// Create a window
|
|
RECT rc = { 0, 0, 640, 480 };
|
|
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
|
|
HWND wnd = CreateWindow(L"TwDX10", L"AntTweakBar simple example using DirectX10",
|
|
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
|
|
rc.right-rc.left, rc.bottom-rc.top, NULL, NULL, instance, NULL);
|
|
if( !wnd )
|
|
{
|
|
MessageBox(NULL, L"Cannot create window", L"Error", MB_OK|MB_ICONERROR);
|
|
return 0;
|
|
}
|
|
|
|
// Initialize D3D10
|
|
if( FAILED(InitDevice(wnd)) )
|
|
{
|
|
Cleanup();
|
|
MessageBox(wnd, L"Cannot create D3D10 device", L"Error", MB_OK|MB_ICONERROR);
|
|
return 0;
|
|
}
|
|
|
|
// Initialize the 3D scene
|
|
if( FAILED(InitScene()) )
|
|
{
|
|
Cleanup();
|
|
MessageBox(wnd, L"Scene initialization failed.", L"Error", MB_OK|MB_ICONERROR);
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Initialize AntTweakBar
|
|
if( !TwInit(TW_DIRECT3D10, g_D3DDevice) )
|
|
{
|
|
Cleanup();
|
|
MessageBoxA(wnd, TwGetLastError(), "AntTweakBar initialization failed", MB_OK|MB_ICONERROR);
|
|
return 0;
|
|
}
|
|
|
|
// Create a tweak bar
|
|
TwBar *bar = TwNewBar("TweakBar");
|
|
TwDefine(" GLOBAL help='This example shows how to integrate AntTweakBar in a DirectX10 application.' "); // Message added to the help bar.
|
|
|
|
// Add rotation and scale vars to bar
|
|
TwAddVarRW(bar, "Rotation", TW_TYPE_INT32, &g_Angle,
|
|
" KeyIncr=r KeyDecr=R Help='Rotates the triangle (angle in degree).' ");
|
|
TwAddVarRW(bar, "Scale", TW_TYPE_FLOAT, &g_Scale,
|
|
" Min=-2 Max=2 Step=0.01 KeyIncr=s KeyDecr=S Help='Scales the triangle (1=original size).' ");
|
|
|
|
// Create a new TwType to edit 2D points: a struct that contains two floats
|
|
TwStructMember pointMembers[] = {
|
|
{ "X", TW_TYPE_FLOAT, offsetof(Point, X), " Min=-1 Max=1 Step=0.01 " },
|
|
{ "Y", TW_TYPE_FLOAT, offsetof(Point, Y), " Min=-1 Max=1 Step=0.01 " } };
|
|
TwType pointType = TwDefineStruct("POINT", pointMembers, 2, sizeof(Point), NULL, NULL);
|
|
|
|
// Add color and position of the 3 vertices of the triangle
|
|
TwAddVarRW(bar, "Color0", TW_TYPE_COLOR4F, &g_Colors[0], " Alpha HLS Group='Vertex 0' Label=Color ");
|
|
TwAddVarRW(bar, "Pos0", pointType, &g_Positions[0], " Group='Vertex 0' Label='Position' ");
|
|
TwAddVarRW(bar, "Color1", TW_TYPE_COLOR4F, &g_Colors[1], " Alpha HLS Group='Vertex 1' Label=Color ");
|
|
TwAddVarRW(bar, "Pos1", pointType, &g_Positions[1], " Group='Vertex 1' Label='Position' ");
|
|
TwAddVarRW(bar, "Color2", TW_TYPE_COLOR4F, &g_Colors[2], " Alpha HLS Group='Vertex 2' Label=Color ");
|
|
TwAddVarRW(bar, "Pos2", pointType, &g_Positions[2], " Group='Vertex 2' Label='Position' ");
|
|
|
|
|
|
// Show and update the window
|
|
ShowWindow(wnd, cmdShow);
|
|
UpdateWindow(wnd);
|
|
|
|
// Main message loop.
|
|
// Passive loop: Content is repaint only when needed.
|
|
MSG msg = {0};
|
|
while( GetMessage(&msg, NULL, 0, 0) > 0 )
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
TwTerminate();
|
|
Cleanup();
|
|
|
|
return (int)msg.wParam;
|
|
}
|
|
|
|
|
|
// Create Direct3D device and swap chain
|
|
HRESULT InitDevice(HWND wnd)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
RECT rc;
|
|
GetClientRect(wnd, &rc);
|
|
UINT width = rc.right - rc.left;
|
|
UINT height = rc.bottom - rc.top;
|
|
|
|
UINT createDeviceFlags = 0;
|
|
#ifdef _DEBUG
|
|
createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG;
|
|
#endif
|
|
ZeroMemory(&g_SwapChainDesc, sizeof(g_SwapChainDesc));
|
|
g_SwapChainDesc.BufferCount = 1;
|
|
g_SwapChainDesc.BufferDesc.Width = width;
|
|
g_SwapChainDesc.BufferDesc.Height = height;
|
|
g_SwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
g_SwapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
|
|
g_SwapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
|
|
g_SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
|
|
g_SwapChainDesc.OutputWindow = wnd;
|
|
g_SwapChainDesc.SampleDesc.Count = 1;
|
|
g_SwapChainDesc.SampleDesc.Quality = 0;
|
|
g_SwapChainDesc.Windowed = TRUE;
|
|
g_SwapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
|
|
|
|
// Try to create a hardware accelerated device first
|
|
hr = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags,
|
|
D3D10_SDK_VERSION, &g_SwapChainDesc, &g_SwapChain, &g_D3DDevice);
|
|
if( FAILED(hr) )
|
|
{
|
|
// If failed, try to create a reference device
|
|
hr = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_REFERENCE, NULL, createDeviceFlags,
|
|
D3D10_SDK_VERSION, &g_SwapChainDesc, &g_SwapChain, &g_D3DDevice);
|
|
if( SUCCEEDED(hr) )
|
|
MessageBox(wnd, L"No DX10 hardware acceleration found.\nSwitching to REFERENCE driver (very slow).",
|
|
L"Warning", MB_OK|MB_ICONWARNING);
|
|
else
|
|
return hr;
|
|
}
|
|
|
|
// Create a render target view
|
|
ID3D10Texture2D *buffer;
|
|
hr = g_SwapChain->GetBuffer( 0, __uuidof( ID3D10Texture2D ), (LPVOID*)&buffer );
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
|
|
hr = g_D3DDevice->CreateRenderTargetView( buffer, NULL, &g_RenderTargetView );
|
|
buffer->Release();
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
|
|
g_D3DDevice->OMSetRenderTargets( 1, &g_RenderTargetView, NULL );
|
|
|
|
// Setup the viewport
|
|
D3D10_VIEWPORT vp;
|
|
vp.Width = width;
|
|
vp.Height = height;
|
|
vp.MinDepth = 0.0f;
|
|
vp.MaxDepth = 1.0f;
|
|
vp.TopLeftX = 0;
|
|
vp.TopLeftY = 0;
|
|
g_D3DDevice->RSSetViewports( 1, &vp );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// Initialize the 3D objects & effects
|
|
HRESULT InitScene()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Create effect
|
|
DWORD shaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
|
|
#if defined( DEBUG ) || defined( _DEBUG )
|
|
// shaderFlags |= D3D10_SHADER_DEBUG;
|
|
#endif
|
|
|
|
// DX10 requires shaders (no fixed function anymore). We will read the shaders from the following string.
|
|
char shaderFX[] = " struct PSInput { float4 Pos : SV_POSITION; float4 Col : COLOR0; }; \n"
|
|
" PSInput VertShad(float4 pos : POSITION, float4 col : COLOR) { \n"
|
|
" PSInput ps; ps.Pos=pos; ps.Col=col; return ps; } \n"
|
|
" float4 PixShad(PSInput input) : SV_Target { return input.Col; } \n"
|
|
" technique10 Render { pass P0 { \n"
|
|
" SetVertexShader( CompileShader( vs_4_0, VertShad() ) ); \n"
|
|
" SetGeometryShader( NULL ); \n"
|
|
" SetPixelShader( CompileShader( ps_4_0, PixShad() ) ); \n"
|
|
" } }\n";
|
|
|
|
ID3D10Blob *compiledFX = NULL;
|
|
ID3D10Blob *errors = NULL;
|
|
hr = D3D10CompileEffectFromMemory(shaderFX, strlen(shaderFX), "TestDX10",
|
|
NULL, NULL, shaderFlags, 0, &compiledFX, &errors);
|
|
if( FAILED(hr) )
|
|
{
|
|
char *errMsg = static_cast<char *>(errors->GetBufferPointer());
|
|
errMsg[errors->GetBufferSize()-1] = '\0';
|
|
MessageBoxA( NULL, errMsg, "Effect compilation failed", MB_OK|MB_ICONERROR );
|
|
errors->Release();
|
|
return hr;
|
|
}
|
|
hr = D3D10CreateEffectFromMemory(compiledFX->GetBufferPointer(), compiledFX->GetBufferSize(),
|
|
0, g_D3DDevice, NULL, &g_Effect);
|
|
compiledFX->Release();
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
MessageBox( NULL, L"Effect creation failed", L"Error", MB_OK );
|
|
return hr;
|
|
}
|
|
|
|
// Obtain the technique
|
|
g_Technique = g_Effect->GetTechniqueByName("Render");
|
|
|
|
// Define the input layout
|
|
D3D10_INPUT_ELEMENT_DESC layout[] =
|
|
{
|
|
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
|
|
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 3*sizeof(float), D3D10_INPUT_PER_VERTEX_DATA, 0 }
|
|
};
|
|
|
|
// Create the input layout
|
|
D3D10_PASS_DESC passDesc;
|
|
g_Technique->GetPassByIndex(0)->GetDesc(&passDesc);
|
|
hr = g_D3DDevice->CreateInputLayout(layout, sizeof(layout)/sizeof(layout[0]), passDesc.pIAInputSignature,
|
|
passDesc.IAInputSignatureSize, &g_VertexLayout);
|
|
if( FAILED( hr ) )
|
|
return hr;
|
|
const int VERTEX_SIZE = (3 + 4)*sizeof(float); // 3 floats for POSITION + 4 floats for COLOR
|
|
|
|
// Set the input layout
|
|
g_D3DDevice->IASetInputLayout(g_VertexLayout);
|
|
|
|
// Create vertex buffer
|
|
D3D10_BUFFER_DESC bd;
|
|
bd.Usage = D3D10_USAGE_DYNAMIC;
|
|
bd.ByteWidth = VERTEX_SIZE * NB_VERTS;
|
|
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
|
|
bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
|
|
bd.MiscFlags = 0;
|
|
hr = g_D3DDevice->CreateBuffer(&bd, NULL, &g_VertexBuffer);
|
|
if( FAILED( hr ) )
|
|
return hr;
|
|
|
|
// Set vertex buffer
|
|
UINT stride = VERTEX_SIZE;
|
|
UINT offset = 0;
|
|
g_D3DDevice->IASetVertexBuffers(0, 1, &g_VertexBuffer, &stride, &offset);
|
|
|
|
// Set primitive topology
|
|
g_D3DDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
|
|
// Blend state
|
|
D3D10_BLEND_DESC bsd;
|
|
bsd.AlphaToCoverageEnable = FALSE;
|
|
for(int i=0; i<8; ++i)
|
|
{
|
|
bsd.BlendEnable[i] = TRUE;
|
|
bsd.RenderTargetWriteMask[i] = D3D10_COLOR_WRITE_ENABLE_ALL;
|
|
}
|
|
bsd.SrcBlend = D3D10_BLEND_SRC_ALPHA;
|
|
bsd.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
|
|
bsd.BlendOp = D3D10_BLEND_OP_ADD;
|
|
bsd.SrcBlendAlpha = D3D10_BLEND_SRC_ALPHA;
|
|
bsd.DestBlendAlpha = D3D10_BLEND_INV_SRC_ALPHA;
|
|
bsd.BlendOpAlpha = D3D10_BLEND_OP_ADD;
|
|
g_D3DDevice->CreateBlendState(&bsd, &g_BlendState);
|
|
float blendFactors[4] = { 1, 1, 1, 1 };
|
|
g_D3DDevice->OMSetBlendState(g_BlendState, blendFactors, 0xffffffff);
|
|
|
|
// Rasterizer state
|
|
D3D10_RASTERIZER_DESC rs;
|
|
ZeroMemory(&rs, sizeof(rs));
|
|
rs.FillMode = D3D10_FILL_SOLID;
|
|
rs.CullMode = D3D10_CULL_NONE;
|
|
g_D3DDevice->CreateRasterizerState(&rs, &g_RasterState);
|
|
g_D3DDevice->RSSetState(g_RasterState);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// Clean up D3D objects
|
|
void Cleanup()
|
|
{
|
|
if( g_D3DDevice )
|
|
g_D3DDevice->ClearState();
|
|
|
|
if( g_BlendState )
|
|
g_BlendState->Release();
|
|
if( g_RasterState )
|
|
g_RasterState->Release();
|
|
if( g_VertexBuffer )
|
|
g_VertexBuffer->Release();
|
|
if( g_VertexLayout )
|
|
g_VertexLayout->Release();
|
|
if( g_Effect )
|
|
g_Effect->Release();
|
|
if( g_RenderTargetView )
|
|
g_RenderTargetView->Release();
|
|
if( g_SwapChain && g_SwapChainDesc.Windowed )
|
|
g_SwapChain->Release();
|
|
if( g_D3DDevice )
|
|
g_D3DDevice->Release();
|
|
}
|
|
|
|
|
|
// Called every time the application receives a message
|
|
LRESULT CALLBACK MessageProc(HWND wnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
// Send event message to AntTweakBar
|
|
if( TwEventWin(wnd, message, wParam, lParam) )
|
|
{
|
|
// Event has been handled by AntTweakBar.
|
|
// Note: TwEventWin send a WM_PAINT in this case and
|
|
// the window will be repaint next time.
|
|
return 0;
|
|
}
|
|
|
|
switch(message)
|
|
{
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT ps;
|
|
BeginPaint(wnd, &ps);
|
|
|
|
if( g_D3DDevice )
|
|
Render();
|
|
|
|
EndPaint(wnd, &ps);
|
|
}
|
|
return 0;
|
|
case WM_SIZE: // Window size has been changed
|
|
if( g_D3DDevice ) // Resize D3D render target
|
|
{
|
|
// Release render target
|
|
ID3D10RenderTargetView *nullRTV = NULL;
|
|
g_D3DDevice->OMSetRenderTargets(1, &nullRTV, NULL);
|
|
if( g_RenderTargetView )
|
|
{
|
|
g_RenderTargetView->Release();
|
|
g_RenderTargetView = NULL;
|
|
}
|
|
|
|
if( g_SwapChain )
|
|
{
|
|
// Resize swap chain
|
|
g_SwapChainDesc.BufferDesc.Width = LOWORD(lParam);
|
|
g_SwapChainDesc.BufferDesc.Height = HIWORD(lParam);
|
|
g_SwapChain->ResizeBuffers(g_SwapChainDesc.BufferCount, g_SwapChainDesc.BufferDesc.Width,
|
|
g_SwapChainDesc.BufferDesc.Height, g_SwapChainDesc.BufferDesc.Format, g_SwapChainDesc.Flags);
|
|
|
|
// Re-create a render target view
|
|
ID3D10Texture2D *buffer;
|
|
g_SwapChain->GetBuffer(0, __uuidof( ID3D10Texture2D ), (LPVOID*)&buffer);
|
|
g_D3DDevice->CreateRenderTargetView(buffer, NULL, &g_RenderTargetView);
|
|
buffer->Release();
|
|
g_D3DDevice->OMSetRenderTargets(1, &g_RenderTargetView, NULL);
|
|
|
|
// Setup the viewport
|
|
D3D10_VIEWPORT vp;
|
|
vp.Width = g_SwapChainDesc.BufferDesc.Width;
|
|
vp.Height = g_SwapChainDesc.BufferDesc.Height;
|
|
vp.MinDepth = 0.0f;
|
|
vp.MaxDepth = 1.0f;
|
|
vp.TopLeftX = 0;
|
|
vp.TopLeftY = 0;
|
|
g_D3DDevice->RSSetViewports(1, &vp);
|
|
}
|
|
|
|
// TwWindowSize has been called by TwEventWin32, so it is not necessary to call it again here.
|
|
}
|
|
return 0;
|
|
case WM_CHAR:
|
|
if( wParam==VK_ESCAPE )
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
default:
|
|
return DefWindowProc(wnd, message, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
|
|
// Render scene
|
|
void Render()
|
|
{
|
|
// Update the vertex buffer
|
|
float a = (float)g_Angle * (3.14159265358979f/180.0f);
|
|
float ca = cosf(a);
|
|
float sa = sinf(a);
|
|
float ratio = (float)g_SwapChainDesc.BufferDesc.Height/g_SwapChainDesc.BufferDesc.Width;
|
|
float *vertices;
|
|
g_VertexBuffer->Map(D3D10_MAP_WRITE_DISCARD, 0, (void **)&vertices);
|
|
// Vertex 0 (3 floats for POSITION + 4 floats for COLOR)
|
|
vertices[0*7 + 0] = g_Scale*(ca*g_Positions[0].X - sa*g_Positions[0].Y)*ratio;
|
|
vertices[0*7 + 1] = g_Scale*(sa*g_Positions[0].X + ca*g_Positions[0].Y);
|
|
vertices[0*7 + 2] = 0;
|
|
vertices[0*7 + 3] = g_Colors[0][0];
|
|
vertices[0*7 + 4] = g_Colors[0][1];
|
|
vertices[0*7 + 5] = g_Colors[0][2];
|
|
vertices[0*7 + 6] = g_Colors[0][3];
|
|
// Vertex 1 (3 floats for POSITION + 4 floats for COLOR)
|
|
vertices[1*7 + 0] = g_Scale*(ca*g_Positions[1].X - sa*g_Positions[1].Y)*ratio;
|
|
vertices[1*7 + 1] = g_Scale*(sa*g_Positions[1].X + ca*g_Positions[1].Y);
|
|
vertices[1*7 + 2] = 0;
|
|
vertices[1*7 + 3] = g_Colors[1][0];
|
|
vertices[1*7 + 4] = g_Colors[1][1];
|
|
vertices[1*7 + 5] = g_Colors[1][2];
|
|
vertices[1*7 + 6] = g_Colors[1][3];
|
|
// Vertex 2 (3 floats for POSITION + 4 floats for COLOR)
|
|
vertices[2*7 + 0] = g_Scale*(ca*g_Positions[2].X - sa*g_Positions[2].Y)*ratio;
|
|
vertices[2*7 + 1] = g_Scale*(sa*g_Positions[2].X + ca*g_Positions[2].Y);
|
|
vertices[2*7 + 2] = 0;
|
|
vertices[2*7 + 3] = g_Colors[2][0];
|
|
vertices[2*7 + 4] = g_Colors[2][1];
|
|
vertices[2*7 + 5] = g_Colors[2][2];
|
|
vertices[2*7 + 6] = g_Colors[2][3];
|
|
g_VertexBuffer->Unmap();
|
|
|
|
// Clear the back buffer
|
|
float clearColor[4] = {0.125f, 0.125f, 0.3f, 1.0f};
|
|
g_D3DDevice->ClearRenderTargetView(g_RenderTargetView, clearColor);
|
|
|
|
// Render a triangle
|
|
D3D10_TECHNIQUE_DESC techDesc;
|
|
g_Technique->GetDesc(&techDesc);
|
|
for( UINT p=0; p<techDesc.Passes; ++p )
|
|
{
|
|
g_Technique->GetPassByIndex(p)->Apply(0);
|
|
g_D3DDevice->Draw(3, 0);
|
|
}
|
|
|
|
// Draw tweak bars
|
|
TwDraw();
|
|
|
|
// Present the information rendered to the back buffer to the front buffer (the screen)
|
|
g_SwapChain->Present(0, 0);
|
|
}
|
|
|
|
|