1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
/**************************************************************************
*
* Copyright 2009 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
/**
* The rast code is concerned with rasterization of command bins.
* Each screen tile has a bin associated with it. To render the
* scene we iterate over the tile bins and execute the commands
* in each bin.
* We'll do that with multiple threads...
*/
#ifndef LP_RAST_H
#define LP_RAST_H
#include "pipe/p_compiler.h"
#include "lp_jit.h"
/* Initially create and program a single rasterizer directly. Later
* will want multiple of these, one or two per core. At that stage
* will probably pass command buffers into the rasterizers rather than
* individual function calls like this.
*/
struct lp_rasterizer;
struct pipe_screen;
#define FIXED_ORDER 4
#define FIXED_ONE (1<<FIXED_ORDER)
/**
* Rasterization state.
* Objects of this type are put into the shared data bin and pointed
* to by commands in the per-tile bins.
*/
struct lp_rast_state {
/* State for the shader:
*/
struct lp_jit_context jit_context;
/* The shader itself. Probably we also need to pass a pointer to
* the tile color/z/stencil data somehow:
*/
lp_jit_frag_func jit_function;
};
/**
* Coefficients necessary to run the shader at a given location.
* First coefficient is position.
* These pointers point into the bin data buffer.
*/
struct lp_rast_shader_inputs {
float (*a0)[4];
float (*dadx)[4];
float (*dady)[4];
};
/**
* Rasterization information for a triangle known to be in this bin,
* plus inputs to run the shader:
* These fields are tile- and bin-independent.
* Objects of this type are put into the setup_context::data buffer.
*/
struct lp_rast_triangle {
/* bounding box of tri (in pixels) */
int minx;
int maxx;
int miny;
int maxy;
/* one-pixel sized trivial accept offsets for each plane */
int ei1;
int ei2;
int ei3;
/* one-pixel sized trivial reject offsets for each plane */
int eo1;
int eo2;
int eo3;
/* y deltas for vertex pairs (in fixed pt) */
int dy12;
int dy23;
int dy31;
/* x deltas for vertex pairs (in fixed pt) */
int dx12;
int dx23;
int dx31;
/* edge function values at minx,miny ?? */
int c1;
int c2;
int c3;
int step[3][16];
/* inputs for the shader */
struct lp_rast_shader_inputs inputs;
};
struct lp_rasterizer *lp_rast_create( struct pipe_screen *screen );
void lp_rast_destroy( struct lp_rasterizer * );
boolean lp_rast_begin( struct lp_rasterizer *rast,
struct pipe_surface *cbuf,
struct pipe_surface *zsbuf,
boolean write_color,
boolean write_zstencil,
unsigned width,
unsigned height );
void lp_rast_end( struct lp_rasterizer * );
/* Begining of each tile:
*/
void lp_rast_start_tile( struct lp_rasterizer *,
unsigned x,
unsigned y );
union lp_rast_cmd_arg {
const struct lp_rast_shader_inputs *shade_tile;
const struct lp_rast_triangle *triangle;
const struct lp_rast_state *set_state;
uint8_t clear_color[4];
unsigned clear_zstencil;
};
/* Cast wrappers. Hopefully these compile to noops!
*/
static INLINE const union lp_rast_cmd_arg
lp_rast_arg_inputs( const struct lp_rast_shader_inputs *shade_tile )
{
union lp_rast_cmd_arg arg;
arg.shade_tile = shade_tile;
return arg;
}
static INLINE const union lp_rast_cmd_arg
lp_rast_arg_triangle( const struct lp_rast_triangle *triangle )
{
union lp_rast_cmd_arg arg;
arg.triangle = triangle;
return arg;
}
static INLINE const union lp_rast_cmd_arg
lp_rast_arg_state( const struct lp_rast_state *state )
{
union lp_rast_cmd_arg arg;
arg.set_state = state;
return arg;
}
static INLINE const union lp_rast_cmd_arg
lp_rast_arg_null( void )
{
union lp_rast_cmd_arg arg;
arg.set_state = NULL;
return arg;
}
/**
* Binnable Commands.
* These get put into bins by the setup code and are called when
* the bins are executed.
*/
void lp_rast_clear_color( struct lp_rasterizer *,
const union lp_rast_cmd_arg );
void lp_rast_clear_zstencil( struct lp_rasterizer *,
const union lp_rast_cmd_arg );
void lp_rast_load_color( struct lp_rasterizer *,
const union lp_rast_cmd_arg );
void lp_rast_load_zstencil( struct lp_rasterizer *,
const union lp_rast_cmd_arg );
void lp_rast_set_state( struct lp_rasterizer *,
const union lp_rast_cmd_arg );
void lp_rast_triangle( struct lp_rasterizer *,
const union lp_rast_cmd_arg );
void lp_rast_shade_tile( struct lp_rasterizer *,
const union lp_rast_cmd_arg );
/* End of tile:
*/
void lp_rast_end_tile( struct lp_rasterizer *rast );
#endif
|
