Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-22 16:31:49 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactored d3d_render_target (nw)

Browse Source 
* removed cashe_target class
* moved cashe texture and surface to d3d_render_target class
* render targets are now created per screen not per screen texture
* removed useless creation of render targets for ui textures
This commit is contained in:
Jezze 2016-10-22 17:12:38 +02:00
parent e42ed88254
commit 390e6bd43d
4 changed files with 129 additions and 313 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
src/osd/modules/render/d3d/d3dcomm.h
View File

@ -71,7 +71,7 @@ public:
void delete_resources();
texture_info * find_texinfo(const render_texinfo *texture, uint32_t flags);
uint32_t texture_compute_hash(const render_texinfo *texture, uint32_t flags);
uint32_t texture_compute_hash(const render_texinfo *texture, uint32_t flags);
bool is_dynamic_supported() const { return (bool)m_dynamic_supported; }
void set_dynamic_supported(bool dynamic_supported) { m_dynamic_supported = dynamic_supported; }
@ -119,11 +119,11 @@ public:
int get_xscale() const { return m_xprescale; }
int get_yscale() const { return m_yprescale; }
uint32_t get_flags() const { return m_flags; }
uint32_t get_flags() const { return m_flags; }
void set_data(const render_texinfo *texsource, uint32_t flags);
uint32_t get_hash() const { return m_hash; }
uint32_t get_hash() const { return m_hash; }
void increment_frame_count() { m_cur_frame++; }
void mask_frame_count(int mask) { m_cur_frame %= mask; }
@ -147,8 +147,8 @@ private:
renderer_d3d9 * m_renderer; // renderer pointer
uint32_t m_hash; // hash value for the texture
uint32_t m_flags; // rendering flags
uint32_t m_hash; // hash value for the texture
uint32_t m_flags; // rendering flags
render_texinfo m_texinfo; // copy of the texture info
vec2f m_start; // beggining UV coordinates
vec2f m_stop; // ending UV coordinates
@ -181,9 +181,9 @@ public:
}
D3DPRIMITIVETYPE type() const { return m_type; }
uint32_t count() const { return m_count; }
uint32_t numverts() const { return m_numverts; }
uint32_t flags() const { return m_flags; }
uint32_t count() const { return m_count; }
uint32_t numverts() const { return m_numverts; }
uint32_t flags() const { return m_flags; }
texture_info * texture() const { return m_texture; }
DWORD modmode() const { return m_modmode; }
@ -193,9 +193,9 @@ public:
private:
D3DPRIMITIVETYPE m_type; // type of primitive
uint32_t m_count; // total number of primitives
uint32_t m_numverts; // total number of vertices
uint32_t m_flags; // rendering flags
uint32_t m_count; // total number of primitives
uint32_t m_numverts; // total number of vertices
uint32_t m_flags; // rendering flags
texture_info * m_texture; // pointer to texture info
DWORD m_modmode; // texture modulation mode
@ -215,36 +215,12 @@ struct vertex
};
/* cache_target is a simple linked list containing only a renderable target and texture, used for phosphor effects */
class cache_target
{
public:
// construction/destruction
cache_target(): target(nullptr), texture(nullptr), target_width(0), target_height(0), width(0), height(0), screen_index(0)
{ }
~cache_target();
bool init(renderer_d3d9 *d3d, int source_width, int source_height, int target_width, int target_height, int screen_index);
IDirect3DSurface9 *target;
IDirect3DTexture9 *texture;
int target_width;
int target_height;
int width;
int height;
int screen_index;
};
/* d3d_render_target is the information about a Direct3D render target chain */
class d3d_render_target
{
public:
// construction/destruction
d3d_render_target(): target_width(0), target_height(0), width(0), height(0), screen_index(0), page_index(0), bloom_count(0)
d3d_render_target(): target_width(0), target_height(0), width(0), height(0), screen_index(0), bloom_count(0)
{
for (int index = 0; index < MAX_BLOOM_COUNT; index++)
{
@ -259,11 +235,14 @@ public:
target_texture[index] = nullptr;
target_surface[index] = nullptr;
}
cache_texture = nullptr;
cache_surface = nullptr;
}
~d3d_render_target();
bool init(renderer_d3d9 *d3d, int source_width, int source_height, int target_width, int target_height, int screen_index, int page_index);
bool init(renderer_d3d9 *d3d, int source_width, int source_height, int target_width, int target_height, int screen_index);
int next_index(int index) { return ++index > 1 ? 0 : index; }
// real target dimension
@ -275,13 +254,15 @@ public:
int height;
int screen_index;
int page_index;
IDirect3DSurface9 *target_surface[2];
IDirect3DTexture9 *target_texture[2];
IDirect3DSurface9 *source_surface[2];
IDirect3DTexture9 *source_texture[2];
IDirect3DSurface9 *cache_surface;
IDirect3DTexture9 *cache_texture;
IDirect3DSurface9 *bloom_surface[MAX_BLOOM_COUNT];
IDirect3DTexture9 *bloom_texture[MAX_BLOOM_COUNT];

218
src/osd/modules/render/d3d/d3dhlsl.cpp
View File

@ -367,38 +367,13 @@ void shaders::render_snapshot(IDirect3DSurface9 *surface)
}
//============================================================
// remove_cache_target - remove an active cache target
//============================================================
void shaders::remove_cache_target(cache_target *cache)
{
if (cache == nullptr)
return;
for (auto it = m_cache_target_list.begin(); it != m_cache_target_list.end(); it++)
{
if ((*it).get() == cache)
{
m_cache_target_list.erase(it);
break;
}
}
}
//============================================================
// remove_render_target - remove an active target
//============================================================
void shaders::remove_render_target(texture_info *texture)
void shaders::remove_render_target(int source_width, int source_height, uint32_t screen_index)
{
remove_render_target(find_render_target(texture));
}
void shaders::remove_render_target(int source_width, int source_height, uint32_t screen_index, uint32_t page_index)
{
remove_render_target(find_render_target(source_width, source_height, screen_index, page_index));
remove_render_target(find_render_target(source_width, source_height, screen_index));
}
void shaders::remove_render_target(d3d_render_target *rt)
@ -406,11 +381,6 @@ void shaders::remove_render_target(d3d_render_target *rt)
if (rt == nullptr)
return;
int screen_index = rt->screen_index;
int other_page = 1 - rt->page_index;
int width = rt->width;
int height = rt->height;
for (auto it = m_render_target_list.begin(); it != m_render_target_list.end(); it++)
{
if ((*it).get() == rt)
@ -419,11 +389,6 @@ void shaders::remove_render_target(d3d_render_target *rt)
break;
}
}
remove_cache_target(find_cache_target(screen_index, width, height));
// Remove other double-buffered page (if it exists)
remove_render_target(width, height, screen_index, other_page);
}
@ -859,6 +824,7 @@ void shaders::begin_draw()
return;
}
curr_screen = 0;
curr_effect = default_effect;
default_effect->set_technique("ScreenTechnique");
@ -939,48 +905,13 @@ void shaders::blit(
// shaders::find_render_target
//============================================================
d3d_render_target* shaders::find_render_target(texture_info *texture)
{
uint32_t screen_index_data = (uint32_t)texture->get_texinfo().osddata;
uint32_t screen_index = screen_index_data >> 1;
uint32_t page_index = screen_index_data & 1;
return find_render_target(texture->get_width(), texture->get_height(), screen_index, page_index);
}
//============================================================
// shaders::find_render_target
//============================================================
d3d_render_target* shaders::find_render_target(int source_width, int source_height, uint32_t screen_index, uint32_t page_index)
d3d_render_target* shaders::find_render_target(int source_width, int source_height, uint32_t screen_index)
{
for (auto it = m_render_target_list.begin(); it != m_render_target_list.end(); it++)
{
if ((*it)->width == source_width &&
(*it)->height == source_height &&
(*it)->screen_index == screen_index &&
(*it)->page_index == page_index)
{
return (*it).get();
}
}
return nullptr;
}
//============================================================
// shaders::find_cache_target
//============================================================
cache_target *shaders::find_cache_target(uint32_t screen_index, int width, int height)
{
for (auto it = m_cache_target_list.begin(); it != m_cache_target_list.end(); it++)
{
if ((*it)->screen_index == screen_index &&
(*it)->width == width &&
(*it)->height == height)
(*it)->screen_index == screen_index)
{
return (*it).get();
}
@ -1128,7 +1059,7 @@ int shaders::defocus_pass(d3d_render_target *rt, int source_index, poly_info *po
return next_index;
}
int shaders::phosphor_pass(d3d_render_target *rt, cache_target *ct, int source_index, poly_info *poly, int vertnum)
int shaders::phosphor_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum)
{
int next_index = source_index;
@ -1141,7 +1072,7 @@ int shaders::phosphor_pass(d3d_render_target *rt, cache_target *ct, int source_i
curr_effect = phosphor_effect;
curr_effect->update_uniforms();
curr_effect->set_texture("Diffuse", rt->target_texture[next_index]);
curr_effect->set_texture("LastPass", ct->texture);
curr_effect->set_texture("LastPass", rt->cache_texture);
curr_effect->set_bool("Passthrough", false);
next_index = rt->next_index(next_index);
@ -1154,7 +1085,7 @@ int shaders::phosphor_pass(d3d_render_target *rt, cache_target *ct, int source_i
curr_effect->set_bool("Passthrough", true);
// Avoid changing targets due to page flipping
blit(ct->target, true, D3DPT_TRIANGLELIST, 0, 2);
blit(rt->cache_surface, true, D3DPT_TRIANGLELIST, 0, 2);
return next_index;
}
@ -1401,11 +1332,17 @@ void shaders::render_quad(poly_info *poly, int vertnum)
auto win = d3d->assert_window();
if (PRIMFLAG_GET_SCREENTEX(d3d->get_last_texture_flags()) && curr_texture != nullptr)
if (PRIMFLAG_GET_SCREENTEX(poly->flags()))
{
if (curr_texture == nullptr)
{
osd_printf_verbose("Direct3D: No texture\n");
return;
}
curr_screen = curr_screen < num_screens ? curr_screen : 0;
curr_render_target = find_render_target(curr_texture);
curr_render_target = find_render_target(curr_texture->get_width(), curr_texture->get_height(), curr_screen);
d3d_render_target *rt = curr_render_target;
if (rt == nullptr)
@ -1414,8 +1351,6 @@ void shaders::render_quad(poly_info *poly, int vertnum)
return;
}
cache_target *ct = find_cache_target(rt->screen_index, curr_texture->get_width(), curr_texture->get_height());
int next_index = 0;
next_index = ntsc_pass(rt, next_index, poly, vertnum); // handled in bgfx
@ -1424,7 +1359,7 @@ void shaders::render_quad(poly_info *poly, int vertnum)
next_index = deconverge_pass(rt, next_index, poly, vertnum); // handled in bgfx
next_index = defocus_pass(rt, next_index, poly, vertnum); // 1st pass
next_index = defocus_pass(rt, next_index, poly, vertnum); // 2nd pass
next_index = phosphor_pass(rt, ct, next_index, poly, vertnum);
next_index = phosphor_pass(rt, next_index, poly, vertnum);
// create bloom textures
int phosphor_index = next_index;
@ -1450,13 +1385,15 @@ void shaders::render_quad(poly_info *poly, int vertnum)
}
else if (PRIMFLAG_GET_VECTOR(poly->flags()))
{
curr_screen = curr_screen < num_screens ? curr_screen : 0;
int source_width = int(poly->prim_width() + 0.5f);
int source_height = int(poly->prim_height() + 0.5f);
if (win->swap_xy())
{
std::swap(source_width, source_height);
}
curr_render_target = find_render_target(source_width, source_height, 0, 0);
curr_render_target = find_render_target(source_width, source_height, curr_screen);
d3d_render_target *rt = curr_render_target;
if (rt == nullptr)
@ -1474,6 +1411,8 @@ void shaders::render_quad(poly_info *poly, int vertnum)
{
osd_printf_verbose("Direct3D: Error %08lX during device SetRenderTarget call\n", result);
}
curr_screen++;
}
else if (PRIMFLAG_GET_VECTORBUF(poly->flags()))
{
@ -1485,7 +1424,7 @@ void shaders::render_quad(poly_info *poly, int vertnum)
{
std::swap(source_width, source_height);
}
curr_render_target = find_render_target(source_width, source_height, 0, 0);
curr_render_target = find_render_target(source_width, source_height, curr_screen);
d3d_render_target *rt = curr_render_target;
if (rt == nullptr)
@ -1494,15 +1433,13 @@ void shaders::render_quad(poly_info *poly, int vertnum)
return;
}
cache_target *ct = find_cache_target(rt->screen_index, rt->width, rt->height);
int next_index = 0;
next_index = vector_buffer_pass(rt, next_index, poly, vertnum);
next_index = deconverge_pass(rt, next_index, poly, vertnum);
next_index = defocus_pass(rt, next_index, poly, vertnum); // 1st pass
next_index = defocus_pass(rt, next_index, poly, vertnum); // 2nd pass
next_index = phosphor_pass(rt, ct, next_index, poly, vertnum);
next_index = phosphor_pass(rt, next_index, poly, vertnum);
// create bloom textures
int phosphor_index = next_index;
@ -1557,27 +1494,11 @@ void shaders::end_draw()
}
//============================================================
// shaders::add_cache_target - register a cache target
//============================================================
bool shaders::add_cache_target(renderer_d3d9* d3d, texture_info* texture, int source_width, int source_height, int target_width, int target_height, int screen_index)
{
auto target = std::make_unique<cache_target>();
if (!target->init(d3d, source_width, source_height, target_width, target_height, screen_index))
return false;
m_cache_target_list.push_back(std::move(target));
return true;
}
//============================================================
// shaders::get_texture_target
//============================================================
d3d_render_target* shaders::get_texture_target(render_primitive *prim, texture_info *texture)
d3d_render_target* shaders::get_texture_target(render_primitive *prim, int width, int height, int screen)
{
if (!enabled())
{
@ -1586,6 +1507,9 @@ d3d_render_target* shaders::get_texture_target(render_primitive *prim, texture_i
auto win = d3d->assert_window();
int source_width = width;
int source_height = height;
int source_screen = screen;
int target_width = int(prim->get_full_quad_width() + 0.5f);
int target_height = int(prim->get_full_quad_height() + 0.5f);
target_width *= oversampling_enable ? 2 : 1;
@ -1596,24 +1520,25 @@ d3d_render_target* shaders::get_texture_target(render_primitive *prim, texture_i
}
// find render target and check if the size of the target quad has changed
d3d_render_target *target = find_render_target(texture);
d3d_render_target *target = find_render_target(source_width, source_height, source_screen);
if (target != nullptr)
{
if (PRIMFLAG_GET_SCREENTEX(prim->flags))
// check if the size of the screen quad has changed
if (target->target_width != target_width || target->target_height != target_height)
{
// check if the size of the screen quad has changed
if (target->target_width != target_width || target->target_height != target_height)
{
osd_printf_verbose("Direct3D: Get texture target - invalid size\n");
return nullptr;
}
osd_printf_verbose("Direct3D: Get texture target - invalid size\n");
return nullptr;
}
}
else
{
osd_printf_verbose("Direct3D: Get texture target - not found - %dx%d:%d\n", source_width, source_height, source_screen);
}
return target;
}
d3d_render_target* shaders::get_vector_target(render_primitive *prim)
d3d_render_target* shaders::get_vector_target(render_primitive *prim, int screen)
{
if (!enabled())
{
@ -1624,6 +1549,7 @@ d3d_render_target* shaders::get_vector_target(render_primitive *prim)
int source_width = int(prim->get_quad_width() + 0.5f);
int source_height = int(prim->get_quad_height() + 0.5f);
int source_screen = screen;
int target_width = int(prim->get_full_quad_width() + 0.5f);
int target_height = int(prim->get_full_quad_height() + 0.5f);
target_width *= oversampling_enable ? 2 : 1;
@ -1635,24 +1561,25 @@ d3d_render_target* shaders::get_vector_target(render_primitive *prim)
}
// find render target
d3d_render_target *target = find_render_target(source_width, source_height, 0, 0);
d3d_render_target *target = find_render_target(source_width, source_height, source_screen);
if (target != nullptr)
{
if (PRIMFLAG_GET_VECTORBUF(prim->flags))
// check if the size of the screen quad has changed
if (target->target_width != target_width || target->target_height != target_height)
{
// check if the size of the screen quad has changed
if (target->target_width != target_width || target->target_height != target_height)
{
osd_printf_verbose("Direct3D: Get vector target - invalid size\n");
return nullptr;
}
osd_printf_verbose("Direct3D: Get vector target - invalid size\n");
return nullptr;
}
}
else
{
osd_printf_verbose("Direct3D: Get vector target - not found - %dx%d:%d\n", source_width, source_height, source_screen);
}
return target;
}
bool shaders::create_vector_target(render_primitive *prim)
bool shaders::create_vector_target(render_primitive *prim, int screen)
{
if (!enabled())
{
@ -1663,6 +1590,7 @@ bool shaders::create_vector_target(render_primitive *prim)
int source_width = int(prim->get_quad_width() + 0.5f);
int source_height = int(prim->get_quad_height() + 0.5f);
int source_screen = screen;
int target_width = int(prim->get_full_quad_width() + 0.5f);
int target_height = int(prim->get_full_quad_height() + 0.5f);
target_width *= oversampling_enable ? 2 : 1;
@ -1674,7 +1602,7 @@ bool shaders::create_vector_target(render_primitive *prim)
}
osd_printf_verbose("Direct3D: Create vector target - %dx%d\n", target_width, target_height);
if (!add_render_target(d3d, prim, nullptr, source_width, source_height, target_width, target_height))
if (!add_render_target(d3d, prim, source_width, source_height, source_screen, target_width, target_height))
{
return false;
}
@ -1687,38 +1615,15 @@ bool shaders::create_vector_target(render_primitive *prim)
// shaders::add_render_target - register a render target
//============================================================
bool shaders::add_render_target(renderer_d3d9* d3d, render_primitive *prim, texture_info* texture, int source_width, int source_height, int target_width, int target_height)
bool shaders::add_render_target(renderer_d3d9* d3d, render_primitive *prim, int source_width, int source_height, int source_screen, int target_width, int target_height)
{
uint32_t screen_index = 0;
uint32_t page_index = 0;
if (texture != nullptr)
{
uint32_t screen_index_data = (uint32_t)texture->get_texinfo().osddata;
screen_index = screen_index_data >> 1;
page_index = screen_index_data & 1;
remove_render_target(find_render_target(texture));
}
else
{
remove_render_target(find_render_target(source_width, source_height, 0, 0));
}
remove_render_target(find_render_target(source_width, source_height, source_screen));
auto target = std::make_unique<d3d_render_target>();
if (!target->init(d3d, source_width, source_height, target_width, target_height, screen_index, page_index))
if (!target->init(d3d, source_width, source_height, target_width, target_height, source_screen))
return false;
// cached target only for screen texture and vector buffer
if (PRIMFLAG_GET_SCREENTEX(prim->flags) || PRIMFLAG_GET_VECTORBUF(prim->flags))
{
if (!find_cache_target(target->screen_index, source_width, source_height))
{
if (!add_cache_target(d3d, texture, source_width, source_height, target_width, target_height, target->screen_index))
return false;
}
}
m_render_target_list.push_back(std::move(target));
return true;
@ -1736,10 +1641,10 @@ void shaders::enumerate_screens()
//============================================================
// shaders::register_texture(texture::info)
// shaders::create_texture_target
//============================================================
bool shaders::register_texture(render_primitive *prim, texture_info *texture)
bool shaders::create_texture_target(render_primitive *prim, int width, int height, int screen)
{
if (!enabled())
{
@ -1748,8 +1653,9 @@ bool shaders::register_texture(render_primitive *prim, texture_info *texture)
auto win = d3d->assert_window();
int source_width = texture->get_width();
int source_height = texture->get_height();
int source_width = width;
int source_height = height;
int source_screen = screen;
int target_width = int(prim->get_full_quad_width() + 0.5f);
int target_height = int(prim->get_full_quad_height() + 0.5f);
target_width *= oversampling_enable ? 2 : 1;
@ -1760,8 +1666,8 @@ bool shaders::register_texture(render_primitive *prim, texture_info *texture)
std::swap(target_width, target_height);
}
osd_printf_verbose("Direct3D: Register texture - %dx%d\n", target_width, target_height);
if (!add_render_target(d3d, prim, texture, source_width, source_height, target_width, target_height))
osd_printf_verbose("Direct3D: Create texture target - %dx%d\n", target_width, target_height);
if (!add_render_target(d3d, prim, source_width, source_height, source_screen, target_width, target_height))
{
return false;
}
@ -1790,8 +1696,6 @@ void shaders::delete_resources()
last_options = *options;
}
m_cache_target_list.clear();
m_render_target_list.clear();
if (downsample_effect != nullptr)

27
src/osd/modules/render/d3d/d3dhlsl.h
View File

@ -283,18 +283,16 @@ public:
bool enabled() { return post_fx_enable && d3dintf->post_fx_available; }
void toggle() { post_fx_enable = initialized && !post_fx_enable; }
d3d_render_target* get_vector_target(render_primitive *prim);
bool create_vector_target(render_primitive *prim);
void begin_draw();
void end_draw();
void render_quad(poly_info *poly, int vertnum);
bool register_texture(render_primitive *prim, texture_info *texture);
d3d_render_target* get_texture_target(render_primitive *prim, texture_info *texture);
bool add_render_target(renderer_d3d9* d3d, render_primitive *prim, texture_info* texture, int source_width, int source_height, int target_width, int target_height);
bool add_cache_target(renderer_d3d9* d3d, texture_info* texture, int source_width, int source_height, int target_width, int target_height, int screen_index);
bool create_vector_target(render_primitive *prim, int screen);
d3d_render_target* get_vector_target(render_primitive *prim, int screen);
bool create_texture_target(render_primitive *prim, int width, int height, int screen);
d3d_render_target* get_texture_target(render_primitive *prim, int width, int height, int screen);
bool add_render_target(renderer_d3d9* d3d, render_primitive *prim, int source_width, int source_height, int source_screen, int target_width, int target_height);
void save_snapshot();
void record_movie();
@ -302,11 +300,9 @@ public:
void init_fsfx_quad();
void set_texture(texture_info *info);
d3d_render_target * find_render_target(texture_info *texture);
void remove_render_target(texture_info *texture);
void remove_render_target(int source_width, int source_height, uint32_t screen_index, uint32_t page_index);
void remove_render_target(d3d_render_target *rt);
void set_texture(texture_info *info);
void remove_render_target(int source_width, int source_height, uint32_t screen_index);
void remove_render_target(d3d_render_target *rt);
int create_resources();
void delete_resources();
@ -324,9 +320,7 @@ private:
void render_snapshot(IDirect3DSurface9 *surface);
d3d_render_target* find_render_target(int source_width, int source_height, uint32_t screen_index, uint32_t page_index);
cache_target * find_cache_target(uint32_t screen_index, int width, int height);
void remove_cache_target(cache_target *cache);
d3d_render_target* find_render_target(int source_width, int source_height, uint32_t screen_index);
rgb_t apply_color_convolution(rgb_t color);
@ -336,7 +330,7 @@ private:
int prescale_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum);
int deconverge_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum);
int defocus_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum);
int phosphor_pass(d3d_render_target *rt, cache_target *ct, int source_index, poly_info *poly, int vertnum);
int phosphor_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum);
int post_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum, bool prepare_bloom);
int downsample_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum);
int bloom_pass(d3d_render_target *rt, int source_index, poly_info *poly, int vertnum);
@ -396,7 +390,6 @@ private:
poly_info * curr_poly;
std::vector<std::unique_ptr<d3d_render_target>> m_render_target_list;
std::vector<std::unique_ptr<cache_target>> m_cache_target_list;
std::vector<slider*> internal_sliders;
std::vector<ui::menu_item> m_sliders;

