ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wined3d: Move the OpenGL texture format to struct wined3d_format_gl. 

Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Henri Verbeet 2018-09-22 02:56:09 +03:30 committed by Alexandre Julliard
parent 3ad933d5e6
commit 1606dd39e2
6 changed files with 349 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dlls/wined3d/context.c
View File

@ -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));

48
dlls/wined3d/surface.c
View File

@ -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 */

93
dlls/wined3d/texture.c
View File

@ -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)

485
dlls/wined3d/utils.c
View File

@ -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;
}
}
}

30
dlls/wined3d/view.c
View File

@ -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");
}

11
dlls/wined3d/wined3d_private.h
View File

@ -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;
};