| 1 |
/* |
| 2 |
* Copyright 2012 Red Hat Inc. |
| 3 |
* |
| 4 |
* Permission is hereby granted, free of charge, to any person obtaining a |
| 5 |
* copy of this software and associated documentation files (the "Software"), |
| 6 |
* to deal in the Software without restriction, including without limitation |
| 7 |
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 8 |
* and/or sell copies of the Software, and to permit persons to whom the |
| 9 |
* Software is furnished to do so, subject to the following conditions: |
| 10 |
* |
| 11 |
* The above copyright notice and this permission notice shall be included in |
| 12 |
* all copies or substantial portions of the Software. |
| 13 |
* |
| 14 |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 15 |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 16 |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 17 |
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| 18 |
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| 19 |
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| 20 |
* OTHER DEALINGS IN THE SOFTWARE. |
| 21 |
* |
| 22 |
* Authors: Ben Skeggs |
| 23 |
* |
| 24 |
*/ |
| 25 |
|
| 26 |
#include "util/u_inlines.h" |
| 27 |
#include "util/format/u_format.h" |
| 28 |
|
| 29 |
#include "nv_object.xml.h" |
| 30 |
#include "nv30/nv30-40_3d.xml.h" |
| 31 |
#include "nv30/nv30_context.h" |
| 32 |
#include "nv30/nv30_format.h" |
| 33 |
|
| 34 |
#define NV30_3D_TEX_WRAP_S_MIRROR_REPEAT NV30_3D_TEX_WRAP_S_MIRRORED_REPEAT |
| 35 |
#define NV30_WRAP(n) \ |
| 36 |
case PIPE_TEX_WRAP_##n: ret = NV30_3D_TEX_WRAP_S_##n; break |
| 37 |
#define NV40_WRAP(n) \ |
| 38 |
case PIPE_TEX_WRAP_##n: ret = NV40_3D_TEX_WRAP_S_##n; break |
| 39 |
|
| 40 |
static inline unsigned |
| 41 |
wrap_mode(unsigned pipe) |
| 42 |
{ |
| 43 |
unsigned ret = NV30_3D_TEX_WRAP_S_REPEAT; |
| 44 |
|
| 45 |
switch (pipe) { |
| 46 |
NV30_WRAP(REPEAT); |
| 47 |
NV30_WRAP(MIRROR_REPEAT); |
| 48 |
NV30_WRAP(CLAMP_TO_EDGE); |
| 49 |
NV30_WRAP(CLAMP_TO_BORDER); |
| 50 |
NV30_WRAP(CLAMP); |
| 51 |
NV40_WRAP(MIRROR_CLAMP_TO_EDGE); |
| 52 |
NV40_WRAP(MIRROR_CLAMP_TO_BORDER); |
| 53 |
NV40_WRAP(MIRROR_CLAMP); |
| 54 |
default: |
| 55 |
break; |
| 56 |
} |
| 57 |
|
| 58 |
return ret >> NV30_3D_TEX_WRAP_S__SHIFT; |
| 59 |
} |
| 60 |
|
| 61 |
static inline unsigned |
| 62 |
filter_mode(const struct pipe_sampler_state *cso) |
| 63 |
{ |
| 64 |
unsigned filter; |
| 65 |
|
| 66 |
switch (cso->mag_img_filter) { |
| 67 |
case PIPE_TEX_FILTER_LINEAR: |
| 68 |
filter = NV30_3D_TEX_FILTER_MAG_LINEAR; |
| 69 |
break; |
| 70 |
default: |
| 71 |
filter = NV30_3D_TEX_FILTER_MAG_NEAREST; |
| 72 |
break; |
| 73 |
} |
| 74 |
|
| 75 |
switch (cso->min_img_filter) { |
| 76 |
case PIPE_TEX_FILTER_LINEAR: |
| 77 |
switch (cso->min_mip_filter) { |
| 78 |
case PIPE_TEX_MIPFILTER_NEAREST: |
| 79 |
filter |= NV30_3D_TEX_FILTER_MIN_LINEAR_MIPMAP_NEAREST; |
| 80 |
break; |
| 81 |
case PIPE_TEX_MIPFILTER_LINEAR: |
| 82 |
filter |= NV30_3D_TEX_FILTER_MIN_LINEAR_MIPMAP_LINEAR; |
| 83 |
break; |
| 84 |
default: |
| 85 |
filter |= NV30_3D_TEX_FILTER_MIN_LINEAR; |
| 86 |
break; |
| 87 |
} |
| 88 |
break; |
| 89 |
default: |
| 90 |
switch (cso->min_mip_filter) { |
| 91 |
case PIPE_TEX_MIPFILTER_NEAREST: |
| 92 |
filter |= NV30_3D_TEX_FILTER_MIN_NEAREST_MIPMAP_NEAREST; |
| 93 |
break; |
| 94 |
case PIPE_TEX_MIPFILTER_LINEAR: |
| 95 |
filter |= NV30_3D_TEX_FILTER_MIN_NEAREST_MIPMAP_LINEAR; |
| 96 |
break; |
| 97 |
default: |
| 98 |
filter |= NV30_3D_TEX_FILTER_MIN_NEAREST; |
| 99 |
break; |
| 100 |
} |
| 101 |
break; |
| 102 |
} |
| 103 |
|
| 104 |
return filter; |
| 105 |
} |
| 106 |
|
| 107 |
static inline unsigned |
| 108 |
compare_mode(const struct pipe_sampler_state *cso) |
| 109 |
{ |
| 110 |
if (cso->compare_mode != PIPE_TEX_COMPARE_R_TO_TEXTURE) |
| 111 |
return 0; |
| 112 |
|
| 113 |
switch (cso->compare_func) { |
| 114 |
case PIPE_FUNC_NEVER : return NV30_3D_TEX_WRAP_RCOMP_NEVER; |
| 115 |
case PIPE_FUNC_GREATER : return NV30_3D_TEX_WRAP_RCOMP_GREATER; |
| 116 |
case PIPE_FUNC_EQUAL : return NV30_3D_TEX_WRAP_RCOMP_EQUAL; |
| 117 |
case PIPE_FUNC_GEQUAL : return NV30_3D_TEX_WRAP_RCOMP_GEQUAL; |
| 118 |
case PIPE_FUNC_LESS : return NV30_3D_TEX_WRAP_RCOMP_LESS; |
| 119 |
case PIPE_FUNC_NOTEQUAL: return NV30_3D_TEX_WRAP_RCOMP_NOTEQUAL; |
| 120 |
case PIPE_FUNC_LEQUAL : return NV30_3D_TEX_WRAP_RCOMP_LEQUAL; |
| 121 |
case PIPE_FUNC_ALWAYS : return NV30_3D_TEX_WRAP_RCOMP_ALWAYS; |
| 122 |
default: |
| 123 |
return 0; |
| 124 |
} |
| 125 |
} |
| 126 |
|
| 127 |
static void * |
| 128 |
nv30_sampler_state_create(struct pipe_context *pipe, |
| 129 |
const struct pipe_sampler_state *cso) |
| 130 |
{ |
| 131 |
struct nouveau_object *eng3d = nv30_context(pipe)->screen->eng3d; |
| 132 |
struct nv30_sampler_state *so; |
| 133 |
const float max_lod = 15.0 + (255.0 / 256.0); |
| 134 |
|
| 135 |
so = MALLOC_STRUCT(nv30_sampler_state); |
| 136 |
if (!so) |
| 137 |
return NULL; |
| 138 |
|
| 139 |
so->pipe = *cso; |
| 140 |
so->fmt = 0; |
| 141 |
so->wrap = (wrap_mode(cso->wrap_s) << NV30_3D_TEX_WRAP_S__SHIFT) | |
| 142 |
(wrap_mode(cso->wrap_t) << NV30_3D_TEX_WRAP_T__SHIFT) | |
| 143 |
(wrap_mode(cso->wrap_r) << NV30_3D_TEX_WRAP_R__SHIFT); |
| 144 |
so->en = 0; |
| 145 |
so->wrap |= compare_mode(cso); |
| 146 |
so->filt = filter_mode(cso) | 0x00002000; |
| 147 |
so->bcol = (float_to_ubyte(cso->border_color.f[3]) << 24) | |
| 148 |
(float_to_ubyte(cso->border_color.f[0]) << 16) | |
| 149 |
(float_to_ubyte(cso->border_color.f[1]) << 8) | |
| 150 |
(float_to_ubyte(cso->border_color.f[2]) << 0); |
| 151 |
|
| 152 |
if (eng3d->oclass >= NV40_3D_CLASS) { |
| 153 |
unsigned aniso = cso->max_anisotropy; |
| 154 |
|
| 155 |
if (cso->unnormalized_coords) |
| 156 |
so->fmt |= NV40_3D_TEX_FORMAT_RECT; |
| 157 |
|
| 158 |
if (aniso > 1) { |
| 159 |
if (aniso >= 16) so->en |= NV40_3D_TEX_ENABLE_ANISO_16X; |
| 160 |
else if (aniso >= 12) so->en |= NV40_3D_TEX_ENABLE_ANISO_12X; |
| 161 |
else if (aniso >= 10) so->en |= NV40_3D_TEX_ENABLE_ANISO_10X; |
| 162 |
else if (aniso >= 8) so->en |= NV40_3D_TEX_ENABLE_ANISO_8X; |
| 163 |
else if (aniso >= 6) so->en |= NV40_3D_TEX_ENABLE_ANISO_6X; |
| 164 |
else if (aniso >= 4) so->en |= NV40_3D_TEX_ENABLE_ANISO_4X; |
| 165 |
else so->en |= NV40_3D_TEX_ENABLE_ANISO_2X; |
| 166 |
|
| 167 |
so->wrap |= nv30_context(pipe)->config.aniso; |
| 168 |
} |
| 169 |
} else { |
| 170 |
so->en |= NV30_3D_TEX_ENABLE_ENABLE; |
| 171 |
|
| 172 |
if (cso->max_anisotropy >= 8) so->en |= NV30_3D_TEX_ENABLE_ANISO_8X; |
| 173 |
else if (cso->max_anisotropy >= 4) so->en |= NV30_3D_TEX_ENABLE_ANISO_4X; |
| 174 |
else if (cso->max_anisotropy >= 2) so->en |= NV30_3D_TEX_ENABLE_ANISO_2X; |
| 175 |
} |
| 176 |
|
| 177 |
so->filt |= (int)(cso->lod_bias * 256.0) & 0x1fff; |
| 178 |
so->max_lod = (int)(CLAMP(cso->max_lod, 0.0, max_lod) * 256.0); |
| 179 |
so->min_lod = (int)(CLAMP(cso->min_lod, 0.0, max_lod) * 256.0); |
| 180 |
return so; |
| 181 |
} |
| 182 |
|
| 183 |
static void |
| 184 |
nv30_sampler_state_delete(struct pipe_context *pipe, void *hwcso) |
| 185 |
{ |
| 186 |
FREE(hwcso); |
| 187 |
} |
| 188 |
|
| 189 |
static void |
| 190 |
nv30_bind_sampler_states(struct pipe_context *pipe, |
| 191 |
mesa_shader_stage shader, unsigned start_slot, |
| 192 |
unsigned num_samplers, void **samplers) |
| 193 |
{ |
| 194 |
switch (shader) { |
| 195 |
case MESA_SHADER_VERTEX: |
| 196 |
nv40_verttex_sampler_states_bind(pipe, num_samplers, samplers); |
| 197 |
break; |
| 198 |
case MESA_SHADER_FRAGMENT: |
| 199 |
nv30_fragtex_sampler_states_bind(pipe, num_samplers, samplers); |
| 200 |
break; |
| 201 |
default: |
| 202 |
assert(!"unexpected shader type"); |
| 203 |
break; |
| 204 |
} |
| 205 |
} |
| 206 |
|
| 207 |
static inline uint32_t |
| 208 |
swizzle(const struct nv30_texfmt *fmt, unsigned cmp, unsigned swz) |
| 209 |
{ |
| 210 |
uint32_t data = fmt->swz[swz].src << 8; |
| 211 |
if (swz <= PIPE_SWIZZLE_W) |
| 212 |
data |= fmt->swz[swz].cmp; |
| 213 |
else |
| 214 |
data |= fmt->swz[cmp].cmp; |
| 215 |
return data; |
| 216 |
} |
| 217 |
|
| 218 |
static struct pipe_sampler_view * |
| 219 |
nv30_sampler_view_create(struct pipe_context *pipe, struct pipe_resource *pt, |
| 220 |
const struct pipe_sampler_view *tmpl) |
| 221 |
{ |
| 222 |
const struct nv30_texfmt *fmt = nv30_texfmt(pipe->screen, tmpl->format); |
| 223 |
struct nouveau_object *eng3d = nv30_context(pipe)->screen->eng3d; |
| 224 |
struct nv30_miptree *mt = nv30_miptree(pt); |
| 225 |
struct nv30_sampler_view *so; |
| 226 |
|
| 227 |
so = MALLOC_STRUCT(nv30_sampler_view); |
| 228 |
if (!so) |
| 229 |
return NULL; |
| 230 |
so->pipe = *tmpl; |
| 231 |
so->pipe.reference.count = 1; |
| 232 |
so->pipe.texture = NULL; |
| 233 |
so->pipe.context = pipe; |
| 234 |
pipe_resource_reference(&so->pipe.texture, pt); |
| 235 |
|
| 236 |
so->fmt = NV30_3D_TEX_FORMAT_NO_BORDER; |
| 237 |
switch (pt->target) { |
| 238 |
case PIPE_TEXTURE_1D: |
| 239 |
so->fmt |= NV30_3D_TEX_FORMAT_DIMS_1D; |
| 240 |
break; |
| 241 |
case PIPE_TEXTURE_CUBE: |
| 242 |
so->fmt |= NV30_3D_TEX_FORMAT_CUBIC; |
| 243 |
FALLTHROUGH; |
| 244 |
case PIPE_TEXTURE_2D: |
| 245 |
case PIPE_TEXTURE_RECT: |
| 246 |
so->fmt |= NV30_3D_TEX_FORMAT_DIMS_2D; |
| 247 |
break; |
| 248 |
case PIPE_TEXTURE_3D: |
| 249 |
so->fmt |= NV30_3D_TEX_FORMAT_DIMS_3D; |
| 250 |
break; |
| 251 |
default: |
| 252 |
assert(0); |
| 253 |
so->fmt |= NV30_3D_TEX_FORMAT_DIMS_1D; |
| 254 |
break; |
| 255 |
} |
| 256 |
|
| 257 |
so->filt = fmt->filter; |
| 258 |
so->wrap = fmt->wrap; |
| 259 |
so->swz = fmt->swizzle; |
| 260 |
so->swz |= swizzle(fmt, 3, tmpl->swizzle_a); |
| 261 |
so->swz |= swizzle(fmt, 0, tmpl->swizzle_r) << 2; |
| 262 |
so->swz |= swizzle(fmt, 1, tmpl->swizzle_g) << 4; |
| 263 |
so->swz |= swizzle(fmt, 2, tmpl->swizzle_b) << 6; |
| 264 |
|
| 265 |
/* apparently, we need to ignore the t coordinate for 1D textures to |
| 266 |
* fix piglit tex1d-2dborder |
| 267 |
*/ |
| 268 |
so->wrap_mask = ~0; |
| 269 |
if (pt->target == PIPE_TEXTURE_1D) { |
| 270 |
so->wrap_mask &= ~NV30_3D_TEX_WRAP_T__MASK; |
| 271 |
so->wrap |= NV30_3D_TEX_WRAP_T_REPEAT; |
| 272 |
} |
| 273 |
|
| 274 |
/* yet more hardware suckage, can't filter 32-bit float formats */ |
| 275 |
switch (tmpl->format) { |
| 276 |
case PIPE_FORMAT_R32_FLOAT: |
| 277 |
case PIPE_FORMAT_R32G32B32A32_FLOAT: |
| 278 |
so->filt_mask = ~(NV30_3D_TEX_FILTER_MIN__MASK | |
| 279 |
NV30_3D_TEX_FILTER_MAG__MASK); |
| 280 |
so->filt |= NV30_3D_TEX_FILTER_MIN_NEAREST | |
| 281 |
NV30_3D_TEX_FILTER_MAG_NEAREST; |
| 282 |
break; |
| 283 |
default: |
| 284 |
so->filt_mask = ~0; |
| 285 |
break; |
| 286 |
} |
| 287 |
|
| 288 |
so->npot_size0 = (pt->width0 << 16) | pt->height0; |
| 289 |
if (eng3d->oclass >= NV40_3D_CLASS) { |
| 290 |
so->npot_size1 = (pt->depth0 << 20) | mt->uniform_pitch; |
| 291 |
if (mt->uniform_pitch) |
| 292 |
so->fmt |= NV40_3D_TEX_FORMAT_LINEAR; |
| 293 |
so->fmt |= 0x00008000; |
| 294 |
so->fmt |= (pt->last_level + 1) << NV40_3D_TEX_FORMAT_MIPMAP_COUNT__SHIFT; |
| 295 |
} else { |
| 296 |
so->swz |= mt->uniform_pitch << NV30_3D_TEX_SWIZZLE_RECT_PITCH__SHIFT; |
| 297 |
if (pt->last_level) |
| 298 |
so->fmt |= NV30_3D_TEX_FORMAT_MIPMAP; |
| 299 |
so->fmt |= util_logbase2(pt->width0) << 20; |
| 300 |
so->fmt |= util_logbase2(pt->height0) << 24; |
| 301 |
so->fmt |= util_logbase2(pt->depth0) << 28; |
| 302 |
so->fmt |= 0x00010000; |
| 303 |
} |
| 304 |
|
| 305 |
so->base_lod = so->pipe.u.tex.first_level << 8; |
| 306 |
so->high_lod = MIN2(pt->last_level, so->pipe.u.tex.last_level) << 8; |
| 307 |
return &so->pipe; |
| 308 |
} |
| 309 |
|
| 310 |
static void |
| 311 |
nv30_sampler_view_destroy(struct pipe_context *pipe, |
| 312 |
struct pipe_sampler_view *view) |
| 313 |
{ |
| 314 |
pipe_resource_reference(&view->texture, NULL); |
| 315 |
FREE(view); |
| 316 |
} |
| 317 |
|
| 318 |
void |
| 319 |
nv30_texture_init(struct pipe_context *pipe) |
| 320 |
{ |
| 321 |
pipe->create_sampler_state = nv30_sampler_state_create; |
| 322 |
pipe->delete_sampler_state = nv30_sampler_state_delete; |
| 323 |
pipe->bind_sampler_states = nv30_bind_sampler_states; |
| 324 |
|
| 325 |
pipe->create_sampler_view = nv30_sampler_view_create; |
| 326 |
pipe->sampler_view_destroy = nv30_sampler_view_destroy; |
| 327 |
pipe->sampler_view_release = u_default_sampler_view_release; |
| 328 |
pipe->resource_release = u_default_resource_release; |
| 329 |
} |