[PATCH 5/5] wined3d: Rename wined3d_format_desc to wined3d_format.
Henri Verbeet
hverbeet at codeweavers.com
Mon Aug 30 13:29:49 CDT 2010
---
dlls/wined3d/arb_program_shader.c | 22 ++--
dlls/wined3d/basetexture.c | 10 +-
dlls/wined3d/buffer.c | 20 ++--
dlls/wined3d/context.c | 52 +++---
dlls/wined3d/cubetexture.c | 8 +-
dlls/wined3d/device.c | 65 ++++----
dlls/wined3d/directx.c | 216 +++++++++++++------------
dlls/wined3d/drawprim.c | 24 ++--
dlls/wined3d/resource.c | 4 +-
dlls/wined3d/shader.c | 6 +-
dlls/wined3d/state.c | 64 ++++----
dlls/wined3d/surface.c | 322 ++++++++++++++++++-------------------
dlls/wined3d/surface_base.c | 99 ++++++------
dlls/wined3d/surface_gdi.c | 4 +-
dlls/wined3d/swapchain.c | 14 +-
dlls/wined3d/texture.c | 14 +-
dlls/wined3d/utils.c | 270 ++++++++++++++++----------------
dlls/wined3d/vertexdeclaration.c | 4 +-
dlls/wined3d/volume.c | 41 ++----
dlls/wined3d/volumetexture.c | 4 +-
dlls/wined3d/wined3d_private.h | 46 +++---
21 files changed, 644 insertions(+), 665 deletions(-)
diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c
index cc420d2..7901f0f 100644
--- a/dlls/wined3d/arb_program_shader.c
+++ b/dlls/wined3d/arb_program_shader.c
@@ -6987,10 +6987,10 @@ static HRESULT arbfp_blit_set(IWineD3DDevice *iface, IWineD3DSurfaceImpl *surfac
enum complex_fixup fixup;
GLenum textype = surface->texture_target;
- if (!is_complex_fixup(surface->resource.format_desc->color_fixup))
+ if (!is_complex_fixup(surface->resource.format->color_fixup))
{
TRACE("Fixup:\n");
- dump_color_fixup_desc(surface->resource.format_desc->color_fixup);
+ dump_color_fixup_desc(surface->resource.format->color_fixup);
/* Don't bother setting up a shader for unconverted formats */
ENTER_GL();
glEnable(textype);
@@ -6999,7 +6999,7 @@ static HRESULT arbfp_blit_set(IWineD3DDevice *iface, IWineD3DSurfaceImpl *surfac
return WINED3D_OK;
}
- fixup = get_complex_fixup(surface->resource.format_desc->color_fixup);
+ fixup = get_complex_fixup(surface->resource.format->color_fixup);
switch(fixup)
{
@@ -7069,10 +7069,8 @@ static void arbfp_blit_unset(IWineD3DDevice *iface) {
}
static BOOL arbfp_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
- const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
- const struct wined3d_format_desc *src_format_desc,
- const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
- const struct wined3d_format_desc *dst_format_desc)
+ const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
+ const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
{
enum complex_fixup src_fixup;
@@ -7082,27 +7080,27 @@ static BOOL arbfp_blit_supported(const struct wined3d_gl_info *gl_info, enum bli
return FALSE;
}
- src_fixup = get_complex_fixup(src_format_desc->color_fixup);
+ src_fixup = get_complex_fixup(src_format->color_fixup);
if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
{
TRACE("Checking support for fixup:\n");
- dump_color_fixup_desc(src_format_desc->color_fixup);
+ dump_color_fixup_desc(src_format->color_fixup);
}
- if (!is_identity_fixup(dst_format_desc->color_fixup))
+ if (!is_identity_fixup(dst_format->color_fixup))
{
TRACE("Destination fixups are not supported\n");
return FALSE;
}
- if (is_identity_fixup(src_format_desc->color_fixup))
+ if (is_identity_fixup(src_format->color_fixup))
{
TRACE("[OK]\n");
return TRUE;
}
/* We only support YUV conversions. */
- if (!is_complex_fixup(src_format_desc->color_fixup))
+ if (!is_complex_fixup(src_format->color_fixup))
{
TRACE("[FAILED]\n");
return FALSE;
diff --git a/dlls/wined3d/basetexture.c b/dlls/wined3d/basetexture.c
index 922550d..584dabd 100644
--- a/dlls/wined3d/basetexture.c
+++ b/dlls/wined3d/basetexture.c
@@ -29,13 +29,13 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d_texture);
HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, UINT layer_count, UINT level_count,
WINED3DRESOURCETYPE resource_type, IWineD3DDeviceImpl *device, UINT size, DWORD usage,
- const struct wined3d_format_desc *format_desc, WINED3DPOOL pool, IUnknown *parent,
+ const struct wined3d_format *format, WINED3DPOOL pool, IUnknown *parent,
const struct wined3d_parent_ops *parent_ops)
{
HRESULT hr;
hr = resource_init((IWineD3DResource *)texture, resource_type, device,
- size, usage, format_desc, pool, parent, parent_ops);
+ size, usage, format, pool, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize resource, returning %#x\n", hr);
@@ -60,7 +60,7 @@ HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, UINT layer_count, UIN
texture->baseTexture.is_srgb = FALSE;
texture->baseTexture.pow2Matrix_identity = TRUE;
- if (texture->resource.format_desc->Flags & WINED3DFMT_FLAG_FILTERING)
+ if (texture->resource.format->Flags & WINED3DFMT_FLAG_FILTERING)
{
texture->baseTexture.minMipLookup = minMipLookup;
texture->baseTexture.magLookup = magLookup;
@@ -520,10 +520,10 @@ void basetexture_apply_state_changes(IWineD3DBaseTexture *iface,
gl_tex->states[WINED3DTEXSTA_MAXANISOTROPY] = aniso;
}
- if (!(This->resource.format_desc->Flags & WINED3DFMT_FLAG_SHADOW)
+ if (!(This->resource.format->Flags & WINED3DFMT_FLAG_SHADOW)
!= !gl_tex->states[WINED3DTEXSTA_SHADOW])
{
- if (This->resource.format_desc->Flags & WINED3DFMT_FLAG_SHADOW)
+ if (This->resource.format->Flags & WINED3DFMT_FLAG_SHADOW)
{
glTexParameteri(textureDimensions, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
glTexParameteri(textureDimensions, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
diff --git a/dlls/wined3d/buffer.c b/dlls/wined3d/buffer.c
index 1fd6058..d97aac1 100644
--- a/dlls/wined3d/buffer.c
+++ b/dlls/wined3d/buffer.c
@@ -245,7 +245,7 @@ static BOOL buffer_process_converted_attribute(struct wined3d_buffer *This,
if (!attrib->stride)
{
FIXME("%s used with stride 0, let's hope we get the vertex stride from somewhere else\n",
- debug_d3dformat(attrib->format_desc->id));
+ debug_d3dformat(attrib->format->id));
}
else if(attrib->stride != *stride_this_run && *stride_this_run)
{
@@ -269,7 +269,7 @@ static BOOL buffer_process_converted_attribute(struct wined3d_buffer *This,
}
data = (((DWORD_PTR)attrib->data) + offset) % This->stride;
- attrib_size = attrib->format_desc->component_count * attrib->format_desc->component_size;
+ attrib_size = attrib->format->component_count * attrib->format->component_size;
for (i = 0; i < attrib_size; ++i)
{
DWORD_PTR idx = (data + i) % This->stride;
@@ -302,7 +302,7 @@ static BOOL buffer_check_attribute(struct wined3d_buffer *This, const struct win
|| attrib->buffer_object != This->buffer_object)
return FALSE;
- format = attrib->format_desc->id;
+ format = attrib->format->id;
/* Look for newly appeared conversion */
if (!gl_info->supported[ARB_HALF_FLOAT_VERTEX]
&& (format == WINED3DFMT_R16G16_FLOAT || format == WINED3DFMT_R16G16B16A16_FLOAT))
@@ -350,7 +350,7 @@ static UINT *find_conversion_shift(struct wined3d_buffer *This,
if (!(strided->use_map & (1 << i)) || strided->elements[i].buffer_object != This->buffer_object) continue;
- format = strided->elements[i].format_desc->id;
+ format = strided->elements[i].format->id;
if (format == WINED3DFMT_R16G16_FLOAT)
{
shift = 4;
@@ -374,8 +374,8 @@ static UINT *find_conversion_shift(struct wined3d_buffer *This,
if (shift)
{
- orig_type_size = strided->elements[i].format_desc->component_count
- * strided->elements[i].format_desc->component_size;
+ orig_type_size = strided->elements[i].format->component_count
+ * strided->elements[i].format->component_size;
for (j = (DWORD_PTR)strided->elements[i].data + orig_type_size; j < stride; ++j)
{
ret[j] += shift;
@@ -1450,9 +1450,9 @@ HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device,
UINT size, DWORD usage, enum wined3d_format_id format_id, WINED3DPOOL pool, GLenum bind_hint,
const char *data, IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
{
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id, &device->adapter->gl_info);
- HRESULT hr;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
+ const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
+ HRESULT hr;
BOOL dynamic_buffer_ok;
if (!size)
@@ -1464,7 +1464,7 @@ HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device,
buffer->vtbl = &wined3d_buffer_vtbl;
hr = resource_init((IWineD3DResource *)buffer, WINED3DRTYPE_BUFFER,
- device, size, usage, format_desc, pool, parent, parent_ops);
+ device, size, usage, format, pool, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize resource, hr %#x\n", hr);
@@ -1473,7 +1473,7 @@ HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device,
buffer->buffer_type_hint = bind_hint;
TRACE("size %#x, usage %#x, format %s, memory @ %p, iface @ %p.\n", buffer->resource.size, buffer->resource.usage,
- debug_d3dformat(buffer->resource.format_desc->id), buffer->resource.allocatedMemory, buffer);
+ debug_d3dformat(buffer->resource.format->id), buffer->resource.allocatedMemory, buffer);
/* GL_ARB_map_buffer_range is disabled for now due to numerous bugs and no gains */
dynamic_buffer_ok = gl_info->supported[APPLE_FLUSH_BUFFER_RANGE];
diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c
index 3e3193f..fa12d10 100644
--- a/dlls/wined3d/context.c
+++ b/dlls/wined3d/context.c
@@ -201,7 +201,7 @@ void context_attach_depth_stencil_fbo(struct wined3d_context *context,
if (depth_stencil)
{
- DWORD format_flags = depth_stencil->resource.format_desc->Flags;
+ DWORD format_flags = depth_stencil->resource.format->Flags;
if (use_render_buffer && depth_stencil->current_renderbuffer)
{
@@ -333,7 +333,7 @@ static void context_check_fbo_status(struct wined3d_context *context, GLenum tar
if (attachment)
{
FIXME("\tColor attachment %d: (%p) %s %ux%u\n",
- i, attachment, debug_d3dformat(attachment->resource.format_desc->id),
+ i, attachment, debug_d3dformat(attachment->resource.format->id),
attachment->pow2Width, attachment->pow2Height);
}
}
@@ -341,7 +341,7 @@ static void context_check_fbo_status(struct wined3d_context *context, GLenum tar
if (attachment)
{
FIXME("\tDepth attachment: (%p) %s %ux%u\n",
- attachment, debug_d3dformat(attachment->resource.format_desc->id),
+ attachment, debug_d3dformat(attachment->resource.format->id),
attachment->pow2Width, attachment->pow2Height);
}
}
@@ -1106,7 +1106,7 @@ static void Context_MarkStateDirty(struct wined3d_context *context, DWORD state,
/* This function takes care of WineD3D pixel format selection. */
static int WineD3D_ChoosePixelFormat(IWineD3DDeviceImpl *This, HDC hdc,
- const struct wined3d_format_desc *color_format_desc, const struct wined3d_format_desc *ds_format_desc,
+ const struct wined3d_format *color_format, const struct wined3d_format *ds_format,
BOOL auxBuffers, int numSamples, BOOL findCompatible)
{
int iPixelFormat=0;
@@ -1141,17 +1141,17 @@ static int WineD3D_ChoosePixelFormat(IWineD3DDeviceImpl *This, HDC hdc,
int nCfgs = This->adapter->nCfgs;
TRACE("ColorFormat=%s, DepthStencilFormat=%s, auxBuffers=%d, numSamples=%d, findCompatible=%d\n",
- debug_d3dformat(color_format_desc->id), debug_d3dformat(ds_format_desc->id),
+ debug_d3dformat(color_format->id), debug_d3dformat(ds_format->id),
auxBuffers, numSamples, findCompatible);
- if (!getColorBits(color_format_desc, &redBits, &greenBits, &blueBits, &alphaBits, &colorBits))
+ if (!getColorBits(color_format, &redBits, &greenBits, &blueBits, &alphaBits, &colorBits))
{
ERR("Unable to get color bits for format %s (%#x)!\n",
- debug_d3dformat(color_format_desc->id), color_format_desc->id);
+ debug_d3dformat(color_format->id), color_format->id);
return 0;
}
- getDepthStencilBits(ds_format_desc, &depthBits, &stencilBits);
+ getDepthStencilBits(ds_format, &depthBits, &stencilBits);
for(matchtry = 0; matchtry < (sizeof(matches) / sizeof(matches[0])) && !iPixelFormat; matchtry++) {
for(i=0; i<nCfgs; i++) {
@@ -1260,7 +1260,7 @@ static int WineD3D_ChoosePixelFormat(IWineD3DDeviceImpl *This, HDC hdc,
}
TRACE("Found iPixelFormat=%d for ColorFormat=%s, DepthStencilFormat=%s\n",
- iPixelFormat, debug_d3dformat(color_format_desc->id), debug_d3dformat(ds_format_desc->id));
+ iPixelFormat, debug_d3dformat(color_format->id), debug_d3dformat(ds_format->id));
return iPixelFormat;
}
@@ -1276,12 +1276,12 @@ static int WineD3D_ChoosePixelFormat(IWineD3DDeviceImpl *This, HDC hdc,
* pPresentParameters: contains the pixelformats to use for onscreen rendering
*
*****************************************************************************/
-struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3DSurfaceImpl *target,
- const struct wined3d_format_desc *ds_format_desc)
+struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain,
+ IWineD3DSurfaceImpl *target, const struct wined3d_format *ds_format)
{
IWineD3DDeviceImpl *device = swapchain->device;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
- const struct wined3d_format_desc *color_format_desc;
+ const struct wined3d_format *color_format;
struct wined3d_context *ret;
PIXELFORMATDESCRIPTOR pfd;
BOOL auxBuffers = FALSE;
@@ -1307,7 +1307,7 @@ struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3
goto out;
}
- color_format_desc = target->resource.format_desc;
+ color_format = target->resource.format;
/* In case of ORM_BACKBUFFER, make sure to request an alpha component for
* X4R4G4B4/X8R8G8B8 as we might need it for the backbuffer. */
@@ -1315,10 +1315,10 @@ struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3
{
auxBuffers = TRUE;
- if (color_format_desc->id == WINED3DFMT_B4G4R4X4_UNORM)
- color_format_desc = getFormatDescEntry(WINED3DFMT_B4G4R4A4_UNORM, gl_info);
- else if (color_format_desc->id == WINED3DFMT_B8G8R8X8_UNORM)
- color_format_desc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
+ if (color_format->id == WINED3DFMT_B4G4R4X4_UNORM)
+ color_format = wined3d_get_format(gl_info, WINED3DFMT_B4G4R4A4_UNORM);
+ else if (color_format->id == WINED3DFMT_B8G8R8X8_UNORM)
+ color_format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
}
/* DirectDraw supports 8bit paletted render targets and these are used by
@@ -1327,8 +1327,8 @@ struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3
* conversion (ab)uses the alpha component for storing the palette index.
* For this reason we require a format with 8bit alpha, so request
* A8R8G8B8. */
- if (color_format_desc->id == WINED3DFMT_P8_UINT)
- color_format_desc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
+ if (color_format->id == WINED3DFMT_P8_UINT)
+ color_format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
/* D3D only allows multisampling when SwapEffect is set to WINED3DSWAPEFFECT_DISCARD. */
if (swapchain->presentParms.MultiSampleType && (swapchain->presentParms.SwapEffect == WINED3DSWAPEFFECT_DISCARD))
@@ -1343,14 +1343,14 @@ struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3
}
/* Try to find a pixel format which matches our requirements. */
- pixel_format = WineD3D_ChoosePixelFormat(device, hdc, color_format_desc, ds_format_desc,
+ pixel_format = WineD3D_ChoosePixelFormat(device, hdc, color_format, ds_format,
auxBuffers, numSamples, FALSE /* findCompatible */);
/* Try to locate a compatible format if we weren't able to find anything. */
if (!pixel_format)
{
TRACE("Trying to locate a compatible pixel format because an exact match failed.\n");
- pixel_format = WineD3D_ChoosePixelFormat(device, hdc, color_format_desc, ds_format_desc,
+ pixel_format = WineD3D_ChoosePixelFormat(device, hdc, color_format, ds_format,
auxBuffers, 0 /* numSamples */, TRUE /* findCompatible */);
}
@@ -2046,8 +2046,8 @@ static inline void context_set_render_offscreen(struct wined3d_context *context,
context->render_offscreen = offscreen;
}
-static BOOL match_depth_stencil_format(const struct wined3d_format_desc *existing,
- const struct wined3d_format_desc *required)
+static BOOL match_depth_stencil_format(const struct wined3d_format *existing,
+ const struct wined3d_format *required)
{
short existing_depth, existing_stencil, required_depth, required_stencil;
@@ -2071,7 +2071,7 @@ static void context_validate_onscreen_formats(IWineD3DDeviceImpl *device,
IWineD3DSwapChainImpl *swapchain = context->current_rt->container.u.swapchain;
if (context->render_offscreen || !depth_stencil) return;
- if (match_depth_stencil_format(swapchain->ds_format, depth_stencil->resource.format_desc)) return;
+ if (match_depth_stencil_format(swapchain->ds_format, depth_stencil->resource.format)) return;
/* TODO: If the requested format would satisfy the needs of the existing one(reverse match),
* or no onscreen depth buffer was created, the OpenGL drawable could be changed to the new
@@ -2253,8 +2253,8 @@ static void context_setup_target(IWineD3DDeviceImpl *device,
}
else
{
- const struct wined3d_format_desc *old = context->current_rt->resource.format_desc;
- const struct wined3d_format_desc *new = target->resource.format_desc;
+ const struct wined3d_format *old = context->current_rt->resource.format;
+ const struct wined3d_format *new = target->resource.format;
if (old->id != new->id)
{
diff --git a/dlls/wined3d/cubetexture.c b/dlls/wined3d/cubetexture.c
index 13f41b6..fd690a6 100644
--- a/dlls/wined3d/cubetexture.c
+++ b/dlls/wined3d/cubetexture.c
@@ -70,8 +70,8 @@ static void cubetexture_internal_preload(IWineD3DBaseTexture *iface, enum WINED3
context = context_acquire(device, NULL);
}
- if (This->resource.format_desc->id == WINED3DFMT_P8_UINT
- || This->resource.format_desc->id == WINED3DFMT_P8_UINT_A8_UNORM)
+ if (This->resource.format->id == WINED3DFMT_P8_UINT
+ || This->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
{
for (i = 0; i < sub_count; ++i)
{
@@ -455,7 +455,7 @@ HRESULT cubetexture_init(IWineD3DCubeTextureImpl *texture, UINT edge_length, UIN
IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
{
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id, gl_info);
+ const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
UINT pow2_edge_length;
unsigned int i, j;
UINT tmp_w;
@@ -501,7 +501,7 @@ HRESULT cubetexture_init(IWineD3DCubeTextureImpl *texture, UINT edge_length, UIN
texture->lpVtbl = &IWineD3DCubeTexture_Vtbl;
hr = basetexture_init((IWineD3DBaseTextureImpl *)texture, 6, levels,
- WINED3DRTYPE_CUBETEXTURE, device, 0, usage, format_desc, pool, parent, parent_ops);
+ WINED3DRTYPE_CUBETEXTURE, device, 0, usage, format, pool, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize basetexture, returning %#x\n", hr);
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index bf28b9c..9b2cf93 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -274,7 +274,7 @@ void device_stream_info_from_declaration(IWineD3DDeviceImpl *This,
if (!element->ffp_valid)
{
WARN("Skipping unsupported fixed function element of format %s and usage %s\n",
- debug_d3dformat(element->format_desc->id), debug_d3ddeclusage(element->usage));
+ debug_d3dformat(element->format->id), debug_d3ddeclusage(element->usage));
stride_used = FALSE;
}
else
@@ -289,16 +289,16 @@ void device_stream_info_from_declaration(IWineD3DDeviceImpl *This,
"input_slot %u, offset %u, stride %u, format %s, buffer_object %u]\n",
use_vshader ? "shader": "fixed function", idx,
debug_d3ddeclusage(element->usage), element->usage_idx, element->input_slot,
- element->offset, stride, debug_d3dformat(element->format_desc->id), buffer_object);
+ element->offset, stride, debug_d3dformat(element->format->id), buffer_object);
- stream_info->elements[idx].format_desc = element->format_desc;
+ stream_info->elements[idx].format = element->format;
stream_info->elements[idx].stride = stride;
stream_info->elements[idx].data = data;
stream_info->elements[idx].stream_idx = element->input_slot;
stream_info->elements[idx].buffer_object = buffer_object;
if (!This->adapter->gl_info.supported[ARB_VERTEX_ARRAY_BGRA]
- && element->format_desc->id == WINED3DFMT_B8G8R8A8_UNORM)
+ && element->format->id == WINED3DFMT_B8G8R8A8_UNORM)
{
stream_info->swizzle_map |= 1 << idx;
}
@@ -343,8 +343,7 @@ void device_stream_info_from_declaration(IWineD3DDeviceImpl *This,
static void stream_info_element_from_strided(const struct wined3d_gl_info *gl_info,
const struct WineDirect3DStridedData *strided, struct wined3d_stream_info_element *e)
{
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(strided->format, gl_info);
- e->format_desc = format_desc;
+ e->format = wined3d_get_format(gl_info, strided->format);
e->stride = strided->dwStride;
e->data = strided->lpData;
e->stream_idx = 0;
@@ -378,10 +377,10 @@ static void device_stream_info_from_strided(const struct wined3d_gl_info *gl_inf
for (i = 0; i < sizeof(stream_info->elements) / sizeof(*stream_info->elements); ++i)
{
- if (!stream_info->elements[i].format_desc) continue;
+ if (!stream_info->elements[i].format) continue;
if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
- && stream_info->elements[i].format_desc->id == WINED3DFMT_B8G8R8A8_UNORM)
+ && stream_info->elements[i].format->id == WINED3DFMT_B8G8R8A8_UNORM)
{
stream_info->swizzle_map |= 1 << i;
}
@@ -1365,14 +1364,14 @@ struct wined3d_fvf_convert_state
};
static void append_decl_element(struct wined3d_fvf_convert_state *state,
- enum wined3d_format_id format, WINED3DDECLUSAGE usage, UINT usage_idx)
+ enum wined3d_format_id format_id, WINED3DDECLUSAGE usage, UINT usage_idx)
{
WINED3DVERTEXELEMENT *elements = state->elements;
- const struct wined3d_format_desc *format_desc;
+ const struct wined3d_format *format;
UINT offset = state->offset;
UINT idx = state->idx;
- elements[idx].format = format;
+ elements[idx].format = format_id;
elements[idx].input_slot = 0;
elements[idx].offset = offset;
elements[idx].output_slot = 0;
@@ -1380,8 +1379,8 @@ static void append_decl_element(struct wined3d_fvf_convert_state *state,
elements[idx].usage = usage;
elements[idx].usage_idx = usage_idx;
- format_desc = getFormatDescEntry(format, state->gl_info);
- state->offset += format_desc->component_count * format_desc->component_size;
+ format = wined3d_get_format(state->gl_info, format_id);
+ state->offset += format->component_count * format->component_size;
++state->idx;
}
@@ -2190,7 +2189,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetDisplayMode(IWineD3DDevice *iface, U
const WINED3DDISPLAYMODE* pMode) {
DEVMODEW devmode;
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(pMode->Format, &This->adapter->gl_info);
+ const struct wined3d_format *format = wined3d_get_format(&This->adapter->gl_info, pMode->Format);
LONG ret;
RECT clip_rc;
@@ -2205,7 +2204,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetDisplayMode(IWineD3DDevice *iface, U
memset(&devmode, 0, sizeof(devmode));
devmode.dmSize = sizeof(devmode);
devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
- devmode.dmBitsPerPel = format_desc->byte_count * 8;
+ devmode.dmBitsPerPel = format->byte_count * CHAR_BIT;
devmode.dmPelsWidth = pMode->Width;
devmode.dmPelsHeight = pMode->Height;
@@ -5023,7 +5022,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_ValidateDevice(IWineD3DDevice *iface,
}
texture = (IWineD3DBaseTextureImpl *) This->stateBlock->textures[i];
- if (!texture || texture->resource.format_desc->Flags & WINED3DFMT_FLAG_FILTERING) continue;
+ if (!texture || texture->resource.format->Flags & WINED3DFMT_FLAG_FILTERING) continue;
if(This->stateBlock->samplerState[i][WINED3DSAMP_MAGFILTER] != WINED3DTEXF_POINT) {
WARN("Non-filterable texture and mag filter enabled on samper %u, returning E_FAIL\n", i);
@@ -5054,8 +5053,8 @@ static void dirtify_p8_texture_samplers(IWineD3DDeviceImpl *device)
for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
{
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl*)device->stateBlock->textures[i];
- if (texture && (texture->resource.format_desc->id == WINED3DFMT_P8_UINT
- || texture->resource.format_desc->id == WINED3DFMT_P8_UINT_A8_UNORM))
+ if (texture && (texture->resource.format->id == WINED3DFMT_P8_UINT
+ || texture->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM))
{
IWineD3DDeviceImpl_MarkStateDirty(device, STATE_SAMPLER(i));
}
@@ -5241,8 +5240,8 @@ static HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface,
IWineD3DSurfaceImpl *src_impl = (IWineD3DSurfaceImpl *)src_surface;
IWineD3DSurfaceImpl *dst_impl = (IWineD3DSurfaceImpl *)dst_surface;
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
- const struct wined3d_format_desc *src_format;
- const struct wined3d_format_desc *dst_format;
+ const struct wined3d_format *src_format;
+ const struct wined3d_format *dst_format;
const struct wined3d_gl_info *gl_info;
struct wined3d_context *context;
const unsigned char *data;
@@ -5251,7 +5250,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface,
UINT src_w, src_h;
UINT dst_x, dst_y;
DWORD sampler;
- struct wined3d_format_desc desc;
+ struct wined3d_format format;
TRACE("iface %p, src_surface %p, src_rect %s, dst_surface %p, dst_point %s.\n",
iface, src_surface, wine_dbgstr_rect(src_rect),
@@ -5264,8 +5263,8 @@ static HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface,
return WINED3DERR_INVALIDCALL;
}
- src_format = src_impl->resource.format_desc;
- dst_format = dst_impl->resource.format_desc;
+ src_format = src_impl->resource.format;
+ dst_format = dst_impl->resource.format;
if (src_format->id != dst_format->id)
{
@@ -5280,8 +5279,8 @@ static HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface,
* surface to the destination's sysmem copy. If surface conversion is
* needed, use BltFast instead to copy in sysmem and use regular surface
* loading. */
- d3dfmt_get_conv(dst_impl, FALSE, TRUE, &desc, &convert);
- if (convert != NO_CONVERSION || desc.convert)
+ d3dfmt_get_conv(dst_impl, FALSE, TRUE, &format, &convert);
+ if (convert != NO_CONVERSION || format.convert)
return IWineD3DSurface_BltFast(dst_surface, dst_x, dst_y, src_surface, src_rect, 0);
context = context_acquire(This, NULL);
@@ -5630,7 +5629,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetFrontBackBuffers(IWineD3DDevice *ifa
{
swapchain->presentParms.BackBufferWidth = back_impl->currentDesc.Width;
swapchain->presentParms.BackBufferHeight = back_impl->currentDesc.Height;
- swapchain->presentParms.BackBufferFormat = back_impl->resource.format_desc->id;
+ swapchain->presentParms.BackBufferFormat = back_impl->resource.format->id;
swapchain->presentParms.BackBufferCount = 1;
surface_set_container(back_impl, WINED3D_CONTAINER_SWAPCHAIN, (IWineD3DBase *)swapchain);
@@ -5802,7 +5801,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice *ifa
WINED3DLOCKED_RECT rect;
/* MSDN: Cursor must be A8R8G8B8 */
- if (s->resource.format_desc->id != WINED3DFMT_B8G8R8A8_UNORM)
+ if (s->resource.format->id != WINED3DFMT_B8G8R8A8_UNORM)
{
WARN("surface %p has an invalid format.\n", cursor_image);
return WINED3DERR_INVALIDCALL;
@@ -5831,15 +5830,15 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice *ifa
if (SUCCEEDED(IWineD3DSurface_LockRect(cursor_image, &rect, NULL, WINED3DLOCK_READONLY)))
{
const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
+ const struct wined3d_format *format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
struct wined3d_context *context;
char *mem, *bits = rect.pBits;
- GLint intfmt = format_desc->glInternal;
- GLint format = format_desc->glFormat;
- GLint type = format_desc->glType;
+ GLint intfmt = format->glInternal;
+ GLint gl_format = format->glFormat;
+ GLint type = format->glType;
INT height = This->cursorHeight;
INT width = This->cursorWidth;
- INT bpp = format_desc->byte_count;
+ INT bpp = format->byte_count;
DWORD sampler;
INT i;
@@ -5874,7 +5873,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice *ifa
glBindTexture(GL_TEXTURE_2D, This->cursorTexture);
checkGLcall("glBindTexture");
/* Copy the bitmap memory into the cursor texture */
- glTexImage2D(GL_TEXTURE_2D, 0, intfmt, width, height, 0, format, type, mem);
+ glTexImage2D(GL_TEXTURE_2D, 0, intfmt, width, height, 0, gl_format, type, mem);
HeapFree(GetProcessHeap(), 0, mem);
checkGLcall("glTexImage2D");
diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c
index 9c85dca..01b4e46 100644
--- a/dlls/wined3d/directx.c
+++ b/dlls/wined3d/directx.c
@@ -341,7 +341,7 @@ unsigned int WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *device, unsigned int
static void wined3d_adapter_cleanup(struct wined3d_adapter *adapter)
{
- HeapFree(GetProcessHeap(), 0, adapter->gl_info.gl_formats);
+ HeapFree(GetProcessHeap(), 0, adapter->gl_info.formats);
HeapFree(GetProcessHeap(), 0, adapter->cfgs);
}
@@ -2771,9 +2771,10 @@ static UINT WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapte
}
/* TODO: Store modes per adapter and read it from the adapter structure */
- if (Adapter == 0) { /* Display */
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id, &This->adapters[Adapter].gl_info);
- UINT format_bits = format_desc->byte_count * CHAR_BIT;
+ if (Adapter == 0)
+ {
+ const struct wined3d_format *format = wined3d_get_format(&This->adapters[Adapter].gl_info, format_id);
+ UINT format_bits = format->byte_count * CHAR_BIT;
unsigned int i = 0;
unsigned int j = 0;
DEVMODEW mode;
@@ -2823,8 +2824,8 @@ static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapte
/* TODO: Store modes per adapter and read it from the adapter structure */
if (Adapter == 0)
{
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id, &This->adapters[Adapter].gl_info);
- UINT format_bits = format_desc->byte_count * CHAR_BIT;
+ const struct wined3d_format *format = wined3d_get_format(&This->adapters[Adapter].gl_info, format_id);
+ UINT format_bits = format->byte_count * CHAR_BIT;
DEVMODEW DevModeW;
int ModeIdx = 0;
UINT i = 0;
@@ -2990,7 +2991,7 @@ static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Ad
}
static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined3d_gl_info *gl_info,
- const WineD3D_PixelFormat *cfg, const struct wined3d_format_desc *format_desc)
+ const WineD3D_PixelFormat *cfg, const struct wined3d_format *format)
{
short redSize, greenSize, blueSize, alphaSize, colorBits;
@@ -2998,12 +2999,12 @@ static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined
return FALSE;
/* Float formats need FBOs. If FBOs are used this function isn't called */
- if (format_desc->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
+ if (format->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
- if (!getColorBits(format_desc, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
+ if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
{
- ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format_desc->id));
+ ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
return FALSE;
}
@@ -3027,7 +3028,7 @@ static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined
}
static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3d_gl_info *gl_info,
- const WineD3D_PixelFormat *cfg, const struct wined3d_format_desc *format_desc)
+ const WineD3D_PixelFormat *cfg, const struct wined3d_format *format)
{
short depthSize, stencilSize;
BOOL lockable = FALSE;
@@ -3035,16 +3036,16 @@ static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3
if(!cfg)
return FALSE;
- if (!getDepthStencilBits(format_desc, &depthSize, &stencilSize))
+ if (!getDepthStencilBits(format, &depthSize, &stencilSize))
{
- ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format_desc->id));
+ ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
return FALSE;
}
/* Float formats need FBOs. If FBOs are used this function isn't called */
- if (format_desc->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
+ if (format->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
- if ((format_desc->id == WINED3DFMT_D16_LOCKABLE) || (format_desc->id == WINED3DFMT_D32_FLOAT))
+ if ((format->id == WINED3DFMT_D16_LOCKABLE) || (format->id == WINED3DFMT_D32_FLOAT))
lockable = TRUE;
/* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
@@ -3069,8 +3070,8 @@ static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface,
int nCfgs;
const WineD3D_PixelFormat *cfgs;
const struct wined3d_adapter *adapter;
- const struct wined3d_format_desc *rt_format_desc;
- const struct wined3d_format_desc *ds_format_desc;
+ const struct wined3d_format *rt_format;
+ const struct wined3d_format *ds_format;
int it;
WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
@@ -3086,12 +3087,13 @@ static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface,
}
adapter = &This->adapters[Adapter];
- rt_format_desc = getFormatDescEntry(RenderTargetFormat, &adapter->gl_info);
- ds_format_desc = getFormatDescEntry(DepthStencilFormat, &adapter->gl_info);
+ rt_format = wined3d_get_format(&adapter->gl_info, RenderTargetFormat);
+ ds_format = wined3d_get_format(&adapter->gl_info, DepthStencilFormat);
if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
{
- if ((rt_format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET) &&
- (ds_format_desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))) {
+ if ((rt_format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
+ && (ds_format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
+ {
TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
return WINED3D_OK;
}
@@ -3100,10 +3102,11 @@ static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface,
{
cfgs = adapter->cfgs;
nCfgs = adapter->nCfgs;
- for (it = 0; it < nCfgs; ++it) {
- if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, &cfgs[it], rt_format_desc))
+ for (it = 0; it < nCfgs; ++it)
+ {
+ if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, &cfgs[it], rt_format))
{
- if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[it], ds_format_desc))
+ if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[it], ds_format))
{
TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
return WINED3D_OK;
@@ -3121,8 +3124,8 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, U
WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD *pQualityLevels)
{
IWineD3DImpl *This = (IWineD3DImpl *)iface;
- const struct wined3d_format_desc *glDesc;
const struct wined3d_adapter *adapter;
+ const struct wined3d_format *format;
TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
This,
@@ -3151,10 +3154,11 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, U
return WINED3DERR_NOTAVAILABLE;
adapter = &This->adapters[Adapter];
- glDesc = getFormatDescEntry(SurfaceFormat, &adapter->gl_info);
- if (!glDesc) return WINED3DERR_INVALIDCALL;
+ format = wined3d_get_format(&adapter->gl_info, SurfaceFormat);
+ if (!format) return WINED3DERR_INVALIDCALL;
- if(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) {
+ if (format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
+ {
int i, nCfgs;
const WineD3D_PixelFormat *cfgs;
@@ -3164,7 +3168,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, U
if(cfgs[i].numSamples != MultiSampleType)
continue;
- if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[i], glDesc))
+ if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[i], format))
continue;
TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
@@ -3174,12 +3178,13 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, U
return WINED3D_OK;
}
}
- else if(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET) {
+ else if (format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
+ {
short redSize, greenSize, blueSize, alphaSize, colorBits;
int i, nCfgs;
const WineD3D_PixelFormat *cfgs;
- if (!getColorBits(glDesc, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
+ if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
{
ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
return WINED3DERR_NOTAVAILABLE;
@@ -3199,7 +3204,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, U
/* Not all drivers report alpha-less formats since they use 32-bit anyway, so accept alpha even if we didn't ask for it. */
if(alphaSize && cfgs[i].alphaSize != alphaSize)
continue;
- if(cfgs[i].colorSize != (glDesc->byte_count << 3))
+ if (cfgs[i].colorSize != (format->byte_count << 3))
continue;
TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
@@ -3300,28 +3305,28 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter
/* Check if we support bumpmapping for a format */
-static BOOL CheckBumpMapCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
+static BOOL CheckBumpMapCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
{
/* Ask the fixed function pipeline implementation if it can deal
* with the conversion. If we've got a GL extension giving native
* support this will be an identity conversion. */
- return (format_desc->Flags & WINED3DFMT_FLAG_BUMPMAP)
- && adapter->fragment_pipe->color_fixup_supported(format_desc->color_fixup);
+ return (format->Flags & WINED3DFMT_FLAG_BUMPMAP)
+ && adapter->fragment_pipe->color_fixup_supported(format->color_fixup);
}
/* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
static BOOL CheckDepthStencilCapability(struct wined3d_adapter *adapter,
- const struct wined3d_format_desc *display_format_desc, const struct wined3d_format_desc *ds_format_desc)
+ const struct wined3d_format *display_format, const struct wined3d_format *ds_format)
{
int it=0;
/* Only allow depth/stencil formats */
- if (!(ds_format_desc->depth_size || ds_format_desc->stencil_size)) return FALSE;
+ if (!(ds_format->depth_size || ds_format->stencil_size)) return FALSE;
if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
{
/* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
- if (ds_format_desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) return TRUE;
+ if (ds_format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) return TRUE;
}
else
{
@@ -3329,9 +3334,9 @@ static BOOL CheckDepthStencilCapability(struct wined3d_adapter *adapter,
for (it = 0; it < adapter->nCfgs; ++it)
{
WineD3D_PixelFormat *cfg = &adapter->cfgs[it];
- if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, cfg, display_format_desc))
+ if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, cfg, display_format))
{
- if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, cfg, ds_format_desc))
+ if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, cfg, ds_format))
{
return TRUE;
}
@@ -3342,28 +3347,29 @@ static BOOL CheckDepthStencilCapability(struct wined3d_adapter *adapter,
return FALSE;
}
-static BOOL CheckFilterCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
+static BOOL CheckFilterCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
{
/* The flags entry of a format contains the filtering capability */
- if (format_desc->Flags & WINED3DFMT_FLAG_FILTERING) return TRUE;
+ if (format->Flags & WINED3DFMT_FLAG_FILTERING) return TRUE;
return FALSE;
}
/* Check the render target capabilities of a format */
static BOOL CheckRenderTargetCapability(struct wined3d_adapter *adapter,
- const struct wined3d_format_desc *adapter_format_desc, const struct wined3d_format_desc *check_format_desc)
+ const struct wined3d_format *adapter_format, const struct wined3d_format *check_format)
{
/* Filter out non-RT formats */
- if (!(check_format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET)) return FALSE;
- if(wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) {
+ if (!(check_format->Flags & WINED3DFMT_FLAG_RENDERTARGET)) return FALSE;
+ if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
+ {
WineD3D_PixelFormat *cfgs = adapter->cfgs;
int it;
short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
- getColorBits(adapter_format_desc, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
- getColorBits(check_format_desc, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
+ getColorBits(adapter_format, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
+ getColorBits(check_format, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
/* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
* The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
@@ -3377,10 +3383,10 @@ static BOOL CheckRenderTargetCapability(struct wined3d_adapter *adapter,
for (it = 0; it < adapter->nCfgs; ++it)
{
if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info,
- &cfgs[it], check_format_desc))
+ &cfgs[it], check_format))
{
TRACE_(d3d_caps)("Pixel format %d is compatible with format %s.\n",
- cfgs[it].iPixelFormat, debug_d3dformat(check_format_desc->id));
+ cfgs[it].iPixelFormat, debug_d3dformat(check_format->id));
return TRUE;
}
}
@@ -3394,18 +3400,17 @@ static BOOL CheckRenderTargetCapability(struct wined3d_adapter *adapter,
return FALSE;
}
-static BOOL CheckSrgbReadCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
+static BOOL CheckSrgbReadCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
{
- return adapter->gl_info.supported[EXT_TEXTURE_SRGB]
- && (format_desc->Flags & WINED3DFMT_FLAG_SRGB_READ);
+ return adapter->gl_info.supported[EXT_TEXTURE_SRGB] && (format->Flags & WINED3DFMT_FLAG_SRGB_READ);
}
-static BOOL CheckSrgbWriteCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
+static BOOL CheckSrgbWriteCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
{
/* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
* doing the color fixup in shaders.
* Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
- if (format_desc->Flags & WINED3DFMT_FLAG_SRGB_WRITE)
+ if (format->Flags & WINED3DFMT_FLAG_SRGB_WRITE)
{
int vs_selected_mode;
int ps_selected_mode;
@@ -3417,21 +3422,21 @@ static BOOL CheckSrgbWriteCapability(struct wined3d_adapter *adapter, const stru
}
}
- TRACE_(d3d_caps)("[FAILED] - sRGB writes not supported by format %s.\n", debug_d3dformat(format_desc->id));
+ TRACE_(d3d_caps)("[FAILED] - sRGB writes not supported by format %s.\n", debug_d3dformat(format->id));
return FALSE;
}
/* Check if a format support blending in combination with pixel shaders */
static BOOL CheckPostPixelShaderBlendingCapability(struct wined3d_adapter *adapter,
- const struct wined3d_format_desc *format_desc)
+ const struct wined3d_format *format)
{
/* The flags entry of a format contains the post pixel shader blending capability */
- if (format_desc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) return TRUE;
+ if (format->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) return TRUE;
return FALSE;
}
-static BOOL CheckWrapAndMipCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
+static BOOL CheckWrapAndMipCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
{
/* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
* but we have to report mipmapping so we cannot reject this flag. Tests show that
@@ -3446,11 +3451,11 @@ static BOOL CheckWrapAndMipCapability(struct wined3d_adapter *adapter, const str
}
/* Check if a texture format is supported on the given adapter */
-static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
+static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
{
const struct wined3d_gl_info *gl_info = &adapter->gl_info;
- switch (format_desc->id)
+ switch (format->id)
{
/*****
* supported: RGB(A) formats
@@ -3526,7 +3531,7 @@ static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct
/* Ask the shader backend if it can deal with the conversion. If
* we've got a GL extension giving native support this will be an
* identity conversion. */
- if (adapter->shader_backend->shader_color_fixup_supported(format_desc->color_fixup))
+ if (adapter->shader_backend->shader_color_fixup_supported(format->color_fixup))
{
TRACE_(d3d_caps)("[OK]\n");
return TRUE;
@@ -3642,8 +3647,8 @@ static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct
if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC]
|| gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC])
{
- if (adapter->shader_backend->shader_color_fixup_supported(format_desc->color_fixup)
- && adapter->fragment_pipe->color_fixup_supported(format_desc->color_fixup))
+ if (adapter->shader_backend->shader_color_fixup_supported(format->color_fixup)
+ && adapter->fragment_pipe->color_fixup_supported(format->color_fixup))
{
TRACE_(d3d_caps)("[OK]\n");
return TRUE;
@@ -3670,20 +3675,20 @@ static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct
return FALSE;
default:
- ERR("Unhandled format %s.\n", debug_d3dformat(format_desc->id));
+ ERR("Unhandled format %s.\n", debug_d3dformat(format->id));
break;
}
return FALSE;
}
static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
- const struct wined3d_format_desc *adapter_format_desc,
- const struct wined3d_format_desc *check_format_desc,
+ const struct wined3d_format *adapter_format,
+ const struct wined3d_format *check_format,
WINED3DSURFTYPE SurfaceType)
{
if (SurfaceType == SURFACE_GDI)
{
- switch (check_format_desc->id)
+ switch (check_format->id)
{
case WINED3DFMT_B8G8R8_UNORM:
case WINED3DFMT_B8G8R8A8_UNORM:
@@ -3712,14 +3717,14 @@ static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
}
/* All format that are supported for textures are supported for surfaces as well */
- if (CheckTextureCapability(adapter, check_format_desc)) return TRUE;
+ if (CheckTextureCapability(adapter, check_format)) return TRUE;
/* All depth stencil formats are supported on surfaces */
- if (CheckDepthStencilCapability(adapter, adapter_format_desc, check_format_desc)) return TRUE;
+ if (CheckDepthStencilCapability(adapter, adapter_format, check_format)) return TRUE;
/* If opengl can't process the format natively, the blitter may be able to convert it */
if (adapter->blitter->blit_supported(&adapter->gl_info, BLIT_OP_BLIT,
- NULL, WINED3DPOOL_DEFAULT, 0, check_format_desc,
- NULL, WINED3DPOOL_DEFAULT, 0, adapter_format_desc))
+ NULL, WINED3DPOOL_DEFAULT, 0, check_format,
+ NULL, WINED3DPOOL_DEFAULT, 0, adapter_format))
{
TRACE_(d3d_caps)("[OK]\n");
return TRUE;
@@ -3731,10 +3736,9 @@ static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
}
static BOOL CheckVertexTextureCapability(struct wined3d_adapter *adapter,
- const struct wined3d_format_desc *format_desc)
+ const struct wined3d_format *format)
{
- return adapter->gl_info.limits.vertex_samplers
- && (format_desc->Flags & WINED3DFMT_FLAG_VTF);
+ return adapter->gl_info.limits.vertex_samplers && (format->Flags & WINED3DFMT_FLAG_VTF);
}
static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
@@ -3744,8 +3748,8 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
IWineD3DImpl *This = (IWineD3DImpl *)iface;
struct wined3d_adapter *adapter = &This->adapters[Adapter];
const struct wined3d_gl_info *gl_info = &adapter->gl_info;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(CheckFormat, gl_info);
- const struct wined3d_format_desc *adapter_format_desc = getFormatDescEntry(AdapterFormat, gl_info);
+ const struct wined3d_format *format = wined3d_get_format(gl_info, CheckFormat);
+ const struct wined3d_format *adapter_format = wined3d_get_format(gl_info, AdapterFormat);
DWORD UsageCaps = 0;
TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
@@ -3785,7 +3789,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
return WINED3DERR_NOTAVAILABLE;
}
- if (!CheckTextureCapability(adapter, format_desc))
+ if (!CheckTextureCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3807,7 +3811,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_RENDERTARGET)
{
- if (!CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
+ if (!CheckRenderTargetCapability(adapter, adapter_format, format))
{
TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3821,7 +3825,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_FILTER)
{
- if (!CheckFilterCapability(adapter, format_desc))
+ if (!CheckFilterCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3831,7 +3835,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
{
- if (!CheckPostPixelShaderBlendingCapability(adapter, format_desc))
+ if (!CheckPostPixelShaderBlendingCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3841,7 +3845,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
{
- if (!CheckSrgbReadCapability(adapter, format_desc))
+ if (!CheckSrgbReadCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3851,7 +3855,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
{
- if (!CheckSrgbWriteCapability(adapter, format_desc))
+ if (!CheckSrgbWriteCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3861,7 +3865,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
{
- if (!CheckVertexTextureCapability(adapter, format_desc))
+ if (!CheckVertexTextureCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3871,7 +3875,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
{
- if (!CheckWrapAndMipCapability(adapter, format_desc))
+ if (!CheckWrapAndMipCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3886,7 +3890,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
* - WINED3DUSAGE_NONSECURE (d3d9ex)
* - WINED3DUSAGE_RENDERTARGET
*/
- if (!CheckSurfaceCapability(adapter, adapter_format_desc, format_desc, SurfaceType))
+ if (!CheckSurfaceCapability(adapter, adapter_format, format, SurfaceType))
{
TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3894,7 +3898,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
{
- if (!CheckDepthStencilCapability(adapter, adapter_format_desc, format_desc))
+ if (!CheckDepthStencilCapability(adapter, adapter_format, format))
{
TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3904,7 +3908,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_RENDERTARGET)
{
- if (!CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
+ if (!CheckRenderTargetCapability(adapter, adapter_format, format))
{
TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3914,7 +3918,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
{
- if (!CheckPostPixelShaderBlendingCapability(adapter, format_desc))
+ if (!CheckPostPixelShaderBlendingCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3941,7 +3945,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
return WINED3DERR_NOTAVAILABLE;
}
- if (!CheckTextureCapability(adapter, format_desc))
+ if (!CheckTextureCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3963,7 +3967,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_RENDERTARGET)
{
- if (!CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
+ if (!CheckRenderTargetCapability(adapter, adapter_format, format))
{
TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3977,7 +3981,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_FILTER)
{
- if (!CheckFilterCapability(adapter, format_desc))
+ if (!CheckFilterCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3987,7 +3991,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP)
{
- if (!CheckBumpMapCapability(adapter, format_desc))
+ if (!CheckBumpMapCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -3997,7 +4001,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
{
- if (!CheckPostPixelShaderBlendingCapability(adapter, format_desc))
+ if (!CheckPostPixelShaderBlendingCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4007,7 +4011,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
{
- if (!CheckSrgbReadCapability(adapter, format_desc))
+ if (!CheckSrgbReadCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4017,7 +4021,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
{
- if (!CheckSrgbWriteCapability(adapter, format_desc))
+ if (!CheckSrgbWriteCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4027,7 +4031,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
{
- if (!CheckVertexTextureCapability(adapter, format_desc))
+ if (!CheckVertexTextureCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4037,7 +4041,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
{
- if (!CheckWrapAndMipCapability(adapter, format_desc))
+ if (!CheckWrapAndMipCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4047,12 +4051,12 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
{
- if (!CheckDepthStencilCapability(adapter, adapter_format_desc, format_desc))
+ if (!CheckDepthStencilCapability(adapter, adapter_format, format))
{
TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
return WINED3DERR_NOTAVAILABLE;
}
- if ((format_desc->Flags & WINED3DFMT_FLAG_SHADOW) && !gl_info->supported[ARB_SHADOW])
+ if ((format->Flags & WINED3DFMT_FLAG_SHADOW) && !gl_info->supported[ARB_SHADOW])
{
TRACE_(d3d_caps)("[FAILED] - No shadow sampler support.\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4085,7 +4089,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
return WINED3DERR_NOTAVAILABLE;
}
- if (!CheckTextureCapability(adapter, format_desc))
+ if (!CheckTextureCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4155,7 +4159,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_FILTER)
{
- if (!CheckFilterCapability(adapter, format_desc))
+ if (!CheckFilterCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4165,7 +4169,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
{
- if (!CheckPostPixelShaderBlendingCapability(adapter, format_desc))
+ if (!CheckPostPixelShaderBlendingCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4175,7 +4179,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
{
- if (!CheckSrgbReadCapability(adapter, format_desc))
+ if (!CheckSrgbReadCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4185,7 +4189,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
{
- if (!CheckSrgbWriteCapability(adapter, format_desc))
+ if (!CheckSrgbWriteCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4195,7 +4199,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
{
- if (!CheckVertexTextureCapability(adapter, format_desc))
+ if (!CheckVertexTextureCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
return WINED3DERR_NOTAVAILABLE;
@@ -4205,7 +4209,7 @@ static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapt
if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
{
- if (!CheckWrapAndMipCapability(adapter, format_desc))
+ if (!CheckWrapAndMipCapability(adapter, format))
{
TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
return WINED3DERR_NOTAVAILABLE;
diff --git a/dlls/wined3d/drawprim.c b/dlls/wined3d/drawprim.c
index 5366e36..fc28d50 100644
--- a/dlls/wined3d/drawprim.c
+++ b/dlls/wined3d/drawprim.c
@@ -125,8 +125,8 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context
element = &si->elements[WINED3D_FFP_DIFFUSE];
diffuse = element->data + streamOffset[element->stream_idx];
- if (num_untracked_materials && element->format_desc->id != WINED3DFMT_B8G8R8A8_UNORM)
- FIXME("Implement diffuse color tracking from %s\n", debug_d3dformat(element->format_desc->id));
+ if (num_untracked_materials && element->format->id != WINED3DFMT_B8G8R8A8_UNORM)
+ FIXME("Implement diffuse color tracking from %s\n", debug_d3dformat(element->format->id));
}
else
{
@@ -141,13 +141,13 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context
/* special case where the fog density is stored in the specular alpha channel */
if (This->stateBlock->renderState[WINED3DRS_FOGENABLE]
&& (This->stateBlock->renderState[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE
- || si->elements[WINED3D_FFP_POSITION].format_desc->id == WINED3DFMT_R32G32B32A32_FLOAT)
+ || si->elements[WINED3D_FFP_POSITION].format->id == WINED3DFMT_R32G32B32A32_FLOAT)
&& This->stateBlock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
{
if (gl_info->supported[EXT_FOG_COORD])
{
- if (element->format_desc->id == WINED3DFMT_B8G8R8A8_UNORM) specular_fog = TRUE;
- else FIXME("Implement fog coordinates from %s\n", debug_d3dformat(element->format_desc->id));
+ if (element->format->id == WINED3DFMT_B8G8R8A8_UNORM) specular_fog = TRUE;
+ else FIXME("Implement fog coordinates from %s\n", debug_d3dformat(element->format->id));
}
else
{
@@ -243,7 +243,7 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context
ptr = texCoords[coord_idx] + (SkipnStrides * si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].stride);
texture_idx = This->texUnitMap[texture];
- multi_texcoord_funcs[si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].format_desc->emit_idx](
+ multi_texcoord_funcs[si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].format->emit_idx](
GL_TEXTURE0_ARB + texture_idx, ptr);
}
@@ -251,7 +251,7 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context
if (diffuse) {
const void *ptrToCoords = diffuse + SkipnStrides * si->elements[WINED3D_FFP_DIFFUSE].stride;
- diffuse_funcs[si->elements[WINED3D_FFP_DIFFUSE].format_desc->emit_idx](ptrToCoords);
+ diffuse_funcs[si->elements[WINED3D_FFP_DIFFUSE].format->emit_idx](ptrToCoords);
if (num_untracked_materials)
{
DWORD diffuseColor = ((const DWORD *)ptrToCoords)[0];
@@ -274,7 +274,7 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context
if (specular) {
const void *ptrToCoords = specular + SkipnStrides * si->elements[WINED3D_FFP_SPECULAR].stride;
- specular_funcs[si->elements[WINED3D_FFP_SPECULAR].format_desc->emit_idx](ptrToCoords);
+ specular_funcs[si->elements[WINED3D_FFP_SPECULAR].format->emit_idx](ptrToCoords);
if (specular_fog)
{
@@ -286,13 +286,13 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context
/* Normal -------------------------------- */
if (normal != NULL) {
const void *ptrToCoords = normal + SkipnStrides * si->elements[WINED3D_FFP_NORMAL].stride;
- normal_funcs[si->elements[WINED3D_FFP_NORMAL].format_desc->emit_idx](ptrToCoords);
+ normal_funcs[si->elements[WINED3D_FFP_NORMAL].format->emit_idx](ptrToCoords);
}
/* Position -------------------------------- */
if (position) {
const void *ptrToCoords = position + SkipnStrides * si->elements[WINED3D_FFP_POSITION].stride;
- position_funcs[si->elements[WINED3D_FFP_POSITION].format_desc->emit_idx](ptrToCoords);
+ position_funcs[si->elements[WINED3D_FFP_POSITION].format->emit_idx](ptrToCoords);
}
/* For non indexed mode, step onto next parts */
@@ -468,7 +468,7 @@ static void drawStridedSlowVs(IWineD3DDevice *iface, const struct wined3d_stream
si->elements[i].stride * SkipnStrides +
stateblock->streamOffset[si->elements[i].stream_idx];
- send_attribute(This, si->elements[i].format_desc->id, i, ptr);
+ send_attribute(This, si->elements[i].format->id, i, ptr);
}
SkipnStrides++;
}
@@ -539,7 +539,7 @@ static inline void drawStridedInstanced(IWineD3DDevice *iface, const struct wine
ptr += (ULONG_PTR)buffer_get_sysmem(vb, &This->adapter->gl_info);
}
- send_attribute(This, si->elements[instancedData[j]].format_desc->id, instancedData[j], ptr);
+ send_attribute(This, si->elements[instancedData[j]].format->id, instancedData[j], ptr);
}
glDrawElements(glPrimitiveType, numberOfVertices, idxSize == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT,
diff --git a/dlls/wined3d/resource.c b/dlls/wined3d/resource.c
index 11db1f8..4bdd415 100644
--- a/dlls/wined3d/resource.c
+++ b/dlls/wined3d/resource.c
@@ -28,7 +28,7 @@
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
HRESULT resource_init(IWineD3DResource *iface, WINED3DRESOURCETYPE resource_type,
- IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format_desc *format_desc,
+ IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format *format,
WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
{
struct IWineD3DResourceClass *resource = &((IWineD3DResourceImpl *)iface)->resource;
@@ -38,7 +38,7 @@ HRESULT resource_init(IWineD3DResource *iface, WINED3DRESOURCETYPE resource_type
resource->resourceType = resource_type;
resource->ref = 1;
resource->pool = pool;
- resource->format_desc = format_desc;
+ resource->format = format;
resource->usage = usage;
resource->size = size;
resource->priority = 0;
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index e14666c..e2d7f6b 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -2087,7 +2087,7 @@ void find_ps_compile_args(IWineD3DPixelShaderImpl *shader,
if (stateblock->renderState[WINED3DRS_SRGBWRITEENABLE])
{
IWineD3DSurfaceImpl *rt = device->render_targets[0];
- if(rt->resource.format_desc->Flags & WINED3DFMT_FLAG_SRGB_WRITE) args->srgb_correction = 1;
+ if(rt->resource.format->Flags & WINED3DFMT_FLAG_SRGB_WRITE) args->srgb_correction = 1;
}
args->np2_fixup = 0;
@@ -2101,9 +2101,9 @@ void find_ps_compile_args(IWineD3DPixelShaderImpl *shader,
args->color_fixup[i] = COLOR_FIXUP_IDENTITY;
continue;
}
- args->color_fixup[i] = texture->resource.format_desc->color_fixup;
+ args->color_fixup[i] = texture->resource.format->color_fixup;
- if (texture->resource.format_desc->Flags & WINED3DFMT_FLAG_SHADOW)
+ if (texture->resource.format->Flags & WINED3DFMT_FLAG_SHADOW)
args->shadow |= 1 << i;
/* Flag samplers that need NP2 texcoord fixup. */
diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index 437ea9d..2224247 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -244,7 +244,7 @@ static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock, struct
/* Disable blending in all cases even without pixelshaders. With blending on we could face a big performance penalty.
* The d3d9 visual test confirms the behavior. */
if (context->render_offscreen
- && !(target->resource.format_desc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING))
+ && !(target->resource.format->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING))
{
glDisable(GL_BLEND);
checkGLcall("glDisable GL_BLEND");
@@ -276,10 +276,10 @@ static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock, struct
* returns 1.0, so D3DBLEND_DESTALPHA is GL_ONE, and D3DBLEND_INVDESTALPHA is GL_ZERO
*/
case WINED3DBLEND_DESTALPHA :
- dstBlend = target->resource.format_desc->alpha_mask ? GL_DST_ALPHA : GL_ONE;
+ dstBlend = target->resource.format->alpha_mask ? GL_DST_ALPHA : GL_ONE;
break;
case WINED3DBLEND_INVDESTALPHA :
- dstBlend = target->resource.format_desc->alpha_mask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
+ dstBlend = target->resource.format->alpha_mask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
break;
case WINED3DBLEND_SRCALPHASAT :
@@ -318,10 +318,10 @@ static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock, struct
case WINED3DBLEND_SRCALPHASAT : srcBlend = GL_SRC_ALPHA_SATURATE; break;
case WINED3DBLEND_DESTALPHA :
- srcBlend = target->resource.format_desc->alpha_mask ? GL_DST_ALPHA : GL_ONE;
+ srcBlend = target->resource.format->alpha_mask ? GL_DST_ALPHA : GL_ONE;
break;
case WINED3DBLEND_INVDESTALPHA :
- srcBlend = target->resource.format_desc->alpha_mask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
+ srcBlend = target->resource.format->alpha_mask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
break;
case WINED3DBLEND_BOTHSRCALPHA : srcBlend = GL_SRC_ALPHA;
@@ -487,7 +487,7 @@ static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock, struct
/* The surface conversion does not do color keying conversion for surfaces that have an alpha
* channel on their own. Likewise, the alpha test shouldn't be set up for color keying if the
* surface has alpha bits */
- if (!surf->resource.format_desc->alpha_mask) enable_ckey = TRUE;
+ if (!surf->resource.format->alpha_mask) enable_ckey = TRUE;
}
}
}
@@ -3108,7 +3108,7 @@ void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)stateblock->textures[0];
IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[0];
- if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format_desc->alpha_mask)
+ if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask)
{
/* Color keying needs to pass alpha values from the texture through to have the alpha test work
* properly. On the other hand applications can still use texture combiners apparently. This code
@@ -3200,7 +3200,7 @@ static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock, s
set_texture_matrix(&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS], generated, context->last_was_rhw,
stateblock->device->strided_streams.use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coordIdx))
- ? stateblock->device->strided_streams.elements[WINED3D_FFP_TEXCOORD0 + coordIdx].format_desc->id
+ ? stateblock->device->strided_streams.elements[WINED3D_FFP_TEXCOORD0 + coordIdx].format->id
: WINED3DFMT_UNKNOWN,
stateblock->device->frag_pipe->ffp_proj_control);
@@ -3262,7 +3262,7 @@ static void loadTexCoords(const struct wined3d_gl_info *gl_info, IWineD3DStateBl
checkGLcall("glClientActiveTextureARB");
/* The coords to supply depend completely on the fvf / vertex shader */
- glTexCoordPointer(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
+ glTexCoordPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
} else {
@@ -4078,20 +4078,20 @@ static inline void loadNumberedArrays(IWineD3DStateBlockImpl *stateblock,
i, stream_info->elements[i].stride, vb->conversion_stride);
TRACE("Original offset %p, additional offset 0x%08x\n",
stream_info->elements[i].data, vb->conversion_shift[(DWORD_PTR)stream_info->elements[i].data]);
- TRACE("Opengl type %#x\n", stream_info->elements[i].format_desc->gl_vtx_type);
+ TRACE("Opengl type %#x\n", stream_info->elements[i].format->gl_vtx_type);
shift_index = ((DWORD_PTR)stream_info->elements[i].data + offset[stream_info->elements[i].stream_idx]);
shift_index = shift_index % stream_info->elements[i].stride;
- GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format_desc->gl_vtx_format,
- stream_info->elements[i].format_desc->gl_vtx_type,
- stream_info->elements[i].format_desc->gl_normalized,
+ GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format->gl_vtx_format,
+ stream_info->elements[i].format->gl_vtx_type,
+ stream_info->elements[i].format->gl_normalized,
vb->conversion_stride, stream_info->elements[i].data + vb->conversion_shift[shift_index]
+ stateblock->loadBaseVertexIndex * stream_info->elements[i].stride
+ offset[stream_info->elements[i].stream_idx]));
} else {
- GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format_desc->gl_vtx_format,
- stream_info->elements[i].format_desc->gl_vtx_type,
- stream_info->elements[i].format_desc->gl_normalized,
+ GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format->gl_vtx_format,
+ stream_info->elements[i].format->gl_vtx_type,
+ stream_info->elements[i].format->gl_normalized,
stream_info->elements[i].stride, stream_info->elements[i].data
+ stateblock->loadBaseVertexIndex * stream_info->elements[i].stride
+ offset[stream_info->elements[i].stream_idx]));
@@ -4115,7 +4115,7 @@ static inline void loadNumberedArrays(IWineD3DStateBlockImpl *stateblock,
if (context->numbered_array_mask & (1 << i)) unload_numbered_array(context, i);
- switch (stream_info->elements[i].format_desc->id)
+ switch (stream_info->elements[i].format->id)
{
case WINED3DFMT_R32_FLOAT:
GL_EXTCALL(glVertexAttrib1fvARB(i, (const GLfloat *)ptr));
@@ -4225,13 +4225,13 @@ static void loadVertexData(const struct wined3d_context *context, IWineD3DStateB
if (gl_info->supported[ARB_VERTEX_BLEND])
{
- TRACE("Blend %d %p %d\n", e->format_desc->component_count,
+ TRACE("Blend %u %p %u\n", e->format->component_count,
e->data + stateblock->loadBaseVertexIndex * e->stride, e->stride + offset[e->stream_idx]);
glEnableClientState(GL_WEIGHT_ARRAY_ARB);
checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
- GL_EXTCALL(glVertexBlendARB(e->format_desc->component_count + 1));
+ GL_EXTCALL(glVertexBlendARB(e->format->component_count + 1));
if (curVBO != e->buffer_object)
{
@@ -4241,11 +4241,11 @@ static void loadVertexData(const struct wined3d_context *context, IWineD3DStateB
}
TRACE("glWeightPointerARB(%#x, %#x, %#x, %p);\n",
- e->format_desc->gl_vtx_format,
- e->format_desc->gl_vtx_type,
+ e->format->gl_vtx_format,
+ e->format->gl_vtx_type,
e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
- GL_EXTCALL(glWeightPointerARB(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
+ GL_EXTCALL(glWeightPointerARB(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]));
checkGLcall("glWeightPointerARB");
@@ -4305,17 +4305,17 @@ static void loadVertexData(const struct wined3d_context *context, IWineD3DStateB
*/
if (!e->buffer_object)
{
- TRACE("glVertexPointer(3, %#x, %#x, %p);\n", e->format_desc->gl_vtx_type, e->stride,
+ TRACE("glVertexPointer(3, %#x, %#x, %p);\n", e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
- glVertexPointer(3 /* min(e->format_desc->gl_vtx_format, 3) */, e->format_desc->gl_vtx_type, e->stride,
+ glVertexPointer(3 /* min(e->format->gl_vtx_format, 3) */, e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
}
else
{
TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n",
- e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
+ e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
- glVertexPointer(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
+ glVertexPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
}
checkGLcall("glVertexPointer(...)");
@@ -4334,9 +4334,9 @@ static void loadVertexData(const struct wined3d_context *context, IWineD3DStateB
curVBO = e->buffer_object;
}
- TRACE("glNormalPointer(%#x, %#x, %p);\n", e->format_desc->gl_vtx_type, e->stride,
+ TRACE("glNormalPointer(%#x, %#x, %p);\n", e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
- glNormalPointer(e->format_desc->gl_vtx_type, e->stride,
+ glNormalPointer(e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
checkGLcall("glNormalPointer(...)");
glEnableClientState(GL_NORMAL_ARRAY);
@@ -4367,9 +4367,9 @@ static void loadVertexData(const struct wined3d_context *context, IWineD3DStateB
}
TRACE("glColorPointer(%#x, %#x %#x, %p);\n",
- e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
+ e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
- glColorPointer(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
+ glColorPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
glEnableClientState(GL_COLOR_ARRAY);
@@ -4388,8 +4388,8 @@ static void loadVertexData(const struct wined3d_context *context, IWineD3DStateB
e = &si->elements[WINED3D_FFP_SPECULAR];
if (gl_info->supported[EXT_SECONDARY_COLOR])
{
- GLenum type = e->format_desc->gl_vtx_type;
- GLint format = e->format_desc->gl_vtx_format;
+ GLenum type = e->format->gl_vtx_type;
+ GLint format = e->format->gl_vtx_format;
if (curVBO != e->buffer_object)
{
diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c
index 1cc5dbd..f7cca8f 100644
--- a/dlls/wined3d/surface.c
+++ b/dlls/wined3d/surface.c
@@ -350,7 +350,7 @@ HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type,
WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
{
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id, gl_info);
+ const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
void (*cleanup)(IWineD3DSurfaceImpl *This);
unsigned int resource_size;
HRESULT hr;
@@ -363,7 +363,7 @@ HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type,
/* FIXME: Check that the format is supported by the device. */
- resource_size = wined3d_format_calculate_size(format_desc, alignment, width, height);
+ resource_size = wined3d_format_calculate_size(format, alignment, width, height);
/* Look at the implementation and set the correct Vtable. */
switch (surface_type)
@@ -384,7 +384,7 @@ HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type,
}
hr = resource_init((IWineD3DResource *)surface, WINED3DRTYPE_SURFACE,
- device, resource_size, usage, format_desc, pool, parent, parent_ops);
+ device, resource_size, usage, format, pool, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize resource, returning %#x.\n", hr);
@@ -554,7 +554,7 @@ static BOOL primary_render_target_is_p8(IWineD3DDeviceImpl *device)
{
IWineD3DSurfaceImpl *render_target = device->render_targets[0];
if ((render_target->resource.usage & WINED3DUSAGE_RENDERTARGET)
- && (render_target->resource.format_desc->id == WINED3DFMT_P8_UINT))
+ && (render_target->resource.format->id == WINED3DFMT_P8_UINT))
return TRUE;
}
return FALSE;
@@ -565,21 +565,21 @@ static BOOL primary_render_target_is_p8(IWineD3DDeviceImpl *device)
/* Context activation is done by the caller. */
static void surface_download_data(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info)
{
- const struct wined3d_format_desc *format_desc = This->resource.format_desc;
+ const struct wined3d_format *format = This->resource.format;
/* Only support read back of converted P8 surfaces */
- if (This->Flags & SFLAG_CONVERTED && format_desc->id != WINED3DFMT_P8_UINT)
+ if (This->Flags & SFLAG_CONVERTED && format->id != WINED3DFMT_P8_UINT)
{
- FIXME("Readback conversion not supported for format %s.\n", debug_d3dformat(format_desc->id));
+ FIXME("Readback conversion not supported for format %s.\n", debug_d3dformat(format->id));
return;
}
ENTER_GL();
- if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
+ if (format->Flags & WINED3DFMT_FLAG_COMPRESSED)
{
TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p.\n",
- This, This->texture_level, format_desc->glFormat, format_desc->glType,
+ This, This->texture_level, format->glFormat, format->glType,
This->resource.allocatedMemory);
if (This->Flags & SFLAG_PBO)
@@ -601,21 +601,21 @@ static void surface_download_data(IWineD3DSurfaceImpl *This, const struct wined3
LEAVE_GL();
} else {
void *mem;
- GLenum format = format_desc->glFormat;
- GLenum type = format_desc->glType;
+ GLenum gl_format = format->glFormat;
+ GLenum gl_type = format->glType;
int src_pitch = 0;
int dst_pitch = 0;
/* In case of P8 the index is stored in the alpha component if the primary render target uses P8 */
- if (format_desc->id == WINED3DFMT_P8_UINT && primary_render_target_is_p8(This->resource.device))
+ if (format->id == WINED3DFMT_P8_UINT && primary_render_target_is_p8(This->resource.device))
{
- format = GL_ALPHA;
- type = GL_UNSIGNED_BYTE;
+ gl_format = GL_ALPHA;
+ gl_type = GL_UNSIGNED_BYTE;
}
if (This->Flags & SFLAG_NONPOW2) {
unsigned char alignment = This->resource.device->surface_alignment;
- src_pitch = format_desc->byte_count * This->pow2Width;
+ src_pitch = format->byte_count * This->pow2Width;
dst_pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This);
src_pitch = (src_pitch + alignment - 1) & ~(alignment - 1);
mem = HeapAlloc(GetProcessHeap(), 0, src_pitch * This->pow2Height);
@@ -624,19 +624,19 @@ static void surface_download_data(IWineD3DSurfaceImpl *This, const struct wined3
}
TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n",
- This, This->texture_level, format, type, mem);
+ This, This->texture_level, gl_format, gl_type, mem);
if(This->Flags & SFLAG_PBO) {
GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
checkGLcall("glBindBufferARB");
- glGetTexImage(This->texture_target, This->texture_level, format, type, NULL);
+ glGetTexImage(This->texture_target, This->texture_level, gl_format, gl_type, NULL);
checkGLcall("glGetTexImage");
GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
checkGLcall("glBindBufferARB");
} else {
- glGetTexImage(This->texture_target, This->texture_level, format, type, mem);
+ glGetTexImage(This->texture_target, This->texture_level, gl_format, gl_type, mem);
checkGLcall("glGetTexImage");
}
LEAVE_GL();
@@ -717,7 +717,7 @@ static void surface_download_data(IWineD3DSurfaceImpl *This, const struct wined3
* correct texture. */
/* Context activation is done by the caller. */
static void surface_upload_data(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
- const struct wined3d_format_desc *format_desc, BOOL srgb, const GLvoid *data)
+ const struct wined3d_format *format, BOOL srgb, const GLvoid *data)
{
GLsizei width = This->currentDesc.Width;
GLsizei height = This->currentDesc.Height;
@@ -725,23 +725,23 @@ static void surface_upload_data(IWineD3DSurfaceImpl *This, const struct wined3d_
if (srgb)
{
- internal = format_desc->glGammaInternal;
+ internal = format->glGammaInternal;
}
else if (This->resource.usage & WINED3DUSAGE_RENDERTARGET && surface_is_offscreen(This))
{
- internal = format_desc->rtInternal;
+ internal = format->rtInternal;
}
else
{
- internal = format_desc->glInternal;
+ internal = format->glInternal;
}
TRACE("This %p, internal %#x, width %d, height %d, format %#x, type %#x, data %p.\n",
- This, internal, width, height, format_desc->glFormat, format_desc->glType, data);
+ This, internal, width, height, format->glFormat, format->glType, data);
TRACE("target %#x, level %u, resource size %u.\n",
This->texture_target, This->texture_level, This->resource.size);
- if (format_desc->heightscale != 1.0f && format_desc->heightscale != 0.0f) height *= format_desc->heightscale;
+ if (format->heightscale != 1.0f && format->heightscale != 0.0f) height *= format->heightscale;
ENTER_GL();
@@ -754,7 +754,7 @@ static void surface_upload_data(IWineD3DSurfaceImpl *This, const struct wined3d_
data = NULL;
}
- if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
+ if (format->Flags & WINED3DFMT_FLAG_COMPRESSED)
{
TRACE("Calling glCompressedTexSubImage2DARB.\n");
@@ -767,7 +767,7 @@ static void surface_upload_data(IWineD3DSurfaceImpl *This, const struct wined3d_
TRACE("Calling glTexSubImage2D.\n");
glTexSubImage2D(This->texture_target, This->texture_level,
- 0, 0, width, height, format_desc->glFormat, format_desc->glType, data);
+ 0, 0, width, height, format->glFormat, format->glType, data);
checkGLcall("glTexSubImage2D");
}
@@ -795,7 +795,7 @@ static void surface_upload_data(IWineD3DSurfaceImpl *This, const struct wined3d_
* the correct texture. */
/* Context activation is done by the caller. */
static void surface_allocate_surface(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
- const struct wined3d_format_desc *format_desc, BOOL srgb)
+ const struct wined3d_format *format, BOOL srgb)
{
BOOL enable_client_storage = FALSE;
GLsizei width = This->pow2Width;
@@ -805,22 +805,22 @@ static void surface_allocate_surface(IWineD3DSurfaceImpl *This, const struct win
if (srgb)
{
- internal = format_desc->glGammaInternal;
+ internal = format->glGammaInternal;
}
else if (This->resource.usage & WINED3DUSAGE_RENDERTARGET && surface_is_offscreen(This))
{
- internal = format_desc->rtInternal;
+ internal = format->rtInternal;
}
else
{
- internal = format_desc->glInternal;
+ internal = format->glInternal;
}
- if (format_desc->heightscale != 1.0f && format_desc->heightscale != 0.0f) height *= format_desc->heightscale;
+ if (format->heightscale != 1.0f && format->heightscale != 0.0f) height *= format->heightscale;
TRACE("(%p) : Creating surface (target %#x) level %d, d3d format %s, internal format %#x, width %d, height %d, gl format %#x, gl type=%#x\n",
- This, This->texture_target, This->texture_level, debug_d3dformat(format_desc->id),
- internal, width, height, format_desc->glFormat, format_desc->glType);
+ This, This->texture_target, This->texture_level, debug_d3dformat(format->id),
+ internal, width, height, format->glFormat, format->glType);
ENTER_GL();
@@ -847,7 +847,7 @@ static void surface_allocate_surface(IWineD3DSurfaceImpl *This, const struct win
}
}
- if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED && mem)
+ if (format->Flags & WINED3DFMT_FLAG_COMPRESSED && mem)
{
GL_EXTCALL(glCompressedTexImage2DARB(This->texture_target, This->texture_level,
internal, width, height, 0, This->resource.size, mem));
@@ -856,7 +856,7 @@ static void surface_allocate_surface(IWineD3DSurfaceImpl *This, const struct win
else
{
glTexImage2D(This->texture_target, This->texture_level,
- internal, width, height, 0, format_desc->glFormat, format_desc->glType, mem);
+ internal, width, height, 0, format->glFormat, format->glType, mem);
checkGLcall("glTexImage2D");
}
@@ -908,7 +908,7 @@ void surface_set_compatible_renderbuffer(IWineD3DSurfaceImpl *surface, unsigned
gl_info->fbo_ops.glGenRenderbuffers(1, &renderbuffer);
gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER,
- surface->resource.format_desc->glInternal, width, height);
+ surface->resource.format->glInternal, width, height);
entry = HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t));
entry->width = width;
@@ -989,7 +989,7 @@ void surface_add_dirty_rect(IWineD3DSurfaceImpl *surface, const RECT *dirty_rect
static BOOL surface_convert_color_to_float(IWineD3DSurfaceImpl *surface, DWORD color, WINED3DCOLORVALUE *float_color)
{
- const struct wined3d_format_desc *format = surface->resource.format_desc;
+ const struct wined3d_format *format = surface->resource.format;
IWineD3DDeviceImpl *device = surface->resource.device;
switch (format->id)
@@ -1083,8 +1083,8 @@ void surface_internal_preload(IWineD3DSurfaceImpl *surface, enum WINED3DSRGB srg
if (!device->isInDraw) context = context_acquire(device, NULL);
- if (surface->resource.format_desc->id == WINED3DFMT_P8_UINT
- || surface->resource.format_desc->id == WINED3DFMT_P8_UINT_A8_UNORM)
+ if (surface->resource.format->id == WINED3DFMT_P8_UINT
+ || surface->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
{
if (palette9_changed(surface))
{
@@ -1308,7 +1308,7 @@ static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, v
}
/* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
- switch (This->resource.format_desc->id)
+ switch (This->resource.format->id)
{
case WINED3DFMT_P8_UINT:
{
@@ -1318,7 +1318,7 @@ static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, v
fmt = GL_ALPHA;
type = GL_UNSIGNED_BYTE;
mem = dest;
- bpp = This->resource.format_desc->byte_count;
+ bpp = This->resource.format->byte_count;
} else {
/* GL can't return palettized data, so read ARGB pixels into a
* separate block of memory and convert them into palettized format
@@ -1338,16 +1338,16 @@ static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, v
LEAVE_GL();
return;
}
- bpp = This->resource.format_desc->byte_count * 3;
+ bpp = This->resource.format->byte_count * 3;
}
}
break;
default:
mem = dest;
- fmt = This->resource.format_desc->glFormat;
- type = This->resource.format_desc->glType;
- bpp = This->resource.format_desc->byte_count;
+ fmt = This->resource.format->glFormat;
+ type = This->resource.format->glType;
+ bpp = This->resource.format->byte_count;
}
if(This->Flags & SFLAG_PBO) {
@@ -1417,7 +1417,7 @@ static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, v
row = HeapAlloc(GetProcessHeap(), 0, len);
if(!row) {
ERR("Out of memory\n");
- if (This->resource.format_desc->id == WINED3DFMT_P8_UINT) HeapFree(GetProcessHeap(), 0, mem);
+ if (This->resource.format->id == WINED3DFMT_P8_UINT) HeapFree(GetProcessHeap(), 0, mem);
LEAVE_GL();
return;
}
@@ -1448,7 +1448,7 @@ static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, v
* the same color but we have no choice.
* In case of P8 render targets, the index is stored in the alpha component so no conversion is needed.
*/
- if (This->resource.format_desc->id == WINED3DFMT_P8_UINT && !primary_render_target_is_p8(device))
+ if (This->resource.format->id == WINED3DFMT_P8_UINT && !primary_render_target_is_p8(device))
{
const PALETTEENTRY *pal = NULL;
DWORD width = pitch / 3;
@@ -1532,16 +1532,16 @@ static void surface_prepare_texture_internal(IWineD3DSurfaceImpl *surface,
{
DWORD alloc_flag = srgb ? SFLAG_SRGBALLOCATED : SFLAG_ALLOCATED;
CONVERT_TYPES convert;
- struct wined3d_format_desc desc;
+ struct wined3d_format format;
if (surface->Flags & alloc_flag) return;
- d3dfmt_get_conv(surface, TRUE, TRUE, &desc, &convert);
- if(convert != NO_CONVERSION || desc.convert) surface->Flags |= SFLAG_CONVERTED;
+ d3dfmt_get_conv(surface, TRUE, TRUE, &format, &convert);
+ if (convert != NO_CONVERSION || format.convert) surface->Flags |= SFLAG_CONVERTED;
else surface->Flags &= ~SFLAG_CONVERTED;
surface_bind_and_dirtify(surface, srgb);
- surface_allocate_surface(surface, gl_info, &desc, srgb);
+ surface_allocate_surface(surface, gl_info, &format, srgb);
surface->Flags |= alloc_flag;
}
@@ -2043,8 +2043,8 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHD
return hr;
}
- if (This->resource.format_desc->id == WINED3DFMT_P8_UINT
- || This->resource.format_desc->id == WINED3DFMT_P8_UINT_A8_UNORM)
+ if (This->resource.format->id == WINED3DFMT_P8_UINT
+ || This->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
{
/* GetDC on palettized formats is unsupported in D3D9, and the method is missing in
D3D8, so this should only be used for DX <=7 surfaces (with non-device palettes) */
@@ -2111,7 +2111,8 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC
IWineD3DSurface Internal (No mapping to directx api) parts follow
****************************************************** */
-HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_texturing, struct wined3d_format_desc *desc, CONVERT_TYPES *convert)
+HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck,
+ BOOL use_texturing, struct wined3d_format *format, CONVERT_TYPES *convert)
{
BOOL colorkey_active = need_alpha_ck && (This->CKeyFlags & WINEDDSD_CKSRCBLT);
IWineD3DDeviceImpl *device = This->resource.device;
@@ -2120,28 +2121,25 @@ HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_
/* Copy the default values from the surface. Below we might perform fixups */
/* TODO: get rid of color keying desc fixups by using e.g. a table. */
- *desc = *This->resource.format_desc;
+ *format = *This->resource.format;
*convert = NO_CONVERSION;
/* Ok, now look if we have to do any conversion */
- switch (This->resource.format_desc->id)
+ switch (This->resource.format->id)
{
case WINED3DFMT_P8_UINT:
- /* ****************
- Paletted Texture
- **************** */
-
- /* Below the call to blit_supported is disabled for Wine 1.2 because the function isn't operating correctly yet.
- * At the moment 8-bit blits are handled in software and if certain GL extensions are around, surface conversion
- * is performed at upload time. The blit_supported call recognizes it as a destination fixup. This type of upload 'fixup'
- * and 8-bit to 8-bit blits need to be handled by the blit_shader.
- * TODO: get rid of this #if 0
- */
+ /* Below the call to blit_supported is disabled for Wine 1.2
+ * because the function isn't operating correctly yet. At the
+ * moment 8-bit blits are handled in software and if certain GL
+ * extensions are around, surface conversion is performed at
+ * upload time. The blit_supported call recognizes it as a
+ * destination fixup. This type of upload 'fixup' and 8-bit to
+ * 8-bit blits need to be handled by the blit_shader.
+ * TODO: get rid of this #if 0. */
#if 0
blit_supported = device->blitter->blit_supported(&device->adapter->gl_info, BLIT_OP_BLIT,
- &rect, This->resource.usage, This->resource.pool,
- This->resource.format_desc, &rect, This->resource.usage,
- This->resource.pool, This->resource.format_desc);
+ &rect, This->resource.usage, This->resource.pool, This->resource.format,
+ &rect, This->resource.usage, This->resource.pool, This->resource.format);
#endif
blit_supported = gl_info->supported[EXT_PALETTED_TEXTURE] || gl_info->supported[ARB_FRAGMENT_PROGRAM];
@@ -2154,15 +2152,14 @@ HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_
if (!((blit_supported && device->render_targets && This == device->render_targets[0]))
|| colorkey_active || !use_texturing)
{
- desc->glFormat = GL_RGBA;
- desc->glInternal = GL_RGBA;
- desc->glType = GL_UNSIGNED_BYTE;
- desc->conv_byte_count = 4;
- if(colorkey_active) {
+ format->glFormat = GL_RGBA;
+ format->glInternal = GL_RGBA;
+ format->glType = GL_UNSIGNED_BYTE;
+ format->conv_byte_count = 4;
+ if (colorkey_active)
*convert = CONVERT_PALETTED_CK;
- } else {
+ else
*convert = CONVERT_PALETTED;
- }
}
break;
@@ -2178,42 +2175,46 @@ HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_
break;
case WINED3DFMT_B5G6R5_UNORM:
- if (colorkey_active) {
+ if (colorkey_active)
+ {
*convert = CONVERT_CK_565;
- desc->glFormat = GL_RGBA;
- desc->glInternal = GL_RGB5_A1;
- desc->glType = GL_UNSIGNED_SHORT_5_5_5_1;
- desc->conv_byte_count = 2;
+ format->glFormat = GL_RGBA;
+ format->glInternal = GL_RGB5_A1;
+ format->glType = GL_UNSIGNED_SHORT_5_5_5_1;
+ format->conv_byte_count = 2;
}
break;
case WINED3DFMT_B5G5R5X1_UNORM:
- if (colorkey_active) {
+ if (colorkey_active)
+ {
*convert = CONVERT_CK_5551;
- desc->glFormat = GL_BGRA;
- desc->glInternal = GL_RGB5_A1;
- desc->glType = GL_UNSIGNED_SHORT_1_5_5_5_REV;
- desc->conv_byte_count = 2;
+ format->glFormat = GL_BGRA;
+ format->glInternal = GL_RGB5_A1;
+ format->glType = GL_UNSIGNED_SHORT_1_5_5_5_REV;
+ format->conv_byte_count = 2;
}
break;
case WINED3DFMT_B8G8R8_UNORM:
- if (colorkey_active) {
+ if (colorkey_active)
+ {
*convert = CONVERT_CK_RGB24;
- desc->glFormat = GL_RGBA;
- desc->glInternal = GL_RGBA8;
- desc->glType = GL_UNSIGNED_INT_8_8_8_8;
- desc->conv_byte_count = 4;
+ format->glFormat = GL_RGBA;
+ format->glInternal = GL_RGBA8;
+ format->glType = GL_UNSIGNED_INT_8_8_8_8;
+ format->conv_byte_count = 4;
}
break;
case WINED3DFMT_B8G8R8X8_UNORM:
- if (colorkey_active) {
+ if (colorkey_active)
+ {
*convert = CONVERT_RGB32_888;
- desc->glFormat = GL_RGBA;
- desc->glInternal = GL_RGBA8;
- desc->glType = GL_UNSIGNED_INT_8_8_8_8;
- desc->conv_byte_count = 4;
+ format->glFormat = GL_RGBA;
+ format->glInternal = GL_RGBA8;
+ format->glType = GL_UNSIGNED_INT_8_8_8_8;
+ format->conv_byte_count = 4;
}
break;
@@ -2462,8 +2463,8 @@ BOOL palette9_changed(IWineD3DSurfaceImpl *This)
{
IWineD3DDeviceImpl *device = This->resource.device;
- if (This->palette || (This->resource.format_desc->id != WINED3DFMT_P8_UINT
- && This->resource.format_desc->id != WINED3DFMT_P8_UINT_A8_UNORM))
+ if (This->palette || (This->resource.format->id != WINED3DFMT_P8_UINT
+ && This->resource.format->id != WINED3DFMT_P8_UINT_A8_UNORM))
{
/* If a ddraw-style palette is attached assume no d3d9 palette change.
* Also the palette isn't interesting if the surface format isn't P8 or A8P8
@@ -2601,8 +2602,8 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface *iface, enum
hr = IWineD3DBaseSurfaceImpl_SetFormat(iface, format);
if(SUCCEEDED(hr)) {
This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
- TRACE("(%p) : glFormat %d, glFormatInternal %d, glType %d\n", This, This->resource.format_desc->glFormat,
- This->resource.format_desc->glInternal, This->resource.format_desc->glType);
+ TRACE("(%p) : glFormat %d, glFormatInternal %d, glType %d\n", This, This->resource.format->glFormat,
+ This->resource.format->glInternal, This->resource.format->glType);
}
return hr;
}
@@ -3193,10 +3194,8 @@ static void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl *dst_surface, IWine
/* Until the blit_shader is ready, define some prototypes here. */
static BOOL fbo_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
- const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
- const struct wined3d_format_desc *src_format_desc,
- const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
- const struct wined3d_format_desc *dst_format_desc);
+ const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
+ const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format);
/* Front buffer coordinates are always full screen coordinates, but our GL
* drawable is limited to the window's client area. The sysmem and texture
@@ -3360,7 +3359,7 @@ HRESULT surface_color_fill(IWineD3DSurfaceImpl *s, const RECT *rect, const WINED
const struct blit_shader *blitter;
blitter = wined3d_select_blitter(&device->adapter->gl_info, BLIT_OP_COLOR_FILL,
- NULL, 0, 0, NULL, rect, s->resource.usage, s->resource.pool, s->resource.format_desc);
+ NULL, 0, 0, NULL, rect, s->resource.usage, s->resource.pool, s->resource.format);
if (!blitter)
{
FIXME("No blitter is capable of performing the requested color fill operation.\n");
@@ -3547,8 +3546,8 @@ static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *dst_surface,
BOOL stretchx;
/* P8 read back is not implemented */
- if (src_surface->resource.format_desc->id == WINED3DFMT_P8_UINT
- || dst_surface->resource.format_desc->id == WINED3DFMT_P8_UINT)
+ if (src_surface->resource.format->id == WINED3DFMT_P8_UINT
+ || dst_surface->resource.format->id == WINED3DFMT_P8_UINT)
{
TRACE("P8 read back not supported by frame buffer to texture blit\n");
return WINED3DERR_INVALIDCALL;
@@ -3582,8 +3581,8 @@ static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *dst_surface,
* backends.
*/
if (fbo_blit_supported(gl_info, BLIT_OP_BLIT,
- &src_rect, src_surface->resource.usage, src_surface->resource.pool, src_surface->resource.format_desc,
- &dst_rect, dst_surface->resource.usage, dst_surface->resource.pool, dst_surface->resource.format_desc))
+ &src_rect, src_surface->resource.usage, src_surface->resource.pool, src_surface->resource.format,
+ &dst_rect, dst_surface->resource.usage, dst_surface->resource.pool, dst_surface->resource.format))
{
surface_blt_fbo(device, Filter,
src_surface, SFLAG_INDRAWABLE, &src_rect,
@@ -3625,9 +3624,9 @@ static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *dst_surface,
if (!(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE))
&& fbo_blit_supported(gl_info, BLIT_OP_BLIT,
&src_rect, src_surface->resource.usage, src_surface->resource.pool,
- src_surface->resource.format_desc,
+ src_surface->resource.format,
&dst_rect, dst_surface->resource.usage, dst_surface->resource.pool,
- dst_surface->resource.format_desc))
+ dst_surface->resource.format))
{
TRACE("Using surface_blt_fbo.\n");
/* The source is always a texture, but never the currently active render target, and the texture
@@ -3642,9 +3641,9 @@ static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *dst_surface,
if (!(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE))
&& arbfp_blit.blit_supported(gl_info, BLIT_OP_BLIT,
&src_rect, src_surface->resource.usage, src_surface->resource.pool,
- src_surface->resource.format_desc,
+ src_surface->resource.format,
&dst_rect, dst_surface->resource.usage, dst_surface->resource.pool,
- dst_surface->resource.format_desc))
+ dst_surface->resource.format))
{
return arbfp_blit_surface(device, src_surface, &src_rect, dst_surface, &dst_rect, BLIT_OP_BLIT, Filter);
}
@@ -3678,8 +3677,8 @@ static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *dst_surface,
surface_translate_frontbuffer_coords(dst_surface, context->win_handle, &dst_rect);
if (!device->blitter->blit_supported(gl_info, BLIT_OP_BLIT,
- &src_rect, src_surface->resource.usage, src_surface->resource.pool, src_surface->resource.format_desc,
- &dst_rect, dst_surface->resource.usage, dst_surface->resource.pool, dst_surface->resource.format_desc))
+ &src_rect, src_surface->resource.usage, src_surface->resource.pool, src_surface->resource.format,
+ &dst_rect, dst_surface->resource.usage, dst_surface->resource.pool, dst_surface->resource.format))
{
FIXME("Unsupported blit operation falling back to software\n");
return WINED3DERR_INVALIDCALL;
@@ -3770,7 +3769,7 @@ static HRESULT IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl *This, const RECT *D
if (Flags & WINEDDBLT_DEPTHFILL)
{
- switch (This->resource.format_desc->id)
+ switch (This->resource.format->id)
{
case WINED3DFMT_D16_UNORM:
depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000ffff;
@@ -3787,7 +3786,7 @@ static HRESULT IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl *This, const RECT *D
break;
default:
depth = 0.0f;
- ERR("Unexpected format for depth fill: %s.\n", debug_d3dformat(This->resource.format_desc->id));
+ ERR("Unexpected format for depth fill: %s.\n", debug_d3dformat(This->resource.format->id));
}
return IWineD3DDevice_Clear((IWineD3DDevice *)device, DestRect ? 1 : 0, DestRect,
@@ -3913,8 +3912,8 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_RealizePalette(IWineD3DSurface *iface)
if (!pal) return WINED3D_OK;
- if (This->resource.format_desc->id == WINED3DFMT_P8_UINT
- || This->resource.format_desc->id == WINED3DFMT_P8_UINT_A8_UNORM)
+ if (This->resource.format->id == WINED3DFMT_P8_UINT
+ || This->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
{
if (This->resource.usage & WINED3DUSAGE_RENDERTARGET)
{
@@ -3980,9 +3979,10 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface *iface) {
This->pow2Width = pow2Width;
This->pow2Height = pow2Height;
- if (pow2Width > This->currentDesc.Width || pow2Height > This->currentDesc.Height) {
- /** TODO: add support for non power two compressed textures **/
- if (This->resource.format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
+ if (pow2Width > This->currentDesc.Width || pow2Height > This->currentDesc.Height)
+ {
+ /* TODO: Add support for non power two compressed textures. */
+ if (This->resource.format->Flags & WINED3DFMT_FLAG_COMPRESSED)
{
FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
This, This->currentDesc.Width, This->currentDesc.Height);
@@ -4021,7 +4021,7 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface *iface) {
doesn't work in combination with ARB_TEXTURE_RECTANGLE.
*/
if (This->Flags & SFLAG_NONPOW2 && gl_info->supported[ARB_TEXTURE_RECTANGLE]
- && !(This->resource.format_desc->id == WINED3DFMT_P8_UINT
+ && !(This->resource.format->id == WINED3DFMT_P8_UINT
&& gl_info->supported[EXT_PALETTED_TEXTURE]
&& wined3d_settings.rendertargetlock_mode == RTL_READTEX))
{
@@ -4185,7 +4185,7 @@ void surface_load_ds_location(IWineD3DSurfaceImpl *surface, struct wined3d_conte
bind_target = GL_TEXTURE_2D;
}
glBindTexture(bind_target, device->depth_blt_texture);
- glCopyTexImage2D(bind_target, surface->texture_level, surface->resource.format_desc->glInternal,
+ glCopyTexImage2D(bind_target, surface->texture_level, surface->resource.format->glInternal,
0, 0, surface->currentDesc.Width, surface->currentDesc.Height, 0);
glTexParameteri(bind_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(bind_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -4367,7 +4367,7 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
IWineD3DDeviceImpl *device = surface->resource.device;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
BOOL drawable_read_ok = surface_is_offscreen(surface);
- struct wined3d_format_desc desc;
+ struct wined3d_format format;
CONVERT_TYPES convert;
int width, pitch, outpitch;
BYTE *mem;
@@ -4462,7 +4462,7 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
}
d3dfmt_get_conv(surface, FALSE /* We need color keying */,
- FALSE /* We won't use textures */, &desc, &convert);
+ FALSE /* We won't use textures */, &format, &convert);
/* The width is in 'length' not in bytes */
width = surface->currentDesc.Width;
@@ -4484,7 +4484,7 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
if ((convert != NO_CONVERSION) && surface->resource.allocatedMemory)
{
int height = surface->currentDesc.Height;
- byte_count = desc.conv_byte_count;
+ byte_count = format.conv_byte_count;
/* Stick to the alignment for the converted surface too, makes it easier to load the surface */
outpitch = width * byte_count;
@@ -4504,10 +4504,10 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
{
surface->Flags &= ~SFLAG_CONVERTED;
mem = surface->resource.allocatedMemory;
- byte_count = desc.byte_count;
+ byte_count = format.byte_count;
}
- flush_to_framebuffer_drawpixels(surface, desc.glFormat, desc.glType, byte_count, mem);
+ flush_to_framebuffer_drawpixels(surface, format.glFormat, format.glType, byte_count, mem);
/* Don't delete PBO memory */
if ((mem != surface->resource.allocatedMemory) && !(surface->Flags & SFLAG_PBO))
@@ -4523,10 +4523,10 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
read_from_framebuffer_texture(surface, flag == SFLAG_INSRGBTEX);
}
else if (surface->Flags & (SFLAG_INSRGBTEX | SFLAG_INTEXTURE)
- && (surface->resource.format_desc->Flags & attach_flags) == attach_flags
+ && (surface->resource.format->Flags & attach_flags) == attach_flags
&& fbo_blit_supported(gl_info, BLIT_OP_BLIT,
- NULL, surface->resource.usage, surface->resource.pool, surface->resource.format_desc,
- NULL, surface->resource.usage, surface->resource.pool, surface->resource.format_desc))
+ NULL, surface->resource.usage, surface->resource.pool, surface->resource.format,
+ NULL, surface->resource.usage, surface->resource.pool, surface->resource.format))
{
DWORD src_location = flag == SFLAG_INSRGBTEX ? SFLAG_INTEXTURE : SFLAG_INSRGBTEX;
RECT rect = {0, 0, surface->currentDesc.Width, surface->currentDesc.Height};
@@ -4541,7 +4541,7 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
struct wined3d_context *context = NULL;
d3dfmt_get_conv(surface, TRUE /* We need color keying */,
- TRUE /* We will use textures */, &desc, &convert);
+ TRUE /* We will use textures */, &format, &convert);
if (srgb)
{
@@ -4586,19 +4586,19 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
/* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
* but it isn't set (yet) in all cases it is getting called. */
- if ((convert != NO_CONVERSION || desc.convert) && (surface->Flags & SFLAG_PBO))
+ if ((convert != NO_CONVERSION || format.convert) && (surface->Flags & SFLAG_PBO))
{
TRACE("Removing the pbo attached to surface %p.\n", surface);
surface_remove_pbo(surface, gl_info);
}
- if (desc.convert)
+ if (format.convert)
{
/* This code is entered for texture formats which need a fixup. */
int height = surface->currentDesc.Height;
/* Stick to the alignment for the converted surface too, makes it easier to load the surface */
- outpitch = width * desc.conv_byte_count;
+ outpitch = width * format.conv_byte_count;
outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
@@ -4607,7 +4607,7 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
if (context) context_release(context);
return WINED3DERR_OUTOFVIDEOMEMORY;
}
- desc.convert(surface->resource.allocatedMemory, mem, pitch, width, height);
+ format.convert(surface->resource.allocatedMemory, mem, pitch, width, height);
}
else if (convert != NO_CONVERSION && surface->resource.allocatedMemory)
{
@@ -4615,7 +4615,7 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
int height = surface->currentDesc.Height;
/* Stick to the alignment for the converted surface too, makes it easier to load the surface */
- outpitch = width * desc.conv_byte_count;
+ outpitch = width * format.conv_byte_count;
outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
@@ -4638,7 +4638,7 @@ HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RE
LEAVE_GL();
if (mem || (surface->Flags & SFLAG_PBO))
- surface_upload_data(surface, gl_info, &desc, srgb, mem);
+ surface_upload_data(surface, gl_info, &format, srgb, mem);
/* Restore the default pitch */
ENTER_GL();
@@ -4780,7 +4780,7 @@ static HRESULT ffp_blit_set(IWineD3DDevice *iface, IWineD3DSurfaceImpl *surface)
{
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
- enum complex_fixup fixup = get_complex_fixup(surface->resource.format_desc->color_fixup);
+ enum complex_fixup fixup = get_complex_fixup(surface->resource.format->color_fixup);
/* When EXT_PALETTED_TEXTURE is around, palette conversion is done by the GPU
* else the surface is converted in software at upload time in LoadLocation.
@@ -4818,10 +4818,8 @@ static void ffp_blit_unset(IWineD3DDevice *iface)
}
static BOOL ffp_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
- const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
- const struct wined3d_format_desc *src_format_desc,
- const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
- const struct wined3d_format_desc *dst_format_desc)
+ const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
+ const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
{
enum complex_fixup src_fixup;
@@ -4836,11 +4834,11 @@ static BOOL ffp_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_
return TRUE;
}
- src_fixup = get_complex_fixup(src_format_desc->color_fixup);
+ src_fixup = get_complex_fixup(src_format->color_fixup);
if (TRACE_ON(d3d_surface) && TRACE_ON(d3d))
{
TRACE("Checking support for fixup:\n");
- dump_color_fixup_desc(src_format_desc->color_fixup);
+ dump_color_fixup_desc(src_format->color_fixup);
}
if (blit_op != BLIT_OP_BLIT)
@@ -4849,7 +4847,7 @@ static BOOL ffp_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_
return FALSE;
}
- if (!is_identity_fixup(dst_format_desc->color_fixup))
+ if (!is_identity_fixup(dst_format->color_fixup))
{
TRACE("Destination fixups are not supported\n");
return FALSE;
@@ -4862,7 +4860,7 @@ static BOOL ffp_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_
}
/* We only support identity conversions. */
- if (is_identity_fixup(src_format_desc->color_fixup))
+ if (is_identity_fixup(src_format->color_fixup))
{
TRACE("[OK]\n");
return TRUE;
@@ -4912,10 +4910,8 @@ static void cpu_blit_unset(IWineD3DDevice *iface)
}
static BOOL cpu_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
- const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
- const struct wined3d_format_desc *src_format_desc,
- const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
- const struct wined3d_format_desc *dst_format_desc)
+ const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
+ const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
{
if (blit_op == BLIT_OP_COLOR_FILL)
{
@@ -4932,7 +4928,7 @@ static HRESULT cpu_blit_color_fill(IWineD3DDeviceImpl *device, IWineD3DSurfaceIm
memset(&BltFx, 0, sizeof(BltFx));
BltFx.dwSize = sizeof(BltFx);
- BltFx.u5.dwFillColor = wined3d_format_convert_from_float(dst_surface->resource.format_desc, color);
+ BltFx.u5.dwFillColor = wined3d_format_convert_from_float(dst_surface->resource.format, color);
return IWineD3DBaseSurfaceImpl_Blt((IWineD3DSurface*)dst_surface, dst_rect,
NULL, NULL, WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_POINT);
}
@@ -4947,10 +4943,8 @@ const struct blit_shader cpu_blit = {
};
static BOOL fbo_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
- const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
- const struct wined3d_format_desc *src_format_desc,
- const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
- const struct wined3d_format_desc *dst_format_desc)
+ const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
+ const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
{
if ((wined3d_settings.offscreen_rendering_mode != ORM_FBO) || !gl_info->fbo_ops.glBlitFramebuffer)
return FALSE;
@@ -4965,17 +4959,17 @@ static BOOL fbo_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_
if (src_pool == WINED3DPOOL_SYSTEMMEM || dst_pool == WINED3DPOOL_SYSTEMMEM)
return FALSE;
- if(!((src_format_desc->Flags & WINED3DFMT_FLAG_FBO_ATTACHABLE) || (src_usage & WINED3DUSAGE_RENDERTARGET))
- && ((dst_format_desc->Flags & WINED3DFMT_FLAG_FBO_ATTACHABLE) || (dst_usage & WINED3DUSAGE_RENDERTARGET)))
+ if (!((src_format->Flags & WINED3DFMT_FLAG_FBO_ATTACHABLE) || (src_usage & WINED3DUSAGE_RENDERTARGET))
+ && ((dst_format->Flags & WINED3DFMT_FLAG_FBO_ATTACHABLE) || (dst_usage & WINED3DUSAGE_RENDERTARGET)))
return FALSE;
- if (!is_identity_fixup(src_format_desc->color_fixup) ||
- !is_identity_fixup(dst_format_desc->color_fixup))
+ if (!is_identity_fixup(src_format->color_fixup)
+ || !is_identity_fixup(dst_format->color_fixup))
return FALSE;
- if (!(src_format_desc->id == dst_format_desc->id
- || (is_identity_fixup(src_format_desc->color_fixup)
- && is_identity_fixup(dst_format_desc->color_fixup))))
+ if (!(src_format->id == dst_format->id
+ || (is_identity_fixup(src_format->color_fixup)
+ && is_identity_fixup(dst_format->color_fixup))))
return FALSE;
return TRUE;
diff --git a/dlls/wined3d/surface_base.c b/dlls/wined3d/surface_base.c
index 919cba0..a5d040d 100644
--- a/dlls/wined3d/surface_base.c
+++ b/dlls/wined3d/surface_base.c
@@ -153,7 +153,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSU
TRACE("(%p) : copying into %p\n", This, pDesc);
- pDesc->format = This->resource.format_desc->id;
+ pDesc->format = This->resource.format->id;
pDesc->resource_type = This->resource.resourceType;
pDesc->usage = This->resource.usage;
pDesc->pool = This->resource.pool;
@@ -303,24 +303,24 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPalette(IWineD3DSurface *iface, IWineD
return WINED3D_OK;
}
-DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPitch(IWineD3DSurface *iface) {
+DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPitch(IWineD3DSurface *iface)
+{
IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
- const struct wined3d_format_desc *format_desc = This->resource.format_desc;
+ const struct wined3d_format *format = This->resource.format;
DWORD ret;
TRACE("(%p)\n", This);
- if ((format_desc->Flags & (WINED3DFMT_FLAG_COMPRESSED | WINED3DFMT_FLAG_BROKEN_PITCH))
- == WINED3DFMT_FLAG_COMPRESSED)
+ if ((format->Flags & (WINED3DFMT_FLAG_COMPRESSED | WINED3DFMT_FLAG_BROKEN_PITCH)) == WINED3DFMT_FLAG_COMPRESSED)
{
/* Since compressed formats are block based, pitch means the amount of
* bytes to the next row of block rather than the next row of pixels. */
- UINT row_block_count = (This->currentDesc.Width + format_desc->block_width - 1) / format_desc->block_width;
- ret = row_block_count * format_desc->block_byte_count;
+ UINT row_block_count = (This->currentDesc.Width + format->block_width - 1) / format->block_width;
+ ret = row_block_count * format->block_byte_count;
}
else
{
unsigned char alignment = This->resource.device->surface_alignment;
- ret = This->resource.format_desc->byte_count * This->currentDesc.Width; /* Bytes / row */
+ ret = This->resource.format->byte_count * This->currentDesc.Width; /* Bytes / row */
ret = (ret + alignment - 1) & ~(alignment - 1);
}
TRACE("(%p) Returning %d\n", This, ret);
@@ -470,32 +470,32 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetClipper(IWineD3DSurface *iface, IWineD
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetFormat(IWineD3DSurface *iface, enum wined3d_format_id format_id)
{
IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id,
- &This->resource.device->adapter->gl_info);
+ const struct wined3d_format *format = wined3d_get_format(&This->resource.device->adapter->gl_info, format_id);
- if (This->resource.format_desc->id != WINED3DFMT_UNKNOWN)
+ if (This->resource.format->id != WINED3DFMT_UNKNOWN)
{
FIXME("(%p) : The format of the surface must be WINED3DFORMAT_UNKNOWN\n", This);
return WINED3DERR_INVALIDCALL;
}
- TRACE("(%p) : Setting texture format to (%d,%s)\n", This, format_id, debug_d3dformat(format_id));
+ TRACE("(%p) : Setting texture format to %s (%#x).\n", This, debug_d3dformat(format_id), format_id);
- This->resource.size = wined3d_format_calculate_size(format_desc, This->resource.device->surface_alignment,
+ This->resource.size = wined3d_format_calculate_size(format, This->resource.device->surface_alignment,
This->pow2Width, This->pow2Height);
This->Flags |= (WINED3DFMT_D16_LOCKABLE == format_id) ? SFLAG_LOCKABLE : 0;
- This->resource.format_desc = format_desc;
+ This->resource.format = format;
- TRACE("(%p) : Size %d, bytesPerPixel %d\n", This, This->resource.size, format_desc->byte_count);
+ TRACE("(%p) : Size %d, bytesPerPixel %d\n", This, This->resource.size, format->byte_count);
return WINED3D_OK;
}
-HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface) {
+HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface)
+{
IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
- const struct wined3d_format_desc *format_desc = This->resource.format_desc;
+ const struct wined3d_format *format = This->resource.format;
int extraline = 0;
SYSTEM_INFO sysInfo;
BITMAPINFO* b_info;
@@ -503,13 +503,13 @@ HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface) {
DWORD *masks;
UINT usage;
- if(!(format_desc->Flags & WINED3DFMT_FLAG_GETDC))
+ if (!(format->Flags & WINED3DFMT_FLAG_GETDC))
{
- WARN("Cannot use GetDC on a %s surface\n", debug_d3dformat(format_desc->id));
+ WARN("Cannot use GetDC on a %s surface\n", debug_d3dformat(format->id));
return WINED3DERR_INVALIDCALL;
}
- switch (format_desc->byte_count)
+ switch (format->byte_count)
{
case 2:
case 4:
@@ -524,7 +524,7 @@ HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface) {
default:
/* Allocate extra space for a palette. */
b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (1 << (format_desc->byte_count * 8)));
+ sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (1 << (format->byte_count * 8)));
break;
}
@@ -544,11 +544,11 @@ HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface) {
b_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
/* TODO: Is there a nicer way to force a specific alignment? (8 byte for ddraw) */
- b_info->bmiHeader.biWidth = IWineD3DSurface_GetPitch(iface) / format_desc->byte_count;
+ b_info->bmiHeader.biWidth = IWineD3DSurface_GetPitch(iface) / format->byte_count;
b_info->bmiHeader.biHeight = -This->currentDesc.Height -extraline;
b_info->bmiHeader.biSizeImage = ( This->currentDesc.Height + extraline) * IWineD3DSurface_GetPitch(iface);
b_info->bmiHeader.biPlanes = 1;
- b_info->bmiHeader.biBitCount = format_desc->byte_count * 8;
+ b_info->bmiHeader.biBitCount = format->byte_count * 8;
b_info->bmiHeader.biXPelsPerMeter = 0;
b_info->bmiHeader.biYPelsPerMeter = 0;
@@ -557,7 +557,7 @@ HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface) {
/* Get the bit masks */
masks = (DWORD *)b_info->bmiColors;
- switch (This->resource.format_desc->id)
+ switch (This->resource.format->id)
{
case WINED3DFMT_B8G8R8_UNORM:
usage = DIB_RGB_COLORS;
@@ -578,9 +578,9 @@ HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface) {
case WINED3DFMT_R16G16B16A16_UNORM:
usage = 0;
b_info->bmiHeader.biCompression = BI_BITFIELDS;
- masks[0] = format_desc->red_mask;
- masks[1] = format_desc->green_mask;
- masks[2] = format_desc->blue_mask;
+ masks[0] = format->red_mask;
+ masks[1] = format->green_mask;
+ masks[2] = format->blue_mask;
break;
default:
@@ -802,11 +802,11 @@ static IWineD3DSurfaceImpl *surface_convert_format(IWineD3DSurfaceImpl *source,
WINED3DLOCKED_RECT lock_src, lock_dst;
HRESULT hr;
- conv = find_convertor(source->resource.format_desc->id, to_fmt);
+ conv = find_convertor(source->resource.format->id, to_fmt);
if (!conv)
{
FIXME("Cannot find a conversion function from format %s to %s.\n",
- debug_d3dformat(source->resource.format_desc->id), debug_d3dformat(to_fmt));
+ debug_d3dformat(source->resource.format->id), debug_d3dformat(to_fmt));
return NULL;
}
@@ -930,7 +930,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *D
HRESULT ret = WINED3D_OK;
WINED3DLOCKED_RECT dlock, slock;
int bpp, srcheight, srcwidth, dstheight, dstwidth, width;
- const struct wined3d_format_desc *sEntry, *dEntry;
+ const struct wined3d_format *sEntry, *dEntry;
int x, y;
const BYTE *sbuf;
BYTE *dbuf;
@@ -1095,15 +1095,15 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *D
{
IWineD3DSurface_LockRect(iface, &dlock, NULL, 0);
slock = dlock;
- sEntry = This->resource.format_desc;
+ sEntry = This->resource.format;
dEntry = sEntry;
}
else
{
- dEntry = This->resource.format_desc;
+ dEntry = This->resource.format;
if (src)
{
- if (This->resource.format_desc->id != src->resource.format_desc->id)
+ if (This->resource.format->id != src->resource.format->id)
{
src = surface_convert_format(src, dEntry->id);
if (!src)
@@ -1114,7 +1114,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *D
}
}
IWineD3DSurface_LockRect((IWineD3DSurface *)src, &slock, NULL, WINED3DLOCK_READONLY);
- sEntry = src->resource.format_desc;
+ sEntry = src->resource.format;
}
else
{
@@ -1137,7 +1137,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *D
}
}
- bpp = This->resource.format_desc->byte_count;
+ bpp = This->resource.format->byte_count;
srcheight = xsrc.bottom - xsrc.top;
srcwidth = xsrc.right - xsrc.left;
dstheight = xdst.bottom - xdst.top;
@@ -1561,7 +1561,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst
RECT lock_src, lock_dst, lock_union;
const BYTE *sbuf;
BYTE *dbuf;
- const struct wined3d_format_desc *sEntry, *dEntry;
+ const struct wined3d_format *sEntry, *dEntry;
TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
iface, dstx, dsty, src_surface, wine_dbgstr_rect(rsrc), trans);
@@ -1614,7 +1614,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst
lock_dst.right = dstx + w;
lock_dst.bottom = dsty + h;
- bpp = This->resource.format_desc->byte_count;
+ bpp = This->resource.format->byte_count;
/* We need to lock the surfaces, or we won't get refreshes when done. */
if (src == This)
@@ -1633,7 +1633,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst
/* Since slock was originally copied from this surface's description, we can just reuse it */
sbuf = This->resource.allocatedMemory + lock_src.top * pitch + lock_src.left * bpp;
dbuf = This->resource.allocatedMemory + lock_dst.top * pitch + lock_dst.left * bpp;
- sEntry = src->resource.format_desc;
+ sEntry = src->resource.format;
dEntry = sEntry;
}
else
@@ -1647,8 +1647,8 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst
dbuf = dlock.pBits;
TRACE("Dst is at %p, Src is at %p\n", dbuf, sbuf);
- sEntry = src->resource.format_desc;
- dEntry = This->resource.format_desc;
+ sEntry = src->resource.format;
+ dEntry = This->resource.format;
}
/* Handle compressed surfaces first... */
@@ -1661,7 +1661,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst
FIXME("trans arg not supported when a compressed surface is involved\n");
if (dstx || dsty)
FIXME("offset for destination surface is not supported\n");
- if (src->resource.format_desc->id != This->resource.format_desc->id)
+ if (src->resource.format->id != This->resource.format->id)
{
FIXME("compressed -> compressed copy only supported for the same type of surface\n");
ret = WINED3DERR_WRONGTEXTUREFORMAT;
@@ -1690,9 +1690,9 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst
if (trans & (WINEDDBLTFAST_SRCCOLORKEY | WINEDDBLTFAST_DESTCOLORKEY))
{
DWORD keylow, keyhigh;
- DWORD mask = src->resource.format_desc->red_mask
- | src->resource.format_desc->green_mask
- | src->resource.format_desc->blue_mask;
+ DWORD mask = src->resource.format->red_mask
+ | src->resource.format->green_mask
+ | src->resource.format->blue_mask;
/* For some 8-bit formats like L8 and P8 color masks don't make sense */
if(!mask && bpp==1)
@@ -1829,25 +1829,24 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DL
}
else
{
- const struct wined3d_format_desc *format_desc = This->resource.format_desc;
+ const struct wined3d_format *format = This->resource.format;
TRACE("Lock Rect (%p) = l %d, t %d, r %d, b %d\n",
pRect, pRect->left, pRect->top, pRect->right, pRect->bottom);
- if ((format_desc->Flags & (WINED3DFMT_FLAG_COMPRESSED | WINED3DFMT_FLAG_BROKEN_PITCH))
- == WINED3DFMT_FLAG_COMPRESSED)
+ if ((format->Flags & (WINED3DFMT_FLAG_COMPRESSED | WINED3DFMT_FLAG_BROKEN_PITCH)) == WINED3DFMT_FLAG_COMPRESSED)
{
/* Compressed textures are block based, so calculate the offset of
* the block that contains the top-left pixel of the locked rectangle. */
pLockedRect->pBits = This->resource.allocatedMemory
- + ((pRect->top / format_desc->block_height) * pLockedRect->Pitch)
- + ((pRect->left / format_desc->block_width) * format_desc->block_byte_count);
+ + ((pRect->top / format->block_height) * pLockedRect->Pitch)
+ + ((pRect->left / format->block_width) * format->block_byte_count);
}
else
{
pLockedRect->pBits = This->resource.allocatedMemory +
(pLockedRect->Pitch * pRect->top) +
- (pRect->left * format_desc->byte_count);
+ (pRect->left * format->byte_count);
}
This->lockedRect.left = pRect->left;
This->lockedRect.top = pRect->top;
diff --git a/dlls/wined3d/surface_gdi.c b/dlls/wined3d/surface_gdi.c
index 513fb1b..a640b79 100644
--- a/dlls/wined3d/surface_gdi.c
+++ b/dlls/wined3d/surface_gdi.c
@@ -289,8 +289,8 @@ static HRESULT WINAPI IWineGDISurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHD
return hr;
}
- if (This->resource.format_desc->id == WINED3DFMT_P8_UINT
- || This->resource.format_desc->id == WINED3DFMT_P8_UINT_A8_UNORM)
+ if (This->resource.format->id == WINED3DFMT_P8_UINT
+ || This->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
{
unsigned int n;
const PALETTEENTRY *pal = NULL;
diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c
index 4fa7e64..3fb803f 100644
--- a/dlls/wined3d/swapchain.c
+++ b/dlls/wined3d/swapchain.c
@@ -117,7 +117,7 @@ static void swapchain_blit(IWineD3DSwapChainImpl *This, struct wined3d_context *
GetClientRect(This->win_handle, &win_rect);
win_h = win_rect.bottom - win_rect.top;
- if (gl_info->fbo_ops.glBlitFramebuffer && is_identity_fixup(backbuffer->resource.format_desc->color_fixup))
+ if (gl_info->fbo_ops.glBlitFramebuffer && is_identity_fixup(backbuffer->resource.format->color_fixup))
{
ENTER_GL();
context_apply_fbo_state_blit(context, GL_READ_FRAMEBUFFER, backbuffer, NULL, SFLAG_INTEXTURE);
@@ -161,7 +161,7 @@ static void swapchain_blit(IWineD3DSwapChainImpl *This, struct wined3d_context *
tex_bottom /= src_h;
}
- if (is_complex_fixup(backbuffer->resource.format_desc->color_fixup))
+ if (is_complex_fixup(backbuffer->resource.format->color_fixup))
gl_filter = GL_NEAREST;
ENTER_GL();
@@ -261,7 +261,7 @@ static HRESULT WINAPI IWineD3DSwapChainImpl_Present(IWineD3DSwapChain *iface, CO
cursor.resource.ref = 1;
cursor.resource.device = This->device;
cursor.resource.pool = WINED3DPOOL_SCRATCH;
- cursor.resource.format_desc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
+ cursor.resource.format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
cursor.resource.resourceType = WINED3DRTYPE_SURFACE;
cursor.texture_name = This->device->cursorTexture;
cursor.texture_target = GL_TEXTURE_2D;
@@ -625,7 +625,7 @@ HRESULT swapchain_init(IWineD3DSwapChainImpl *swapchain, WINED3DSURFTYPE surface
IWineD3DDeviceImpl *device, WINED3DPRESENT_PARAMETERS *present_parameters, IUnknown *parent)
{
const struct wined3d_adapter *adapter = device->adapter;
- const struct wined3d_format_desc *format_desc;
+ const struct wined3d_format *format;
BOOL displaymode_set = FALSE;
WINED3DDISPLAYMODE mode;
RECT client_rect;
@@ -679,7 +679,7 @@ HRESULT swapchain_init(IWineD3DSwapChainImpl *swapchain, WINED3DSURFTYPE surface
swapchain->orig_width = mode.Width;
swapchain->orig_height = mode.Height;
swapchain->orig_fmt = mode.Format;
- format_desc = getFormatDescEntry(mode.Format, &adapter->gl_info);
+ format = wined3d_get_format(&adapter->gl_info, mode.Format);
GetClientRect(window, &client_rect);
if (present_parameters->Windowed
@@ -795,7 +795,7 @@ HRESULT swapchain_init(IWineD3DSwapChainImpl *swapchain, WINED3DSURFTYPE surface
* issue needs to be fixed. */
for (i = 0; i < (sizeof(formats) / sizeof(*formats)); i++)
{
- swapchain->ds_format = getFormatDescEntry(formats[i], gl_info);
+ swapchain->ds_format = wined3d_get_format(gl_info, formats[i]);
swapchain->context[0] = context_create(swapchain, swapchain->front_buffer, swapchain->ds_format);
if (swapchain->context[0]) break;
TRACE("Depth stencil format %s is not supported, trying next format\n",
@@ -886,7 +886,7 @@ err:
memset(&devmode, 0, sizeof(devmode));
devmode.dmSize = sizeof(devmode);
devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
- devmode.dmBitsPerPel = format_desc->byte_count * 8;
+ devmode.dmBitsPerPel = format->byte_count * CHAR_BIT;
devmode.dmPelsWidth = swapchain->orig_width;
devmode.dmPelsHeight = swapchain->orig_height;
ChangeDisplaySettingsExW(adapter->DeviceName, &devmode, NULL, CDS_FULLSCREEN, NULL);
diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c
index 7dd4bd9..4d8aabc 100644
--- a/dlls/wined3d/texture.c
+++ b/dlls/wined3d/texture.c
@@ -66,8 +66,8 @@ static void texture_internal_preload(IWineD3DBaseTexture *iface, enum WINED3DSRG
context = context_acquire(device, NULL);
}
- if (This->resource.format_desc->id == WINED3DFMT_P8_UINT
- || This->resource.format_desc->id == WINED3DFMT_P8_UINT_A8_UNORM)
+ if (This->resource.format->id == WINED3DFMT_P8_UINT
+ || This->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
{
for (i = 0; i < This->baseTexture.level_count; ++i)
{
@@ -466,7 +466,7 @@ HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT
IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
{
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id, gl_info);
+ const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
UINT pow2_width, pow2_height;
UINT tmp_w, tmp_h;
unsigned int i;
@@ -530,7 +530,7 @@ HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT
texture->lpVtbl = &IWineD3DTexture_Vtbl;
hr = basetexture_init((IWineD3DBaseTextureImpl *)texture, 1, levels,
- WINED3DRTYPE_TEXTURE, device, 0, usage, format_desc, pool, parent, parent_ops);
+ WINED3DRTYPE_TEXTURE, device, 0, usage, format, pool, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize basetexture, returning %#x.\n", hr);
@@ -552,7 +552,7 @@ HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT
texture->baseTexture.minMipLookup = minMipLookup_noFilter;
}
else if (gl_info->supported[ARB_TEXTURE_RECTANGLE] && (width != pow2_width || height != pow2_height)
- && !(format_desc->id == WINED3DFMT_P8_UINT && gl_info->supported[EXT_PALETTED_TEXTURE]
+ && !(format->id == WINED3DFMT_P8_UINT && gl_info->supported[EXT_PALETTED_TEXTURE]
&& wined3d_settings.rendertargetlock_mode == RTL_READTEX))
{
if ((width != 1) || (height != 1)) texture->baseTexture.pow2Matrix_identity = FALSE;
@@ -564,7 +564,7 @@ HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT
texture->target = GL_TEXTURE_RECTANGLE_ARB;
texture->cond_np2 = TRUE;
- if(texture->resource.format_desc->Flags & WINED3DFMT_FLAG_FILTERING)
+ if(texture->resource.format->Flags & WINED3DFMT_FLAG_FILTERING)
{
texture->baseTexture.minMipLookup = minMipLookup_noMip;
}
@@ -603,7 +603,7 @@ HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT
/* Use the callback to create the texture surface. */
hr = IWineD3DDeviceParent_CreateSurface(device->device_parent, parent, tmp_w, tmp_h,
- format_desc->id, usage, pool, i, 0, &surface);
+ format->id, usage, pool, i, 0, &surface);
if (FAILED(hr))
{
FIXME("Failed to create surface %p, hr %#x\n", texture, hr);
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index 1c414e9..ef6da58 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -882,8 +882,8 @@ static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
UINT format_count = sizeof(formats) / sizeof(*formats);
UINT i;
- gl_info->gl_formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, format_count * sizeof(*gl_info->gl_formats));
- if (!gl_info->gl_formats)
+ gl_info->formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, format_count * sizeof(*gl_info->formats));
+ if (!gl_info->formats)
{
ERR("Failed to allocate memory.\n");
return FALSE;
@@ -891,15 +891,15 @@ static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
for (i = 0; i < format_count; ++i)
{
- struct wined3d_format_desc *desc = &gl_info->gl_formats[i];
- desc->id = formats[i].id;
- desc->red_mask = formats[i].redMask;
- desc->green_mask = formats[i].greenMask;
- desc->blue_mask = formats[i].blueMask;
- desc->alpha_mask = formats[i].alphaMask;
- desc->byte_count = formats[i].bpp;
- desc->depth_size = formats[i].depthSize;
- desc->stencil_size = formats[i].stencilSize;
+ struct wined3d_format *format = &gl_info->formats[i];
+ format->id = formats[i].id;
+ format->red_mask = formats[i].redMask;
+ format->green_mask = formats[i].greenMask;
+ format->blue_mask = formats[i].blueMask;
+ format->alpha_mask = formats[i].alphaMask;
+ format->byte_count = formats[i].bpp;
+ format->depth_size = formats[i].depthSize;
+ format->stencil_size = formats[i].stencilSize;
}
for (i = 0; i < (sizeof(format_base_flags) / sizeof(*format_base_flags)); ++i)
@@ -910,11 +910,11 @@ static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
{
ERR("Format %s (%#x) not found.\n",
debug_d3dformat(format_base_flags[i].id), format_base_flags[i].id);
- HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
+ HeapFree(GetProcessHeap(), 0, gl_info->formats);
return FALSE;
}
- gl_info->gl_formats[fmt_idx].Flags |= format_base_flags[i].flags;
+ gl_info->formats[fmt_idx].Flags |= format_base_flags[i].flags;
}
return TRUE;
@@ -926,7 +926,7 @@ static BOOL init_format_compression_info(struct wined3d_gl_info *gl_info)
for (i = 0; i < (sizeof(format_compression_info) / sizeof(*format_compression_info)); ++i)
{
- struct wined3d_format_desc *format_desc;
+ struct wined3d_format *format;
int fmt_idx = getFmtIdx(format_compression_info[i].id);
if (fmt_idx == -1)
@@ -936,18 +936,18 @@ static BOOL init_format_compression_info(struct wined3d_gl_info *gl_info)
return FALSE;
}
- format_desc = &gl_info->gl_formats[fmt_idx];
- format_desc->block_width = format_compression_info[i].block_width;
- format_desc->block_height = format_compression_info[i].block_height;
- format_desc->block_byte_count = format_compression_info[i].block_byte_count;
- format_desc->Flags |= WINED3DFMT_FLAG_COMPRESSED;
+ format = &gl_info->formats[fmt_idx];
+ format->block_width = format_compression_info[i].block_width;
+ format->block_height = format_compression_info[i].block_height;
+ format->block_byte_count = format_compression_info[i].block_byte_count;
+ format->Flags |= WINED3DFMT_FLAG_COMPRESSED;
}
return TRUE;
}
/* Context activation is done by the caller. */
-static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined3d_format_desc *format_desc)
+static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined3d_format *format)
{
/* Check if the default internal format is supported as a frame buffer
* target, otherwise fall back to the render target internal.
@@ -964,8 +964,7 @@ static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
- glTexImage2D(GL_TEXTURE_2D, 0, format_desc->glInternal, 16, 16, 0,
- format_desc->glFormat, format_desc->glType, NULL);
+ glTexImage2D(GL_TEXTURE_2D, 0, format->glInternal, 16, 16, 0, format->glFormat, format->glType, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -976,37 +975,36 @@ static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined
if (status == GL_FRAMEBUFFER_COMPLETE)
{
- TRACE("Format %s is supported as FBO color attachment.\n", debug_d3dformat(format_desc->id));
- format_desc->Flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
- format_desc->rtInternal = format_desc->glInternal;
+ TRACE("Format %s is supported as FBO color attachment.\n", debug_d3dformat(format->id));
+ format->Flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
+ format->rtInternal = format->glInternal;
}
else
{
- if (!format_desc->rtInternal)
+ if (!format->rtInternal)
{
- if (format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET)
+ if (format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
{
FIXME("Format %s with rendertarget flag is not supported as FBO color attachment,"
- " and no fallback specified.\n", debug_d3dformat(format_desc->id));
- format_desc->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
+ " and no fallback specified.\n", debug_d3dformat(format->id));
+ format->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
}
else
{
- TRACE("Format %s is not supported as FBO color attachment.\n", debug_d3dformat(format_desc->id));
+ TRACE("Format %s is not supported as FBO color attachment.\n", debug_d3dformat(format->id));
}
- format_desc->rtInternal = format_desc->glInternal;
+ format->rtInternal = format->glInternal;
}
else
{
TRACE("Format %s is not supported as FBO color attachment, trying rtInternal format as fallback.\n",
- debug_d3dformat(format_desc->id));
+ debug_d3dformat(format->id));
while(glGetError());
gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
- glTexImage2D(GL_TEXTURE_2D, 0, format_desc->rtInternal, 16, 16, 0,
- format_desc->glFormat, format_desc->glType, NULL);
+ glTexImage2D(GL_TEXTURE_2D, 0, format->rtInternal, 16, 16, 0, format->glFormat, format->glType, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -1018,18 +1016,18 @@ static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined
if (status == GL_FRAMEBUFFER_COMPLETE)
{
TRACE("Format %s rtInternal format is supported as FBO color attachment.\n",
- debug_d3dformat(format_desc->id));
+ debug_d3dformat(format->id));
}
else
{
FIXME("Format %s rtInternal format is not supported as FBO color attachment.\n",
- debug_d3dformat(format_desc->id));
- format_desc->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
+ debug_d3dformat(format->id));
+ format->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
}
}
}
- if (status == GL_FRAMEBUFFER_COMPLETE && format_desc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
+ if (status == GL_FRAMEBUFFER_COMPLETE && format->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
{
GLuint rb;
@@ -1050,7 +1048,7 @@ static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined
{
while(glGetError());
TRACE("Format doesn't support post-pixelshader blending.\n");
- format_desc->Flags &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
+ format->Flags &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
}
if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
@@ -1063,10 +1061,9 @@ static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined
}
}
- if (format_desc->glInternal != format_desc->glGammaInternal)
+ if (format->glInternal != format->glGammaInternal)
{
- glTexImage2D(GL_TEXTURE_2D, 0, format_desc->glGammaInternal, 16, 16, 0,
- format_desc->glFormat, format_desc->glType, NULL);
+ glTexImage2D(GL_TEXTURE_2D, 0, format->glGammaInternal, 16, 16, 0, format->glFormat, format->glType, NULL);
gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
@@ -1074,12 +1071,12 @@ static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined
if (status == GL_FRAMEBUFFER_COMPLETE)
{
- TRACE("Format %s's sRGB format is FBO attachable.\n", debug_d3dformat(format_desc->id));
- format_desc->Flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
+ TRACE("Format %s's sRGB format is FBO attachable.\n", debug_d3dformat(format->id));
+ format->Flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
}
else
{
- WARN("Format %s's sRGB format is not FBO attachable.\n", debug_d3dformat(format_desc->id));
+ WARN("Format %s's sRGB format is not FBO attachable.\n", debug_d3dformat(format->id));
}
}
@@ -1106,32 +1103,32 @@ static void init_format_fbo_compat_info(struct wined3d_gl_info *gl_info)
for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i)
{
- struct wined3d_format_desc *desc = &gl_info->gl_formats[i];
+ struct wined3d_format *format = &gl_info->formats[i];
- if (!desc->glInternal) continue;
+ if (!format->glInternal) continue;
- if (desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
+ if (format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
{
TRACE("Skipping format %s because it's a depth/stencil format.\n",
- debug_d3dformat(desc->id));
+ debug_d3dformat(format->id));
continue;
}
- if (desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
+ if (format->Flags & WINED3DFMT_FLAG_COMPRESSED)
{
TRACE("Skipping format %s because it's a compressed format.\n",
- debug_d3dformat(desc->id));
+ debug_d3dformat(format->id));
continue;
}
if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
{
- TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(desc->id));
- check_fbo_compat(gl_info, desc);
+ TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(format->id));
+ check_fbo_compat(gl_info, format);
}
else
{
- desc->rtInternal = desc->glInternal;
+ format->rtInternal = format->glInternal;
}
}
@@ -1152,7 +1149,7 @@ static BOOL init_format_texture_info(struct wined3d_gl_info *gl_info)
for (i = 0; i < sizeof(format_texture_info) / sizeof(*format_texture_info); ++i)
{
int fmt_idx = getFmtIdx(format_texture_info[i].id);
- struct wined3d_format_desc *desc;
+ struct wined3d_format *format;
if (fmt_idx == -1)
{
@@ -1163,19 +1160,19 @@ static BOOL init_format_texture_info(struct wined3d_gl_info *gl_info)
if (!gl_info->supported[format_texture_info[i].extension]) continue;
- desc = &gl_info->gl_formats[fmt_idx];
- desc->glInternal = format_texture_info[i].gl_internal;
- desc->glGammaInternal = format_texture_info[i].gl_srgb_internal;
- desc->rtInternal = format_texture_info[i].gl_rt_internal;
- desc->glFormat = format_texture_info[i].gl_format;
- desc->glType = format_texture_info[i].gl_type;
- desc->color_fixup = COLOR_FIXUP_IDENTITY;
- desc->Flags |= format_texture_info[i].flags;
- desc->heightscale = 1.0f;
+ format = &gl_info->formats[fmt_idx];
+ format->glInternal = format_texture_info[i].gl_internal;
+ format->glGammaInternal = format_texture_info[i].gl_srgb_internal;
+ format->rtInternal = format_texture_info[i].gl_rt_internal;
+ format->glFormat = format_texture_info[i].gl_format;
+ format->glType = format_texture_info[i].gl_type;
+ format->color_fixup = COLOR_FIXUP_IDENTITY;
+ format->Flags |= format_texture_info[i].flags;
+ format->heightscale = 1.0f;
/* Texture conversion stuff */
- desc->convert = format_texture_info[i].convert;
- desc->conv_byte_count = format_texture_info[i].conv_byte_count;
+ format->convert = format_texture_info[i].convert;
+ format->conv_byte_count = format_texture_info[i].conv_byte_count;
}
return TRUE;
@@ -1293,7 +1290,7 @@ static BOOL check_filter(const struct wined3d_gl_info *gl_info, GLenum internal)
static void init_format_filter_info(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
{
- struct wined3d_format_desc *desc;
+ struct wined3d_format *format;
unsigned int fmt_idx, i;
static const enum wined3d_format_id fmts16[] =
{
@@ -1327,7 +1324,7 @@ static void init_format_filter_info(struct wined3d_gl_info *gl_info, enum wined3
for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
{
fmt_idx = getFmtIdx(fmts16[i]);
- gl_info->gl_formats[fmt_idx].Flags |= WINED3DFMT_FLAG_FILTERING;
+ gl_info->formats[fmt_idx].Flags |= WINED3DFMT_FLAG_FILTERING;
}
}
return;
@@ -1336,14 +1333,14 @@ static void init_format_filter_info(struct wined3d_gl_info *gl_info, enum wined3
for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
{
fmt_idx = getFmtIdx(fmts16[i]);
- desc = &gl_info->gl_formats[fmt_idx];
- if(!desc->glInternal) continue; /* Not supported by GL */
+ format = &gl_info->formats[fmt_idx];
+ if (!format->glInternal) continue; /* Not supported by GL */
- filtered = check_filter(gl_info, gl_info->gl_formats[fmt_idx].glInternal);
+ filtered = check_filter(gl_info, gl_info->formats[fmt_idx].glInternal);
if(filtered)
{
TRACE("Format %s supports filtering\n", debug_d3dformat(fmts16[i]));
- desc->Flags |= WINED3DFMT_FLAG_FILTERING;
+ format->Flags |= WINED3DFMT_FLAG_FILTERING;
}
else
{
@@ -1357,23 +1354,23 @@ static void apply_format_fixups(struct wined3d_gl_info *gl_info)
int idx;
idx = getFmtIdx(WINED3DFMT_R16_FLOAT);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
idx = getFmtIdx(WINED3DFMT_R32_FLOAT);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
idx = getFmtIdx(WINED3DFMT_R16G16_UNORM);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
idx = getFmtIdx(WINED3DFMT_R32G32_FLOAT);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
/* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
@@ -1388,20 +1385,20 @@ static void apply_format_fixups(struct wined3d_gl_info *gl_info)
if (!gl_info->supported[NV_TEXTURE_SHADER])
{
idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
}
else
{
idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
}
@@ -1411,13 +1408,13 @@ static void apply_format_fixups(struct wined3d_gl_info *gl_info)
* with each other
*/
idx = getFmtIdx(WINED3DFMT_R5G5_SNORM_L6_UNORM);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
idx = getFmtIdx(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
idx = getFmtIdx(WINED3DFMT_R8G8B8A8_SNORM);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
}
else
@@ -1432,39 +1429,39 @@ static void apply_format_fixups(struct wined3d_gl_info *gl_info)
if (gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
{
idx = getFmtIdx(WINED3DFMT_ATI2N);
- gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup = create_color_fixup_desc(
0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
}
else if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC])
{
idx = getFmtIdx(WINED3DFMT_ATI2N);
- gl_info->gl_formats[idx].color_fixup= create_color_fixup_desc(
+ gl_info->formats[idx].color_fixup= create_color_fixup_desc(
0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
}
if (!gl_info->supported[APPLE_YCBCR_422])
{
idx = getFmtIdx(WINED3DFMT_YUY2);
- gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
+ gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
idx = getFmtIdx(WINED3DFMT_UYVY);
- gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY);
+ gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY);
}
idx = getFmtIdx(WINED3DFMT_YV12);
- gl_info->gl_formats[idx].heightscale = 1.5f;
- gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12);
+ gl_info->formats[idx].heightscale = 1.5f;
+ gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12);
if (gl_info->supported[EXT_PALETTED_TEXTURE] || gl_info->supported[ARB_FRAGMENT_PROGRAM])
{
idx = getFmtIdx(WINED3DFMT_P8_UINT);
- gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
+ gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
}
if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
{
idx = getFmtIdx(WINED3DFMT_B8G8R8A8_UNORM);
- gl_info->gl_formats[idx].gl_vtx_format = GL_BGRA;
+ gl_info->formats[idx].gl_vtx_format = GL_BGRA;
}
if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
@@ -1472,10 +1469,10 @@ static void apply_format_fixups(struct wined3d_gl_info *gl_info)
/* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
* It is the job of the vertex buffer code to make sure that the vbos have the right format */
idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
- gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT; /* == GL_HALF_FLOAT_NV */
+ gl_info->formats[idx].gl_vtx_type = GL_HALF_FLOAT; /* == GL_HALF_FLOAT_NV */
idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
- gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT;
+ gl_info->formats[idx].gl_vtx_type = GL_HALF_FLOAT;
}
}
@@ -1485,7 +1482,7 @@ static BOOL init_format_vertex_info(struct wined3d_gl_info *gl_info)
for (i = 0; i < (sizeof(format_vertex_info) / sizeof(*format_vertex_info)); ++i)
{
- struct wined3d_format_desc *format_desc;
+ struct wined3d_format *format;
int fmt_idx = getFmtIdx(format_vertex_info[i].id);
if (fmt_idx == -1)
@@ -1495,13 +1492,13 @@ static BOOL init_format_vertex_info(struct wined3d_gl_info *gl_info)
return FALSE;
}
- format_desc = &gl_info->gl_formats[fmt_idx];
- format_desc->emit_idx = format_vertex_info[i].emit_idx;
- format_desc->component_count = format_vertex_info[i].component_count;
- format_desc->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
- format_desc->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
- format_desc->gl_normalized = format_vertex_info[i].gl_normalized;
- format_desc->component_size = format_vertex_info[i].component_size;
+ format = &gl_info->formats[fmt_idx];
+ format->emit_idx = format_vertex_info[i].emit_idx;
+ format->component_count = format_vertex_info[i].component_count;
+ format->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
+ format->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
+ format->gl_normalized = format_vertex_info[i].gl_normalized;
+ format->component_size = format_vertex_info[i].component_size;
}
return TRUE;
@@ -1513,8 +1510,8 @@ BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info)
if (!init_format_compression_info(gl_info))
{
- HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
- gl_info->gl_formats = NULL;
+ HeapFree(GetProcessHeap(), 0, gl_info->formats);
+ gl_info->formats = NULL;
return FALSE;
}
@@ -1537,13 +1534,13 @@ BOOL initPixelFormats(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor v
return TRUE;
fail:
- HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
- gl_info->gl_formats = NULL;
+ HeapFree(GetProcessHeap(), 0, gl_info->formats);
+ gl_info->formats = NULL;
return FALSE;
}
-const struct wined3d_format_desc *getFormatDescEntry(enum wined3d_format_id format_id,
- const struct wined3d_gl_info *gl_info)
+const struct wined3d_format *wined3d_get_format(const struct wined3d_gl_info *gl_info,
+ enum wined3d_format_id format_id)
{
int idx = getFmtIdx(format_id);
@@ -1555,10 +1552,10 @@ const struct wined3d_format_desc *getFormatDescEntry(enum wined3d_format_id form
idx = getFmtIdx(WINED3DFMT_UNKNOWN);
}
- return &gl_info->gl_formats[idx];
+ return &gl_info->formats[idx];
}
-UINT wined3d_format_calculate_size(const struct wined3d_format_desc *format, UINT alignment, UINT width, UINT height)
+UINT wined3d_format_calculate_size(const struct wined3d_format *format, UINT alignment, UINT width, UINT height)
{
UINT size;
@@ -2490,12 +2487,12 @@ unsigned int count_bits(unsigned int mask)
/* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
* The later function requires individual color components. */
-BOOL getColorBits(const struct wined3d_format_desc *format_desc,
+BOOL getColorBits(const struct wined3d_format *format,
short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize)
{
- TRACE("format %s.\n", debug_d3dformat(format_desc->id));
+ TRACE("format %s.\n", debug_d3dformat(format->id));
- switch (format_desc->id)
+ switch (format->id)
{
case WINED3DFMT_B8G8R8X8_UNORM:
case WINED3DFMT_B8G8R8_UNORM:
@@ -2512,27 +2509,27 @@ BOOL getColorBits(const struct wined3d_format_desc *format_desc,
case WINED3DFMT_P8_UINT:
break;
default:
- FIXME("Unsupported format %s.\n", debug_d3dformat(format_desc->id));
+ FIXME("Unsupported format %s.\n", debug_d3dformat(format->id));
return FALSE;
}
- *redSize = count_bits(format_desc->red_mask);
- *greenSize = count_bits(format_desc->green_mask);
- *blueSize = count_bits(format_desc->blue_mask);
- *alphaSize = count_bits(format_desc->alpha_mask);
+ *redSize = count_bits(format->red_mask);
+ *greenSize = count_bits(format->green_mask);
+ *blueSize = count_bits(format->blue_mask);
+ *alphaSize = count_bits(format->alpha_mask);
*totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for format %s.\n",
- *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(format_desc->id));
+ *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(format->id));
return TRUE;
}
/* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
-BOOL getDepthStencilBits(const struct wined3d_format_desc *format_desc, short *depthSize, short *stencilSize)
+BOOL getDepthStencilBits(const struct wined3d_format *format, short *depthSize, short *stencilSize)
{
- TRACE("format %s.\n", debug_d3dformat(format_desc->id));
+ TRACE("format %s.\n", debug_d3dformat(format->id));
- switch (format_desc->id)
+ switch (format->id)
{
case WINED3DFMT_D16_LOCKABLE:
case WINED3DFMT_D16_UNORM:
@@ -2545,22 +2542,22 @@ BOOL getDepthStencilBits(const struct wined3d_format_desc *format_desc, short *d
case WINED3DFMT_D32_FLOAT:
break;
default:
- FIXME("Unsupported depth/stencil format %s.\n", debug_d3dformat(format_desc->id));
+ FIXME("Unsupported depth/stencil format %s.\n", debug_d3dformat(format->id));
return FALSE;
}
- *depthSize = format_desc->depth_size;
- *stencilSize = format_desc->stencil_size;
+ *depthSize = format->depth_size;
+ *stencilSize = format->stencil_size;
TRACE("Returning depthSize: %d and stencilSize: %d for format %s.\n",
- *depthSize, *stencilSize, debug_d3dformat(format_desc->id));
+ *depthSize, *stencilSize, debug_d3dformat(format->id));
return TRUE;
}
/* Note: It's the caller's responsibility to ensure values can be expressed
* in the requested format. UNORM formats for example can only express values
* in the range 0.0f -> 1.0f. */
-DWORD wined3d_format_convert_from_float(const struct wined3d_format_desc *format, const WINED3DCOLORVALUE *color)
+DWORD wined3d_format_convert_from_float(const struct wined3d_format *format, const WINED3DCOLORVALUE *color)
{
static const struct
{
@@ -2745,9 +2742,11 @@ void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_setting
}
texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
- if(texture) {
- settings->op[i].color_fixup = texture->resource.format_desc->color_fixup;
- if(ignore_textype) {
+ if (texture)
+ {
+ settings->op[i].color_fixup = texture->resource.format->color_fixup;
+ if (ignore_textype)
+ {
settings->op[i].tex_type = tex_1d;
} else {
switch (IWineD3DBaseTexture_GetTextureDimensions((IWineD3DBaseTexture *)texture)) {
@@ -2810,7 +2809,7 @@ void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_setting
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)stateblock->textures[0];
IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[0];
- if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format_desc->alpha_mask)
+ if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask)
{
if (aop == WINED3DTOP_DISABLE)
{
@@ -2913,8 +2912,9 @@ void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_setting
break;
}
}
- if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE] &&
- rt->resource.format_desc->Flags & WINED3DFMT_FLAG_SRGB_WRITE) {
+ if (stateblock->renderState[WINED3DRS_SRGBWRITEENABLE]
+ && rt->resource.format->Flags & WINED3DFMT_FLAG_SRGB_WRITE)
+ {
settings->sRGB_write = 1;
} else {
settings->sRGB_write = 0;
@@ -3138,8 +3138,8 @@ void select_shader_mode(const struct wined3d_gl_info *gl_info, int *ps_selected,
}
const struct blit_shader *wined3d_select_blitter(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
- const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format_desc *src_format,
- const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format_desc *dst_format)
+ const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
+ const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
{
static const struct blit_shader * const blitters[] =
{
diff --git a/dlls/wined3d/vertexdeclaration.c b/dlls/wined3d/vertexdeclaration.c
index 0bc141a..056fbb0 100644
--- a/dlls/wined3d/vertexdeclaration.c
+++ b/dlls/wined3d/vertexdeclaration.c
@@ -221,7 +221,7 @@ HRESULT vertexdeclaration_init(IWineD3DVertexDeclarationImpl *declaration, IWine
{
struct wined3d_vertex_declaration_element *e = &declaration->elements[i];
- e->format_desc = getFormatDescEntry(elements[i].format, gl_info);
+ e->format = wined3d_get_format(gl_info, elements[i].format);
e->ffp_valid = declaration_element_valid_ffp(&elements[i]);
e->input_slot = elements[i].input_slot;
e->offset = elements[i].offset;
@@ -236,7 +236,7 @@ HRESULT vertexdeclaration_init(IWineD3DVertexDeclarationImpl *declaration, IWine
* to be loaded when drawing, but filter tesselation pseudo streams. */
if (e->input_slot >= MAX_STREAMS) continue;
- if (!e->format_desc->gl_vtx_format)
+ if (!e->format->gl_vtx_format)
{
FIXME("The application tries to use an unsupported format (%s), returning E_FAIL.\n",
debug_d3dformat(elements[i].format));
diff --git a/dlls/wined3d/volume.c b/dlls/wined3d/volume.c
index 3370581..18c8d46 100644
--- a/dlls/wined3d/volume.c
+++ b/dlls/wined3d/volume.c
@@ -189,7 +189,7 @@ static HRESULT WINAPI IWineD3DVolumeImpl_GetDesc(IWineD3DVolume *iface, WINED3DV
IWineD3DVolumeImpl *This = (IWineD3DVolumeImpl *)iface;
TRACE("(%p) : copying into %p\n", This, pDesc);
- pDesc->Format = This->resource.format_desc->id;
+ pDesc->Format = This->resource.format->id;
pDesc->Type = This->resource.resourceType;
pDesc->Usage = This->resource.usage;
pDesc->Pool = This->resource.pool;
@@ -212,8 +212,8 @@ static HRESULT WINAPI IWineD3DVolumeImpl_LockBox(IWineD3DVolume *iface, WINED3DL
/* fixme: should we really lock as such? */
TRACE("(%p) : box=%p, output pbox=%p, allMem=%p\n", This, pBox, pLockedVolume, This->resource.allocatedMemory);
- pLockedVolume->RowPitch = This->resource.format_desc->byte_count * This->currentDesc.Width; /* Bytes / row */
- pLockedVolume->SlicePitch = This->resource.format_desc->byte_count
+ pLockedVolume->RowPitch = This->resource.format->byte_count * This->currentDesc.Width; /* Bytes / row */
+ pLockedVolume->SlicePitch = This->resource.format->byte_count
* This->currentDesc.Width * This->currentDesc.Height; /* Bytes / slice */
if (!pBox) {
TRACE("No box supplied - all is ok\n");
@@ -229,7 +229,7 @@ static HRESULT WINAPI IWineD3DVolumeImpl_LockBox(IWineD3DVolume *iface, WINED3DL
pLockedVolume->pBits = This->resource.allocatedMemory
+ (pLockedVolume->SlicePitch * pBox->Front) /* FIXME: is front < back or vica versa? */
+ (pLockedVolume->RowPitch * pBox->Top)
- + (pBox->Left * This->resource.format_desc->byte_count);
+ + (pBox->Left * This->resource.format->byte_count);
This->lockedBox.Left = pBox->Left;
This->lockedBox.Top = pBox->Top;
This->lockedBox.Front = pBox->Front;
@@ -273,36 +273,21 @@ static HRESULT WINAPI IWineD3DVolumeImpl_LoadTexture(IWineD3DVolume *iface, int
{
IWineD3DVolumeImpl *This = (IWineD3DVolumeImpl *)iface;
const struct wined3d_gl_info *gl_info = &This->resource.device->adapter->gl_info;
- const struct wined3d_format_desc *glDesc = This->resource.format_desc;
+ const struct wined3d_format *format = This->resource.format;
TRACE("iface %p, level %u, srgb %#x, format %s (%#x).\n",
- iface, gl_level, srgb_mode, debug_d3dformat(glDesc->id), glDesc->id);
+ iface, gl_level, srgb_mode, debug_d3dformat(format->id), format->id);
volume_bind_and_dirtify(iface);
TRACE("Calling glTexImage3D %x level=%d, intfmt=%x, w=%d, h=%d,d=%d, 0=%d, glFmt=%x, glType=%x, Mem=%p\n",
- GL_TEXTURE_3D,
- gl_level,
- glDesc->glInternal,
- This->currentDesc.Width,
- This->currentDesc.Height,
- This->currentDesc.Depth,
- 0,
- glDesc->glFormat,
- glDesc->glType,
- This->resource.allocatedMemory);
+ GL_TEXTURE_3D, gl_level, format->glInternal, This->currentDesc.Width, This->currentDesc.Height,
+ This->currentDesc.Depth, 0, format->glFormat, format->glType, This->resource.allocatedMemory);
ENTER_GL();
- GL_EXTCALL(glTexImage3DEXT(GL_TEXTURE_3D,
- gl_level,
- glDesc->glInternal,
- This->currentDesc.Width,
- This->currentDesc.Height,
- This->currentDesc.Depth,
- 0,
- glDesc->glFormat,
- glDesc->glType,
- This->resource.allocatedMemory));
+ GL_EXTCALL(glTexImage3DEXT(GL_TEXTURE_3D, gl_level, format->glInternal,
+ This->currentDesc.Width, This->currentDesc.Height, This->currentDesc.Depth,
+ 0, format->glFormat, format->glType, This->resource.allocatedMemory));
checkGLcall("glTexImage3D");
LEAVE_GL();
@@ -343,7 +328,7 @@ HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT
IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
{
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id, gl_info);
+ const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
HRESULT hr;
if (!gl_info->supported[EXT_TEXTURE3D])
@@ -355,7 +340,7 @@ HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT
volume->lpVtbl = &IWineD3DVolume_Vtbl;
hr = resource_init((IWineD3DResource *)volume, WINED3DRTYPE_VOLUME, device,
- width * height * depth * format_desc->byte_count, usage, format_desc, pool, parent, parent_ops);
+ width * height * depth * format->byte_count, usage, format, pool, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize resource, returning %#x.\n", hr);
diff --git a/dlls/wined3d/volumetexture.c b/dlls/wined3d/volumetexture.c
index e647158..a64b05d 100644
--- a/dlls/wined3d/volumetexture.c
+++ b/dlls/wined3d/volumetexture.c
@@ -388,7 +388,7 @@ HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT
WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
{
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
- const struct wined3d_format_desc *format_desc = getFormatDescEntry(format_id, gl_info);
+ const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
UINT tmp_w, tmp_h, tmp_d;
unsigned int i;
HRESULT hr;
@@ -433,7 +433,7 @@ HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT
texture->lpVtbl = &IWineD3DVolumeTexture_Vtbl;
hr = basetexture_init((IWineD3DBaseTextureImpl *)texture, 1, levels,
- WINED3DRTYPE_VOLUMETEXTURE, device, 0, usage, format_desc, pool, parent, parent_ops);
+ WINED3DRTYPE_VOLUMETEXTURE, device, 0, usage, format, pool, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize basetexture, returning %#x.\n", hr);
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index e0a4dd4..914814d 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -806,7 +806,7 @@ do {
/* Trace vector and strided data information */
#define TRACE_STRIDED(si, name) do { if (si->use_map & (1 << name)) \
TRACE( #name "=(data:%p, stride:%d, format:%#x, vbo %d, stream %u)\n", \
- si->elements[name].data, si->elements[name].stride, si->elements[name].format_desc->id, \
+ si->elements[name].data, si->elements[name].stride, si->elements[name].format->id, \
si->elements[name].buffer_object, si->elements[name].stream_idx); } while(0)
/* Advance declaration of structures to satisfy compiler */
@@ -862,7 +862,7 @@ enum wined3d_ffp_emit_idx
struct wined3d_stream_info_element
{
- const struct wined3d_format_desc *format_desc;
+ const struct wined3d_format *format;
GLsizei stride;
const BYTE *data;
UINT stream_idx;
@@ -1141,8 +1141,8 @@ struct blit_shader
HRESULT (*set_shader)(IWineD3DDevice *iface, IWineD3DSurfaceImpl *surface);
void (*unset_shader)(IWineD3DDevice *iface);
BOOL (*blit_supported)(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
- const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format_desc *src_format_desc,
- const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format_desc *dst_format_desc);
+ const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
+ const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format);
HRESULT (*color_fill)(IWineD3DDeviceImpl *device, IWineD3DSurfaceImpl *dst_surface,
const RECT *dst_rect, const WINED3DCOLORVALUE *color);
};
@@ -1152,8 +1152,8 @@ extern const struct blit_shader arbfp_blit DECLSPEC_HIDDEN;
extern const struct blit_shader cpu_blit DECLSPEC_HIDDEN;
const struct blit_shader *wined3d_select_blitter(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
- const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format_desc *src_format,
- const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format_desc *dst_format)
+ const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
+ const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
DECLSPEC_HIDDEN;
/* Temporary blit_shader helper functions */
@@ -1176,7 +1176,7 @@ void context_attach_depth_stencil_fbo(struct wined3d_context *context,
GLenum fbo_target, IWineD3DSurfaceImpl *depth_stencil, BOOL use_render_buffer) DECLSPEC_HIDDEN;
void context_bind_fbo(struct wined3d_context *context, GLenum target, GLuint *fbo) DECLSPEC_HIDDEN;
struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3DSurfaceImpl *target,
- const struct wined3d_format_desc *ds_format_desc) DECLSPEC_HIDDEN;
+ const struct wined3d_format *ds_format) DECLSPEC_HIDDEN;
void context_destroy(IWineD3DDeviceImpl *This, struct wined3d_context *context) DECLSPEC_HIDDEN;
void context_free_event_query(struct wined3d_event_query *query) DECLSPEC_HIDDEN;
void context_free_occlusion_query(struct wined3d_occlusion_query *query) DECLSPEC_HIDDEN;
@@ -1417,7 +1417,7 @@ struct wined3d_gl_info
WGL_EXT_FUNCS_GEN
#undef USE_GL_FUNC
- struct wined3d_format_desc *gl_formats;
+ struct wined3d_format *formats;
};
struct wined3d_driver_info
@@ -1755,7 +1755,7 @@ typedef struct IWineD3DResourceClass
WINED3DPOOL pool;
UINT size;
DWORD usage;
- const struct wined3d_format_desc *format_desc;
+ const struct wined3d_format *format;
DWORD priority;
BYTE *allocatedMemory; /* Pointer to the real data location */
BYTE *heapMemory; /* Pointer to the HeapAlloced block of memory */
@@ -1778,7 +1778,7 @@ DWORD resource_get_priority(IWineD3DResource *iface) DECLSPEC_HIDDEN;
HRESULT resource_get_private_data(IWineD3DResource *iface, REFGUID guid,
void *data, DWORD *data_size) DECLSPEC_HIDDEN;
HRESULT resource_init(IWineD3DResource *iface, WINED3DRESOURCETYPE resource_type,
- IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format_desc *format_desc,
+ IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format *format,
WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
WINED3DRESOURCETYPE resource_get_type(IWineD3DResource *iface) DECLSPEC_HIDDEN;
DWORD resource_set_priority(IWineD3DResource *iface, DWORD new_priority) DECLSPEC_HIDDEN;
@@ -1868,7 +1868,7 @@ IWineD3DResourceImpl *basetexture_get_sub_resource(IWineD3DBaseTextureImpl *text
UINT layer, UINT level) DECLSPEC_HIDDEN;
HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, UINT layer_count, UINT level_count,
WINED3DRESOURCETYPE resource_type, IWineD3DDeviceImpl *device, UINT size, DWORD usage,
- const struct wined3d_format_desc *format_desc, WINED3DPOOL pool, IUnknown *parent,
+ const struct wined3d_format *format, WINED3DPOOL pool, IUnknown *parent,
const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
HRESULT basetexture_set_autogen_filter_type(IWineD3DBaseTexture *iface,
WINED3DTEXTUREFILTERTYPE filter_type) DECLSPEC_HIDDEN;
@@ -2227,9 +2227,9 @@ typedef enum {
CONVERT_RGB32_888
} CONVERT_TYPES;
-HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_texturing,
- struct wined3d_format_desc *desc, CONVERT_TYPES *convert) DECLSPEC_HIDDEN;
-void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl *This, BYTE table[256][4], BOOL colorkey) DECLSPEC_HIDDEN;
+HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *surface, BOOL need_alpha_ck, BOOL use_texturing,
+ struct wined3d_format *format, CONVERT_TYPES *convert) DECLSPEC_HIDDEN;
+void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl *surface, BYTE table[256][4], BOOL colorkey) DECLSPEC_HIDDEN;
BOOL palette9_changed(IWineD3DSurfaceImpl *This) DECLSPEC_HIDDEN;
@@ -2239,7 +2239,7 @@ BOOL palette9_changed(IWineD3DSurfaceImpl *This) DECLSPEC_HIDDEN;
struct wined3d_vertex_declaration_element
{
- const struct wined3d_format_desc *format_desc;
+ const struct wined3d_format *format;
BOOL ffp_valid;
WORD input_slot;
WORD offset;
@@ -2553,7 +2553,7 @@ struct IWineD3DSwapChainImpl
enum wined3d_format_id orig_fmt;
WINED3DGAMMARAMP orig_gamma;
BOOL render_to_fbo;
- const struct wined3d_format_desc *ds_format;
+ const struct wined3d_format *ds_format;
LONG prev_time, frames; /* Performance tracking */
unsigned int vSyncCounter;
@@ -2652,9 +2652,9 @@ void state_fogstartend(DWORD state, IWineD3DStateBlockImpl *stateblock,
void state_fog_fragpart(DWORD state, IWineD3DStateBlockImpl *stateblock,
struct wined3d_context *context) DECLSPEC_HIDDEN;
-BOOL getColorBits(const struct wined3d_format_desc *format_desc,
+BOOL getColorBits(const struct wined3d_format *format,
short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize) DECLSPEC_HIDDEN;
-BOOL getDepthStencilBits(const struct wined3d_format_desc *format_desc,
+BOOL getDepthStencilBits(const struct wined3d_format *format,
short *depthSize, short *stencilSize) DECLSPEC_HIDDEN;
/* Math utils */
@@ -2963,7 +2963,7 @@ extern enum wined3d_format_id pixelformat_for_depth(DWORD depth) DECLSPEC_HIDDEN
#define WINED3DFMT_FLAG_COMPRESSED 0x00008000
#define WINED3DFMT_FLAG_BROKEN_PITCH 0x00010000
-struct wined3d_format_desc
+struct wined3d_format
{
enum wined3d_format_id id;
@@ -2998,11 +2998,11 @@ struct wined3d_format_desc
void (*convert)(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height);
};
-const struct wined3d_format_desc *getFormatDescEntry(enum wined3d_format_id format_id,
- const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
-UINT wined3d_format_calculate_size(const struct wined3d_format_desc *format,
+const struct wined3d_format *wined3d_get_format(const struct wined3d_gl_info *gl_info,
+ enum wined3d_format_id format_id) DECLSPEC_HIDDEN;
+UINT wined3d_format_calculate_size(const struct wined3d_format *format,
UINT alignment, UINT width, UINT height) DECLSPEC_HIDDEN;
-DWORD wined3d_format_convert_from_float(const struct wined3d_format_desc *format,
+DWORD wined3d_format_convert_from_float(const struct wined3d_format *format,
const WINED3DCOLORVALUE *color) DECLSPEC_HIDDEN;
static inline BOOL use_vs(IWineD3DStateBlockImpl *stateblock)
--
1.7.1
More information about the wine-patches
mailing list