"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/gallium/drivers/nouveau/nv30/nv30_texture.c" (16 Sep 2020, 10567 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "nv30_texture.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 20.1.5_vs_20.2.0-rc1.

    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->normalized_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                          enum pipe_shader_type shader, unsigned start_slot,
  192                          unsigned num_samplers, void **samplers)
  193 {
  194    switch (shader) {
  195    case PIPE_SHADER_VERTEX:
  196       nv40_verttex_sampler_states_bind(pipe, num_samplers, samplers);
  197       break;
  198    case PIPE_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    case PIPE_TEXTURE_2D:
  244    case PIPE_TEXTURE_RECT:
  245       so->fmt |= NV30_3D_TEX_FORMAT_DIMS_2D;
  246       break;
  247    case PIPE_TEXTURE_3D:
  248       so->fmt |= NV30_3D_TEX_FORMAT_DIMS_3D;
  249       break;
  250    default:
  251       assert(0);
  252       so->fmt |= NV30_3D_TEX_FORMAT_DIMS_1D;
  253       break;
  254    }
  255 
  256    so->filt = fmt->filter;
  257    so->wrap = fmt->wrap;
  258    so->swz  = fmt->swizzle;
  259    so->swz |= swizzle(fmt, 3, tmpl->swizzle_a);
  260    so->swz |= swizzle(fmt, 0, tmpl->swizzle_r) << 2;
  261    so->swz |= swizzle(fmt, 1, tmpl->swizzle_g) << 4;
  262    so->swz |= swizzle(fmt, 2, tmpl->swizzle_b) << 6;
  263 
  264    /* apparently, we need to ignore the t coordinate for 1D textures to
  265     * fix piglit tex1d-2dborder
  266     */
  267    so->wrap_mask = ~0;
  268    if (pt->target == PIPE_TEXTURE_1D) {
  269       so->wrap_mask &= ~NV30_3D_TEX_WRAP_T__MASK;
  270       so->wrap      |=  NV30_3D_TEX_WRAP_T_REPEAT;
  271    }
  272 
  273    /* yet more hardware suckage, can't filter 32-bit float formats */
  274    switch (tmpl->format) {
  275    case PIPE_FORMAT_R32_FLOAT:
  276    case PIPE_FORMAT_R32G32B32A32_FLOAT:
  277       so->filt_mask = ~(NV30_3D_TEX_FILTER_MIN__MASK |
  278                         NV30_3D_TEX_FILTER_MAG__MASK);
  279       so->filt     |= NV30_3D_TEX_FILTER_MIN_NEAREST |
  280                       NV30_3D_TEX_FILTER_MAG_NEAREST;
  281       break;
  282    default:
  283       so->filt_mask = ~0;
  284       break;
  285    }
  286 
  287    so->npot_size0 = (pt->width0 << 16) | pt->height0;
  288    if (eng3d->oclass >= NV40_3D_CLASS) {
  289       so->npot_size1 = (pt->depth0 << 20) | mt->uniform_pitch;
  290       if (mt->uniform_pitch)
  291          so->fmt |= NV40_3D_TEX_FORMAT_LINEAR;
  292       so->fmt |= 0x00008000;
  293       so->fmt |= (pt->last_level + 1) << NV40_3D_TEX_FORMAT_MIPMAP_COUNT__SHIFT;
  294    } else {
  295       so->swz |= mt->uniform_pitch << NV30_3D_TEX_SWIZZLE_RECT_PITCH__SHIFT;
  296       if (pt->last_level)
  297          so->fmt |= NV30_3D_TEX_FORMAT_MIPMAP;
  298       so->fmt |= util_logbase2(pt->width0)  << 20;
  299       so->fmt |= util_logbase2(pt->height0) << 24;
  300       so->fmt |= util_logbase2(pt->depth0)  << 28;
  301       so->fmt |= 0x00010000;
  302    }
  303 
  304    so->base_lod = so->pipe.u.tex.first_level << 8;
  305    so->high_lod = MIN2(pt->last_level, so->pipe.u.tex.last_level) << 8;
  306    return &so->pipe;
  307 }
  308 
  309 static void
  310 nv30_sampler_view_destroy(struct pipe_context *pipe,
  311                           struct pipe_sampler_view *view)
  312 {
  313    pipe_resource_reference(&view->texture, NULL);
  314    FREE(view);
  315 }
  316 
  317 void
  318 nv30_texture_init(struct pipe_context *pipe)
  319 {
  320    pipe->create_sampler_state = nv30_sampler_state_create;
  321    pipe->delete_sampler_state = nv30_sampler_state_delete;
  322    pipe->bind_sampler_states = nv30_bind_sampler_states;
  323 
  324    pipe->create_sampler_view = nv30_sampler_view_create;
  325    pipe->sampler_view_destroy = nv30_sampler_view_destroy;
  326 }