summaryrefslogtreecommitdiffstatshomepage
path: root/src/osd/modules/render/drawd3d.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/osd/modules/render/drawd3d.cpp')
-rw-r--r--src/osd/modules/render/drawd3d.cpp389
1 files changed, 176 insertions, 213 deletions
diff --git a/src/osd/modules/render/drawd3d.cpp b/src/osd/modules/render/drawd3d.cpp
index b8730696a54..83f94864495 100644
--- a/src/osd/modules/render/drawd3d.cpp
+++ b/src/osd/modules/render/drawd3d.cpp
@@ -14,16 +14,6 @@
// Windows NT shipped with DirectX 3.0a
// Windows 95 shipped with DirectX 2
-// standard windows headers
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <tchar.h>
-#include <mmsystem.h>
-#include <d3d9.h>
-#include <d3dx9.h>
-#include <math.h>
-#undef interface
-
// MAME headers
#include "emu.h"
#include "render.h"
@@ -33,11 +23,11 @@
#include "aviio.h"
// MAMEOS headers
-#include "modules/render/d3d/d3dintf.h"
#include "winmain.h"
#include "window.h"
-#include "modules/render/d3d/d3dcomm.h"
#include "drawd3d.h"
+#include "modules/render/d3d/d3dhlsl.h"
+#include "d3dtarget.h"
//============================================================
@@ -109,7 +99,7 @@ static inline BOOL GetClientRectExceptMenu(HWND hWnd, PRECT pRect, BOOL fullscre
last_menu = menu;
last_rect = *pRect;
- SetMenu(hWnd, NULL);
+ SetMenu(hWnd, nullptr);
result = GetClientRect(hWnd, &cached_rect);
SetMenu(hWnd, menu);
}
@@ -165,26 +155,21 @@ static inline UINT32 ycc_to_rgb(UINT8 y, UINT8 cb, UINT8 cr)
// drawd3d_init
//============================================================
-static d3d::base * d3dintf; // FIX ME
+static d3d_base * d3dintf; // FIX ME
//============================================================
// PROTOTYPES
//============================================================
-// core functions
-static void drawd3d_exit(void);
-
-
//============================================================
// drawd3d_window_init
//============================================================
-int d3d::renderer::create()
+int renderer_d3d9::create()
{
if (!initialize())
{
- destroy();
osd_printf_error("Unable to initialize Direct3D.\n");
return 1;
}
@@ -192,50 +177,27 @@ int d3d::renderer::create()
return 0;
}
-
-//============================================================
-// drawd3d_exit
-//============================================================
-
-static void drawd3d_exit(void)
-{
- if (d3dintf != NULL)
- (*d3dintf->d3d.release)(d3dintf);
-}
-
-void d3d::renderer::toggle_fsfx()
+void renderer_d3d9::toggle_fsfx()
{
set_restarting(true);
}
-void d3d::renderer::record()
+void renderer_d3d9::record()
{
get_shaders()->window_record();
}
-void d3d::renderer::save()
+void renderer_d3d9::save()
{
get_shaders()->window_save();
}
//============================================================
-// drawd3d_window_destroy
-//============================================================
-
-void d3d::renderer::destroy()
-{
- if (get_shaders() != NULL && get_shaders()->recording())
- get_shaders()->window_record();
-
-}
-
-
-//============================================================
// drawd3d_window_get_primitives
//============================================================
-render_primitive_list *d3d::renderer::get_primitives()
+render_primitive_list *renderer_d3d9::get_primitives()
{
RECT client;
@@ -245,7 +207,7 @@ render_primitive_list *d3d::renderer::get_primitives()
window().target()->set_bounds(rect_width(&client), rect_height(&client), window().aspect());
window().target()->set_max_update_rate((get_refresh() == 0) ? get_origmode().RefreshRate : get_refresh());
}
- if (m_shaders != NULL)
+ if (m_shaders != nullptr)
{
window().target()->set_transform_primitives(!m_shaders->enabled());
}
@@ -257,29 +219,18 @@ render_primitive_list *d3d::renderer::get_primitives()
// drawnone_create
//============================================================
-static osd_renderer *drawd3d_create(osd_window *window)
-{
- return global_alloc(d3d::renderer(window));
-}
-
-int drawd3d_init(running_machine &machine, osd_draw_callbacks *callbacks)
+int renderer_d3d9::init(running_machine &machine)
{
- d3dintf = NULL;
-
// Use Direct3D9
- d3dintf = d3d::drawd3d9_init();
+ d3dintf = drawd3d9_init();
// if we failed, note the error
- if (d3dintf == NULL)
+ if (d3dintf == nullptr)
{
osd_printf_error("Unable to initialize Direct3D.\n");
return 1;
}
- // fill in the callbacks
- memset(callbacks, 0, sizeof(*callbacks));
- callbacks->exit = drawd3d_exit;
- callbacks->create = drawd3d_create;
return 0;
}
@@ -288,7 +239,7 @@ int drawd3d_init(running_machine &machine, osd_draw_callbacks *callbacks)
// drawd3d_window_draw
//============================================================
-int d3d::renderer::draw(const int update)
+int renderer_d3d9::draw(const int update)
{
int check = pre_window_draw_check();
if (check >= 0)
@@ -301,21 +252,19 @@ int d3d::renderer::draw(const int update)
return 0;
}
-namespace d3d
-{
-void renderer::set_texture(texture_info *texture)
+void renderer_d3d9::set_texture(texture_info *texture)
{
if (texture != m_last_texture)
{
m_last_texture = texture;
- m_last_texture_flags = (texture == NULL ? 0 : texture->get_flags());
- HRESULT result = (*d3dintf->device.set_texture)(m_device, 0, (texture == NULL) ? get_default_texture()->get_finaltex() : texture->get_finaltex());
+ m_last_texture_flags = (texture == nullptr ? 0 : texture->get_flags());
+ HRESULT result = (*d3dintf->device.set_texture)(m_device, 0, (texture == nullptr) ? get_default_texture()->get_finaltex() : texture->get_finaltex());
m_shaders->set_texture(texture);
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device set_texture call\n", (int)result);
}
}
-void renderer::set_filter(int filter)
+void renderer_d3d9::set_filter(int filter)
{
if (filter != m_last_filter)
{
@@ -331,7 +280,7 @@ void renderer::set_filter(int filter)
}
}
-void renderer::set_wrap(D3DTEXTUREADDRESS wrap)
+void renderer_d3d9::set_wrap(unsigned int wrap)
{
if (wrap != m_last_wrap)
{
@@ -347,7 +296,7 @@ void renderer::set_wrap(D3DTEXTUREADDRESS wrap)
}
}
-void renderer::set_modmode(DWORD modmode)
+void renderer_d3d9::set_modmode(int modmode)
{
if (modmode != m_last_modmode)
{
@@ -359,7 +308,7 @@ void renderer::set_modmode(DWORD modmode)
}
}
-void renderer::set_blendmode(int blendmode)
+void renderer_d3d9::set_blendmode(int blendmode)
{
int blendenable;
int blendop;
@@ -406,7 +355,7 @@ void renderer::set_blendmode(int blendmode)
}
}
-void renderer::reset_render_states()
+void renderer_d3d9::reset_render_states()
{
// this ensures subsequent calls to the above setters will force-update the data
m_last_texture = (texture_info *)~0;
@@ -418,13 +367,13 @@ void renderer::reset_render_states()
m_last_wrap = (D3DTEXTUREADDRESS)-1;
}
-texture_manager::texture_manager(renderer *d3d)
+d3d_texture_manager::d3d_texture_manager(renderer_d3d9 *d3d)
{
m_renderer = d3d;
- m_texlist = NULL;
- m_vector_texture = NULL;
- m_default_texture = NULL;
+ m_texlist = nullptr;
+ m_vector_texture = nullptr;
+ m_default_texture = nullptr;
// check for dynamic texture support
DWORD tempcaps;
@@ -466,20 +415,20 @@ texture_manager::texture_manager(renderer *d3d)
osd_printf_verbose("Direct3D: Max texture size = %dx%d\n", (int)m_texture_max_width, (int)m_texture_max_height);
}
-texture_manager::~texture_manager()
+d3d_texture_manager::~d3d_texture_manager()
{
}
-void texture_manager::create_resources()
+void d3d_texture_manager::create_resources()
{
// experimental: load a PNG to use for vector rendering; it is treated
// as a brightness map
emu_file file(m_renderer->window().machine().options().art_path(), OPEN_FLAG_READ);
- render_load_png(m_vector_bitmap, file, NULL, "vector.png");
+ render_load_png(m_vector_bitmap, file, nullptr, "vector.png");
if (m_vector_bitmap.valid())
{
m_vector_bitmap.fill(rgb_t(0xff,0xff,0xff,0xff));
- render_load_png(m_vector_bitmap, file, NULL, "vector.png", true);
+ render_load_png(m_vector_bitmap, file, nullptr, "vector.png", true);
}
m_default_bitmap.allocate(8, 8);
@@ -494,7 +443,7 @@ void texture_manager::create_resources()
texture.rowpixels = m_default_bitmap.rowpixels();
texture.width = m_default_bitmap.width();
texture.height = m_default_bitmap.height();
- texture.palette = NULL;
+ texture.palette = nullptr;
texture.seqid = 0;
// now create it
@@ -511,7 +460,7 @@ void texture_manager::create_resources()
texture.rowpixels = m_vector_bitmap.rowpixels();
texture.width = m_vector_bitmap.width();
texture.height = m_vector_bitmap.height();
- texture.palette = NULL;
+ texture.palette = nullptr;
texture.seqid = 0;
// now create it
@@ -519,17 +468,17 @@ void texture_manager::create_resources()
}
}
-void texture_manager::delete_resources()
+void d3d_texture_manager::delete_resources()
{
// is part of m_texlist and will be free'd there
//global_free(m_default_texture);
- m_default_texture = NULL;
+ m_default_texture = nullptr;
//global_free(m_vector_texture);
- m_vector_texture = NULL;
+ m_vector_texture = nullptr;
// free all textures
- while (m_texlist != NULL)
+ while (m_texlist != nullptr)
{
texture_info *tex = m_texlist;
m_texlist = tex->get_next();
@@ -537,18 +486,18 @@ void texture_manager::delete_resources()
}
}
-UINT32 texture_manager::texture_compute_hash(const render_texinfo *texture, UINT32 flags)
+UINT32 d3d_texture_manager::texture_compute_hash(const render_texinfo *texture, UINT32 flags)
{
return (FPTR)texture->base ^ (flags & (PRIMFLAG_BLENDMODE_MASK | PRIMFLAG_TEXFORMAT_MASK));
}
-texture_info *texture_manager::find_texinfo(const render_texinfo *texinfo, UINT32 flags)
+texture_info *d3d_texture_manager::find_texinfo(const render_texinfo *texinfo, UINT32 flags)
{
UINT32 hash = texture_compute_hash(texinfo, flags);
texture_info *texture;
// find a match
- for (texture = m_renderer->get_texture_manager()->get_texlist(); texture != NULL; texture = texture->get_next())
+ for (texture = m_renderer->get_texture_manager()->get_texlist(); texture != nullptr; texture = texture->get_next())
{
UINT32 test_screen = (UINT32)texture->get_texinfo().osddata >> 1;
UINT32 test_page = (UINT32)texture->get_texinfo().osddata & 1;
@@ -568,7 +517,7 @@ texture_info *texture_manager::find_texinfo(const render_texinfo *texinfo, UINT3
// Reject a texture if it belongs to an out-of-date render target, so as to cause the HLSL system to re-cache
if (m_renderer->get_shaders()->enabled() && texinfo->width != 0 && texinfo->height != 0 && (flags & PRIMFLAG_SCREENTEX_MASK) != 0)
{
- if (m_renderer->get_shaders()->find_render_target(texture) != NULL)
+ if (m_renderer->get_shaders()->find_render_target(texture) != nullptr)
{
return texture;
}
@@ -585,13 +534,13 @@ texture_info *texture_manager::find_texinfo(const render_texinfo *texinfo, UINT3
{
if (texinfo->width == 0 || texinfo->height == 0)
{
- return NULL;
+ return nullptr;
}
UINT32 prim_screen = texinfo->osddata >> 1;
UINT32 prim_page = texinfo->osddata & 1;
- for (texture = m_renderer->get_texture_manager()->get_texlist(); texture != NULL; texture = texture->get_next())
+ for (texture = m_renderer->get_texture_manager()->get_texlist(); texture != nullptr; texture = texture->get_next())
{
UINT32 test_screen = texture->get_texinfo().osddata >> 1;
UINT32 test_page = texture->get_texinfo().osddata & 1;
@@ -612,18 +561,18 @@ texture_info *texture_manager::find_texinfo(const render_texinfo *texinfo, UINT3
}
}
- return NULL;
+ return nullptr;
}
-renderer::renderer(osd_window *window)
- : osd_renderer(window, FLAG_NONE), m_adapter(0), m_width(0), m_height(0), m_refresh(0), m_create_error_count(0), m_device(NULL), m_gamma_supported(0), m_pixformat(),
- m_vertexbuf(NULL), m_lockedbuf(NULL), m_numverts(0), m_vectorbatch(NULL), m_batchindex(0), m_numpolys(0), m_restarting(false), m_mod2x_supported(0), m_mod4x_supported(0),
- m_screen_format(), m_last_texture(NULL), m_last_texture_flags(0), m_last_blendenable(0), m_last_blendop(0), m_last_blendsrc(0), m_last_blenddst(0), m_last_filter(0),
- m_last_wrap(), m_last_modmode(0), m_hlsl_buf(NULL), m_shaders(NULL), m_shaders_options(NULL), m_texture_manager(NULL), m_line_count(0)
+renderer_d3d9::renderer_d3d9(osd_window *window)
+ : osd_renderer(window, FLAG_NONE), m_adapter(0), m_width(0), m_height(0), m_refresh(0), m_create_error_count(0), m_device(nullptr), m_gamma_supported(0), m_pixformat(),
+ m_vertexbuf(nullptr), m_lockedbuf(nullptr), m_numverts(0), m_vectorbatch(nullptr), m_batchindex(0), m_numpolys(0), m_restarting(false), m_mod2x_supported(0), m_mod4x_supported(0),
+ m_screen_format(), m_last_texture(nullptr), m_last_texture_flags(0), m_last_blendenable(0), m_last_blendop(0), m_last_blendsrc(0), m_last_blenddst(0), m_last_filter(0),
+ m_last_wrap(), m_last_modmode(0), m_hlsl_buf(nullptr), m_shaders(nullptr), m_shaders_options(nullptr), m_texture_manager(nullptr), m_line_count(0)
{
}
-int renderer::initialize()
+int renderer_d3d9::initialize()
{
// configure the adapter for the mode we want
if (config_adapter_mode())
@@ -636,7 +585,7 @@ int renderer::initialize()
return true;
}
-int renderer::pre_window_draw_check()
+int renderer_d3d9::pre_window_draw_check()
{
// if we're in the middle of resizing, leave things alone
if (window().m_resize_state == RESIZE_STATE_RESIZING)
@@ -651,7 +600,7 @@ int renderer::pre_window_draw_check()
}
// if we have a device, check the cooperative level
- if (m_device != NULL)
+ if (m_device != nullptr)
{
if (device_test_cooperative())
{
@@ -660,28 +609,28 @@ int renderer::pre_window_draw_check()
}
// in window mode, we need to track the window size
- if (!window().fullscreen() || m_device == NULL)
+ if (!window().fullscreen() || m_device == nullptr)
{
// if the size changes, skip this update since the render target will be out of date
if (update_window_size())
return 0;
// if we have no device, after updating the size, return an error so GDI can try
- if (m_device == NULL)
+ if (m_device == nullptr)
return 1;
}
return -1;
}
-void texture_manager::update_textures()
+void d3d_texture_manager::update_textures()
{
- for (render_primitive *prim = m_renderer->window().m_primlist->first(); prim != NULL; prim = prim->next())
+ for (render_primitive *prim = m_renderer->window().m_primlist->first(); prim != nullptr; prim = prim->next())
{
- if (prim->texture.base != NULL)
+ if (prim->texture.base != nullptr)
{
texture_info *texture = find_texinfo(&prim->texture, prim->flags);
- if (texture == NULL)
+ if (texture == nullptr)
{
// if there isn't one, create a new texture
global_alloc(texture_info(this, &prim->texture, m_renderer->window().prescale(), prim->flags));
@@ -706,9 +655,9 @@ void texture_manager::update_textures()
}
}
-void renderer::begin_frame()
+void renderer_d3d9::begin_frame()
{
- HRESULT result = (*d3dintf->device.clear)(m_device, 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0,0,0,0), 0, 0);
+ HRESULT result = (*d3dintf->device.clear)(m_device, 0, nullptr, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0,0,0,0), 0, 0);
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device clear call\n", (int)result);
m_shaders->begin_frame();
@@ -723,7 +672,7 @@ void renderer::begin_frame()
result = (*d3dintf->device.begin_scene)(m_device);
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device begin_scene call\n", (int)result);
- m_lockedbuf = NULL;
+ m_lockedbuf = nullptr;
if(m_shaders->enabled())
{
@@ -734,15 +683,15 @@ void renderer::begin_frame()
m_line_count = 0;
// loop over primitives
- for (render_primitive *prim = window().m_primlist->first(); prim != NULL; prim = prim->next())
+ for (render_primitive *prim = window().m_primlist->first(); prim != nullptr; prim = prim->next())
if (prim->type == render_primitive::LINE && PRIMFLAG_GET_VECTOR(prim->flags))
m_line_count++;
}
-void renderer::process_primitives()
+void renderer_d3d9::process_primitives()
{
// Rotating index for vector time offsets
- for (render_primitive *prim = window().m_primlist->first(); prim != NULL; prim = prim->next())
+ for (render_primitive *prim = window().m_primlist->first(); prim != nullptr; prim = prim->next())
{
switch (prim->type)
{
@@ -770,7 +719,7 @@ void renderer::process_primitives()
}
}
-void renderer::end_frame()
+void renderer_d3d9::end_frame()
{
window().m_primlist->release_lock();
@@ -784,7 +733,7 @@ void renderer::end_frame()
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device end_scene call\n", (int)result);
// present the current buffers
- result = (*d3dintf->device.present)(m_device, NULL, NULL, NULL, NULL, 0);
+ result = (*d3dintf->device.present)(m_device, nullptr, nullptr, nullptr, nullptr, 0);
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device present call\n", (int)result);
}
@@ -792,10 +741,10 @@ void renderer::end_frame()
// device_create
//============================================================
-int renderer::device_create(HWND device_hwnd)
+int renderer_d3d9::device_create(HWND device_hwnd)
{
// if a device exists, free it
- if (m_device != NULL)
+ if (m_device != nullptr)
{
device_delete();
}
@@ -820,7 +769,7 @@ int renderer::device_create(HWND device_hwnd)
return 1;
}
- m_texture_manager = global_alloc(texture_manager(this));
+ m_texture_manager = global_alloc(d3d_texture_manager(this));
try_again:
// try for XRGB first
@@ -913,7 +862,7 @@ try_again:
}
// create shader options only once
- if (m_shaders_options == NULL)
+ if (m_shaders_options == nullptr)
{
m_shaders_options = (hlsl_options*)global_alloc_clear<hlsl_options>();
m_shaders_options->params_init = false;
@@ -936,7 +885,7 @@ try_again:
// device_create_resources
//============================================================
-int renderer::device_create_resources()
+int renderer_d3d9::device_create_resources()
{
// allocate a vertex buffer to use
HRESULT result = (*d3dintf->device.create_vertex_buffer)(m_device,
@@ -988,8 +937,8 @@ int renderer::device_create_resources()
reset_render_states();
// clear the buffer
- result = (*d3dintf->device.clear)(m_device, 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0,0,0,0), 0, 0);
- result = (*d3dintf->device.present)(m_device, NULL, NULL, NULL, NULL, 0);
+ result = (*d3dintf->device.clear)(m_device, 0, nullptr, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0,0,0,0), 0, 0);
+ result = (*d3dintf->device.present)(m_device, nullptr, nullptr, nullptr, nullptr, 0);
m_texture_manager->create_resources();
@@ -1001,20 +950,26 @@ int renderer::device_create_resources()
// device_delete
//============================================================
-renderer::~renderer()
+renderer_d3d9::~renderer_d3d9()
{
+ if (get_shaders() != nullptr && get_shaders()->recording())
+ get_shaders()->window_record();
+
+ if (d3dintf != nullptr)
+ (*d3dintf->d3d.release)(d3dintf);
+
device_delete();
- if (m_shaders_options != NULL)
+ if (m_shaders_options != nullptr)
{
global_free(m_shaders_options);
- m_shaders_options = NULL;
+ m_shaders_options = nullptr;
}
}
-void renderer::device_delete()
+void renderer_d3d9::device_delete()
{
- if (m_shaders != NULL)
+ if (m_shaders != nullptr)
{
// free our effects
m_shaders->delete_resources(false);
@@ -1026,18 +981,18 @@ void renderer::device_delete()
// free our base resources
device_delete_resources();
- if (m_texture_manager != NULL)
+ if (m_texture_manager != nullptr)
{
global_free(m_texture_manager);
- m_texture_manager = NULL;
+ m_texture_manager = nullptr;
}
// free the device itself
- if (m_device != NULL)
+ if (m_device != nullptr)
{
(*d3dintf->device.reset)(m_device, &m_presentation);
(*d3dintf->device.release)(m_device);
- m_device = NULL;
+ m_device = nullptr;
}
}
@@ -1046,18 +1001,18 @@ void renderer::device_delete()
// device_delete_resources
//============================================================
-void renderer::device_delete_resources()
+void renderer_d3d9::device_delete_resources()
{
- if (m_texture_manager != NULL)
+ if (m_texture_manager != nullptr)
{
m_texture_manager->delete_resources();
}
// free the vertex buffer
- if (m_vertexbuf != NULL)
+ if (m_vertexbuf != nullptr)
{
(*d3dintf->vertexbuf.release)(m_vertexbuf);
- m_vertexbuf = NULL;
+ m_vertexbuf = nullptr;
}
}
@@ -1066,7 +1021,7 @@ void renderer::device_delete_resources()
// device_verify_caps
//============================================================
-int renderer::device_verify_caps()
+int renderer_d3d9::device_verify_caps()
{
int retval = 0;
@@ -1132,7 +1087,7 @@ int renderer::device_verify_caps()
// device_test_cooperative
//============================================================
-int renderer::device_test_cooperative()
+int renderer_d3d9::device_test_cooperative()
{
// check our current status; if we lost the device, punt to GDI
HRESULT result = (*d3dintf->device.test_cooperative_level)(m_device);
@@ -1179,7 +1134,7 @@ int renderer::device_test_cooperative()
// config_adapter_mode
//============================================================
-int renderer::config_adapter_mode()
+int renderer_d3d9::config_adapter_mode()
{
adapter_identifier identifier;
@@ -1254,7 +1209,7 @@ int renderer::config_adapter_mode()
// get_adapter_for_monitor
//============================================================
-int renderer::get_adapter_for_monitor()
+int renderer_d3d9::get_adapter_for_monitor()
{
int maxadapter = (*d3dintf->d3d.get_adapter_count)(d3dintf);
@@ -1280,7 +1235,7 @@ int renderer::get_adapter_for_monitor()
// pick_best_mode
//============================================================
-void renderer::pick_best_mode()
+void renderer_d3d9::pick_best_mode()
{
double target_refresh = 60.0;
INT32 minwidth, minheight;
@@ -1288,7 +1243,7 @@ void renderer::pick_best_mode()
// determine the refresh rate of the primary screen
const screen_device *primary_screen = window().machine().config().first_screen();
- if (primary_screen != NULL)
+ if (primary_screen != nullptr)
{
target_refresh = ATTOSECONDS_TO_HZ(primary_screen->refresh_attoseconds());
}
@@ -1368,14 +1323,14 @@ void renderer::pick_best_mode()
// update_window_size
//============================================================
-int renderer::update_window_size()
+int renderer_d3d9::update_window_size()
{
// get the current window bounds
RECT client;
GetClientRectExceptMenu(window().m_hwnd, &client, window().fullscreen());
// if we have a device and matching width/height, nothing to do
- if (m_device != NULL && rect_width(&client) == m_width && rect_height(&client) == m_height)
+ if (m_device != nullptr && rect_width(&client) == m_width && rect_height(&client) == m_height)
{
// clear out any pending resizing if the area didn't change
if (window().m_resize_state == RESIZE_STATE_PENDING)
@@ -1403,7 +1358,7 @@ int renderer::update_window_size()
// batch_vectors
//============================================================
-void renderer::batch_vectors()
+void renderer_d3d9::batch_vectors()
{
windows_options &options = downcast<windows_options &>(window().machine().options());
@@ -1415,7 +1370,7 @@ void renderer::batch_vectors()
int line_index = 0;
float period = options.screen_vector_time_period();
UINT32 cached_flags = 0;
- for (render_primitive *prim = window().m_primlist->first(); prim != NULL; prim = prim->next())
+ for (render_primitive *prim = window().m_primlist->first(); prim != nullptr; prim = prim->next())
{
switch (prim->type)
{
@@ -1455,7 +1410,7 @@ void renderer::batch_vectors()
m_line_count = 0;
}
-void renderer::batch_vector(const render_primitive *prim, float line_time)
+void renderer_d3d9::batch_vector(const render_primitive *prim, float line_time)
{
// compute the effective width based on the direction of the line
float effwidth = prim->width;
@@ -1473,7 +1428,7 @@ void renderer::batch_vector(const render_primitive *prim, float line_time)
step->weight != 0; step++)
{
// get a pointer to the vertex buffer
- if (m_vectorbatch == NULL)
+ if (m_vectorbatch == nullptr)
return;
m_vectorbatch[m_batchindex + 0].x = b0.x0 + step->xoffs;
@@ -1557,7 +1512,7 @@ void renderer::batch_vector(const render_primitive *prim, float line_time)
// draw_line
//============================================================
-void renderer::draw_line(const render_primitive *prim)
+void renderer_d3d9::draw_line(const render_primitive *prim)
{
// compute the effective width based on the direction of the line
float effwidth = prim->width;
@@ -1576,7 +1531,7 @@ void renderer::draw_line(const render_primitive *prim)
{
// get a pointer to the vertex buffer
vertex *vertex = mesh_alloc(4);
- if (vertex == NULL)
+ if (vertex == nullptr)
return;
// rotate the unit vector by 135 degrees and add to point 0
@@ -1641,18 +1596,18 @@ void renderer::draw_line(const render_primitive *prim)
// draw_quad
//============================================================
-void renderer::draw_quad(const render_primitive *prim)
+void renderer_d3d9::draw_quad(const render_primitive *prim)
{
texture_info *texture = m_texture_manager->find_texinfo(&prim->texture, prim->flags);
- if (texture == NULL)
+ if (texture == nullptr)
{
texture = get_default_texture();
}
// get a pointer to the vertex buffer
vertex *vertex = mesh_alloc(4);
- if (vertex == NULL)
+ if (vertex == nullptr)
return;
// fill in the vertexes clockwise
@@ -1668,7 +1623,7 @@ void renderer::draw_quad(const render_primitive *prim)
float height = prim->bounds.y1 - prim->bounds.y0;
// set the texture coordinates
- if(texture != NULL)
+ if(texture != nullptr)
{
vec2f& start = texture->get_uvstart();
vec2f& stop = texture->get_uvstop();
@@ -1689,7 +1644,7 @@ void renderer::draw_quad(const render_primitive *prim)
INT32 b = (INT32)(prim->color.b * 255.0f);
INT32 a = (INT32)(prim->color.a * 255.0f);
DWORD modmode = D3DTOP_MODULATE;
- if (texture != NULL)
+ if (texture != nullptr)
{
if (m_mod2x_supported && (r > 255 || g > 255 || b > 255))
{
@@ -1755,12 +1710,12 @@ void poly_info::init(D3DPRIMITIVETYPE type, UINT32 count, UINT32 numverts,
// primitive_alloc
//============================================================
-vertex *renderer::mesh_alloc(int numverts)
+vertex *renderer_d3d9::mesh_alloc(int numverts)
{
HRESULT result;
// if we're going to overflow, flush
- if (m_lockedbuf != NULL && m_numverts + numverts >= VERTEX_BUFFER_SIZE)
+ if (m_lockedbuf != nullptr && m_numverts + numverts >= VERTEX_BUFFER_SIZE)
{
primitive_flush_pending();
@@ -1772,21 +1727,21 @@ vertex *renderer::mesh_alloc(int numverts)
}
// if we don't have a lock, grab it now
- if (m_lockedbuf == NULL)
+ if (m_lockedbuf == nullptr)
{
result = (*d3dintf->vertexbuf.lock)(m_vertexbuf, 0, 0, (VOID **)&m_lockedbuf, D3DLOCK_DISCARD);
if (result != D3D_OK)
- return NULL;
+ return nullptr;
}
// if we already have the lock and enough room, just return a pointer
- if (m_lockedbuf != NULL && m_numverts + numverts < VERTEX_BUFFER_SIZE)
+ if (m_lockedbuf != nullptr && m_numverts + numverts < VERTEX_BUFFER_SIZE)
{
int oldverts = m_numverts;
m_numverts += numverts;
return &m_lockedbuf[oldverts];
}
- return NULL;
+ return nullptr;
}
@@ -1794,10 +1749,10 @@ vertex *renderer::mesh_alloc(int numverts)
// primitive_flush_pending
//============================================================
-void renderer::primitive_flush_pending()
+void renderer_d3d9::primitive_flush_pending()
{
// ignore if we're not locked
- if (m_lockedbuf == NULL)
+ if (m_lockedbuf == nullptr)
{
return;
}
@@ -1805,7 +1760,7 @@ void renderer::primitive_flush_pending()
// unlock the buffer
HRESULT result = (*d3dintf->vertexbuf.unlock)(m_vertexbuf);
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during vertex buffer unlock call\n", (int)result);
- m_lockedbuf = NULL;
+ m_lockedbuf = nullptr;
// set the stream
result = (*d3dintf->device.set_stream_source)(m_device, 0, m_vertexbuf, sizeof(vertex));
@@ -1830,7 +1785,7 @@ void renderer::primitive_flush_pending()
set_texture(texture);
// set filtering if different
- if (texture != NULL)
+ if (texture != nullptr)
{
newfilter = FALSE;
if (PRIMFLAG_GET_SCREENTEX(flags))
@@ -1882,24 +1837,24 @@ void renderer::primitive_flush_pending()
texture_info::~texture_info()
{
- if (m_d3dfinaltex != NULL)
+ if (m_d3dfinaltex != nullptr)
{
if (m_d3dtex == m_d3dfinaltex)
{
- m_d3dtex = NULL;
+ m_d3dtex = nullptr;
}
(*d3dintf->texture.release)(m_d3dfinaltex);
- m_d3dfinaltex = NULL;
+ m_d3dfinaltex = nullptr;
}
- if (m_d3dtex != NULL)
+ if (m_d3dtex != nullptr)
{
(*d3dintf->texture.release)(m_d3dtex);
- m_d3dtex = NULL;
+ m_d3dtex = nullptr;
}
- if (m_d3dsurface != NULL)
+ if (m_d3dsurface != nullptr)
{
(*d3dintf->surface.release)(m_d3dsurface);
- m_d3dsurface = NULL;
+ m_d3dsurface = nullptr;
}
}
@@ -1908,7 +1863,7 @@ texture_info::~texture_info()
// texture_info constructor
//============================================================
-texture_info::texture_info(texture_manager *manager, const render_texinfo* texsource, int prescale, UINT32 flags)
+texture_info::texture_info(d3d_texture_manager *manager, const render_texinfo* texsource, int prescale, UINT32 flags)
{
HRESULT result;
@@ -1921,9 +1876,9 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
m_xprescale = prescale;
m_yprescale = prescale;
- m_d3dtex = NULL;
- m_d3dsurface = NULL;
- m_d3dfinaltex = NULL;
+ m_d3dtex = nullptr;
+ m_d3dsurface = nullptr;
+ m_d3dfinaltex = nullptr;
// compute the size
compute_size(texsource->width, texsource->height);
@@ -2053,7 +2008,7 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
break;
}
(*d3dintf->texture.release)(m_d3dtex);
- m_d3dtex = NULL;
+ m_d3dtex = nullptr;
}
}
}
@@ -2063,9 +2018,9 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
//texsource->osdhandle = (void*)this;
// add us to the texture list
- if(m_texture_manager->get_texlist() != NULL)
+ if(m_texture_manager->get_texlist() != nullptr)
m_texture_manager->get_texlist()->m_prev = this;
- m_prev = NULL;
+ m_prev = nullptr;
m_next = m_texture_manager->get_texlist();
m_texture_manager->set_texlist(this);
return;
@@ -2073,9 +2028,9 @@ texture_info::texture_info(texture_manager *manager, const render_texinfo* texso
error:
d3dintf->post_fx_available = false;
osd_printf_error("Direct3D: Critical warning: A texture failed to allocate. Expect things to get bad quickly.\n");
- if (m_d3dsurface != NULL)
+ if (m_d3dsurface != nullptr)
(*d3dintf->surface.release)(m_d3dsurface);
- if (m_d3dtex != NULL)
+ if (m_d3dtex != nullptr)
(*d3dintf->texture.release)(m_d3dtex);
}
@@ -2242,7 +2197,7 @@ static inline void copyline_rgb32(UINT32 *dst, const UINT32 *src, int width, con
assert(xborderpix == 0 || xborderpix == 1);
// palette (really RGB map) case
- if (palette != NULL)
+ if (palette != nullptr)
{
if (xborderpix)
{
@@ -2285,7 +2240,7 @@ static inline void copyline_argb32(UINT32 *dst, const UINT32 *src, int width, co
assert(xborderpix == 0 || xborderpix == 1);
// palette (really RGB map) case
- if (palette != NULL)
+ if (palette != nullptr)
{
if (xborderpix)
{
@@ -2329,7 +2284,7 @@ static inline void copyline_yuy16_to_yuy2(UINT16 *dst, const UINT16 *src, int wi
assert(width % 2 == 0);
// palette (really RGB map) case
- if (palette != NULL)
+ if (palette != nullptr)
{
if (xborderpix)
{
@@ -2394,7 +2349,7 @@ static inline void copyline_yuy16_to_uyvy(UINT16 *dst, const UINT16 *src, int wi
assert(width % 2 == 0);
// palette (really RGB map) case
- if (palette != NULL)
+ if (palette != nullptr)
{
if (xborderpix)
{
@@ -2457,7 +2412,7 @@ static inline void copyline_yuy16_to_argb(UINT32 *dst, const UINT16 *src, int wi
assert(width % 2 == 0);
// palette (really RGB map) case
- if (palette != NULL)
+ if (palette != nullptr)
{
if (xborderpix)
{
@@ -2535,9 +2490,9 @@ void texture_info::set_data(const render_texinfo *texsource, UINT32 flags)
switch (m_type)
{
default:
- case TEXTURE_TYPE_PLAIN: result = (*d3dintf->texture.lock_rect)(m_d3dtex, 0, &rect, NULL, 0); break;
- case TEXTURE_TYPE_DYNAMIC: result = (*d3dintf->texture.lock_rect)(m_d3dtex, 0, &rect, NULL, D3DLOCK_DISCARD); break;
- case TEXTURE_TYPE_SURFACE: result = (*d3dintf->surface.lock_rect)(m_d3dsurface, &rect, NULL, D3DLOCK_DISCARD); break;
+ case TEXTURE_TYPE_PLAIN: result = (*d3dintf->texture.lock_rect)(m_d3dtex, 0, &rect, nullptr, 0); break;
+ case TEXTURE_TYPE_DYNAMIC: result = (*d3dintf->texture.lock_rect)(m_d3dtex, 0, &rect, nullptr, D3DLOCK_DISCARD); break;
+ case TEXTURE_TYPE_SURFACE: result = (*d3dintf->surface.lock_rect)(m_d3dsurface, &rect, nullptr, D3DLOCK_DISCARD); break;
}
if (result != D3D_OK)
{
@@ -2625,7 +2580,7 @@ void texture_info::prescale()
// if we have an offscreen plain surface, we can just StretchRect to it
if (m_type == TEXTURE_TYPE_SURFACE)
{
- assert(m_d3dsurface != NULL);
+ assert(m_d3dsurface != nullptr);
// set the source bounds
RECT source;
@@ -2649,7 +2604,7 @@ void texture_info::prescale()
{
surface *backbuffer;
- assert(m_d3dtex != NULL);
+ assert(m_d3dtex != nullptr);
// first remember the original render target and set the new one
result = (*d3dintf->device.get_render_target)(m_renderer->get_device(), 0, &backbuffer);
@@ -2704,7 +2659,7 @@ void texture_info::prescale()
// unlock the vertex buffer
result = (*d3dintf->vertexbuf.unlock)(m_renderer->get_vertex_buffer());
if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during vertex buffer unlock call\n", (int)result);
- m_renderer->set_locked_buffer(NULL);
+ m_renderer->set_locked_buffer(nullptr);
// set the stream and draw the triangle strip
result = (*d3dintf->device.set_stream_source)(m_renderer->get_device(), 0, m_renderer->get_vertex_buffer(), sizeof(vertex));
@@ -2734,15 +2689,15 @@ void texture_info::prescale()
cache_target::~cache_target()
{
- if (last_texture != NULL)
+ if (last_texture != nullptr)
{
(*d3dintf->texture.release)(last_texture);
- last_texture = NULL;
+ last_texture = nullptr;
}
- if (last_target != NULL)
+ if (last_target != nullptr)
{
(*d3dintf->surface.release)(last_target);
- last_target = NULL;
+ last_target = nullptr;
}
}
@@ -2751,7 +2706,7 @@ cache_target::~cache_target()
// cache_target::init - initializes a target cache
//============================================================
-bool cache_target::init(renderer *d3d, base *d3dintf, int width, int height, int prescale_x, int prescale_y)
+bool cache_target::init(renderer_d3d9 *d3d, d3d_base *d3dintf, int width, int height, int prescale_x, int prescale_y)
{
HRESULT result = (*d3dintf->device.create_texture)(d3d->get_device(), width * prescale_x, height * prescale_y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &last_texture);
if (result != D3D_OK)
@@ -2768,56 +2723,56 @@ bool cache_target::init(renderer *d3d, base *d3dintf, int width, int height, int
//============================================================
-// render_target::~render_target
+// d3d_render_target::~d3d_render_target
//============================================================
-render_target::~render_target()
+d3d_render_target::~d3d_render_target()
{
for (int index = 0; index < 11; index++)
{
- if (bloom_texture[index] != NULL)
+ if (bloom_texture[index] != nullptr)
{
(*d3dintf->texture.release)(bloom_texture[index]);
- bloom_texture[index] = NULL;
+ bloom_texture[index] = nullptr;
}
- if (bloom_target[index] != NULL)
+ if (bloom_target[index] != nullptr)
{
(*d3dintf->surface.release)(bloom_target[index]);
- bloom_target[index] = NULL;
+ bloom_target[index] = nullptr;
}
}
for (int index = 0; index < 2; index++)
{
- if (native_texture[index] != NULL)
+ if (native_texture[index] != nullptr)
{
(*d3dintf->texture.release)(native_texture[index]);
- native_texture[index] = NULL;
+ native_texture[index] = nullptr;
}
- if (native_target[index] != NULL)
+ if (native_target[index] != nullptr)
{
(*d3dintf->surface.release)(native_target[index]);
- native_target[index] = NULL;
+ native_target[index] = nullptr;
}
- if (prescale_texture[index] != NULL)
+ if (prescale_texture[index] != nullptr)
{
(*d3dintf->texture.release)(prescale_texture[index]);
- prescale_texture[index] = NULL;
+ prescale_texture[index] = nullptr;
}
- if (prescale_target[index] != NULL)
+ if (prescale_target[index] != nullptr)
{
(*d3dintf->surface.release)(prescale_target[index]);
- prescale_target[index] = NULL;
+ prescale_target[index] = nullptr;
}
}
}
//============================================================
-// render_target::init - initializes a render target
+// d3d_render_target::init - initializes a render target
//============================================================
-bool render_target::init(renderer *d3d, base *d3dintf, int width, int height, int prescale_x, int prescale_y)
+bool d3d_render_target::init(renderer_d3d9 *d3d, d3d_base *d3dintf, int width, int height, int prescale_x, int prescale_y)
{
HRESULT result;
@@ -2866,4 +2821,12 @@ bool render_target::init(renderer *d3d, base *d3dintf, int width, int height, in
return true;
}
+texture_info *renderer_d3d9::get_default_texture()
+{
+ return m_texture_manager->get_default_texture();
+}
+
+texture_info *renderer_d3d9::get_vector_texture()
+{
+ return m_texture_manager->get_vector_texture();
}