void AmjuGLDX9::Init()
{
AMJU_CALL_STACK;
// Set cullmode
dd->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
Enable(AmjuGL::AMJU_DEPTH_READ);
Disable(AmjuGL::AMJU_LIGHTING);
D3DXCreateMatrixStack( 0, &g_matrixStack );
// Set view matrix to identity and leave it alone
D3DXMATRIX matView;
D3DXMatrixIdentity(&matView);
dd->SetTransform(D3DTS_VIEW, &matView);
// Set texture sampling: if you don't do this you get horible aliased textures.
// TODO Make sure mipmapping is enabled.
dd->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
dd->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
// Mipmap filter
// This shows that mip mapping is on - LINEAR looks best.
// TODO Turn this on when we create mip map data!
// dd->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT); // LINEAR);
// Set up blend mode
dd->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
dd->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
dd->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
// Ignore vertex colours when doing lighting calculations
// -- makes no difference ??!
dd->SetRenderState( D3DRS_COLORVERTEX, FALSE );
}
void InitMatrices(void)
{
msIndex = MAT_MODELVIEW;
// Create the stack objects.
for(int i = 0; i < NUM_MATRIX_STACKS; ++i)
{
if(FAILED(hr = D3DXCreateMatrixStack(0, &matStack[i])))
{
DXError("D3DXCreateMatrixStack");
return;
}
matStack[i]->LoadIdentity();
}
D3DXMatrixIdentity(&identityMatrix);
}
void Renderer::Init( LPDIRECT3DDEVICE9 pD3DDevice, int iXPos, int iYPos, int iWidth, int iHeight, float fPixelRatio )
{
DebugConsole::Log("Renderer: Viewport x%d, y%d, w%d, h%d, pixel%f\n", iXPos, iYPos, iWidth, iHeight, fPixelRatio );
m_pD3DDevice = pD3DDevice;
g_viewport.X = iXPos;
g_viewport.Y = iYPos;
g_viewport.Width = iWidth;
g_viewport.Height = iHeight;
g_viewport.MinZ = 0;
g_viewport.MaxZ = 1;
g_defaultAspect = ((float)iWidth / iHeight) * fPixelRatio;
m_pD3DDevice->CreateDepthStencilSurface(1024, 1024, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, TRUE, &g_depthBuffer, NULL);
/*
if (D3D_OK != m_pD3DDevice->GetDepthStencilSurface(&g_oldDepthBuffer))
{
DebugConsole::Log("Renderer: No default depth buffer\n", iXPos, iYPos, iWidth, iHeight, fPixelRatio );
//OutputDebugString("Vortex INFO: Renderer::Init - Failed to Get old depth stencil\n");
// Create our own
// D3DSURFACE_DESC desc;
// g_backBuffer->GetDesc(&desc);
// g_device->CreateDepthStencilSurface(desc.Width, desc.Height, D3DFMT_LIN_D24S8, 0, &g_oldDepthBuffer);
// g_ownDepth = true;
}
else
{
// g_ownDepth = false;
}
*/
{
char fullname[512];
sprintf_s(fullname, 512, "%sfont.bmp", g_TexturePath );
m_pTextureFont = LoadTexture( fullname, false );
}
D3DXCreateMatrixStack(0, &g_matrixStack);
g_matrixStackLevel = 0;
g_scratchTexture = CreateTexture( 512, 512 );
CompileShaders();
CreateCubeBuffers();
CreateFonts();
}
bool Video_DX9::init_device() {
DWORD num_quality_levels;
while(FAILED(m_d3d->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_A8R8G8B8, m_d3d_parameters.Windowed, m_d3d_parameters.MultiSampleType, &num_quality_levels))) {
switch(m_d3d_parameters.MultiSampleType) {
case D3DMULTISAMPLE_2_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_NONE; preinit_multisampling(0); break;
case D3DMULTISAMPLE_3_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_2_SAMPLES; preinit_multisampling(2); break;
case D3DMULTISAMPLE_4_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_3_SAMPLES; preinit_multisampling(3); break;
case D3DMULTISAMPLE_5_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_4_SAMPLES; preinit_multisampling(4); break;
case D3DMULTISAMPLE_6_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_5_SAMPLES; preinit_multisampling(5); break;
case D3DMULTISAMPLE_7_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_6_SAMPLES; preinit_multisampling(6); break;
case D3DMULTISAMPLE_8_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_7_SAMPLES; preinit_multisampling(7); break;
case D3DMULTISAMPLE_9_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_8_SAMPLES; preinit_multisampling(8); break;
case D3DMULTISAMPLE_10_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_9_SAMPLES; preinit_multisampling(9); break;
case D3DMULTISAMPLE_11_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_10_SAMPLES; preinit_multisampling(10); break;
case D3DMULTISAMPLE_12_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_11_SAMPLES; preinit_multisampling(11); break;
case D3DMULTISAMPLE_13_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_12_SAMPLES; preinit_multisampling(12); break;
case D3DMULTISAMPLE_14_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_13_SAMPLES; preinit_multisampling(13); break;
case D3DMULTISAMPLE_15_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_14_SAMPLES; preinit_multisampling(14); break;
case D3DMULTISAMPLE_16_SAMPLES: m_d3d_parameters.MultiSampleType = D3DMULTISAMPLE_15_SAMPLES; preinit_multisampling(15); break;
case D3DMULTISAMPLE_NONE:
default:
return false;
}
}
const bool try_hardware = (m_d3d_capabilities.VertexProcessingCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) != 0;
if((!try_hardware || FAILED(m_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_d3d_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &m_d3d_parameters, &m_d3d_device))) &&
(!try_hardware || FAILED(m_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_d3d_parameters.hDeviceWindow, D3DCREATE_MIXED_VERTEXPROCESSING, &m_d3d_parameters, &m_d3d_device))) &&
FAILED(m_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_d3d_parameters.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &m_d3d_parameters, &m_d3d_device)))
{
// HARDWARE, MIXED, and SOFTWARE all failed
return false;
}
// Set Up Matrix Stack
D3DXCreateMatrixStack(0, &m_matrix_stack);
m_matrix_stack->LoadIdentity();
return true;
}
bool RendererD3D::InitializeRenderer(HWND hWnd, bool fullScreen, unsigned int sampleState)
{
HRESULT result;
// Create the D3D object.
if( NULL == ( m_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return false;
ZeroMemory( &m_d3dpp, sizeof(m_d3dpp) );
if(fullScreen){
// Set up the structure used to create the D3DDevice for fullscreen mode
D3DDISPLAYMODE dispMode = {0};
// Get the current configuration of the primary monitor
result = m_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &dispMode);
assert(result == D3D_OK);
m_d3dpp.Windowed = FALSE;
m_d3dpp.BackBufferWidth = SCREEN_WIDTH;
m_d3dpp.BackBufferHeight = SCREEN_HEIGHT;
if(sampleState==0){
m_d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
} else if(sampleState==2){
m_d3dpp.MultiSampleType = D3DMULTISAMPLE_2_SAMPLES;
} else if(sampleState==4){
m_d3dpp.MultiSampleType = D3DMULTISAMPLE_4_SAMPLES;
} else {
// invalid sample state was passed in, set to none
m_d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
}
m_d3dpp.FullScreen_RefreshRateInHz = dispMode.RefreshRate;
m_d3dpp.BackBufferFormat = dispMode.Format; // Use the current color depth of the monitor
m_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
m_d3dpp.PresentationInterval = D3DPRESENT_DONOTWAIT;
m_d3dpp.EnableAutoDepthStencil = TRUE;
m_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
} else {
// Set up the structure used to create the D3DDevice for windowed mode
m_d3dpp.Windowed = TRUE;
m_d3dpp.BackBufferWidth = SCREEN_WIDTH;
m_d3dpp.BackBufferHeight = SCREEN_HEIGHT;
if(sampleState==0){
m_d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
} else if(sampleState==2){
m_d3dpp.MultiSampleType = D3DMULTISAMPLE_2_SAMPLES;
} else if(sampleState==4){
m_d3dpp.MultiSampleType = D3DMULTISAMPLE_4_SAMPLES;
} else {
// invalid sample state was passed in, set to none
m_d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
}
m_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
m_d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
m_d3dpp.PresentationInterval = D3DPRESENT_DONOTWAIT;
m_d3dpp.EnableAutoDepthStencil = TRUE;
m_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
}
// Create the D3DDevice
if( FAILED( m_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&m_d3dpp, &m_pd3dDevice ) ) )
{
return false;
}
// Set up the projection matrix.
D3DXMATRIXA16 m_matrixProjection;
D3DXMatrixPerspectiveFovRH( &m_matrixProjection, D3DXToRadian( m_fov ), m_d3dpp.BackBufferWidth / (float) m_d3dpp.BackBufferHeight, 1.0f, 4000.f );
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &m_matrixProjection );
// Turn off D3D lighting
result = m_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
assert(result == D3D_OK);
// Turn on Alpha and setup src/dest blending
result = m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
assert(result == D3D_OK);
result = m_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
assert(result == D3D_OK);
result = m_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
assert(result == D3D_OK);
// Turn on the z-buffer
result = m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );
assert(result == D3D_OK);
//result = m_pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
//assert(result == D3D_OK);
//
//// Set minification filter,
//result = m_pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
//assert(result == D3D_OK);
//
//// Enable mipmapping in general
//result = m_pd3dDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
//assert(result == D3D_OK);
//result = m_pd3dDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
//assert(result == D3D_OK);
//
//// Set minification filter,
//result = m_pd3dDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
//assert(result == D3D_OK);
//
//// Enable mipmapping in general
//result = m_pd3dDevice->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
//assert(result == D3D_OK);
// Turn off culling so that triangles will still be drawn even when turned away from the camera
result = m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
assert(result == D3D_OK);
if(sampleState==2 || sampleState==4){
result = m_pd3dDevice->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, TRUE);
assert(result == D3D_OK);
}
// Setup font data
D3DXCreateFont( m_pd3dDevice, 16, 0, FW_BOLD, 1, FALSE,
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE,
"Arial", &m_pD3DXFont );
m_pStack = (LPD3DXMATRIXSTACK) new LPD3DXMATRIXSTACK;
D3DXCreateMatrixStack( 0, &m_pStack);
result= NULL;
return true;
}
SDL_Renderer *
D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
D3D_RenderData *data;
SDL_SysWMinfo windowinfo;
HRESULT result;
D3DPRESENT_PARAMETERS pparams;
IDirect3DSwapChain9 *chain;
D3DCAPS9 caps;
Uint32 window_flags;
int w, h;
SDL_DisplayMode fullscreen_mode;
D3DMATRIX matrix;
int d3dxVersion;
char d3dxDLLFile[50];
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (D3D_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
SDL_free(renderer);
SDL_OutOfMemory();
return NULL;
}
data->d3dDLL = SDL_LoadObject("D3D9.DLL");
if (data->d3dDLL) {
IDirect3D9 *(WINAPI * D3DCreate) (UINT SDKVersion);
D3DCreate =
(IDirect3D9 * (WINAPI *) (UINT)) SDL_LoadFunction(data->d3dDLL,
"Direct3DCreate9");
if (D3DCreate) {
data->d3d = D3DCreate(D3D_SDK_VERSION);
}
if (!data->d3d) {
SDL_UnloadObject(data->d3dDLL);
data->d3dDLL = NULL;
}
for (d3dxVersion=50;d3dxVersion>0;d3dxVersion--) {
SDL_snprintf(d3dxDLLFile, 49, "D3DX9_%02d.dll", d3dxVersion);
data->d3dxDLL = SDL_LoadObject(d3dxDLLFile);
if (data->d3dxDLL) {
HRESULT (WINAPI *D3DXCreateMatrixStack) (DWORD Flags, LPD3DXMATRIXSTACK* ppStack);
D3DXCreateMatrixStack = (HRESULT (WINAPI *) (DWORD, LPD3DXMATRIXSTACK*)) SDL_LoadFunction(data->d3dxDLL, "D3DXCreateMatrixStack");
if (D3DXCreateMatrixStack) {
D3DXCreateMatrixStack(0, &data->matrixStack);
break;
}
}
}
if (!data->matrixStack) {
if (data->d3dxDLL) SDL_UnloadObject(data->d3dxDLL);
}
}
if (!data->d3d || !data->matrixStack) {
SDL_free(renderer);
SDL_free(data);
SDL_SetError("Unable to create Direct3D interface");
return NULL;
}
renderer->WindowEvent = D3D_WindowEvent;
renderer->CreateTexture = D3D_CreateTexture;
renderer->UpdateTexture = D3D_UpdateTexture;
renderer->LockTexture = D3D_LockTexture;
renderer->UnlockTexture = D3D_UnlockTexture;
renderer->SetRenderTarget = D3D_SetRenderTarget;
renderer->UpdateViewport = D3D_UpdateViewport;
renderer->RenderClear = D3D_RenderClear;
renderer->RenderDrawPoints = D3D_RenderDrawPoints;
renderer->RenderDrawLines = D3D_RenderDrawLines;
renderer->RenderFillRects = D3D_RenderFillRects;
renderer->RenderCopy = D3D_RenderCopy;
renderer->RenderCopyEx = D3D_RenderCopyEx;
renderer->RenderReadPixels = D3D_RenderReadPixels;
renderer->RenderPresent = D3D_RenderPresent;
renderer->DestroyTexture = D3D_DestroyTexture;
renderer->DestroyRenderer = D3D_DestroyRenderer;
renderer->info = D3D_RenderDriver.info;
renderer->driverdata = data;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
SDL_VERSION(&windowinfo.version);
SDL_GetWindowWMInfo(window, &windowinfo);
window_flags = SDL_GetWindowFlags(window);
SDL_GetWindowSize(window, &w, &h);
SDL_GetWindowDisplayMode(window, &fullscreen_mode);
SDL_zero(pparams);
pparams.hDeviceWindow = windowinfo.info.win.window;
pparams.BackBufferWidth = w;
pparams.BackBufferHeight = h;
if (window_flags & SDL_WINDOW_FULLSCREEN) {
pparams.BackBufferFormat =
PixelFormatToD3DFMT(fullscreen_mode.format);
} else {
pparams.BackBufferFormat = D3DFMT_UNKNOWN;
}
pparams.BackBufferCount = 1;
pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;
if (window_flags & SDL_WINDOW_FULLSCREEN) {
pparams.Windowed = FALSE;
pparams.FullScreen_RefreshRateInHz =
fullscreen_mode.refresh_rate;
} else {
pparams.Windowed = TRUE;
pparams.FullScreen_RefreshRateInHz = 0;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
} else {
pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
}
/* FIXME: Which adapter? */
data->adapter = D3DADAPTER_DEFAULT;
IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
result = IDirect3D9_CreateDevice(data->d3d, data->adapter,
D3DDEVTYPE_HAL,
pparams.hDeviceWindow,
D3DCREATE_FPU_PRESERVE | ((caps.
DevCaps &
D3DDEVCAPS_HWTRANSFORMANDLIGHT) ?
D3DCREATE_HARDWARE_VERTEXPROCESSING :
D3DCREATE_SOFTWARE_VERTEXPROCESSING),
&pparams, &data->device);
if (FAILED(result)) {
D3D_DestroyRenderer(renderer);
D3D_SetError("CreateDevice()", result);
return NULL;
}
data->beginScene = SDL_TRUE;
data->scaleMode = D3DTEXF_FORCE_DWORD;
/* Get presentation parameters to fill info */
result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);
if (FAILED(result)) {
D3D_DestroyRenderer(renderer);
D3D_SetError("GetSwapChain()", result);
return NULL;
}
result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);
if (FAILED(result)) {
IDirect3DSwapChain9_Release(chain);
D3D_DestroyRenderer(renderer);
D3D_SetError("GetPresentParameters()", result);
return NULL;
}
IDirect3DSwapChain9_Release(chain);
if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
data->pparams = pparams;
IDirect3DDevice9_GetDeviceCaps(data->device, &caps);
renderer->info.max_texture_width = caps.MaxTextureWidth;
renderer->info.max_texture_height = caps.MaxTextureHeight;
if (caps.NumSimultaneousRTs >= 2) {
renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
}
/* Set up parameters for rendering */
IDirect3DDevice9_SetVertexShader(data->device, NULL);
IDirect3DDevice9_SetFVF(data->device,
D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_ZENABLE, D3DZB_FALSE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
D3DCULL_NONE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);
/* Enable color modulation by diffuse color */
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLOROP,
D3DTOP_MODULATE);
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLORARG1,
D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLORARG2,
D3DTA_DIFFUSE);
/* Enable alpha modulation by diffuse alpha */
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAOP,
D3DTOP_MODULATE);
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAARG1,
D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAARG2,
D3DTA_DIFFUSE);
/* Disable second texture stage, since we're done */
IDirect3DDevice9_SetTextureStageState(data->device, 1, D3DTSS_COLOROP,
D3DTOP_DISABLE);
IDirect3DDevice9_SetTextureStageState(data->device, 1, D3DTSS_ALPHAOP,
D3DTOP_DISABLE);
/* Store the default render target */
IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget );
data->currentRenderTarget = NULL;
/* Set an identity world and view matrix */
matrix.m[0][0] = 1.0f;
matrix.m[0][1] = 0.0f;
matrix.m[0][2] = 0.0f;
matrix.m[0][3] = 0.0f;
matrix.m[1][0] = 0.0f;
matrix.m[1][1] = 1.0f;
matrix.m[1][2] = 0.0f;
matrix.m[1][3] = 0.0f;
matrix.m[2][0] = 0.0f;
matrix.m[2][1] = 0.0f;
matrix.m[2][2] = 1.0f;
matrix.m[2][3] = 0.0f;
matrix.m[3][0] = 0.0f;
matrix.m[3][1] = 0.0f;
matrix.m[3][2] = 0.0f;
matrix.m[3][3] = 1.0f;
IDirect3DDevice9_SetTransform(data->device, D3DTS_WORLD, &matrix);
IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, &matrix);
return renderer;
}
