Max 5 API Reference
Max 5 API Reference
00001 #include "jit.gl.shader.h" 00002 #include "jit.gl.shader.asm.h" 00003 #include "jit.gl.shader.glsl.h" 00004 #include "jit.gl.shader.cg.h" 00005 #include "jit.gl.shader.cache.h" 00006 00007 #include "jit.vecmath.h" 00008 #include "jit.xml.h" 00009 00010 00011 // -------------------------------------------------------------------------------- 00012 00013 void *_jit_gl_shader_class; 00014 00015 00016 const unsigned char *pb_jit_gl_extensions; 00017 00018 #ifdef __APPLE_CC__ 00019 t_symbol *ps_nobox, *ps_atomarray; 00020 #else 00021 static t_symbol *ps_nobox, *ps_atomarray; 00022 #endif 00023 00024 t_symbol *ps_jit_gl_bind; 00025 t_symbol *ps_jit_gl_unbind; 00026 t_symbol *ps_jit_gl_drawto; 00027 00028 t_symbol *ps_jit_gl_mesh; 00029 t_symbol *ps_jit_gl_mesh_get_cache; 00030 00031 #ifdef __APPLE_CC__ 00032 t_symbol *ps_jit_gl_texture; 00033 #else 00034 static t_symbol *ps_jit_gl_texture; 00035 #endif 00036 00037 t_symbol *ps_jit_gl_shader_texture; 00038 t_symbol *ps_jit_gl_texture_width; 00039 t_symbol *ps_jit_gl_texture_height; 00040 t_symbol *ps_jit_gl_texture_depth; 00041 00042 t_symbol *ps_jit_gl_shader_language_auto; 00043 t_symbol *ps_jit_gl_shader_language_glsl; 00044 t_symbol *ps_jit_gl_shader_language_arb; 00045 t_symbol *ps_jit_gl_shader_language_nv; 00046 t_symbol *ps_jit_gl_shader_language_cg; 00047 t_symbol *ps_jit_gl_shader_backend_glsl; 00048 t_symbol *ps_jit_gl_shader_backend_asm; 00049 t_symbol *ps_jit_gl_shader_backend_cg; 00050 t_symbol *ps_jit_gl_shader_profile; 00051 t_symbol *ps_jit_gl_shader_entry; 00052 t_symbol *ps_jit_gl_shader_args; 00053 t_symbol *ps_jit_gl_shader_count; 00054 t_symbol *ps_jit_gl_shader_state; 00055 t_symbol *ps_jit_gl_shader_transform; 00056 t_symbol *ps_jit_gl_shader_bind; 00057 t_symbol *ps_jit_gl_shader_target; 00058 t_symbol *ps_jit_gl_shader_program; 00059 t_symbol *ps_jit_gl_shader_param; 00060 t_symbol *ps_jit_gl_shader_language; 00061 t_symbol *ps_jit_gl_shader_version; 00062 t_symbol *ps_jit_gl_shader_source; 00063 t_symbol *ps_jit_gl_shader_assembly; 00064 t_symbol *ps_jit_gl_shader_params; 00065 t_symbol *ps_jit_gl_shader_object; 00066 t_symbol *ps_jit_gl_shader_all; 00067 t_symbol *ps_jit_gl_shader_user; 00068 t_symbol *ps_jit_gl_shader_getparamval; 00069 t_symbol *ps_jit_gl_shader_getparamdefault; 00070 t_symbol *ps_jit_gl_shader_getparamtype; 00071 00072 // shader managed state variables 00073 t_symbol *ps_jit_gl_shader_state_modelview_matrix; // MODELVIEW_MATRIX 00074 t_symbol *ps_jit_gl_shader_state_projection_matrix; // PROJECTION_MATRIX 00075 t_symbol *ps_jit_gl_shader_state_modelview_projection_matrix; // MODELVIEW_PROJECTION_MATRIX 00076 t_symbol *ps_jit_gl_shader_state_normal_matrix; // NORMAL_MATRIX 00077 t_symbol *ps_jit_gl_shader_state_texture_matrix; // TEXTURE_MATRIX 00078 t_symbol *ps_jit_gl_shader_state_texture0_matrix; // TEXTURE0_MATRIX 00079 t_symbol *ps_jit_gl_shader_state_texture1_matrix; // TEXTURE1_MATRIX 00080 t_symbol *ps_jit_gl_shader_state_texture2_matrix; // TEXTURE2_MATRIX 00081 t_symbol *ps_jit_gl_shader_state_texture3_matrix; // TEXTURE3_MATRIX 00082 t_symbol *ps_jit_gl_shader_state_texture4_matrix; // TEXTURE4_MATRIX 00083 t_symbol *ps_jit_gl_shader_state_texture5_matrix; // TEXTURE5_MATRIX 00084 t_symbol *ps_jit_gl_shader_state_texture6_matrix; // TEXTURE6_MATRIX 00085 t_symbol *ps_jit_gl_shader_state_texture7_matrix; // TEXTURE7_MATRIX 00086 00087 // ob3d managed state parameters 00088 t_symbol *ps_jit_gl_shader_state_position; // vertex position 00089 t_symbol *ps_jit_gl_shader_state_normal; // normal direction 00090 t_symbol *ps_jit_gl_shader_state_tangent; // tangent position (calculated in mesh) 00091 t_symbol *ps_jit_gl_shader_state_bitangent; // bitangent position (calculated in mesh) 00092 t_symbol *ps_jit_gl_shader_state_vertex_attr; // per vertex attribute from (calculated in mesh) 00093 t_symbol *ps_jit_gl_shader_state_edgeflag; // edgeflags (calculated in mesh) 00094 t_symbol *ps_jit_gl_shader_state_blendweight; // TODO: blendweight (via WeightARB & VertexWeightEXT) 00095 t_symbol *ps_jit_gl_shader_state_color0; // primary color (via Color) 00096 t_symbol *ps_jit_gl_shader_state_color1; // TODO: secondary color (via SecondaryColorEXT) 00097 t_symbol *ps_jit_gl_shader_state_ambient; // ambient color 00098 t_symbol *ps_jit_gl_shader_state_diffuse; // primary color (same as color0) 00099 t_symbol *ps_jit_gl_shader_state_specular; // TODO: secondary color (same as color1) 00100 t_symbol *ps_jit_gl_shader_state_emission; // emission color 00101 t_symbol *ps_jit_gl_shader_state_fogcoord; // TODO: fog coordinates (via FogCoordEXT) 00102 t_symbol *ps_jit_gl_shader_state_texcoord; // texture unit 0 coordinates 00103 t_symbol *ps_jit_gl_shader_state_texcoord0; // texture unit 0 coordinates 00104 t_symbol *ps_jit_gl_shader_state_texcoord1; // texture unit 1 coordinates (via MultiTexCoord) 00105 t_symbol *ps_jit_gl_shader_state_texcoord2; // texture unit 2 coordinates (via MultiTexCoord) 00106 t_symbol *ps_jit_gl_shader_state_texcoord3; // texture unit 3 coordinates (via MultiTexCoord) 00107 t_symbol *ps_jit_gl_shader_state_texcoord4; // texture unit 4 coordinates (via MultiTexCoord) 00108 t_symbol *ps_jit_gl_shader_state_texcoord5; // texture unit 5 coordinates (via MultiTexCoord) 00109 t_symbol *ps_jit_gl_shader_state_texcoord6; // texture unit 6 coordinates (via MultiTexCoord) 00110 t_symbol *ps_jit_gl_shader_state_texcoord7; // texture unit 7 coordinates (via MultiTexCoord) 00111 t_symbol *ps_jit_gl_shader_state_texunit0; // texture unit 0 00112 t_symbol *ps_jit_gl_shader_state_texunit1; // texture unit 1 00113 t_symbol *ps_jit_gl_shader_state_texunit2; // texture unit 2 00114 t_symbol *ps_jit_gl_shader_state_texunit3; // texture unit 3 00115 t_symbol *ps_jit_gl_shader_state_texunit4; // texture unit 4 00116 t_symbol *ps_jit_gl_shader_state_texunit5; // texture unit 5 00117 t_symbol *ps_jit_gl_shader_state_texunit6; // texture unit 6 00118 t_symbol *ps_jit_gl_shader_state_texunit7; // texture unit 7 00119 00120 t_symbol *ps_jit_gl_shader_state_camera_position; 00121 t_symbol *ps_jit_gl_shader_state_camera_direction; 00122 00123 t_symbol *ps_jit_gl_shader_state_light_position; 00124 t_symbol *ps_jit_gl_shader_state_light0_position; 00125 t_symbol *ps_jit_gl_shader_state_light1_position; 00126 t_symbol *ps_jit_gl_shader_state_light2_position; 00127 t_symbol *ps_jit_gl_shader_state_light3_position; 00128 t_symbol *ps_jit_gl_shader_state_light4_position; 00129 t_symbol *ps_jit_gl_shader_state_light5_position; 00130 t_symbol *ps_jit_gl_shader_state_light6_position; 00131 t_symbol *ps_jit_gl_shader_state_light7_position; 00132 00133 t_symbol *ps_jit_gl_shader_state_light_direction; 00134 t_symbol *ps_jit_gl_shader_state_light0_direction; 00135 t_symbol *ps_jit_gl_shader_state_light1_direction; 00136 t_symbol *ps_jit_gl_shader_state_light2_direction; 00137 t_symbol *ps_jit_gl_shader_state_light3_direction; 00138 t_symbol *ps_jit_gl_shader_state_light4_direction; 00139 t_symbol *ps_jit_gl_shader_state_light5_direction; 00140 t_symbol *ps_jit_gl_shader_state_light6_direction; 00141 t_symbol *ps_jit_gl_shader_state_light7_direction; 00142 00143 t_symbol *ps_jit_gl_shader_state_light_ambient; 00144 t_symbol *ps_jit_gl_shader_state_light0_ambient; 00145 t_symbol *ps_jit_gl_shader_state_light1_ambient; 00146 t_symbol *ps_jit_gl_shader_state_light2_ambient; 00147 t_symbol *ps_jit_gl_shader_state_light3_ambient; 00148 t_symbol *ps_jit_gl_shader_state_light4_ambient; 00149 t_symbol *ps_jit_gl_shader_state_light5_ambient; 00150 t_symbol *ps_jit_gl_shader_state_light6_ambient; 00151 t_symbol *ps_jit_gl_shader_state_light7_ambient; 00152 00153 t_symbol *ps_jit_gl_shader_state_light_diffuse; 00154 t_symbol *ps_jit_gl_shader_state_light0_diffuse; 00155 t_symbol *ps_jit_gl_shader_state_light1_diffuse; 00156 t_symbol *ps_jit_gl_shader_state_light2_diffuse; 00157 t_symbol *ps_jit_gl_shader_state_light3_diffuse; 00158 t_symbol *ps_jit_gl_shader_state_light4_diffuse; 00159 t_symbol *ps_jit_gl_shader_state_light5_diffuse; 00160 t_symbol *ps_jit_gl_shader_state_light6_diffuse; 00161 t_symbol *ps_jit_gl_shader_state_light7_diffuse; 00162 00163 t_symbol *ps_jit_gl_shader_state_light_specular; 00164 t_symbol *ps_jit_gl_shader_state_light0_specular; 00165 t_symbol *ps_jit_gl_shader_state_light1_specular; 00166 t_symbol *ps_jit_gl_shader_state_light2_specular; 00167 t_symbol *ps_jit_gl_shader_state_light3_specular; 00168 t_symbol *ps_jit_gl_shader_state_light4_specular; 00169 t_symbol *ps_jit_gl_shader_state_light5_specular; 00170 t_symbol *ps_jit_gl_shader_state_light6_specular; 00171 t_symbol *ps_jit_gl_shader_state_light7_specular; 00172 00173 t_symbol *ps_jit_gl_shader_state_light_cutoff; 00174 t_symbol *ps_jit_gl_shader_state_light0_cutoff; 00175 t_symbol *ps_jit_gl_shader_state_light1_cutoff; 00176 t_symbol *ps_jit_gl_shader_state_light2_cutoff; 00177 t_symbol *ps_jit_gl_shader_state_light3_cutoff; 00178 t_symbol *ps_jit_gl_shader_state_light4_cutoff; 00179 t_symbol *ps_jit_gl_shader_state_light5_cutoff; 00180 t_symbol *ps_jit_gl_shader_state_light6_cutoff; 00181 t_symbol *ps_jit_gl_shader_state_light7_cutoff; 00182 00183 t_symbol *ps_jit_gl_shader_state_light_exponent; 00184 t_symbol *ps_jit_gl_shader_state_light0_exponent; 00185 t_symbol *ps_jit_gl_shader_state_light1_exponent; 00186 t_symbol *ps_jit_gl_shader_state_light2_exponent; 00187 t_symbol *ps_jit_gl_shader_state_light3_exponent; 00188 t_symbol *ps_jit_gl_shader_state_light4_exponent; 00189 t_symbol *ps_jit_gl_shader_state_light5_exponent; 00190 t_symbol *ps_jit_gl_shader_state_light6_exponent; 00191 t_symbol *ps_jit_gl_shader_state_light7_exponent; 00192 00193 // gl.texture managed state parameters 00194 t_symbol *ps_jit_gl_shader_state_texdim; // TEXDIM texture unit 0 dimensions 00195 t_symbol *ps_jit_gl_shader_state_texdim0; // TEXDIM0 texture unit 0 dimensions 00196 t_symbol *ps_jit_gl_shader_state_texdim1; // TEXDIM1 texture unit 1 dimensions 00197 t_symbol *ps_jit_gl_shader_state_texdim2; // TEXDIM2 texture unit 2 dimensions 00198 t_symbol *ps_jit_gl_shader_state_texdim3; // TEXDIM3 texture unit 3 dimensions 00199 t_symbol *ps_jit_gl_shader_state_texdim4; // TEXDIM4 texture unit 4 dimensions 00200 t_symbol *ps_jit_gl_shader_state_texdim5; // TEXDIM5 texture unit 5 dimensions 00201 t_symbol *ps_jit_gl_shader_state_texdim6; // TEXDIM6 texture unit 6 dimensions 00202 t_symbol *ps_jit_gl_shader_state_texdim7; // TEXDIM7 texture unit 7 dimensions 00203 00204 // matrix transform methods 00205 t_symbol *ps_jit_gl_shader_transform_identity; // IDENTITY 00206 t_symbol *ps_jit_gl_shader_transform_transpose; // TRANSPOSE 00207 t_symbol *ps_jit_gl_shader_transform_inverse; // INVERSE 00208 t_symbol *ps_jit_gl_shader_transform_inversetranspose; // INVERSE_TRANSPOSE 00209 00210 00211 // compiler settings 00212 t_symbol *ps_jit_gl_shader_compiler_auto; 00213 t_symbol *ps_jit_gl_shader_compiler_native; 00214 t_symbol *ps_jit_gl_shader_compiler_internal; 00215 00216 //for texture finding/binding 00217 t_symbol *ps_jit_gl_shader_name; 00218 t_symbol *ps_jit_gl_shader_glid; 00219 00220 // -------------------------------------------------------------------------------- 00221 00222 t_jit_err jit_gl_shader_init(void) 00223 { 00224 long attrflags=0; 00225 long ob3d_flags=0; 00226 t_jit_object *attr; 00227 void * ob3d; 00228 00229 _jit_gl_shader_class = jit_class_new("jit_gl_shader", (method)jit_gl_shader_new, (method)jit_gl_shader_free, 00230 sizeof(t_jit_gl_shader),A_DEFSYM,0L); 00231 00232 // generate symbols 00233 ps_jit_gl_bind = gensym("bind"); 00234 ps_jit_gl_unbind = gensym("unbind"); 00235 ps_jit_gl_drawto = gensym("drawto"); 00236 00237 ps_jit_gl_mesh = gensym("jit_gl_mesh"); 00238 ps_jit_gl_mesh_get_cache = gensym("get_cache"); 00239 00240 ps_jit_gl_shader_texture = gensym("texture"); 00241 ps_jit_gl_texture_width = gensym("width"); 00242 ps_jit_gl_texture_height = gensym("height"); 00243 ps_jit_gl_texture_depth = gensym("depth"); 00244 00245 ps_jit_gl_shader_language_auto = gensym("auto"); 00246 ps_jit_gl_shader_language_glsl = gensym("glsl"); 00247 ps_jit_gl_shader_language_arb = gensym("arb"); 00248 ps_jit_gl_shader_language_nv = gensym("nv"); 00249 ps_jit_gl_shader_language_cg = gensym("cg"); 00250 ps_jit_gl_shader_backend_glsl = gensym("glsl"); 00251 ps_jit_gl_shader_backend_asm = gensym("asm"); 00252 ps_jit_gl_shader_backend_cg = gensym("cg"); 00253 ps_jit_gl_shader_count = gensym("count"); 00254 ps_jit_gl_shader_state = gensym("state"); 00255 ps_jit_gl_shader_transform = gensym("transform"); 00256 ps_jit_gl_shader_bind = gensym("bind"); 00257 ps_jit_gl_shader_target = gensym("target"); 00258 ps_jit_gl_shader_program = gensym("program"); 00259 ps_jit_gl_shader_profile = gensym("profile"); 00260 ps_jit_gl_shader_entry = gensym("entry"); 00261 ps_jit_gl_shader_param = gensym("param"); 00262 ps_jit_gl_shader_language = gensym("language"); 00263 ps_jit_gl_shader_version = gensym("version"); 00264 ps_jit_gl_shader_source = gensym("source"); 00265 ps_jit_gl_shader_assembly = gensym("assembly"); 00266 ps_jit_gl_shader_params = gensym("params"); 00267 ps_jit_gl_shader_object = gensym("object"); 00268 ps_jit_gl_shader_all = gensym("all"); 00269 ps_jit_gl_shader_user = gensym("user"); 00270 ps_jit_gl_shader_getparamval = gensym("getparamval"); 00271 ps_jit_gl_shader_getparamdefault = gensym("getparamdefault"); 00272 ps_jit_gl_shader_getparamtype = gensym("getparamtype"); 00273 00274 ps_jit_gl_shader_state_modelview_matrix = gensym("MODELVIEW_MATRIX"); 00275 ps_jit_gl_shader_state_projection_matrix = gensym("PROJECTION_MATRIX"); 00276 ps_jit_gl_shader_state_modelview_projection_matrix = gensym("MODELVIEW_PROJECTION_MATRIX"); 00277 ps_jit_gl_shader_state_normal_matrix = gensym("NORMAL_MATRIX"); 00278 ps_jit_gl_shader_state_texture_matrix = gensym("TEXTURE_MATRIX"); 00279 ps_jit_gl_shader_state_texture0_matrix = gensym("TEXTURE0_MATRIX"); 00280 ps_jit_gl_shader_state_texture1_matrix = gensym("TEXTURE1_MATRIX"); 00281 ps_jit_gl_shader_state_texture2_matrix = gensym("TEXTURE2_MATRIX"); 00282 ps_jit_gl_shader_state_texture3_matrix = gensym("TEXTURE3_MATRIX"); 00283 ps_jit_gl_shader_state_texture4_matrix = gensym("TEXTURE4_MATRIX"); 00284 ps_jit_gl_shader_state_texture5_matrix = gensym("TEXTURE5_MATRIX"); 00285 ps_jit_gl_shader_state_texture6_matrix = gensym("TEXTURE6_MATRIX"); 00286 ps_jit_gl_shader_state_texture7_matrix = gensym("TEXTURE7_MATRIX"); 00287 00288 ps_jit_gl_shader_state_position = gensym("POSITION"); 00289 ps_jit_gl_shader_state_normal = gensym("NORMAL"); 00290 ps_jit_gl_shader_state_tangent = gensym("TANGENT"); 00291 ps_jit_gl_shader_state_bitangent = gensym("BITANGENT"); 00292 ps_jit_gl_shader_state_vertex_attr = gensym("VERTEX_ATTR"); 00293 ps_jit_gl_shader_state_edgeflag = gensym("EDGEFLAG"); 00294 ps_jit_gl_shader_state_blendweight = gensym("BLENDWEIGHT"); 00295 ps_jit_gl_shader_state_color0 = gensym("COLOR0"); 00296 ps_jit_gl_shader_state_color1 = gensym("COLOR1"); 00297 ps_jit_gl_shader_state_ambient = gensym("AMBIENT"); 00298 ps_jit_gl_shader_state_diffuse = gensym("DIFFUSE"); 00299 ps_jit_gl_shader_state_specular = gensym("SPECULAR"); 00300 ps_jit_gl_shader_state_emission = gensym("EMISSION"); 00301 ps_jit_gl_shader_state_fogcoord = gensym("FOGCOORD"); 00302 ps_jit_gl_shader_state_texcoord = gensym("TEXCOORD"); 00303 ps_jit_gl_shader_state_texcoord0 = gensym("TEXCOORD0"); 00304 ps_jit_gl_shader_state_texcoord1 = gensym("TEXCOORD1"); 00305 ps_jit_gl_shader_state_texcoord2 = gensym("TEXCOORD2"); 00306 ps_jit_gl_shader_state_texcoord3 = gensym("TEXCOORD3"); 00307 ps_jit_gl_shader_state_texcoord4 = gensym("TEXCOORD4"); 00308 ps_jit_gl_shader_state_texcoord5 = gensym("TEXCOORD5"); 00309 ps_jit_gl_shader_state_texcoord6 = gensym("TEXCOORD6"); 00310 ps_jit_gl_shader_state_texcoord7 = gensym("TEXCOORD7"); 00311 ps_jit_gl_shader_state_texunit0 = gensym("TEXUNIT0"); 00312 ps_jit_gl_shader_state_texunit1 = gensym("TEXUNIT1"); 00313 ps_jit_gl_shader_state_texunit2 = gensym("TEXUNIT2"); 00314 ps_jit_gl_shader_state_texunit3 = gensym("TEXUNIT3"); 00315 ps_jit_gl_shader_state_texunit4 = gensym("TEXUNIT4"); 00316 ps_jit_gl_shader_state_texunit5 = gensym("TEXUNIT5"); 00317 ps_jit_gl_shader_state_texunit6 = gensym("TEXUNIT6"); 00318 ps_jit_gl_shader_state_texunit7 = gensym("TEXUNIT7"); 00319 00320 ps_jit_gl_shader_state_camera_position = gensym("CAMERA_POSITION"); 00321 ps_jit_gl_shader_state_camera_direction = gensym("CAMERA_DIRECTION"); 00322 00323 ps_jit_gl_shader_state_light_position = gensym("LIGHT_POSITION"); 00324 ps_jit_gl_shader_state_light0_position = gensym("LIGHT0_POSITION"); 00325 ps_jit_gl_shader_state_light1_position = gensym("LIGHT1_POSITION"); 00326 ps_jit_gl_shader_state_light2_position = gensym("LIGHT2_POSITION"); 00327 ps_jit_gl_shader_state_light3_position = gensym("LIGHT3_POSITION"); 00328 ps_jit_gl_shader_state_light4_position = gensym("LIGHT4_POSITION"); 00329 ps_jit_gl_shader_state_light5_position = gensym("LIGHT5_POSITION"); 00330 ps_jit_gl_shader_state_light6_position = gensym("LIGHT6_POSITION"); 00331 ps_jit_gl_shader_state_light7_position = gensym("LIGHT7_POSITION"); 00332 00333 ps_jit_gl_shader_state_light_direction = gensym("LIGHT_DIRECTION"); 00334 ps_jit_gl_shader_state_light0_direction = gensym("LIGHT0_DIRECTION"); 00335 ps_jit_gl_shader_state_light1_direction = gensym("LIGHT1_DIRECTION"); 00336 ps_jit_gl_shader_state_light2_direction = gensym("LIGHT2_DIRECTION"); 00337 ps_jit_gl_shader_state_light3_direction = gensym("LIGHT3_DIRECTION"); 00338 ps_jit_gl_shader_state_light4_direction = gensym("LIGHT4_DIRECTION"); 00339 ps_jit_gl_shader_state_light5_direction = gensym("LIGHT5_DIRECTION"); 00340 ps_jit_gl_shader_state_light6_direction = gensym("LIGHT6_DIRECTION"); 00341 ps_jit_gl_shader_state_light7_direction = gensym("LIGHT7_DIRECTION"); 00342 00343 ps_jit_gl_shader_state_light_ambient = gensym("LIGHT_AMBIENT"); 00344 ps_jit_gl_shader_state_light0_ambient = gensym("LIGHT0_AMBIENT"); 00345 ps_jit_gl_shader_state_light1_ambient = gensym("LIGHT1_AMBIENT"); 00346 ps_jit_gl_shader_state_light2_ambient = gensym("LIGHT2_AMBIENT"); 00347 ps_jit_gl_shader_state_light3_ambient = gensym("LIGHT3_AMBIENT"); 00348 ps_jit_gl_shader_state_light4_ambient = gensym("LIGHT4_AMBIENT"); 00349 ps_jit_gl_shader_state_light5_ambient = gensym("LIGHT5_AMBIENT"); 00350 ps_jit_gl_shader_state_light6_ambient = gensym("LIGHT6_AMBIENT"); 00351 ps_jit_gl_shader_state_light7_ambient = gensym("LIGHT7_AMBIENT"); 00352 00353 ps_jit_gl_shader_state_light_diffuse = gensym("LIGHT_DIFFUSE"); 00354 ps_jit_gl_shader_state_light0_diffuse = gensym("LIGHT0_DIFFUSE"); 00355 ps_jit_gl_shader_state_light1_diffuse = gensym("LIGHT1_DIFFUSE"); 00356 ps_jit_gl_shader_state_light2_diffuse = gensym("LIGHT2_DIFFUSE"); 00357 ps_jit_gl_shader_state_light3_diffuse = gensym("LIGHT3_DIFFUSE"); 00358 ps_jit_gl_shader_state_light4_diffuse = gensym("LIGHT4_DIFFUSE"); 00359 ps_jit_gl_shader_state_light5_diffuse = gensym("LIGHT5_DIFFUSE"); 00360 ps_jit_gl_shader_state_light6_diffuse = gensym("LIGHT6_DIFFUSE"); 00361 ps_jit_gl_shader_state_light7_diffuse = gensym("LIGHT7_DIFFUSE"); 00362 00363 ps_jit_gl_shader_state_light_specular = gensym("LIGHT_SPECULAR"); 00364 ps_jit_gl_shader_state_light0_specular = gensym("LIGHT0_SPECULAR"); 00365 ps_jit_gl_shader_state_light1_specular = gensym("LIGHT1_SPECULAR"); 00366 ps_jit_gl_shader_state_light2_specular = gensym("LIGHT2_SPECULAR"); 00367 ps_jit_gl_shader_state_light3_specular = gensym("LIGHT3_SPECULAR"); 00368 ps_jit_gl_shader_state_light4_specular = gensym("LIGHT4_SPECULAR"); 00369 ps_jit_gl_shader_state_light5_specular = gensym("LIGHT5_SPECULAR"); 00370 ps_jit_gl_shader_state_light6_specular = gensym("LIGHT6_SPECULAR"); 00371 ps_jit_gl_shader_state_light7_specular = gensym("LIGHT7_SPECULAR"); 00372 00373 ps_jit_gl_shader_state_light_cutoff = gensym("LIGHT_CUTOFF"); 00374 ps_jit_gl_shader_state_light0_cutoff = gensym("LIGHT0_CUTOFF"); 00375 ps_jit_gl_shader_state_light1_cutoff = gensym("LIGHT1_CUTOFF"); 00376 ps_jit_gl_shader_state_light2_cutoff = gensym("LIGHT2_CUTOFF"); 00377 ps_jit_gl_shader_state_light3_cutoff = gensym("LIGHT3_CUTOFF"); 00378 ps_jit_gl_shader_state_light4_cutoff = gensym("LIGHT4_CUTOFF"); 00379 ps_jit_gl_shader_state_light5_cutoff = gensym("LIGHT5_CUTOFF"); 00380 ps_jit_gl_shader_state_light6_cutoff = gensym("LIGHT6_CUTOFF"); 00381 ps_jit_gl_shader_state_light7_cutoff = gensym("LIGHT7_CUTOFF"); 00382 00383 ps_jit_gl_shader_state_light_exponent = gensym("LIGHT_EXPONENT"); 00384 ps_jit_gl_shader_state_light0_exponent = gensym("LIGHT0_EXPONENT"); 00385 ps_jit_gl_shader_state_light1_exponent = gensym("LIGHT1_EXPONENT"); 00386 ps_jit_gl_shader_state_light2_exponent = gensym("LIGHT2_EXPONENT"); 00387 ps_jit_gl_shader_state_light3_exponent = gensym("LIGHT3_EXPONENT"); 00388 ps_jit_gl_shader_state_light4_exponent = gensym("LIGHT4_EXPONENT"); 00389 ps_jit_gl_shader_state_light5_exponent = gensym("LIGHT5_EXPONENT"); 00390 ps_jit_gl_shader_state_light6_exponent = gensym("LIGHT6_EXPONENT"); 00391 ps_jit_gl_shader_state_light7_exponent = gensym("LIGHT7_EXPONENT"); 00392 00393 ps_jit_gl_shader_state_texdim = gensym("TEXDIM"); 00394 ps_jit_gl_shader_state_texdim0 = gensym("TEXDIM0"); 00395 ps_jit_gl_shader_state_texdim1 = gensym("TEXDIM1"); 00396 ps_jit_gl_shader_state_texdim2 = gensym("TEXDIM2"); 00397 ps_jit_gl_shader_state_texdim3 = gensym("TEXDIM3"); 00398 ps_jit_gl_shader_state_texdim4 = gensym("TEXDIM4"); 00399 ps_jit_gl_shader_state_texdim5 = gensym("TEXDIM5"); 00400 ps_jit_gl_shader_state_texdim6 = gensym("TEXDIM6"); 00401 ps_jit_gl_shader_state_texdim7 = gensym("TEXDIM7"); 00402 00403 ps_jit_gl_shader_transform_identity = gensym("IDENTITY"); 00404 ps_jit_gl_shader_transform_transpose = gensym("TRANSPOSE"); 00405 ps_jit_gl_shader_transform_inverse = gensym("INVERSE"); 00406 ps_jit_gl_shader_transform_inversetranspose = gensym("INVERSE_TRANSPOSE"); 00407 00408 ps_jit_gl_shader_compiler_auto = gensym("auto"); 00409 ps_jit_gl_shader_compiler_native = gensym("native"); 00410 ps_jit_gl_shader_compiler_internal = gensym("internal"); 00411 00412 ps_atomarray = gensym("atomarray"); 00413 ps_nobox = gensym("nobox"); 00414 ps_jit_gl_texture = gensym("jit_gl_texture"); 00415 00416 ps_jit_gl_shader_name = gensym("name"); 00417 ps_jit_gl_shader_glid = gensym("glid"); 00418 00419 00420 // set up object extension for 3d object, customized with flags 00421 ob3d_flags |= JIT_OB3D_NO_ROTATION_SCALE; 00422 ob3d_flags |= JIT_OB3D_NO_POLY_VARS; 00423 ob3d_flags |= JIT_OB3D_NO_BLEND; 00424 ob3d_flags |= JIT_OB3D_NO_TEXTURE; 00425 ob3d_flags |= JIT_OB3D_NO_DEPTH; 00426 ob3d_flags |= JIT_OB3D_NO_ANTIALIAS; 00427 ob3d_flags |= JIT_OB3D_NO_FOG; 00428 ob3d_flags |= JIT_OB3D_NO_LIGHTING_MATERIAL; 00429 ob3d_flags |= JIT_OB3D_NO_COLOR; 00430 ob3d = jit_ob3d_setup(_jit_gl_shader_class, calcoffset(t_jit_gl_shader, ob3d), ob3d_flags); 00431 00432 // add attributes 00433 attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW; 00434 00435 // shader 00436 attr = jit_object_new(_jit_sym_jit_attr_offset,"shader",_jit_sym_symbol,attrflags, 00437 (method)0L,(method)jit_gl_shader_setattr_shader,calcoffset(t_jit_gl_shader, shader)); 00438 jit_class_addattr(_jit_gl_shader_class,attr); 00439 attr = jit_object_new(_jit_sym_jit_attr_offset,"file",_jit_sym_symbol,attrflags, 00440 (method)0L,(method)jit_gl_shader_setattr_file,calcoffset(t_jit_gl_shader, filename)); 00441 jit_class_addattr(_jit_gl_shader_class,attr); 00442 00443 // language preference access 00444 attr = jit_object_new(_jit_sym_jit_attr_offset,"prefer",_jit_sym_symbol,attrflags, 00445 (method)0L,(method)jit_gl_shader_setattr_prefer,calcoffset(t_jit_gl_shader, prefer)); 00446 jit_class_addattr(_jit_gl_shader_class,attr); 00447 attr = jit_object_new(_jit_sym_jit_attr_offset,"compiler",_jit_sym_symbol,attrflags, 00448 (method)0L,(method)jit_gl_shader_setattr_compiler,calcoffset(t_jit_gl_shader, compiler)); 00449 jit_class_addattr(_jit_gl_shader_class,attr); 00450 00451 // verbose output 00452 attr = jit_object_new(_jit_sym_jit_attr_offset,"verbose",_jit_sym_long,attrflags, 00453 (method)0L,(method)0L,calcoffset(t_jit_gl_shader, verbose)); 00454 jit_class_addattr(_jit_gl_shader_class,attr); 00455 00456 // state flag access 00457 attrflags = JIT_ATTR_GET_OPAQUE_USER | JIT_ATTR_SET_OPAQUE_USER; 00458 attr = jit_object_new(_jit_sym_jit_attr_offset,"stateflags",_jit_sym_long,attrflags, 00459 (method)0L,(method)0L,calcoffset(t_jit_gl_shader, stateflags)); 00460 jit_class_addattr(_jit_gl_shader_class,attr); 00461 00462 // set parameter values (also allow as attr argument) 00463 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_setparam, "param", A_DEFER_LOW, 0L); 00464 jit_class_method_addargsafe(_jit_gl_shader_class, "param", "param"); 00465 00466 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_setprogram_param, "program_param", A_DEFER_LOW, 0L); 00467 jit_class_method_addargsafe(_jit_gl_shader_class, "program_param", "program_param"); 00468 00469 // dump shader info 00470 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_dump, "dump", A_DEFER_LOW, 0L); 00471 00472 // read xml format shader 00473 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_read_jxs, "read", A_DEFER_LOW, 0L); 00474 00475 // clear shader cache 00476 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_flush_cache, "flush_cache", A_DEFER_LOW, 0L); 00477 00478 // dispose and unload current shader 00479 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_dispose, "dispose", A_DEFER_LOW, 0L); 00480 00481 // helper functions for loading specific language & program types 00482 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_asm, "arb", A_DEFER_LOW, 0L); 00483 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_asmvp_from_file, "arbvp", A_DEFER_LOW, 0L); 00484 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_asmfp_from_file, "arbfp", A_DEFER_LOW, 0L); 00485 00486 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_glsl, "glsl", A_DEFER_LOW, 0L); 00487 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_glslvp_from_file, "glslvp", A_DEFER_LOW, 0L); 00488 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_glslfp_from_file, "glslfp", A_DEFER_LOW, 0L); 00489 00490 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_cg, "cg", A_DEFER_LOW, 0L); 00491 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_cgvp_from_file, "cgvp", A_DEFER_LOW, 0L); 00492 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_load_cgfp_from_file, "cgfp", A_DEFER_LOW, 0L); 00493 00494 // methods to bind/unbind our shaders. 00495 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_bind, "bind", A_DEFER_LOW, 0L); 00496 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_unbind, "unbind", A_DEFER_LOW, 0L); 00497 00498 // compile / link / assemble shader 00499 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_compile, "compile", 0L); 00500 00501 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_getparamlist, "getparamlist", A_GIMMEBACK, 0L); 00502 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_getparam_method, "getparamtype", A_GIMMEBACK, 0L); 00503 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_getparam_method, "getparamval", A_GIMMEBACK, 0L); 00504 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_getparam_method, "getparamdefault", A_GIMMEBACK, 0L); 00505 00506 00507 // handle draw method. called in automatic mode by jit.gl.render, or otherwise through ob3d when banged. 00508 // this is A_CANT because draw setup needs to happen in the ob3d beforehand. 00509 // this object doesn't do anything in it's draw method. we are just exploiting the ob3d 00510 // implementation for 00511 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_draw, "ob3d_draw", A_CANT, 0L); 00512 00513 // handle dest_changed method. 00514 // this method is called by jit.render when the destination context changes: for example, 00515 // when the user moves the window from one monitor to another. Anything your object keeps 00516 // in the OpenGL machine -- textures, display lists, vertex shaders, etc. -- will need to 00517 // be rebuilt here. 00518 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_dest_changed, "dest_changed", A_CANT, 0L); 00519 00520 // must register for ob3d 00521 jit_class_addmethod(_jit_gl_shader_class, (method)jit_object_register, "register", A_CANT, 0L); 00522 jit_class_addmethod(_jit_gl_shader_class, (method)jit_gl_shader_dest_closing, "dest_closing", A_CANT, 0L); 00523 jit_class_register(_jit_gl_shader_class); 00524 00525 // init shader program & param objs 00526 jit_gl_shader_program_init(); 00527 jit_gl_shader_param_init(); 00528 00529 // init shader cache 00530 jit_gl_shader_cache_init(); 00531 00532 #ifndef WIN_VERSION 00533 // init mac osx cfm wrapper interface 00534 jit_gl_shader_framework_init_cg(); 00535 #endif 00536 00537 return JIT_ERR_NONE; 00538 } 00539 00540 t_jit_gl_shader *jit_gl_shader_new(t_symbol * dest_name) 00541 { 00542 t_jit_gl_shader *x; 00543 long i, j; 00544 00545 // make jit object 00546 if (x = (t_jit_gl_shader *)jit_object_alloc(_jit_gl_shader_class)) 00547 { 00548 // create and attach ob3d 00549 jit_ob3d_new(x, dest_name); 00550 00551 // set instance variable defaults 00552 x->bound = NULL; 00553 x->shader = _jit_sym_nothing; 00554 x->filename = _jit_sym_nothing; 00555 x->language = _jit_sym_nothing; 00556 x->backend = _jit_sym_nothing; 00557 x->prefer = ps_jit_gl_shader_language_auto; 00558 x->compiler = ps_jit_gl_shader_compiler_auto; 00559 x->changed = TRUE; 00560 x->context = NULL; 00561 x->handle = NULL; 00562 x->pending = FALSE; 00563 x->stateflags = 0; 00564 x->verbose = FALSE; 00565 x->runtime = NULL; 00566 x->loadparamcount = 0; 00567 x->id = JIT_GL_SHADER_INVALID; 00568 00569 for(i = 0; i < 256; i++) 00570 { 00571 x->loadparam[i] = NULL; 00572 } 00573 x->loadparamcount = 0; 00574 00575 for(i = 0; i < JIT_MAX_PROGAM_PARAMS; i++) 00576 { 00577 x->loadprogramparam[i] = NULL; 00578 } 00579 x->loadprogramparamcount = 0; 00580 00581 for(i = 0; i < JIT_GL_MAX_TEXTUREUNITS; i++) 00582 { 00583 x->texture[i] = NULL; 00584 x->texturemanage[i] = FALSE; 00585 } 00586 x->texturecount = 0; 00587 00588 x->shaderxml = jit_object_new(gensym("jit_xml_document")); 00589 x->timestamp = 0; 00590 00591 // set program defaults 00592 x->program[0] = jit_gl_shader_program_new(dest_name); 00593 x->program[1] = jit_gl_shader_program_new(dest_name); 00594 x->program[2] = jit_gl_shader_program_new(dest_name); 00595 x->programcount = JIT_GL_SHADER_PROGRAM_TYPES; 00596 for(i = 0; i < x->programcount; i++) 00597 { 00598 jit_gl_shader_program_reset(x->program[i]); 00599 } 00600 00601 jit_attr_setlong(x,gensym("automatic"),0); 00602 jit_attr_setlong(x,gensym("layer"),-999999); 00603 } 00604 else 00605 { 00606 x = NULL; 00607 } 00608 return x; 00609 } 00610 00611 void jit_gl_shader_free(t_jit_gl_shader *x) 00612 { 00613 long i; 00614 t_jit_err error; 00615 00616 jit_ob3d_set_context(x); 00617 jit_gl_shader_destroy(x); 00618 00619 // free the shader xml description 00620 if (x->shaderxml) 00621 jit_object_free(x->shaderxml); 00622 00623 // free all allocated programs 00624 for(i = 0; i < x->programcount; i++) 00625 { 00626 if (x->program[i]) 00627 jit_object_free(x->program[i]); 00628 } 00629 00630 // free all cached load params 00631 for(i = 0; i < 256; i++) 00632 { 00633 if(x->loadparam[i]) 00634 jit_object_free(x->loadparam[i]); 00635 x->loadparam[i] = NULL; 00636 } 00637 x->loadparamcount = 0; 00638 00639 // free all cached load program params 00640 for(i = 0; i < JIT_MAX_PROGAM_PARAMS; i++) 00641 { 00642 if(x->loadprogramparam[i]) 00643 jit_object_free(x->loadprogramparam[i]); 00644 x->loadprogramparam[i] = NULL; 00645 } 00646 x->loadprogramparamcount = 0; 00647 00648 jit_ob3d_free(x); 00649 } 00650 00651 t_jit_err jit_gl_shader_flush_cache(t_jit_gl_shader *x) 00652 { 00653 return jit_gl_shader_cache_flush(); 00654 } 00655 00656 // -------------------------------------------------------------------------------- 00657 00658 t_jit_err jit_gl_shader_setattr_file(t_jit_gl_shader *x, void *attr, long argc, t_atom *argv) 00659 { 00660 t_symbol *val; 00661 t_atom a; 00662 if (argc&&argv) 00663 { 00664 val = jit_atom_getsym(argv); 00665 if(JIT_SYM_IF(val)) 00666 { 00667 x->filename = val; 00668 jit_atom_setsym(&a, x->filename); 00669 jit_gl_shader_read_jxs(x, x->filename, 1, &a); 00670 } 00671 } 00672 return JIT_ERR_NONE; 00673 } 00674 00675 t_jit_err jit_gl_shader_setattr_shader(t_jit_gl_shader *x, void *attr, long argc, t_atom *argv) 00676 { 00677 if (argc&&argv) 00678 { 00679 x->shader = jit_atom_getsym(argv); 00680 //change it... 00681 } 00682 00683 return JIT_ERR_NONE; 00684 } 00685 00686 t_jit_err jit_gl_shader_setattr_prefer(t_jit_gl_shader *x, void *attr, long argc, t_atom *argv) 00687 { 00688 t_symbol *val; 00689 t_atom a; 00690 if (argc&&argv) { 00691 val = jit_atom_getsym(argv); 00692 if(x->prefer != val) 00693 { 00694 x->prefer = val; 00695 00696 if(x->filename) 00697 { 00698 jit_atom_setsym(&a, x->filename); 00699 jit_gl_shader_read_jxs(x, x->filename, 1, &a); 00700 } 00701 } 00702 } 00703 return JIT_ERR_NONE; 00704 } 00705 00706 t_jit_err jit_gl_shader_setattr_compiler(t_jit_gl_shader *x, void *attr, long argc, t_atom *argv) 00707 { 00708 t_symbol *val; 00709 t_atom a; 00710 if (argc&&argv) 00711 { 00712 val = jit_atom_getsym(argv); 00713 if(x->compiler != val) 00714 { 00715 x->compiler = val; 00716 00717 if(x->filename) 00718 { 00719 jit_atom_setsym(&a, x->filename); 00720 jit_gl_shader_read_jxs(x, x->filename, 1, &a); 00721 } 00722 } 00723 } 00724 return JIT_ERR_NONE; 00725 } 00726 00727 t_jit_err jit_gl_shader_dest_closing(t_jit_gl_shader *x) 00728 { 00729 long i; 00730 t_jit_err error; 00731 00732 error = jit_ob3d_set_context(x); 00733 if(error) return error; 00734 00735 error = jit_gl_shader_disable(x); 00736 if(error) return error; 00737 00738 // toggle changed flag for new context 00739 x->changed = TRUE; 00740 00741 return error; 00742 } 00743 00744 t_jit_err jit_gl_shader_draw(t_jit_gl_shader *x) 00745 { 00746 t_atom s; 00747 t_jit_err err = JIT_ERR_NONE; 00748 00749 // dummy, does nothing 00750 return err; 00751 } 00752 00753 t_jit_err jit_gl_shader_dest_changed(t_jit_gl_shader *x) 00754 { 00755 t_atom s; 00756 t_jit_err error; 00757 00758 if(x->pending) 00759 { 00760 jit_atom_setsym(&s, x->filename); 00761 error = jit_gl_shader_read_jxs(x, NULL, 1, &s); 00762 if(error) return error; 00763 } 00764 00765 // toggle changed flag for new context 00766 x->changed = TRUE; 00767 jit_gl_shader_link(x); 00768 00769 return JIT_ERR_NONE; 00770 } 00771 00772 t_jit_gl_shader_program *jit_gl_shader_get_program_by_type(t_jit_gl_shader *x, t_symbol *type) 00773 { 00774 00775 // get the indicated program based on its type symbol 00776 t_jit_gl_shader_program *program; 00777 00778 if(type == ps_jit_gl_shader_program_type_vp) 00779 { 00780 program = x->program[JIT_GL_SHADER_PROGRAM_VERTEX_INDEX]; 00781 } 00782 else if(type == ps_jit_gl_shader_program_type_vertex) 00783 { 00784 program = x->program[JIT_GL_SHADER_PROGRAM_VERTEX_INDEX]; 00785 } 00786 else if(type == ps_jit_gl_shader_program_type_fp) 00787 { 00788 program = x->program[JIT_GL_SHADER_PROGRAM_FRAGMENT_INDEX]; 00789 } 00790 else if(type == ps_jit_gl_shader_program_type_fragment) 00791 { 00792 program = x->program[JIT_GL_SHADER_PROGRAM_FRAGMENT_INDEX]; 00793 } 00794 else if(type == ps_jit_gl_shader_program_type_ps) 00795 { 00796 program = x->program[JIT_GL_SHADER_PROGRAM_FRAGMENT_INDEX]; 00797 } 00798 else if(type == ps_jit_gl_shader_program_type_pixel) 00799 { 00800 program = x->program[JIT_GL_SHADER_PROGRAM_FRAGMENT_INDEX]; 00801 } 00802 else if(type == ps_jit_gl_shader_program_type_gp) 00803 { 00804 program = x->program[JIT_GL_SHADER_PROGRAM_GEOMETRY_INDEX]; 00805 } 00806 else if(type == ps_jit_gl_shader_program_type_geometry) 00807 { 00808 program = x->program[JIT_GL_SHADER_PROGRAM_GEOMETRY_INDEX]; 00809 } 00810 else 00811 { 00812 program = NULL; 00813 jit_object_error((t_object *)x,"jit.gl.shader: unkown shader program type %s", type->s_name); 00814 } 00815 00816 00817 // return the appropriate program 00818 return program; 00819 } 00820 00821 t_jit_gl_shader_program *jit_gl_shader_get_program_by_name(t_jit_gl_shader *x, t_symbol *name) 00822 { 00823 long i; 00824 t_jit_gl_shader_program *program=NULL; 00825 00826 if (name && (name != _jit_sym_nothing ) ) 00827 { 00828 for (i = 0; i < x->programcount; i++) 00829 { 00830 if (name == x->program[i]->name) 00831 return x->program[i]; 00832 } 00833 } 00834 return NULL; 00835 } 00836 00837 t_jit_gl_shader_program *jit_gl_shader_get_program_by_profile(t_jit_gl_shader *x, t_symbol *profile) 00838 { 00839 long i; 00840 t_jit_gl_shader_program *program=NULL; 00841 00842 if (profile && (profile != _jit_sym_nothing ) ) 00843 { 00844 for (i = 0; i < x->programcount; i++) 00845 { 00846 if (profile == x->program[i]->profile) 00847 return x->program[i]; 00848 } 00849 } 00850 return NULL; 00851 } 00852 00853 t_jit_gl_shader_program *jit_gl_shader_get_program_by_filename(t_jit_gl_shader *x, t_symbol *filename) 00854 { 00855 long i; 00856 t_jit_gl_shader_program *program=NULL; 00857 00858 if (filename && (filename != _jit_sym_nothing ) ) 00859 { 00860 for (i = 0; i < x->programcount; i++) 00861 { 00862 if (filename == x->program[i]->filename) 00863 return x->program[i]; 00864 } 00865 } 00866 return NULL; 00867 } 00868 00869 t_jit_err jit_gl_shader_load_program( 00870 t_jit_gl_shader *x, t_symbol *lang, t_symbol *name, 00871 t_symbol *filename, t_symbol *type, long precompiled, 00872 const char *source, long length, t_symbol *profile, t_symbol *entry) 00873 { 00874 t_atom af; 00875 char *temp = NULL; 00876 long bytes = 0; 00877 t_jit_gl_shader_program *program = NULL; 00878 00879 t_jit_err err = JIT_ERR_NONE; 00880 long vp = (type == ps_jit_gl_shader_program_type_vertex || 00881 type == ps_jit_gl_shader_program_type_vp ) ? TRUE : FALSE; 00882 00883 long gp = (type == ps_jit_gl_shader_program_type_geometry || 00884 type == ps_jit_gl_shader_program_type_gp ) ? TRUE : FALSE; 00885 00886 if(filename && filename != _jit_sym_nothing) 00887 jit_atom_setsym(&af,filename); 00888 00889 00890 // attempt to load programs for given language 00891 if (lang == ps_jit_gl_shader_language_arb) 00892 { 00893 if(x->verbose) 00894 jit_object_post((t_object *)x,"jit.gl.shader: attempting to load ARB implementation."); 00895 00896 err = jit_gl_shader_verify_asm_arb(x); 00897 if(!err) 00898 { 00899 if(filename && filename != _jit_sym_nothing) 00900 { 00901 if(vp) { 00902 err = jit_gl_shader_load_asmvp_from_file(x, NULL, 1, &af); 00903 } 00904 else if(gp) { 00905 //not implemented yet 00906 } 00907 else { 00908 err = jit_gl_shader_load_asmfp_from_file(x, NULL, 1, &af); 00909 } 00910 } 00911 else if(source && length) 00912 { 00913 if(vp) { 00914 err = jit_gl_shader_load_asmvp_from_mem(x, source, length); 00915 } 00916 else if(gp) { 00917 //not implemented yet 00918 } 00919 else { 00920 err = jit_gl_shader_load_asmfp_from_mem(x, source, length); 00921 } 00922 } 00923 } 00924 } 00925 else if (lang == ps_jit_gl_shader_language_nv) 00926 { 00927 if(x->verbose) 00928 jit_object_post((t_object *)x,"jit.gl.shader: attempting to load NV implementation."); 00929 00930 err = jit_gl_shader_verify_asm_nv(x); 00931 if(!err) 00932 { 00933 if(filename && filename != _jit_sym_nothing) 00934 { 00935 if(vp) { 00936 err = jit_gl_shader_load_asmvp_from_file(x, NULL, 1, &af); 00937 } 00938 else if(gp) { 00939 //not implemented yet 00940 } 00941 else { 00942 err = jit_gl_shader_load_asmfp_from_file(x, NULL, 1, &af); 00943 } 00944 } 00945 else if(source && length) 00946 { 00947 if(vp) { 00948 err = jit_gl_shader_load_asmvp_from_mem(x, source, length); 00949 } 00950 else if(gp) { 00951 //not implemented yet 00952 } 00953 else { 00954 err = jit_gl_shader_load_asmfp_from_mem(x, source, length); 00955 } 00956 } 00957 } 00958 } 00959 else if (lang == ps_jit_gl_shader_language_glsl) 00960 { 00961 if(x->verbose) 00962 jit_object_post((t_object *)x,"jit.gl.shader: attempting to load GLSL implementation."); 00963 00964 // attempt to load glsl programs via native compiler 00965 if( x->compiler == ps_jit_gl_shader_compiler_auto || 00966 x->compiler == ps_jit_gl_shader_compiler_native) 00967 { 00968 err = jit_gl_shader_verify_glsl(x); 00969 if(!err) 00970 { 00971 if(filename && filename != _jit_sym_nothing) 00972 { 00973 if(vp) { 00974 err = jit_gl_shader_load_glslvp_from_file(x, NULL, 1, &af); 00975 } 00976 else if(gp) { 00977 //not implemented yet 00978 } 00979 else { 00980 err = jit_gl_shader_load_glslfp_from_file(x, NULL, 1, &af); 00981 } 00982 } 00983 else if(source && length) 00984 { 00985 if(vp) { 00986 err = jit_gl_shader_load_glslvp_from_mem(x, source, length); 00987 } 00988 else if(gp) { 00989 err = jit_gl_shader_load_glslgp_from_mem(x, source, length); 00990 } 00991 else { 00992 err = jit_gl_shader_load_glslfp_from_mem(x, source, length); 00993 } 00994 } 00995 } 00996 } 00997 00998 // attempt to load glsl programs via internal cg compiler 00999 if(err || x->compiler == ps_jit_gl_shader_compiler_internal) 01000 { 01001 if(x->verbose) 01002 jit_object_post((t_object *)x,"jit.gl.shader: attempting to load GLSL implementation via CG."); 01003 01004 err = jit_gl_shader_verify_cg(x); 01005 if(!err) 01006 { 01007 if(filename && filename != _jit_sym_nothing) 01008 { 01009 if(vp) { 01010 err = jit_gl_shader_load_glslvp_with_cg_from_file(x, NULL, 1, &af); 01011 } 01012 else if(gp) { 01013 err = jit_gl_shader_load_glslgp_with_cg_from_file(x, NULL, 1, &af); 01014 } 01015 else { 01016 err = jit_gl_shader_load_glslfp_with_cg_from_file(x, NULL, 1, &af); 01017 } 01018 } 01019 else if(source && length) 01020 { 01021 if(vp) { 01022 err = jit_gl_shader_load_glslvp_with_cg_from_mem(x, source, length); 01023 } 01024 else if(gp) { 01025 err = jit_gl_shader_load_glslgp_with_cg_from_mem(x, source, length); 01026 } 01027 else { 01028 err = jit_gl_shader_load_glslfp_with_cg_from_mem(x, source, length); 01029 } 01030 } 01031 01032 } 01033 } 01034 } 01035 else if (lang==ps_jit_gl_shader_language_cg) 01036 { 01037 if(x->verbose) 01038 jit_object_post((t_object *)x,"jit.gl.shader: attempting to load CG implementation."); 01039 01040 err = jit_gl_shader_verify_cg(x); 01041 if(!err) 01042 { 01043 if(precompiled && filename && filename != _jit_sym_nothing) 01044 { 01045 if(vp) { 01046 err = jit_gl_shader_load_cgvp_from_file(x, ps_jit_gl_shader_object, 1, &af); 01047 } 01048 else if(gp) { 01049 err = jit_gl_shader_load_cggp_from_file(x, ps_jit_gl_shader_object, 1, &af); 01050 } 01051 else { 01052 err = jit_gl_shader_load_cgfp_from_file(x, ps_jit_gl_shader_object, 1, &af); 01053 } 01054 } 01055 else if(filename && filename != _jit_sym_nothing) 01056 { 01057 if(vp) { 01058 err = jit_gl_shader_load_cgvp_from_file(x, ps_jit_gl_shader_source, 1, &af); 01059 } 01060 else if(gp) { 01061 err = jit_gl_shader_load_cggp_from_file(x, ps_jit_gl_shader_source, 1, &af); 01062 } 01063 else { 01064 err = jit_gl_shader_load_cgfp_from_file(x, ps_jit_gl_shader_source, 1, &af); 01065 } 01066 } 01067 else if(source && length) 01068 { 01069 if(vp) { 01070 err = jit_gl_shader_load_cgvp_from_mem(x, source, length); 01071 } 01072 else if(gp) { 01073 err = jit_gl_shader_load_cggp_from_mem(x, source, length); 01074 } 01075 else { 01076 err = jit_gl_shader_load_cgfp_from_mem(x, source, length); 01077 } 01078 } 01079 01080 } 01081 } 01082 else 01083 { 01084 err = JIT_ERR_GENERIC; 01085 jit_object_error((t_object *)x,"jit.gl.shader: unknown language type!"); 01086 } 01087 01088 if(!err) 01089 { 01090 // set the program data members 01091 program = jit_gl_shader_get_program_by_filename(x, filename); 01092 if (!program) 01093 program = jit_gl_shader_get_program_by_type(x, type); 01094 if (!program) 01095 program = jit_gl_shader_get_program_by_profile(x, profile); 01096 01097 if(program) 01098 { 01099 x->language = lang; 01100 01101 // allocate temp string (filename + name + colon + null) 01102 bytes = (strlen(JIT_SYM_SAFECSTR(x->filename)) + strlen(JIT_SYM_SAFECSTR(name)) + 2) * sizeof(char); 01103 temp = jit_getbytes(bytes); 01104 temp[0] = 0; 01105 01106 // create unique name from jxs file and program name 01107 sprintf(temp, "%s:%s", JIT_SYM_SAFECSTR(x->filename), JIT_SYM_SAFECSTR(name)); 01108 if (x->verbose) 01109 jit_object_post((t_object *)x,"jit.gl.shader: caching %s", temp); 01110 program->hashkey = gensym(temp); 01111 01112 // free temp string 01113 jit_freebytes(temp, bytes); 01114 01115 // save 01116 program->name = name; 01117 program->profile = profile; 01118 program->precompiled = precompiled; 01119 program->language = lang; 01120 if(program->entry) 01121 program->entry = entry; 01122 } 01123 else 01124 { 01125 jit_object_error((t_object *)x,"jit.gl.shader: failed to load program!"); 01126 err = JIT_ERR_GENERIC; 01127 } 01128 } 01129 01130 return err; 01131 } 01132 01133 t_jit_err jit_gl_shader_set_geometry_shader_parameters(t_jit_gl_shader *x, long vertices_out, t_symbol *input_type, t_symbol *output_type) 01134 { 01135 t_jit_gl_shader_program *program = NULL; 01136 t_jit_err err = JIT_ERR_NONE; 01137 program = jit_gl_shader_get_program_by_type(x, ps_jit_gl_shader_program_type_geometry); 01138 if(program) { 01139 program->vertices_out = vertices_out; 01140 program->input_type = input_type; 01141 program->output_type = output_type; 01142 } 01143 else { 01144 err = JIT_ERR_INVALID_PTR; 01145 } 01146 01147 return err; 01148 } 01149 01150 t_jit_err jit_gl_shader_load_program_from_file(t_jit_gl_shader *x, t_jit_gl_shader_program *program) 01151 { 01152 if(!program) 01153 return JIT_ERR_INVALID_PTR; 01154 01155 01156 // load the program's source 01157 sysmem_lockhandle(program->source,0); 01158 if (!jit_gl_shader_load_source_from_file(x, program->filename, program->source, &program->length, &program->timestamp)) 01159 { 01160 sysmem_lockhandle(program->source,1); 01161 } 01162 else 01163 { 01164 sysmem_lockhandle(program->source,1); 01165 return JIT_ERR_DATA_UNAVAILABLE; 01166 } 01167 01168 return JIT_ERR_NONE; 01169 } 01170 01171 t_jit_err jit_gl_shader_load_source_from_mem(t_jit_gl_shader *x, const char *source, long length, t_handle texthandle, long *textsize, unsigned long *timestamp) 01172 { 01173 long i = 0; 01174 long pos = 0; 01175 long start = 0; 01176 long end = length-1; 01177 long trimlength = length; 01178 01179 if(source && length) 01180 { 01181 // find leading whitespace 01182 while(start < length && (source[start] == ' ' || source[start] == '\t' || source[start] == '\n' || source[start] == '\r')) 01183 start++; 01184 01185 // find trailing spaces 01186 //while(end > start && source[end] == ' ' || source[end] == '\t') 01187 // end--; 01188 01189 trimlength = end - start; 01190 01191 // get timestamp from jxs modification date 01192 path_getfilemoddate(JIT_SYM_SAFECSTR(x->filename), 0, timestamp); 01193 01194 // resize handle 01195 sysmem_lockhandle(texthandle,0); 01196 sysmem_resizehandle(texthandle, trimlength+1); 01197 sysmem_lockhandle(texthandle,1); 01198 01199 // copy trimmed source 01200 for(i = start; i < end; i++) 01201 { 01202 (*texthandle)[pos++] = source[i]; 01203 } 01204 (*texthandle)[pos] = '\0'; 01205 *textsize = trimlength; 01206 } 01207 01208 return JIT_ERR_NONE; 01209 } 01210 01211 t_jit_err jit_gl_shader_load_source_from_file(t_jit_gl_shader *x, t_symbol *s, t_handle texthandle, long *textsize, unsigned long *timestamp) 01212 { 01213 t_filehandle fh; 01214 char filename[MAX_PATH_CHARS]; 01215 short vol; 01216 long size; 01217 OSErr err = -1; 01218 long type = FOUR_CHAR_CODE( 'TEXT' ); 01219 01220 01221 // open the dialog for the file if unspecified 01222 if (s == _jit_sym_nothing) 01223 { 01224 filename[0] = 0; 01225 01226 if (open_dialog(filename, &vol, &type, &type, 1)) 01227 return err; 01228 01229 } else { 01230 01231 // make a copy of the filename for locatefile 01232 strcpy(filename,s->s_name); 01233 01234 if(x->verbose) 01235 jit_object_post((t_object *)x,"jit.gl.shader: loading program file '%s'", filename); 01236 01237 // locate the file 01238 if (locatefile_extended(filename,&vol,(long *)&type,NULL,0)) 01239 { 01240 jit_object_error((t_object *)x,"jit.gl.shader: can't find file %s", filename); 01241 return err; 01242 } 01243 } 01244 01245 // open the file with read-only permissions 01246 err = path_opensysfile(filename,vol,&fh, READ_PERM); 01247 01248 if (!err) 01249 { 01250 // read the text file in unix format 01251 sysfile_readtextfile(fh,texthandle,0,TEXT_LB_UNIX); 01252 01253 // close the filehandle 01254 sysfile_close(fh); 01255 01256 // get timestamp from from modification date 01257 path_getfilemoddate(filename, 0, timestamp); 01258 01259 // get the file size 01260 size = sysmem_handlesize(texthandle); 01261 *textsize = size; 01262 01263 // resize the mem 01264 sysmem_resizehandle(texthandle,size+1L); 01265 sysmem_lockhandle(texthandle,1); 01266 (*texthandle)[*textsize] = 0; 01267 sysmem_lockhandle(texthandle,0); 01268 } 01269 01270 01271 return err; 01272 } 01273 01274 t_jit_err jit_gl_shader_setprogram_param(t_jit_gl_shader *x, t_symbol *s, long argc, t_atom *argv) 01275 { 01276 if(argc >= 2) { 01277 t_symbol *program_paramname = jit_atom_getsym(argv); 01278 argc--; argv++; 01279 01280 01281 if(x->pending || !JIT_SYM_IF(x->filename)) { 01282 //cache for after program loaded 01283 long found = FALSE; 01284 long i; 01285 01286 for(i = 0; i < x->loadprogramparamcount; i++) 01287 { 01288 if(x->loadprogramparam[i] && x->loadprogramparam[i]->name == program_paramname) 01289 { 01290 jit_gl_shader_programparam_setvalueof(x->loadprogramparam[i], NULL, argc, argv); 01291 found = TRUE; 01292 break; 01293 } 01294 } 01295 01296 // add the program param to the list 01297 if(!found && x->loadprogramparamcount < JIT_MAX_PROGAM_PARAMS) 01298 { 01299 // reset param 01300 if(x->loadprogramparam[x->loadprogramparamcount]) 01301 jit_object_free(x->loadprogramparam[x->loadprogramparamcount]); 01302 01303 x->loadprogramparam[x->loadprogramparamcount] = NULL; 01304 x->loadprogramparam[x->loadprogramparamcount] = jit_gl_shader_param_new(program_paramname); 01305 if(!x->loadprogramparam[x->loadprogramparamcount]) 01306 return JIT_ERR_INVALID_PTR; 01307 01308 // save name 01309 x->loadprogramparam[x->loadprogramparamcount]->name = program_paramname; 01310 01311 // assign values 01312 jit_gl_shader_programparam_setvalueof(x->loadprogramparam[i], NULL, argc, argv); 01313 01314 // increment load count 01315 x->loadprogramparamcount++; 01316 } 01317 } 01318 else { 01319 //set already loaded program param 01320 jit_object_method(x->program[JIT_GL_SHADER_PROGRAM_GEOMETRY_INDEX], program_paramname, program_paramname, argc, argv); 01321 01322 //trigger rebuild because program parameters are set at link time 01323 // call appropriate backend implementation 01324 /*if(x->backend == ps_jit_gl_shader_backend_asm) 01325 { 01326 jit_gl_shader_destroy_asm(x); 01327 } 01328 else if(x->backend == ps_jit_gl_shader_backend_glsl) 01329 { 01330 jit_gl_shader_destroy_glsl(x); 01331 } 01332 else if(x->backend == ps_jit_gl_shader_backend_cg) 01333 { 01334 jit_gl_shader_destroy_cg(x); 01335 }*/ 01336 01337 jit_gl_shader_disable(x); 01338 x->changed = TRUE; 01339 jit_gl_shader_link(x); 01340 } 01341 } 01342 01343 return JIT_ERR_NONE; 01344 } 01345 01346 t_jit_err jit_gl_shader_setparam(t_jit_gl_shader *x, t_symbol *s, long argc, t_atom *argv) 01347 { 01348 long i,j; 01349 long found = FALSE; 01350 t_symbol *paramname = _jit_sym_nothing; 01351 t_jit_gl_shader_param *param = NULL; 01352 01353 if (argc) 01354 { 01355 paramname = jit_atom_getsym(argv); 01356 argc--; argv++; 01357 } 01358 01359 if (!JIT_SYM_IF(paramname)) 01360 return JIT_ERR_NONE; 01361 01362 // cache shader parameters since we cannot verify whether or not 01363 // they are valid at this point since shader file has not been loaded 01364 if(x->pending || !JIT_SYM_IF(x->filename)) 01365 { 01366 for(i = 0; i < x->loadparamcount; i++) 01367 { 01368 if(x->loadparam[i] && x->loadparam[i]->name == paramname) 01369 { 01370 jit_gl_shader_param_setvalueof(x->loadparam[i], NULL, argc, argv); 01371 found = TRUE; 01372 break; 01373 } 01374 } 01375 01376 // add the param to the list 01377 if(!found && x->loadparamcount < 255) 01378 { 01379 // reset param 01380 if(x->loadparam[x->loadparamcount]) 01381 jit_object_free(x->loadparam[x->loadparamcount]); 01382 01383 x->loadparam[x->loadparamcount] = NULL; 01384 x->loadparam[x->loadparamcount] = jit_gl_shader_param_new(paramname); 01385 if(!x->loadparam[x->loadparamcount]) 01386 return JIT_ERR_INVALID_PTR; 01387 01388 jit_gl_shader_param_reset(x->loadparam[x->loadparamcount]); 01389 01390 // save name 01391 x->loadparam[x->loadparamcount]->name = paramname; 01392 01393 // assign values 01394 jit_gl_shader_param_setvalueof(x->loadparam[x->loadparamcount], NULL, argc, argv); 01395 01396 // increment load count 01397 x->loadparamcount++; 01398 } 01399 } 01400 else 01401 { 01402 for(i = 0; i < x->programcount && x->program && x->program[i]; i++) 01403 { 01404 param = jit_gl_shader_program_get_param_by_name(x->program[i], paramname); 01405 if(param) 01406 { 01407 jit_gl_shader_param_setvalueof(param,NULL,argc,argv); 01408 found = TRUE; 01409 break; 01410 } 01411 } 01412 } 01413 01414 if(found == FALSE && x->verbose) 01415 jit_object_post((t_object *)x,"jit.gl.shader: attempted to set unknown parameter '%s'", JIT_SYM_SAFECSTR(paramname)); 01416 01417 return JIT_ERR_NONE; 01418 } 01419 01420 t_jit_err jit_gl_shader_getparamlist(t_jit_gl_shader *x, void *s, long argc, t_atom *argv, t_atom *rv) 01421 { 01422 long rac=0; 01423 t_atom rav[256]; // I suppose there could be more params than this, but seems unlikely 01424 long i,j,k=0,user=1,state=1; 01425 t_jit_gl_shader_program *p; 01426 01427 if (argc&&argv&&jit_atom_getsym(argv)==ps_jit_gl_shader_user) 01428 state = 0; 01429 else if (argc&&argv&&jit_atom_getsym(argv)==ps_jit_gl_shader_state) 01430 user = 0; 01431 01432 01433 for(i = 0; i < x->programcount && x->program && x->program[i]; i++) 01434 { 01435 p = x->program[i]; 01436 for(j = 0; j < p->paramcount && p->param && p->param[j] && k < 256; j++ ) 01437 { 01438 if ((k<256)&&((state&&JIT_SYM_IF(p->param[j]->state))||(user&&!JIT_SYM_IF(p->param[j]->state)))) 01439 { 01440 jit_atom_setsym(rav+k,p->param[j]->name); 01441 rac++,k++; 01442 } 01443 } 01444 } 01445 01446 if (rac&&rv) { 01447 atom_setobj(rv,object_new(ps_nobox,ps_atomarray,rac,rav)); 01448 } 01449 01450 return JIT_ERR_NONE; 01451 } 01452 01453 t_jit_err jit_gl_shader_getparam_method(t_jit_gl_shader *x, void *s, long argc, t_atom *argv, t_atom *rv) 01454 { 01455 long i,j; 01456 long found = FALSE; 01457 t_jit_object *o = NULL; 01458 t_symbol *paramname = _jit_sym_nothing; 01459 t_jit_gl_shader_param *param = NULL; 01460 01461 01462 if (argc) 01463 { 01464 paramname = jit_atom_getsym(argv); 01465 argc--; argv++; 01466 } 01467 01468 if (paramname == _jit_sym_nothing) 01469 return JIT_ERR_NONE; 01470 01471 for(i = 0; i < x->programcount && x->program && x->program[i]; i++) 01472 { 01473 param = jit_gl_shader_program_get_param_by_name(x->program[i], paramname); 01474 if(param) 01475 { 01476 found = TRUE; 01477 break; 01478 } 01479 } 01480 01481 if(found == FALSE && x->verbose) 01482 jit_object_post((t_object *)x,"jit.gl.shader: attempted to get unknown parameter '%s'", JIT_SYM_SAFECSTR(paramname)); 01483 01484 if(param && found && rv) 01485 { 01486 if (s == ps_jit_gl_shader_getparamval) 01487 { 01488 if (param->acount && param->avalue) 01489 { 01490 o = object_new(ps_nobox,ps_atomarray,param->acount,param->avalue); 01491 if(o) atom_setobj(rv, o); 01492 } 01493 } 01494 else if (s == ps_jit_gl_shader_getparamtype) 01495 { 01496 atom_setsym(rv,param->datatype); 01497 } 01498 else if (s == ps_jit_gl_shader_getparamdefault) 01499 { 01500 if (param->dcount && param->dvalue) 01501 { 01502 o = object_new(ps_nobox,ps_atomarray,param->dcount,param->dvalue); 01503 if(o) atom_setobj(rv, o); 01504 } 01505 } 01506 } 01507 01508 return JIT_ERR_NONE; 01509 } 01510 01511 t_jit_err jit_gl_shader_set_general_state_param(t_jit_gl_shader *x) 01512 { 01513 long i, j, k; 01514 t_jit_err err = JIT_ERR_NONE; 01515 t_jit_gl_shader_program *program; 01516 t_jit_gl_shader_param *param; 01517 01518 // submit params for each program 01519 for(i = 0; i < x->programcount && x->program[i]; i++) 01520 { 01521 // get the next program 01522 program = x->program[i]; 01523 01524 // get state data 01525 for(j = 0; j < program->paramcount && program->param[j]; j++) 01526 { 01527 param = program->param[j]; 01528 if(param->state && param->state != _jit_sym_nothing && param->fvalue) 01529 { 01530 // get matrix state 01531 err = jit_gl_shader_assign_general_state_to_param(x, param); 01532 if(err) return err; 01533 } 01534 } 01535 } 01536 01537 01538 return err; 01539 } 01540 01541 01542 t_jit_err jit_gl_shader_set_matrix_state_param(t_jit_gl_shader *x) 01543 { 01544 long i, j, k; 01545 t_jit_err err = JIT_ERR_NONE; 01546 t_jit_gl_shader_program *program; 01547 t_jit_gl_shader_param *param; 01548 01549 // submit params for each program 01550 for(i = 0; i < x->programcount && x->program[i]; i++) 01551 { 01552 // get the next program 01553 program = x->program[i]; 01554 01555 // get state data 01556 for(j = 0; j < program->paramcount && program->param[j]; j++) 01557 { 01558 param = program->param[j]; 01559 if(param->state && param->state != _jit_sym_nothing && param->fvalue) 01560 { 01561 // get matrix state 01562 err = jit_gl_shader_assign_matrix_state_to_param(param); 01563 if(err) return err; 01564 01565 // perform transform 01566 if(param->transform) 01567 { 01568 err = jit_gl_shader_apply_matrix_transform_to_param(param); 01569 if(err) return err; 01570 } 01571 } 01572 } 01573 } 01574 01575 01576 return err; 01577 } 01578 01579 t_jit_err jit_gl_shader_assign_general_state_to_param(t_jit_gl_shader *x, t_jit_gl_shader_param *param) 01580 { 01581 long ac=0; 01582 t_atom *av=NULL; 01583 01584 GLint active = 0; 01585 GLfloat fv[4] = {0, 0, 0, 0}; 01586 long i, j; 01587 01588 if(!param || !param->state) 01589 return JIT_ERR_INVALID_PTR; 01590 01591 if(param->state == ps_jit_gl_shader_state_camera_position) 01592 { 01593 if(x->bound) 01594 { 01595 jit_object_method(x->bound,gensym("getcamera"),&ac,&av); 01596 if ((ac==3)&&av) 01597 { 01598 fv[0] = jit_atom_getfloat(av); 01599 fv[1] = jit_atom_getfloat(av+1); 01600 fv[2] = jit_atom_getfloat(av+2); 01601 jit_freebytes(av,ac*sizeof(t_atom)); 01602 } 01603 for(i = 0; i < param->datasize; i++) 01604 param->fvalue[i] = fv[i]; 01605 } 01606 } 01607 else if(param->state == ps_jit_gl_shader_state_camera_direction) 01608 { 01609 if(x->bound) 01610 { 01611 jit_object_method(x->bound,gensym("getlookat"),&ac,&av); 01612 if ((ac==3)&&av) 01613 { 01614 fv[0] = jit_atom_getfloat(av); 01615 fv[1] = jit_atom_getfloat(av+1); 01616 fv[2] = jit_atom_getfloat(av+2); 01617 jit_freebytes(av,ac*sizeof(t_atom)); 01618 } 01619 for(i = 0; i < param->datasize; i++) 01620 param->fvalue[i] = fv[i]; 01621 } 01622 } 01623 else if(param->state == ps_jit_gl_shader_state_ambient) 01624 { 01625 glGetMaterialfv(GL_FRONT, GL_AMBIENT, fv); 01626 for(i = 0; i < param->datasize; i++) 01627 param->fvalue[i] = fv[i]; 01628 } 01629 else if(param->state == ps_jit_gl_shader_state_diffuse) 01630 { 01631 glGetMaterialfv(GL_FRONT, GL_DIFFUSE, fv); 01632 for(i = 0; i < param->datasize; i++) 01633 param->fvalue[i] = fv[i]; 01634 } 01635 else if(param->state == ps_jit_gl_shader_state_specular) 01636 { 01637 glGetMaterialfv(GL_FRONT, GL_SPECULAR, fv); 01638 for(i = 0; i < param->datasize; i++) 01639 param->fvalue[i] = fv[i]; 01640 } 01641 else if(param->state == ps_jit_gl_shader_state_emission) 01642 { 01643 glGetMaterialfv(GL_FRONT, GL_EMISSION, fv); 01644 for(i = 0; i < param->datasize; i++) 01645 param->fvalue[i] = fv[i]; 01646 } 01647 else if(param->state == ps_jit_gl_shader_state_light_position || 01648 param->state == ps_jit_gl_shader_state_light0_position) 01649 { 01650 glGetLightfv(GL_LIGHT0, GL_POSITION, fv); 01651 for(i = 0; i < param->datasize; i++) 01652 param->fvalue[i] = fv[i]; 01653 } 01654 else if(param->state == ps_jit_gl_shader_state_light1_position) 01655 { 01656 glGetLightfv(GL_LIGHT1, GL_POSITION, fv); 01657 for(i = 0; i < param->datasize; i++) 01658 param->fvalue[i] = fv[i]; 01659 } 01660 else if(param->state == ps_jit_gl_shader_state_light2_position) 01661 { 01662 glGetLightfv(GL_LIGHT2, GL_POSITION, fv); 01663 for(i = 0; i < param->datasize; i++) 01664 param->fvalue[i] = fv[i]; 01665 } 01666 else if(param->state == ps_jit_gl_shader_state_light3_position) 01667 { 01668 glGetLightfv(GL_LIGHT3, GL_POSITION, fv); 01669 for(i = 0; i < param->datasize; i++) 01670 param->fvalue[i] = fv[i]; 01671 } 01672 else if(param->state == ps_jit_gl_shader_state_light4_position) 01673 { 01674 glGetLightfv(GL_LIGHT4, GL_POSITION, fv); 01675 for(i = 0; i < param->datasize; i++) 01676 param->fvalue[i] = fv[i]; 01677 } 01678 else if(param->state == ps_jit_gl_shader_state_light5_position) 01679 { 01680 glGetLightfv(GL_LIGHT5, GL_POSITION, fv); 01681 for(i = 0; i < param->datasize; i++) 01682 param->fvalue[i] = fv[i]; 01683 } 01684 else if(param->state == ps_jit_gl_shader_state_light6_position) 01685 { 01686 glGetLightfv(GL_LIGHT6, GL_POSITION, fv); 01687 for(i = 0; i < param->datasize; i++) 01688 param->fvalue[i] = fv[i]; 01689 } 01690 else if(param->state == ps_jit_gl_shader_state_light7_position) 01691 { 01692 glGetLightfv(GL_LIGHT7, GL_POSITION, fv); 01693 for(i = 0; i < param->datasize; i++) 01694 param->fvalue[i] = fv[i]; 01695 } 01696 else if(param->state == ps_jit_gl_shader_state_light_direction || 01697 param->state == ps_jit_gl_shader_state_light0_direction) 01698 { 01699 glGetLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, fv); 01700 for(i = 0; i < param->datasize; i++) 01701 param->fvalue[i] = fv[i]; 01702 } 01703 else if(param->state == ps_jit_gl_shader_state_light1_direction) 01704 { 01705 glGetLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, fv); 01706 for(i = 0; i < param->datasize; i++) 01707 param->fvalue[i] = fv[i]; 01708 } 01709 else if(param->state == ps_jit_gl_shader_state_light2_direction) 01710 { 01711 glGetLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, fv); 01712 for(i = 0; i < param->datasize; i++) 01713 param->fvalue[i] = fv[i]; 01714 } 01715 else if(param->state == ps_jit_gl_shader_state_light3_direction) 01716 { 01717 glGetLightfv(GL_LIGHT3, GL_SPOT_DIRECTION, fv); 01718 for(i = 0; i < param->datasize; i++) 01719 param->fvalue[i] = fv[i]; 01720 } 01721 else if(param->state == ps_jit_gl_shader_state_light4_direction) 01722 { 01723 glGetLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, fv); 01724 for(i = 0; i < param->datasize; i++) 01725 param->fvalue[i] = fv[i]; 01726 } 01727 else if(param->state == ps_jit_gl_shader_state_light5_direction) 01728 { 01729 glGetLightfv(GL_LIGHT5, GL_SPOT_DIRECTION, fv); 01730 for(i = 0; i < param->datasize; i++) 01731 param->fvalue[i] = fv[i]; 01732 } 01733 else if(param->state == ps_jit_gl_shader_state_light6_direction) 01734 { 01735 glGetLightfv(GL_LIGHT6, GL_SPOT_DIRECTION, fv); 01736 for(i = 0; i < param->datasize; i++) 01737 param->fvalue[i] = fv[i]; 01738 } 01739 else if(param->state == ps_jit_gl_shader_state_light7_direction) 01740 { 01741 glGetLightfv(GL_LIGHT7, GL_SPOT_DIRECTION, fv); 01742 for(i = 0; i < param->datasize; i++) 01743 param->fvalue[i] = fv[i]; 01744 } 01745 else if(param->state == ps_jit_gl_shader_state_light_ambient || 01746 param->state == ps_jit_gl_shader_state_light0_ambient) 01747 { 01748 glGetLightfv(GL_LIGHT0, GL_AMBIENT, fv); 01749 for(i = 0; i < param->datasize; i++) 01750 param->fvalue[i] = fv[i]; 01751 } 01752 else if(param->state == ps_jit_gl_shader_state_light1_ambient) 01753 { 01754 glGetLightfv(GL_LIGHT1, GL_AMBIENT, fv); 01755 for(i = 0; i < param->datasize; i++) 01756 param->fvalue[i] = fv[i]; 01757 } 01758 else if(param->state == ps_jit_gl_shader_state_light2_ambient) 01759 { 01760 glGetLightfv(GL_LIGHT2, GL_AMBIENT, fv); 01761 for(i = 0; i < param->datasize; i++) 01762 param->fvalue[i] = fv[i]; 01763 } 01764 else if(param->state == ps_jit_gl_shader_state_light3_ambient) 01765 { 01766 glGetLightfv(GL_LIGHT3, GL_AMBIENT, fv); 01767 for(i = 0; i < param->datasize; i++) 01768 param->fvalue[i] = fv[i]; 01769 } 01770 else if(param->state == ps_jit_gl_shader_state_light4_ambient) 01771 { 01772 glGetLightfv(GL_LIGHT4, GL_AMBIENT, fv); 01773 for(i = 0; i < param->datasize; i++) 01774 param->fvalue[i] = fv[i]; 01775 } 01776 else if(param->state == ps_jit_gl_shader_state_light5_ambient) 01777 { 01778 glGetLightfv(GL_LIGHT5, GL_AMBIENT, fv); 01779 for(i = 0; i < param->datasize; i++) 01780 param->fvalue[i] = fv[i]; 01781 } 01782 else if(param->state == ps_jit_gl_shader_state_light6_ambient) 01783 { 01784 glGetLightfv(GL_LIGHT6, GL_AMBIENT, fv); 01785 for(i = 0; i < param->datasize; i++) 01786 param->fvalue[i] = fv[i]; 01787 } 01788 else if(param->state == ps_jit_gl_shader_state_light7_ambient) 01789 { 01790 glGetLightfv(GL_LIGHT7, GL_AMBIENT, fv); 01791 for(i = 0; i < param->datasize; i++) 01792 param->fvalue[i] = fv[i]; 01793 } 01794 else if(param->state == ps_jit_gl_shader_state_light_diffuse || 01795 param->state == ps_jit_gl_shader_state_light0_diffuse) 01796 { 01797 glGetLightfv(GL_LIGHT0, GL_DIFFUSE, fv); 01798 for(i = 0; i < param->datasize; i++) 01799 param->fvalue[i] = fv[i]; 01800 } 01801 else if(param->state == ps_jit_gl_shader_state_light1_diffuse) 01802 { 01803 glGetLightfv(GL_LIGHT1, GL_DIFFUSE, fv); 01804 for(i = 0; i < param->datasize; i++) 01805 param->fvalue[i] = fv[i]; 01806 } 01807 else if(param->state == ps_jit_gl_shader_state_light2_diffuse) 01808 { 01809 glGetLightfv(GL_LIGHT2, GL_DIFFUSE, fv); 01810 for(i = 0; i < param->datasize; i++) 01811 param->fvalue[i] = fv[i]; 01812 } 01813 else if(param->state == ps_jit_gl_shader_state_light3_diffuse) 01814 { 01815 glGetLightfv(GL_LIGHT3, GL_DIFFUSE, fv); 01816 for(i = 0; i < param->datasize; i++) 01817 param->fvalue[i] = fv[i]; 01818 } 01819 else if(param->state == ps_jit_gl_shader_state_light4_diffuse) 01820 { 01821 glGetLightfv(GL_LIGHT4, GL_DIFFUSE, fv); 01822 for(i = 0; i < param->datasize; i++) 01823 param->fvalue[i] = fv[i]; 01824 } 01825 else if(param->state == ps_jit_gl_shader_state_light5_diffuse) 01826 { 01827 glGetLightfv(GL_LIGHT5, GL_DIFFUSE, fv); 01828 for(i = 0; i < param->datasize; i++) 01829 param->fvalue[i] = fv[i]; 01830 } 01831 else if(param->state == ps_jit_gl_shader_state_light6_diffuse) 01832 { 01833 glGetLightfv(GL_LIGHT6, GL_DIFFUSE, fv); 01834 for(i = 0; i < param->datasize; i++) 01835 param->fvalue[i] = fv[i]; 01836 } 01837 else if(param->state == ps_jit_gl_shader_state_light7_diffuse) 01838 { 01839 glGetLightfv(GL_LIGHT7, GL_DIFFUSE, fv); 01840 for(i = 0; i < param->datasize; i++) 01841 param->fvalue[i] = fv[i]; 01842 } 01843 else if(param->state == ps_jit_gl_shader_state_light_specular || 01844 param->state == ps_jit_gl_shader_state_light0_specular) 01845 { 01846 glGetLightfv(GL_LIGHT0, GL_SPECULAR, fv); 01847 for(i = 0; i < param->datasize; i++) 01848 param->fvalue[i] = fv[i]; 01849 } 01850 else if(param->state == ps_jit_gl_shader_state_light1_specular) 01851 { 01852 glGetLightfv(GL_LIGHT1, GL_SPECULAR, fv); 01853 for(i = 0; i < param->datasize; i++) 01854 param->fvalue[i] = fv[i]; 01855 } 01856 else if(param->state == ps_jit_gl_shader_state_light2_specular) 01857 { 01858 glGetLightfv(GL_LIGHT2, GL_SPECULAR, fv); 01859 for(i = 0; i < param->datasize; i++) 01860 param->fvalue[i] = fv[i]; 01861 } 01862 else if(param->state == ps_jit_gl_shader_state_light3_specular) 01863 { 01864 glGetLightfv(GL_LIGHT3, GL_SPECULAR, fv); 01865 for(i = 0; i < param->datasize; i++) 01866 param->fvalue[i] = fv[i]; 01867 } 01868 else if(param->state == ps_jit_gl_shader_state_light4_specular) 01869 { 01870 glGetLightfv(GL_LIGHT4, GL_SPECULAR, fv); 01871 for(i = 0; i < param->datasize; i++) 01872 param->fvalue[i] = fv[i]; 01873 } 01874 else if(param->state == ps_jit_gl_shader_state_light5_specular) 01875 { 01876 glGetLightfv(GL_LIGHT5, GL_SPECULAR, fv); 01877 for(i = 0; i < param->datasize; i++) 01878 param->fvalue[i] = fv[i]; 01879 } 01880 else if(param->state == ps_jit_gl_shader_state_light6_specular) 01881 { 01882 glGetLightfv(GL_LIGHT6, GL_SPECULAR, fv); 01883 for(i = 0; i < param->datasize; i++) 01884 param->fvalue[i] = fv[i]; 01885 } 01886 else if(param->state == ps_jit_gl_shader_state_light7_specular) 01887 { 01888 glGetLightfv(GL_LIGHT7, GL_SPECULAR, fv); 01889 for(i = 0; i < param->datasize; i++) 01890 param->fvalue[i] = fv[i]; 01891 } 01892 else if(param->state == ps_jit_gl_shader_state_light_cutoff || 01893 param->state == ps_jit_gl_shader_state_light0_cutoff) 01894 { 01895 glGetLightfv(GL_LIGHT0, GL_SPOT_CUTOFF, fv); 01896 for(i = 0; i < param->datasize; i++) 01897 param->fvalue[i] = fv[i]; 01898 } 01899 else if(param->state == ps_jit_gl_shader_state_light1_cutoff) 01900 { 01901 glGetLightfv(GL_LIGHT1, GL_SPOT_CUTOFF, fv); 01902 for(i = 0; i < param->datasize; i++) 01903 param->fvalue[i] = fv[i]; 01904 } 01905 else if(param->state == ps_jit_gl_shader_state_light2_cutoff) 01906 { 01907 glGetLightfv(GL_LIGHT2, GL_SPOT_CUTOFF, fv); 01908 for(i = 0; i < param->datasize; i++) 01909 param->fvalue[i] = fv[i]; 01910 } 01911 else if(param->state == ps_jit_gl_shader_state_light3_cutoff) 01912 { 01913 glGetLightfv(GL_LIGHT3, GL_SPOT_CUTOFF, fv); 01914 for(i = 0; i < param->datasize; i++) 01915 param->fvalue[i] = fv[i]; 01916 } 01917 else if(param->state == ps_jit_gl_shader_state_light4_cutoff) 01918 { 01919 glGetLightfv(GL_LIGHT4, GL_SPOT_CUTOFF, fv); 01920 for(i = 0; i < param->datasize; i++) 01921 param->fvalue[i] = fv[i]; 01922 } 01923 else if(param->state == ps_jit_gl_shader_state_light5_cutoff) 01924 { 01925 glGetLightfv(GL_LIGHT5, GL_SPOT_CUTOFF, fv); 01926 for(i = 0; i < param->datasize; i++) 01927 param->fvalue[i] = fv[i]; 01928 } 01929 else if(param->state == ps_jit_gl_shader_state_light6_cutoff) 01930 { 01931 glGetLightfv(GL_LIGHT6, GL_SPOT_CUTOFF, fv); 01932 for(i = 0; i < param->datasize; i++) 01933 param->fvalue[i] = fv[i]; 01934 } 01935 else if(param->state == ps_jit_gl_shader_state_light7_cutoff) 01936 { 01937 glGetLightfv(GL_LIGHT7, GL_SPOT_CUTOFF, fv); 01938 for(i = 0; i < param->datasize; i++) 01939 param->fvalue[i] = fv[i]; 01940 } 01941 else if(param->state == ps_jit_gl_shader_state_light_exponent || 01942 param->state == ps_jit_gl_shader_state_light0_exponent) 01943 { 01944 glGetLightfv(GL_LIGHT0, GL_SPOT_EXPONENT, fv); 01945 for(i = 0; i < param->datasize; i++) 01946 param->fvalue[i] = fv[i]; 01947 } 01948 else if(param->state == ps_jit_gl_shader_state_light1_exponent) 01949 { 01950 glGetLightfv(GL_LIGHT1, GL_SPOT_EXPONENT, fv); 01951 for(i = 0; i < param->datasize; i++) 01952 param->fvalue[i] = fv[i]; 01953 } 01954 else if(param->state == ps_jit_gl_shader_state_light2_exponent) 01955 { 01956 glGetLightfv(GL_LIGHT2, GL_SPOT_EXPONENT, fv); 01957 for(i = 0; i < param->datasize; i++) 01958 param->fvalue[i] = fv[i]; 01959 } 01960 else if(param->state == ps_jit_gl_shader_state_light3_exponent) 01961 { 01962 glGetLightfv(GL_LIGHT3, GL_SPOT_EXPONENT, fv); 01963 for(i = 0; i < param->datasize; i++) 01964 param->fvalue[i] = fv[i]; 01965 } 01966 else if(param->state == ps_jit_gl_shader_state_light4_exponent) 01967 { 01968 glGetLightfv(GL_LIGHT4, GL_SPOT_EXPONENT, fv); 01969 for(i = 0; i < param->datasize; i++) 01970 param->fvalue[i] = fv[i]; 01971 } 01972 else if(param->state == ps_jit_gl_shader_state_light5_exponent) 01973 { 01974 glGetLightfv(GL_LIGHT5, GL_SPOT_EXPONENT, fv); 01975 for(i = 0; i < param->datasize; i++) 01976 param->fvalue[i] = fv[i]; 01977 } 01978 else if(param->state == ps_jit_gl_shader_state_light6_exponent) 01979 { 01980 glGetLightfv(GL_LIGHT6, GL_SPOT_EXPONENT, fv); 01981 for(i = 0; i < param->datasize; i++) 01982 param->fvalue[i] = fv[i]; 01983 } 01984 else if(param->state == ps_jit_gl_shader_state_light7_exponent) 01985 { 01986 glGetLightfv(GL_LIGHT7, GL_SPOT_EXPONENT, fv); 01987 for(i = 0; i < param->datasize; i++) 01988 param->fvalue[i] = fv[i]; 01989 } 01990 return JIT_ERR_NONE; 01991 } 01992 01993 t_jit_err jit_gl_shader_assign_matrix_state_to_param(t_jit_gl_shader_param *param) 01994 { 01995 GLint active = 0; 01996 t_jit_mat4 a, b, c; 01997 t_jit_mat3 n, m; 01998 t_jit_gl_context ctx; 01999 long j; 02000 02001 ctx = jit_gl_get_context(); 02002 if(!ctx) return JIT_ERR_GENERIC; 02003 02004 if(!param || !param->state) 02005 return JIT_ERR_INVALID_PTR; 02006 02007 if(param->state == ps_jit_gl_shader_state_modelview_matrix) 02008 { 02009 if(param->fvalue && param->datasize == 16) 02010 glGetFloatv(GL_MODELVIEW_MATRIX, param->fvalue); 02011 } 02012 else if(param->state == ps_jit_gl_shader_state_projection_matrix) 02013 { 02014 if(param->fvalue && param->datasize == 16) 02015 glGetFloatv(GL_PROJECTION_MATRIX, param->fvalue); 02016 } 02017 else if(param->state == ps_jit_gl_shader_state_modelview_projection_matrix) 02018 { 02019 if(param->fvalue && param->datasize == 16) 02020 { 02021 glGetFloatv(GL_PROJECTION_MATRIX, a.vals); 02022 glGetFloatv(GL_MODELVIEW_MATRIX, b.vals); 02023 02024 // C = A * B 02025 jit_mat4_mult(&c, &a, &b); 02026 jit_mat4_to_array(&c, param->fvalue); 02027 } 02028 } 02029 else if(param->state == ps_jit_gl_shader_state_texture_matrix || 02030 param->state == ps_jit_gl_shader_state_texture0_matrix || 02031 param->state == ps_jit_gl_shader_state_texture1_matrix || 02032 param->state == ps_jit_gl_shader_state_texture2_matrix || 02033 param->state == ps_jit_gl_shader_state_texture3_matrix || 02034 param->state == ps_jit_gl_shader_state_texture4_matrix || 02035 param->state == ps_jit_gl_shader_state_texture5_matrix || 02036 param->state == ps_jit_gl_shader_state_texture6_matrix || 02037 param->state == ps_jit_gl_shader_state_texture7_matrix) 02038 { 02039 if(param->fvalue && param->datasize == 16) 02040 { 02041 if (ctx->support->multitexture) { 02042 glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &active); 02043 if(ctx->support->texture_units > param->unit) 02044 { 02045 // jit_object_post((t_object *)x,"jit.gl.shader: getting texture matrix %d", param->unit); 02046 glActiveTextureARB(GL_TEXTURE0_ARB + param->unit); 02047 glGetFloatv(GL_TEXTURE_MATRIX, param->fvalue); 02048 } 02049 glActiveTextureARB(active); 02050 } 02051 } 02052 } 02053 else if(param->state == ps_jit_gl_shader_state_normal_matrix) 02054 { 02055 if(param->fvalue && param->datasize == 9) 02056 { 02057 glGetFloatv(GL_MODELVIEW_MATRIX, a.vals); 02058 jit_mat3_from_mat4(&m, &a); 02059 jit_mat3_get_inverse(&n, &m); 02060 jit_mat3_to_array(&n, param->fvalue); 02061 } 02062 else if(param->fvalue && param->datasize == 12) 02063 { 02064 glGetFloatv(GL_MODELVIEW_MATRIX, a.vals); 02065 jit_mat3_from_mat4(&m, &a); 02066 jit_mat3_get_inverse(&n, &m); 02067 02068 param->fvalue[0] = n.vals[0]; 02069 param->fvalue[1] = n.vals[1]; 02070 param->fvalue[2] = n.vals[2]; 02071 param->fvalue[3] = 0.0f; // 0 1 2 3 02072 02073 param->fvalue[4] = n.vals[3]; 02074 param->fvalue[5] = n.vals[4]; 02075 param->fvalue[6] = n.vals[5]; 02076 param->fvalue[7] = 0.0f; // 4 5 6 7 02077 02078 param->fvalue[8] = n.vals[6]; 02079 param->fvalue[9] = n.vals[7]; 02080 param->fvalue[10] = n.vals[8]; 02081 param->fvalue[11] = 0.0f; // 8 9 10 11 02082 } 02083 else if(param->fvalue && param->datasize == 16) 02084 { 02085 glGetFloatv(GL_MODELVIEW_MATRIX, a.vals); 02086 jit_mat3_from_mat4(&m, &a); 02087 jit_mat3_get_inverse(&n, &m); 02088 jit_mat4_from_mat3(&a, &n); 02089 jit_mat4_to_array(&a, param->fvalue); 02090 02091 param->fvalue[3] = 0.0f; // 0 1 2 3 02092 param->fvalue[7] = 0.0f; // 4 5 6 7 02093 param->fvalue[11] = 0.0f; // 8 9 10 11 02094 param->fvalue[12] = 0.0f; // 12 13 14 15 02095 param->fvalue[13] = 0.0f; 02096 param->fvalue[14] = 0.0f; 02097 param->fvalue[15] = 0.0f; 02098 } 02099 } 02100 return JIT_ERR_NONE; 02101 } 02102 02103 t_jit_err jit_gl_shader_apply_matrix_transform_to_param(t_jit_gl_shader_param *param) 02104 { 02105 t_jit_mat4 a, b; 02106 02107 if(!param || !param->transform) 02108 return JIT_ERR_INVALID_PTR; 02109 02110 // perform transform 02111 if(param->transform == ps_jit_gl_shader_transform_inverse) 02112 { 02113 jit_mat4_from_array(&a, param->fvalue); 02114 jit_mat4_get_inverse(&b, &a); 02115 jit_mat4_to_array(&b, param->fvalue); 02116 } 02117 else if(param->transform == ps_jit_gl_shader_transform_transpose) 02118 { 02119 jit_mat4_from_array(&a, param->fvalue); 02120 jit_mat4_get_transpose(&b, &a); 02121 jit_mat4_to_array(&b, param->fvalue); 02122 } 02123 else if(param->transform == ps_jit_gl_shader_transform_inversetranspose) 02124 { 02125 jit_mat4_get_inverse(&b, &a); 02126 jit_mat4_transpose(&b); 02127 jit_mat4_to_array(&b, param->fvalue); 02128 } 02129 else 02130 { 02131 // identity (do nothing!) 02132 } 02133 02134 return JIT_ERR_NONE; 02135 } 02136 02137 t_jit_err jit_gl_shader_set_texture_state_param(t_jit_gl_shader *x) 02138 { 02139 long i, j, k; 02140 t_jit_err err = JIT_ERR_NONE; 02141 t_jit_gl_shader_program *program; 02142 t_jit_gl_shader_param *param; 02143 long texdim = FALSE; 02144 float dim[4]; 02145 dim[0] = dim[1] = dim[2] = 0; 02146 dim[3] = 1.0; 02147 02148 // submit params for each program 02149 for(i = 0; i < x->programcount && x->program[i]; i++) 02150 { 02151 // get the next program 02152 program = x->program[i]; 02153 02154 // get state data 02155 for(j = 0; j < program->paramcount && program->param[j]; j++) 02156 { 02157 param = program->param[j]; 02158 02159 // get texture state 02160 if( param->state == ps_jit_gl_shader_state_texdim || 02161 param->state == ps_jit_gl_shader_state_texdim0 ) 02162 { 02163 err = jit_gl_shader_get_texture_dim(x, 1, &dim[0], &dim[1], &dim[2]); 02164 if(!err) texdim = TRUE; 02165 } 02166 else if(param->state == ps_jit_gl_shader_state_texdim1 ) 02167 { 02168 err = jit_gl_shader_get_texture_dim(x, 2, &dim[0], &dim[1], &dim[2]); 02169 if(!err) texdim = TRUE; 02170 } 02171 else if(param->state == ps_jit_gl_shader_state_texdim2 ) 02172 { 02173 err = jit_gl_shader_get_texture_dim(x, 3, &dim[0], &dim[1], &dim[2]); 02174 if(!err) texdim = TRUE; 02175 } 02176 else if(param->state == ps_jit_gl_shader_state_texdim3 ) 02177 { 02178 err = jit_gl_shader_get_texture_dim(x, 4, &dim[0], &dim[1], &dim[2]); 02179 if(!err) texdim = TRUE; 02180 } 02181 else if(param->state == ps_jit_gl_shader_state_texdim4 ) 02182 { 02183 err = jit_gl_shader_get_texture_dim(x, 5, &dim[0], &dim[1], &dim[2]); 02184 if(!err) texdim = TRUE; 02185 } 02186 else if(param->state == ps_jit_gl_shader_state_texdim5 ) 02187 { 02188 err = jit_gl_shader_get_texture_dim(x, 6, &dim[0], &dim[1], &dim[2]); 02189 if(!err) texdim = TRUE; 02190 } 02191 else if(param->state == ps_jit_gl_shader_state_texdim6 ) 02192 { 02193 err = jit_gl_shader_get_texture_dim(x, 7, &dim[0], &dim[1], &dim[2]); 02194 if(!err) texdim = TRUE; 02195 } 02196 else if(param->state == ps_jit_gl_shader_state_texdim7 ) 02197 { 02198 err = jit_gl_shader_get_texture_dim(x, 8, &dim[0], &dim[1], &dim[2]); 02199 if(!err) texdim = TRUE; 02200 } 02201 02202 if(texdim) 02203 { 02204 t_atom a[4]; 02205 jit_atom_setfloat(a + 0, dim[0]); 02206 jit_atom_setfloat(a + 1, dim[1]); 02207 jit_atom_setfloat(a + 2, dim[2]); 02208 jit_atom_setfloat(a + 3, dim[3]); 02209 02210 // set defaults (up to 4 coordinates for arb) 02211 jit_gl_shader_param_setdefault(param, param->name, param->datasize, a); 02212 } 02213 } 02214 } 02215 02216 return err; 02217 } 02218 02219 02220 t_jit_err jit_gl_shader_get_texture_dim(t_jit_gl_shader *x, long n, GLfloat *width, GLfloat *height, GLfloat *depth) 02221 { 02222 long i = 0; 02223 long count = 0; 02224 t_jit_err err = JIT_ERR_GENERIC; 02225 t_symbol *texture[8]; 02226 t_symbol *name = NULL; 02227 t_jit_object *ob3d = NULL, *o = NULL; 02228 02229 long ac=0; 02230 t_atom *av=NULL; 02231 02232 if(x->bound) 02233 { 02234 for(i = 0; i < 8; i++) 02235 texture[i] = NULL; 02236 02237 // get requested texture name from array of ob3d bound textures 02238 ac = jit_attr_getsym_array(x->bound, ps_jit_gl_shader_texture, n, texture); 02239 if(ac && ac >= n && JIT_SYM_IF(texture[n-1])) 02240 { 02241 // find registered gl.texture object with given name 02242 o = jit_object_findregistered(texture[n-1]); 02243 if (o && jit_object_classname(o) == ps_jit_gl_texture) 02244 { 02245 // get texture dimensions 02246 *width = jit_attr_getlong(o, ps_jit_gl_texture_width); 02247 *height = jit_attr_getlong(o, ps_jit_gl_texture_height); 02248 *depth = jit_attr_getlong(o, ps_jit_gl_texture_depth); 02249 err = JIT_ERR_NONE; 02250 } 02251 } 02252 } 02253 return err; 02254 } 02255 02256 t_jit_err jit_gl_shader_get_flag_from_state(t_symbol *state, long *flag) 02257 { 02258 if(!state || !flag) 02259 return JIT_ERR_INVALID_PTR; 02260 02261 *flag = 0; 02262 if(state == _jit_sym_nothing) 02263 return JIT_ERR_NONE; 02264 02265 if(state == ps_jit_gl_shader_state_modelview_matrix) 02266 *flag = JIT_GL_SHADER_NEEDS_MODELVIEW_MATRIX; 02267 else if(state == ps_jit_gl_shader_state_projection_matrix) 02268 *flag = JIT_GL_SHADER_NEEDS_PROJECTION_MATRIX; 02269 else if(state == ps_jit_gl_shader_state_modelview_projection_matrix) 02270 *flag = JIT_GL_SHADER_NEEDS_MODELVIEW_PROJECTION_MATRIX; 02271 else if(state == ps_jit_gl_shader_state_texture_matrix) 02272 *flag = JIT_GL_SHADER_NEEDS_TEXTURE_MATRIX; 02273 else if(state == ps_jit_gl_shader_state_position) 02274 *flag = JIT_GL_SHADER_NEEDS_POSITION; 02275 else if(state == ps_jit_gl_shader_state_normal) 02276 *flag = JIT_GL_SHADER_NEEDS_NORMAL; 02277 else if(state == ps_jit_gl_shader_state_tangent) 02278 *flag = JIT_GL_SHADER_NEEDS_TANGENT; 02279 else if(state == ps_jit_gl_shader_state_bitangent) 02280 *flag = JIT_GL_SHADER_NEEDS_BITANGENT; 02281 else if(state == ps_jit_gl_shader_state_blendweight) 02282 *flag = JIT_GL_SHADER_NEEDS_BLENDWEIGHT; 02283 else if(state == ps_jit_gl_shader_state_color0) 02284 *flag = JIT_GL_SHADER_NEEDS_COLOR0; 02285 else if(state == ps_jit_gl_shader_state_color1) 02286 *flag = JIT_GL_SHADER_NEEDS_COLOR1; 02287 else if(state == ps_jit_gl_shader_state_diffuse) 02288 *flag = JIT_GL_SHADER_NEEDS_DIFFUSE; 02289 else if(state == ps_jit_gl_shader_state_specular) 02290 *flag = JIT_GL_SHADER_NEEDS_SPECULAR; 02291 else if(state == ps_jit_gl_shader_state_fogcoord) 02292 *flag = JIT_GL_SHADER_NEEDS_FOGCOORD; 02293 else if(state == ps_jit_gl_shader_state_texcoord0) 02294 *flag = JIT_GL_SHADER_NEEDS_TEXCOORD0; 02295 else if(state == ps_jit_gl_shader_state_texcoord1) 02296 *flag = JIT_GL_SHADER_NEEDS_TEXCOORD1; 02297 else if(state == ps_jit_gl_shader_state_texcoord2) 02298 *flag = JIT_GL_SHADER_NEEDS_TEXCOORD2; 02299 else if(state == ps_jit_gl_shader_state_texcoord3) 02300 *flag = JIT_GL_SHADER_NEEDS_TEXCOORD3; 02301 else if(state == ps_jit_gl_shader_state_texcoord4) 02302 *flag = JIT_GL_SHADER_NEEDS_TEXCOORD4; 02303 else if(state == ps_jit_gl_shader_state_texcoord5) 02304 *flag = JIT_GL_SHADER_NEEDS_TEXCOORD5; 02305 else if(state == ps_jit_gl_shader_state_texcoord6) 02306 *flag = JIT_GL_SHADER_NEEDS_TEXCOORD6; 02307 else if(state == ps_jit_gl_shader_state_texcoord7) 02308 *flag = JIT_GL_SHADER_NEEDS_TEXCOORD7; 02309 else 02310 return JIT_ERR_MISMATCH_TYPE; 02311 02312 return JIT_ERR_NONE; 02313 } 02314 02315 t_jit_err jit_gl_shader_compile(t_jit_gl_shader *x) 02316 { 02317 t_jit_err err = JIT_ERR_NONE; 02318 02319 // call appropriate language implementation 02320 if(x->backend == ps_jit_gl_shader_backend_asm) 02321 { 02322 err = jit_gl_shader_compile_asm(x); 02323 } 02324 else if(x->backend == ps_jit_gl_shader_backend_glsl) 02325 { 02326 err = jit_gl_shader_compile_glsl(x); 02327 if(x->backend != ps_jit_gl_shader_backend_glsl) 02328 return JIT_ERR_NONE; 02329 } 02330 else if(x->backend == ps_jit_gl_shader_backend_cg) 02331 { 02332 err = jit_gl_shader_compile_cg(x); 02333 } 02334 else 02335 { 02336 return JIT_ERR_MISMATCH_TYPE; 02337 } 02338 02339 if(err) 02340 jit_gl_shader_destroy(x); 02341 02342 02343 02344 return err; 02345 } 02346 02347 t_jit_err jit_gl_shader_link(t_jit_gl_shader *x) 02348 { 02349 t_jit_err err; 02350 02351 // call appropriate language implementation 02352 if(x->backend == ps_jit_gl_shader_backend_asm) 02353 { 02354 return jit_gl_shader_link_asm(x); 02355 } 02356 else if(x->backend == ps_jit_gl_shader_backend_glsl) 02357 { 02358 return jit_gl_shader_link_glsl(x); 02359 } 02360 else if(x->backend == ps_jit_gl_shader_backend_cg) 02361 { 02362 return jit_gl_shader_link_cg(x); 02363 } 02364 else 02365 { 02366 return JIT_ERR_MISMATCH_TYPE; 02367 } 02368 } 02369 02370 t_jit_err jit_gl_shader_bind(t_jit_gl_shader *x, t_symbol *s, int argc, t_atom *argv) 02371 { 02372 t_jit_err err; 02373 long i; 02374 t_atom a; 02375 t_symbol *bindname; 02376 void *target = NULL; 02377 02378 if(x->pending) 02379 { 02380 jit_atom_setsym(&a, x->filename); 02381 err = jit_gl_shader_read_jxs(x, NULL, 1, &a); 02382 if(err) return err; 02383 } 02384 02385 // get ob3d to bind to 02386 if(argc && argv) 02387 { 02388 x->bound = jit_atom_getobj(argv); 02389 } 02390 02391 // bind any textures 02392 for(i = 0; i < JIT_GL_MAX_TEXTUREUNITS; i++) 02393 { 02394 if(x->texture[i]) 02395 { 02396 t_symbol *tex_name = jit_object_findregisteredbyptr(x->texture[i]); 02397 02398 if(tex_name) { 02399 jit_atom_setlong(&a, i); 02400 jit_gl_texture_bind(x->texture[i], ps_jit_gl_bind, 1, &a); 02401 } 02402 } 02403 } 02404 02405 // link the shader if necessary 02406 if(x->id == JIT_GL_SHADER_INVALID) 02407 { 02408 t_jit_gl_context ctx; 02409 // cache context which may have been changed during shader destruction/compilation 02410 ctx = jit_gl_get_context(); 02411 02412 err = jit_gl_shader_compile(x); 02413 jit_gl_report_error("jit.gl.shader: error compiling"); 02414 02415 if(!err) { 02416 err = jit_gl_shader_link(x); 02417 jit_gl_report_error("jit.gl.shader: error linking"); 02418 } 02419 02420 // restore context which may have been changed during shader destruction/compilation 02421 jit_gl_set_context(ctx); 02422 02423 if(err) return err; 02424 } 02425 02426 // call appropriate backend implementation 02427 if(x->backend == ps_jit_gl_shader_backend_asm) 02428 { 02429 return jit_gl_shader_bind_asm(x); 02430 } 02431 else if(x->backend == ps_jit_gl_shader_backend_glsl) 02432 { 02433 return jit_gl_shader_bind_glsl(x); 02434 } 02435 else if(x->backend == ps_jit_gl_shader_backend_cg) 02436 { 02437 return jit_gl_shader_bind_cg(x); 02438 } 02439 else 02440 { 02441 return JIT_ERR_MISMATCH_TYPE; 02442 } 02443 02444 return JIT_ERR_NONE; 02445 } 02446 02447 t_jit_err jit_gl_shader_unbind(t_jit_gl_shader *x, t_symbol *s, int argc, t_atom *argv) 02448 { 02449 long i; 02450 t_atom a; 02451 t_jit_err err; 02452 02453 // unbind any textures 02454 for(i = 0; i < JIT_GL_MAX_TEXTUREUNITS; i++) 02455 { 02456 if(x->texture[i]) 02457 { 02458 t_symbol *tex_name = jit_object_findregisteredbyptr(x->texture[i]); 02459 02460 if(tex_name) { 02461 jit_atom_setlong(&a, i); 02462 jit_gl_texture_unbind(x->texture[i], ps_jit_gl_unbind, 1, &a); 02463 } 02464 } 02465 } 02466 02467 // clear binding 02468 x->bound = NULL; 02469 02470 // call appropriate language implementation 02471 if(x->backend == ps_jit_gl_shader_backend_asm) 02472 { 02473 return jit_gl_shader_unbind_asm(x); 02474 } 02475 else if(x->backend == ps_jit_gl_shader_backend_glsl) 02476 { 02477 return jit_gl_shader_unbind_glsl(x); 02478 } 02479 else if(x->backend == ps_jit_gl_shader_backend_cg) 02480 { 02481 return jit_gl_shader_unbind_cg(x); 02482 } 02483 else 02484 { 02485 return JIT_ERR_MISMATCH_TYPE; 02486 } 02487 02488 return JIT_ERR_NONE; 02489 } 02490 02491 t_jit_err jit_gl_shader_disable(t_jit_gl_shader *x) 02492 { 02493 long i; 02494 t_jit_err err = JIT_ERR_NONE; 02495 02496 // call appropriate backend implementation 02497 if(x->backend == ps_jit_gl_shader_backend_asm) 02498 { 02499 err = jit_gl_shader_destroy_asm(x); 02500 } 02501 else if(x->backend == ps_jit_gl_shader_backend_glsl) 02502 { 02503 err = jit_gl_shader_destroy_glsl(x); 02504 } 02505 else if(x->backend == ps_jit_gl_shader_backend_cg) 02506 { 02507 err = jit_gl_shader_destroy_cg(x); 02508 } 02509 02510 x->changed = TRUE; 02511 return err; 02512 } 02513 02514 t_jit_err jit_gl_shader_dump(t_jit_gl_shader *x, t_symbol *s, long argc, t_atom *argv) 02515 { 02516 02517 02518 // call appropriate language implementation 02519 if(x->backend == ps_jit_gl_shader_backend_asm) 02520 { 02521 return jit_gl_shader_dump_asm(x, s, argc, argv); 02522 } 02523 else if(x->backend == ps_jit_gl_shader_backend_glsl) 02524 { 02525 return jit_gl_shader_dump_glsl(x, s, argc, argv); 02526 } 02527 else if(x->backend == ps_jit_gl_shader_backend_cg) 02528 { 02529 return jit_gl_shader_dump_cg(x, s, argc, argv); 02530 } 02531 else 02532 { 02533 return JIT_ERR_MISMATCH_TYPE; 02534 } 02535 } 02536 02537 t_jit_err jit_gl_shader_dispose(t_jit_gl_shader *x) 02538 { 02539 if(x) 02540 { 02541 // destroy current shader 02542 return jit_gl_shader_destroy(x); 02543 } 02544 02545 return JIT_ERR_INVALID_PTR; 02546 } 02547 02548 t_jit_err jit_gl_shader_destroy(t_jit_gl_shader *x) 02549 { 02550 long i; 02551 t_jit_err err = JIT_ERR_NONE; 02552 t_jit_gl_context ctx = NULL; 02553 // set the current context 02554 02555 ctx = jit_gl_get_context(); 02556 err = jit_ob3d_set_context(x); 02557 if(err) goto cleanup; 02558 02559 // call appropriate backend implementation 02560 if(x->backend == ps_jit_gl_shader_backend_asm) 02561 { 02562 err = jit_gl_shader_destroy_asm(x); 02563 } 02564 else if(x->backend == ps_jit_gl_shader_backend_glsl) 02565 { 02566 err = jit_gl_shader_destroy_glsl(x); 02567 } 02568 else if(x->backend == ps_jit_gl_shader_backend_cg) 02569 { 02570 err = jit_gl_shader_destroy_cg(x); 02571 } 02572 02573 // reset all of the programs 02574 for(i = 0; i < x->programcount; i++) 02575 { 02576 err = jit_gl_shader_program_reset(x->program[i]); 02577 } 02578 02579 x->pending = FALSE; 02580 x->filename = NULL; 02581 x->bound = NULL; 02582 x->backend = NULL; 02583 x->language = NULL; 02584 x->changed = TRUE; 02585 x->context = NULL; 02586 x->handle = NULL; 02587 x->id = JIT_GL_SHADER_INVALID; 02588 02589 02590 for(i = 0; i < JIT_GL_MAX_TEXTUREUNITS; i++) 02591 { 02592 if(x->texture[i] && x->texturemanage[i]) 02593 { 02594 jit_object_free(x->texture[i]); 02595 } 02596 x->texture[i] = NULL; 02597 x->texturemanage[i] = FALSE; 02598 #ifdef WESLEY_NEW_SHADER_CODE 02599 x->textureparam[i] = NULL; 02600 #endif 02601 } 02602 x->texturecount = 0; 02603 02604 02605 cleanup: 02606 // restore context which may have been changed during shader destruction/compilation 02607 jit_gl_set_context(ctx); 02608 return err; 02609 } 02610 02611 t_jit_err jit_gl_shader_texture_passthru_enable(long rectangle) 02612 { 02613 static long initialized = FALSE; 02614 static GLuint programs[] = {0, 0}; 02615 02616 static const char* s_texture_rect_passthru = 02617 "!!ARBfp1.0\n" 02618 "TEX result.color, fragment.texcoord[0], texture[0], RECT;\n" 02619 "END\n"; 02620 02621 static const char* s_texture_2d_passthru = 02622 "!!ARBfp1.0\n" 02623 "TEX result.color, fragment.texcoord[0], texture[0], 2D;\n" 02624 "END\n"; 02625 02626 if(!initialized) 02627 { 02628 glGenProgramsARB(2, programs); 02629 glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, programs[0]); 02630 glProgramStringARB( 02631 GL_FRAGMENT_PROGRAM_ARB, 02632 GL_PROGRAM_FORMAT_ASCII_ARB, 02633 (GLsizei)strlen(s_texture_rect_passthru), 02634 s_texture_rect_passthru 02635 ); 02636 glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, programs[1]); 02637 glProgramStringARB( 02638 GL_FRAGMENT_PROGRAM_ARB, 02639 GL_PROGRAM_FORMAT_ASCII_ARB, 02640 (GLsizei)strlen(s_texture_2d_passthru), 02641 s_texture_2d_passthru 02642 ); 02643 initialized = TRUE; 02644 } 02645 02646 if(rectangle) 02647 { 02648 glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, programs[0]); 02649 } 02650 else 02651 { 02652 glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, programs[1]); 02653 } 02654 02655 glEnable(GL_FRAGMENT_PROGRAM_ARB); 02656 return JIT_ERR_NONE; 02657 } 02658 02659 t_jit_err jit_gl_shader_texture_passthru_disable() 02660 { 02661 glDisable(GL_FRAGMENT_PROGRAM_ARB); 02662 return JIT_ERR_NONE; 02663 } 02664 02665 t_jit_err jit_gl_shader_dump_program_params(t_jit_gl_shader *x, t_jit_gl_shader_program *p) 02666 { 02667 long i, j, c; 02668 float *fvalue = NULL; 02669 t_jit_gl_shader_param *param = NULL; 02670 02671 if(!x || !p) 02672 return JIT_ERR_MISMATCH_TYPE; 02673 02674 if(p->paramcount) 02675 { 02676 jit_object_post((t_object *)x,"-- START PARAMS: %s : %s -> %s --", JIT_SYM_SAFECSTR(x->language), JIT_SYM_SAFECSTR(p->name), JIT_SYM_SAFECSTR(p->filename)); 02677 for(j = 0; j < p->paramcount && p->param[j]; j++) 02678 { 02679 param = p->param[j]; 02680 if(param->fvalue) 02681 { 02682 if(JIT_SYM_IF(param->target)) 02683 { 02684 if(JIT_SYM_IF(param->state)) 02685 jit_object_post((t_object *)x,"state param: %s %dx%s: %s %s -> %s[%d] :", JIT_SYM_SAFECSTR(param->name), param->datacount, JIT_SYM_SAFECSTR(param->datatype), JIT_SYM_SAFECSTR(param->state), JIT_SYM_SAFECSTR(param->transform), JIT_SYM_SAFECSTR(param->target), param->id); 02686 else 02687 jit_object_post((t_object *)x," user param: %s %dx%s -> %s[%d] :", JIT_SYM_SAFECSTR(param->name), param->datacount, JIT_SYM_SAFECSTR(param->datatype), JIT_SYM_SAFECSTR(param->target), param->id); 02688 } 02689 else 02690 { 02691 if(JIT_SYM_IF(param->state)) 02692 jit_object_post((t_object *)x,"state param: %s %s : %s %s ", JIT_SYM_SAFECSTR(param->datatype), JIT_SYM_SAFECSTR(param->name), JIT_SYM_SAFECSTR(param->state), JIT_SYM_SAFECSTR(param->transform)); 02693 else 02694 jit_object_post((t_object *)x," user param: %s %s : ", JIT_SYM_SAFECSTR(param->datatype), JIT_SYM_SAFECSTR(param->name)); 02695 } 02696 for(c = 0; c < param->datacount; c++) 02697 { 02698 fvalue = ¶m->fvalue[c * param->datasize]; 02699 switch(param->datasize) 02700 { 02701 case 1: 02702 jit_object_post((t_object *)x," [ %f ]", 02703 fvalue[0]); 02704 break; 02705 case 2: 02706 jit_object_post((t_object *)x," [ %f %f ]", 02707 fvalue[0], fvalue[1]); 02708 break; 02709 case 3: 02710 jit_object_post((t_object *)x," [ %f %f %f ]", 02711 fvalue[0], fvalue[1], fvalue[2]); 02712 break; 02713 case 4: 02714 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02715 fvalue[0], fvalue[1], fvalue[2], fvalue[3]); 02716 break; 02717 case 8: 02718 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02719 fvalue[0], fvalue[1], fvalue[2], fvalue[3]); 02720 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02721 fvalue[4], fvalue[5], fvalue[6], fvalue[7]); 02722 break; 02723 case 9: 02724 jit_object_post((t_object *)x," [ %f %f %f ]", 02725 fvalue[0], fvalue[1], fvalue[2]); 02726 jit_object_post((t_object *)x," [ %f %f %f ]", 02727 fvalue[3], fvalue[4], fvalue[5]); 02728 jit_object_post((t_object *)x," [ %f %f %f ]", 02729 fvalue[6], fvalue[7], fvalue[8]); 02730 break; 02731 case 12: 02732 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02733 fvalue[0], fvalue[1], fvalue[2], fvalue[3]); 02734 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02735 fvalue[4], fvalue[5], fvalue[6], fvalue[7]); 02736 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02737 fvalue[8], fvalue[9], fvalue[10], fvalue[11]); 02738 break; 02739 case 16: 02740 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02741 fvalue[0], fvalue[1], fvalue[2], fvalue[3]); 02742 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02743 fvalue[4], fvalue[5], fvalue[6], fvalue[7]); 02744 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02745 fvalue[8], fvalue[9], fvalue[10], fvalue[11]); 02746 jit_object_post((t_object *)x," [ %f %f %f %f ]", 02747 fvalue[12], fvalue[13], fvalue[14], fvalue[15]); 02748 break; 02749 default: 02750 jit_object_post((t_object *)x," user param: %s %s", JIT_SYM_SAFECSTR(param->datatype), JIT_SYM_SAFECSTR(param->name)); 02751 break; 02752 }; 02753 } 02754 } 02755 else 02756 { 02757 jit_object_post((t_object *)x,"user param: %s %s", JIT_SYM_SAFECSTR(param->datatype), JIT_SYM_SAFECSTR(param->name)); 02758 } 02759 } 02760 jit_object_post((t_object *)x,"-- END PARAMS: %s : %s -> %s --", JIT_SYM_SAFECSTR(x->language), JIT_SYM_SAFECSTR(p->name), JIT_SYM_SAFECSTR(p->filename)); 02761 } 02762 else 02763 { 02764 jit_object_error((t_object *)x,"jit.gl.shader: program has no parameters defined: %s : %s -> %s", JIT_SYM_SAFECSTR(x->language), JIT_SYM_SAFECSTR(p->name), JIT_SYM_SAFECSTR(p->filename)); 02765 } 02766 02767 return JIT_ERR_NONE; 02768 } 02769 02770 t_jit_err jit_gl_shader_post_log(const char *log) 02771 { 02772 long i, j, p, n, k, pos; 02773 char line[1024]; 02774 const char *start = NULL; 02775 long length = strlen(log); 02776 02777 // output the listing 02778 if(length > 0) 02779 { 02780 p = 0; 02781 for(j = 0; j <= length && p < length; j++) 02782 { 02783 if(log[j] == '\r' || log[j] == '\n' || log[j] == '\0') 02784 { 02785 n = j - p + 1; 02786 start = log + p; 02787 pos = 0; 02788 for(k = 0; k < n && pos < 1024; k++) 02789 { 02790 // replace tabs with spaces 02791 if(start[k] == '\t') 02792 { 02793 line[pos++] = ' '; 02794 line[pos++] = ' '; 02795 line[pos++] = ' '; 02796 line[pos++] = ' '; 02797 } 02798 else 02799 { 02800 line[pos++] = start[k]; 02801 } 02802 } 02803 line[pos-1] = 0; 02804 error("%s", line); 02805 p += n; 02806 } 02807 } 02808 } 02809 return JIT_ERR_NONE; 02810 } 02811 02812 // -------------------------------------------------------------------------------- 02813 02814 long jit_str_begins_with(const char *test, const char *pattern) 02815 { 02816 unsigned long i; 02817 if (strlen(test) >= strlen(pattern)) 02818 { 02819 for (i = 0; i < strlen(pattern); ++i) 02820 { 02821 if (pattern[i] != test[i]) { 02822 return FALSE; 02823 } 02824 } 02825 return TRUE; 02826 } 02827 else 02828 { 02829 return FALSE; 02830 } 02831 }
Copyright © 2008, Cycling '74