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 "draw/draw_context.h"
27 #include "draw/draw_vbuf.h"
28 #include "util/u_bitmask.h"
29 #include "util/u_inlines.h"
30 #include "pipe/p_state.h"
31 
32 #include "svga_cmd.h"
33 #include "svga_context.h"
34 #include "svga_shader.h"
35 #include "svga_swtnl.h"
36 #include "svga_state.h"
37 #include "svga_tgsi.h"
38 #include "svga_swtnl_private.h"
39 
40 
41 #define SVGA_POINT_ADJ_X -0.375f
42 #define SVGA_POINT_ADJ_Y -0.5f
43 
44 #define SVGA_LINE_ADJ_X -0.5f
45 #define SVGA_LINE_ADJ_Y -0.5f
46 
47 #define SVGA_TRIANGLE_ADJ_X -0.375f
48 #define SVGA_TRIANGLE_ADJ_Y -0.5f
49 
50 
51 static void
set_draw_viewport(struct svga_context * svga)52 set_draw_viewport(struct svga_context *svga)
53 {
54    struct pipe_viewport_state vp = svga->curr.viewport[0];
55    float adjx = 0.0f;
56    float adjy = 0.0f;
57 
58    if (svga_have_vgpu10(svga)) {
59       if (svga->curr.reduced_prim == PIPE_PRIM_TRIANGLES) {
60          adjy = 0.25;
61       }
62    }
63    else {
64       switch (svga->curr.reduced_prim) {
65       case PIPE_PRIM_POINTS:
66          adjx = SVGA_POINT_ADJ_X;
67          adjy = SVGA_POINT_ADJ_Y;
68          break;
69       case PIPE_PRIM_LINES:
70          /* XXX: This is to compensate for the fact that wide lines are
71           * going to be drawn with triangles, but we're not catching all
72           * cases where that will happen.
73           */
74          if (svga->curr.rast->need_pipeline & SVGA_PIPELINE_FLAG_LINES)
75          {
76             adjx = SVGA_LINE_ADJ_X + 0.175f;
77             adjy = SVGA_LINE_ADJ_Y - 0.175f;
78          }
79          else {
80             adjx = SVGA_LINE_ADJ_X;
81             adjy = SVGA_LINE_ADJ_Y;
82          }
83          break;
84       case PIPE_PRIM_TRIANGLES:
85          adjx += SVGA_TRIANGLE_ADJ_X;
86          adjy += SVGA_TRIANGLE_ADJ_Y;
87          break;
88       default:
89          /* nothing */
90          break;
91       }
92    }
93 
94    vp.translate[0] += adjx;
95    vp.translate[1] += adjy;
96 
97    draw_set_viewport_states(svga->swtnl.draw, 0, 1, &vp);
98 }
99 
100 static enum pipe_error
update_swtnl_draw(struct svga_context * svga,uint64_t dirty)101 update_swtnl_draw(struct svga_context *svga, uint64_t dirty)
102 {
103    SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_SWTNLUPDATEDRAW);
104 
105    draw_flush(svga->swtnl.draw);
106 
107    if (dirty & SVGA_NEW_VS)
108       draw_bind_vertex_shader(svga->swtnl.draw,
109                               svga->curr.vs->draw_shader);
110 
111    if (dirty & SVGA_NEW_FS)
112       draw_bind_fragment_shader(svga->swtnl.draw,
113                                 svga->curr.fs->draw_shader);
114 
115    if (dirty & SVGA_NEW_VBUFFER)
116       draw_set_vertex_buffers(svga->swtnl.draw, 0,
117                               svga->curr.num_vertex_buffers, 0,
118                               svga->curr.vb);
119 
120    if (dirty & SVGA_NEW_VELEMENT)
121       draw_set_vertex_elements(svga->swtnl.draw,
122                                svga->curr.velems->count,
123                                svga->curr.velems->velem);
124 
125    if (dirty & SVGA_NEW_CLIP)
126       draw_set_clip_state(svga->swtnl.draw,
127                           &svga->curr.clip);
128 
129    if (dirty & (SVGA_NEW_VIEWPORT |
130                 SVGA_NEW_REDUCED_PRIMITIVE |
131                 SVGA_NEW_RAST))
132       set_draw_viewport(svga);
133 
134    if (dirty & SVGA_NEW_RAST)
135       draw_set_rasterizer_state(svga->swtnl.draw,
136                                 &svga->curr.rast->templ,
137                                 (void *) svga->curr.rast);
138 
139    /* Tell the draw module how deep the Z/depth buffer is.
140     *
141     * If no depth buffer is bound, send the utility function the
142     * format for no bound depth (PIPE_FORMAT_NONE).
143     */
144    if (dirty & SVGA_NEW_FRAME_BUFFER)
145       draw_set_zs_format(svga->swtnl.draw,
146          (svga->curr.framebuffer.zsbuf) ?
147              svga->curr.framebuffer.zsbuf->format : PIPE_FORMAT_NONE);
148 
149    SVGA_STATS_TIME_POP(svga_sws(svga));
150    return PIPE_OK;
151 }
152 
153 
154 struct svga_tracked_state svga_update_swtnl_draw =
155 {
156    "update draw module state",
157    (SVGA_NEW_VS |
158     SVGA_NEW_VBUFFER |
159     SVGA_NEW_VELEMENT |
160     SVGA_NEW_CLIP |
161     SVGA_NEW_VIEWPORT |
162     SVGA_NEW_RAST |
163     SVGA_NEW_FRAME_BUFFER |
164     SVGA_NEW_REDUCED_PRIMITIVE),
165    update_swtnl_draw
166 };
167 
168 
169 static SVGA3dSurfaceFormat
translate_vertex_format(SVGA3dDeclType format)170 translate_vertex_format(SVGA3dDeclType format)
171 {
172    switch (format) {
173    case SVGA3D_DECLTYPE_FLOAT1:
174       return SVGA3D_R32_FLOAT;
175    case SVGA3D_DECLTYPE_FLOAT2:
176       return SVGA3D_R32G32_FLOAT;
177    case SVGA3D_DECLTYPE_FLOAT3:
178       return SVGA3D_R32G32B32_FLOAT;
179    case SVGA3D_DECLTYPE_FLOAT4:
180       return SVGA3D_R32G32B32A32_FLOAT;
181    default:
182       assert(!"Unexpected format in translate_vertex_format()");
183       return SVGA3D_R32G32B32A32_FLOAT;
184    }
185 }
186 
187 
188 static SVGA3dElementLayoutId
svga_vdecl_to_input_element(struct svga_context * svga,const SVGA3dVertexDecl * vdecl,unsigned num_decls)189 svga_vdecl_to_input_element(struct svga_context *svga,
190                             const SVGA3dVertexDecl *vdecl, unsigned num_decls)
191 {
192    SVGA3dElementLayoutId id;
193    SVGA3dInputElementDesc elements[PIPE_MAX_ATTRIBS];
194    unsigned i;
195 
196    assert(num_decls <= PIPE_MAX_ATTRIBS);
197    assert(svga_have_vgpu10(svga));
198 
199    for (i = 0; i < num_decls; i++) {
200       elements[i].inputSlot = 0; /* vertex buffer index */
201       elements[i].alignedByteOffset = vdecl[i].array.offset;
202       elements[i].format = translate_vertex_format(vdecl[i].identity.type);
203       elements[i].inputSlotClass = SVGA3D_INPUT_PER_VERTEX_DATA;
204       elements[i].instanceDataStepRate = 0;
205       elements[i].inputRegister = i;
206    }
207 
208    id = util_bitmask_add(svga->input_element_object_id_bm);
209 
210    SVGA_RETRY(svga, SVGA3D_vgpu10_DefineElementLayout(svga->swc, num_decls, id,
211                                                       elements));
212 
213    return id;
214 }
215 
216 
217 enum pipe_error
svga_swtnl_update_vdecl(struct svga_context * svga)218 svga_swtnl_update_vdecl(struct svga_context *svga)
219 {
220    struct svga_vbuf_render *svga_render = svga_vbuf_render(svga->swtnl.backend);
221    struct draw_context *draw = svga->swtnl.draw;
222    struct vertex_info *vinfo = &svga_render->vertex_info;
223    SVGA3dVertexDecl vdecl[PIPE_MAX_ATTRIBS];
224    struct svga_fragment_shader *fs = svga->curr.fs;
225    int offset = 0;
226    int nr_decls = 0;
227    int src;
228    unsigned i;
229    int any_change;
230 
231    SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_SWTNLUPDATEVDECL);
232 
233    memset(vinfo, 0, sizeof(*vinfo));
234    memset(vdecl, 0, sizeof(vdecl));
235 
236    draw_prepare_shader_outputs(draw);
237 
238    /* always add position */
239    src = draw_find_shader_output(draw, TGSI_SEMANTIC_POSITION, 0);
240    draw_emit_vertex_attr(vinfo, EMIT_4F, src);
241    vinfo->attrib[0].emit = EMIT_4F;
242    vdecl[0].array.offset = offset;
243    vdecl[0].identity.method = SVGA3D_DECLMETHOD_DEFAULT;
244    vdecl[0].identity.type = SVGA3D_DECLTYPE_FLOAT4;
245    vdecl[0].identity.usage = SVGA3D_DECLUSAGE_POSITIONT;
246    vdecl[0].identity.usageIndex = 0;
247    offset += 16;
248    nr_decls++;
249 
250    for (i = 0; i < fs->base.info.num_inputs; i++) {
251       const enum tgsi_semantic sem_name = fs->base.info.input_semantic_name[i];
252       const unsigned sem_index = fs->base.info.input_semantic_index[i];
253 
254       src = draw_find_shader_output(draw, sem_name, sem_index);
255 
256       vdecl[nr_decls].array.offset = offset;
257       vdecl[nr_decls].identity.usageIndex = sem_index;
258 
259       switch (sem_name) {
260       case TGSI_SEMANTIC_COLOR:
261          draw_emit_vertex_attr(vinfo, EMIT_4F, src);
262          vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_COLOR;
263          vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT4;
264          offset += 16;
265          nr_decls++;
266          break;
267       case TGSI_SEMANTIC_GENERIC:
268          draw_emit_vertex_attr(vinfo, EMIT_4F, src);
269          vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD;
270          vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT4;
271          vdecl[nr_decls].identity.usageIndex =
272             svga_remap_generic_index(fs->generic_remap_table, sem_index);
273          offset += 16;
274          nr_decls++;
275          break;
276       case TGSI_SEMANTIC_FOG:
277          draw_emit_vertex_attr(vinfo, EMIT_1F, src);
278          vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD;
279          vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT1;
280          assert(vdecl[nr_decls].identity.usageIndex == 0);
281          offset += 4;
282          nr_decls++;
283          break;
284       case TGSI_SEMANTIC_POSITION:
285       case TGSI_SEMANTIC_FACE:
286          /* generated internally, not a vertex shader output */
287          break;
288       default:
289          assert(0);
290       }
291    }
292 
293    draw_compute_vertex_size(vinfo);
294 
295    svga_render->vdecl_count = nr_decls;
296    for (i = 0; i < svga_render->vdecl_count; i++) {
297       vdecl[i].array.stride = offset;
298    }
299 
300    any_change = memcmp(svga_render->vdecl, vdecl, sizeof(vdecl));
301 
302    if (svga_have_vgpu10(svga)) {
303       if (!any_change && svga_render->layout_id != SVGA3D_INVALID_ID) {
304          goto done;
305       }
306 
307       if (svga_render->layout_id != SVGA3D_INVALID_ID) {
308          /* destroy old */
309          SVGA_RETRY(svga, SVGA3D_vgpu10_DestroyElementLayout
310                     (svga->swc, svga_render->layout_id));
311 
312          /**
313           * reset current layout id state after the element layout is
314           * destroyed, so that if a new layout has the same layout id, we
315           * will know to re-issue the SetInputLayout command.
316           */
317          if (svga->state.hw_draw.layout_id == svga_render->layout_id)
318             svga->state.hw_draw.layout_id = SVGA3D_INVALID_ID;
319 
320          util_bitmask_clear(svga->input_element_object_id_bm,
321                             svga_render->layout_id);
322       }
323 
324       svga_render->layout_id =
325          svga_vdecl_to_input_element(svga, vdecl, nr_decls);
326 
327       /* bind new */
328       if (svga->state.hw_draw.layout_id != svga_render->layout_id) {
329          SVGA_RETRY(svga, SVGA3D_vgpu10_SetInputLayout(svga->swc,
330                                                        svga_render->layout_id));
331          svga->state.hw_draw.layout_id = svga_render->layout_id;
332       }
333    }
334    else {
335       if (!any_change)
336          goto done;
337    }
338 
339    memcpy(svga_render->vdecl, vdecl, sizeof(vdecl));
340    svga->swtnl.new_vdecl = TRUE;
341 
342 done:
343    SVGA_STATS_TIME_POP(svga_sws(svga));
344    return PIPE_OK;
345 }
346 
347 
348 static enum pipe_error
update_swtnl_vdecl(struct svga_context * svga,uint64_t dirty)349 update_swtnl_vdecl(struct svga_context *svga, uint64_t dirty)
350 {
351    return svga_swtnl_update_vdecl(svga);
352 }
353 
354 
355 struct svga_tracked_state svga_update_swtnl_vdecl =
356 {
357    "update draw module vdecl",
358    (SVGA_NEW_VS |
359     SVGA_NEW_FS),
360    update_swtnl_vdecl
361 };
362