140
src/osd/modules/render/drawd3d.cpp
View File

@ -490,48 +490,7 @@ texture_info *d3d_texture_manager::find_texinfo(const render_texinfo *texinfo, u
(*it)->get_texinfo().height == texinfo->height &&
(((*it)->get_flags() ^ flags) & (PRIMFLAG_BLENDMODE_MASK | PRIMFLAG_TEXFORMAT_MASK)) == 0)
{
// 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((*it).get()) != nullptr)
return (*it).get();
}
else
{
return (*it).get();
}
}
}
// Nothing found, check if we need to unregister something with HLSL
if (m_renderer->get_shaders()->enabled())
{
if (texinfo->width == 0 || texinfo->height == 0)
{
return nullptr;
}
uint32_t prim_screen = texinfo->osddata >> 1;
uint32_t prim_page = texinfo->osddata & 1;
for (auto it = m_texture_list.begin(); it != m_texture_list.end(); it++)
{
uint32_t test_screen = (*it)->get_texinfo().osddata >> 1;
uint32_t test_page = (*it)->get_texinfo().osddata & 1;
if (test_screen != prim_screen || test_page != prim_page)
{
continue;
}
// Clear out our old texture reference
if ((*it)->get_hash() == hash &&
(*it)->get_texinfo().base == texinfo->base &&
(((*it)->get_flags() ^ flags) & (PRIMFLAG_BLENDMODE_MASK | PRIMFLAG_TEXFORMAT_MASK)) == 0 &&
((*it)->get_texinfo().width != texinfo->width ||
(*it)->get_texinfo().height != texinfo->height))
{
m_renderer->get_shaders()->remove_render_target((*it).get());
}
return (*it).get();
}
}
@ -644,30 +603,40 @@ void d3d_texture_manager::update_textures()
texture->get_texinfo().seqid = prim.texture.seqid;
}
}
if (m_renderer->get_shaders()->enabled())
{
if (!m_renderer->get_shaders()->get_texture_target(&prim, texture))
{
if (!m_renderer->get_shaders()->register_texture(&prim, texture))
{
d3dintf->post_fx_available = false;
}
}
}
}
else if(PRIMFLAG_GET_VECTORBUF(prim.flags))
}
if (!m_renderer->get_shaders()->enabled())
{
return;
}
int screen_index = 0;
for (render_primitive &prim : *win->m_primlist)
{
if (PRIMFLAG_GET_SCREENTEX(prim.flags))
{
if (m_renderer->get_shaders()->enabled())
if (!m_renderer->get_shaders()->get_texture_target(&prim, prim.texture.width, prim.texture.height, screen_index))
{
if (!m_renderer->get_shaders()->get_vector_target(&prim))
if (!m_renderer->get_shaders()->create_texture_target(&prim, prim.texture.width, prim.texture.height, screen_index))
{
if (!m_renderer->get_shaders()->create_vector_target(&prim))
{
d3dintf->post_fx_available = false;
}
d3dintf->post_fx_available = false;
break;
}
}
screen_index++;
}
else if (PRIMFLAG_GET_VECTORBUF(prim.flags))
{
if (!m_renderer->get_shaders()->get_vector_target(&prim, screen_index))
{
if (!m_renderer->get_shaders()->create_vector_target(&prim, screen_index))
{
d3dintf->post_fx_available = false;
break;
}
}
screen_index++;
}
}
}
@ -929,7 +898,7 @@ int renderer_d3d9::device_create_resources()
HRESULT result = m_device->CreateVertexBuffer(
sizeof(vertex) * VERTEX_BUFFER_SIZE,
D3DUSAGE_DYNAMIC | D3DUSAGE_SOFTWAREPROCESSING | D3DUSAGE_WRITEONLY,
VERTEX_BASE_FORMAT | ((m_shaders->enabled() && d3dintf->post_fx_available)
VERTEX_BASE_FORMAT | ((m_shaders->enabled())
? D3DFVF_XYZW
: D3DFVF_XYZRHW),
D3DPOOL_DEFAULT, &m_vertexbuf, nullptr);
@ -941,7 +910,7 @@ int renderer_d3d9::device_create_resources()
// set the vertex format
result = m_device->SetFVF(
(D3DFORMAT)(VERTEX_BASE_FORMAT | ((m_shaders->enabled() && d3dintf->post_fx_available)
(D3DFORMAT)(VERTEX_BASE_FORMAT | ((m_shaders->enabled())
? D3DFVF_XYZW
: D3DFVF_XYZRHW)));
if (FAILED(result))
@ -1871,7 +1840,7 @@ void renderer_d3d9::primitive_flush_pending()
assert(vertnum + m_poly[polynum].numverts() <= m_numverts);
if(m_shaders->enabled() && d3dintf->post_fx_available)
if(m_shaders->enabled())
{
m_shaders->render_quad(&m_poly[polynum], vertnum);
}
@ -2764,42 +2733,6 @@ void texture_info::prescale()
}
//============================================================
// cache_target::~cache_target
//============================================================
cache_target::~cache_target()
{
if (texture != nullptr)
texture->Release();
if (target != nullptr)
target->Release();
}
//============================================================
// cache_target::init - initializes a target cache
//============================================================
bool cache_target::init(renderer_d3d9 *d3d, int source_width, int source_height, int target_width, int target_height, int screen_index)
{
this->width = source_width;
this->height = source_height;
this->target_width = target_width;
this->target_height = target_height;
this->screen_index = screen_index;
HRESULT result = d3d->get_device()->CreateTexture(target_width, target_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &texture, nullptr);
if (FAILED(result))
return false;
texture->GetSurfaceLevel(0, &target);
return true;
}
//============================================================
// d3d_render_target::~d3d_render_target
//============================================================
@ -2836,7 +2769,7 @@ d3d_render_target::~d3d_render_target()
// d3d_render_target::init - initializes a render target
//============================================================
bool d3d_render_target::init(renderer_d3d9 *d3d, int source_width, int source_height, int target_width, int target_height, int screen_index, int page_index)
bool d3d_render_target::init(renderer_d3d9 *d3d, int source_width, int source_height, int target_width, int target_height, int screen_index)
{
HRESULT result;
@ -2847,7 +2780,6 @@ bool d3d_render_target::init(renderer_d3d9 *d3d, int source_width, int source_he
this->target_height = target_height;
this->screen_index = screen_index;
this->page_index = page_index;
for (int index = 0; index < 2; index++)
{
@ -2864,6 +2796,12 @@ bool d3d_render_target::init(renderer_d3d9 *d3d, int source_width, int source_he
target_texture[index]->GetSurfaceLevel(0, &target_surface[index]);
}
result = d3d->get_device()->CreateTexture(target_width, target_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &cache_texture, nullptr);
if (FAILED(result))
return false;
cache_texture->GetSurfaceLevel(0, &cache_surface);
auto win = d3d->assert_window();
auto first_screen = win->machine().first_screen();