← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/gallium/drivers/llvmpipe/lp_rast.h

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/llvmpipe/lp_rast.h
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 "pipe/p_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
 
 * Rasterization state.
80
 
 * Objects of this type are put into the shared data bin and pointed
81
 
 * to by commands in the per-tile bins.
82
 
 */
83
 
struct lp_rast_state {
84
 
   /* State for the shader.  This also contains state which feeds into
85
 
    * the fragment shader, such as blend color and alpha ref value.
86
 
    */
87
 
   struct lp_jit_context jit_context;
88
 
   
89
 
   /* The shader itself.  Probably we also need to pass a pointer to
90
 
    * the tile color/z/stencil data somehow
91
 
     */
92
 
   struct lp_fragment_shader_variant *variant;
93
 
};
94
 
 
95
 
 
96
 
/**
97
 
 * Texture blit offsets.
98
 
 */
99
 
struct lp_rast_blit {
100
 
   int16_t x0;
101
 
   int16_t y0;
102
 
};
103
 
 
104
 
 
105
 
/**
106
 
 * Coefficients necessary to run the shader at a given location.
107
 
 * First coefficient is position.
108
 
 * These pointers point into the bin data buffer.
109
 
 */
110
 
struct lp_rast_shader_inputs {
111
 
   unsigned frontfacing:1;      /** True for front-facing */
112
 
   unsigned disable:1;          /** Partially binned, disable this command */
113
 
   unsigned is_blit:1;          /* blit */
114
 
   unsigned viewport_index:4;  /* viewport index */
115
 
   unsigned layer:11;
116
 
   unsigned view_index:14;
117
 
   unsigned stride;             /* how much to advance data between a0, dadx, dady */
118
 
   unsigned pad[2];
119
 
   /* followed by a0, dadx, dady and planes[] */
120
 
};
121
 
 
122
 
struct lp_rast_plane {
123
 
   /* edge function values at minx,miny ?? */
124
 
   int64_t c;
125
 
 
126
 
   int32_t dcdx;
127
 
   int32_t dcdy;
128
 
 
129
 
   /* one-pixel sized trivial reject offsets for each plane */
130
 
   uint32_t eo;
131
 
   /*
132
 
    * We rely on this struct being 64bit aligned (ideally it would be 128bit
133
 
    * but that's quite the waste) and therefore on 32bit we need padding
134
 
    * since otherwise (even with the 64bit number in there) it wouldn't be.
135
 
    */
136
 
   uint32_t pad;
137
 
};
138
 
 
139
 
/**
140
 
 * Rasterization information for a triangle known to be in this bin,
141
 
 * plus inputs to run the shader:
142
 
 * These fields are tile- and bin-independent.
143
 
 * Objects of this type are put into the lp_setup_context::data buffer.
144
 
 */
145
 
struct lp_rast_triangle {
146
 
#ifdef DEBUG
147
 
   float v[3][2];
148
 
   float pad0;
149
 
   float pad1;
150
 
#endif
151
 
 
152
 
   /* inputs for the shader */
153
 
   struct lp_rast_shader_inputs inputs;
154
 
   /* planes are also allocated here */
155
 
};
156
 
 
157
 
 
158
 
#define RECT_PLANE_LEFT   0x1
159
 
#define RECT_PLANE_RIGHT  0x2
160
 
#define RECT_PLANE_TOP    0x4
161
 
#define RECT_PLANE_BOTTOM 0x8
162
 
 
163
 
/**
164
 
 * Rasterization information for a screen-aligned rectangle known to
165
 
 * be in this bin, plus inputs to run the shader:
166
 
 * These fields are tile- and bin-independent.
167
 
 * Objects of this type are put into the lp_setup_context::data buffer.
168
 
 */
169
 
struct lp_rast_rectangle {
170
 
#ifdef DEBUG
171
 
   float v[2][2]; /**< diagonal corners */
172
 
#endif
173
 
 
174
 
   /* Rectangle boundaries in integer pixels:
175
 
    */
176
 
   struct u_rect box;
177
 
 
178
 
   /* inputs for the shader */
179
 
   struct lp_rast_shader_inputs inputs;
180
 
};
181
 
 
182
 
 
183
 
struct lp_rast_clear_rb {
184
 
   union util_color color_val;
185
 
   unsigned cbuf;
186
 
};
187
 
 
188
 
 
189
 
#define GET_A0(inputs) ((float (*)[4])((inputs)+1))
190
 
#define GET_DADX(inputs) ((float (*)[4])((char *)((inputs) + 1) + (inputs)->stride))
191
 
#define GET_DADY(inputs) ((float (*)[4])((char *)((inputs) + 1) + 2 * (inputs)->stride))
192
 
