2012-12-05 21:01:47 +01:00
|
|
|
/*
|
2015-01-15 17:19:03 +01:00
|
|
|
* Copyright 2012, 2015 Henri Verbeet for CodeWeavers
|
2012-12-05 21:01:47 +01:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "wine/port.h"
|
|
|
|
|
|
|
|
#include "wined3d_private.h"
|
|
|
|
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
|
|
|
|
|
|
|
|
ULONG CDECL wined3d_sampler_incref(struct wined3d_sampler *sampler)
|
|
|
|
{
|
|
|
|
ULONG refcount = InterlockedIncrement(&sampler->refcount);
|
|
|
|
|
|
|
|
TRACE("%p increasing refcount to %u.\n", sampler, refcount);
|
|
|
|
|
|
|
|
return refcount;
|
|
|
|
}
|
|
|
|
|
2016-08-05 12:38:59 +02:00
|
|
|
static void wined3d_sampler_destroy_object(void *object)
|
2012-12-05 21:01:47 +01:00
|
|
|
{
|
2016-06-22 10:39:00 +02:00
|
|
|
struct wined3d_sampler *sampler = object;
|
2015-01-15 17:19:06 +01:00
|
|
|
const struct wined3d_gl_info *gl_info;
|
|
|
|
struct wined3d_context *context;
|
2012-12-05 21:01:47 +01:00
|
|
|
|
2017-03-20 12:13:03 +01:00
|
|
|
if (sampler->name)
|
|
|
|
{
|
|
|
|
context = context_acquire(sampler->device, NULL, 0);
|
|
|
|
gl_info = context->gl_info;
|
|
|
|
GL_EXTCALL(glDeleteSamplers(1, &sampler->name));
|
|
|
|
context_release(context);
|
|
|
|
}
|
2016-06-22 10:39:00 +02:00
|
|
|
|
2018-02-14 07:39:59 +01:00
|
|
|
heap_free(sampler);
|
2016-06-22 10:39:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ULONG CDECL wined3d_sampler_decref(struct wined3d_sampler *sampler)
|
|
|
|
{
|
|
|
|
ULONG refcount = InterlockedDecrement(&sampler->refcount);
|
|
|
|
|
2012-12-05 21:01:47 +01:00
|
|
|
TRACE("%p decreasing refcount to %u.\n", sampler, refcount);
|
|
|
|
|
|
|
|
if (!refcount)
|
2017-04-26 13:19:54 +02:00
|
|
|
{
|
|
|
|
sampler->parent_ops->wined3d_object_destroyed(sampler->parent);
|
2017-02-16 00:58:53 +01:00
|
|
|
wined3d_cs_destroy_object(sampler->device->cs, wined3d_sampler_destroy_object, sampler);
|
2017-04-26 13:19:54 +02:00
|
|
|
}
|
2012-12-05 21:01:47 +01:00
|
|
|
|
|
|
|
return refcount;
|
|
|
|
}
|
|
|
|
|
|
|
|
void * CDECL wined3d_sampler_get_parent(const struct wined3d_sampler *sampler)
|
|
|
|
{
|
|
|
|
TRACE("sampler %p.\n", sampler);
|
|
|
|
|
|
|
|
return sampler->parent;
|
|
|
|
}
|
|
|
|
|
2017-02-16 00:58:53 +01:00
|
|
|
static void wined3d_sampler_cs_init(void *object)
|
2012-12-05 21:01:47 +01:00
|
|
|
{
|
2017-02-16 00:58:53 +01:00
|
|
|
struct wined3d_sampler *sampler = object;
|
|
|
|
const struct wined3d_sampler_desc *desc;
|
2015-01-15 17:19:06 +01:00
|
|
|
const struct wined3d_gl_info *gl_info;
|
|
|
|
struct wined3d_context *context;
|
|
|
|
|
2017-02-16 00:58:53 +01:00
|
|
|
context = context_acquire(sampler->device, NULL, 0);
|
2015-01-15 17:19:06 +01:00
|
|
|
gl_info = context->gl_info;
|
|
|
|
|
2017-02-16 00:58:53 +01:00
|
|
|
desc = &sampler->desc;
|
2015-01-15 17:19:06 +01:00
|
|
|
GL_EXTCALL(glGenSamplers(1, &sampler->name));
|
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_WRAP_S,
|
|
|
|
gl_info->wrap_lookup[desc->address_u - WINED3D_TADDRESS_WRAP]));
|
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_WRAP_T,
|
|
|
|
gl_info->wrap_lookup[desc->address_v - WINED3D_TADDRESS_WRAP]));
|
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_WRAP_R,
|
|
|
|
gl_info->wrap_lookup[desc->address_w - WINED3D_TADDRESS_WRAP]));
|
|
|
|
GL_EXTCALL(glSamplerParameterfv(sampler->name, GL_TEXTURE_BORDER_COLOR, &desc->border_color[0]));
|
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_MAG_FILTER,
|
|
|
|
wined3d_gl_mag_filter(desc->mag_filter)));
|
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_MIN_FILTER,
|
|
|
|
wined3d_gl_min_mip_filter(desc->min_filter, desc->mip_filter)));
|
|
|
|
GL_EXTCALL(glSamplerParameterf(sampler->name, GL_TEXTURE_LOD_BIAS, desc->lod_bias));
|
|
|
|
GL_EXTCALL(glSamplerParameterf(sampler->name, GL_TEXTURE_MIN_LOD, desc->min_lod));
|
|
|
|
GL_EXTCALL(glSamplerParameterf(sampler->name, GL_TEXTURE_MAX_LOD, desc->max_lod));
|
2017-09-15 15:12:28 +02:00
|
|
|
if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC])
|
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_MAX_ANISOTROPY, desc->max_anisotropy));
|
2015-01-15 17:19:06 +01:00
|
|
|
if (desc->compare)
|
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE));
|
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_COMPARE_FUNC,
|
|
|
|
wined3d_gl_compare_func(desc->comparison_func)));
|
2016-02-12 11:06:09 +01:00
|
|
|
if ((context->d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
|
|
|
|
&& gl_info->supported[EXT_TEXTURE_SRGB_DECODE] && !desc->srgb_decode)
|
2015-01-15 17:19:06 +01:00
|
|
|
GL_EXTCALL(glSamplerParameteri(sampler->name, GL_TEXTURE_SRGB_DECODE_EXT, GL_SKIP_DECODE_EXT));
|
|
|
|
checkGLcall("sampler creation");
|
|
|
|
|
|
|
|
TRACE("Created sampler %u.\n", sampler->name);
|
|
|
|
|
|
|
|
context_release(context);
|
2012-12-05 21:01:47 +01:00
|
|
|
}
|
|
|
|
|
2017-02-16 00:58:53 +01:00
|
|
|
static void wined3d_sampler_init(struct wined3d_sampler *sampler, struct wined3d_device *device,
|
2017-04-26 13:19:54 +02:00
|
|
|
const struct wined3d_sampler_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
|
2017-02-16 00:58:53 +01:00
|
|
|
{
|
|
|
|
sampler->refcount = 1;
|
|
|
|
sampler->device = device;
|
|
|
|
sampler->parent = parent;
|
2017-04-26 13:19:54 +02:00
|
|
|
sampler->parent_ops = parent_ops;
|
2017-02-16 00:58:53 +01:00
|
|
|
sampler->desc = *desc;
|
2017-03-20 12:13:03 +01:00
|
|
|
|
|
|
|
if (device->adapter->gl_info.supported[ARB_SAMPLER_OBJECTS])
|
|
|
|
wined3d_cs_init_object(device->cs, wined3d_sampler_cs_init, sampler);
|
2017-02-16 00:58:53 +01:00
|
|
|
}
|
|
|
|
|
2015-01-15 17:19:06 +01:00
|
|
|
HRESULT CDECL wined3d_sampler_create(struct wined3d_device *device, const struct wined3d_sampler_desc *desc,
|
2017-04-26 13:19:54 +02:00
|
|
|
void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_sampler **sampler)
|
2012-12-05 21:01:47 +01:00
|
|
|
{
|
|
|
|
struct wined3d_sampler *object;
|
|
|
|
|
2015-01-15 17:19:06 +01:00
|
|
|
TRACE("device %p, desc %p, parent %p, sampler %p.\n", device, desc, parent, sampler);
|
|
|
|
|
|
|
|
if (desc->address_u < WINED3D_TADDRESS_WRAP || desc->address_u > WINED3D_TADDRESS_MIRROR_ONCE
|
|
|
|
|| desc->address_v < WINED3D_TADDRESS_WRAP || desc->address_v > WINED3D_TADDRESS_MIRROR_ONCE
|
|
|
|
|| desc->address_w < WINED3D_TADDRESS_WRAP || desc->address_w > WINED3D_TADDRESS_MIRROR_ONCE)
|
|
|
|
return WINED3DERR_INVALIDCALL;
|
|
|
|
|
|
|
|
if (desc->mag_filter < WINED3D_TEXF_POINT || desc->mag_filter > WINED3D_TEXF_LINEAR
|
|
|
|
|| desc->min_filter < WINED3D_TEXF_POINT || desc->min_filter > WINED3D_TEXF_LINEAR
|
|
|
|
|| desc->mip_filter > WINED3D_TEXF_LINEAR)
|
|
|
|
return WINED3DERR_INVALIDCALL;
|
2012-12-05 21:01:47 +01:00
|
|
|
|
2018-02-14 07:39:59 +01:00
|
|
|
if (!(object = heap_alloc_zero(sizeof(*object))))
|
2012-12-05 21:01:47 +01:00
|
|
|
return E_OUTOFMEMORY;
|
|
|
|
|
2017-04-26 13:19:54 +02:00
|
|
|
wined3d_sampler_init(object, device, desc, parent, parent_ops);
|
2012-12-05 21:01:47 +01:00
|
|
|
|
|
|
|
TRACE("Created sampler %p.\n", object);
|
|
|
|
*sampler = object;
|
|
|
|
|
|
|
|
return WINED3D_OK;
|
|
|
|
}
|
2017-03-20 12:13:06 +01:00
|
|
|
|
2018-10-30 10:48:43 +01:00
|
|
|
static void texture_gl_apply_base_level(struct wined3d_texture_gl *texture_gl,
|
2017-03-20 12:13:08 +01:00
|
|
|
const struct wined3d_sampler_desc *desc, const struct wined3d_gl_info *gl_info)
|
|
|
|
{
|
|
|
|
struct gl_texture *gl_tex;
|
|
|
|
unsigned int base_level;
|
|
|
|
|
2018-10-30 10:48:43 +01:00
|
|
|
if (texture_gl->t.flags & WINED3D_TEXTURE_COND_NP2)
|
2017-03-20 12:13:08 +01:00
|
|
|
base_level = 0;
|
|
|
|
else if (desc->mip_filter == WINED3D_TEXF_NONE)
|
2018-10-30 10:48:43 +01:00
|
|
|
base_level = texture_gl->t.lod;
|
2017-03-20 12:13:08 +01:00
|
|
|
else
|
2018-10-30 10:48:43 +01:00
|
|
|
base_level = min(max(desc->mip_base_level, texture_gl->t.lod), texture_gl->t.level_count - 1);
|
2017-03-20 12:13:08 +01:00
|
|
|
|
2018-10-30 10:48:43 +01:00
|
|
|
gl_tex = wined3d_texture_gl_get_gl_texture(texture_gl, texture_gl->t.flags & WINED3D_TEXTURE_IS_SRGB);
|
2017-03-20 12:13:08 +01:00
|
|
|
if (base_level != gl_tex->base_level)
|
|
|
|
{
|
|
|
|
/* Note that WINED3D_SAMP_MAX_MIP_LEVEL specifies the largest mipmap
|
|
|
|
* (default 0), while GL_TEXTURE_MAX_LEVEL specifies the smallest
|
|
|
|
* mipmap used (default 1000). So WINED3D_SAMP_MAX_MIP_LEVEL
|
|
|
|
* corresponds to GL_TEXTURE_BASE_LEVEL. */
|
2018-10-30 10:48:44 +01:00
|
|
|
gl_info->gl_ops.gl.p_glTexParameteri(texture_gl->target, GL_TEXTURE_BASE_LEVEL, base_level);
|
2017-03-20 12:13:08 +01:00
|
|
|
gl_tex->base_level = base_level;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-20 12:13:06 +01:00
|
|
|
/* This function relies on the correct texture being bound and loaded. */
|
|
|
|
void wined3d_sampler_bind(struct wined3d_sampler *sampler, unsigned int unit,
|
2019-06-13 13:40:36 +02:00
|
|
|
struct wined3d_texture_gl *texture_gl, const struct wined3d_context_gl *context_gl)
|
2017-03-20 12:13:06 +01:00
|
|
|
{
|
2019-06-13 13:40:36 +02:00
|
|
|
const struct wined3d_gl_info *gl_info = context_gl->c.gl_info;
|
2017-03-20 12:13:06 +01:00
|
|
|
|
|
|
|
if (gl_info->supported[ARB_SAMPLER_OBJECTS])
|
|
|
|
{
|
|
|
|
GL_EXTCALL(glBindSampler(unit, sampler->name));
|
|
|
|
checkGLcall("bind sampler");
|
|
|
|
}
|
2018-10-30 10:48:43 +01:00
|
|
|
else if (texture_gl)
|
2017-03-20 12:13:06 +01:00
|
|
|
{
|
2019-06-12 13:29:33 +02:00
|
|
|
wined3d_texture_gl_apply_sampler_desc(texture_gl, &sampler->desc, context_gl);
|
2017-03-20 12:13:06 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ERR("Could not apply sampler state.\n");
|
|
|
|
}
|
2017-03-20 12:13:08 +01:00
|
|
|
|
2018-10-30 10:48:43 +01:00
|
|
|
if (texture_gl)
|
|
|
|
texture_gl_apply_base_level(texture_gl, &sampler->desc, gl_info);
|
2017-03-20 12:13:06 +01:00
|
|
|
}
|