OpenBarnyard
 
Loading...
Searching...
No Matches
AGUI2Renderer_DX8.cpp
Go to the documentation of this file.
1#include "pch.h"
2#include "AGUI2Renderer_DX8.h"
3
4#include "Assets/AMaterialLibraryManager.h"
5#include "GUI/AGUI2.h"
6
7#ifdef TOSHI_SKU_WINDOWS
8# include "Platform/DX8/TTextureResourceHAL_DX8.h"
9# include "Platform/DX8/TRenderInterface_DX8.h"
10#endif // TOSHI_SKU_WINDOWS
11
12//-----------------------------------------------------------------------------
13// Enables memory debugging.
14// Note: Should be the last include!
15//-----------------------------------------------------------------------------
16#include <Core/TMemoryDebugOn.h>
17
18TOSHI_NAMESPACE_USING
19
20AGUI2RendererDX8::AGUI2RendererDX8()
21{
22 m_pTransforms = new AGUI2Transform[ MAX_NUM_TRANSFORMS ];
23 m_iTransformCount = 0;
24 m_bIsTransformDirty = TFALSE;
25}
26
27AGUI2RendererDX8::~AGUI2RendererDX8()
28{
29 delete[] m_pTransforms;
30}
31
32AGUI2Material* AGUI2RendererDX8::CreateMaterial( const TCHAR* a_szTextureName )
33{
34 return CreateMaterial(
35 GetTexture( a_szTextureName )
36 );
37}
38
39AGUI2Material* AGUI2RendererDX8::CreateMaterial( Toshi::TTexture* a_pTexture )
40{
41 auto pMaterial = new AGUI2Material;
42
43 pMaterial->Create();
44 pMaterial->m_pTextureResource = a_pTexture;
45
46 return pMaterial;
47}
48
49void AGUI2RendererDX8::DestroyMaterial( AGUI2Material* a_pMaterial )
50{
51 if ( a_pMaterial )
52 {
53 a_pMaterial->OnDestroy();
54 delete a_pMaterial;
55 }
56}
57
58Toshi::TTexture* AGUI2RendererDX8::GetTexture( const TCHAR* a_szTextureName )
59{
60 return AMaterialLibraryManager::GetSingleton()->FindTexture( a_szTextureName );
61}
62
63TUINT AGUI2RendererDX8::GetWidth( AGUI2Material* a_pMaterial )
64{
65 return a_pMaterial->m_pTextureResource->GetWidth();
66}
67
68TUINT AGUI2RendererDX8::GetHeight( AGUI2Material* a_pMaterial )
69{
70 return a_pMaterial->m_pTextureResource->GetHeight();
71}
72
73void AGUI2RendererDX8::BeginScene()
74{
75 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
76 auto pD3DDevice = pRender->GetDirect3DDevice();
77
78 TRenderD3DInterface::FlushShaders();
79 auto pDisplayParams = pRender->GetCurrentDisplayParams();
80
81 TFLOAT fRootWidth;
82 TFLOAT fRootHeight;
83 AGUI2::GetContext()->GetRootElement()->GetDimensions( fRootWidth, fRootHeight );
84
85 auto& rTransform = m_pTransforms[ m_iTransformCount ];
86 rTransform.m_aMatrixRows[ 0 ] = { pDisplayParams->uiWidth / fRootWidth, 0.0f };
87 rTransform.m_aMatrixRows[ 1 ] = { 0.0f, -TFLOAT( pDisplayParams->uiHeight ) / fRootHeight };
88 rTransform.m_vecTranslation = { 0.0f, 0.0f };
89
90 static TUINT32 s_MatrixFlags = 0;
91 static Toshi::TMatrix44 s_IdentityMatrix;
92
93 if ( ( s_MatrixFlags & 1 ) == 0 )
94 {
95 s_MatrixFlags |= 1;
96 s_IdentityMatrix = TMatrix44::IDENTITY;
97 }
98
99 pD3DDevice->SetTransform( D3DTS_WORLDMATRIX( 0 ), (D3DMATRIX*)&s_IdentityMatrix );
100 pD3DDevice->SetTransform( D3DTS_VIEW, (D3DMATRIX*)&s_IdentityMatrix );
101
102 TMatrix44 projection = {
103 2.0f / (TFLOAT)pDisplayParams->uiWidth, 0.0f, 0.0f, 0.0f,
104 0.0f, 2.0f / (TFLOAT)pDisplayParams->uiHeight, 0.0f, 0.0f,
105 0.0f, 0.0f, 1.0f, 0.0f,
106 0.0f, 0.0f, 0.0f, 1.0f
107 };
108
109 pD3DDevice->SetTransform( D3DTS_PROJECTION, (D3DMATRIX*)&projection );
110 pD3DDevice->SetVertexShader( 322 );
111 pD3DDevice->SetPixelShader( 0 );
112 pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, 1 );
113 pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, 0 );
114 pD3DDevice->SetRenderState( D3DRS_LIGHTING, 0 );
115 pD3DDevice->SetRenderState( D3DRS_FOGENABLE, 0 );
116 pD3DDevice->SetRenderState( D3DRS_ZFUNC, 8 );
117 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 0 );
118 pD3DDevice->SetRenderState( D3DRS_CULLMODE, 1 );
119
120 SetColour( 0xFFFFFFFF );
121 m_pMaterial = TNULL;
122
123 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
124 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
125 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
126 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
127 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 5 );
128 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 6 );
129 pD3DDevice->SetRenderState( D3DRS_ZBIAS, 0 );
130 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, 2 );
131 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, 0 );
132 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, 2 );
133 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, 0 );
134 pD3DDevice->SetTextureStageState( 0, D3DTSS_MIPMAPLODBIAS, 0 );
135 pD3DDevice->SetTextureStageState( 1, D3DTSS_COLOROP, 1 );
136 pD3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, 1 );
137 sm_bUnknownFlag = TFALSE;
138}
139
140void AGUI2RendererDX8::EndScene()
141{
142 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
143 auto pD3DDevice = pRender->GetDirect3DDevice();
144
145 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 1 );
146 pD3DDevice->SetRenderState( D3DRS_ZFUNC, 4 );
147 pD3DDevice->SetRenderState( D3DRS_ZBIAS, 0 );
148 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
149 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
150 pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, 0 );
151 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
152 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
153 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, 2 );
154 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, 0 );
155 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, 2 );
156 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, 0 );
157 pD3DDevice->SetTextureStageState( 0, D3DTSS_MIPMAPLODBIAS, 0 );
158 pD3DDevice->SetTexture( 1, NULL );
159 pD3DDevice->SetTextureStageState( 1, D3DTSS_COLOROP, 1 );
160 pD3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, 1 );
161 pRender->SetTextureAddress( 0, ADDRESSINGMODE_WRAP, TEXCOORD_UV );
162}
163
164void AGUI2RendererDX8::ResetRenderer()
165{
166 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
167 auto pD3DDevice = pRender->GetDirect3DDevice();
168
169 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
170 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 1 );
171 pD3DDevice->SetRenderState( D3DRS_ZFUNC, 4 );
172 pD3DDevice->SetRenderState( D3DRS_ZBIAS, 0 );
173 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
174 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
175 pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, 0 );
176 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
177 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
178 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, 2 );
179 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, 0 );
180 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, 2 );
181 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, 0 );
182 pD3DDevice->SetTextureStageState( 0, D3DTSS_MIPMAPLODBIAS, 0 );
183 pD3DDevice->SetTexture( 1, NULL );
184 pD3DDevice->SetTextureStageState( 1, D3DTSS_COLOROP, 1 );
185 pD3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, 1 );
186}
187
188void AGUI2RendererDX8::PrepareRenderer()
189{
190 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
191 auto pD3DDevice = pRender->GetDirect3DDevice();
192
193 auto pDisplayParams = pRender->GetCurrentDisplayParams();
194
195 static TUINT32 s_MatrixFlags = 0;
196 static Toshi::TMatrix44 s_IdentityMatrix;
197
198 if ( ( s_MatrixFlags & 1 ) == 0 )
199 {
200 s_MatrixFlags |= 1;
201 s_IdentityMatrix = TMatrix44::IDENTITY;
202 }
203
204 pD3DDevice->SetTransform( D3DTS_WORLDMATRIX( 0 ), (D3DMATRIX*)&s_IdentityMatrix );
205 pD3DDevice->SetTransform( D3DTS_VIEW, (D3DMATRIX*)&s_IdentityMatrix );
206
207 TMatrix44 projection = {
208 2.0f / (TFLOAT)pDisplayParams->uiWidth, 0.0f, 0.0f, 0.0f,
209 0.0f, 2.0f / (TFLOAT)pDisplayParams->uiHeight, 0.0f, 0.0f,
210 0.0f, 0.0f, 1.0f, 0.0f,
211 0.0f, 0.0f, 0.0f, 1.0f
212 };
213
214 pD3DDevice->SetTransform( D3DTS_PROJECTION, (D3DMATRIX*)&projection );
215 pD3DDevice->SetVertexShader( 322 );
216 pD3DDevice->SetPixelShader( 0 );
217 pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, 1 );
218 pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, 0 );
219 pD3DDevice->SetRenderState( D3DRS_LIGHTING, 0 );
220 pD3DDevice->SetRenderState( D3DRS_FOGENABLE, 0 );
221 pD3DDevice->SetRenderState( D3DRS_ZFUNC, 8 );
222 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 0 );
223 pD3DDevice->SetRenderState( D3DRS_CULLMODE, 1 );
224
225 sm_fZCoordinate = 0.1f;
226
227 // Force material to update
228 auto pMaterial = m_pMaterial;
229 m_pMaterial = (AGUI2Material*)( ~(uintptr_t)pMaterial );
230 SetMaterial( pMaterial );
231
232 // Force colour to update
233 auto uiColour = m_uiColour;
234 m_uiColour = ~uiColour;
235 SetColour( uiColour );
236
237 m_bIsTransformDirty = TTRUE;
238}
239
240void AGUI2RendererDX8::SetMaterial( AGUI2Material* a_pMaterial )
241{
242 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
243 auto pD3DDevice = pRender->GetDirect3DDevice();
244
245 if ( a_pMaterial == m_pMaterial )
246 {
247 return;
248 }
249
250 pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, 0 );
251 pD3DDevice->SetRenderState( D3DRS_CULLMODE, 1 );
252 sm_fZCoordinate = 0.1f;
253
254 if ( a_pMaterial == TNULL )
255 {
256 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
257 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
258 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
259 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
260 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 5 );
261 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 6 );
262 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, 2 );
263 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, 0 );
264 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, 2 );
265 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, 0 );
266 pD3DDevice->SetTextureStageState( 0, D3DTSS_MIPMAPLODBIAS, 0 );
267 pD3DDevice->SetTextureStageState( 1, D3DTSS_COLOROP, 1 );
268 pD3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, 1 );
269 m_pMaterial = TNULL;
270 }
271 else
272 {
273 auto pTexture = TSTATICCAST( Toshi::TTextureResourceHAL, a_pMaterial->m_pTextureResource );
274 pTexture->Validate();
275
276 pD3DDevice->SetTexture( 0, pTexture->GetD3DTexture() );
277 pRender->SetTextureAddress( 0, pTexture->GetAddressing(), TEXCOORD_UV );
278
279 switch ( a_pMaterial->m_eBlendState )
280 {
281 case 0:
282 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 0 );
283 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
284 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
285 break;
286 case 1:
287 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
288 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
289 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
290 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
291 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 5 );
292 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 6 );
293 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 0 );
294 break;
295 case 2:
296 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
297 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
298 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
299 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
300 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 5 );
301 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 2 );
302 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 0 );
303 break;
304 case 3:
305 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
306 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
307 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
308 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 3 );
309 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 5 );
310 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 2 );
311 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 0 );
312 break;
313 case 4:
314 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 1 );
315 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 2 );
316 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
317 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
318 pD3DDevice->SetRenderState( D3DRS_ZENABLE, 1 );
319 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 1 );
320 pD3DDevice->SetRenderState( D3DRS_ZFUNC, 4 );
321 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0x3c );
322 pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, 1 );
323 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 7 );
324
325 if ( !sm_bUnknownFlag )
326 {
327 sm_fZCoordinate = 0.05f;
328 }
329 else
330 {
331 sm_fZCoordinate = 0.02f;
332 }
333
334 break;
335 case 5:
336 pD3DDevice->SetRenderState( D3DRS_ZENABLE, 1 );
337 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 0 );
338 pD3DDevice->SetRenderState( D3DRS_ZFUNC, 4 );
339 pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, 0 );
340 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
341 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
342 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 5 );
343 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 6 );
344 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
345
346 if ( sm_bUnknownFlag )
347 {
348 sm_fZCoordinate = 0.03f;
349 sm_bUnknownFlag = TFALSE;
350 }
351
352 break;
353 case 6:
354 pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, 0 );
355 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
356 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
357 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
358 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
359 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 5 );
360 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 6 );
361 pD3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, 1 );
362 pD3DDevice->SetRenderState( D3DRS_ZFUNC, 4 );
363 sm_fZCoordinate = 0.04f;
364 sm_bUnknownFlag = TTRUE;
365 break;
366 default:
367 pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, 1 );
368 pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, 5 );
369 pD3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
370 pD3DDevice->SetRenderState( D3DRS_BLENDOP, 1 );
371 pD3DDevice->SetRenderState( D3DRS_SRCBLEND, 5 );
372 pD3DDevice->SetRenderState( D3DRS_DESTBLEND, 6 );
373 break;
374 }
375
376 if ( a_pMaterial->m_eTextureAddress == 1 )
377 {
378 pD3DDevice->SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
379 pD3DDevice->SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
380 }
381 else if ( a_pMaterial->m_eTextureAddress == 2 )
382 {
383 pD3DDevice->SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_MIRROR );
384 pD3DDevice->SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_MIRROR );
385 }
386 else
387 {
388 pD3DDevice->SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP );
389 pD3DDevice->SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP );
390 }
391
392 pD3DDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, 2 );
393 pD3DDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, 2 );
394 pD3DDevice->SetTextureStageState( 0, D3DTSS_MIPFILTER, 1 );
395 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, 4 );
396 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, 2 );
397 pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, 0 );
398 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, 4 );
399 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, 2 );
400 pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, 0 );
401 pD3DDevice->SetTextureStageState( 0, D3DTSS_MIPMAPLODBIAS, a_pMaterial->m_iMipMapLODBias );
402 pD3DDevice->SetTextureStageState( 1, D3DTSS_COLOROP, 1 );
403 pD3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, 1 );
404 m_pMaterial = a_pMaterial;
405 }
406}
407
408void AGUI2RendererDX8::PushTransform( const AGUI2Transform& a_rTransform, const Toshi::TVector2& a_rVec1, const Toshi::TVector2& a_rVec2 )
409{
410 TASSERT( m_iTransformCount < MAX_NUM_TRANSFORMS );
411 auto pTransform = m_pTransforms + ( m_iTransformCount++ );
412
413 AGUI2Transform transform1 = *pTransform;
414 AGUI2Transform transform2 = a_rTransform;
415
416 TVector2 vec;
417 transform1.Transform( vec, a_rVec1 );
418 transform1.m_vecTranslation = { vec.x, vec.y };
419
420 transform2.Transform( vec, a_rVec2 );
421 transform2.m_vecTranslation = { vec.x, vec.y };
422
423 AGUI2Transform::Multiply( m_pTransforms[ m_iTransformCount ], transform1, transform2 );
424 m_bIsTransformDirty = TTRUE;
425}
426
427void AGUI2RendererDX8::PopTransform()
428{
429 TASSERT( m_iTransformCount >= 0 );
430 m_iTransformCount -= 1;
431 m_bIsTransformDirty = TTRUE;
432}
433
434void AGUI2RendererDX8::SetTransform( const AGUI2Transform& a_rTransform )
435{
436 m_pTransforms[ m_iTransformCount ] = a_rTransform;
437 m_bIsTransformDirty = TTRUE;
438}
439
440void AGUI2RendererDX8::SetColour( TUINT32 a_uiColour )
441{
442 m_uiColour = a_uiColour;
443}
444
445void AGUI2RendererDX8::SetScissor( TFLOAT a_fVal1, TFLOAT a_fVal2, TFLOAT a_fVal3, TFLOAT a_fVal4 )
446{
447 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
448 auto pD3DDevice = pRender->GetDirect3DDevice();
449
450 auto pDisplayParams = pRender->GetCurrentDisplayParams();
451 auto pTransform = m_pTransforms + m_iTransformCount;
452
453 TVector2 transformed1;
454 pTransform->Transform( transformed1, { a_fVal1, a_fVal2 } );
455
456 TVector2 transformed2;
457 pTransform->Transform( transformed2, { a_fVal3, a_fVal4 } );
458
459 transformed1.x = ( pDisplayParams->uiWidth / 2.0f ) + transformed1.x;
460 transformed2.x = ( pDisplayParams->uiWidth / 2.0f ) + transformed2.x;
461 transformed1.y = ( pDisplayParams->uiHeight / 2.0f ) - transformed1.y;
462 transformed2.y = ( pDisplayParams->uiHeight / 2.0f ) - transformed2.y;
463
464 DWORD iLeft = TMath::Max( TMath::FloorToInt( transformed1.x ), 0 );
465 DWORD iRight = TMath::Min( TMath::CeilToInt( transformed2.x ), TINT( pDisplayParams->uiWidth ) );
466 DWORD iTop = TMath::Max( TMath::FloorToInt( transformed2.y ), 0 );
467 DWORD iBottom = TMath::Min( TMath::FloorToInt( transformed1.y ), TINT( pDisplayParams->uiHeight ) );
468
469 D3DVIEWPORT8 viewport = {
470 .X = iLeft,
471 .Y = iTop,
472 .Width = iRight - iLeft,
473 .Height = iBottom - iTop,
474 .MinZ = 0.0f,
475 .MaxZ = 1.0f
476 };
477
478 if ( viewport.Width == 0 )
479 {
480 viewport.Width = 1;
481 }
482
483 if ( viewport.Height == 0 )
484 {
485 viewport.Height = 1;
486 }
487
488 pD3DDevice->SetViewport( &viewport );
489
490 static TUINT32 s_MatrixFlags = 0;
491 static Toshi::TMatrix44 s_IdentityMatrix;
492
493 if ( ( s_MatrixFlags & 1 ) == 0 )
494 {
495 s_MatrixFlags |= 1;
496 s_IdentityMatrix = TMatrix44::IDENTITY;
497 }
498
499 pD3DDevice->SetTransform( D3DTS_WORLDMATRIX( 0 ), (D3DMATRIX*)&s_IdentityMatrix );
500 pD3DDevice->SetTransform( D3DTS_VIEW, (D3DMATRIX*)&s_IdentityMatrix );
501
502 TMatrix44 projection;
503 SetupProjectionMatrix( projection, iLeft, iRight, iTop, iBottom );
504 pD3DDevice->SetTransform( D3DTS_PROJECTION, (D3DMATRIX*)&projection );
505}
506
507void AGUI2RendererDX8::ClearScissor()
508{
509 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
510 auto pD3DDevice = pRender->GetDirect3DDevice();
511
512 auto pDisplayParams = pRender->GetCurrentDisplayParams();
513
514 D3DVIEWPORT8 viewport = {
515 .X = 0,
516 .Y = 0,
517 .Width = pDisplayParams->uiWidth,
518 .Height = pDisplayParams->uiHeight,
519 .MinZ = 0.0f,
520 .MaxZ = 1.0f
521 };
522
523 pD3DDevice->SetViewport( &viewport );
524
525 static TUINT32 s_MatrixFlags = 0;
526 static Toshi::TMatrix44 s_IdentityMatrix;
527
528 if ( ( s_MatrixFlags & 1 ) == 0 )
529 {
530 s_MatrixFlags |= 1;
531 s_IdentityMatrix = TMatrix44::IDENTITY;
532 }
533
534 pD3DDevice->SetTransform( D3DTS_WORLDMATRIX( 0 ), (D3DMATRIX*)&s_IdentityMatrix );
535 pD3DDevice->SetTransform( D3DTS_VIEW, (D3DMATRIX*)&s_IdentityMatrix );
536
537 TMatrix44 projection;
538 SetupProjectionMatrix( projection, viewport.X, viewport.Width + viewport.X, viewport.Y, viewport.Height + viewport.Y );
539 pD3DDevice->SetTransform( D3DTS_PROJECTION, (D3DMATRIX*)&projection );
540}
541
542void AGUI2RendererDX8::RenderRectangle( const Toshi::TVector2& a, const Toshi::TVector2& b, const Toshi::TVector2& uv1, const Toshi::TVector2& uv2 )
543{
544 if ( m_bIsTransformDirty )
545 {
546 UpdateTransform();
547 }
548
549 sm_Vertices[ 0 ].Position = { a.x, a.y, sm_fZCoordinate };
550 sm_Vertices[ 0 ].Colour = m_uiColour;
551 sm_Vertices[ 0 ].UV = { uv1.x, uv1.y };
552
553 sm_Vertices[ 1 ].Position = { b.x, a.y, sm_fZCoordinate };
554 sm_Vertices[ 1 ].Colour = m_uiColour;
555 sm_Vertices[ 1 ].UV = { uv2.x, uv1.y };
556
557 sm_Vertices[ 2 ].Position = { a.x, b.y, sm_fZCoordinate };
558 sm_Vertices[ 2 ].Colour = m_uiColour;
559 sm_Vertices[ 2 ].UV = { uv1.x, uv2.y };
560
561 sm_Vertices[ 3 ].Position = { b.x, b.y, sm_fZCoordinate };
562 sm_Vertices[ 3 ].Colour = m_uiColour;
563 sm_Vertices[ 3 ].UV = { uv2.x, uv2.y };
564
565 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
566 pRender->GetDirect3DDevice()->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, sm_Vertices, sizeof( Vertex ) );
567}
568
569void AGUI2RendererDX8::RenderTriStrip( Toshi::TVector2* vertices, Toshi::TVector2* UV, uint32_t numverts )
570{
571 TIMPLEMENT();
572}
573
574void AGUI2RendererDX8::RenderLine( const Toshi::TVector2& a, const Toshi::TVector2& b )
575{
576 auto pMaterial = m_pMaterial;
577 SetMaterial( TNULL );
578
579 if ( m_bIsTransformDirty )
580 {
581 UpdateTransform();
582 }
583
584 sm_Vertices[ 0 ].Position = { a.x, a.y, 0.0f };
585 sm_Vertices[ 0 ].Colour = m_uiColour;
586 sm_Vertices[ 0 ].UV = { 0.0f, 0.0f };
587
588 sm_Vertices[ 1 ].Position = { b.x, b.y, 0.0f };
589 sm_Vertices[ 1 ].Colour = m_uiColour;
590 sm_Vertices[ 1 ].UV = { 0.0f, 0.0f };
591
592 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
593 pRender->GetDirect3DDevice()->DrawPrimitiveUP( D3DPT_LINELIST, 1, sm_Vertices, sizeof( Vertex ) );
594
595 SetMaterial( pMaterial );
596}
597
598void AGUI2RendererDX8::RenderLine( TFLOAT x1, TFLOAT y1, TFLOAT x2, TFLOAT y2 )
599{
600 auto pMaterial = m_pMaterial;
601 SetMaterial( TNULL );
602
603 if ( m_bIsTransformDirty )
604 {
605 UpdateTransform();
606 }
607
608 sm_Vertices[ 0 ].Position = { x1, y1, 0.0f };
609 sm_Vertices[ 0 ].Colour = m_uiColour;
610 sm_Vertices[ 0 ].UV = { 0.0f, 0.0f };
611
612 sm_Vertices[ 1 ].Position = { x2, y2, 0.0f };
613 sm_Vertices[ 1 ].Colour = m_uiColour;
614 sm_Vertices[ 1 ].UV = { 0.0f, 0.0f };
615
616 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
617 pRender->GetDirect3DDevice()->DrawPrimitiveUP( D3DPT_LINELIST, 1, sm_Vertices, sizeof( Vertex ) );
618
619 SetMaterial( pMaterial );
620}
621
622void AGUI2RendererDX8::RenderOutlineRectangle( const Toshi::TVector2& a, const Toshi::TVector2& b )
623{
624 auto pMaterial = m_pMaterial;
625 SetMaterial( TNULL );
626
627 if ( m_bIsTransformDirty )
628 {
629 UpdateTransform();
630 }
631
632 sm_Vertices[ 0 ].Position = { a.x, a.y, sm_fZCoordinate };
633 sm_Vertices[ 0 ].Colour = m_uiColour;
634 sm_Vertices[ 0 ].UV = { 0.0f, 0.0f };
635
636 sm_Vertices[ 1 ].Position = { b.x, a.y, sm_fZCoordinate };
637 sm_Vertices[ 1 ].Colour = m_uiColour;
638 sm_Vertices[ 1 ].UV = { 0.0f, 0.0f };
639
640 sm_Vertices[ 2 ].Position = { b.x, b.y, sm_fZCoordinate };
641 sm_Vertices[ 2 ].Colour = m_uiColour;
642 sm_Vertices[ 2 ].UV = { 0.0f, 0.0f };
643
644 sm_Vertices[ 3 ].Position = { a.x, b.y, sm_fZCoordinate };
645 sm_Vertices[ 3 ].Colour = m_uiColour;
646 sm_Vertices[ 3 ].UV = { 0.0f, 0.0f };
647
648 sm_Vertices[ 4 ].Position = { a.x, a.y, sm_fZCoordinate };
649 sm_Vertices[ 4 ].Colour = m_uiColour;
650 sm_Vertices[ 4 ].UV = { 0.0f, 0.0f };
651
652 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
653 pRender->GetDirect3DDevice()->DrawPrimitiveUP( D3DPT_LINESTRIP, 4, sm_Vertices, sizeof( Vertex ) );
654
655 SetMaterial( pMaterial );
656}
657
658void AGUI2RendererDX8::RenderFilledRectangle( const Toshi::TVector2& a, const Toshi::TVector2& b )
659{
660 auto pMaterial = m_pMaterial;
661 SetMaterial( TNULL );
662
663 if ( m_bIsTransformDirty )
664 {
665 UpdateTransform();
666 }
667
668 sm_Vertices[ 0 ].Position = { a.x, a.y, sm_fZCoordinate };
669 sm_Vertices[ 0 ].Colour = m_uiColour;
670 sm_Vertices[ 0 ].UV = { 0.0f, 0.0f };
671
672 sm_Vertices[ 1 ].Position = { b.x, a.y, sm_fZCoordinate };
673 sm_Vertices[ 1 ].Colour = m_uiColour;
674 sm_Vertices[ 1 ].UV = { 0.0f, 0.0f };
675
676 sm_Vertices[ 2 ].Position = { a.x, b.y, sm_fZCoordinate };
677 sm_Vertices[ 2 ].Colour = m_uiColour;
678 sm_Vertices[ 2 ].UV = { 0.0f, 0.0f };
679
680 sm_Vertices[ 3 ].Position = { b.x, b.y, sm_fZCoordinate };
681 sm_Vertices[ 3 ].Colour = m_uiColour;
682 sm_Vertices[ 3 ].UV = { 0.0f, 0.0f };
683
684 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
685 pRender->GetDirect3DDevice()->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, sm_Vertices, sizeof( Vertex ) );
686
687 SetMaterial( pMaterial );
688}
689
690void AGUI2RendererDX8::ScaleCoords( TFLOAT& x, TFLOAT& y )
691{
692 auto pDisplayParams = TRenderInterface::GetSingleton()->GetCurrentDisplayParams();
693
694 TFLOAT fRootWidth, fRootHeight;
695 AGUI2::GetContext()->GetRootElement()->GetDimensions( fRootWidth, fRootHeight );
696
697 x /= pDisplayParams->uiWidth / fRootWidth;
698 y /= pDisplayParams->uiHeight / fRootHeight;
699}
700
705
706void AGUI2RendererDX8::UpdateTransform()
707{
708 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
709 AGUI2Transform* pTransform = m_pTransforms + m_iTransformCount;
710
711 TMatrix44 worldMatrix;
712 worldMatrix.m_f11 = pTransform->m_aMatrixRows[ 0 ].x;
713 worldMatrix.m_f12 = pTransform->m_aMatrixRows[ 0 ].y;
714 worldMatrix.m_f13 = 0.0f;
715 worldMatrix.m_f14 = 0.0f;
716
717 worldMatrix.m_f21 = pTransform->m_aMatrixRows[ 1 ].x;
718 worldMatrix.m_f22 = pTransform->m_aMatrixRows[ 1 ].y;
719 worldMatrix.m_f23 = 0.0f;
720 worldMatrix.m_f24 = 0.0f;
721
722 worldMatrix.m_f31 = 0.0f;
723 worldMatrix.m_f32 = 0.0f;
724 worldMatrix.m_f33 = 1.0f;
725 worldMatrix.m_f34 = 0.0f;
726
727 worldMatrix.m_f41 = pTransform->m_vecTranslation.x;
728 worldMatrix.m_f42 = pTransform->m_vecTranslation.y;
729 worldMatrix.m_f43 = 0.0f;
730 worldMatrix.m_f44 = 1.0f;
731
732 pRender->GetDirect3DDevice()->SetTransform( D3DTS_WORLDMATRIX( 0 ), (D3DMATRIX*)&worldMatrix );
733 m_bIsTransformDirty = TFALSE;
734}
735
736void AGUI2RendererDX8::SetupProjectionMatrix( TMatrix44& a_rOutMatrix, TINT a_iLeft, TINT a_iRight, TINT a_iTop, TINT a_iBottom )
737{
738 auto pRender = TSTATICCAST( TRenderD3DInterface, TRenderInterface::GetSingleton() );
739 auto pDisplayParams = pRender->GetCurrentDisplayParams();
740
741 a_rOutMatrix = {
742 2.0f / ( a_iRight - a_iLeft ), 0.0f, 0.0f, 0.0f,
743 0.0f, 2.0f / ( a_iBottom - a_iTop ), 0.0f, 0.0f,
744 0.0f, 0.0f, 1.0f, 0.0f,
745 ( ( pDisplayParams->uiWidth - a_iLeft ) - a_iRight ) / (TFLOAT)( a_iRight - a_iLeft ), ( ( pDisplayParams->uiHeight - a_iTop ) - a_iBottom ) / (TFLOAT)( a_iTop - a_iBottom ), 0.0f, 1.0f
746 };
747}
ADDRESSINGMODE_WRAP
@ ADDRESSINGMODE_WRAP
Definition TRender.h:40
TEXCOORD_UV
@ TEXCOORD_UV
Definition TRender.h:29
TIMPLEMENT
#define TIMPLEMENT()
Definition Defines.h:136
TASSERT
#define TASSERT(X,...)
Definition Defines.h:138
TSTATICCAST
#define TSTATICCAST(POINTERTYPE, VALUE)
Definition Defines.h:69
TOSHI_NAMESPACE_USING
#define TOSHI_NAMESPACE_USING
Definition Defines.h:46
TUINT
unsigned int TUINT
Definition Typedefs.h:8
TCHAR
char TCHAR
Definition Typedefs.h:20
TFLOAT
float TFLOAT
Definition Typedefs.h:4
TNULL
#define TNULL
Definition Typedefs.h:23
TUINT32
uint32_t TUINT32
Definition Typedefs.h:13
TINT
int TINT
Definition Typedefs.h:7
TFALSE
#define TFALSE
Definition Typedefs.h:24
TTRUE
#define TTRUE
Definition Typedefs.h:25
TMath::CeilToInt
TFORCEINLINE TINT CeilToInt(TFLOAT a_fVal)
Definition TMathInline.h:100
TMath::Max
TFORCEINLINE const T & Max(const T &a, const T &b)
Definition TMathInline.h:167
TMath::Min
TFORCEINLINE const T & Min(const T &a, const T &b)
Definition TMathInline.h:161
TMath::FloorToInt
TFORCEINLINE TINT FloorToInt(TFLOAT a_fVal)
Definition TMathInline.h:103
TMatrix44::m_f21
TFLOAT m_f21
Definition TMatrix44.h:361
TMatrix44::m_f12
TFLOAT m_f12
Definition TMatrix44.h:360
TMatrix44::m_f44
TFLOAT m_f44
Definition TMatrix44.h:363
TMatrix44::m_f43
TFLOAT m_f43
Definition TMatrix44.h:363
TMatrix44::m_f32
TFLOAT m_f32
Definition TMatrix44.h:362
TMatrix44::m_f13
TFLOAT m_f13
Definition TMatrix44.h:360
TMatrix44::IDENTITY
static constinit TMatrix44 IDENTITY
Definition TMatrix44.h:357
TMatrix44::m_f14
TFLOAT m_f14
Definition TMatrix44.h:360
TMatrix44::m_f11
TFLOAT m_f11
Definition TMatrix44.h:360
TMatrix44::m_f23
TFLOAT m_f23
Definition TMatrix44.h:361
TMatrix44::m_f22
TFLOAT m_f22
Definition TMatrix44.h:361
TMatrix44::m_f41
TFLOAT m_f41
Definition TMatrix44.h:363
TMatrix44::m_f31
TFLOAT m_f31
Definition TMatrix44.h:362
TMatrix44::m_f24
TFLOAT m_f24
Definition TMatrix44.h:361
TMatrix44::m_f34
TFLOAT m_f34
Definition TMatrix44.h:362
TMatrix44::m_f42
TFLOAT m_f42
Definition TMatrix44.h:363
TMatrix44::m_f33
TFLOAT m_f33
Definition TMatrix44.h:362
TVector2::y
TFLOAT y
Definition TVector2.h:139
TVector2::x
TFLOAT x
Definition TVector2.h:139
TRenderD3DInterface
DirectX 8 implementation of the render interface Handles DirectX 8 specific rendering functionality a...
Definition TRenderInterface_DX8.h:18
TRenderD3DInterface::FlushShaders
static void FlushShaders()
Flushes all order tables and shaders.
Definition TRenderInterface_DX8.cpp:350
TRenderInterface::GetCurrentDisplayParams
virtual DISPLAYPARAMS * GetCurrentDisplayParams()=0
TSingleton< TRenderInterface >::GetSingleton
static TFORCEINLINE TRenderInterface * GetSingleton()
Definition TSingleton.h:49
AGUI2::GetContext
static AGUI2Context * GetContext()
Definition AGUI2.h:32
AGUI2Context::GetRootElement
AGUI2Element * GetRootElement() const
Definition AGUI2Context.h:14
AGUI2Element::GetDimensions
virtual void GetDimensions(TFLOAT &a_rWidth, TFLOAT &a_rHeight)
Definition AGUI2Element.cpp:88
AGUI2Transform::Transform
void Transform(Toshi::TVector2 &a_rOutVec, const Toshi::TVector2 &a_rTransformVec) const
Definition AGUI2Transform.cpp:46
AGUI2Transform::m_vecTranslation
Toshi::TVector2 m_vecTranslation
Definition AGUI2Transform.h:74
AGUI2Transform::m_aMatrixRows
Toshi::TVector2 m_aMatrixRows[2]
Definition AGUI2Transform.h:73
AGUI2Transform::Multiply
static void Multiply(AGUI2Transform &a_rOutTransform, const AGUI2Transform &a_rA, const AGUI2Transform &a_rB)
Definition AGUI2Transform.cpp:85
AGUI2RendererDX8::sm_Vertices
static Vertex sm_Vertices[MAX_VERTICES]
Definition AGUI2Renderer_DX8.h:55
AGUI2RendererDX8::RenderLine
virtual void RenderLine(const Toshi::TVector2 &a, const Toshi::TVector2 &b) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:574
AGUI2RendererDX8::RenderOutlineRectangle
virtual void RenderOutlineRectangle(const Toshi::TVector2 &a, const Toshi::TVector2 &b) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:622
AGUI2RendererDX8::PushTransform
virtual void PushTransform(const AGUI2Transform &a_rTransform, const Toshi::TVector2 &a_rVec1, const Toshi::TVector2 &a_rVec2) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:408
AGUI2RendererDX8::EndScene
virtual void EndScene() OVERRIDE
Definition AGUI2Renderer_DX8.cpp:140
AGUI2RendererDX8::sm_bUnknownFlag
static TBOOL sm_bUnknownFlag
Definition AGUI2Renderer_DX8.h:56
AGUI2RendererDX8::SetColour
virtual void SetColour(TUINT32 a_uiColour) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:440
AGUI2RendererDX8::SetTransform
virtual void SetTransform(const AGUI2Transform &a_rTransform) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:434
AGUI2RendererDX8::PopTransform
virtual void PopTransform() OVERRIDE
Definition AGUI2Renderer_DX8.cpp:427
AGUI2RendererDX8::RenderFilledRectangle
virtual void RenderFilledRectangle(const Toshi::TVector2 &a, const Toshi::TVector2 &b) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:658
AGUI2RendererDX8::SetScissor
virtual void SetScissor(TFLOAT a_fVal1, TFLOAT a_fVal2, TFLOAT a_fVal3, TFLOAT a_fVal4) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:445
AGUI2RendererDX8::RenderRectangle
virtual void RenderRectangle(const Toshi::TVector2 &a, const Toshi::TVector2 &b, const Toshi::TVector2 &uv1, const Toshi::TVector2 &uv2) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:542
AGUI2RendererDX8::sm_fZCoordinate
static TFLOAT sm_fZCoordinate
Definition AGUI2Renderer_DX8.h:57
AGUI2RendererDX8::RenderTriStrip
virtual void RenderTriStrip(Toshi::TVector2 *vertices, Toshi::TVector2 *UV, uint32_t numverts) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:569
AGUI2RendererDX8::ScaleCoords
virtual void ScaleCoords(TFLOAT &x, TFLOAT &y) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:690
AGUI2RendererDX8::MAX_NUM_TRANSFORMS
static constexpr TUINT32 MAX_NUM_TRANSFORMS
Definition AGUI2Renderer_DX8.h:9
AGUI2RendererDX8::SetMaterial
virtual void SetMaterial(AGUI2Material *a_pMaterial) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:240
AGUI2RendererDX8::DestroyMaterial
virtual void DestroyMaterial(AGUI2Material *a_pMaterial) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:49
AGUI2RendererDX8::ClearScissor
virtual void ClearScissor() OVERRIDE
Definition AGUI2Renderer_DX8.cpp:507
AGUI2RendererDX8::ResetZCoordinate
virtual void ResetZCoordinate() OVERRIDE
Definition AGUI2Renderer_DX8.cpp:701
AGUI2RendererDX8::CreateMaterial
virtual AGUI2Material * CreateMaterial(const TCHAR *a_szTextureName) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:32
AGUI2RendererDX8::ResetRenderer
virtual void ResetRenderer() OVERRIDE
Definition AGUI2Renderer_DX8.cpp:164
AGUI2RendererDX8::GetHeight
virtual TUINT GetHeight(AGUI2Material *a_pMaterial) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:68
AGUI2RendererDX8::GetWidth
virtual TUINT GetWidth(AGUI2Material *a_pMaterial) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:63
AGUI2RendererDX8::PrepareRenderer
virtual void PrepareRenderer() OVERRIDE
Definition AGUI2Renderer_DX8.cpp:188
AGUI2RendererDX8::BeginScene
virtual void BeginScene() OVERRIDE
Definition AGUI2Renderer_DX8.cpp:73
AGUI2RendererDX8::GetTexture
virtual Toshi::TTexture * GetTexture(const TCHAR *a_szTextureName) OVERRIDE
Definition AGUI2Renderer_DX8.cpp:58