src/gallium/drivers/svga/svga_resource_texture.h

   1 /**********************************************************
   2  * Copyright 2008-2009 VMware, Inc.  All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person
   5  * obtaining a copy of this software and associated documentation
   6  * files (the "Software"), to deal in the Software without
   7  * restriction, including without limitation the rights to use, copy,
   8  * modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  **********************************************************/
  25
  26 #ifndef SVGA_TEXTURE_H
  27 #define SVGA_TEXTURE_H
  28
  29
  30 #include "pipe/p_compiler.h"
  31 #include "pipe/p_state.h"
  32 #include "util/u_inlines.h"
  33 #include "util/u_memory.h"
  34 #include "util/u_transfer.h"
  35 #include "svga_screen_cache.h"
  36
  37 struct pipe_context;
  38 struct pipe_screen;
  39 struct svga_context;
  40 struct svga_winsys_surface;
  41 enum SVGA3dSurfaceFormat;
  42
  43
  44 #define SVGA_MAX_TEXTURE_LEVELS 16
  45
  46
  47 extern struct u_resource_vtbl svga_texture_vtbl;
  48
  49
  50 struct svga_texture
  51 {
  52    struct u_resource b;
  53
  54    boolean defined[6][SVGA_MAX_TEXTURE_LEVELS];
  55
  56    struct svga_sampler_view *cached_view;
  57
  58    unsigned view_age[SVGA_MAX_TEXTURE_LEVELS];
  59    unsigned age;
  60
  61    boolean views_modified;
  62
  63    /**
  64     * Creation key for the host surface handle.
  65     *
  66     * This structure describes all the host surface characteristics so that it
  67     * can be looked up in cache, since creating a host surface is often a slow
  68     * operation.
  69     */
  70    struct svga_host_surface_cache_key key;
  71
  72    /**
  73     * Handle for the host side surface.
  74     *
  75     * This handle is owned by this texture. Views should hold on to a reference
  76     * to this texture and never destroy this handle directly.
  77     */
  78    struct svga_winsys_surface *handle;
  79
  80    unsigned size;  /**< Approximate size in bytes */
  81
  82    /** array indexed by cube face or 3D/array slice, one bit per mipmap level */
  83    ushort *rendered_to;
  84 };
  85
  86
  87
  88 /* Note this is only used for texture (not buffer) transfers:
  89  */
  90 struct svga_transfer
  91 {
  92    struct pipe_transfer base;
  93
  94    unsigned face;
  95
  96    struct svga_winsys_buffer *hwbuf;
  97
  98    /* Height of the hardware buffer in pixel blocks */
  99    unsigned hw_nblocksy;
 100
 101    /* Temporary malloc buffer when we can't allocate a hardware buffer
 102     * big enough */
 103    void *swbuf;
 104
 105    boolean use_direct_map;
 106 };
 107
 108
 109 static INLINE struct svga_texture *svga_texture( struct pipe_resource *resource )
 110 {
 111    struct svga_texture *tex = (struct svga_texture *)resource;
 112    assert(tex == NULL || tex->b.vtbl == &svga_texture_vtbl);
 113    return tex;
 114 }
 115
 116
 117 static INLINE struct svga_transfer *
 118 svga_transfer(struct pipe_transfer *transfer)
 119 {
 120    assert(transfer);
 121    return (struct svga_transfer *)transfer;
 122 }
 123
 124
 125 /**
 126  * Increment the age of a view into a texture
 127  * This is used to track updates to textures when we draw into
 128  * them via a surface.
 129  */
 130 static INLINE void
 131 svga_age_texture_view(struct svga_texture *tex, unsigned level)
 132 {
 133    assert(level < Elements(tex->view_age));
 134    tex->view_age[level] = ++(tex->age);
 135 }
 136
 137
 138 /**
 139  * Mark the given texture face/level as being defined.
 140  */
 141 static INLINE void
 142 svga_define_texture_level(struct svga_texture *tex,
 143                           unsigned face,unsigned level)
 144 {
 145    assert(face < Elements(tex->defined));
 146    assert(level < Elements(tex->defined[0]));
 147    tex->defined[face][level] = TRUE;
 148 }
 149
 150
 151 static INLINE bool
 152 svga_is_texture_level_defined(const struct svga_texture *tex,
 153                               unsigned face, unsigned level)
 154 {
 155    assert(face < Elements(tex->defined));
 156    assert(level < Elements(tex->defined[0]));
 157    return tex->defined[face][level];
 158 }
 159
 160
 161 /** For debugging, check that face and level are legal */
 162 static inline void
 163 check_face_level(const struct svga_texture *tex,
 164                  unsigned face, unsigned level)
 165 {
 166    if (tex->b.b.target == PIPE_TEXTURE_CUBE) {
 167       assert(face < 6);
 168    }
 169    else if (tex->b.b.target == PIPE_TEXTURE_3D) {
 170       assert(face < tex->b.b.depth0);
 171    }
 172    else {
 173       assert(face < tex->b.b.array_size);
 174    }
 175
 176    assert(level < 8 * sizeof(tex->rendered_to[0]));
 177 }
 178
 179
 180 static INLINE void
 181 svga_set_texture_rendered_to(struct svga_texture *tex,
 182                              unsigned face, unsigned level)
 183 {
 184    check_face_level(tex, face, level);
 185    tex->rendered_to[face] |= 1 << level;
 186 }
 187
 188
 189 static INLINE void
 190 svga_clear_texture_rendered_to(struct svga_texture *tex,
 191                                unsigned face, unsigned level)
 192 {
 193    check_face_level(tex, face, level);
 194    tex->rendered_to[face] &= ~(1 << level);
 195 }
 196
 197
 198 static INLINE boolean
 199 svga_was_texture_rendered_to(const struct svga_texture *tex,
 200                              unsigned face, unsigned level)
 201 {
 202    check_face_level(tex, face, level);
 203    return !!(tex->rendered_to[face] & (1 << level));
 204 }
 205
 206
 207 struct pipe_resource *
 208 svga_texture_create(struct pipe_screen *screen,
 209                     const struct pipe_resource *template);
 210
 211 struct pipe_resource *
 212 svga_texture_from_handle(struct pipe_screen * screen,
 213                         const struct pipe_resource *template,
 214                         struct winsys_handle *whandle);
 215
 216
 217
 218
 219 #endif /* SVGA_TEXTURE_H */