• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /****************************************************************************
2  * Copyright (C) 2015 Intel Corporation.   All Rights Reserved.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21  * IN THE SOFTWARE.
22  ***************************************************************************/
23 
24 #ifndef SWR_STATE_H
25 #define SWR_STATE_H
26 
27 #include "pipe/p_defines.h"
28 #include "tgsi/tgsi_scan.h"
29 #include "tgsi/tgsi_parse.h"
30 #include "tgsi/tgsi_dump.h"
31 #include "gallivm/lp_bld_init.h"
32 #include "gallivm/lp_bld_tgsi.h"
33 #include "util/crc32.h"
34 #include "api.h"
35 #include "swr_tex_sample.h"
36 #include "swr_shader.h"
37 #include <unordered_map>
38 #include <memory>
39 
40 template <typename T>
41 struct ShaderVariant {
42    struct gallivm_state *gallivm;
43    T shader;
44 
ShaderVariantShaderVariant45    ShaderVariant(struct gallivm_state *gs, T code) : gallivm(gs), shader(code) {}
~ShaderVariantShaderVariant46    ~ShaderVariant() { gallivm_destroy(gallivm); }
47 };
48 
49 typedef ShaderVariant<PFN_VERTEX_FUNC> VariantVS;
50 typedef ShaderVariant<PFN_PIXEL_KERNEL> VariantFS;
51 typedef ShaderVariant<PFN_GS_FUNC> VariantGS;
52 
53 /* skeleton */
54 struct swr_vertex_shader {
55    struct pipe_shader_state pipe;
56    struct lp_tgsi_info info;
57    std::unordered_map<swr_jit_vs_key, std::unique_ptr<VariantVS>> map;
58    SWR_STREAMOUT_STATE soState;
59    PFN_SO_FUNC soFunc[PIPE_PRIM_MAX] {0};
60 };
61 
62 struct swr_fragment_shader {
63    struct pipe_shader_state pipe;
64    struct lp_tgsi_info info;
65    uint32_t constantMask;
66    uint32_t flatConstantMask;
67    uint32_t pointSpriteMask;
68    std::unordered_map<swr_jit_fs_key, std::unique_ptr<VariantFS>> map;
69 };
70 
71 struct swr_geometry_shader {
72    struct pipe_shader_state pipe;
73    struct lp_tgsi_info info;
74    SWR_GS_STATE gsState;
75 
76    std::unordered_map<swr_jit_gs_key, std::unique_ptr<VariantGS>> map;
77 };
78 
79 /* Vertex element state */
80 struct swr_vertex_element_state {
81    FETCH_COMPILE_STATE fsState;
82    PFN_FETCH_FUNC fsFunc {NULL};
83    uint32_t stream_pitch[PIPE_MAX_ATTRIBS] {0};
84    uint32_t min_instance_div[PIPE_MAX_ATTRIBS] {0};
85    uint32_t instanced_bufs {0};
86    std::unordered_map<swr_jit_fetch_key, PFN_FETCH_FUNC> map;
87 };
88 
89 struct swr_blend_state {
90    struct pipe_blend_state pipe;
91    SWR_BLEND_STATE blendState;
92    RENDER_TARGET_BLEND_COMPILE_STATE compileState[PIPE_MAX_COLOR_BUFS];
93 };
94 
95 struct swr_poly_stipple {
96    struct pipe_poly_stipple pipe;
97    bool prim_is_poly;
98 };
99 
100 /*
101  * Derived SWR API DrawState
102  * For convenience of making simple changes without re-deriving state.
103  */
104 struct swr_derived_state {
105    SWR_RASTSTATE rastState;
106    SWR_VIEWPORT vp;
107    SWR_VIEWPORT_MATRICES vpm;
108 };
109 
110 void swr_update_derived(struct pipe_context *,
111                         const struct pipe_draw_info * = nullptr);
112 
113 /*
114  * Conversion functions: Convert mesa state defines to SWR.
115  */
116 
117 static INLINE SWR_LOGIC_OP
swr_convert_logic_op(const UINT op)118 swr_convert_logic_op(const UINT op)
119 {
120    switch (op) {
121    case PIPE_LOGICOP_CLEAR:
122       return LOGICOP_CLEAR;
123    case PIPE_LOGICOP_NOR:
124       return LOGICOP_NOR;
125    case PIPE_LOGICOP_AND_INVERTED:
126       return LOGICOP_AND_INVERTED;
127    case PIPE_LOGICOP_COPY_INVERTED:
128       return LOGICOP_COPY_INVERTED;
129    case PIPE_LOGICOP_AND_REVERSE:
130       return LOGICOP_AND_REVERSE;
131    case PIPE_LOGICOP_INVERT:
132       return LOGICOP_INVERT;
133    case PIPE_LOGICOP_XOR:
134       return LOGICOP_XOR;
135    case PIPE_LOGICOP_NAND:
136       return LOGICOP_NAND;
137    case PIPE_LOGICOP_AND:
138       return LOGICOP_AND;
139    case PIPE_LOGICOP_EQUIV:
140       return LOGICOP_EQUIV;
141    case PIPE_LOGICOP_NOOP:
142       return LOGICOP_NOOP;
143    case PIPE_LOGICOP_OR_INVERTED:
144       return LOGICOP_OR_INVERTED;
145    case PIPE_LOGICOP_COPY:
146       return LOGICOP_COPY;
147    case PIPE_LOGICOP_OR_REVERSE:
148       return LOGICOP_OR_REVERSE;
149    case PIPE_LOGICOP_OR:
150       return LOGICOP_OR;
151    case PIPE_LOGICOP_SET:
152       return LOGICOP_SET;
153    default:
154       assert(0 && "Unsupported logic op");
155       return LOGICOP_NOOP;
156    }
157 }
158 
159 static INLINE SWR_STENCILOP
swr_convert_stencil_op(const UINT op)160 swr_convert_stencil_op(const UINT op)
161 {
162    switch (op) {
163    case PIPE_STENCIL_OP_KEEP:
164       return STENCILOP_KEEP;
165    case PIPE_STENCIL_OP_ZERO:
166       return STENCILOP_ZERO;
167    case PIPE_STENCIL_OP_REPLACE:
168       return STENCILOP_REPLACE;
169    case PIPE_STENCIL_OP_INCR:
170       return STENCILOP_INCRSAT;
171    case PIPE_STENCIL_OP_DECR:
172       return STENCILOP_DECRSAT;
173    case PIPE_STENCIL_OP_INCR_WRAP:
174       return STENCILOP_INCR;
175    case PIPE_STENCIL_OP_DECR_WRAP:
176       return STENCILOP_DECR;
177    case PIPE_STENCIL_OP_INVERT:
178       return STENCILOP_INVERT;
179    default:
180       assert(0 && "Unsupported stencil op");
181       return STENCILOP_KEEP;
182    }
183 }
184 
185 static INLINE SWR_FORMAT
swr_convert_index_type(const UINT index_size)186 swr_convert_index_type(const UINT index_size)
187 {
188    switch (index_size) {
189    case sizeof(unsigned char):
190       return R8_UINT;
191    case sizeof(unsigned short):
192       return R16_UINT;
193    case sizeof(unsigned int):
194       return R32_UINT;
195    default:
196       assert(0 && "Unsupported index type");
197       return R32_UINT;
198    }
199 }
200 
201 
202 static INLINE SWR_ZFUNCTION
swr_convert_depth_func(const UINT pipe_func)203 swr_convert_depth_func(const UINT pipe_func)
204 {
205    switch (pipe_func) {
206    case PIPE_FUNC_NEVER:
207       return ZFUNC_NEVER;
208    case PIPE_FUNC_LESS:
209       return ZFUNC_LT;
210    case PIPE_FUNC_EQUAL:
211       return ZFUNC_EQ;
212    case PIPE_FUNC_LEQUAL:
213       return ZFUNC_LE;
214    case PIPE_FUNC_GREATER:
215       return ZFUNC_GT;
216    case PIPE_FUNC_NOTEQUAL:
217       return ZFUNC_NE;
218    case PIPE_FUNC_GEQUAL:
219       return ZFUNC_GE;
220    case PIPE_FUNC_ALWAYS:
221       return ZFUNC_ALWAYS;
222    default:
223       assert(0 && "Unsupported depth func");
224       return ZFUNC_ALWAYS;
225    }
226 }
227 
228 
229 static INLINE SWR_CULLMODE
swr_convert_cull_mode(const UINT cull_face)230 swr_convert_cull_mode(const UINT cull_face)
231 {
232    switch (cull_face) {
233    case PIPE_FACE_NONE:
234       return SWR_CULLMODE_NONE;
235    case PIPE_FACE_FRONT:
236       return SWR_CULLMODE_FRONT;
237    case PIPE_FACE_BACK:
238       return SWR_CULLMODE_BACK;
239    case PIPE_FACE_FRONT_AND_BACK:
240       return SWR_CULLMODE_BOTH;
241    default:
242       assert(0 && "Invalid cull mode");
243       return SWR_CULLMODE_NONE;
244    }
245 }
246 
247 static INLINE SWR_BLEND_OP
swr_convert_blend_func(const UINT blend_func)248 swr_convert_blend_func(const UINT blend_func)
249 {
250    switch (blend_func) {
251    case PIPE_BLEND_ADD:
252       return BLENDOP_ADD;
253    case PIPE_BLEND_SUBTRACT:
254       return BLENDOP_SUBTRACT;
255    case PIPE_BLEND_REVERSE_SUBTRACT:
256       return BLENDOP_REVSUBTRACT;
257    case PIPE_BLEND_MIN:
258       return BLENDOP_MIN;
259    case PIPE_BLEND_MAX:
260       return BLENDOP_MAX;
261    default:
262       assert(0 && "Invalid blend func");
263       return BLENDOP_ADD;
264    }
265 }
266 
267 static INLINE SWR_BLEND_FACTOR
swr_convert_blend_factor(const UINT blend_factor)268 swr_convert_blend_factor(const UINT blend_factor)
269 {
270    switch (blend_factor) {
271    case PIPE_BLENDFACTOR_ONE:
272       return BLENDFACTOR_ONE;
273    case PIPE_BLENDFACTOR_SRC_COLOR:
274       return BLENDFACTOR_SRC_COLOR;
275    case PIPE_BLENDFACTOR_SRC_ALPHA:
276       return BLENDFACTOR_SRC_ALPHA;
277    case PIPE_BLENDFACTOR_DST_ALPHA:
278       return BLENDFACTOR_DST_ALPHA;
279    case PIPE_BLENDFACTOR_DST_COLOR:
280       return BLENDFACTOR_DST_COLOR;
281    case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
282       return BLENDFACTOR_SRC_ALPHA_SATURATE;
283    case PIPE_BLENDFACTOR_CONST_COLOR:
284       return BLENDFACTOR_CONST_COLOR;
285    case PIPE_BLENDFACTOR_CONST_ALPHA:
286       return BLENDFACTOR_CONST_ALPHA;
287    case PIPE_BLENDFACTOR_SRC1_COLOR:
288       return BLENDFACTOR_SRC1_COLOR;
289    case PIPE_BLENDFACTOR_SRC1_ALPHA:
290       return BLENDFACTOR_SRC1_ALPHA;
291    case PIPE_BLENDFACTOR_ZERO:
292       return BLENDFACTOR_ZERO;
293    case PIPE_BLENDFACTOR_INV_SRC_COLOR:
294       return BLENDFACTOR_INV_SRC_COLOR;
295    case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
296       return BLENDFACTOR_INV_SRC_ALPHA;
297    case PIPE_BLENDFACTOR_INV_DST_ALPHA:
298       return BLENDFACTOR_INV_DST_ALPHA;
299    case PIPE_BLENDFACTOR_INV_DST_COLOR:
300       return BLENDFACTOR_INV_DST_COLOR;
301    case PIPE_BLENDFACTOR_INV_CONST_COLOR:
302       return BLENDFACTOR_INV_CONST_COLOR;
303    case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
304       return BLENDFACTOR_INV_CONST_ALPHA;
305    case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
306       return BLENDFACTOR_INV_SRC1_COLOR;
307    case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
308       return BLENDFACTOR_INV_SRC1_ALPHA;
309    default:
310       assert(0 && "Invalid blend factor");
311       return BLENDFACTOR_ONE;
312    }
313 }
314 
315 static INLINE enum SWR_SURFACE_TYPE
swr_convert_target_type(const enum pipe_texture_target target)316 swr_convert_target_type(const enum pipe_texture_target target)
317 {
318    switch (target) {
319    case PIPE_BUFFER:
320       return SURFACE_BUFFER;
321    case PIPE_TEXTURE_1D:
322    case PIPE_TEXTURE_1D_ARRAY:
323       return SURFACE_1D;
324    case PIPE_TEXTURE_2D:
325    case PIPE_TEXTURE_2D_ARRAY:
326    case PIPE_TEXTURE_RECT:
327       return SURFACE_2D;
328    case PIPE_TEXTURE_3D:
329       return SURFACE_3D;
330    case PIPE_TEXTURE_CUBE:
331    case PIPE_TEXTURE_CUBE_ARRAY:
332       return SURFACE_CUBE;
333    default:
334       assert(0);
335       return SURFACE_NULL;
336    }
337 }
338 
339 /*
340  * Convert mesa PIPE_PRIM_X to SWR enum PRIMITIVE_TOPOLOGY
341  */
342 static INLINE enum PRIMITIVE_TOPOLOGY
swr_convert_prim_topology(const unsigned mode)343 swr_convert_prim_topology(const unsigned mode)
344 {
345    switch (mode) {
346    case PIPE_PRIM_POINTS:
347       return TOP_POINT_LIST;
348    case PIPE_PRIM_LINES:
349       return TOP_LINE_LIST;
350    case PIPE_PRIM_LINE_LOOP:
351       return TOP_LINE_LOOP;
352    case PIPE_PRIM_LINE_STRIP:
353       return TOP_LINE_STRIP;
354    case PIPE_PRIM_TRIANGLES:
355       return TOP_TRIANGLE_LIST;
356    case PIPE_PRIM_TRIANGLE_STRIP:
357       return TOP_TRIANGLE_STRIP;
358    case PIPE_PRIM_TRIANGLE_FAN:
359       return TOP_TRIANGLE_FAN;
360    case PIPE_PRIM_QUADS:
361       return TOP_QUAD_LIST;
362    case PIPE_PRIM_QUAD_STRIP:
363       return TOP_QUAD_STRIP;
364    case PIPE_PRIM_POLYGON:
365       return TOP_TRIANGLE_FAN; /* XXX TOP_POLYGON; */
366    case PIPE_PRIM_LINES_ADJACENCY:
367       return TOP_LINE_LIST_ADJ;
368    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
369       return TOP_LISTSTRIP_ADJ;
370    case PIPE_PRIM_TRIANGLES_ADJACENCY:
371       return TOP_TRI_LIST_ADJ;
372    case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
373       return TOP_TRI_STRIP_ADJ;
374    default:
375       assert(0 && "Unknown topology");
376       return TOP_UNKNOWN;
377    }
378 };
379 
380 /*
381  * convert mesa PIPE_POLYGON_MODE_X to SWR enum SWR_FILLMODE
382  */
383 static INLINE enum SWR_FILLMODE
swr_convert_fill_mode(const unsigned mode)384 swr_convert_fill_mode(const unsigned mode)
385 {
386    switch(mode) {
387    case PIPE_POLYGON_MODE_FILL:
388       return SWR_FILLMODE_SOLID;
389    case PIPE_POLYGON_MODE_LINE:
390       return SWR_FILLMODE_WIREFRAME;
391    case PIPE_POLYGON_MODE_POINT:
392       return SWR_FILLMODE_POINT;
393    default:
394       assert(0 && "Unknown fillmode");
395       return SWR_FILLMODE_SOLID; // at least do something sensible
396    }
397 }
398 
399 #endif
400