#define GET_PLANES(tri) ((struct lp_rast_plane *)((char *)(&(tri)->inputs + 1) + 3 * (tri)->inputs.stride))
193
 
 
194
 
 
195
 
 
196
 
struct lp_rasterizer *
197
 
lp_rast_create( unsigned num_threads );
198
 
 
199
 
void
200
 
lp_rast_destroy( struct lp_rasterizer * );
201
 
 
202
 
void 
203
 
lp_rast_queue_scene( struct lp_rasterizer *rast,
204
 
                     struct lp_scene *scene );
205
 
 
206
 
void
207
 
lp_rast_finish( struct lp_rasterizer *rast );
208
 
 
209
 
 
210
 
union lp_rast_cmd_arg {
211
 
   const struct lp_rast_shader_inputs *shade_tile;
212
 
   struct {
213
 
      const struct lp_rast_triangle *tri;
214
 
      unsigned plane_mask;
215
 
   } triangle;
216
 
   const struct lp_rast_rectangle *rectangle;
217
 
   const struct lp_rast_state *set_state;
218
 
   const struct lp_rast_clear_rb *clear_rb;
219
 
   struct {
220
 
      uint64_t value;
221
 
      uint64_t mask;
222
 
   } clear_zstencil;
223
 
   const struct lp_rast_state *state;
224
 
   struct lp_fence *fence;
225
 
   struct llvmpipe_query *query_obj;
226
 
};
227
 
 
228
 
 
229
 
/* Cast wrappers.  Hopefully these compile to noops!
230
 
 */
231
 
static inline union lp_rast_cmd_arg
232
 
lp_rast_arg_inputs( const struct lp_rast_shader_inputs *shade_tile )
233
 
{
234
 
   union lp_rast_cmd_arg arg;
235
 
   arg.shade_tile = shade_tile;
236
 
   return arg;
237
 
}
238
 
 
239
 
static inline union lp_rast_cmd_arg
240
 
lp_rast_arg_triangle( const struct lp_rast_triangle *triangle,
241
 
                      unsigned plane_mask)
242
 
{
243
 
   union lp_rast_cmd_arg arg;
244
 
   arg.triangle.tri = triangle;
245
 
   arg.triangle.plane_mask = plane_mask;
246
 
   return arg;
247
 
}
248
 
 
249
 
/**
250
 
 * Build argument for a contained triangle.
251
 
 *
252
 
 * All planes are enabled, so instead of the plane mask we pass the upper
253
 
 * left coordinates of the a block that fully encloses the triangle.
254
 
 */
255
 
static inline union lp_rast_cmd_arg
256
 
lp_rast_arg_triangle_contained( const struct lp_rast_triangle *triangle,
257
 
                                unsigned x, unsigned y)
258
 
{
259
 
   union lp_rast_cmd_arg arg;
260
 
   arg.triangle.tri = triangle;
261
 
   arg.triangle.plane_mask = x | (y << 8);
262
 
   return arg;
263
 
}
264
 
 
265
 
static inline union lp_rast_cmd_arg
266
 
lp_rast_arg_rectangle( const struct lp_rast_rectangle *rectangle )
267
 
{
268
 
   union lp_rast_cmd_arg arg;
269
 
   arg.rectangle = rectangle;
270
 
   return arg;
271
 
}
272
 
 
273
 
static inline union lp_rast_cmd_arg
274
 
lp_rast_arg_state( const struct lp_rast_state *state )
275
 
{
276
 
   union lp_rast_cmd_arg arg;
277
 
   arg.set_state = state;
278
 
   return arg;
279
 
}
280
 
 
281
 
static inline union lp_rast_cmd_arg
282
 
lp_rast_arg_fence( struct lp_fence *fence )
283
 
{
284
 
   union lp_rast_cmd_arg arg;
285
 
   arg.fence = fence;
286
 
   return arg;
287
 
}
288
 
 
289
 
 
290
 
static inline union lp_rast_cmd_arg
291
 
lp_rast_arg_clearzs( uint64_t value, uint64_t mask )
292
 
{
293
 
   union lp_rast_cmd_arg arg;
294
 
   arg.clear_zstencil.value = value;
295
 
   arg.clear_zstencil.mask = mask;
296
 
   return arg;
297
 
}
298
 
 
299
 
 
300
 
static inline union lp_rast_cmd_arg
301
 
lp_rast_arg_query( struct llvmpipe_query *pq )
302
 
{
303
 
   union lp_rast_cmd_arg arg;
304
 
   arg.query_obj = pq;
305
 
   return arg;
306
 
}
307
 
 
308
 
static inline union lp_rast_cmd_arg
309
 
lp_rast_arg_null( void )
310
 
{
311
 
   union lp_rast_cmd_arg arg;
312
 
   arg.set_state = NULL;
313
 
   return arg;
314
 
}
315
 
 
316
 
 
317
 
