summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
author Miodrag Milanovic <mmicko@gmail.com>2013-04-08 14:19:17 +0000
committer Miodrag Milanovic <mmicko@gmail.com>2013-04-08 14:19:17 +0000
commitbeab9e30078cd796d870d14bd979bc9f495cb233 (patch)
treec3c395fb764c3d29d014bdd0e54c7eb43f064eb1
parentcbb20345659cfbbde2202c897c1330e30a79b680 (diff)
revert of r22266 (nw)
-rw-r--r--src/emu/render.h1
-rw-r--r--src/osd/windows/d3dcomm.h73
-rw-r--r--src/osd/windows/d3dhlsl.c179
-rw-r--r--src/osd/windows/d3dhlsl.h18
-rw-r--r--src/osd/windows/drawd3d.c610
-rw-r--r--src/osd/windows/drawd3d.h17
6 files changed, 474 insertions, 424 deletions
diff --git a/src/emu/render.h b/src/emu/render.h
index 0b591a9d3d6..e67f6fcfdca 100644
--- a/src/emu/render.h
+++ b/src/emu/render.h
@@ -249,7 +249,6 @@ struct render_texinfo
const rgb_t * palette; // palette for PALETTE16 textures, LUTs for RGB15/RGB32
UINT32 seqid; // sequence ID
UINT64 osddata; // aux data to pass to osd
- void * osdhandle; // handle to OSD-side representation;
};
diff --git a/src/osd/windows/d3dcomm.h b/src/osd/windows/d3dcomm.h
index 3951124fe16..41318dc0822 100644
--- a/src/osd/windows/d3dcomm.h
+++ b/src/osd/windows/d3dcomm.h
@@ -42,68 +42,40 @@
#ifndef __WIN_D3DCOMM__
#define __WIN_D3DCOMM__
-struct d3d_info;
-
//============================================================
// CONSTANTS
//============================================================
-namespace d3d
-{
-//============================================================
-// FORWARD DECLARATIONS
-//============================================================
-
-class texture_info;
//============================================================
// TYPE DEFINITIONS
//============================================================
-/* d3d::texture_info holds information about a texture */
-class texture_info
+/* d3d_texture_info holds information about a texture */
+struct d3d_texture_info
{
-public:
- texture_info(d3d_info *d3d, render_texinfo *texsource, UINT32 flags);
- ~texture_info();
-
- render_texinfo * get_texinfo() { return m_texinfo; }
-
- int get_width() { return m_rawwidth; }
- int get_height() { return m_rawheight; }
- int get_xscale() { return m_xprescale; }
- int get_yscale() { return m_yprescale; }
-
- void set_data(const render_texinfo *texsource, UINT32 flags);
-
-public:
- void prescale();
- void compute_size(int texwidth, int texheight);
-
- d3d_info * m_d3d; // d3d info pointer
- texture_info * m_next; // next texture in the list
- texture_info * m_prev; // prev texture in the list
-
- UINT32 m_hash; // hash value for the texture
- UINT32 m_flags; // rendering flags
- render_texinfo * m_texinfo; // copy of the texture info
- float m_ustart, m_ustop; // beginning/ending U coordinates
- float m_vstart, m_vstop; // beginning/ending V coordinates
- int m_rawwidth, m_rawheight; // raw width/height of the texture
- int m_type; // what type of texture are we?
- int m_xborderpix, m_yborderpix; // number of border pixels on X/Y
- int m_xprescale, m_yprescale; // X/Y prescale factor
- int m_cur_frame; // what is our current frame?
- int m_prev_frame; // what was our last frame? (used to determine pause state)
- d3d_texture * m_d3dtex; // Direct3D texture pointer
- d3d_surface * m_d3dsurface; // Direct3D offscreen plain surface pointer
- d3d_texture * m_d3dfinaltex; // Direct3D final (post-scaled) texture
- int m_target_index; // Direct3D target index
+ d3d_texture_info * next; // next texture in the list
+ d3d_texture_info * prev; // prev texture in the list
+ UINT32 hash; // hash value for the texture
+ UINT32 flags; // rendering flags
+ render_texinfo texinfo; // copy of the texture info
+ float ustart, ustop; // beginning/ending U coordinates
+ float vstart, vstop; // beginning/ending V coordinates
+ int rawwidth, rawheight; // raw width/height of the texture
+ int type; // what type of texture are we?
+ int xborderpix; // number of border pixels in X
+ int yborderpix; // number of border pixels in Y
+ int xprescale; // what is our X prescale factor?
+ int yprescale; // what is our Y prescale factor?
+ int cur_frame; // what is our current frame?
+ int prev_frame; // what was our last frame? (used to determine pause state)
+ d3d_texture * d3dtex; // Direct3D texture pointer
+ d3d_surface * d3dsurface; // Direct3D offscreen plain surface pointer
+ d3d_texture * d3dfinaltex; // Direct3D final (post-scaled) texture
+ int target_index; // Direct3D target index
};
-}; // d3d
-
/* d3d_poly_info holds information about a single polygon/d3d primitive */
struct d3d_poly_info
@@ -113,7 +85,7 @@ struct d3d_poly_info
UINT32 numverts; // total number of vertices
UINT32 flags; // rendering flags
DWORD modmode; // texture modulation mode
- d3d::texture_info * texture; // pointer to texture info
+ d3d_texture_info * texture; // pointer to texture info
float line_time; // used by vectors
float line_length; // used by vectors
};
@@ -136,4 +108,5 @@ struct line_aa_step
float weight; // weight contribution
};
+
#endif
diff --git a/src/osd/windows/d3dhlsl.c b/src/osd/windows/d3dhlsl.c
index 897880c1c7a..733725faa0b 100644
--- a/src/osd/windows/d3dhlsl.c
+++ b/src/osd/windows/d3dhlsl.c
@@ -621,7 +621,7 @@ void hlsl_info::remove_cache_target(d3d_cache_target *cache)
// remove_render_target - remove an active target
//============================================================
-void hlsl_info::remove_render_target(d3d::texture_info *texture)
+void hlsl_info::remove_render_target(d3d_texture_info *texture)
{
remove_render_target(find_render_target(texture));
}
@@ -677,7 +677,7 @@ void hlsl_info::remove_render_target(d3d_render_target *rt)
// hlsl_info::set_texture
//============================================================
-void hlsl_info::set_texture(d3d::texture_info *texture)
+void hlsl_info::set_texture(d3d_texture_info *texture)
{
if (!master_enable || !d3dintf->post_fx_available)
return;
@@ -686,7 +686,7 @@ void hlsl_info::set_texture(d3d::texture_info *texture)
if(texture != NULL)
{
- if(texture->m_prev_frame == texture->m_cur_frame)
+ if(texture->prev_frame == texture->cur_frame)
{
paused = true;
}
@@ -695,15 +695,15 @@ void hlsl_info::set_texture(d3d::texture_info *texture)
paused = false;
}
- texture->m_prev_frame = texture->m_cur_frame;
+ texture->prev_frame = texture->cur_frame;
}
- (*d3dintf->effect.set_texture)(effect, "Diffuse", (texture == NULL) ? d3d->default_texture->m_d3dfinaltex : texture->m_d3dfinaltex);
+ (*d3dintf->effect.set_texture)(effect, "Diffuse", (texture == NULL) ? d3d->default_texture->d3dfinaltex : texture->d3dfinaltex);
if (options->yiq_enable)
- (*d3dintf->effect.set_texture)(yiq_encode_effect, "Diffuse", (texture == NULL) ? d3d->default_texture->m_d3dfinaltex : texture->m_d3dfinaltex);
+ (*d3dintf->effect.set_texture)(yiq_encode_effect, "Diffuse", (texture == NULL) ? d3d->default_texture->d3dfinaltex : texture->d3dfinaltex);
else
- (*d3dintf->effect.set_texture)(color_effect, "Diffuse", (texture == NULL) ? d3d->default_texture->m_d3dfinaltex : texture->m_d3dfinaltex);
- (*d3dintf->effect.set_texture)(pincushion_effect, "Diffuse", (texture == NULL) ? d3d->default_texture->m_d3dfinaltex : texture->m_d3dfinaltex);
+ (*d3dintf->effect.set_texture)(color_effect, "Diffuse", (texture == NULL) ? d3d->default_texture->d3dfinaltex : texture->d3dfinaltex);
+ (*d3dintf->effect.set_texture)(pincushion_effect, "Diffuse", (texture == NULL) ? d3d->default_texture->d3dfinaltex : texture->d3dfinaltex);
}
@@ -1115,7 +1115,7 @@ int hlsl_info::create_resources(bool reset)
texture.seqid = 0;
// now create it
- shadow_texture = new d3d::texture_info(d3d, &texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXFORMAT(TEXFORMAT_ARGB32));
+ shadow_texture = texture_create(d3d, &texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXFORMAT(TEXFORMAT_ARGB32));
}
const char *fx_dir = downcast<windows_options &>(window->machine().options()).screen_post_fx_dir();
@@ -1526,14 +1526,14 @@ void hlsl_info::init_effect_info(d3d_poly_info *poly)
// just post-processing.
curr_effect = post_effect;
- (*d3dintf->effect.set_float)(curr_effect, "ScanlineOffset", (poly->texture->m_cur_frame == 0) ? 0.0f : options->scanline_offset);
+ (*d3dintf->effect.set_float)(curr_effect, "ScanlineOffset", (poly->texture->cur_frame == 0) ? 0.0f : options->scanline_offset);
if(options->params_dirty)
{
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->m_ustop - poly->texture->m_ustart));
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->m_vstop - poly->texture->m_vstart));
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->ustop - poly->texture->ustart));
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", d3d->height);
(*d3dintf->effect.set_vector)(curr_effect, "Floor", 3, options->floor);
@@ -1542,20 +1542,20 @@ void hlsl_info::init_effect_info(d3d_poly_info *poly)
(*d3dintf->effect.set_float)(curr_effect, "PincushionAmount", options->pincushion);
(*d3dintf->effect.set_float)(curr_effect, "CurvatureAmount", options->curvature);
(*d3dintf->effect.set_float)(curr_effect, "UseShadow", shadow_texture == NULL ? 0.0f : 1.0f);
- (*d3dintf->effect.set_texture)(curr_effect, "Shadow", shadow_texture == NULL ? NULL : shadow_texture->m_d3dfinaltex);
+ (*d3dintf->effect.set_texture)(curr_effect, "Shadow", shadow_texture == NULL ? NULL : shadow_texture->d3dfinaltex);
(*d3dintf->effect.set_float)(curr_effect, "ShadowBrightness", options->shadow_mask_alpha);
(*d3dintf->effect.set_float)(curr_effect, "ShadowMaskSizeX", (float)options->shadow_mask_count_x);
(*d3dintf->effect.set_float)(curr_effect, "ShadowMaskSizeY", (float)options->shadow_mask_count_y);
(*d3dintf->effect.set_float)(curr_effect, "ShadowU", options->shadow_mask_u_size);
(*d3dintf->effect.set_float)(curr_effect, "ShadowV", options->shadow_mask_v_size);
- (*d3dintf->effect.set_float)(curr_effect, "ShadowWidth", shadow_texture == NULL ? 1.0f : (float)shadow_texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "ShadowHeight", shadow_texture == NULL ? 1.0f : (float)shadow_texture->m_rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "ShadowWidth", shadow_texture == NULL ? 1.0f : (float)shadow_texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "ShadowHeight", shadow_texture == NULL ? 1.0f : (float)shadow_texture->rawheight);
(*d3dintf->effect.set_float)(curr_effect, "ScanlineAmount", options->scanline_alpha);
(*d3dintf->effect.set_float)(curr_effect, "ScanlineScale", options->scanline_scale);
(*d3dintf->effect.set_float)(curr_effect, "ScanlineHeight", options->scanline_height);
(*d3dintf->effect.set_float)(curr_effect, "ScanlineBrightScale", options->scanline_bright_scale);
(*d3dintf->effect.set_float)(curr_effect, "ScanlineBrightOffset", options->scanline_bright_offset);
- //(*d3dintf->effect.set_float)(curr_effect, "ScanlineOffset", (poly->texture->m_cur_frame == 0) ? 0.0f : options->scanline_offset);
+ //(*d3dintf->effect.set_float)(curr_effect, "ScanlineOffset", (poly->texture->cur_frame == 0) ? 0.0f : options->scanline_offset);
(*d3dintf->effect.set_vector)(curr_effect, "Power", 3, options->power);
}
}
@@ -1572,15 +1572,15 @@ void hlsl_info::init_effect_info(d3d_poly_info *poly)
// hlsl_info::find_render_target
//============================================================
-d3d_render_target* hlsl_info::find_render_target(d3d::texture_info *info)
+d3d_render_target* hlsl_info::find_render_target(d3d_texture_info *info)
{
d3d_render_target *curr = targethead;
- render_texinfo *texinfo = info->get_texinfo();
- UINT32 screen_index_data = (UINT32)texinfo->osddata;
+
+ UINT32 screen_index_data = (UINT32)info->texinfo.osddata;
UINT32 screen_index = screen_index_data >> 1;
UINT32 page_index = screen_index_data & 1;
- while (curr != NULL && (curr->screen_index != screen_index || curr->page_index != page_index || curr->width != texinfo->width || curr->height != texinfo->height))
+ while (curr != NULL && (curr->screen_index != screen_index || curr->page_index != page_index || curr->width != info->texinfo.width || curr->height != info->texinfo.height))
{
curr = curr->next;
}
@@ -1642,7 +1642,7 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
return;
}
- d3d_cache_target *ct = find_cache_target(rt->screen_index, poly->texture->get_texinfo()->width, poly->texture->get_texinfo()->height);
+ d3d_cache_target *ct = find_cache_target(rt->screen_index, poly->texture->texinfo.width, poly->texture->texinfo.height);
if(options->yiq_enable)
{
@@ -1651,15 +1651,15 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
if(options->params_dirty)
{
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->m_ustop - poly->texture->m_ustart));
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->m_vstop - poly->texture->m_vstart));
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->ustop - poly->texture->ustart));
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "CCValue", options->yiq_cc);
(*d3dintf->effect.set_float)(curr_effect, "AValue", options->yiq_a);
- (*d3dintf->effect.set_float)(curr_effect, "BValue", (poly->texture->m_cur_frame == 2) ? 0.0f : ((float)poly->texture->m_cur_frame * options->yiq_b));
+ (*d3dintf->effect.set_float)(curr_effect, "BValue", (poly->texture->cur_frame == 2) ? 0.0f : ((float)poly->texture->cur_frame * options->yiq_b));
(*d3dintf->effect.set_float)(curr_effect, "PValue", options->yiq_p);
(*d3dintf->effect.set_float)(curr_effect, "NotchHalfWidth", options->yiq_n);
(*d3dintf->effect.set_float)(curr_effect, "YFreqResponse", options->yiq_y);
@@ -1691,18 +1691,18 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
curr_effect = yiq_decode_effect;
(*d3dintf->effect.set_texture)(curr_effect, "Composite", rt->texture[4]);
- (*d3dintf->effect.set_texture)(curr_effect, "Diffuse", poly->texture->m_d3dfinaltex);
+ (*d3dintf->effect.set_texture)(curr_effect, "Diffuse", poly->texture->d3dfinaltex);
if(options->params_dirty)
{
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->m_ustop - poly->texture->m_ustart));
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->m_vstop - poly->texture->m_vstart));
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->ustop - poly->texture->ustart));
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "CCValue", options->yiq_cc);
(*d3dintf->effect.set_float)(curr_effect, "AValue", options->yiq_a);
- (*d3dintf->effect.set_float)(curr_effect, "BValue", (poly->texture->m_cur_frame == 2) ? 0.0f : ((float)poly->texture->m_cur_frame * options->yiq_b));
+ (*d3dintf->effect.set_float)(curr_effect, "BValue", (poly->texture->cur_frame == 2) ? 0.0f : ((float)poly->texture->cur_frame * options->yiq_b));
(*d3dintf->effect.set_float)(curr_effect, "OValue", options->yiq_o);
(*d3dintf->effect.set_float)(curr_effect, "PValue", options->yiq_p);
(*d3dintf->effect.set_float)(curr_effect, "NotchHalfWidth", options->yiq_n);
@@ -1741,10 +1741,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
/* Render the initial color-convolution pass */
if(options->params_dirty)
{
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", options->yiq_enable ? 1.0f : (1.0f / (poly->texture->m_ustop - poly->texture->m_ustart)));
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", options->yiq_enable ? 1.0f : (1.0f / (poly->texture->m_vstop - poly->texture->m_vstart)));
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", options->yiq_enable ? 1.0f : (1.0f / (poly->texture->ustop - poly->texture->ustart)));
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", options->yiq_enable ? 1.0f : (1.0f / (poly->texture->vstop - poly->texture->vstart)));
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "YIQEnable", options->yiq_enable ? 1.0f : 0.0f);
@@ -1783,10 +1783,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->m_ustop - poly->texture->m_ustart));
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->m_vstop - poly->texture->m_vstart));
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->ustop - poly->texture->ustart));
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
}
(*d3dintf->effect.begin)(curr_effect, &num_passes, 0);
@@ -1815,10 +1815,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->m_ustop - poly->texture->m_ustart));
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->m_vstop - poly->texture->m_vstart));
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->ustop - poly->texture->ustart));
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
(*d3dintf->effect.set_vector)(curr_effect, "ConvergeX", 3, options->converge_x);
(*d3dintf->effect.set_vector)(curr_effect, "ConvergeY", 3, options->converge_y);
(*d3dintf->effect.set_vector)(curr_effect, "RadialConvergeX", 3, options->radial_converge_x);
@@ -1855,10 +1855,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", poly->texture != NULL ? (1.0f / (poly->texture->m_ustop - poly->texture->m_ustart)) : 0.0f);
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", poly->texture != NULL ? (1.0f / (poly->texture->m_vstop - poly->texture->m_vstart)) : 0.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", poly->texture != NULL ? (1.0f / (poly->texture->ustop - poly->texture->ustart)) : 0.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", poly->texture != NULL ? (1.0f / (poly->texture->vstop - poly->texture->vstart)) : 0.0f);
(*d3dintf->effect.set_vector)(curr_effect, "Defocus", 2, &options->defocus[0]);
(*d3dintf->effect.begin)(curr_effect, &num_passes, 0);
@@ -1885,8 +1885,8 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
(*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f);
(*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f);
(*d3dintf->effect.set_vector)(curr_effect, "Defocus", 2, &options->defocus[1]);
@@ -1917,10 +1917,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
{
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->m_ustop - poly->texture->m_ustart));
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->m_vstop - poly->texture->m_vstart));
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->ustop - poly->texture->ustart));
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
(*d3dintf->effect.set_vector)(curr_effect, "Phosphor", 3, options->phosphor);
}
(*d3dintf->effect.set_float)(curr_effect, "TextureWidth", (float)rt->target_width);
@@ -2151,10 +2151,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_texture)(curr_effect, "Diffuse", rt->texture[2]);
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", poly->texture != NULL ? (float)poly->texture->m_rawwidth : 8.0f);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", poly->texture != NULL ? (float)poly->texture->m_rawheight : 8.0f);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", poly->texture != NULL ? (1.0f / (poly->texture->m_ustop - poly->texture->m_ustart)) : 0.0f);
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", poly->texture != NULL ? (1.0f / (poly->texture->m_vstop - poly->texture->m_vstart)) : 0.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", poly->texture != NULL ? (float)poly->texture->rawwidth : 8.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", poly->texture != NULL ? (float)poly->texture->rawheight : 8.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", poly->texture != NULL ? (1.0f / (poly->texture->ustop - poly->texture->ustart)) : 0.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", poly->texture != NULL ? (1.0f / (poly->texture->vstop - poly->texture->vstart)) : 0.0f);
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "PostPass", 0.0f);
@@ -2174,8 +2174,8 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.end)(curr_effect);
#endif
- poly->texture->m_cur_frame++;
- poly->texture->m_cur_frame %= options->yiq_phase_count;
+ poly->texture->cur_frame++;
+ poly->texture->cur_frame %= options->yiq_phase_count;
options->params_dirty = false;
}
@@ -2379,10 +2379,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->m_rawwidth);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->m_rawheight);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->m_ustop - poly->texture->m_ustart));
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->m_vstop - poly->texture->m_vstart));
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", (float)poly->texture->rawwidth);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", (float)poly->texture->rawheight);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", 1.0f / (poly->texture->ustop - poly->texture->ustart));
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", 1.0f / (poly->texture->vstop - poly->texture->vstart));
result = (*d3dintf->device.set_render_target)(d3d->device, 0, rt->target[1]);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device set_render_target call\n", (int)result);
@@ -2407,10 +2407,10 @@ void hlsl_info::render_quad(d3d_poly_info *poly, int vertnum)
#endif
else
{
- (*d3dintf->effect.set_float)(curr_effect, "RawWidth", poly->texture != NULL ? (float)poly->texture->m_rawwidth : 8.0f);
- (*d3dintf->effect.set_float)(curr_effect, "RawHeight", poly->texture != NULL ? (float)poly->texture->m_rawheight : 8.0f);
- (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", poly->texture != NULL ? (1.0f / (poly->texture->m_ustop - poly->texture->m_ustart)) : 0.0f);
- (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", poly->texture != NULL ? (1.0f / (poly->texture->m_vstop - poly->texture->m_vstart)) : 0.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "RawWidth", poly->texture != NULL ? (float)poly->texture->rawwidth : 8.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "RawHeight", poly->texture != NULL ? (float)poly->texture->rawheight : 8.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "WidthRatio", poly->texture != NULL ? (1.0f / (poly->texture->ustop - poly->texture->ustart)) : 0.0f);
+ (*d3dintf->effect.set_float)(curr_effect, "HeightRatio", poly->texture != NULL ? (1.0f / (poly->texture->vstop - poly->texture->vstart)) : 0.0f);
(*d3dintf->effect.set_float)(curr_effect, "TargetWidth", (float)d3d->width);
(*d3dintf->effect.set_float)(curr_effect, "TargetHeight", (float)d3d->height);
(*d3dintf->effect.set_float)(curr_effect, "PostPass", 0.0f);
@@ -2450,16 +2450,16 @@ void hlsl_info::end_draw()
// hlsl_info::register_prescaled_texture
//============================================================
-bool hlsl_info::register_prescaled_texture(d3d::texture_info *texture)
+bool hlsl_info::register_prescaled_texture(d3d_texture_info *texture)
{
- return register_texture(texture);
+ return register_texture(texture, texture->rawwidth, texture->rawheight, texture->xprescale, texture->yprescale);
}
//============================================================
// hlsl_info::add_cache_target - register a cache target
//============================================================
-bool hlsl_info::add_cache_target(d3d_info* d3d, d3d::texture_info* info, int width, int height, int xprescale, int yprescale, int screen_index)
+bool hlsl_info::add_cache_target(d3d_info* d3d, d3d_texture_info* info, int width, int height, int xprescale, int yprescale, int screen_index)
{
d3d_cache_target* target = (d3d_cache_target*)global_alloc_clear(d3d_cache_target);
@@ -2471,8 +2471,8 @@ bool hlsl_info::add_cache_target(d3d_info* d3d, d3d::texture_info* info, int wid
if (info != NULL)
{
- target->width = info->get_texinfo()->width;
- target->height = info->get_texinfo()->height;
+ target->width = info->texinfo.width;
+ target->height = info->texinfo.height;
}
else
{
@@ -2524,7 +2524,7 @@ void hlsl_info::create_vector_target(render_primitive *prim)
// hlsl_info::add_render_target - register a render target
//============================================================
-bool hlsl_info::add_render_target(d3d_info* d3d, d3d::texture_info* info, int width, int height, int xprescale, int yprescale, bool bloom)
+bool hlsl_info::add_render_target(d3d_info* d3d, d3d_texture_info* info, int width, int height, int xprescale, int yprescale, bool bloom)
{
UINT32 screen_index = 0;
UINT32 page_index = 0;
@@ -2536,7 +2536,7 @@ bool hlsl_info::add_render_target(d3d_info* d3d, d3d::texture_info* info, int wi
remove_render_target(existing_target);
}
- UINT32 screen_index_data = (UINT32)info->get_texinfo()->osddata;
+ UINT32 screen_index_data = (UINT32)info->texinfo.osddata;
screen_index = screen_index_data >> 1;
page_index = screen_index_data & 1;
}
@@ -2559,8 +2559,8 @@ bool hlsl_info::add_render_target(d3d_info* d3d, d3d::texture_info* info, int wi
if (info != NULL)
{
- target->width = info->get_texinfo()->width;
- target->height = info->get_texinfo()->height;
+ target->width = info->texinfo.width;
+ target->height = info->texinfo.height;
}
else
{
@@ -2611,20 +2611,23 @@ void hlsl_info::enumerate_screens()
//============================================================
-// hlsl_info::register_texture(d3d_texture::info)
+// hlsl_info::register_texture
//============================================================
-bool hlsl_info::register_texture(d3d::texture_info *texture)
+bool hlsl_info::register_texture(d3d_texture_info *texture)
{
- int width = texture->get_width();
- int height = texture->get_height();
- int xscale = texture->get_xscale();
- int yscale = texture->get_yscale();
+ return register_texture(texture, texture->rawwidth, texture->rawheight, 1, 1);
+}
+
+
+//============================================================
+// hlsl_info::register_texture(d3d_texture_info, int, int, int, int)
+//============================================================
+bool hlsl_info::register_texture(d3d_texture_info *texture, int width, int height, int xscale, int yscale)
+{
if (!master_enable || !d3dintf->post_fx_available)
- {
- return false;
- }
+ return 0;
enumerate_screens();
diff --git a/src/osd/windows/d3dhlsl.h b/src/osd/windows/d3dhlsl.h
index 45e8a5e0977..25c6cf77077 100644
--- a/src/osd/windows/d3dhlsl.h
+++ b/src/osd/windows/d3dhlsl.h
@@ -138,10 +138,10 @@ public:
void init_effect_info(d3d_poly_info *poly);
void render_quad(d3d_poly_info *poly, int vertnum);
- bool register_texture(d3d::texture_info *texture);
- bool register_prescaled_texture(d3d::texture_info *texture);
- bool add_render_target(d3d_info* d3d, d3d::texture_info* info, int width, int height, int xprescale, int yprescale, bool bloom = false);
- bool add_cache_target(d3d_info* d3d, d3d::texture_info* info, int width, int height, int xprescale, int yprescale, int screen_index);
+ bool register_texture(d3d_texture_info *texture);
+ bool register_prescaled_texture(d3d_texture_info *texture);
+ bool add_render_target(d3d_info* d3d, d3d_texture_info* info, int width, int height, int xprescale, int yprescale, bool bloom = false);
+ bool add_cache_target(d3d_info* d3d, d3d_texture_info* info, int width, int height, int xprescale, int yprescale, int screen_index);
void window_save();
void window_record();
@@ -152,9 +152,9 @@ public:
void record_texture();
void init_fsfx_quad(void *vertbuf);
- void set_texture(d3d::texture_info *texture);
- d3d_render_target * find_render_target(d3d::texture_info *info);
- void remove_render_target(d3d::texture_info *texture);
+ void set_texture(d3d_texture_info *texture);
+ d3d_render_target * find_render_target(d3d_texture_info *info);
+ void remove_render_target(d3d_texture_info *texture);
void remove_render_target(int width, int height, UINT32 screen_index, UINT32 page_index);
void remove_render_target(d3d_render_target *rt);
@@ -175,7 +175,7 @@ private:
void end_avi_recording();
void begin_avi_recording(const char *name);
- bool register_texture(d3d::texture_info *texture, int width, int height, int xscale, int yscale);
+ bool register_texture(d3d_texture_info *texture, int width, int height, int xscale, int yscale);
d3d_render_target* find_render_target(int width, int height, UINT32 screen_index, UINT32 page_index);
d3d_cache_target * find_cache_target(UINT32 screen_index, int width, int height);
@@ -199,7 +199,7 @@ private:
int prescale_size_y; // prescale size y
int preset; // preset, if relevant
bitmap_argb32 shadow_bitmap; // shadow mask bitmap for post-processing shader
- d3d::texture_info * shadow_texture; // shadow mask texture for post-processing shader
+ d3d_texture_info * shadow_texture; // shadow mask texture for post-processing shader
hlsl_options * options; // current uniform state
D3DPRIMITIVETYPE vecbuf_type;
UINT32 vecbuf_index;
diff --git a/src/osd/windows/drawd3d.c b/src/osd/windows/drawd3d.c
index 0505244af44..7aa426d4867 100644
--- a/src/osd/windows/drawd3d.c
+++ b/src/osd/windows/drawd3d.c
@@ -209,14 +209,14 @@ INLINE UINT32 texture_compute_hash(const render_texinfo *texture, UINT32 flags)
}
-INLINE void set_texture(d3d_info *d3d, d3d::texture_info *texture)
+INLINE void set_texture(d3d_info *d3d, d3d_texture_info *texture)
{
HRESULT result;
if (texture != d3d->last_texture)
{
d3d->last_texture = texture;
- d3d->last_texture_flags = (texture == NULL ? 0 : texture->m_flags);
- result = (*d3dintf->device.set_texture)(d3d->device, 0, (texture == NULL) ? d3d->default_texture->m_d3dfinaltex : texture->m_d3dfinaltex);
+ d3d->last_texture_flags = (texture == NULL ? 0 : texture->flags);
+ result = (*d3dintf->device.set_texture)(d3d->device, 0, (texture == NULL) ? d3d->default_texture->d3dfinaltex : texture->d3dfinaltex);
d3d->hlsl->set_texture(texture);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device set_texture call\n", (int)result);
}
@@ -325,7 +325,7 @@ INLINE void set_blendmode(d3d_info *d3d, int blendmode)
INLINE void reset_render_states(d3d_info *d3d)
{
// this ensures subsequent calls to the above setters will force-update the data
- d3d->last_texture = (d3d::texture_info *)~0;
+ d3d->last_texture = (d3d_texture_info *)~0;
d3d->last_filter = -1;
d3d->last_blendenable = -1;
d3d->last_blendop = -1;
@@ -372,6 +372,13 @@ static void draw_quad(d3d_info *d3d, const render_primitive *prim);
static d3d_vertex *primitive_alloc(d3d_info *d3d, int numverts);
static void primitive_flush_pending(d3d_info *d3d);
+// textures
+static void texture_compute_size(d3d_info *d3d, int texwidth, int texheight, d3d_texture_info *texture);
+static void texture_set_data(d3d_info *d3d, d3d_texture_info *texture, const render_texinfo *texsource, UINT32 flags);
+static void texture_prescale(d3d_info *d3d, d3d_texture_info *texture);
+static d3d_texture_info *texture_find(d3d_info *d3d, const render_primitive *prim);
+static void texture_update(d3d_info *d3d, const render_primitive *prim);
+
//============================================================
// drawd3d_init
//============================================================
@@ -600,21 +607,7 @@ mtlog_add("drawd3d_window_draw: begin");
{
if (prim->texture.base != NULL)
{
- if (prim->texture.osdhandle == NULL)
- {
- // if there isn't one, create a new texture
- prim->texture.osdhandle = (void*)(new d3d::texture_info(d3d, &prim->texture, prim->flags));
- }
- else
- {
- // if there is one, but with a different seqid, copy the data
- d3d::texture_info *texture = (d3d::texture_info *)prim->texture.osdhandle;
- if (texture->get_texinfo()->seqid != prim->texture.seqid)
- {
- texture->set_data(&prim->texture, prim->flags);
- texture->get_texinfo()->seqid = prim->texture.seqid;
- }
- }
+ texture_update(d3d, prim);
}
else if(d3d->hlsl->vector_enabled() && PRIMFLAG_GET_VECTORBUF(prim->flags))
{
@@ -928,7 +921,7 @@ static int device_create_resources(d3d_info *d3d)
texture.seqid = 0;
// now create it
- d3d->default_texture = new d3d::texture_info(d3d, &texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXFORMAT(TEXFORMAT_ARGB32));
+ d3d->default_texture = texture_create(d3d, &texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXFORMAT(TEXFORMAT_ARGB32));
}
// experimental: if we have a vector bitmap, create a texture for it
@@ -945,7 +938,7 @@ static int device_create_resources(d3d_info *d3d)
texture.seqid = 0;
// now create it
- d3d->vector_texture = new d3d::texture_info(d3d, &texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXFORMAT(TEXFORMAT_ARGB32));
+ d3d->vector_texture = texture_create(d3d, &texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXFORMAT(TEXFORMAT_ARGB32));
}
return 0;
@@ -985,9 +978,25 @@ static void device_delete_resources(d3d_info *d3d)
// free all textures
while (d3d->texlist != NULL)
{
- d3d::texture_info *tex = d3d->texlist;
- d3d->texlist = tex->m_next;
- delete tex;
+ d3d_texture_info *tex = d3d->texlist;
+ d3d->texlist = tex->next;
+ if (tex->d3dfinaltex != NULL)
+ {
+ if (tex->d3dtex == tex->d3dfinaltex) tex->d3dtex = NULL;
+ (*d3dintf->texture.release)(tex->d3dfinaltex);
+ tex->d3dfinaltex = NULL;
+ }
+ if (tex->d3dtex != NULL)
+ {
+ (*d3dintf->texture.release)(tex->d3dtex);
+ tex->d3dtex = NULL;
+ }
+ if (tex->d3dsurface != NULL)
+ {
+ (*d3dintf->surface.release)(tex->d3dsurface);
+ tex->d3dsurface = NULL;
+ }
+ global_free(tex);
}
// free the vertex buffer
@@ -1528,31 +1537,31 @@ static void draw_line(d3d_info *d3d, const render_primitive *prim, float line_ti
// if we have a texture to use for the vectors, use it here
if (d3d->vector_texture != NULL)
{
- vertex[0].u0 = d3d->vector_texture->m_ustart;
- vertex[0].v0 = d3d->vector_texture->m_vstart;
+ vertex[0].u0 = d3d->vector_texture->ustart;
+ vertex[0].v0 = d3d->vector_texture->vstart;
- vertex[2].u0 = d3d->vector_texture->m_ustop;
- vertex[2].v0 = d3d->vector_texture->m_vstart;
+ vertex[2].u0 = d3d->vector_texture->ustop;
+ vertex[2].v0 = d3d->vector_texture->vstart;
- vertex[1].u0 = d3d->vector_texture->m_ustart;
- vertex[1].v0 = d3d->vector_texture->m_vstop;
+ vertex[1].u0 = d3d->vector_texture->ustart;
+ vertex[1].v0 = d3d->vector_texture->vstop;
- vertex[3].u0 = d3d->vector_texture->m_ustop;
- vertex[3].v0 = d3d->vector_texture->m_vstop;
+ vertex[3].u0 = d3d->vector_texture->ustop;
+ vertex[3].v0 = d3d->vector_texture->vstop;
}
else if(d3d->default_texture != NULL)
{
- vertex[0].u0 = d3d->default_texture->m_ustart;
- vertex[0].v0 = d3d->default_texture->m_vstart;
+ vertex[0].u0 = d3d->default_texture->ustart;
+ vertex[0].v0 = d3d->default_texture->vstart;
- vertex[2].u0 = d3d->default_texture->m_ustart;
- vertex[2].v0 = d3d->default_texture->m_vstart;
+ vertex[2].u0 = d3d->default_texture->ustart;
+ vertex[2].v0 = d3d->default_texture->vstart;
- vertex[1].u0 = d3d->default_texture->m_ustart;
- vertex[1].v0 = d3d->default_texture->m_vstart;
+ vertex[1].u0 = d3d->default_texture->ustart;
+ vertex[1].v0 = d3d->default_texture->vstart;
- vertex[3].u0 = d3d->default_texture->m_ustart;
- vertex[3].v0 = d3d->default_texture->m_vstart;
+ vertex[3].u0 = d3d->default_texture->ustart;
+ vertex[3].v0 = d3d->default_texture->vstart;
}
// set the color, Z parameters to standard values
@@ -1598,15 +1607,17 @@ static void draw_line(d3d_info *d3d, const render_primitive *prim, float line_ti
static void draw_quad(d3d_info *d3d, const render_primitive *prim)
{
- d3d::texture_info *texture = (d3d::texture_info *)prim->texture.osdhandle;
+ d3d_texture_info *texture = texture_find(d3d, prim);
+ DWORD color, modmode;
+ d3d_vertex *vertex;
+ INT32 r, g, b, a;
+ d3d_poly_info *poly;
+ int i;
- if (texture == NULL)
- {
- texture = d3d->default_texture;
- }
+ texture = texture != NULL ? texture : d3d->default_texture;
// get a pointer to the vertex buffer
- d3d_vertex *vertex = primitive_alloc(d3d, 4);
+ vertex = primitive_alloc(d3d, 4);
if (vertex == NULL)
return;
@@ -1623,24 +1634,24 @@ static void draw_quad(d3d_info *d3d, const render_primitive *prim)
// set the texture coordinates
if(texture != NULL)
{
- float du = texture->m_ustop - texture->m_ustart;
- float dv = texture->m_vstop - texture->m_vstart;
- vertex[0].u0 = texture->m_ustart + du * prim->texcoords.tl.u;
- vertex[0].v0 = texture->m_vstart + dv * prim->texcoords.tl.v;
- vertex[1].u0 = texture->m_ustart + du * prim->texcoords.tr.u;
- vertex[1].v0 = texture->m_vstart + dv * prim->texcoords.tr.v;
- vertex[2].u0 = texture->m_ustart + du * prim->texcoords.bl.u;
- vertex[2].v0 = texture->m_vstart + dv * prim->texcoords.bl.v;
- vertex[3].u0 = texture->m_ustart + du * prim->texcoords.br.u;
- vertex[3].v0 = texture->m_vstart + dv * prim->texcoords.br.v;
+ float du = texture->ustop - texture->ustart;
+ float dv = texture->vstop - texture->vstart;
+ vertex[0].u0 = texture->ustart + du * prim->texcoords.tl.u;
+ vertex[0].v0 = texture->vstart + dv * prim->texcoords.tl.v;
+ vertex[1].u0 = texture->ustart + du * prim->texcoords.tr.u;
+ vertex[1].v0 = texture->vstart + dv * prim->texcoords.tr.v;
+ vertex[2].u0 = texture->ustart + du * prim->texcoords.bl.u;
+ vertex[2].v0 = texture->vstart + dv * prim->texcoords.bl.v;
+ vertex[3].u0 = texture->ustart + du * prim->texcoords.br.u;
+ vertex[3].v0 = texture->vstart + dv * prim->texcoords.br.v;
}
// determine the color, allowing for over modulation
- INT32 r = (INT32)(prim->color.r * 255.0f);
- INT32 g = (INT32)(prim->color.g * 255.0f);
- INT32 b = (INT32)(prim->color.b * 255.0f);
- INT32 a = (INT32)(prim->color.a * 255.0f);
- DWORD modmode = D3DTOP_MODULATE;
+ r = (INT32)(prim->color.r * 255.0f);
+ g = (INT32)(prim->color.g * 255.0f);
+ b = (INT32)(prim->color.b * 255.0f);
+ a = (INT32)(prim->color.a * 255.0f);
+ modmode = D3DTOP_MODULATE;
if (texture != NULL)
{
if (d3d->mod2x_supported && (r > 255 || g > 255 || b > 255))
@@ -1661,10 +1672,10 @@ static void draw_quad(d3d_info *d3d, const render_primitive *prim)
if (g > 255) g = 255;
if (b > 255) b = 255;
if (a > 255) a = 255;
- DWORD color = D3DCOLOR_ARGB(a, r, g, b);
+ color = D3DCOLOR_ARGB(a, r, g, b);
// set the color, Z parameters to standard values
- for (int i = 0; i < 4; i++)
+ for (i = 0; i < 4; i++)
{
vertex[i].z = 0.0f;
vertex[i].rhw = 1.0f;
@@ -1672,7 +1683,7 @@ static void draw_quad(d3d_info *d3d, const render_primitive *prim)
}
// now add a polygon entry
- d3d_poly_info *poly = &d3d->poly[d3d->numpolys++];
+ poly = &d3d->poly[d3d->numpolys++];
poly->type = D3DPT_TRIANGLESTRIP;
poly->count = 2;
poly->numverts = 4;
@@ -1807,65 +1818,42 @@ static void primitive_flush_pending(d3d_info *d3d)
d3d->numpolys = 0;
}
-//============================================================
-// texture_info destructor
-//============================================================
-d3d::texture_info::~texture_info()
+void texture_destroy(d3d_info *d3d, d3d_texture_info *info)
{
- if (m_d3dfinaltex != NULL)
- {
- if (m_d3dtex == m_d3dfinaltex)
- {
- m_d3dtex = NULL;
- }
- (*d3dintf->texture.release)(m_d3dfinaltex);
- m_d3dfinaltex = NULL;
- }
- if (m_d3dtex != NULL)
- {
- (*d3dintf->texture.release)(m_d3dtex);
- m_d3dtex = NULL;
- }
- if (m_d3dsurface != NULL)
- {
- (*d3dintf->surface.release)(m_d3dsurface);
- m_d3dsurface = NULL;
- }
}
//============================================================
-// texture_info constructor
+// texture_create
//============================================================
-d3d::texture_info::texture_info(d3d_info *d3d, render_texinfo* texsource, UINT32 flags)
+d3d_texture_info *texture_create(d3d_info *d3d, const render_texinfo *texsource, UINT32 flags)
{
+ d3d_texture_info *texture;
HRESULT result;
- // fill in the core data
- m_d3d = d3d;
- m_hash = texture_compute_hash(texsource, flags);
- m_flags = flags;
- m_texinfo = texsource;
- m_xprescale = video_config.prescale;
- m_yprescale = video_config.prescale;
+ // allocate a new texture
+ texture = global_alloc_clear(d3d_texture_info);
- m_d3dtex = NULL;
- m_d3dsurface = NULL;
- m_d3dfinaltex = NULL;
+ // fill in the core data
+ texture->hash = texture_compute_hash(texsource, flags);
+ texture->flags = flags;
+ texture->texinfo = *texsource;
+ texture->xprescale = video_config.prescale;
+ texture->yprescale = video_config.prescale;
// compute the size
- compute_size(texsource->width, texsource->height);
+ texture_compute_size(d3d, texsource->width, texsource->height, texture);
// non-screen textures are easy
if (!PRIMFLAG_GET_SCREENTEX(flags))
{
assert(PRIMFLAG_TEXFORMAT(flags) != TEXFORMAT_YUY16);
- result = (*d3dintf->device.create_texture)(d3d->device, m_rawwidth, m_rawheight, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &m_d3dtex);
+ result = (*d3dintf->device.create_texture)(d3d->device, texture->rawwidth, texture->rawheight, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture->d3dtex);
if (result != D3D_OK)
goto error;
- m_d3dfinaltex = m_d3dtex;
- m_type = TEXTURE_TYPE_PLAIN;
+ texture->d3dfinaltex = texture->d3dtex;
+ texture->type = TEXTURE_TYPE_PLAIN;
}
// screen textures are allocated differently
@@ -1875,62 +1863,45 @@ d3d::texture_info::texture_info(d3d_info *d3d, render_texinfo* texsource, UINT32
DWORD usage = d3d->dynamic_supported ? D3DUSAGE_DYNAMIC : 0;
D3DPOOL pool = d3d->dynamic_supported ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED;
int maxdim = MAX(d3d->presentation.BackBufferWidth, d3d->presentation.BackBufferHeight);
+ int attempt;
// pick the format
if (PRIMFLAG_GET_TEXFORMAT(flags) == TEXFORMAT_YUY16)
- {
format = d3d->yuv_format;
- }
else if (PRIMFLAG_GET_TEXFORMAT(flags) == TEXFORMAT_ARGB32 || PRIMFLAG_GET_TEXFORMAT(flags) == TEXFORMAT_PALETTEA16)
- {
format = D3DFMT_A8R8G8B8;
- }
else
- {
format = d3d->screen_format;
- }
// don't prescale above screen size
- while (m_xprescale > 1 && m_rawwidth * m_xprescale >= 2 * maxdim)
- {
- m_xprescale--;
- }
- while (m_xprescale > 1 && m_rawwidth * m_xprescale > d3d->texture_max_width)
- {
- m_xprescale--;
- }
- while (m_yprescale > 1 && m_rawheight * m_yprescale >= 2 * maxdim)
- {
- m_yprescale--;
- }
- while (m_yprescale > 1 && m_rawheight * m_yprescale > d3d->texture_max_height)
- {
- m_yprescale--;
- }
- if (m_xprescale != video_config.prescale || m_yprescale != video_config.prescale)
- {
- mame_printf_verbose("Direct3D: adjusting prescale from %dx%d to %dx%d\n", video_config.prescale, video_config.prescale, m_xprescale, m_yprescale);
- }
+ while (texture->xprescale > 1 && texture->rawwidth * texture->xprescale >= 2 * maxdim)
+ texture->xprescale--;
+ while (texture->xprescale > 1 && texture->rawwidth * texture->xprescale > d3d->texture_max_width)
+ texture->xprescale--;
+ while (texture->yprescale > 1 && texture->rawheight * texture->yprescale >= 2 * maxdim)
+ texture->yprescale--;
+ while (texture->yprescale > 1 && texture->rawheight * texture->yprescale > d3d->texture_max_height)
+ texture->yprescale--;
+ if (texture->xprescale != video_config.prescale || texture->yprescale != video_config.prescale)
+ mame_printf_verbose("Direct3D: adjusting prescale from %dx%d to %dx%d\n", video_config.prescale, video_config.prescale, texture->xprescale, texture->yprescale);
// loop until we allocate something or error
- for (int attempt = 0; attempt < 2; attempt++)
+ for (attempt = 0; attempt < 2; attempt++)
{
// second attempt is always 1:1
if (attempt == 1)
- {
- m_xprescale = m_yprescale = 1;
- }
+ texture->xprescale = texture->yprescale = 1;
// screen textures with no prescaling are pretty easy
- if (m_xprescale == 1 && m_yprescale == 1)
+ if (texture->xprescale == 1 && texture->yprescale == 1)
{
- result = (*d3dintf->device.create_texture)(d3d->device, m_rawwidth, m_rawheight, 1, usage, format, pool, &m_d3dtex);
+ result = (*d3dintf->device.create_texture)(d3d->device, texture->rawwidth, texture->rawheight, 1, usage, format, pool, &texture->d3dtex);
if (result == D3D_OK)
{
- m_d3dfinaltex = m_d3dtex;
- m_type = d3d->dynamic_supported ? TEXTURE_TYPE_DYNAMIC : TEXTURE_TYPE_PLAIN;
+ texture->d3dfinaltex = texture->d3dtex;
+ texture->type = d3d->dynamic_supported ? TEXTURE_TYPE_DYNAMIC : TEXTURE_TYPE_PLAIN;
- if (d3d->hlsl->enabled() && !d3d->hlsl->register_texture(this))
+ if (d3d->hlsl->enabled() && !d3d->hlsl->register_texture(texture))
{
goto error;
}
@@ -1942,98 +1913,98 @@ d3d::texture_info::texture_info(d3d_info *d3d, render_texinfo* texsource, UINT32
// screen textures with prescaling require two allocations
else
{
+ int scwidth, scheight;
+ D3DFORMAT finalfmt;
+
// use an offscreen plain surface for stretching if supported
// (won't work for YUY textures)
if (d3d->stretch_supported && PRIMFLAG_GET_TEXFORMAT(flags) != TEXFORMAT_YUY16)
{
- result = (*d3dintf->device.create_offscreen_plain_surface)(d3d->device, m_rawwidth, m_rawheight, format, D3DPOOL_DEFAULT, &m_d3dsurface);
+ result = (*d3dintf->device.create_offscreen_plain_surface)(d3d->device, texture->rawwidth, texture->rawheight, format, D3DPOOL_DEFAULT, &texture->d3dsurface);
if (result != D3D_OK)
- {
continue;
- }
- m_type = TEXTURE_TYPE_SURFACE;
+ texture->type = TEXTURE_TYPE_SURFACE;
}
// otherwise, we allocate a dynamic texture for the source
else
{
- result = (*d3dintf->device.create_texture)(d3d->device, m_rawwidth, m_rawheight, 1, usage, format, pool, &m_d3dtex);
+ result = (*d3dintf->device.create_texture)(d3d->device, texture->rawwidth, texture->rawheight, 1, usage, format, pool, &texture->d3dtex);
if (result != D3D_OK)
- {
continue;
- }
- m_type = d3d->dynamic_supported ? TEXTURE_TYPE_DYNAMIC : TEXTURE_TYPE_PLAIN;
+ texture->type = d3d->dynamic_supported ? TEXTURE_TYPE_DYNAMIC : TEXTURE_TYPE_PLAIN;
}
// for the target surface, we allocate a render target texture
- int scwidth = m_rawwidth * m_xprescale;
- int scheight = m_rawheight * m_yprescale;
+ scwidth = texture->rawwidth * texture->xprescale;
+ scheight = texture->rawheight * texture->yprescale;
// target surfaces typically cannot be YCbCr, so we always pick RGB in that case
- D3DFORMAT finalfmt = (format != d3d->yuv_format) ? format : D3DFMT_A8R8G8B8;
- result = (*d3dintf->device.create_texture)(d3d->device, scwidth, scheight, 1, D3DUSAGE_RENDERTARGET, finalfmt, D3DPOOL_DEFAULT, &m_d3dfinaltex);
+ finalfmt = (format != d3d->yuv_format) ? format : D3DFMT_A8R8G8B8;
+ result = (*d3dintf->device.create_texture)(d3d->device, scwidth, scheight, 1, D3DUSAGE_RENDERTARGET, finalfmt, D3DPOOL_DEFAULT, &texture->d3dfinaltex);
if (result == D3D_OK)
{
- if (d3d->hlsl->enabled() && !d3d->hlsl->register_prescaled_texture(this))
+ if (d3d->hlsl->enabled() && !d3d->hlsl->register_prescaled_texture(texture))
{
goto error;
}
break;
}
- (*d3dintf->texture.release)(m_d3dtex);
- m_d3dtex = NULL;
+ (*d3dintf->texture.release)(texture->d3dtex);
+ texture->d3dtex = NULL;
}
}
}
// copy the data to the texture
- set_data(texsource, flags);
+ texture_set_data(d3d, texture, texsource, flags);
- texsource->osdhandle = (void*)this;
// add us to the texture list
if(d3d->texlist != NULL)
- d3d->texlist->m_prev = this;
- m_prev = NULL;
- m_next = d3d->texlist;
- d3d->texlist = this;
- return;
+ d3d->texlist->prev = texture;
+ texture->prev = NULL;
+ texture->next = d3d->texlist;
+ d3d->texlist = texture;
+ return texture;
error:
d3dintf->post_fx_available = false;
printf("Direct3D: Critical warning: A texture failed to allocate. Expect things to get bad quickly.\n");
- if (m_d3dsurface != NULL)
- (*d3dintf->surface.release)(m_d3dsurface);
- if (m_d3dtex != NULL)
- (*d3dintf->texture.release)(m_d3dtex);
+ if (texture->d3dsurface != NULL)
+ (*d3dintf->surface.release)(texture->d3dsurface);
+ if (texture->d3dtex != NULL)
+ (*d3dintf->texture.release)(texture->d3dtex);
+ global_free(texture);
+ return NULL;
}
//============================================================
-// texture_info::compute_size
+// texture_compute_size
//============================================================
-void d3d::texture_info::compute_size(int texwidth, int texheight)
+static void texture_compute_size(d3d_info *d3d, int texwidth, int texheight, d3d_texture_info *texture)
{
int finalheight = texheight;
int finalwidth = texwidth;
// if we're not wrapping, add a 1-2 pixel border on all sides
- m_xborderpix = 0;
- m_yborderpix = 0;
- if (ENABLE_BORDER_PIX && !(m_flags & PRIMFLAG_TEXWRAP_MASK))
+ texture->xborderpix = 0;
+ texture->yborderpix = 0;
+ if (ENABLE_BORDER_PIX && !(texture->flags & PRIMFLAG_TEXWRAP_MASK))
{
// note we need 2 pixels in X for YUY textures
- m_xborderpix = (PRIMFLAG_GET_TEXFORMAT(m_flags) == TEXFORMAT_YUY16) ? 2 : 1;
- m_yborderpix = 1;
+ texture->xborderpix = (PRIMFLAG_GET_TEXFORMAT(texture->flags) == TEXFORMAT_YUY16) ? 2 : 1;
+ texture->yborderpix = 1;
}
// compute final texture size
- finalwidth += 2 * m_xborderpix;
- finalheight += 2 * m_yborderpix;
+ finalwidth += 2 * texture->xborderpix;
+ finalheight += 2 * texture->yborderpix;
// round width/height up to nearest power of 2 if we need to
- if (!(m_d3d->texture_caps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL))
+ if (!(d3d->texture_caps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL))
{
// first the width
if (finalwidth & (finalwidth - 1))
@@ -2057,7 +2028,7 @@ void d3d::texture_info::compute_size(int texwidth, int texheight)
}
// round up to square if we need to
- if (m_d3d->texture_caps & D3DPTEXTURECAPS_SQUAREONLY)
+ if (d3d->texture_caps & D3DPTEXTURECAPS_SQUAREONLY)
{
if (finalwidth < finalheight)
finalwidth = finalheight;
@@ -2066,42 +2037,38 @@ void d3d::texture_info::compute_size(int texwidth, int texheight)
}
// adjust the aspect ratio if we need to
- while (finalwidth < finalheight && finalheight / finalwidth > m_d3d->texture_max_aspect)
- {
+ while (finalwidth < finalheight && finalheight / finalwidth > d3d->texture_max_aspect)
finalwidth *= 2;
- }
- while (finalheight < finalwidth && finalwidth / finalheight > m_d3d->texture_max_aspect)
- {
+ while (finalheight < finalwidth && finalwidth / finalheight > d3d->texture_max_aspect)
finalheight *= 2;
- }
// if we added pixels for the border, and that just barely pushed us over, take it back
- if ((finalwidth > m_d3d->texture_max_width && finalwidth - 2 * m_xborderpix <= m_d3d->texture_max_width) ||
- (finalheight > m_d3d->texture_max_height && finalheight - 2 * m_yborderpix <= m_d3d->texture_max_height))
+ if ((finalwidth > d3d->texture_max_width && finalwidth - 2 * texture->xborderpix <= d3d->texture_max_width) ||
+ (finalheight > d3d->texture_max_height && finalheight - 2 * texture->yborderpix <= d3d->texture_max_height))
{
- finalwidth -= 2 * m_xborderpix;
- finalheight -= 2 * m_yborderpix;
- m_xborderpix = 0;
- m_yborderpix = 0;
+ finalwidth -= 2 * texture->xborderpix;
+ finalheight -= 2 * texture->yborderpix;
+ texture->xborderpix = 0;
+ texture->yborderpix = 0;
}
// if we're above the max width/height, do what?
- if (finalwidth > m_d3d->texture_max_width || finalheight > m_d3d->texture_max_height)
+ if (finalwidth > d3d->texture_max_width || finalheight > d3d->texture_max_height)
{
static int printed = FALSE;
- if (!printed) mame_printf_warning("Texture too big! (wanted: %dx%d, max is %dx%d)\n", finalwidth, finalheight, (int)m_d3d->texture_max_width, (int)m_d3d->texture_max_height);
+ if (!printed) mame_printf_warning("Texture too big! (wanted: %dx%d, max is %dx%d)\n", finalwidth, finalheight, (int)d3d->texture_max_width, (int)d3d->texture_max_height);
printed = TRUE;
}
// compute the U/V scale factors
- m_ustart = (float)m_xborderpix / (float)finalwidth;
- m_ustop = (float)(texwidth + m_xborderpix) / (float)finalwidth;
- m_vstart = (float)m_yborderpix / (float)finalheight;
- m_vstop = (float)(texheight + m_yborderpix) / (float)finalheight;
+ texture->ustart = (float)texture->xborderpix / (float)finalwidth;
+ texture->ustop = (float)(texwidth + texture->xborderpix) / (float)finalwidth;
+ texture->vstart = (float)texture->yborderpix / (float)finalheight;
+ texture->vstop = (float)(texheight + texture->yborderpix) / (float)finalheight;
// set the final values
- m_rawwidth = finalwidth;
- m_rawheight = finalheight;
+ texture->rawwidth = finalwidth;
+ texture->rawheight = finalheight;
}
@@ -2444,58 +2411,58 @@ INLINE void copyline_yuy16_to_argb(UINT32 *dst, const UINT16 *src, int width, co
// texture_set_data
//============================================================
-void d3d::texture_info::set_data(const render_texinfo *texsource, UINT32 flags)
+static void texture_set_data(d3d_info *d3d, d3d_texture_info *texture, const render_texinfo *texsource, UINT32 flags)
{
D3DLOCKED_RECT rect;
HRESULT result;
+ int miny, maxy;
+ int dsty;
// lock the texture
- switch (m_type)
+ switch (texture->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)(texture->d3dtex, 0, &rect, NULL, 0); break;
+ case TEXTURE_TYPE_DYNAMIC: result = (*d3dintf->texture.lock_rect)(texture->d3dtex, 0, &rect, NULL, D3DLOCK_DISCARD); break;
+ case TEXTURE_TYPE_SURFACE: result = (*d3dintf->surface.lock_rect)(texture->d3dsurface, &rect, NULL, D3DLOCK_DISCARD); break;
}
if (result != D3D_OK)
- {
return;
- }
// loop over Y
- int miny = 0 - m_yborderpix;
- int maxy = texsource->height + m_yborderpix;
- for (int dsty = miny; dsty < maxy; dsty++)
+ miny = 0 - texture->yborderpix;
+ maxy = texsource->height + texture->yborderpix;
+ for (dsty = miny; dsty < maxy; dsty++)
{
int srcy = (dsty < 0) ? 0 : (dsty >= texsource->height) ? texsource->height - 1 : dsty;
- void *dst = (BYTE *)rect.pBits + (dsty + m_yborderpix) * rect.Pitch;
+ void *dst = (BYTE *)rect.pBits + (dsty + texture->yborderpix) * rect.Pitch;
// switch off of the format and
switch (PRIMFLAG_GET_TEXFORMAT(flags))
{
case TEXFORMAT_PALETTE16:
- copyline_palette16((UINT32 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, m_xborderpix);
+ copyline_palette16((UINT32 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, texture->xborderpix);
break;
case TEXFORMAT_PALETTEA16:
- copyline_palettea16((UINT32 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, m_xborderpix);
+ copyline_palettea16((UINT32 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, texture->xborderpix);
break;
case TEXFORMAT_RGB32:
- copyline_rgb32((UINT32 *)dst, (UINT32 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, m_xborderpix);
+ copyline_rgb32((UINT32 *)dst, (UINT32 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, texture->xborderpix);
break;
case TEXFORMAT_ARGB32:
- copyline_argb32((UINT32 *)dst, (UINT32 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, m_xborderpix);
+ copyline_argb32((UINT32 *)dst, (UINT32 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, texture->xborderpix);
break;
case TEXFORMAT_YUY16:
- if (m_d3d->yuv_format == D3DFMT_YUY2)
- copyline_yuy16_to_yuy2((UINT16 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, m_xborderpix);
- else if (m_d3d->yuv_format == D3DFMT_UYVY)
- copyline_yuy16_to_uyvy((UINT16 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, m_xborderpix);
+ if (d3d->yuv_format == D3DFMT_YUY2)
+ copyline_yuy16_to_yuy2((UINT16 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, texture->xborderpix);
+ else if (d3d->yuv_format == D3DFMT_UYVY)
+ copyline_yuy16_to_uyvy((UINT16 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, texture->xborderpix);
else
- copyline_yuy16_to_argb((UINT32 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, m_xborderpix);
+ copyline_yuy16_to_argb((UINT32 *)dst, (UINT16 *)texsource->base + srcy * texsource->rowpixels, texsource->width, texsource->palette, texture->xborderpix);
break;
default:
@@ -2505,61 +2472,58 @@ void d3d::texture_info::set_data(const render_texinfo *texsource, UINT32 flags)
}
// unlock
- switch (m_type)
+ switch (texture->type)
{
default:
- case TEXTURE_TYPE_PLAIN: result = (*d3dintf->texture.unlock_rect)(m_d3dtex, 0); break;
- case TEXTURE_TYPE_DYNAMIC: result = (*d3dintf->texture.unlock_rect)(m_d3dtex, 0); break;
- case TEXTURE_TYPE_SURFACE: result = (*d3dintf->surface.unlock_rect)(m_d3dsurface); break;
- }
- if (result != D3D_OK)
- {
- mame_printf_verbose("Direct3D: Error %08X during texture unlock_rect call\n", (int)result);
+ case TEXTURE_TYPE_PLAIN: result = (*d3dintf->texture.unlock_rect)(texture->d3dtex, 0); break;
+ case TEXTURE_TYPE_DYNAMIC: result = (*d3dintf->texture.unlock_rect)(texture->d3dtex, 0); break;
+ case TEXTURE_TYPE_SURFACE: result = (*d3dintf->surface.unlock_rect)(texture->d3dsurface); break;
}
+ if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during texture unlock_rect call\n", (int)result);
// prescale
- prescale();
+ texture_prescale(d3d, texture);
}
//============================================================
-// texture_info::prescale
+// texture_prescale
//============================================================
-void d3d::texture_info::prescale()
+static void texture_prescale(d3d_info *d3d, d3d_texture_info *texture)
{
d3d_surface *surface;
HRESULT result;
int i;
// if we don't need to, just skip it
- if (m_d3dtex == m_d3dfinaltex)
+ if (texture->d3dtex == texture->d3dfinaltex)
return;
// for all cases, we need to get the surface of the render target
- result = (*d3dintf->texture.get_surface_level)(m_d3dfinaltex, 0, &surface);
+ result = (*d3dintf->texture.get_surface_level)(texture->d3dfinaltex, 0, &surface);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during texture get_surface_level call\n", (int)result);
// if we have an offscreen plain surface, we can just StretchRect to it
- if (m_type == TEXTURE_TYPE_SURFACE)
+ if (texture->type == TEXTURE_TYPE_SURFACE)
{
- assert(m_d3dsurface != NULL);
+ RECT source, dest;
+
+ assert(texture->d3dsurface != NULL);
// set the source bounds
- RECT source;
source.left = source.top = 0;
- source.right = m_texinfo->width + 2 * m_xborderpix;
- source.bottom = m_texinfo->height + 2 * m_yborderpix;
+ source.right = texture->texinfo.width + 2 * texture->xborderpix;
+ source.bottom = texture->texinfo.height + 2 * texture->yborderpix;
// set the target bounds
- RECT dest;
dest = source;
- dest.right *= m_xprescale;
- dest.bottom *= m_yprescale;
+ dest.right *= texture->xprescale;
+ dest.bottom *= texture->yprescale;
// do the stretchrect
- result = (*d3dintf->device.stretch_rect)(m_d3d->device, m_d3dsurface, &source, surface, &dest, D3DTEXF_POINT);
+ result = (*d3dintf->device.stretch_rect)(d3d->device, texture->d3dsurface, &source, surface, &dest, D3DTEXF_POINT);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device stretct_rect call\n", (int)result);
}
@@ -2568,77 +2532,77 @@ void d3d::texture_info::prescale()
{
d3d_surface *backbuffer;
- assert(m_d3dtex != NULL);
+ assert(texture->d3dtex != NULL);
// first remember the original render target and set the new one
- result = (*d3dintf->device.get_render_target)(m_d3d->device, 0, &backbuffer);
+ result = (*d3dintf->device.get_render_target)(d3d->device, 0, &backbuffer);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device get_render_target call\n", (int)result);
- result = (*d3dintf->device.set_render_target)(m_d3d->device, 0, surface);
+ result = (*d3dintf->device.set_render_target)(d3d->device, 0, surface);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device set_render_target call 1\n", (int)result);
- reset_render_states(m_d3d);
+ reset_render_states(d3d);
// start the scene
- result = (*d3dintf->device.begin_scene)(m_d3d->device);
+ result = (*d3dintf->device.begin_scene)(d3d->device);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device begin_scene call\n", (int)result);
// configure the rendering pipeline
- set_filter(m_d3d, FALSE);
- set_blendmode(m_d3d, BLENDMODE_NONE);
- result = (*d3dintf->device.set_texture)(m_d3d->device, 0, m_d3dtex);
+ set_filter(d3d, FALSE);
+ set_blendmode(d3d, BLENDMODE_NONE);
+ result = (*d3dintf->device.set_texture)(d3d->device, 0, texture->d3dtex);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device set_texture call\n", (int)result);
// lock the vertex buffer
- result = (*d3dintf->vertexbuf.lock)(m_d3d->vertexbuf, 0, 0, (VOID **)&m_d3d->lockedbuf, D3DLOCK_DISCARD);
+ result = (*d3dintf->vertexbuf.lock)(d3d->vertexbuf, 0, 0, (VOID **)&d3d->lockedbuf, D3DLOCK_DISCARD);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during vertex buffer lock call\n", (int)result);
// configure the X/Y coordinates on the target surface
- m_d3d->lockedbuf[0].x = -0.5f;
- m_d3d->lockedbuf[0].y = -0.5f;
- m_d3d->lockedbuf[1].x = (float)((m_texinfo->width + 2 * m_xborderpix) * m_xprescale) - 0.5f;
- m_d3d->lockedbuf[1].y = -0.5f;
- m_d3d->lockedbuf[2].x = -0.5f;
- m_d3d->lockedbuf[2].y = (float)((m_texinfo->height + 2 * m_yborderpix) * m_yprescale) - 0.5f;
- m_d3d->lockedbuf[3].x = (float)((m_texinfo->width + 2 * m_xborderpix) * m_xprescale) - 0.5f;
- m_d3d->lockedbuf[3].y = (float)((m_texinfo->height + 2 * m_yborderpix) * m_yprescale) - 0.5f;
+ d3d->lockedbuf[0].x = -0.5f;
+ d3d->lockedbuf[0].y = -0.5f;
+ d3d->lockedbuf[1].x = (float)((texture->texinfo.width + 2 * texture->xborderpix) * texture->xprescale) - 0.5f;
+ d3d->lockedbuf[1].y = -0.5f;
+ d3d->lockedbuf[2].x = -0.5f;
+ d3d->lockedbuf[2].y = (float)((texture->texinfo.height + 2 * texture->yborderpix) * texture->yprescale) - 0.5f;
+ d3d->lockedbuf[3].x = (float)((texture->texinfo.width + 2 * texture->xborderpix) * texture->xprescale) - 0.5f;
+ d3d->lockedbuf[3].y = (float)((texture->texinfo.height + 2 * texture->yborderpix) * texture->yprescale) - 0.5f;
// configure the U/V coordintes on the source texture
- m_d3d->lockedbuf[0].u0 = 0.0f;
- m_d3d->lockedbuf[0].v0 = 0.0f;
- m_d3d->lockedbuf[1].u0 = (float)(m_texinfo->width + 2 * m_xborderpix) / (float)m_rawwidth;
- m_d3d->lockedbuf[1].v0 = 0.0f;
- m_d3d->lockedbuf[2].u0 = 0.0f;
- m_d3d->lockedbuf[2].v0 = (float)(m_texinfo->height + 2 * m_yborderpix) / (float)m_rawheight;
- m_d3d->lockedbuf[3].u0 = (float)(m_texinfo->width + 2 * m_xborderpix) / (float)m_rawwidth;
- m_d3d->lockedbuf[3].v0 = (float)(m_texinfo->height + 2 * m_yborderpix) / (float)m_rawheight;
+ d3d->lockedbuf[0].u0 = 0.0f;
+ d3d->lockedbuf[0].v0 = 0.0f;
+ d3d->lockedbuf[1].u0 = (float)(texture->texinfo.width + 2 * texture->xborderpix) / (float)texture->rawwidth;
+ d3d->lockedbuf[1].v0 = 0.0f;
+ d3d->lockedbuf[2].u0 = 0.0f;
+ d3d->lockedbuf[2].v0 = (float)(texture->texinfo.height + 2 * texture->yborderpix) / (float)texture->rawheight;
+ d3d->lockedbuf[3].u0 = (float)(texture->texinfo.width + 2 * texture->xborderpix) / (float)texture->rawwidth;
+ d3d->lockedbuf[3].v0 = (float)(texture->texinfo.height + 2 * texture->yborderpix) / (float)texture->rawheight;
// reset the remaining vertex parameters
for (i = 0; i < 4; i++)
{
- m_d3d->lockedbuf[i].z = 0.0f;
- m_d3d->lockedbuf[i].rhw = 1.0f;
- m_d3d->lockedbuf[i].color = D3DCOLOR_ARGB(0xff,0xff,0xff,0xff);
+ d3d->lockedbuf[i].z = 0.0f;
+ d3d->lockedbuf[i].rhw = 1.0f;
+ d3d->lockedbuf[i].color = D3DCOLOR_ARGB(0xff,0xff,0xff,0xff);
}
// unlock the vertex buffer
- result = (*d3dintf->vertexbuf.unlock)(m_d3d->vertexbuf);
+ result = (*d3dintf->vertexbuf.unlock)(d3d->vertexbuf);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during vertex buffer unlock call\n", (int)result);
- m_d3d->lockedbuf = NULL;
+ d3d->lockedbuf = NULL;
// set the stream and draw the triangle strip
- result = (*d3dintf->device.set_stream_source)(m_d3d->device, 0, m_d3d->vertexbuf, sizeof(d3d_vertex));
+ result = (*d3dintf->device.set_stream_source)(d3d->device, 0, d3d->vertexbuf, sizeof(d3d_vertex));
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device set_stream_source call\n", (int)result);
- result = (*d3dintf->device.draw_primitive)(m_d3d->device, D3DPT_TRIANGLESTRIP, 0, 2);
+ result = (*d3dintf->device.draw_primitive)(d3d->device, D3DPT_TRIANGLESTRIP, 0, 2);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device draw_primitive call\n", (int)result);
// end the scene
- result = (*d3dintf->device.end_scene)(m_d3d->device);
+ result = (*d3dintf->device.end_scene)(d3d->device);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device end_scene call\n", (int)result);
// reset the render target and release our reference to the backbuffer
- result = (*d3dintf->device.set_render_target)(m_d3d->device, 0, backbuffer);
+ result = (*d3dintf->device.set_render_target)(d3d->device, 0, backbuffer);
if (result != D3D_OK) mame_printf_verbose("Direct3D: Error %08X during device set_render_target call 2\n", (int)result);
(*d3dintf->surface.release)(backbuffer);
- reset_render_states(m_d3d);
+ reset_render_states(d3d);
}
// release our reference to the target surface
@@ -2646,6 +2610,108 @@ void d3d::texture_info::prescale()
}
+
+//============================================================
+// texture_find
+//============================================================
+
+static d3d_texture_info *texture_find(d3d_info *d3d, const render_primitive *prim)
+{
+ UINT32 texhash = texture_compute_hash(&prim->texture, prim->flags);
+ d3d_texture_info *texture;
+
+ // find a match
+ for (texture = d3d->texlist; texture != NULL; texture = texture->next)
+ {
+ UINT32 test_screen = (UINT32)texture->texinfo.osddata >> 1;
+ UINT32 test_page = (UINT32)texture->texinfo.osddata & 1;
+ UINT32 prim_screen = (UINT32)prim->texture.osddata >> 1;
+ UINT32 prim_page = (UINT32)prim->texture.osddata & 1;
+ if (test_screen != prim_screen || test_page != prim_page)
+ {
+ continue;
+ }
+
+ if (texture->hash == texhash &&
+ texture->texinfo.base == prim->texture.base &&
+ texture->texinfo.width == prim->texture.width &&
+ texture->texinfo.height == prim->texture.height &&
+ ((texture->flags ^ prim->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 (d3d->hlsl->enabled() && prim->texture.width != 0 && prim->texture.height != 0 && (prim->flags & PRIMFLAG_SCREENTEX_MASK) != 0)
+ {
+ if (d3d->hlsl->find_render_target(texture) != NULL)
+ {
+ return texture;
+ }
+ }
+ else
+ {
+ return texture;
+ }
+ }
+ }
+
+ // nothing found, check if we need to unregister something with hlsl
+ if (d3d->hlsl->enabled())
+ {
+ if (prim->texture.width == 0 || prim->texture.height == 0)
+ {
+ return NULL;
+ }
+
+ UINT32 prim_screen = (UINT32)prim->texture.osddata >> 1;
+ UINT32 prim_page = (UINT32)prim->texture.osddata & 1;
+
+ for (texture = d3d->texlist; texture != NULL; texture = texture->next)
+ {
+ UINT32 test_screen = (UINT32)texture->texinfo.osddata >> 1;
+ UINT32 test_page = (UINT32)texture->texinfo.osddata & 1;
+ if (test_screen != prim_screen || test_page != prim_page)
+ {
+ continue;
+ }
+
+ // Clear our old texture reference
+ if (texture->hash == texhash &&
+ texture->texinfo.base == prim->texture.base &&
+ ((texture->flags ^ prim->flags) & (PRIMFLAG_BLENDMODE_MASK | PRIMFLAG_TEXFORMAT_MASK)) == 0 &&
+ (texture->texinfo.width != prim->texture.width ||
+ texture->texinfo.height != prim->texture.height))
+ {
+ d3d->hlsl->remove_render_target(texture);
+ break;
+ }
+ }
+ }
+ return NULL;
+}
+
+
+//============================================================
+// texture_update
+//============================================================
+
+static void texture_update(d3d_info *d3d, const render_primitive *prim)
+{
+ d3d_texture_info *texture = texture_find(d3d, prim);
+
+ // if we didn't find one, create a new texture
+ if (texture == NULL)
+ {
+ texture = texture_create(d3d, &prim->texture, prim->flags);
+ }
+
+ // if we found it, but with a different seqid, copy the data
+ if (texture->texinfo.seqid != prim->texture.seqid)
+ {
+ texture_set_data(d3d, texture, &prim->texture, prim->flags);
+ texture->texinfo.seqid = prim->texture.seqid;
+ }
+}
+
+
//============================================================
// d3d_cache_target::~d3d_cache_target
//============================================================
diff --git a/src/osd/windows/drawd3d.h b/src/osd/windows/drawd3d.h
index c08f2ff7814..a4e3ef40c19 100644
--- a/src/osd/windows/drawd3d.h
+++ b/src/osd/windows/drawd3d.h
@@ -145,7 +145,7 @@ struct d3d_info
bool restarting; // if we're restarting
- d3d::texture_info * texlist; // list of active textures
+ d3d_texture_info * texlist; // list of active textures
int dynamic_supported; // are dynamic textures supported?
int stretch_supported; // is StretchRect with point filtering supported?
int mod2x_supported; // is D3DTOP_MODULATE2X supported?
@@ -158,7 +158,7 @@ struct d3d_info
DWORD texture_max_width; // texture maximum width
DWORD texture_max_height; // texture maximum height
- d3d::texture_info * last_texture; // previous texture
+ d3d_texture_info * last_texture; // previous texture
UINT32 last_texture_flags; // previous texture flags
int last_blendenable; // previous blendmode
int last_blendop; // previous blendmode
@@ -169,13 +169,22 @@ struct d3d_info
DWORD last_modmode; // previous texture modulation
bitmap_argb32 vector_bitmap; // experimental: bitmap for vectors
- d3d::texture_info * vector_texture; // experimental: texture for vectors
+ d3d_texture_info * vector_texture; // experimental: texture for vectors
bitmap_rgb32 default_bitmap; // experimental: default bitmap
- d3d::texture_info * default_texture; // experimental: default texture
+ d3d_texture_info * default_texture; // experimental: default texture
void * hlsl_buf; // HLSL vertex data
hlsl_info * hlsl; // HLSL interface
};
+
+
+//============================================================
+// PROTOTYPES
+//============================================================
+
+d3d_texture_info *texture_create(d3d_info *d3d, const render_texinfo *texsource, UINT32 flags);
+void texture_destroy(d3d_info *d3d, d3d_texture_info *info);
+
#endif