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 * @file 30 * C - JIT interfaces 31 * 32 * @author Jose Fonseca <jfonseca@vmware.com> 33 */ 34 35 #ifndef LP_JIT_H 36 #define LP_JIT_H 37 38 39 #include "gallivm/lp_bld_struct.h" 40 #include "gallivm/lp_bld_limits.h" 41 42 #include "pipe/p_state.h" 43 #include "lp_texture.h" 44 45 46 struct lp_build_format_cache; 47 struct lp_fragment_shader_variant; 48 struct llvmpipe_screen; 49 50 51 struct lp_jit_texture 52 { 53 uint32_t width; /* same as number of elements */ 54 uint32_t height; 55 uint32_t depth; /* doubles as array size */ 56 uint32_t first_level; 57 uint32_t last_level; 58 const void *base; 59 uint32_t row_stride[LP_MAX_TEXTURE_LEVELS]; 60 uint32_t img_stride[LP_MAX_TEXTURE_LEVELS]; 61 uint32_t mip_offsets[LP_MAX_TEXTURE_LEVELS]; 62 }; 63 64 65 struct lp_jit_sampler 66 { 67 float min_lod; 68 float max_lod; 69 float lod_bias; 70 float border_color[4]; 71 }; 72 73 74 struct lp_jit_viewport 75 { 76 float min_depth; 77 float max_depth; 78 }; 79 80 81 enum { 82 LP_JIT_TEXTURE_WIDTH = 0, 83 LP_JIT_TEXTURE_HEIGHT, 84 LP_JIT_TEXTURE_DEPTH, 85 LP_JIT_TEXTURE_FIRST_LEVEL, 86 LP_JIT_TEXTURE_LAST_LEVEL, 87 LP_JIT_TEXTURE_BASE, 88 LP_JIT_TEXTURE_ROW_STRIDE, 89 LP_JIT_TEXTURE_IMG_STRIDE, 90 LP_JIT_TEXTURE_MIP_OFFSETS, 91 LP_JIT_TEXTURE_NUM_FIELDS /* number of fields above */ 92 }; 93 94 95 enum { 96 LP_JIT_SAMPLER_MIN_LOD, 97 LP_JIT_SAMPLER_MAX_LOD, 98 LP_JIT_SAMPLER_LOD_BIAS, 99 LP_JIT_SAMPLER_BORDER_COLOR, 100 LP_JIT_SAMPLER_NUM_FIELDS /* number of fields above */ 101 }; 102 103 104 enum { 105 LP_JIT_VIEWPORT_MIN_DEPTH, 106 LP_JIT_VIEWPORT_MAX_DEPTH, 107 LP_JIT_VIEWPORT_NUM_FIELDS /* number of fields above */ 108 }; 109 110 111 /** 112 * This structure is passed directly to the generated fragment shader. 113 * 114 * It contains the derived state. 115 * 116 * Changes here must be reflected in the lp_jit_context_* macros and 117 * lp_jit_init_types function. Changes to the ordering should be avoided. 118 * 119 * Only use types with a clear size and padding here, in particular prefer the 120 * stdint.h types to the basic integer types. 121 */ 122 struct lp_jit_context 123 { 124 const float *constants[LP_MAX_TGSI_CONST_BUFFERS]; 125 int num_constants[LP_MAX_TGSI_CONST_BUFFERS]; 126 127 float alpha_ref_value; 128 129 uint32_t stencil_ref_front, stencil_ref_back; 130 131 uint8_t *u8_blend_color; 132 float *f_blend_color; 133 134 struct lp_jit_viewport *viewports; 135 136 struct lp_jit_texture textures[PIPE_MAX_SHADER_SAMPLER_VIEWS]; 137 struct lp_jit_sampler samplers[PIPE_MAX_SAMPLERS]; 138 }; 139 140 141 /** 142 * These enum values must match the position of the fields in the 143 * lp_jit_context struct above. 144 */ 145 enum { 146 LP_JIT_CTX_CONSTANTS = 0, 147 LP_JIT_CTX_NUM_CONSTANTS, 148 LP_JIT_CTX_ALPHA_REF, 149 LP_JIT_CTX_STENCIL_REF_FRONT, 150 LP_JIT_CTX_STENCIL_REF_BACK, 151 LP_JIT_CTX_U8_BLEND_COLOR, 152 LP_JIT_CTX_F_BLEND_COLOR, 153 LP_JIT_CTX_VIEWPORTS, 154 LP_JIT_CTX_TEXTURES, 155 LP_JIT_CTX_SAMPLERS, 156 LP_JIT_CTX_COUNT 157 }; 158 159 160 #define lp_jit_context_constants(_gallivm, _ptr) \ 161 lp_build_struct_get_ptr(_gallivm, _ptr, LP_JIT_CTX_CONSTANTS, "constants") 162 163 #define lp_jit_context_num_constants(_gallivm, _ptr) \ 164 lp_build_struct_get_ptr(_gallivm, _ptr, LP_JIT_CTX_NUM_CONSTANTS, "num_constants") 165 166 #define lp_jit_context_alpha_ref_value(_gallivm, _ptr) \ 167 lp_build_struct_get(_gallivm, _ptr, LP_JIT_CTX_ALPHA_REF, "alpha_ref_value") 168 169 #define lp_jit_context_stencil_ref_front_value(_gallivm, _ptr) \ 170 lp_build_struct_get(_gallivm, _ptr, LP_JIT_CTX_STENCIL_REF_FRONT, "stencil_ref_front") 171 172 #define lp_jit_context_stencil_ref_back_value(_gallivm, _ptr) \ 173 lp_build_struct_get(_gallivm, _ptr, LP_JIT_CTX_STENCIL_REF_BACK, "stencil_ref_back") 174 175 #define lp_jit_context_u8_blend_color(_gallivm, _ptr) \ 176 lp_build_struct_get(_gallivm, _ptr, LP_JIT_CTX_U8_BLEND_COLOR, "u8_blend_color") 177 178 #define lp_jit_context_f_blend_color(_gallivm, _ptr) \ 179 lp_build_struct_get(_gallivm, _ptr, LP_JIT_CTX_F_BLEND_COLOR, "f_blend_color") 180 181 #define lp_jit_context_viewports(_gallivm, _ptr) \ 182 lp_build_struct_get(_gallivm, _ptr, LP_JIT_CTX_VIEWPORTS, "viewports") 183 184 #define lp_jit_context_textures(_gallivm, _ptr) \ 185 lp_build_struct_get_ptr(_gallivm, _ptr, LP_JIT_CTX_TEXTURES, "textures") 186 187 #define lp_jit_context_samplers(_gallivm, _ptr) \ 188 lp_build_struct_get_ptr(_gallivm, _ptr, LP_JIT_CTX_SAMPLERS, "samplers") 189 190 191 struct lp_jit_thread_data 192 { 193 struct lp_build_format_cache *cache; 194 uint64_t vis_counter; 195 196 /* 197 * Non-interpolated rasterizer state passed through to the fragment shader. 198 */ 199 struct { 200 uint32_t viewport_index; 201 } raster_state; 202 }; 203 204 205 enum { 206 LP_JIT_THREAD_DATA_CACHE = 0, 207 LP_JIT_THREAD_DATA_COUNTER, 208 LP_JIT_THREAD_DATA_RASTER_STATE_VIEWPORT_INDEX, 209 LP_JIT_THREAD_DATA_COUNT 210 }; 211 212 213 #define lp_jit_thread_data_cache(_gallivm, _ptr) \ 214 lp_build_struct_get(_gallivm, _ptr, LP_JIT_THREAD_DATA_CACHE, "cache") 215 216 #define lp_jit_thread_data_counter(_gallivm, _ptr) \ 217 lp_build_struct_get_ptr(_gallivm, _ptr, LP_JIT_THREAD_DATA_COUNTER, "counter") 218 219 #define lp_jit_thread_data_raster_state_viewport_index(_gallivm, _ptr) \ 220 lp_build_struct_get(_gallivm, _ptr, \ 221 LP_JIT_THREAD_DATA_RASTER_STATE_VIEWPORT_INDEX, \ 222 "raster_state.viewport_index") 223 224 /** 225 * typedef for fragment shader function 226 * 227 * @param context jit context 228 * @param x block start x 229 * @param y block start y 230 * @param facing is front facing 231 * @param a0 shader input a0 232 * @param dadx shader input dadx 233 * @param dady shader input dady 234 * @param color color buffer 235 * @param depth depth buffer 236 * @param mask mask of visible pixels in block 237 * @param thread_data task thread data 238 * @param stride color buffer row stride in bytes 239 * @param depth_stride depth buffer row stride in bytes 240 */ 241 typedef void 242 (*lp_jit_frag_func)(const struct lp_jit_context *context, 243 uint32_t x, 244 uint32_t y, 245 uint32_t facing, 246 const void *a0, 247 const void *dadx, 248 const void *dady, 249 uint8_t **color, 250 uint8_t *depth, 251 uint32_t mask, 252 struct lp_jit_thread_data *thread_data, 253 unsigned *stride, 254 unsigned depth_stride); 255 256 257 void 258 lp_jit_screen_cleanup(struct llvmpipe_screen *screen); 259 260 261 boolean 262 lp_jit_screen_init(struct llvmpipe_screen *screen); 263 264 265 void 266 lp_jit_init_types(struct lp_fragment_shader_variant *lp); 267 268 269 #endif /* LP_JIT_H */ 270