1/**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28/* Authors:
29 *  Brian Paul
30 */
31
32#include "util/u_inlines.h"
33#include "util/u_memory.h"
34
35#include "draw/draw_context.h"
36
37#include "lp_context.h"
38#include "lp_screen.h"
39#include "lp_state.h"
40#include "lp_debug.h"
41#include "state_tracker/sw_winsys.h"
42
43
44static void *
45llvmpipe_create_sampler_state(struct pipe_context *pipe,
46                              const struct pipe_sampler_state *sampler)
47{
48   struct pipe_sampler_state *state = mem_dup(sampler, sizeof *sampler);
49
50   if (LP_PERF & PERF_NO_MIP_LINEAR) {
51      if (state->min_mip_filter == PIPE_TEX_MIPFILTER_LINEAR)
52	 state->min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
53   }
54
55   if (LP_PERF & PERF_NO_MIPMAPS)
56      state->min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
57
58   if (LP_PERF & PERF_NO_LINEAR) {
59      state->mag_img_filter = PIPE_TEX_FILTER_NEAREST;
60      state->min_img_filter = PIPE_TEX_FILTER_NEAREST;
61   }
62
63   return state;
64}
65
66
67static void
68llvmpipe_bind_sampler_states(struct pipe_context *pipe,
69                             unsigned shader,
70                             unsigned start,
71                             unsigned num,
72                             void **samplers)
73{
74   struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
75   unsigned i;
76
77   assert(shader < PIPE_SHADER_TYPES);
78   assert(start + num <= Elements(llvmpipe->samplers[shader]));
79
80   /* Check for no-op */
81   if (start + num <= llvmpipe->num_samplers[shader] &&
82       !memcmp(llvmpipe->samplers[shader] + start, samplers,
83               num * sizeof(void *))) {
84      return;
85   }
86
87   draw_flush(llvmpipe->draw);
88
89   /* set the new samplers */
90   for (i = 0; i < num; i++) {
91      llvmpipe->samplers[shader][start + i] = samplers[i];
92   }
93
94   /* find highest non-null samplers[] entry */
95   {
96      unsigned j = MAX2(llvmpipe->num_samplers[shader], start + num);
97      while (j > 0 && llvmpipe->samplers[shader][j - 1] == NULL)
98         j--;
99      llvmpipe->num_samplers[shader] = j;
100   }
101
102   if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) {
103      draw_set_samplers(llvmpipe->draw,
104                        shader,
105                        llvmpipe->samplers[shader],
106                        llvmpipe->num_samplers[shader]);
107   }
108
109   llvmpipe->dirty |= LP_NEW_SAMPLER;
110}
111
112
113static void
114llvmpipe_bind_fragment_sampler_states(struct pipe_context *pipe,
115                                      unsigned num, void **samplers)
116{
117   llvmpipe_bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0, num, samplers);
118}
119
120
121static void
122llvmpipe_bind_vertex_sampler_states(struct pipe_context *pipe,
123                                    unsigned num, void **samplers)
124{
125   llvmpipe_bind_sampler_states(pipe, PIPE_SHADER_VERTEX, 0, num, samplers);
126}
127
128
129static void
130llvmpipe_bind_geometry_sampler_states(struct pipe_context *pipe,
131                                      unsigned num, void **samplers)
132{
133   llvmpipe_bind_sampler_states(pipe, PIPE_SHADER_GEOMETRY, 0, num, samplers);
134}
135
136static void
137llvmpipe_set_sampler_views(struct pipe_context *pipe,
138                           unsigned shader,
139                           unsigned start,
140                           unsigned num,
141                           struct pipe_sampler_view **views)
142{
143   struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
144   uint i;
145
146   assert(num <= PIPE_MAX_SAMPLERS);
147
148   assert(shader < PIPE_SHADER_TYPES);
149   assert(start + num <= Elements(llvmpipe->sampler_views[shader]));
150
151   /* Check for no-op */
152   if (start + num <= llvmpipe->num_sampler_views[shader] &&
153       !memcmp(llvmpipe->sampler_views[shader] + start, views,
154               num * sizeof(struct pipe_sampler_view *))) {
155      return;
156   }
157
158   draw_flush(llvmpipe->draw);
159
160   /* set the new sampler views */
161   for (i = 0; i < num; i++) {
162      pipe_sampler_view_reference(&llvmpipe->sampler_views[shader][start + i],
163                                  views[i]);
164   }
165
166   /* find highest non-null sampler_views[] entry */
167   {
168      unsigned j = MAX2(llvmpipe->num_sampler_views[shader], start + num);
169      while (j > 0 && llvmpipe->sampler_views[shader][j - 1] == NULL)
170         j--;
171      llvmpipe->num_sampler_views[shader] = j;
172   }
173
174   if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) {
175      draw_set_sampler_views(llvmpipe->draw,
176                             shader,
177                             llvmpipe->sampler_views[shader],
178                             llvmpipe->num_sampler_views[shader]);
179   }
180
181   llvmpipe->dirty |= LP_NEW_SAMPLER_VIEW;
182}
183
184
185static void
186llvmpipe_set_fragment_sampler_views(struct pipe_context *pipe,
187                                    unsigned num,
188                                    struct pipe_sampler_view **views)
189{
190   llvmpipe_set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, num, views);
191}
192
193
194static void
195llvmpipe_set_vertex_sampler_views(struct pipe_context *pipe,
196                                  unsigned num,
197                                  struct pipe_sampler_view **views)
198{
199   llvmpipe_set_sampler_views(pipe, PIPE_SHADER_VERTEX, 0, num, views);
200}
201
202
203static void
204llvmpipe_set_geometry_sampler_views(struct pipe_context *pipe,
205                                    unsigned num,
206                                    struct pipe_sampler_view **views)
207{
208   llvmpipe_set_sampler_views(pipe, PIPE_SHADER_GEOMETRY, 0, num, views);
209}
210
211static struct pipe_sampler_view *
212llvmpipe_create_sampler_view(struct pipe_context *pipe,
213                            struct pipe_resource *texture,
214                            const struct pipe_sampler_view *templ)
215{
216   struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
217
218   if (view) {
219      *view = *templ;
220      view->reference.count = 1;
221      view->texture = NULL;
222      pipe_resource_reference(&view->texture, texture);
223      view->context = pipe;
224   }
225
226   return view;
227}
228
229
230static void
231llvmpipe_sampler_view_destroy(struct pipe_context *pipe,
232                              struct pipe_sampler_view *view)
233{
234   pipe_resource_reference(&view->texture, NULL);
235   FREE(view);
236}
237
238
239static void
240llvmpipe_delete_sampler_state(struct pipe_context *pipe,
241                              void *sampler)
242{
243   FREE( sampler );
244}
245
246
247/**
248 * Called during state validation when LP_NEW_SAMPLER_VIEW is set.
249 */
250void
251llvmpipe_prepare_vertex_sampling(struct llvmpipe_context *lp,
252                                 unsigned num,
253                                 struct pipe_sampler_view **views)
254{
255   unsigned i;
256   uint32_t row_stride[PIPE_MAX_TEXTURE_LEVELS];
257   uint32_t img_stride[PIPE_MAX_TEXTURE_LEVELS];
258   const void *data[PIPE_MAX_TEXTURE_LEVELS];
259
260   assert(num <= PIPE_MAX_SAMPLERS);
261   if (!num)
262      return;
263
264   for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
265      struct pipe_sampler_view *view = i < num ? views[i] : NULL;
266
267      if (view) {
268         struct pipe_resource *tex = view->texture;
269         struct llvmpipe_resource *lp_tex = llvmpipe_resource(tex);
270
271         /* We're referencing the texture's internal data, so save a
272          * reference to it.
273          */
274         pipe_resource_reference(&lp->mapped_vs_tex[i], tex);
275
276         if (!lp_tex->dt) {
277            /* regular texture - setup array of mipmap level pointers */
278            int j;
279            for (j = view->u.tex.first_level; j <= tex->last_level; j++) {
280               data[j] =
281                  llvmpipe_get_texture_image_all(lp_tex, j, LP_TEX_USAGE_READ,
282                                                 LP_TEX_LAYOUT_LINEAR);
283               row_stride[j] = lp_tex->row_stride[j];
284               img_stride[j] = lp_tex->img_stride[j];
285            }
286         }
287         else {
288            /* display target texture/surface */
289            /*
290             * XXX: Where should this be unmapped?
291             */
292            struct llvmpipe_screen *screen = llvmpipe_screen(tex->screen);
293            struct sw_winsys *winsys = screen->winsys;
294            data[0] = winsys->displaytarget_map(winsys, lp_tex->dt,
295                                                PIPE_TRANSFER_READ);
296            row_stride[0] = lp_tex->row_stride[0];
297            img_stride[0] = lp_tex->img_stride[0];
298            assert(data[0]);
299         }
300         draw_set_mapped_texture(lp->draw,
301                                 PIPE_SHADER_VERTEX,
302                                 i,
303                                 tex->width0, tex->height0, tex->depth0,
304                                 view->u.tex.first_level, tex->last_level,
305                                 row_stride, img_stride, data);
306      }
307   }
308}
309
310void
311llvmpipe_cleanup_vertex_sampling(struct llvmpipe_context *ctx)
312{
313   unsigned i;
314   for (i = 0; i < Elements(ctx->mapped_vs_tex); i++) {
315      pipe_resource_reference(&ctx->mapped_vs_tex[i], NULL);
316   }
317}
318
319void
320llvmpipe_init_sampler_funcs(struct llvmpipe_context *llvmpipe)
321{
322   llvmpipe->pipe.create_sampler_state = llvmpipe_create_sampler_state;
323
324   llvmpipe->pipe.bind_fragment_sampler_states  = llvmpipe_bind_fragment_sampler_states;
325   llvmpipe->pipe.bind_vertex_sampler_states  = llvmpipe_bind_vertex_sampler_states;
326   llvmpipe->pipe.bind_geometry_sampler_states  = llvmpipe_bind_geometry_sampler_states;
327   llvmpipe->pipe.set_fragment_sampler_views = llvmpipe_set_fragment_sampler_views;
328   llvmpipe->pipe.set_vertex_sampler_views = llvmpipe_set_vertex_sampler_views;
329   llvmpipe->pipe.set_geometry_sampler_views = llvmpipe_set_geometry_sampler_views;
330   llvmpipe->pipe.create_sampler_view = llvmpipe_create_sampler_view;
331   llvmpipe->pipe.sampler_view_destroy = llvmpipe_sampler_view_destroy;
332   llvmpipe->pipe.delete_sampler_state = llvmpipe_delete_sampler_state;
333}
334