/**
318
 
 * Binnable Commands.
319
 
 * These get put into bins by the setup code and are called when
320
 
 * the bins are executed.
321
 
 */
322
 
#define LP_RAST_OP_CLEAR_COLOR       0x0
323
 
#define LP_RAST_OP_CLEAR_ZSTENCIL    0x1
324
 
#define LP_RAST_OP_TRIANGLE_1        0x2
325
 
#define LP_RAST_OP_TRIANGLE_2        0x3
326
 
#define LP_RAST_OP_TRIANGLE_3        0x4
327
 
#define LP_RAST_OP_TRIANGLE_4        0x5
328
 
#define LP_RAST_OP_TRIANGLE_5        0x6
329
 
#define LP_RAST_OP_TRIANGLE_6        0x7
330
 
#define LP_RAST_OP_TRIANGLE_7        0x8
331
 
#define LP_RAST_OP_TRIANGLE_8        0x9
332
 
#define LP_RAST_OP_TRIANGLE_3_4      0xa
333
 
#define LP_RAST_OP_TRIANGLE_3_16     0xb
334
 
#define LP_RAST_OP_TRIANGLE_4_16     0xc
335
 
#define LP_RAST_OP_SHADE_TILE        0xd
336
 
#define LP_RAST_OP_SHADE_TILE_OPAQUE 0xe
337
 
#define LP_RAST_OP_BEGIN_QUERY       0xf
338
 
#define LP_RAST_OP_END_QUERY         0x10
339
 
#define LP_RAST_OP_SET_STATE         0x11
340
 
#define LP_RAST_OP_TRIANGLE_32_1     0x12
341
 
#define LP_RAST_OP_TRIANGLE_32_2     0x13
342
 
#define LP_RAST_OP_TRIANGLE_32_3     0x14
343
 
#define LP_RAST_OP_TRIANGLE_32_4     0x15
344
 
#define LP_RAST_OP_TRIANGLE_32_5     0x16
345
 
#define LP_RAST_OP_TRIANGLE_32_6     0x17
346
 
#define LP_RAST_OP_TRIANGLE_32_7     0x18
347
 
#define LP_RAST_OP_TRIANGLE_32_8     0x19
348
 
#define LP_RAST_OP_TRIANGLE_32_3_4   0x1a
349
 
#define LP_RAST_OP_TRIANGLE_32_3_16  0x1b
350
 
#define LP_RAST_OP_TRIANGLE_32_4_16  0x1c
351
 
 
352
 
#define LP_RAST_OP_MS_TRIANGLE_1     0x1d
353
 
#define LP_RAST_OP_MS_TRIANGLE_2     0x1e
354
 
#define LP_RAST_OP_MS_TRIANGLE_3     0x1f
355
 
#define LP_RAST_OP_MS_TRIANGLE_4     0x20
356
 
#define LP_RAST_OP_MS_TRIANGLE_5     0x21
357
 
#define LP_RAST_OP_MS_TRIANGLE_6     0x22
358
 
#define LP_RAST_OP_MS_TRIANGLE_7     0x23
359
 
#define LP_RAST_OP_MS_TRIANGLE_8     0x24
360
 
#define LP_RAST_OP_MS_TRIANGLE_3_4   0x25
361
 
#define LP_RAST_OP_MS_TRIANGLE_3_16  0x26
362
 
#define LP_RAST_OP_MS_TRIANGLE_4_16  0x27
363
 
#define LP_RAST_OP_RECTANGLE         0x28  /* Keep at end */
364
 
#define LP_RAST_OP_BLIT              0x29  /* Keep at end */
365
 
 
366
 
#define LP_RAST_OP_MAX               0x2a
367
 
#define LP_RAST_OP_MASK              0xff
368
 
 
369
 
/* Returned by characterize_bin:
370
 
 */
371
 
#define LP_RAST_FLAGS_TRI            (0x1)
372
 
#define LP_RAST_FLAGS_RECT           (0x2)
373
 
#define LP_RAST_FLAGS_TILE           (0x4)
374
 
#define LP_RAST_FLAGS_BLIT           (0x8)
375
 
 
376
 
struct lp_bin_info {
377
 
   unsigned type:8;
378
 
   unsigned count:24;
379
 
};
380
 
 
381
 
struct lp_bin_info
382
 
lp_characterize_bin(const struct cmd_bin *bin);
383
 
 
384
 
void
385
 
lp_debug_bins( struct lp_scene *scene );
386
 
void
387
 
lp_debug_draw_bins_by_cmd_length( struct lp_scene *scene );
388
 
void
389
 
lp_debug_draw_bins_by_coverage( struct lp_scene *scene );
390
 
 
391
 
 
392
 
#endif