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 #include "util/u_inlines.h"
27 #include "pipe/p_defines.h"
28 #include "util/u_format.h"
29 #include "util/u_math.h"
30 #include "util/u_memory.h"
31 #include "tgsi/tgsi_parse.h"
32
33 #include "svga_context.h"
34 #include "svga_resource_texture.h"
35
36 #include "svga_debug.h"
37
38 static INLINE unsigned
translate_wrap_mode(unsigned wrap)39 translate_wrap_mode(unsigned wrap)
40 {
41 switch (wrap) {
42 case PIPE_TEX_WRAP_REPEAT:
43 return SVGA3D_TEX_ADDRESS_WRAP;
44
45 case PIPE_TEX_WRAP_CLAMP:
46 return SVGA3D_TEX_ADDRESS_CLAMP;
47
48 case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
49 /* Unfortunately SVGA3D_TEX_ADDRESS_EDGE not respected by
50 * hardware.
51 */
52 return SVGA3D_TEX_ADDRESS_CLAMP;
53
54 case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
55 return SVGA3D_TEX_ADDRESS_BORDER;
56
57 case PIPE_TEX_WRAP_MIRROR_REPEAT:
58 return SVGA3D_TEX_ADDRESS_MIRROR;
59
60 case PIPE_TEX_WRAP_MIRROR_CLAMP:
61 case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
62 case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
63 return SVGA3D_TEX_ADDRESS_MIRRORONCE;
64
65 default:
66 assert(0);
67 return SVGA3D_TEX_ADDRESS_WRAP;
68 }
69 }
70
translate_img_filter(unsigned filter)71 static INLINE unsigned translate_img_filter( unsigned filter )
72 {
73 switch (filter) {
74 case PIPE_TEX_FILTER_NEAREST: return SVGA3D_TEX_FILTER_NEAREST;
75 case PIPE_TEX_FILTER_LINEAR: return SVGA3D_TEX_FILTER_LINEAR;
76 default:
77 assert(0);
78 return SVGA3D_TEX_FILTER_NEAREST;
79 }
80 }
81
translate_mip_filter(unsigned filter)82 static INLINE unsigned translate_mip_filter( unsigned filter )
83 {
84 switch (filter) {
85 case PIPE_TEX_MIPFILTER_NONE: return SVGA3D_TEX_FILTER_NONE;
86 case PIPE_TEX_MIPFILTER_NEAREST: return SVGA3D_TEX_FILTER_NEAREST;
87 case PIPE_TEX_MIPFILTER_LINEAR: return SVGA3D_TEX_FILTER_LINEAR;
88 default:
89 assert(0);
90 return SVGA3D_TEX_FILTER_NONE;
91 }
92 }
93
94 static void *
svga_create_sampler_state(struct pipe_context * pipe,const struct pipe_sampler_state * sampler)95 svga_create_sampler_state(struct pipe_context *pipe,
96 const struct pipe_sampler_state *sampler)
97 {
98 struct svga_context *svga = svga_context(pipe);
99 struct svga_sampler_state *cso = CALLOC_STRUCT( svga_sampler_state );
100
101 if (!cso)
102 return NULL;
103
104 cso->mipfilter = translate_mip_filter(sampler->min_mip_filter);
105 cso->magfilter = translate_img_filter( sampler->mag_img_filter );
106 cso->minfilter = translate_img_filter( sampler->min_img_filter );
107 cso->aniso_level = MAX2( sampler->max_anisotropy, 1 );
108 if(sampler->max_anisotropy)
109 cso->magfilter = cso->minfilter = SVGA3D_TEX_FILTER_ANISOTROPIC;
110 cso->lod_bias = sampler->lod_bias;
111 cso->addressu = translate_wrap_mode(sampler->wrap_s);
112 cso->addressv = translate_wrap_mode(sampler->wrap_t);
113 cso->addressw = translate_wrap_mode(sampler->wrap_r);
114 cso->normalized_coords = sampler->normalized_coords;
115 cso->compare_mode = sampler->compare_mode;
116 cso->compare_func = sampler->compare_func;
117
118 {
119 uint32 r = float_to_ubyte(sampler->border_color.f[0]);
120 uint32 g = float_to_ubyte(sampler->border_color.f[1]);
121 uint32 b = float_to_ubyte(sampler->border_color.f[2]);
122 uint32 a = float_to_ubyte(sampler->border_color.f[3]);
123
124 cso->bordercolor = (a << 24) | (r << 16) | (g << 8) | b;
125 }
126
127 /* No SVGA3D support for:
128 * - min/max LOD clamping
129 */
130 cso->min_lod = 0;
131 cso->view_min_lod = MAX2((int) (sampler->min_lod + 0.5), 0);
132 cso->view_max_lod = MAX2((int) (sampler->max_lod + 0.5), 0);
133
134 /* Use min_mipmap */
135 if (svga->debug.use_min_mipmap) {
136 if (cso->view_min_lod == cso->view_max_lod) {
137 cso->min_lod = cso->view_min_lod;
138 cso->view_min_lod = 0;
139 cso->view_max_lod = 1000; /* Just a high number */
140 cso->mipfilter = SVGA3D_TEX_FILTER_NONE;
141 }
142 }
143
144 SVGA_DBG(DEBUG_VIEWS, "min %u, view(min %u, max %u) lod, mipfilter %s\n",
145 cso->min_lod, cso->view_min_lod, cso->view_max_lod,
146 cso->mipfilter == SVGA3D_TEX_FILTER_NONE ? "SVGA3D_TEX_FILTER_NONE" : "SOMETHING");
147
148 return cso;
149 }
150
151 static void
svga_bind_sampler_states(struct pipe_context * pipe,unsigned shader,unsigned start,unsigned num,void ** samplers)152 svga_bind_sampler_states(struct pipe_context *pipe,
153 unsigned shader,
154 unsigned start,
155 unsigned num,
156 void **samplers)
157 {
158 struct svga_context *svga = svga_context(pipe);
159 unsigned i;
160
161 assert(shader < PIPE_SHADER_TYPES);
162 assert(start + num <= PIPE_MAX_SAMPLERS);
163
164 /* we only support fragment shader samplers at this time */
165 if (shader != PIPE_SHADER_FRAGMENT)
166 return;
167
168 /* Check for no-op */
169 if (start + num <= svga->curr.num_samplers &&
170 !memcmp(svga->curr.sampler + start, samplers, num * sizeof(void *))) {
171 if (0) debug_printf("sampler noop\n");
172 return;
173 }
174
175 for (i = 0; i < num; i++)
176 svga->curr.sampler[start + i] = samplers[i];
177
178 /* find highest non-null sampler_views[] entry */
179 {
180 unsigned j = MAX2(svga->curr.num_samplers, start + num);
181 while (j > 0 && svga->curr.sampler[j - 1] == NULL)
182 j--;
183 svga->curr.num_samplers = j;
184 }
185
186 svga->dirty |= SVGA_NEW_SAMPLER;
187 }
188
189
190 static void
svga_bind_fragment_sampler_states(struct pipe_context * pipe,unsigned num,void ** sampler)191 svga_bind_fragment_sampler_states(struct pipe_context *pipe,
192 unsigned num, void **sampler)
193 {
194 svga_bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0, num, sampler);
195 }
196
197
svga_delete_sampler_state(struct pipe_context * pipe,void * sampler)198 static void svga_delete_sampler_state(struct pipe_context *pipe,
199 void *sampler)
200 {
201 FREE(sampler);
202 }
203
204
205 static struct pipe_sampler_view *
svga_create_sampler_view(struct pipe_context * pipe,struct pipe_resource * texture,const struct pipe_sampler_view * templ)206 svga_create_sampler_view(struct pipe_context *pipe,
207 struct pipe_resource *texture,
208 const struct pipe_sampler_view *templ)
209 {
210 struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
211
212 if (view) {
213 *view = *templ;
214 view->reference.count = 1;
215 view->texture = NULL;
216 pipe_resource_reference(&view->texture, texture);
217 view->context = pipe;
218 }
219
220 return view;
221 }
222
223
224 static void
svga_sampler_view_destroy(struct pipe_context * pipe,struct pipe_sampler_view * view)225 svga_sampler_view_destroy(struct pipe_context *pipe,
226 struct pipe_sampler_view *view)
227 {
228 pipe_resource_reference(&view->texture, NULL);
229 FREE(view);
230 }
231
232 static void
svga_set_sampler_views(struct pipe_context * pipe,unsigned shader,unsigned start,unsigned num,struct pipe_sampler_view ** views)233 svga_set_sampler_views(struct pipe_context *pipe,
234 unsigned shader,
235 unsigned start,
236 unsigned num,
237 struct pipe_sampler_view **views)
238 {
239 struct svga_context *svga = svga_context(pipe);
240 unsigned flag_1d = 0;
241 unsigned flag_srgb = 0;
242 uint i;
243
244 assert(shader < PIPE_SHADER_TYPES);
245 assert(start + num <= Elements(svga->curr.sampler_views));
246
247 /* we only support fragment shader sampler views at this time */
248 if (shader != PIPE_SHADER_FRAGMENT)
249 return;
250
251 /* Check for no-op */
252 if (start + num <= svga->curr.num_sampler_views &&
253 !memcmp(svga->curr.sampler_views + start, views,
254 num * sizeof(struct pipe_sampler_view *))) {
255 if (0) debug_printf("texture noop\n");
256 return;
257 }
258
259 for (i = 0; i < num; i++) {
260 if (svga->curr.sampler_views[start + i] != views[i]) {
261 /* Note: we're using pipe_sampler_view_release() here to work around
262 * a possible crash when the old view belongs to another context that
263 * was already destroyed.
264 */
265 pipe_sampler_view_release(pipe, &svga->curr.sampler_views[start + i]);
266 pipe_sampler_view_reference(&svga->curr.sampler_views[start + i],
267 views[i]);
268 }
269
270 if (!views[i])
271 continue;
272
273 if (util_format_is_srgb(views[i]->format))
274 flag_srgb |= 1 << (start + i);
275
276 if (views[i]->texture->target == PIPE_TEXTURE_1D)
277 flag_1d |= 1 << (start + i);
278 }
279
280 /* find highest non-null sampler_views[] entry */
281 {
282 unsigned j = MAX2(svga->curr.num_sampler_views, start + num);
283 while (j > 0 && svga->curr.sampler_views[j - 1] == NULL)
284 j--;
285 svga->curr.num_sampler_views = j;
286 }
287
288 svga->dirty |= SVGA_NEW_TEXTURE_BINDING;
289
290 if (flag_srgb != svga->curr.tex_flags.flag_srgb ||
291 flag_1d != svga->curr.tex_flags.flag_1d)
292 {
293 svga->dirty |= SVGA_NEW_TEXTURE_FLAGS;
294 svga->curr.tex_flags.flag_1d = flag_1d;
295 svga->curr.tex_flags.flag_srgb = flag_srgb;
296 }
297 }
298
299
300 static void
svga_set_fragment_sampler_views(struct pipe_context * pipe,unsigned num,struct pipe_sampler_view ** views)301 svga_set_fragment_sampler_views(struct pipe_context *pipe,
302 unsigned num,
303 struct pipe_sampler_view **views)
304 {
305 svga_set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, num, views);
306 }
307
308
svga_init_sampler_functions(struct svga_context * svga)309 void svga_init_sampler_functions( struct svga_context *svga )
310 {
311 svga->pipe.create_sampler_state = svga_create_sampler_state;
312 svga->pipe.bind_fragment_sampler_states = svga_bind_fragment_sampler_states;
313 svga->pipe.delete_sampler_state = svga_delete_sampler_state;
314 svga->pipe.set_fragment_sampler_views = svga_set_fragment_sampler_views;
315 svga->pipe.create_sampler_view = svga_create_sampler_view;
316 svga->pipe.sampler_view_destroy = svga_sampler_view_destroy;
317 }
318
319
320
321