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 52 set_draw_viewport(struct svga_context *svga) 53 { 54 struct pipe_viewport_state vp = svga->curr.viewport; 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 101 update_swtnl_draw(struct svga_context *svga, unsigned 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, 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 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 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 enum pipe_error ret; 195 unsigned i; 196 197 assert(num_decls <= PIPE_MAX_ATTRIBS); 198 assert(svga_have_vgpu10(svga)); 199 200 for (i = 0; i < num_decls; i++) { 201 elements[i].inputSlot = 0; /* vertex buffer index */ 202 elements[i].alignedByteOffset = vdecl[i].array.offset; 203 elements[i].format = translate_vertex_format(vdecl[i].identity.type); 204 elements[i].inputSlotClass = SVGA3D_INPUT_PER_VERTEX_DATA; 205 elements[i].instanceDataStepRate = 0; 206 elements[i].inputRegister = i; 207 } 208 209 id = util_bitmask_add(svga->input_element_object_id_bm); 210 211 ret = SVGA3D_vgpu10_DefineElementLayout(svga->swc, num_decls, id, elements); 212 if (ret != PIPE_OK) { 213 svga_context_flush(svga, NULL); 214 ret = SVGA3D_vgpu10_DefineElementLayout(svga->swc, num_decls, 215 id, elements); 216 assert(ret == PIPE_OK); 217 } 218 219 return id; 220 } 221 222 223 enum pipe_error 224 svga_swtnl_update_vdecl(struct svga_context *svga) 225 { 226 struct svga_vbuf_render *svga_render = svga_vbuf_render(svga->swtnl.backend); 227 struct draw_context *draw = svga->swtnl.draw; 228 struct vertex_info *vinfo = &svga_render->vertex_info; 229 SVGA3dVertexDecl vdecl[PIPE_MAX_ATTRIBS]; 230 struct svga_fragment_shader *fs = svga->curr.fs; 231 int offset = 0; 232 int nr_decls = 0; 233 int src; 234 unsigned i; 235 int any_change; 236 237 SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_SWTNLUPDATEVDECL); 238 239 memset(vinfo, 0, sizeof(*vinfo)); 240 memset(vdecl, 0, sizeof(vdecl)); 241 242 draw_prepare_shader_outputs(draw); 243 244 /* always add position */ 245 src = draw_find_shader_output(draw, TGSI_SEMANTIC_POSITION, 0); 246 draw_emit_vertex_attr(vinfo, EMIT_4F, src); 247 vinfo->attrib[0].emit = EMIT_4F; 248 vdecl[0].array.offset = offset; 249 vdecl[0].identity.method = SVGA3D_DECLMETHOD_DEFAULT; 250 vdecl[0].identity.type = SVGA3D_DECLTYPE_FLOAT4; 251 vdecl[0].identity.usage = SVGA3D_DECLUSAGE_POSITIONT; 252 vdecl[0].identity.usageIndex = 0; 253 offset += 16; 254 nr_decls++; 255 256 for (i = 0; i < fs->base.info.num_inputs; i++) { 257 const enum tgsi_semantic sem_name = fs->base.info.input_semantic_name[i]; 258 const unsigned sem_index = fs->base.info.input_semantic_index[i]; 259 260 src = draw_find_shader_output(draw, sem_name, sem_index); 261 262 vdecl[nr_decls].array.offset = offset; 263 vdecl[nr_decls].identity.usageIndex = sem_index; 264 265 switch (sem_name) { 266 case TGSI_SEMANTIC_COLOR: 267 draw_emit_vertex_attr(vinfo, EMIT_4F, src); 268 vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_COLOR; 269 vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT4; 270 offset += 16; 271 nr_decls++; 272 break; 273 case TGSI_SEMANTIC_GENERIC: 274 draw_emit_vertex_attr(vinfo, EMIT_4F, src); 275 vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD; 276 vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT4; 277 vdecl[nr_decls].identity.usageIndex = 278 svga_remap_generic_index(fs->generic_remap_table, sem_index); 279 offset += 16; 280 nr_decls++; 281 break; 282 case TGSI_SEMANTIC_FOG: 283 draw_emit_vertex_attr(vinfo, EMIT_1F, src); 284 vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD; 285 vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT1; 286 assert(vdecl[nr_decls].identity.usageIndex == 0); 287 offset += 4; 288 nr_decls++; 289 break; 290 case TGSI_SEMANTIC_POSITION: 291 /* generated internally, not a vertex shader output */ 292 break; 293 default: 294 assert(0); 295 } 296 } 297 298 draw_compute_vertex_size(vinfo); 299 300 svga_render->vdecl_count = nr_decls; 301 for (i = 0; i < svga_render->vdecl_count; i++) { 302 vdecl[i].array.stride = offset; 303 } 304 305 any_change = memcmp(svga_render->vdecl, vdecl, sizeof(vdecl)); 306 307 if (svga_have_vgpu10(svga)) { 308 enum pipe_error ret; 309 310 if (!any_change && svga_render->layout_id != SVGA3D_INVALID_ID) { 311 goto done; 312 } 313 314 if (svga_render->layout_id != SVGA3D_INVALID_ID) { 315 /* destroy old */ 316 ret = SVGA3D_vgpu10_DestroyElementLayout(svga->swc, 317 svga_render->layout_id); 318 if (ret != PIPE_OK) { 319 svga_context_flush(svga, NULL); 320 ret = SVGA3D_vgpu10_DestroyElementLayout(svga->swc, 321 svga_render->layout_id); 322 assert(ret == PIPE_OK); 323 } 324 325 /** 326 * reset current layout id state after the element layout is 327 * destroyed, so that if a new layout has the same layout id, we 328 * will know to re-issue the SetInputLayout command. 329 */ 330 if (svga->state.hw_draw.layout_id == svga_render->layout_id) 331 svga->state.hw_draw.layout_id = SVGA3D_INVALID_ID; 332 333 util_bitmask_clear(svga->input_element_object_id_bm, 334 svga_render->layout_id); 335 } 336 337 svga_render->layout_id = 338 svga_vdecl_to_input_element(svga, vdecl, nr_decls); 339 340 /* bind new */ 341 if (svga->state.hw_draw.layout_id != svga_render->layout_id) { 342 ret = SVGA3D_vgpu10_SetInputLayout(svga->swc, svga_render->layout_id); 343 if (ret != PIPE_OK) { 344 svga_context_flush(svga, NULL); 345 ret = SVGA3D_vgpu10_SetInputLayout(svga->swc, 346 svga_render->layout_id); 347 assert(ret == PIPE_OK); 348 } 349 350 svga->state.hw_draw.layout_id = svga_render->layout_id; 351 } 352 } 353 else { 354 if (!any_change) 355 goto done; 356 } 357 358 memcpy(svga_render->vdecl, vdecl, sizeof(vdecl)); 359 svga->swtnl.new_vdecl = TRUE; 360 361 done: 362 SVGA_STATS_TIME_POP(svga_sws(svga)); 363 return PIPE_OK; 364 } 365 366 367 static enum pipe_error 368 update_swtnl_vdecl(struct svga_context *svga, unsigned dirty) 369 { 370 return svga_swtnl_update_vdecl(svga); 371 } 372 373 374 struct svga_tracked_state svga_update_swtnl_vdecl = 375 { 376 "update draw module vdecl", 377 (SVGA_NEW_VS | 378 SVGA_NEW_FS), 379 update_swtnl_vdecl 380 }; 381