[PATCH 5/5] wined3d: Move the OpenGL texture format to struct wined3d_format_gl.
Henri Verbeet
hverbeet at codeweavers.com
Fri Sep 21 18:26:09 CDT 2018
Signed-off-by: Henri Verbeet <hverbeet at codeweavers.com>
---
dlls/wined3d/context.c | 4 +-
dlls/wined3d/surface.c | 48 ++--
dlls/wined3d/texture.c | 93 ++++----
dlls/wined3d/utils.c | 485 +++++++++++++++++++++--------------------
dlls/wined3d/view.c | 30 +--
dlls/wined3d/wined3d_private.h | 11 +-
6 files changed, 349 insertions(+), 322 deletions(-)
diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c
index 167241a6f0f..8199afa1d0e 100644
--- a/dlls/wined3d/context.c
+++ b/dlls/wined3d/context.c
@@ -3868,6 +3868,7 @@ static void context_bind_unordered_access_views(struct wined3d_context *context,
{
const struct wined3d_gl_info *gl_info = context->gl_info;
struct wined3d_unordered_access_view *view;
+ const struct wined3d_format_gl *format_gl;
GLuint texture_name;
unsigned int i;
GLint level;
@@ -3903,8 +3904,9 @@ static void context_bind_unordered_access_views(struct wined3d_context *context,
continue;
}
+ format_gl = wined3d_format_gl(view->format);
GL_EXTCALL(glBindImageTexture(i, texture_name, level, GL_TRUE, 0, GL_READ_WRITE,
- view->format->glInternal));
+ format_gl->internal));
if (view->counter_bo)
GL_EXTCALL(glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, i, view->counter_bo));
diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c
index d1847bea34e..8b69720693e 100644
--- a/dlls/wined3d/surface.c
+++ b/dlls/wined3d/surface.c
@@ -348,22 +348,24 @@ static BOOL fbo_blitter_supported(enum wined3d_blit_op blit_op, const struct win
static void texture2d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
const struct wined3d_context *context, DWORD dst_location)
{
- const struct wined3d_format *format = texture->resource.format;
const struct wined3d_gl_info *gl_info = context->gl_info;
struct wined3d_texture_sub_resource *sub_resource;
unsigned int dst_row_pitch, dst_slice_pitch;
unsigned int src_row_pitch, src_slice_pitch;
+ const struct wined3d_format_gl *format_gl;
struct wined3d_bo_address data;
BYTE *temporary_mem = NULL;
unsigned int level;
GLenum target;
void *mem;
+ format_gl = wined3d_format_gl(texture->resource.format);
+
/* Only support read back of converted P8 textures. */
- if (texture->flags & WINED3D_TEXTURE_CONVERTED && format->id != WINED3DFMT_P8_UINT && !format->download)
+ if (texture->flags & WINED3D_TEXTURE_CONVERTED && format_gl->f.id != WINED3DFMT_P8_UINT && !format_gl->f.download)
{
ERR("Trying to read back converted texture %p, %u with format %s.\n",
- texture, sub_resource_idx, debug_d3dformat(format->id));
+ texture, sub_resource_idx, debug_d3dformat(format_gl->f.id));
return;
}
@@ -373,7 +375,7 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in
if (target == GL_TEXTURE_2D_ARRAY)
{
- if (format->download)
+ if (format_gl->f.download)
{
FIXME("Reading back converted array texture %p is not supported.\n", texture);
return;
@@ -396,14 +398,14 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in
if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED)
{
- if (format->download)
+ if (format_gl->f.download)
{
FIXME("Reading back converted texture %p with NP2 emulation is not supported.\n", texture);
return;
}
wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch);
- wined3d_format_calculate_pitch(format, texture->resource.device->surface_alignment,
+ wined3d_format_calculate_pitch(&format_gl->f, texture->resource.device->surface_alignment,
wined3d_texture_get_level_pow2_width(texture, level),
wined3d_texture_get_level_pow2_height(texture, level),
&src_row_pitch, &src_slice_pitch);
@@ -419,7 +421,7 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in
ERR("Unexpected compressed format for NP2 emulated texture.\n");
}
- if (format->download)
+ if (format_gl->f.download)
{
struct wined3d_format f;
@@ -427,10 +429,10 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in
ERR("Converted texture %p uses PBO unexpectedly.\n", texture);
WARN_(d3d_perf)("Downloading converted texture %p, %u with format %s.\n",
- texture, sub_resource_idx, debug_d3dformat(format->id));
+ texture, sub_resource_idx, debug_d3dformat(format_gl->f.id));
- f = *format;
- f.byte_count = format->conv_byte_count;
+ f = format_gl->f;
+ f.byte_count = format_gl->f.conv_byte_count;
wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch);
wined3d_format_calculate_pitch(&f, texture->resource.device->surface_alignment,
wined3d_texture_get_level_width(texture, level),
@@ -462,7 +464,7 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in
if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED)
{
TRACE("Downloading compressed texture %p, %u, level %u, format %#x, type %#x, data %p.\n",
- texture, sub_resource_idx, level, format->glFormat, format->glType, mem);
+ texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem);
GL_EXTCALL(glGetCompressedTexImage(target, level, mem));
checkGLcall("glGetCompressedTexImage");
@@ -470,15 +472,15 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in
else
{
TRACE("Downloading texture %p, %u, level %u, format %#x, type %#x, data %p.\n",
- texture, sub_resource_idx, level, format->glFormat, format->glType, mem);
+ texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem);
- gl_info->gl_ops.gl.p_glGetTexImage(target, level, format->glFormat, format->glType, mem);
+ gl_info->gl_ops.gl.p_glGetTexImage(target, level, format_gl->format, format_gl->type, mem);
checkGLcall("glGetTexImage");
}
- if (format->download)
+ if (format_gl->f.download)
{
- format->download(mem, data.addr, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch,
+ format_gl->f.download(mem, data.addr, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch,
wined3d_texture_get_level_width(texture, level),
wined3d_texture_get_level_height(texture, level), 1);
}
@@ -931,7 +933,9 @@ static struct wined3d_texture *surface_convert_format(struct wined3d_texture *sr
static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, unsigned int sub_resource_idx,
struct wined3d_context *context, DWORD src_location, DWORD dst_location)
{
- struct wined3d_device *device = texture->resource.device;
+ struct wined3d_resource *resource = &texture->resource;
+ struct wined3d_device *device = resource->device;
+ const struct wined3d_format_gl *format_gl;
struct wined3d_texture *restore_texture;
const struct wined3d_gl_info *gl_info;
unsigned int row_pitch, slice_pitch;
@@ -953,10 +957,10 @@ static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, uns
restore_texture = NULL;
gl_info = context->gl_info;
- if (src_location != texture->resource.draw_binding)
+ if (src_location != resource->draw_binding)
{
context_apply_fbo_state_blit(context, GL_READ_FRAMEBUFFER,
- &texture->resource, sub_resource_idx, NULL, 0, src_location);
+ resource, sub_resource_idx, NULL, 0, src_location);
context_check_fbo_status(context, GL_READ_FRAMEBUFFER);
context_invalidate_state(context, STATE_FRAMEBUFFER);
}
@@ -969,7 +973,7 @@ static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, uns
* There is no need to keep track of the current read buffer or reset it,
* every part of the code that reads sets the read buffer as desired.
*/
- if (src_location != WINED3D_LOCATION_DRAWABLE || wined3d_resource_is_offscreen(&texture->resource))
+ if (src_location != WINED3D_LOCATION_DRAWABLE || wined3d_resource_is_offscreen(resource))
{
/* Mapping the primary render target which is not on a swapchain.
* Read from the back buffer. */
@@ -995,16 +999,16 @@ static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, uns
level = sub_resource_idx % texture->level_count;
wined3d_texture_get_pitch(texture, level, &row_pitch, &slice_pitch);
+ format_gl = wined3d_format_gl(resource->format);
/* Setup pixel store pack state -- to glReadPixels into the correct place */
- gl_info->gl_ops.gl.p_glPixelStorei(GL_PACK_ROW_LENGTH, row_pitch / texture->resource.format->byte_count);
+ gl_info->gl_ops.gl.p_glPixelStorei(GL_PACK_ROW_LENGTH, row_pitch / format_gl->f.byte_count);
checkGLcall("glPixelStorei");
width = wined3d_texture_get_level_width(texture, level);
height = wined3d_texture_get_level_height(texture, level);
gl_info->gl_ops.gl.p_glReadPixels(0, 0, width, height,
- texture->resource.format->glFormat,
- texture->resource.format->glType, data.addr);
+ format_gl->format, format_gl->type, data.addr);
checkGLcall("glReadPixels");
/* Reset previous pixel store pack state */
diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c
index b878e38961e..fdf26512b91 100644
--- a/dlls/wined3d/texture.c
+++ b/dlls/wined3d/texture.c
@@ -561,7 +561,7 @@ static unsigned int wined3d_texture_get_gl_sample_count(const struct wined3d_tex
/* Context activation is done by the caller. */
/* The caller is responsible for binding the correct texture. */
static void wined3d_texture_allocate_gl_mutable_storage(struct wined3d_texture *texture,
- GLenum gl_internal_format, const struct wined3d_format *format,
+ GLenum gl_internal_format, const struct wined3d_format_gl *format,
const struct wined3d_gl_info *gl_info)
{
unsigned int level, level_count, layer, layer_count;
@@ -584,8 +584,8 @@ static void wined3d_texture_allocate_gl_mutable_storage(struct wined3d_texture *
height = wined3d_texture_get_level_pow2_height(texture, level);
if (texture->resource.format_flags & WINED3DFMT_FLAG_HEIGHT_SCALE)
{
- height *= format->height_scale.numerator;
- height /= format->height_scale.denominator;
+ height *= format->f.height_scale.numerator;
+ height /= format->f.height_scale.denominator;
}
TRACE("texture %p, layer %u, level %u, target %#x, width %u, height %u.\n",
@@ -596,19 +596,19 @@ static void wined3d_texture_allocate_gl_mutable_storage(struct wined3d_texture *
depth = wined3d_texture_get_level_depth(texture, level);
GL_EXTCALL(glTexImage3D(target, level, gl_internal_format, width, height,
target == GL_TEXTURE_2D_ARRAY ? texture->layer_count : depth, 0,
- format->glFormat, format->glType, NULL));
+ format->format, format->type, NULL));
checkGLcall("glTexImage3D");
}
else if (target == GL_TEXTURE_1D)
{
gl_info->gl_ops.gl.p_glTexImage1D(target, level, gl_internal_format,
- width, 0, format->glFormat, format->glType, NULL);
+ width, 0, format->format, format->type, NULL);
}
else
{
gl_info->gl_ops.gl.p_glTexImage2D(target, level, gl_internal_format, width,
target == GL_TEXTURE_1D_ARRAY ? texture->layer_count : height, 0,
- format->glFormat, format->glType, NULL);
+ format->format, format->type, NULL);
checkGLcall("glTexImage2D");
}
}
@@ -1513,10 +1513,12 @@ void wined3d_texture_set_compatible_renderbuffer(struct wined3d_texture *texture
if (!renderbuffer)
{
+ const struct wined3d_format_gl *format_gl;
+
+ format_gl = wined3d_format_gl(texture->resource.format);
gl_info->fbo_ops.glGenRenderbuffers(1, &renderbuffer);
gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
- gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER,
- texture->resource.format->glInternal, width, height);
+ gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, format_gl->internal, width, height);
entry = heap_alloc(sizeof(*entry));
entry->width = width;
@@ -1712,11 +1714,13 @@ static void wined3d_texture_force_reload(struct wined3d_texture *texture)
void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
{
DWORD alloc_flag = srgb ? WINED3D_TEXTURE_SRGB_ALLOCATED : WINED3D_TEXTURE_RGB_ALLOCATED;
- const struct wined3d_device *device = texture->resource.device;
- const struct wined3d_format *format = texture->resource.format;
const struct wined3d_d3d_info *d3d_info = context->d3d_info;
const struct wined3d_gl_info *gl_info = context->gl_info;
+ struct wined3d_resource *resource = &texture->resource;
+ const struct wined3d_device *device = resource->device;
+ const struct wined3d_format *format = resource->format;
const struct wined3d_color_key_conversion *conversion;
+ const struct wined3d_format_gl *format_gl;
GLenum internal;
TRACE("texture %p, context %p, format %s.\n", texture, context, debug_d3dformat(format->id));
@@ -1734,11 +1738,11 @@ void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct win
if (texture->flags & alloc_flag)
return;
- if (texture->resource.format_flags & WINED3DFMT_FLAG_DECOMPRESS)
+ if (resource->format_flags & WINED3DFMT_FLAG_DECOMPRESS)
{
TRACE("WINED3DFMT_FLAG_DECOMPRESS set.\n");
texture->flags |= WINED3D_TEXTURE_CONVERTED;
- format = wined3d_resource_get_decompress_format(&texture->resource);
+ format = wined3d_resource_get_decompress_format(resource);
}
else if (format->conv_byte_count)
{
@@ -1747,37 +1751,38 @@ void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct win
else if ((conversion = wined3d_format_get_color_key_conversion(texture, TRUE)))
{
texture->flags |= WINED3D_TEXTURE_CONVERTED;
- format = wined3d_get_format(device->adapter, conversion->dst_format, texture->resource.usage);
+ format = wined3d_get_format(device->adapter, conversion->dst_format, resource->usage);
TRACE("Using format %s for color key conversion.\n", debug_d3dformat(format->id));
}
+ format_gl = wined3d_format_gl(format);
wined3d_texture_bind_and_dirtify(texture, context, srgb);
if (srgb)
- internal = format->glGammaInternal;
- else if (texture->resource.usage & WINED3DUSAGE_RENDERTARGET
- && wined3d_resource_is_offscreen(&texture->resource))
- internal = format->rtInternal;
+ internal = format_gl->srgb_internal;
+ else if (resource->usage & WINED3DUSAGE_RENDERTARGET && wined3d_resource_is_offscreen(resource))
+ internal = format_gl->rt_internal;
else
- internal = format->glInternal;
+ internal = format_gl->internal;
if (!internal)
FIXME("No GL internal format for format %s.\n", debug_d3dformat(format->id));
- TRACE("internal %#x, format %#x, type %#x.\n", internal, format->glFormat, format->glType);
+ TRACE("internal %#x, format %#x, type %#x.\n", internal, format_gl->format, format_gl->type);
if (wined3d_texture_use_immutable_storage(texture, gl_info))
wined3d_texture_allocate_gl_immutable_storage(texture, internal, gl_info);
else
- wined3d_texture_allocate_gl_mutable_storage(texture, internal, format, gl_info);
+ wined3d_texture_allocate_gl_mutable_storage(texture, internal, format_gl, gl_info);
texture->flags |= alloc_flag;
}
static void wined3d_texture_prepare_rb(struct wined3d_texture *texture,
const struct wined3d_gl_info *gl_info, BOOL multisample)
{
- const struct wined3d_format *format = texture->resource.format;
+ const struct wined3d_format_gl *format_gl;
+ format_gl = wined3d_format_gl(texture->resource.format);
if (multisample)
{
DWORD samples;
@@ -1790,7 +1795,7 @@ static void wined3d_texture_prepare_rb(struct wined3d_texture *texture,
gl_info->fbo_ops.glGenRenderbuffers(1, &texture->rb_multisample);
gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, texture->rb_multisample);
gl_info->fbo_ops.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- format->glInternal, texture->resource.width, texture->resource.height);
+ format_gl->internal, texture->resource.width, texture->resource.height);
checkGLcall("glRenderbufferStorageMultisample()");
TRACE("Created multisample rb %u.\n", texture->rb_multisample);
}
@@ -1801,7 +1806,7 @@ static void wined3d_texture_prepare_rb(struct wined3d_texture *texture,
gl_info->fbo_ops.glGenRenderbuffers(1, &texture->rb_resolved);
gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, texture->rb_resolved);
- gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, format->glInternal,
+ gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, format_gl->internal,
texture->resource.width, texture->resource.height);
checkGLcall("glRenderbufferStorage()");
TRACE("Created resolved rb %u.\n", texture->rb_resolved);
@@ -1906,9 +1911,10 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s
unsigned int update_w = src_box->right - src_box->left;
unsigned int update_h = src_box->bottom - src_box->top;
unsigned int update_d = src_box->back - src_box->front;
+ const struct wined3d_format_gl *format_gl;
struct wined3d_bo_address bo;
void *converted_mem = NULL;
- struct wined3d_format f;
+ struct wined3d_format_gl f;
unsigned int level;
BOOL decompress;
GLenum target;
@@ -1978,9 +1984,9 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s
if (texture->resource.format_flags & WINED3DFMT_FLAG_BLOCKS)
ERR("Converting a block-based format.\n");
- f = *format;
- f.byte_count = format->conv_byte_count;
- format = &f;
+ f = *wined3d_format_gl(format);
+ f.f.byte_count = format->conv_byte_count;
+ format = &f.f;
}
wined3d_format_calculate_pitch(format, 1, update_w, update_h, &dst_row_pitch, &dst_slice_pitch);
@@ -2015,6 +2021,7 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s
checkGLcall("glBindBuffer");
}
+ format_gl = wined3d_format_gl(format);
if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED)
{
unsigned int dst_row_pitch, dst_slice_pitch;
@@ -2022,12 +2029,12 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s
GLenum internal;
if (srgb)
- internal = format->glGammaInternal;
+ internal = format_gl->srgb_internal;
else if (texture->resource.usage & WINED3DUSAGE_RENDERTARGET
&& wined3d_resource_is_offscreen(&texture->resource))
- internal = format->rtInternal;
+ internal = format_gl->rt_internal;
else
- internal = format->glInternal;
+ internal = format_gl->internal;
wined3d_format_calculate_pitch(format, 1, update_w, update_h, &dst_row_pitch, &dst_slice_pitch);
@@ -2088,23 +2095,23 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s
TRACE("Uploading data, target %#x, level %u, x %u, y %u, z %u, "
"w %u, h %u, d %u, format %#x, type %#x, addr %p.\n",
target, level, dst_x, dst_y, dst_z, update_w, update_h,
- update_d, format->glFormat, format->glType, bo.addr);
+ update_d, format_gl->format, format_gl->type, bo.addr);
gl_info->gl_ops.gl.p_glPixelStorei(GL_UNPACK_ROW_LENGTH, src_row_pitch / format->byte_count);
if (target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_3D)
{
GL_EXTCALL(glTexSubImage3D(target, level, dst_x, dst_y, dst_z,
- update_w, update_h, update_d, format->glFormat, format->glType, bo.addr));
+ update_w, update_h, update_d, format_gl->format, format_gl->type, bo.addr));
}
else if (target == GL_TEXTURE_1D)
{
gl_info->gl_ops.gl.p_glTexSubImage1D(target, level, dst_x,
- update_w, format->glFormat, format->glType, bo.addr);
+ update_w, format_gl->format, format_gl->type, bo.addr);
}
else
{
gl_info->gl_ops.gl.p_glTexSubImage2D(target, level, dst_x, dst_y,
- update_w, update_h, format->glFormat, format->glType, bo.addr);
+ update_w, update_h, format_gl->format, format_gl->type, bo.addr);
}
gl_info->gl_ops.gl.p_glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
checkGLcall("Upload texture data");
@@ -2437,13 +2444,14 @@ static const struct wined3d_resource_ops texture_resource_ops =
static void texture1d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
const struct wined3d_context *context, const struct wined3d_bo_address *data)
{
- const struct wined3d_format *format = texture->resource.format;
const struct wined3d_gl_info *gl_info = context->gl_info;
+ const struct wined3d_format_gl *format_gl;
- if (format->conv_byte_count)
+ format_gl = wined3d_format_gl(texture->resource.format);
+ if (format_gl->f.conv_byte_count)
{
FIXME("Attempting to download a converted texture, format %s.\n",
- debug_d3dformat(format->id));
+ debug_d3dformat(format_gl->f.id));
return;
}
@@ -2454,7 +2462,7 @@ static void texture1d_download_data(struct wined3d_texture *texture, unsigned in
}
gl_info->gl_ops.gl.p_glGetTexImage(texture->target, sub_resource_idx,
- format->glFormat, format->glType, data->addr);
+ format_gl->format, format_gl->type, data->addr);
checkGLcall("glGetTexImage");
if (data->buffer_object)
@@ -2909,13 +2917,14 @@ static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struc
static void texture3d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
const struct wined3d_context *context, const struct wined3d_bo_address *data)
{
- const struct wined3d_format *format = texture->resource.format;
const struct wined3d_gl_info *gl_info = context->gl_info;
+ const struct wined3d_format_gl *format_gl;
- if (format->conv_byte_count)
+ format_gl = wined3d_format_gl(texture->resource.format);
+ if (format_gl->f.conv_byte_count)
{
FIXME("Attempting to download a converted volume, format %s.\n",
- debug_d3dformat(format->id));
+ debug_d3dformat(format_gl->f.id));
return;
}
@@ -2926,7 +2935,7 @@ static void texture3d_download_data(struct wined3d_texture *texture, unsigned in
}
gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_3D, sub_resource_idx,
- format->glFormat, format->glType, data->addr);
+ format_gl->format, format_gl->type, data->addr);
checkGLcall("glGetTexImage");
if (data->buffer_object)
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index 36694856081..055d546ccba 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -1935,6 +1935,11 @@ static struct wined3d_format *get_format_by_idx(const struct wined3d_adapter *ad
return (struct wined3d_format *)((BYTE *)adapter->formats + fmt_idx * adapter->format_size);
}
+static struct wined3d_format_gl *get_format_gl_by_idx(const struct wined3d_adapter *adapter, int fmt_idx)
+{
+ return wined3d_format_gl_mutable(get_format_by_idx(adapter, fmt_idx));
+}
+
static struct wined3d_format *get_format_internal(const struct wined3d_adapter *adapter,
enum wined3d_format_id format_id)
{
@@ -2431,7 +2436,7 @@ static void draw_test_quad(struct wined3d_caps_gl_ctx *ctx, const struct wined3d
}
/* Context activation is done by the caller. */
-static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_format *format)
+static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_format_gl *format)
{
/* Check if the default internal format is supported as a frame buffer
* target, otherwise fall back to the render target internal.
@@ -2440,24 +2445,24 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
static const struct wined3d_color black = {0.0f, 0.0f, 0.0f, 1.0f};
static const struct wined3d_color half_transparent_red = {1.0f, 0.0f, 0.0f, 0.5f};
const struct wined3d_gl_info *gl_info = ctx->gl_info;
- GLenum status, rt_internal = format->rtInternal;
+ GLenum status, rt_internal = format->rt_internal;
GLuint object, color_rb;
enum wined3d_gl_resource_type type;
BOOL fallback_fmt_used = FALSE, regular_fmt_used = FALSE;
gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
- for (type = 0; type < ARRAY_SIZE(format->flags); ++type)
+ for (type = 0; type < ARRAY_SIZE(format->f.flags); ++type)
{
const char *type_string = "color";
if (type == WINED3D_GL_RES_TYPE_BUFFER)
continue;
- create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->glInternal,
- format->glFormat, format->glType);
+ create_and_bind_fbo_attachment(gl_info, format->f.flags[type], type,
+ &object, format->internal, format->format, format->type);
- if (format->flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
+ if (format->f.flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
{
gl_info->fbo_ops.glGenRenderbuffers(1, &color_rb);
gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, color_rb);
@@ -2478,39 +2483,39 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
if (status == GL_FRAMEBUFFER_COMPLETE)
{
TRACE("Format %s is supported as FBO %s attachment, type %u.\n",
- debug_d3dformat(format->id), type_string, type);
- format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
- format->rtInternal = format->glInternal;
+ debug_d3dformat(format->f.id), type_string, type);
+ format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
+ format->rt_internal = format->internal;
regular_fmt_used = TRUE;
}
else
{
if (!rt_internal)
{
- if (format->flags[type] & WINED3DFMT_FLAG_RENDERTARGET)
+ if (format->f.flags[type] & WINED3DFMT_FLAG_RENDERTARGET)
{
WARN("Format %s with rendertarget flag is not supported as FBO color attachment (type %u),"
- " and no fallback specified.\n", debug_d3dformat(format->id), type);
- format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
+ " and no fallback specified.\n", debug_d3dformat(format->f.id), type);
+ format->f.flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
}
else
{
TRACE("Format %s is not supported as FBO %s attachment, type %u.\n",
- debug_d3dformat(format->id), type_string, type);
+ debug_d3dformat(format->f.id), type_string, type);
}
- format->rtInternal = format->glInternal;
+ format->rt_internal = format->internal;
}
else
{
TRACE("Format %s is not supported as FBO %s attachment (type %u),"
" trying rtInternal format as fallback.\n",
- debug_d3dformat(format->id), type_string, type);
+ debug_d3dformat(format->f.id), type_string, type);
while (gl_info->gl_ops.gl.p_glGetError());
delete_fbo_attachment(gl_info, type, object);
- create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->rtInternal,
- format->glFormat, format->glType);
+ create_and_bind_fbo_attachment(gl_info, format->f.flags[type], type,
+ &object, format->rt_internal, format->format, format->type);
status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
checkGLcall("Framebuffer format check");
@@ -2518,25 +2523,25 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
if (status == GL_FRAMEBUFFER_COMPLETE)
{
TRACE("Format %s rtInternal format is supported as FBO %s attachment, type %u.\n",
- debug_d3dformat(format->id), type_string, type);
+ debug_d3dformat(format->f.id), type_string, type);
fallback_fmt_used = TRUE;
}
else
{
WARN("Format %s rtInternal format is not supported as FBO %s attachment, type %u.\n",
- debug_d3dformat(format->id), type_string, type);
- format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
+ debug_d3dformat(format->f.id), type_string, type);
+ format->f.flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
}
}
}
if (status == GL_FRAMEBUFFER_COMPLETE
- && ((format->flags[type] & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
+ && ((format->f.flags[type] & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
|| !(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING))
- && !(format->flags[type] & WINED3DFMT_FLAG_INTEGER)
- && format->id != WINED3DFMT_NULL && format->id != WINED3DFMT_P8_UINT
- && format->glFormat != GL_LUMINANCE && format->glFormat != GL_LUMINANCE_ALPHA
- && (format->red_size || format->alpha_size))
+ && !(format->f.flags[type] & WINED3DFMT_FLAG_INTEGER)
+ && format->f.id != WINED3DFMT_NULL && format->f.id != WINED3DFMT_P8_UINT
+ && format->format != GL_LUMINANCE && format->format != GL_LUMINANCE_ALPHA
+ && (format->f.red_size || format->f.alpha_size))
{
DWORD readback[16 * 16 * 16], color, r_range, a_range;
BYTE r, a;
@@ -2564,8 +2569,8 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
{
while (gl_info->gl_ops.gl.p_glGetError());
TRACE("Format %s doesn't support post-pixelshader blending, type %u.\n",
- debug_d3dformat(format->id), type);
- format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
+ debug_d3dformat(format->f.id), type);
+ format->f.flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
}
else
{
@@ -2628,25 +2633,25 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
a = color >> 24;
r = (color & 0x00ff0000u) >> 16;
- r_range = format->red_size < 8 ? 1u << (8 - format->red_size) : 1;
- a_range = format->alpha_size < 8 ? 1u << (8 - format->alpha_size) : 1;
- if (format->red_size && (r < 0x7f - r_range || r > 0x7f + r_range))
+ r_range = format->f.red_size < 8 ? 1u << (8 - format->f.red_size) : 1;
+ a_range = format->f.alpha_size < 8 ? 1u << (8 - format->f.alpha_size) : 1;
+ if (format->f.red_size && (r < 0x7f - r_range || r > 0x7f + r_range))
match = FALSE;
- else if (format->alpha_size > 1 && (a < 0xbf - a_range || a > 0xbf + a_range))
+ else if (format->f.alpha_size > 1 && (a < 0xbf - a_range || a > 0xbf + a_range))
match = FALSE;
if (!match)
{
TRACE("Format %s doesn't support post-pixelshader blending, type %u.\n",
- debug_d3dformat(format->id), type);
+ debug_d3dformat(format->f.id), type);
TRACE("Color output: %#x\n", color);
- format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
+ format->f.flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
}
else
{
TRACE("Format %s supports post-pixelshader blending, type %u.\n",
- debug_d3dformat(format->id), type);
+ debug_d3dformat(format->f.id), type);
TRACE("Color output: %#x\n", color);
- format->flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
+ format->f.flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
}
}
@@ -2660,11 +2665,11 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
}
}
- if (format->glInternal != format->glGammaInternal)
+ if (format->internal != format->srgb_internal)
{
delete_fbo_attachment(gl_info, type, object);
- create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->glGammaInternal,
- format->glFormat, format->glType);
+ create_and_bind_fbo_attachment(gl_info, format->f.flags[type], type, &object, format->srgb_internal,
+ format->format, format->type);
status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
checkGLcall("Framebuffer format check");
@@ -2672,22 +2677,22 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
if (status == GL_FRAMEBUFFER_COMPLETE)
{
TRACE("Format %s's sRGB format is FBO attachable, type %u.\n",
- debug_d3dformat(format->id), type);
- format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
+ debug_d3dformat(format->f.id), type);
+ format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
- format->glInternal = format->glGammaInternal;
+ format->internal = format->srgb_internal;
}
else
{
WARN("Format %s's sRGB format is not FBO attachable, type %u.\n",
- debug_d3dformat(format->id), type);
- format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE);
+ debug_d3dformat(format->f.id), type);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_WRITE);
}
}
else if (status == GL_FRAMEBUFFER_COMPLETE)
- format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
+ format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
- if (format->flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
+ if (format->f.flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
{
gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0);
gl_info->fbo_ops.glDeleteRenderbuffers(1, &color_rb);
@@ -2700,30 +2705,30 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
if (fallback_fmt_used && regular_fmt_used)
{
FIXME("Format %s needs different render target formats for different resource types.\n",
- debug_d3dformat(format->id));
- format_clear_flag(format, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE
+ debug_d3dformat(format->f.id));
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE
| WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING);
}
}
-static void query_format_flag(struct wined3d_gl_info *gl_info, struct wined3d_format *format,
+static void query_format_flag(struct wined3d_gl_info *gl_info, struct wined3d_format_gl *format,
GLint internal, GLenum pname, DWORD flag, const char *string)
{
GLint value;
enum wined3d_gl_resource_type type;
- for (type = 0; type < ARRAY_SIZE(format->flags); ++type)
+ for (type = 0; type < ARRAY_SIZE(format->f.flags); ++type)
{
gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type), internal, pname, 1, &value);
if (value == GL_FULL_SUPPORT)
{
- TRACE("Format %s supports %s, resource type %u.\n", debug_d3dformat(format->id), string, type);
- format->flags[type] |= flag;
+ TRACE("Format %s supports %s, resource type %u.\n", debug_d3dformat(format->f.id), string, type);
+ format->f.flags[type] |= flag;
}
else
{
- TRACE("Format %s doesn't support %s, resource type %u.\n", debug_d3dformat(format->id), string, type);
- format->flags[type] &= ~flag;
+ TRACE("Format %s doesn't support %s, resource type %u.\n", debug_d3dformat(format->f.id), string, type);
+ format->f.flags[type] &= ~flag;
}
}
}
@@ -2740,56 +2745,56 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter,
{
for (i = 0; i < WINED3D_FORMAT_COUNT; ++i)
{
- struct wined3d_format *format = get_format_by_idx(adapter, i);
+ struct wined3d_format_gl *format = get_format_gl_by_idx(adapter, i);
BOOL fallback_fmt_used = FALSE, regular_fmt_used = FALSE;
- GLenum rt_internal = format->rtInternal;
+ GLenum rt_internal = format->rt_internal;
GLint value;
- if (!format->glInternal)
+ if (!format->internal)
continue;
- for (type = 0; type < ARRAY_SIZE(format->flags); ++type)
+ for (type = 0; type < ARRAY_SIZE(format->f.flags); ++type)
{
gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type),
- format->glInternal, GL_FRAMEBUFFER_RENDERABLE, 1, &value);
+ format->internal, GL_FRAMEBUFFER_RENDERABLE, 1, &value);
if (value == GL_FULL_SUPPORT)
{
TRACE("Format %s is supported as FBO color attachment, resource type %u.\n",
- debug_d3dformat(format->id), type);
- format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
- format->rtInternal = format->glInternal;
+ debug_d3dformat(format->f.id), type);
+ format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
+ format->rt_internal = format->internal;
regular_fmt_used = TRUE;
gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type),
- format->glInternal, GL_FRAMEBUFFER_BLEND, 1, &value);
+ format->internal, GL_FRAMEBUFFER_BLEND, 1, &value);
if (value == GL_FULL_SUPPORT)
{
TRACE("Format %s supports post-pixelshader blending, resource type %u.\n",
- debug_d3dformat(format->id), type);
- format->flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
+ debug_d3dformat(format->f.id), type);
+ format->f.flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
}
else
{
TRACE("Format %s doesn't support post-pixelshader blending, resource typed %u.\n",
- debug_d3dformat(format->id), type);
- format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
+ debug_d3dformat(format->f.id), type);
+ format->f.flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
}
}
else
{
if (!rt_internal)
{
- if (format->flags[type] & WINED3DFMT_FLAG_RENDERTARGET)
+ if (format->f.flags[type] & WINED3DFMT_FLAG_RENDERTARGET)
{
WARN("Format %s with rendertarget flag is not supported as FBO color attachment"
" and no fallback specified, resource type %u.\n",
- debug_d3dformat(format->id), type);
- format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
+ debug_d3dformat(format->f.id), type);
+ format->f.flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
}
else
TRACE("Format %s is not supported as FBO color attachment,"
- " resource type %u.\n", debug_d3dformat(format->id), type);
- format->rtInternal = format->glInternal;
+ " resource type %u.\n", debug_d3dformat(format->f.id), type);
+ format->rt_internal = format->internal;
}
else
{
@@ -2798,46 +2803,46 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter,
if (value == GL_FULL_SUPPORT)
{
TRACE("Format %s rtInternal format is supported as FBO color attachment,"
- " resource type %u.\n", debug_d3dformat(format->id), type);
+ " resource type %u.\n", debug_d3dformat(format->f.id), type);
fallback_fmt_used = TRUE;
}
else
{
WARN("Format %s rtInternal format is not supported as FBO color attachment,"
- " resource type %u.\n", debug_d3dformat(format->id), type);
- format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
+ " resource type %u.\n", debug_d3dformat(format->f.id), type);
+ format->f.flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
}
}
}
- if (format->glInternal != format->glGammaInternal)
+ if (format->internal != format->srgb_internal)
{
gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type),
- format->glGammaInternal, GL_FRAMEBUFFER_RENDERABLE, 1, &value);
+ format->srgb_internal, GL_FRAMEBUFFER_RENDERABLE, 1, &value);
if (value == GL_FULL_SUPPORT)
{
TRACE("Format %s's sRGB format is FBO attachable, resource type %u.\n",
- debug_d3dformat(format->id), type);
- format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
+ debug_d3dformat(format->f.id), type);
+ format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
- format->glInternal = format->glGammaInternal;
+ format->internal = format->srgb_internal;
}
else
{
WARN("Format %s's sRGB format is not FBO attachable, resource type %u.\n",
- debug_d3dformat(format->id), type);
- format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE);
+ debug_d3dformat(format->f.id), type);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_WRITE);
}
}
- else if (format->flags[type] & WINED3DFMT_FLAG_FBO_ATTACHABLE)
- format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
+ else if (format->f.flags[type] & WINED3DFMT_FLAG_FBO_ATTACHABLE)
+ format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
}
if (fallback_fmt_used && regular_fmt_used)
{
FIXME("Format %s needs different render target formats for different resource types.\n",
- debug_d3dformat(format->id));
- format_clear_flag(format, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE
+ debug_d3dformat(format->f.id));
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE
| WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING);
}
}
@@ -2854,25 +2859,26 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter,
for (i = 0; i < WINED3D_FORMAT_COUNT; ++i)
{
- struct wined3d_format *format = get_format_by_idx(adapter, i);
+ struct wined3d_format_gl *format = get_format_gl_by_idx(adapter, i);
- if (!format->glInternal) continue;
+ if (!format->internal)
+ continue;
- if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED)
+ if (format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED)
{
TRACE("Skipping format %s because it's a compressed format.\n",
- debug_d3dformat(format->id));
+ debug_d3dformat(format->f.id));
continue;
}
if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
{
- TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(format->id));
+ TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(format->f.id));
check_fbo_compat(ctx, format);
}
else
{
- format->rtInternal = format->glInternal;
+ format->rt_internal = format->internal;
}
}
@@ -2995,9 +3001,9 @@ static void query_view_class(struct wined3d_format_gl *format)
{
GLenum internal_view_class, gamma_view_class, rt_view_class;
- internal_view_class = lookup_gl_view_class(format->f.glInternal);
- gamma_view_class = lookup_gl_view_class(format->f.glGammaInternal);
- rt_view_class = lookup_gl_view_class(format->f.rtInternal);
+ internal_view_class = lookup_gl_view_class(format->internal);
+ gamma_view_class = lookup_gl_view_class(format->srgb_internal);
+ rt_view_class = lookup_gl_view_class(format->rt_internal);
if (internal_view_class == gamma_view_class || gamma_view_class == rt_view_class)
{
@@ -3012,7 +3018,7 @@ static void query_view_class(struct wined3d_format_gl *format)
}
static void query_internal_format(struct wined3d_adapter *adapter,
- struct wined3d_format *format, const struct wined3d_format_texture_info *texture_info,
+ struct wined3d_format_gl *format, const struct wined3d_format_texture_info *texture_info,
struct wined3d_gl_info *gl_info, BOOL srgb_write_supported, BOOL srgb_format)
{
GLint count, multisample_types[8];
@@ -3021,105 +3027,106 @@ static void query_internal_format(struct wined3d_adapter *adapter,
if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2])
{
- query_format_flag(gl_info, format, format->glInternal, GL_VERTEX_TEXTURE,
+ query_format_flag(gl_info, format, format->internal, GL_VERTEX_TEXTURE,
WINED3DFMT_FLAG_VTF, "vertex texture usage");
- query_format_flag(gl_info, format, format->glInternal, GL_FILTER,
+ query_format_flag(gl_info, format, format->internal, GL_FILTER,
WINED3DFMT_FLAG_FILTERING, "filtering");
- if (srgb_format || format->glGammaInternal != format->glInternal)
+ if (srgb_format || format->srgb_internal != format->internal)
{
- query_format_flag(gl_info, format, format->glGammaInternal, GL_SRGB_READ,
+ query_format_flag(gl_info, format, format->srgb_internal, GL_SRGB_READ,
WINED3DFMT_FLAG_SRGB_READ, "sRGB read");
if (srgb_write_supported)
- query_format_flag(gl_info, format, format->glGammaInternal, GL_SRGB_WRITE,
+ query_format_flag(gl_info, format, format->srgb_internal, GL_SRGB_WRITE,
WINED3DFMT_FLAG_SRGB_WRITE, "sRGB write");
else
- format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_WRITE);
- if (!(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE)))
- format->glGammaInternal = format->glInternal;
+ if (!(format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D]
+ & (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE)))
+ format->srgb_internal = format->internal;
else if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
&& gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
- format->glInternal = format->glGammaInternal;
+ format->internal = format->srgb_internal;
}
}
else
{
if (!gl_info->limits.samplers[WINED3D_SHADER_TYPE_VERTEX])
- format_clear_flag(format, WINED3DFMT_FLAG_VTF);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_VTF);
if (!(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING))
- format_set_flag(format, WINED3DFMT_FLAG_FILTERING);
- else if (format->id != WINED3DFMT_R32G32B32A32_FLOAT && format->id != WINED3DFMT_R32_FLOAT)
- format_clear_flag(format, WINED3DFMT_FLAG_VTF);
+ format_set_flag(&format->f, WINED3DFMT_FLAG_FILTERING);
+ else if (format->f.id != WINED3DFMT_R32G32B32A32_FLOAT && format->f.id != WINED3DFMT_R32_FLOAT)
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_VTF);
- if (srgb_format || format->glGammaInternal != format->glInternal)
+ if (srgb_format || format->srgb_internal != format->internal)
{
/* Filter sRGB capabilities if EXT_texture_sRGB is not supported. */
if (!gl_info->supported[EXT_TEXTURE_SRGB])
{
- format->glGammaInternal = format->glInternal;
- format_clear_flag(format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
+ format->srgb_internal = format->internal;
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
}
else if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
&& gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
{
- format->glInternal = format->glGammaInternal;
+ format->internal = format->srgb_internal;
}
}
- if ((format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_SRGB_WRITE) && !srgb_write_supported)
- format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE);
+ if ((format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_SRGB_WRITE) && !srgb_write_supported)
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_WRITE);
if (!gl_info->supported[ARB_DEPTH_TEXTURE]
&& texture_info->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
{
- format->flags[WINED3D_GL_RES_TYPE_TEX_1D] &= ~WINED3DFMT_FLAG_TEXTURE;
- format->flags[WINED3D_GL_RES_TYPE_TEX_2D] &= ~WINED3DFMT_FLAG_TEXTURE;
- format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
- format->flags[WINED3D_GL_RES_TYPE_TEX_CUBE] &= ~WINED3DFMT_FLAG_TEXTURE;
- format->flags[WINED3D_GL_RES_TYPE_TEX_RECT] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_1D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_CUBE] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_RECT] &= ~WINED3DFMT_FLAG_TEXTURE;
}
}
- query_view_class(wined3d_format_gl_mutable(format));
+ query_view_class(format);
- if (format->glInternal && format->flags[WINED3D_GL_RES_TYPE_RB]
+ if (format->internal && format->f.flags[WINED3D_GL_RES_TYPE_RB]
& (WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
{
if (gl_info->supported[ARB_INTERNALFORMAT_QUERY])
{
target = gl_info->supported[ARB_TEXTURE_MULTISAMPLE] ? GL_TEXTURE_2D_MULTISAMPLE : GL_RENDERBUFFER;
count = 0;
- GL_EXTCALL(glGetInternalformativ(target, format->glInternal,
+ GL_EXTCALL(glGetInternalformativ(target, format->internal,
GL_NUM_SAMPLE_COUNTS, 1, &count));
if (count > ARRAY_SIZE(multisample_types))
FIXME("Unexpectedly high number of multisample types %d.\n", count);
count = min(count, ARRAY_SIZE(multisample_types));
- GL_EXTCALL(glGetInternalformativ(target, format->glInternal,
+ GL_EXTCALL(glGetInternalformativ(target, format->internal,
GL_SAMPLES, count, multisample_types));
checkGLcall("query sample counts");
for (i = 0; i < count; ++i)
{
- if (multisample_types[i] > sizeof(format->multisample_types) * CHAR_BIT)
+ if (multisample_types[i] > sizeof(format->f.multisample_types) * CHAR_BIT)
continue;
- format->multisample_types |= 1u << (multisample_types[i] - 1);
+ format->f.multisample_types |= 1u << (multisample_types[i] - 1);
}
}
else
{
max_log2 = wined3d_log2i(min(gl_info->limits.samples,
- sizeof(format->multisample_types) * CHAR_BIT));
+ sizeof(format->f.multisample_types) * CHAR_BIT));
for (i = 1; i <= max_log2; ++i)
- format->multisample_types |= 1u << ((1u << i) - 1);
+ format->f.multisample_types |= 1u << ((1u << i) - 1);
}
}
}
static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info)
{
- struct wined3d_format *format, *srgb_format;
+ struct wined3d_format_gl *format, *srgb_format;
struct fragment_caps fragment_caps;
struct shader_caps shader_caps;
unsigned int i, j;
@@ -3132,7 +3139,7 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win
for (i = 0; i < ARRAY_SIZE(format_texture_info); ++i)
{
- if (!(format = get_format_internal(adapter, format_texture_info[i].id)))
+ if (!(format = get_format_gl_internal(adapter, format_texture_info[i].id)))
return FALSE;
if (!gl_info->supported[format_texture_info[i].extension])
@@ -3141,62 +3148,62 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win
/* ARB_texture_rg defines floating point formats, but only if
* ARB_texture_float is also supported. */
if (!gl_info->supported[ARB_TEXTURE_FLOAT]
- && (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT))
+ && (format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT))
continue;
/* ARB_texture_rg defines integer formats if EXT_texture_integer is also supported. */
if (!gl_info->supported[EXT_TEXTURE_INTEGER]
- && (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_INTEGER))
+ && (format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_INTEGER))
continue;
- 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->height_scale.numerator = 1;
- format->height_scale.denominator = 1;
+ format->internal = format_texture_info[i].gl_internal;
+ format->srgb_internal = format_texture_info[i].gl_srgb_internal;
+ format->rt_internal = format_texture_info[i].gl_rt_internal;
+ format->format = format_texture_info[i].gl_format;
+ format->type = format_texture_info[i].gl_type;
+ format->f.color_fixup = COLOR_FIXUP_IDENTITY;
+ format->f.height_scale.numerator = 1;
+ format->f.height_scale.denominator = 1;
- format->flags[WINED3D_GL_RES_TYPE_TEX_1D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
- format->flags[WINED3D_GL_RES_TYPE_TEX_2D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
- format->flags[WINED3D_GL_RES_TYPE_BUFFER] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_1D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
+ format->f.flags[WINED3D_GL_RES_TYPE_BUFFER] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
/* GL_ARB_depth_texture does not support 3D textures. It also says "cube textures are
* problematic", but doesn't explicitly mandate that an error is generated. */
if (gl_info->supported[EXT_TEXTURE3D]
&& !(format_texture_info[i].flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
- format->flags[WINED3D_GL_RES_TYPE_TEX_3D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
- format->flags[WINED3D_GL_RES_TYPE_TEX_CUBE] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_CUBE] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
- format->flags[WINED3D_GL_RES_TYPE_TEX_RECT] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_RECT] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
- format->flags[WINED3D_GL_RES_TYPE_RB] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
- format->flags[WINED3D_GL_RES_TYPE_RB] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format->f.flags[WINED3D_GL_RES_TYPE_RB] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT;
+ format->f.flags[WINED3D_GL_RES_TYPE_RB] &= ~WINED3DFMT_FLAG_TEXTURE;
- if (format->glGammaInternal != format->glInternal
+ if (format->srgb_internal != format->internal
&& !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL))
{
- format->glGammaInternal = format->glInternal;
- format_clear_flag(format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
+ format->srgb_internal = format->internal;
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
}
query_internal_format(adapter, format, &format_texture_info[i], gl_info, srgb_write, FALSE);
/* Texture conversion stuff */
- format->conv_byte_count = format_texture_info[i].conv_byte_count;
- format->upload = format_texture_info[i].upload;
- format->download = format_texture_info[i].download;
+ format->f.conv_byte_count = format_texture_info[i].conv_byte_count;
+ format->f.upload = format_texture_info[i].upload;
+ format->f.download = format_texture_info[i].download;
srgb_format = NULL;
for (j = 0; j < ARRAY_SIZE(format_srgb_info); ++j)
{
- if (format_srgb_info[j].base_format_id == format->id)
+ if (format_srgb_info[j].base_format_id == format->f.id)
{
- if (!(srgb_format = get_format_internal(adapter, format_srgb_info[j].srgb_format_id)))
+ if (!(srgb_format = get_format_gl_internal(adapter, format_srgb_info[j].srgb_format_id)))
return FALSE;
break;
}
@@ -3204,14 +3211,14 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win
if (!srgb_format)
continue;
- copy_format(adapter, srgb_format, format);
+ copy_format(adapter, &srgb_format->f, &format->f);
if (gl_info->supported[EXT_TEXTURE_SRGB]
&& !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL))
{
- srgb_format->glInternal = format_texture_info[i].gl_srgb_internal;
- srgb_format->glGammaInternal = format_texture_info[i].gl_srgb_internal;
- format_set_flag(srgb_format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
+ srgb_format->internal = format_texture_info[i].gl_srgb_internal;
+ srgb_format->srgb_internal = format_texture_info[i].gl_srgb_internal;
+ format_set_flag(&srgb_format->f, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
query_internal_format(adapter, srgb_format, &format_texture_info[i], gl_info, srgb_write, TRUE);
}
}
@@ -3335,7 +3342,7 @@ static void init_format_filter_info(struct wined3d_adapter *adapter,
struct wined3d_gl_info *gl_info)
{
enum wined3d_pci_vendor vendor = adapter->driver_info.vendor;
- struct wined3d_format *format;
+ struct wined3d_format_gl *format;
unsigned int i;
static const enum wined3d_format_id fmts16[] =
{
@@ -3373,8 +3380,8 @@ static void init_format_filter_info(struct wined3d_adapter *adapter,
{
for (i = 0; i < ARRAY_SIZE(fmts16); ++i)
{
- format = get_format_internal(adapter, fmts16[i]);
- format_set_flag(format, WINED3DFMT_FLAG_FILTERING);
+ format = get_format_gl_internal(adapter, fmts16[i]);
+ format_set_flag(&format->f, WINED3DFMT_FLAG_FILTERING);
}
}
return;
@@ -3382,19 +3389,19 @@ static void init_format_filter_info(struct wined3d_adapter *adapter,
for (i = 0; i < ARRAY_SIZE(fmts16); ++i)
{
- format = get_format_internal(adapter, fmts16[i]);
- if (!format->glInternal)
+ format = get_format_gl_internal(adapter, fmts16[i]);
+ if (!format->internal)
continue; /* Not supported by GL */
- filtered = check_filter(gl_info, format->glInternal);
+ filtered = check_filter(gl_info, format->internal);
if (filtered)
{
- TRACE("Format %s supports filtering.\n", debug_d3dformat(format->id));
- format_set_flag(format, WINED3DFMT_FLAG_FILTERING);
+ TRACE("Format %s supports filtering.\n", debug_d3dformat(format->f.id));
+ format_set_flag(&format->f, WINED3DFMT_FLAG_FILTERING);
}
else
{
- TRACE("Format %s does not support filtering.\n", debug_d3dformat(format->id));
+ TRACE("Format %s does not support filtering.\n", debug_d3dformat(format->f.id));
}
}
}
@@ -3455,7 +3462,7 @@ static struct color_fixup_desc create_color_fixup_desc_from_string(const char *s
static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info)
{
const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info;
- struct wined3d_format *format;
+ struct wined3d_format_gl *format;
BOOL use_legacy_fixups;
unsigned int i;
@@ -3527,79 +3534,79 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_
if (!gl_info->supported[fixups[i].extension])
continue;
- format = get_format_internal(adapter, fixups[i].id);
- format->color_fixup = create_color_fixup_desc_from_string(fixups[i].fixup);
+ format = get_format_gl_internal(adapter, fixups[i].id);
+ format->f.color_fixup = create_color_fixup_desc_from_string(fixups[i].fixup);
}
if (!gl_info->supported[APPLE_YCBCR_422] && (gl_info->supported[ARB_FRAGMENT_PROGRAM]
|| (gl_info->supported[ARB_FRAGMENT_SHADER] && gl_info->supported[ARB_VERTEX_SHADER])))
{
- format = get_format_internal(adapter, WINED3DFMT_YUY2);
- format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
+ format = get_format_gl_internal(adapter, WINED3DFMT_YUY2);
+ format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
- format = get_format_internal(adapter, WINED3DFMT_UYVY);
- format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY);
+ format = get_format_gl_internal(adapter, WINED3DFMT_UYVY);
+ format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY);
}
else if (!gl_info->supported[APPLE_YCBCR_422] && (!gl_info->supported[ARB_FRAGMENT_PROGRAM]
&& (!gl_info->supported[ARB_FRAGMENT_SHADER] || !gl_info->supported[ARB_VERTEX_SHADER])))
{
- format = get_format_internal(adapter, WINED3DFMT_YUY2);
- format_clear_flag(format, WINED3DFMT_FLAG_BLIT);
- format->glInternal = 0;
+ format = get_format_gl_internal(adapter, WINED3DFMT_YUY2);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_BLIT);
+ format->internal = 0;
- format = get_format_internal(adapter, WINED3DFMT_UYVY);
- format_clear_flag(format, WINED3DFMT_FLAG_BLIT);
- format->glInternal = 0;
+ format = get_format_gl_internal(adapter, WINED3DFMT_UYVY);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_BLIT);
+ format->internal = 0;
}
if (gl_info->supported[ARB_FRAGMENT_PROGRAM]
|| (gl_info->supported[ARB_FRAGMENT_SHADER] && gl_info->supported[ARB_VERTEX_SHADER]))
{
- format = get_format_internal(adapter, WINED3DFMT_YV12);
- format_set_flag(format, WINED3DFMT_FLAG_HEIGHT_SCALE);
- format->height_scale.numerator = 3;
- format->height_scale.denominator = 2;
- format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12);
+ format = get_format_gl_internal(adapter, WINED3DFMT_YV12);
+ format_set_flag(&format->f, WINED3DFMT_FLAG_HEIGHT_SCALE);
+ format->f.height_scale.numerator = 3;
+ format->f.height_scale.denominator = 2;
+ format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12);
- format = get_format_internal(adapter, WINED3DFMT_NV12);
- format_set_flag(format, WINED3DFMT_FLAG_HEIGHT_SCALE);
- format->height_scale.numerator = 3;
- format->height_scale.denominator = 2;
- format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_NV12);
+ format = get_format_gl_internal(adapter, WINED3DFMT_NV12);
+ format_set_flag(&format->f, WINED3DFMT_FLAG_HEIGHT_SCALE);
+ format->f.height_scale.numerator = 3;
+ format->f.height_scale.denominator = 2;
+ format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_NV12);
}
else
{
- format = get_format_internal(adapter, WINED3DFMT_YV12);
- format_clear_flag(format, WINED3DFMT_FLAG_BLIT);
- format->glInternal = 0;
+ format = get_format_gl_internal(adapter, WINED3DFMT_YV12);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_BLIT);
+ format->internal = 0;
- format = get_format_internal(adapter, WINED3DFMT_NV12);
- format_clear_flag(format, WINED3DFMT_FLAG_BLIT);
- format->glInternal = 0;
+ format = get_format_gl_internal(adapter, WINED3DFMT_NV12);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_BLIT);
+ format->internal = 0;
}
if (gl_info->supported[ARB_FRAGMENT_PROGRAM] || gl_info->supported[ARB_FRAGMENT_SHADER])
{
- format = get_format_internal(adapter, WINED3DFMT_P8_UINT);
- format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
+ format = get_format_gl_internal(adapter, WINED3DFMT_P8_UINT);
+ format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
}
if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
{
- format = get_format_internal(adapter, WINED3DFMT_R16_FLOAT);
- format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE);
+ format = get_format_gl_internal(adapter, WINED3DFMT_R16_FLOAT);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE);
- format = get_format_internal(adapter, WINED3DFMT_R16G16_FLOAT);
- format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE);
+ format = get_format_gl_internal(adapter, WINED3DFMT_R16G16_FLOAT);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE);
- format = get_format_internal(adapter, WINED3DFMT_R16G16B16A16_FLOAT);
- format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE);
+ format = get_format_gl_internal(adapter, WINED3DFMT_R16G16B16A16_FLOAT);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE);
}
if (gl_info->quirks & WINED3D_QUIRK_BROKEN_RGBA16)
{
- format = get_format_internal(adapter, WINED3DFMT_R16G16B16A16_UNORM);
- format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE);
+ format = get_format_gl_internal(adapter, WINED3DFMT_R16G16B16A16_UNORM);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE);
}
/* ATI instancing hack: Although ATI cards do not support Shader Model
@@ -3617,8 +3624,8 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_
/* FIXME: This should just check the shader backend caps. */
if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER])
{
- format = get_format_internal(adapter, WINED3DFMT_INST);
- format_set_flag(format, WINED3DFMT_FLAG_TEXTURE);
+ format = get_format_gl_internal(adapter, WINED3DFMT_INST);
+ format_set_flag(&format->f, WINED3DFMT_FLAG_TEXTURE);
}
/* Depth bound test. To query if the card supports it CheckDeviceFormat()
@@ -3629,8 +3636,8 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_
* value. */
if (gl_info->supported[EXT_DEPTH_BOUNDS_TEST])
{
- format = get_format_internal(adapter, WINED3DFMT_NVDB);
- format_set_flag(format, WINED3DFMT_FLAG_TEXTURE);
+ format = get_format_gl_internal(adapter, WINED3DFMT_NVDB);
+ format_set_flag(&format->f, WINED3DFMT_FLAG_TEXTURE);
}
/* RESZ aka AMD DX9-level hack for multisampled depth buffer resolve. You query for RESZ
@@ -3638,27 +3645,27 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_
* RENDERTARGET usage. */
if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
{
- format = get_format_internal(adapter, WINED3DFMT_RESZ);
- format_set_flag(format, WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET);
+ format = get_format_gl_internal(adapter, WINED3DFMT_RESZ);
+ format_set_flag(&format->f, WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET);
}
for (i = 0; i < WINED3D_FORMAT_COUNT; ++i)
{
- struct wined3d_format *format = get_format_by_idx(adapter, i);
+ format = get_format_gl_by_idx(adapter, i);
- if (!(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_TEXTURE))
+ if (!(format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_TEXTURE))
continue;
- if (is_identity_fixup(format->color_fixup))
+ if (is_identity_fixup(format->f.color_fixup))
continue;
TRACE("Checking support for fixup:\n");
- dump_color_fixup_desc(format->color_fixup);
- if (!adapter->shader_backend->shader_color_fixup_supported(format->color_fixup)
- || !adapter->fragment_pipe->color_fixup_supported(format->color_fixup))
+ dump_color_fixup_desc(format->f.color_fixup);
+ if (!adapter->shader_backend->shader_color_fixup_supported(format->f.color_fixup)
+ || !adapter->fragment_pipe->color_fixup_supported(format->f.color_fixup))
{
TRACE("[FAILED]\n");
- format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE);
+ format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE);
}
else
{
@@ -3668,18 +3675,18 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_
/* These formats are not supported for 3D textures. See also
* WINED3DFMT_FLAG_DECOMPRESS. */
- format = get_format_internal(adapter, WINED3DFMT_ATI1N);
- format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
- format = get_format_internal(adapter, WINED3DFMT_ATI2N);
- format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
- format = get_format_internal(adapter, WINED3DFMT_BC4_UNORM);
- format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
- format = get_format_internal(adapter, WINED3DFMT_BC4_SNORM);
- format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
- format = get_format_internal(adapter, WINED3DFMT_BC5_UNORM);
- format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
- format = get_format_internal(adapter, WINED3DFMT_BC5_SNORM);
- format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format = get_format_gl_internal(adapter, WINED3DFMT_ATI1N);
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format = get_format_gl_internal(adapter, WINED3DFMT_ATI2N);
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format = get_format_gl_internal(adapter, WINED3DFMT_BC4_UNORM);
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format = get_format_gl_internal(adapter, WINED3DFMT_BC4_SNORM);
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format = get_format_gl_internal(adapter, WINED3DFMT_BC5_UNORM);
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
+ format = get_format_gl_internal(adapter, WINED3DFMT_BC5_SNORM);
+ format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
}
static BOOL init_format_vertex_info(const struct wined3d_adapter *adapter,
@@ -3936,22 +3943,22 @@ static void init_format_depth_bias_scale(struct wined3d_adapter *adapter,
for (i = 0; i < WINED3D_FORMAT_COUNT; ++i)
{
- struct wined3d_format *format = get_format_by_idx(adapter, i);
+ struct wined3d_format_gl *format = get_format_gl_by_idx(adapter, i);
- if (format->flags[WINED3D_GL_RES_TYPE_RB] & WINED3DFMT_FLAG_DEPTH)
+ if (format->f.flags[WINED3D_GL_RES_TYPE_RB] & WINED3DFMT_FLAG_DEPTH)
{
- TRACE("Testing depth bias scale for format %s.\n", debug_d3dformat(format->id));
- format->depth_bias_scale = wined3d_adapter_find_polyoffset_scale(ctx, format->glInternal);
+ TRACE("Testing depth bias scale for format %s.\n", debug_d3dformat(format->f.id));
+ format->f.depth_bias_scale = wined3d_adapter_find_polyoffset_scale(ctx, format->internal);
if (!(d3d_info->wined3d_creation_flags & WINED3D_NORMALIZED_DEPTH_BIAS))
{
/* The single-precision binary floating-point format has
* a significand precision of 24 bits.
*/
- if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT)
- format->depth_bias_scale /= 1u << 24;
+ if (format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT)
+ format->f.depth_bias_scale /= 1u << 24;
else
- format->depth_bias_scale /= 1u << format->depth_size;
+ format->f.depth_bias_scale /= 1u << format->f.depth_size;
}
}
}
diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c
index dedb9fc8047..ff284684089 100644
--- a/dlls/wined3d/view.c
+++ b/dlls/wined3d/view.c
@@ -169,11 +169,13 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target
const struct wined3d_view_desc *desc, struct wined3d_texture *texture,
const struct wined3d_format *view_format)
{
+ const struct wined3d_format_gl *view_format_gl;
unsigned int level_idx, layer_idx, layer_count;
const struct wined3d_gl_info *gl_info;
struct wined3d_context *context;
GLuint texture_name;
+ view_format_gl = wined3d_format_gl(view_format);
view->target = view_target;
context = context_acquire(texture->resource.device, NULL, 0);
@@ -201,11 +203,11 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target
}
gl_info->gl_ops.gl.p_glGenTextures(1, &view->name);
- GL_EXTCALL(glTextureView(view->name, view->target, texture_name, view_format->glInternal,
+ GL_EXTCALL(glTextureView(view->name, view->target, texture_name, view_format_gl->internal,
level_idx, desc->u.texture.level_count, layer_idx, layer_count));
checkGLcall("create texture view");
- if (is_stencil_view_format(view_format))
+ if (is_stencil_view_format(&view_format_gl->f))
{
static const GLint swizzle[] = {GL_ZERO, GL_RED, GL_ZERO, GL_ZERO};
@@ -233,6 +235,7 @@ static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_c
unsigned int offset, unsigned int size)
{
const struct wined3d_gl_info *gl_info = context->gl_info;
+ const struct wined3d_format_gl *view_format_gl;
if (!gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
{
@@ -247,6 +250,7 @@ static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_c
return;
}
+ view_format_gl = wined3d_format_gl(view_format);
wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER);
view->target = GL_TEXTURE_BUFFER;
@@ -255,14 +259,14 @@ static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_c
context_bind_texture(context, GL_TEXTURE_BUFFER, view->name);
if (gl_info->supported[ARB_TEXTURE_BUFFER_RANGE])
{
- GL_EXTCALL(glTexBufferRange(GL_TEXTURE_BUFFER, view_format->glInternal,
+ GL_EXTCALL(glTexBufferRange(GL_TEXTURE_BUFFER, view_format_gl->internal,
buffer->buffer_object, offset, size));
}
else
{
if (offset || size != buffer->resource.size)
FIXME("OpenGL implementation does not support ARB_texture_buffer_range.\n");
- GL_EXTCALL(glTexBuffer(GL_TEXTURE_BUFFER, view_format->glInternal, buffer->buffer_object));
+ GL_EXTCALL(glTexBuffer(GL_TEXTURE_BUFFER, view_format_gl->internal, buffer->buffer_object));
}
checkGLcall("Create buffer texture");
@@ -1006,7 +1010,7 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi
const struct wined3d_uvec4 *clear_value, struct wined3d_context *context)
{
const struct wined3d_gl_info *gl_info = context->gl_info;
- const struct wined3d_format *format;
+ const struct wined3d_format_gl *format;
struct wined3d_resource *resource;
struct wined3d_buffer *buffer;
unsigned int offset, size;
@@ -1024,12 +1028,12 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi
return;
}
- format = view->format;
- if (format->id != WINED3DFMT_R32_UINT && format->id != WINED3DFMT_R32_SINT
- && format->id != WINED3DFMT_R32G32B32A32_UINT
- && format->id != WINED3DFMT_R32G32B32A32_SINT)
+ format = wined3d_format_gl(view->format);
+ if (format->f.id != WINED3DFMT_R32_UINT && format->f.id != WINED3DFMT_R32_SINT
+ && format->f.id != WINED3DFMT_R32G32B32A32_UINT
+ && format->f.id != WINED3DFMT_R32G32B32A32_SINT)
{
- FIXME("Not implemented for format %s.\n", debug_d3dformat(format->id));
+ FIXME("Not implemented for format %s.\n", debug_d3dformat(format->f.id));
return;
}
@@ -1037,10 +1041,10 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi
wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER);
wined3d_unordered_access_view_invalidate_location(view, ~WINED3D_LOCATION_BUFFER);
- get_buffer_view_range(buffer, &view->desc, format, &offset, &size);
+ get_buffer_view_range(buffer, &view->desc, &format->f, &offset, &size);
context_bind_bo(context, buffer->buffer_type_hint, buffer->buffer_object);
- GL_EXTCALL(glClearBufferSubData(buffer->buffer_type_hint, format->glInternal,
- offset, size, format->glFormat, format->glType, clear_value));
+ GL_EXTCALL(glClearBufferSubData(buffer->buffer_type_hint, format->internal,
+ offset, size, format->format, format->type, clear_value));
checkGLcall("clear unordered access view");
}
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index cec2cfff330..4c5d73f677e 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -4339,11 +4339,6 @@ struct wined3d_format
enum wined3d_ffp_emit_idx emit_idx;
- GLint glInternal;
- GLint glGammaInternal;
- GLint rtInternal;
- GLint glFormat;
- GLint glType;
UINT conv_byte_count;
DWORD multisample_types;
unsigned int flags[WINED3D_GL_RES_TYPE_COUNT];
@@ -4387,6 +4382,12 @@ struct wined3d_format_gl
GLenum vtx_type;
GLint vtx_format;
+ GLint internal;
+ GLint srgb_internal;
+ GLint rt_internal;
+ GLint format;
+ GLint type;
+
GLenum view_class;
};
--
2.11.0
More information about the wine-devel
mailing list