1 /**************************************************************************
2 *
3 * Copyright 2009 VMware, Inc.
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 VMWARE 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 /**
29 * The rast code is concerned with rasterization of command bins.
30 * Each screen tile has a bin associated with it. To render the
31 * scene we iterate over the tile bins and execute the commands
32 * in each bin.
33 * We'll do that with multiple threads...
34 */
35
36
37 #ifndef LP_RAST_H
38 #define LP_RAST_H
39
40 #include "util/compiler.h"
41 #include "util/u_pack_color.h"
42 #include "util/u_rect.h"
43 #include "lp_jit.h"
44
45
46 struct lp_rasterizer;
47 struct lp_scene;
48 struct lp_fence;
49 struct cmd_bin;
50
51 #define FIXED_TYPE_WIDTH 64
52 /** For sub-pixel positioning */
53 #define FIXED_ORDER 8
54 #define FIXED_ONE (1<<FIXED_ORDER)
55 #define FIXED_SHIFT (FIXED_TYPE_WIDTH - 1)
56 /** Maximum length of an edge in a primitive in pixels.
57 * If the framebuffer is large we have to think about fixed-point
58 * integer overflow. Coordinates need ((FIXED_TYPE_WIDTH/2) - 1) bits
59 * to be able to fit product of two such coordinates inside
60 * FIXED_TYPE_WIDTH, any larger and we could overflow a
61 * FIXED_TYPE_WIDTH_-bit int.
62 */
63 #define MAX_FIXED_LENGTH (1 << (((FIXED_TYPE_WIDTH/2) - 1) - FIXED_ORDER))
64
65 #define MAX_FIXED_LENGTH32 (1 << (((32/2) - 1) - FIXED_ORDER))
66
67 /* Rasterizer output size going to jit fs, width/height */
68 #define LP_RASTER_BLOCK_SIZE 4
69
70 #define LP_MAX_ACTIVE_BINNED_QUERIES 64
71
72 #define IMUL64(a, b) (((int64_t)(a)) * ((int64_t)(b)))
73
74 struct lp_rasterizer_task;
75
76 extern const float lp_sample_pos_4x[4][2];
77
78
79 /**
80 * Rasterization state.
81 * Objects of this type are put into the shared data bin and pointed
82 * to by commands in the per-tile bins.
83 */
84 struct lp_rast_state {
85 /* State for the shader. This also contains state which feeds into
86 * the fragment shader, such as blend color and alpha ref value.
87 */
88 struct lp_jit_context jit_context;
89 struct lp_jit_resources jit_resources;
90
91 /* The shader itself. Probably we also need to pass a pointer to
92 * the tile color/z/stencil data somehow
93 */
94 struct lp_fragment_shader_variant *variant;
95 };
96
97
98 /**
99 * Texture blit offsets.
100 */
101 struct lp_rast_blit {
102 int16_t x0;
103 int16_t y0;
104 };
105
106
107 /**
108 * Coefficients necessary to run the shader at a given location.
109 * First coefficient is position.
110 * These pointers point into the bin data buffer.
111 */
112 struct lp_rast_shader_inputs {
113 unsigned frontfacing:1; /** True for front-facing */
114 unsigned disable:1; /** Partially binned, disable this command */
115 unsigned is_blit:1; /* blit */
116 unsigned viewport_index:4; /* viewport index */
117 unsigned layer:11;
118 unsigned view_index:14;
119 unsigned stride; /* how much to advance data between a0, dadx, dady */
120 unsigned pad[2];
121 /* followed by a0, dadx, dady and planes[] */
122 };
123
124
125 struct lp_rast_plane {
126 /* edge function values at minx,miny ?? */
127 int64_t c;
128
129 int32_t dcdx;
130 int32_t dcdy;
131
132 /* one-pixel sized trivial reject offsets for each plane */
133 uint32_t eo;
134 /*
135 * We rely on this struct being 64bit aligned (ideally it would be 128bit
136 * but that's quite the waste) and therefore on 32bit we need padding
137 * since otherwise (even with the 64bit number in there) it wouldn't be.
138 */
139 uint32_t pad;
140 };
141
142
143 /**
144 * Rasterization information for a triangle known to be in this bin,
145 * plus inputs to run the shader:
146 * These fields are tile- and bin-independent.
147 * Objects of this type are put into the lp_setup_context::data buffer.
148 */
149 struct lp_rast_triangle {
150 #if MESA_DEBUG
151 float v[3][2];
152 float pad0;
153 float pad1;
154 #endif
155
156 /* inputs for the shader */
157 struct lp_rast_shader_inputs inputs;
158 /* planes are also allocated here */
159 };
160
161
162 #define RECT_PLANE_LEFT 0x1
163 #define RECT_PLANE_RIGHT 0x2
164 #define RECT_PLANE_TOP 0x4
165 #define RECT_PLANE_BOTTOM 0x8
166
167 /**
168 * Rasterization information for a screen-aligned rectangle known to
169 * be in this bin, plus inputs to run the shader:
170 * These fields are tile- and bin-independent.
171 * Objects of this type are put into the lp_setup_context::data buffer.
172 */
173 struct lp_rast_rectangle {
174 #if MESA_DEBUG
175 float v[2][2]; /**< diagonal corners */
176 #endif
177
178 /* Rectangle boundaries in integer pixels:
179 */
180 struct u_rect box;
181
182 /* inputs for the shader */
183 struct lp_rast_shader_inputs inputs;
184 };
185
186
187 struct lp_rast_clear_rb {
188 union util_color color_val;
189 unsigned cbuf;
190 };
191
192
193 /*
194 * Return the address (as float[][4]) of the FS input values which
195 * are immediately after the 'inputs' object.
196 */
197 static inline float(*
GET_A0(const struct lp_rast_shader_inputs * inputs)198 GET_A0(const struct lp_rast_shader_inputs *inputs))[4]
199 {
200 return (float (*)[4]) (inputs + 1);
201 }
202
203 /*
204 * Return the address (as float[][4]) of the FS input partial derivatives
205 * (w.r.t. X) which are after the 'inputs' object.
206 */
207 static inline float(*
GET_DADX(const struct lp_rast_shader_inputs * inputs)208 GET_DADX(const struct lp_rast_shader_inputs *inputs))[4]
209 {
210 const uint8_t *p = (const uint8_t *) (inputs + 1);
211 return (float (*)[4]) (p + 1 * inputs->stride);
212 }
213
214 /*
215 * Return the address (as float[][4]) of the FS input partial derivatives
216 * (w.r.t. Y) which are after the 'inputs' object.
217 */
218 static inline float(*
GET_DADY(const struct lp_rast_shader_inputs * inputs)219 GET_DADY(const struct lp_rast_shader_inputs *inputs))[4]
220 {
221 const uint8_t *p = (const uint8_t *) (inputs + 1);
222 return (float (*)[4]) (p + 2 * inputs->stride);
223 }
224
225 static inline struct lp_rast_plane *
GET_PLANES(const struct lp_rast_triangle * tri)226 GET_PLANES(const struct lp_rast_triangle *tri)
227 {
228 const uint8_t *p = (const uint8_t *) (&tri->inputs + 1);
229 return (struct lp_rast_plane *) (p + 3 * tri->inputs.stride);
230 }
231
232
233 struct lp_rasterizer *
234 lp_rast_create(unsigned num_threads);
235
236 void
237 lp_rast_destroy(struct lp_rasterizer *);
238
239 void
240 lp_rast_queue_scene(struct lp_rasterizer *rast,
241 struct lp_scene *scene);
242
243 void
244 lp_rast_finish(struct lp_rasterizer *rast);
245
246
247 union lp_rast_cmd_arg {
248 const struct lp_rast_shader_inputs *shade_tile;
249 struct {
250 const struct lp_rast_triangle *tri;
251 unsigned plane_mask;
252 } triangle;
253 const struct lp_rast_rectangle *rectangle;
254 const struct lp_rast_state *set_state;
255 const struct lp_rast_clear_rb *clear_rb;
256 struct {
257 uint64_t value;
258 uint64_t mask;
259 } clear_zstencil;
260 struct lp_fence *fence;
261 struct llvmpipe_query *query_obj;
262 };
263
264
265 /* Cast wrappers. Hopefully these compile to noops!
266 */
267 static inline union lp_rast_cmd_arg
lp_rast_arg_inputs(const struct lp_rast_shader_inputs * shade_tile)268 lp_rast_arg_inputs(const struct lp_rast_shader_inputs *shade_tile)
269 {
270 union lp_rast_cmd_arg arg;
271 arg.shade_tile = shade_tile;
272 return arg;
273 }
274
275
276 static inline union lp_rast_cmd_arg
lp_rast_arg_triangle(const struct lp_rast_triangle * triangle,unsigned plane_mask)277 lp_rast_arg_triangle(const struct lp_rast_triangle *triangle,
278 unsigned plane_mask)
279 {
280 union lp_rast_cmd_arg arg;
281 arg.triangle.tri = triangle;
282 arg.triangle.plane_mask = plane_mask;
283 return arg;
284 }
285
286
287 /**
288 * Build argument for a contained triangle.
289 *
290 * All planes are enabled, so instead of the plane mask we pass the upper
291 * left coordinates of the a block that fully encloses the triangle.
292 */
293 static inline union lp_rast_cmd_arg
lp_rast_arg_triangle_contained(const struct lp_rast_triangle * triangle,unsigned x,unsigned y)294 lp_rast_arg_triangle_contained(const struct lp_rast_triangle *triangle,
295 unsigned x, unsigned y)
296 {
297 union lp_rast_cmd_arg arg;
298 arg.triangle.tri = triangle;
299 arg.triangle.plane_mask = x | (y << 8);
300 return arg;
301 }
302
303
304 static inline union lp_rast_cmd_arg
lp_rast_arg_rectangle(const struct lp_rast_rectangle * rectangle)305 lp_rast_arg_rectangle(const struct lp_rast_rectangle *rectangle)
306 {
307 union lp_rast_cmd_arg arg;
308 arg.rectangle = rectangle;
309 return arg;
310 }
311
312
313 static inline union lp_rast_cmd_arg
lp_rast_arg_state(const struct lp_rast_state * state)314 lp_rast_arg_state(const struct lp_rast_state *state)
315 {
316 union lp_rast_cmd_arg arg;
317 arg.set_state = state;
318 return arg;
319 }
320
321
322 static inline union lp_rast_cmd_arg
lp_rast_arg_fence(struct lp_fence * fence)323 lp_rast_arg_fence(struct lp_fence *fence)
324 {
325 union lp_rast_cmd_arg arg;
326 arg.fence = fence;
327 return arg;
328 }
329
330
331 static inline union lp_rast_cmd_arg
lp_rast_arg_clearzs(uint64_t value,uint64_t mask)332 lp_rast_arg_clearzs(uint64_t value, uint64_t mask)
333 {
334 union lp_rast_cmd_arg arg;
335 arg.clear_zstencil.value = value;
336 arg.clear_zstencil.mask = mask;
337 return arg;
338 }
339
340
341 static inline union lp_rast_cmd_arg
lp_rast_arg_query(struct llvmpipe_query * pq)342 lp_rast_arg_query(struct llvmpipe_query *pq)
343 {
344 union lp_rast_cmd_arg arg;
345 arg.query_obj = pq;
346 return arg;
347 }
348
349
350 static inline union lp_rast_cmd_arg
lp_rast_arg_null(void)351 lp_rast_arg_null(void)
352 {
353 union lp_rast_cmd_arg arg;
354 arg.set_state = NULL;
355 return arg;
356 }
357
358
359 /**
360 * Binnable Commands.
361 * These get put into bins by the setup code and are called when
362 * the bins are executed.
363 */
364 enum lp_rast_op {
365 LP_RAST_OP_CLEAR_COLOR = 0x0,
366 LP_RAST_OP_CLEAR_ZSTENCIL = 0x1,
367 LP_RAST_OP_TRIANGLE_1 = 0x2,
368 LP_RAST_OP_TRIANGLE_2 = 0x3,
369 LP_RAST_OP_TRIANGLE_3 = 0x4,
370 LP_RAST_OP_TRIANGLE_4 = 0x5,
371 LP_RAST_OP_TRIANGLE_5 = 0x6,
372 LP_RAST_OP_TRIANGLE_6 = 0x7,
373 LP_RAST_OP_TRIANGLE_7 = 0x8,
374 LP_RAST_OP_TRIANGLE_8 = 0x9,
375 LP_RAST_OP_TRIANGLE_3_4 = 0xa,
376 LP_RAST_OP_TRIANGLE_3_16 = 0xb,
377 LP_RAST_OP_TRIANGLE_4_16 = 0xc,
378 LP_RAST_OP_SHADE_TILE = 0xd,
379 LP_RAST_OP_SHADE_TILE_OPAQUE = 0xe,
380 LP_RAST_OP_BEGIN_QUERY = 0xf,
381 LP_RAST_OP_END_QUERY = 0x10,
382 LP_RAST_OP_SET_STATE = 0x11,
383 LP_RAST_OP_TRIANGLE_32_1 = 0x12,
384 LP_RAST_OP_TRIANGLE_32_2 = 0x13,
385 LP_RAST_OP_TRIANGLE_32_3 = 0x14,
386 LP_RAST_OP_TRIANGLE_32_4 = 0x15,
387 LP_RAST_OP_TRIANGLE_32_5 = 0x16,
388 LP_RAST_OP_TRIANGLE_32_6 = 0x17,
389 LP_RAST_OP_TRIANGLE_32_7 = 0x18,
390 LP_RAST_OP_TRIANGLE_32_8 = 0x19,
391 LP_RAST_OP_TRIANGLE_32_3_4 = 0x1a,
392 LP_RAST_OP_TRIANGLE_32_3_16 = 0x1b,
393 LP_RAST_OP_TRIANGLE_32_4_16 = 0x1c,
394 LP_RAST_OP_MS_TRIANGLE_1 = 0x1d,
395 LP_RAST_OP_MS_TRIANGLE_2 = 0x1e,
396 LP_RAST_OP_MS_TRIANGLE_3 = 0x1f,
397 LP_RAST_OP_MS_TRIANGLE_4 = 0x20,
398 LP_RAST_OP_MS_TRIANGLE_5 = 0x21,
399 LP_RAST_OP_MS_TRIANGLE_6 = 0x22,
400 LP_RAST_OP_MS_TRIANGLE_7 = 0x23,
401 LP_RAST_OP_MS_TRIANGLE_8 = 0x24,
402 LP_RAST_OP_MS_TRIANGLE_3_4 = 0x25,
403 LP_RAST_OP_MS_TRIANGLE_3_16 = 0x26,
404 LP_RAST_OP_MS_TRIANGLE_4_16 = 0x27,
405 LP_RAST_OP_RECTANGLE = 0x28, /* Keep at end */
406 LP_RAST_OP_BLIT = 0x29, /* Keep at end */
407 LP_RAST_OP_MAX = 0x2a,
408 LP_RAST_OP_MASK = 0xff
409 };
410
411
412 /* Returned by characterize_bin:
413 */
414 #define LP_RAST_FLAGS_TRI (0x1)
415 #define LP_RAST_FLAGS_RECT (0x2)
416 #define LP_RAST_FLAGS_TILE (0x4)
417 #define LP_RAST_FLAGS_BLIT (0x8)
418
419 struct lp_bin_info {
420 unsigned type:8; // bitmask of LP_RAST_FLAGS_x
421 unsigned count:24;
422 };
423
424 struct lp_bin_info
425 lp_characterize_bin(const struct cmd_bin *bin);
426
427 void
428 lp_debug_bins(struct lp_scene *scene);
429
430 void
431 lp_debug_draw_bins_by_cmd_length(struct lp_scene *scene);
432
433 void
434 lp_debug_draw_bins_by_coverage(struct lp_scene *scene);
435
436 void
437 lp_rast_fence(struct lp_rasterizer *rast,
438 struct lp_fence **fence);
439
440 #endif
441