2018-02-22 01:05:17 +03:00
// ImGui Renderer for: DirectX9
// This needs to be used along with a Platform Binding (e.g. Win32)
2018-02-05 22:34:11 +03:00
// Implemented features:
// [X] User texture binding. Use 'LPDIRECT3DTEXTURE9' as ImTextureID. Read the FAQ about ImTextureID in imgui.cpp.
2016-03-24 13:00:47 +03:00
2015-11-29 14:19:30 +03:00
// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
2015-10-13 18:53:43 +03:00
// If you use this binding you'll need to call 4 functions: ImGui_ImplXXXX_Init(), ImGui_ImplXXXX_NewFrame(), ImGui::Render() and ImGui_ImplXXXX_Shutdown().
2015-11-29 14:19:30 +03:00
// If you are new to ImGui, see examples/README.txt and documentation at the top of imgui.cpp.
2015-03-09 16:03:46 +03:00
// https://github.com/ocornut/imgui
2018-02-16 21:18:16 +03:00
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
2018-05-07 12:52:11 +03:00
// 2018-05-07: Render: Saving/restoring Transform because they don't seem to be included in the StateBlock. Setting shading mode to Gouraud.
2018-02-16 21:18:16 +03:00
// 2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplDX9_RenderDrawData() in the .h file so you can call it yourself.
// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
2018-01-29 16:38:46 +03:00
# include "imgui.h"
2015-03-09 16:03:46 +03:00
# include "imgui_impl_dx9.h"
// DirectX
2016-05-03 11:47:42 +03:00
# include <d3d9.h>
2015-03-09 16:03:46 +03:00
# define DIRECTINPUT_VERSION 0x0800
# include <dinput.h>
2018-02-20 15:55:09 +03:00
// DirectX data
2015-03-09 16:03:46 +03:00
static LPDIRECT3DDEVICE9 g_pd3dDevice = NULL ;
static LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL ;
2015-04-09 23:05:35 +03:00
static LPDIRECT3DINDEXBUFFER9 g_pIB = NULL ;
2015-08-14 08:06:11 +03:00
static LPDIRECT3DTEXTURE9 g_FontTexture = NULL ;
static int g_VertexBufferSize = 5000 , g_IndexBufferSize = 10000 ;
2015-03-09 16:03:46 +03:00
struct CUSTOMVERTEX
{
2016-05-03 11:47:42 +03:00
float pos [ 3 ] ;
D3DCOLOR col ;
float uv [ 2 ] ;
2015-03-09 16:03:46 +03:00
} ;
# define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)
2018-02-16 21:18:16 +03:00
// Render function.
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
void ImGui_ImplDX9_RenderDrawData ( ImDrawData * draw_data )
2015-03-09 16:03:46 +03:00
{
2016-05-03 11:47:42 +03:00
// Avoid rendering when minimized
2018-03-13 23:45:09 +03:00
if ( draw_data - > DisplaySize . x < = 0.0f | | draw_data - > DisplaySize . y < = 0.0f )
2016-05-03 11:47:42 +03:00
return ;
2015-08-14 08:13:20 +03:00
// Create and grow buffers if needed
2015-08-14 08:06:11 +03:00
if ( ! g_pVB | | g_VertexBufferSize < draw_data - > TotalVtxCount )
{
2015-08-14 08:13:20 +03:00
if ( g_pVB ) { g_pVB - > Release ( ) ; g_pVB = NULL ; }
2015-08-14 08:06:11 +03:00
g_VertexBufferSize = draw_data - > TotalVtxCount + 5000 ;
if ( g_pd3dDevice - > CreateVertexBuffer ( g_VertexBufferSize * sizeof ( CUSTOMVERTEX ) , D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY , D3DFVF_CUSTOMVERTEX , D3DPOOL_DEFAULT , & g_pVB , NULL ) < 0 )
return ;
}
if ( ! g_pIB | | g_IndexBufferSize < draw_data - > TotalIdxCount )
{
2015-08-14 08:13:20 +03:00
if ( g_pIB ) { g_pIB - > Release ( ) ; g_pIB = NULL ; }
2015-08-14 08:06:11 +03:00
g_IndexBufferSize = draw_data - > TotalIdxCount + 10000 ;
2015-11-08 14:00:31 +03:00
if ( g_pd3dDevice - > CreateIndexBuffer ( g_IndexBufferSize * sizeof ( ImDrawIdx ) , D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY , sizeof ( ImDrawIdx ) = = 2 ? D3DFMT_INDEX16 : D3DFMT_INDEX32 , D3DPOOL_DEFAULT , & g_pIB , NULL ) < 0 )
2015-08-14 08:06:11 +03:00
return ;
}
2016-05-16 03:02:09 +03:00
// Backup the DX9 state
IDirect3DStateBlock9 * d3d9_state_block = NULL ;
2016-05-16 11:54:52 +03:00
if ( g_pd3dDevice - > CreateStateBlock ( D3DSBT_ALL , & d3d9_state_block ) < 0 )
2016-05-16 03:02:09 +03:00
return ;
2016-04-11 19:33:16 +03:00
2018-05-07 12:52:11 +03:00
// Backup the DX9 transform (DX9 documentation suggests that it is included in the StateBlock but it doesn't appear to)
2018-05-03 12:01:41 +03:00
D3DMATRIX last_world , last_view , last_projection ;
g_pd3dDevice - > GetTransform ( D3DTS_WORLD , & last_world ) ;
g_pd3dDevice - > GetTransform ( D3DTS_VIEW , & last_view ) ;
g_pd3dDevice - > GetTransform ( D3DTS_PROJECTION , & last_projection ) ;
2018-05-07 12:52:11 +03:00
// Copy and convert all vertices into a single contiguous buffer, convert colors to DX9 default format.
// FIXME-OPT: This is a waste of resource, the ideal is to use imconfig.h and
// 1) to avoid repacking colors: #define IMGUI_USE_BGRA_PACKED_COLOR
// 2) to avoid repacking vertices: #define IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT struct ImDrawVert { ImVec2 pos; float z; ImU32 col; ImVec2 uv; }
2015-03-09 16:03:46 +03:00
CUSTOMVERTEX * vtx_dst ;
2015-04-09 23:05:35 +03:00
ImDrawIdx * idx_dst ;
2015-07-08 05:17:07 +03:00
if ( g_pVB - > Lock ( 0 , ( UINT ) ( draw_data - > TotalVtxCount * sizeof ( CUSTOMVERTEX ) ) , ( void * * ) & vtx_dst , D3DLOCK_DISCARD ) < 0 )
2015-03-09 16:03:46 +03:00
return ;
2015-07-08 05:17:07 +03:00
if ( g_pIB - > Lock ( 0 , ( UINT ) ( draw_data - > TotalIdxCount * sizeof ( ImDrawIdx ) ) , ( void * * ) & idx_dst , D3DLOCK_DISCARD ) < 0 )
2015-04-09 23:05:35 +03:00
return ;
2015-07-08 05:17:07 +03:00
for ( int n = 0 ; n < draw_data - > CmdListsCount ; n + + )
2015-03-09 16:03:46 +03:00
{
2015-07-08 05:17:07 +03:00
const ImDrawList * cmd_list = draw_data - > CmdLists [ n ] ;
2016-09-03 20:24:57 +03:00
const ImDrawVert * vtx_src = cmd_list - > VtxBuffer . Data ;
for ( int i = 0 ; i < cmd_list - > VtxBuffer . Size ; i + + )
2015-03-09 16:03:46 +03:00
{
2016-05-03 11:47:42 +03:00
vtx_dst - > pos [ 0 ] = vtx_src - > pos . x ;
vtx_dst - > pos [ 1 ] = vtx_src - > pos . y ;
vtx_dst - > pos [ 2 ] = 0.0f ;
2018-05-07 12:52:11 +03:00
vtx_dst - > col = ( vtx_src - > col & 0xFF00FF00 ) | ( ( vtx_src - > col & 0xFF0000 ) > > 16 ) | ( ( vtx_src - > col & 0xFF ) < < 16 ) ; // RGBA --> ARGB for DirectX9
2016-05-03 11:47:42 +03:00
vtx_dst - > uv [ 0 ] = vtx_src - > uv . x ;
vtx_dst - > uv [ 1 ] = vtx_src - > uv . y ;
2015-03-09 16:03:46 +03:00
vtx_dst + + ;
vtx_src + + ;
}
2016-09-03 20:24:57 +03:00
memcpy ( idx_dst , cmd_list - > IdxBuffer . Data , cmd_list - > IdxBuffer . Size * sizeof ( ImDrawIdx ) ) ;
idx_dst + = cmd_list - > IdxBuffer . Size ;
2015-03-09 16:03:46 +03:00
}
g_pVB - > Unlock ( ) ;
2015-04-09 23:05:35 +03:00
g_pIB - > Unlock ( ) ;
2016-05-16 11:54:52 +03:00
g_pd3dDevice - > SetStreamSource ( 0 , g_pVB , 0 , sizeof ( CUSTOMVERTEX ) ) ;
g_pd3dDevice - > SetIndices ( g_pIB ) ;
g_pd3dDevice - > SetFVF ( D3DFVF_CUSTOMVERTEX ) ;
2015-03-09 16:03:46 +03:00
2016-12-20 01:15:38 +03:00
// Setup viewport
D3DVIEWPORT9 vp ;
vp . X = vp . Y = 0 ;
2018-03-13 23:45:09 +03:00
vp . Width = ( DWORD ) draw_data - > DisplaySize . x ;
vp . Height = ( DWORD ) draw_data - > DisplaySize . y ;
2016-12-20 01:15:38 +03:00
vp . MinZ = 0.0f ;
vp . MaxZ = 1.0f ;
g_pd3dDevice - > SetViewport ( & vp ) ;
2018-05-03 12:01:41 +03:00
// Setup render state: fixed-pipeline, alpha-blending, no face culling, no depth testing, shade mode (for gradient)
2016-05-16 11:54:52 +03:00
g_pd3dDevice - > SetPixelShader ( NULL ) ;
g_pd3dDevice - > SetVertexShader ( NULL ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_CULLMODE , D3DCULL_NONE ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_LIGHTING , false ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_ZENABLE , false ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_ALPHABLENDENABLE , true ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_ALPHATESTENABLE , false ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_BLENDOP , D3DBLENDOP_ADD ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_SRCBLEND , D3DBLEND_SRCALPHA ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_DESTBLEND , D3DBLEND_INVSRCALPHA ) ;
g_pd3dDevice - > SetRenderState ( D3DRS_SCISSORTESTENABLE , true ) ;
2018-05-03 12:01:41 +03:00
g_pd3dDevice - > SetRenderState ( D3DRS_SHADEMODE , D3DSHADE_GOURAUD ) ;
2016-05-16 11:54:52 +03:00
g_pd3dDevice - > SetTextureStageState ( 0 , D3DTSS_COLOROP , D3DTOP_MODULATE ) ;
g_pd3dDevice - > SetTextureStageState ( 0 , D3DTSS_COLORARG1 , D3DTA_TEXTURE ) ;
g_pd3dDevice - > SetTextureStageState ( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE ) ;
g_pd3dDevice - > SetTextureStageState ( 0 , D3DTSS_ALPHAOP , D3DTOP_MODULATE ) ;
g_pd3dDevice - > SetTextureStageState ( 0 , D3DTSS_ALPHAARG1 , D3DTA_TEXTURE ) ;
g_pd3dDevice - > SetTextureStageState ( 0 , D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE ) ;
g_pd3dDevice - > SetSamplerState ( 0 , D3DSAMP_MINFILTER , D3DTEXF_LINEAR ) ;
g_pd3dDevice - > SetSamplerState ( 0 , D3DSAMP_MAGFILTER , D3DTEXF_LINEAR ) ;
2015-03-09 16:03:46 +03:00
// Setup orthographic projection matrix
2016-05-03 11:47:42 +03:00
// Being agnostic of whether <d3dx9.h> or <DirectXMath.h> can be used, we aren't relying on D3DXMatrixIdentity()/D3DXMatrixOrthoOffCenterLH() or DirectX::XMMatrixIdentity()/DirectX::XMMatrixOrthographicOffCenterLH()
{
2018-03-13 23:45:09 +03:00
float L = draw_data - > DisplayPos . x + 0.5f ;
float R = draw_data - > DisplayPos . x + draw_data - > DisplaySize . x + 0.5f ;
float T = draw_data - > DisplayPos . y + 0.5f ;
float B = draw_data - > DisplayPos . y + draw_data - > DisplaySize . y + 0.5f ;
2016-05-03 11:47:42 +03:00
D3DMATRIX mat_identity = { { 1.0f , 0.0f , 0.0f , 0.0f , 0.0f , 1.0f , 0.0f , 0.0f , 0.0f , 0.0f , 1.0f , 0.0f , 0.0f , 0.0f , 0.0f , 1.0f } } ;
D3DMATRIX mat_projection =
{
2.0f / ( R - L ) , 0.0f , 0.0f , 0.0f ,
0.0f , 2.0f / ( T - B ) , 0.0f , 0.0f ,
0.0f , 0.0f , 0.5f , 0.0f ,
( L + R ) / ( L - R ) , ( T + B ) / ( B - T ) , 0.5f , 1.0f ,
} ;
g_pd3dDevice - > SetTransform ( D3DTS_WORLD , & mat_identity ) ;
g_pd3dDevice - > SetTransform ( D3DTS_VIEW , & mat_identity ) ;
g_pd3dDevice - > SetTransform ( D3DTS_PROJECTION , & mat_projection ) ;
}
2015-03-09 16:03:46 +03:00
// Render command lists
int vtx_offset = 0 ;
2015-04-09 23:05:35 +03:00
int idx_offset = 0 ;
2015-07-08 05:17:07 +03:00
for ( int n = 0 ; n < draw_data - > CmdListsCount ; n + + )
2015-03-09 16:03:46 +03:00
{
2015-07-08 05:17:07 +03:00
const ImDrawList * cmd_list = draw_data - > CmdLists [ n ] ;
2016-09-03 20:24:57 +03:00
for ( int cmd_i = 0 ; cmd_i < cmd_list - > CmdBuffer . Size ; cmd_i + + )
2015-03-09 16:03:46 +03:00
{
2015-07-08 05:17:07 +03:00
const ImDrawCmd * pcmd = & cmd_list - > CmdBuffer [ cmd_i ] ;
if ( pcmd - > UserCallback )
2015-03-09 18:26:58 +03:00
{
2015-07-08 05:17:07 +03:00
pcmd - > UserCallback ( cmd_list , pcmd ) ;
2015-03-09 18:26:58 +03:00
}
else
{
2015-07-08 05:17:07 +03:00
const RECT r = { ( LONG ) pcmd - > ClipRect . x , ( LONG ) pcmd - > ClipRect . y , ( LONG ) pcmd - > ClipRect . z , ( LONG ) pcmd - > ClipRect . w } ;
2016-05-16 11:54:52 +03:00
g_pd3dDevice - > SetTexture ( 0 , ( LPDIRECT3DTEXTURE9 ) pcmd - > TextureId ) ;
g_pd3dDevice - > SetScissorRect ( & r ) ;
2016-09-03 20:24:57 +03:00
g_pd3dDevice - > DrawIndexedPrimitive ( D3DPT_TRIANGLELIST , vtx_offset , 0 , ( UINT ) cmd_list - > VtxBuffer . Size , idx_offset , pcmd - > ElemCount / 3 ) ;
2015-03-09 18:26:58 +03:00
}
2015-07-08 05:17:07 +03:00
idx_offset + = pcmd - > ElemCount ;
2015-03-09 16:03:46 +03:00
}
2016-09-03 20:24:57 +03:00
vtx_offset + = cmd_list - > VtxBuffer . Size ;
2015-03-09 16:03:46 +03:00
}
2016-04-11 19:33:16 +03:00
2018-05-03 12:01:41 +03:00
// Restore the DX9 transform
g_pd3dDevice - > SetTransform ( D3DTS_WORLD , & last_world ) ;
g_pd3dDevice - > SetTransform ( D3DTS_VIEW , & last_view ) ;
g_pd3dDevice - > SetTransform ( D3DTS_PROJECTION , & last_projection ) ;
2016-05-16 03:02:09 +03:00
// Restore the DX9 state
d3d9_state_block - > Apply ( ) ;
d3d9_state_block - > Release ( ) ;
2015-03-09 16:03:46 +03:00
}
2018-02-20 18:18:02 +03:00
bool ImGui_ImplDX9_Init ( IDirect3DDevice9 * device )
2015-03-09 16:03:46 +03:00
{
g_pd3dDevice = device ;
return true ;
}
2015-03-09 17:55:46 +03:00
void ImGui_ImplDX9_Shutdown ( )
{
ImGui_ImplDX9_InvalidateDeviceObjects ( ) ;
g_pd3dDevice = NULL ;
}
2015-08-14 08:07:53 +03:00
static bool ImGui_ImplDX9_CreateFontsTexture ( )
2015-03-09 17:55:46 +03:00
{
2015-11-29 17:54:05 +03:00
// Build texture atlas
2015-03-09 17:55:46 +03:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
unsigned char * pixels ;
int width , height , bytes_per_pixel ;
2016-02-08 11:03:43 +03:00
io . Fonts - > GetTexDataAsRGBA32 ( & pixels , & width , & height , & bytes_per_pixel ) ;
2015-03-09 17:55:46 +03:00
2015-11-29 17:54:05 +03:00
// Upload texture to graphics system
2015-08-14 08:06:11 +03:00
g_FontTexture = NULL ;
2016-05-03 11:47:42 +03:00
if ( g_pd3dDevice - > CreateTexture ( width , height , 1 , D3DUSAGE_DYNAMIC , D3DFMT_A8R8G8B8 , D3DPOOL_DEFAULT , & g_FontTexture , NULL ) < 0 )
2015-08-14 08:07:53 +03:00
return false ;
2015-03-09 17:55:46 +03:00
D3DLOCKED_RECT tex_locked_rect ;
2016-03-26 17:43:45 +03:00
if ( g_FontTexture - > LockRect ( 0 , & tex_locked_rect , NULL , 0 ) ! = D3D_OK )
2015-08-14 08:07:53 +03:00
return false ;
2015-03-09 17:55:46 +03:00
for ( int y = 0 ; y < height ; y + + )
memcpy ( ( unsigned char * ) tex_locked_rect . pBits + tex_locked_rect . Pitch * y , pixels + ( width * bytes_per_pixel ) * y , ( width * bytes_per_pixel ) ) ;
2015-08-14 08:06:11 +03:00
g_FontTexture - > UnlockRect ( 0 ) ;
2015-03-09 17:55:46 +03:00
// Store our identifier
2015-08-14 08:06:11 +03:00
io . Fonts - > TexID = ( void * ) g_FontTexture ;
2015-05-12 17:16:12 +03:00
2015-08-14 08:07:53 +03:00
return true ;
2015-03-09 17:55:46 +03:00
}
bool ImGui_ImplDX9_CreateDeviceObjects ( )
{
if ( ! g_pd3dDevice )
return false ;
2015-08-14 08:07:53 +03:00
if ( ! ImGui_ImplDX9_CreateFontsTexture ( ) )
return false ;
2015-03-09 17:55:46 +03:00
return true ;
}
2015-03-09 17:13:29 +03:00
void ImGui_ImplDX9_InvalidateDeviceObjects ( )
2015-03-09 16:03:46 +03:00
{
2015-03-09 17:13:29 +03:00
if ( ! g_pd3dDevice )
return ;
2015-03-09 16:03:46 +03:00
if ( g_pVB )
{
g_pVB - > Release ( ) ;
g_pVB = NULL ;
}
2015-04-09 23:05:35 +03:00
if ( g_pIB )
{
g_pIB - > Release ( ) ;
g_pIB = NULL ;
}
2017-06-02 12:23:35 +03:00
// At this point note that we set ImGui::GetIO().Fonts->TexID to be == g_FontTexture, so clear both.
2017-06-02 12:28:48 +03:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
IM_ASSERT ( g_FontTexture = = io . Fonts - > TexID ) ;
2017-06-02 12:23:35 +03:00
if ( g_FontTexture )
g_FontTexture - > Release ( ) ;
2015-10-18 20:05:04 +03:00
g_FontTexture = NULL ;
2017-06-02 12:23:35 +03:00
io . Fonts - > TexID = NULL ;
2015-03-09 17:13:29 +03:00
}
2015-03-09 16:03:46 +03:00
void ImGui_ImplDX9_NewFrame ( )
{
2015-08-14 08:06:11 +03:00
if ( ! g_FontTexture )
2015-03-09 17:55:46 +03:00
ImGui_ImplDX9_CreateDeviceObjects ( ) ;
2015-03-09 16:03:46 +03:00
}