Max5 API Reference

00001 /*
00002  * Copyright 2001-2005 - Cycling '74
00003  * Derek Gerstmann - derek@cycling74.com
00004  *
00005  * Generic object for creating an OpenGL texture from a matrix.
00006  *
00007  */
00008 
00009 #include "jit.gl.texture.h"
00010 #include "jit.gl.readback.h"
00011 
00012 /*************************************************************************/
00013 
00014 void *_jit_gl_texture_class;
00015 
00016 t_symbol *ps_jit_gl_texture_correction_fastest;
00017 t_symbol *ps_jit_gl_texture_correction_nicest;
00018 
00019 t_symbol *ps_jit_gl_colormode_alpha;
00020 t_symbol *ps_jit_gl_colormode_luminance;
00021 t_symbol *ps_jit_gl_colormode_intensity;
00022 t_symbol *ps_jit_gl_colormode_depth;
00023 t_symbol *ps_jit_gl_colormode_lumalpha;
00024 t_symbol *ps_jit_gl_colormode_rgb;
00025 t_symbol *ps_jit_gl_colormode_argb;
00026 t_symbol *ps_jit_gl_colormode_uyvy;
00027 t_symbol *ps_jit_gl_colormode_auto;
00028 
00029 t_symbol *ps_jit_gl_texture_adapt;
00030 
00031 t_symbol *ps_jit_gl_texture_apply_replace;
00032 t_symbol *ps_jit_gl_texture_apply_decal;
00033 t_symbol *ps_jit_gl_texture_apply_modulate;
00034 t_symbol *ps_jit_gl_texture_apply_blend;
00035 t_symbol *ps_jit_gl_texture_apply_combine;
00036 
00037 t_symbol *ps_jit_gl_texture_wrap_clamp;
00038 t_symbol *ps_jit_gl_texture_wrap_repeat;
00039 t_symbol *ps_jit_gl_texture_wrap_clampedge;
00040 t_symbol *ps_jit_gl_texture_wrap_clampborder;
00041 t_symbol *ps_jit_gl_texture_wrap_mirroredrepeat;
00042 
00043 t_symbol *ps_jit_gl_texture_mode_dynamic;
00044 t_symbol *ps_jit_gl_texture_mode_static;
00045 t_symbol *ps_jit_gl_texture_mode_capture;
00046 
00047 t_symbol *ps_jit_gl_texture_type_auto;
00048 t_symbol *ps_jit_gl_texture_type_char;
00049 t_symbol *ps_jit_gl_texture_type_long;
00050 t_symbol *ps_jit_gl_texture_type_half;
00051 t_symbol *ps_jit_gl_texture_type_float;     // same type as float32
00052 t_symbol *ps_jit_gl_texture_type_float16;   // same type as half
00053 t_symbol *ps_jit_gl_texture_type_float32;
00054 
00055 t_symbol *ps_jit_gl_texture_precision_half;
00056 t_symbol *ps_jit_gl_texture_precision_full;
00057 
00058 t_symbol *ps_jit_gl_texture_texgen_objectspace;
00059 t_symbol *ps_jit_gl_texture_texgen_eyespace;
00060 t_symbol *ps_jit_gl_texture_texgen_environment;
00061 t_symbol *ps_jit_gl_texture_texgen_projected;
00062 
00063 t_symbol *ps_jit_gl_texture_function_replace;
00064 t_symbol *ps_jit_gl_texture_function_modulate;
00065 t_symbol *ps_jit_gl_texture_function_add;
00066 t_symbol *ps_jit_gl_texture_function_addsigned;
00067 t_symbol *ps_jit_gl_texture_function_subtract;
00068 t_symbol *ps_jit_gl_texture_function_interpolate;
00069 t_symbol *ps_jit_gl_texture_function_dot3rgb;
00070 t_symbol *ps_jit_gl_texture_function_dot3rgba;
00071 
00072 t_symbol *ps_jit_gl_texture_source_texture;
00073 t_symbol *ps_jit_gl_texture_source_color;
00074 t_symbol *ps_jit_gl_texture_source_constant;
00075 t_symbol *ps_jit_gl_texture_source_previous;
00076 
00077 t_symbol *ps_jit_gl_texture_operand_color;
00078 t_symbol *ps_jit_gl_texture_operand_oneminuscolor;
00079 t_symbol *ps_jit_gl_texture_operand_alpha;
00080 t_symbol *ps_jit_gl_texture_operand_oneminusalpha;
00081 
00082 t_symbol *ps_jit_gl_texture_filter_none;
00083 t_symbol *ps_jit_gl_texture_filter_nearest;
00084 t_symbol *ps_jit_gl_texture_filter_linear;
00085 
00086 t_symbol *ps_jit_gl_texture_mipmap_none;
00087 t_symbol *ps_jit_gl_texture_mipmap_nearest;
00088 t_symbol *ps_jit_gl_texture_mipmap_linear;
00089 t_symbol *ps_jit_gl_texture_mipmap_bilinear;
00090 t_symbol *ps_jit_gl_texture_mipmap_trilinear;
00091 
00092 t_symbol *ps_jit_gl_texture_compress_none;
00093 t_symbol *ps_jit_gl_texture_compress_dxt1;
00094 t_symbol *ps_jit_gl_texture_compress_dxt3;
00095 t_symbol *ps_jit_gl_texture_compress_dxt5;
00096 
00097 t_symbol *ps_jit_gl_texture_checker;
00098 t_symbol *ps_jit_gl_texture_black;
00099 t_symbol *ps_jit_gl_texture_white;
00100 
00101 t_symbol *ps_jit_gl_texture_getmatrix;
00102 
00103 t_symbol *ps_jit_gl_readback_rtt;
00104 t_symbol *ps_jit_gl_readback_ctt;
00105 
00106 /*************************************************************************/
00107 
00108 t_jit_err jit_gl_texture_init(void)
00109 {
00110     long attrflags=0;
00111     long ob3d_flags=0;
00112     void *mop, *attr;
00113     void *ob3d;
00114     
00115     //load jit.openexr for openexr file support
00116     {
00117         void *c, *p;
00118         if (p=newinstance(gensym("jit.openexr"),0,NULL)) { 
00119             c = (void *)class_findbyname(gensym("jitter"),gensym("jit_openexr"));
00120             freeobject(p);
00121         }
00122         else {
00123             // not so common to need this, so don't complain until someone actually tries to load an OpenEXR file
00124             //error("jit.gl.texture: jit.openexr not found, openexr support unavailable");
00125         }
00126     }
00127 
00128     // create class
00129     _jit_gl_texture_class = jit_class_new("jit_gl_texture",(method)jit_gl_texture_new,(method)jit_gl_texture_free,
00130         sizeof(t_jit_gl_texture),A_DEFSYM,0L);
00131 
00132     // set up object extension for 3d object, customized with flags
00133     ob3d_flags |= JIT_OB3D_NO_ROTATION_SCALE;
00134     ob3d_flags |= JIT_OB3D_NO_POLY_VARS;
00135     ob3d_flags |= JIT_OB3D_NO_BLEND;
00136     ob3d_flags |= JIT_OB3D_NO_TEXTURE;
00137     ob3d_flags |= JIT_OB3D_NO_FOG;
00138     ob3d_flags |= JIT_OB3D_NO_LIGHTING_MATERIAL;
00139     ob3d_flags |= JIT_OB3D_NO_ANTIALIAS;
00140     ob3d_flags |= JIT_OB3D_NO_DEPTH;
00141     ob3d_flags |= JIT_OB3D_NO_COLOR;
00142     ob3d = jit_ob3d_setup(_jit_gl_texture_class, calcoffset(t_jit_gl_texture, ob3d), ob3d_flags);
00143     
00144     // add ob3d methods 
00145     jit_class_addmethod(_jit_gl_texture_class, (method)jit_object_register, "register", A_CANT, 0L);
00146     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_draw, "ob3d_draw", A_CANT, 0L);
00147     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_dest_changed, "dest_changed", A_CANT, 0L);
00148     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_dest_closing, "dest_closing", A_CANT, 0L);
00149 
00150     // methods to bind/unbind the texture
00151     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_bind, "bind", A_DEFER_LOW, 0L);
00152     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_unbind, "unbind", A_DEFER_LOW, 0L);
00153 
00154     // methods for forcing texture behavior externally (i.e. in jit.gl.cubemap)
00155     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_force_create, "force_create", A_CANT, 0L);
00156 
00157     // methods to capture/render to the texture
00158     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_setup_capture, "setup_capture", A_CANT, 0L);
00159     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_begin_capture, "begin_capture", A_DEFER_LOW, 0L);
00160     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_end_capture, "end_capture", A_DEFER_LOW, 0L);
00161     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_get_gl_context, "get_gl_context", A_CANT, 0L);
00162 
00163     // texture to texture copy
00164     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_copy, "jit_gl_texture", A_GIMME, 0L);
00165 
00166     // matrix methods
00167     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_jit_matrix, "jit_matrix", A_GIMME, 0L);
00168     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_tomatrix, "tomatrix", A_GIMME, 0L);
00169     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_subtex_matrix, "subtex_matrix", A_GIMME, 0L);
00170 
00171     // read method
00172     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_read, "read", A_GIMME, 0L);
00173     jit_class_addtypedwrapper(_jit_gl_texture_class, (method)jit_gl_texture_read_typed, "read", A_GIMMEBACK, 0L);
00174 
00175     // backwards compatible render to texture call 
00176     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_screen_grab, "screen_grab", A_CANT, 0L);
00177     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_depth_grab, "depth_grab", A_CANT, 0L);
00178 
00179     // notification if we're referencing a matrix or a readback buffer
00180     jit_class_addmethod(_jit_gl_texture_class, (method)jit_gl_texture_notify, "notify", A_CANT, 0L);
00181 
00182     // public attributes
00183     attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
00184     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dim",_jit_sym_long,3,attrflags,
00185         (method)0L,(method)jit_gl_texture_setattr_dim,NULL,calcoffset(t_jit_gl_texture,dim));
00186     jit_class_addattr(_jit_gl_texture_class,attr);
00187     attr = jit_object_new(_jit_sym_jit_attr_offset,"adapt",_jit_sym_long,attrflags,
00188         (method)0L,(method)jit_gl_texture_setattr_adapt,calcoffset(t_jit_gl_texture,adapt));
00189     jit_class_addattr(_jit_gl_texture_class,attr);
00190     attr = jit_object_new(_jit_sym_jit_attr_offset,"type",_jit_sym_symbol,attrflags,
00191         (method)0L,(method)jit_gl_texture_setattr_type,calcoffset(t_jit_gl_texture,type));
00192     jit_class_addattr(_jit_gl_texture_class,attr);
00193     attr = jit_object_new(_jit_sym_jit_attr_offset,"colormode",_jit_sym_symbol,attrflags,
00194         (method)0L,(method)jit_gl_texture_setattr_colormode,calcoffset(t_jit_gl_texture,colormode));
00195     jit_class_addattr(_jit_gl_texture_class,attr);
00196     attr = jit_object_new(_jit_sym_jit_attr_offset,"file",_jit_sym_symbol,attrflags,
00197         (method)0L,(method)jit_gl_texture_setattr_file,calcoffset(t_jit_gl_texture,file));
00198     jit_class_addattr(_jit_gl_texture_class,attr);
00199     attr = jit_object_new(_jit_sym_jit_attr_offset,"compress",_jit_sym_symbol,attrflags,
00200         (method)0L,(method)jit_gl_texture_setattr_compress,calcoffset(t_jit_gl_texture,compress));
00201     jit_class_addattr(_jit_gl_texture_class,attr);
00202     attr = jit_object_new(_jit_sym_jit_attr_offset,"mode",_jit_sym_symbol,attrflags,
00203         (method)0L,(method)jit_gl_texture_setattr_mode,calcoffset(t_jit_gl_texture,mode));
00204     jit_class_addattr(_jit_gl_texture_class,attr);
00205     attr = jit_object_new(_jit_sym_jit_attr_offset,"apply",_jit_sym_symbol,attrflags,
00206         (method)0L,(method)jit_gl_texture_setattr_apply,calcoffset(t_jit_gl_texture,apply));
00207     jit_class_addattr(_jit_gl_texture_class,attr);
00208     attr = jit_object_new(_jit_sym_jit_attr_offset,"rectangle",_jit_sym_long,attrflags,
00209         (method)0L,(method)jit_gl_texture_setattr_rectangle,calcoffset(t_jit_gl_texture,rectangle));
00210     jit_class_addattr(_jit_gl_texture_class,attr);
00211     attr = jit_object_new(_jit_sym_jit_attr_offset,"correction",_jit_sym_symbol,attrflags,
00212         (method)0L,(method)jit_gl_texture_setattr_correction,calcoffset(t_jit_gl_texture,correction));
00213     jit_class_addattr(_jit_gl_texture_class,attr);
00214     attr = jit_object_new(_jit_sym_jit_attr_offset,"filter",_jit_sym_symbol,attrflags,
00215         (method)0L,(method)jit_gl_texture_setattr_filter,calcoffset(t_jit_gl_texture,filter));
00216     jit_class_addattr(_jit_gl_texture_class,attr);
00217     attr = jit_object_new(_jit_sym_jit_attr_offset,"mipmap",_jit_sym_symbol,attrflags,
00218         (method)0L,(method)jit_gl_texture_setattr_mipmap,calcoffset(t_jit_gl_texture,mipmap));
00219     jit_class_addattr(_jit_gl_texture_class,attr);
00220     attr = jit_object_new(_jit_sym_jit_attr_offset,"texgen",_jit_sym_symbol,attrflags,
00221         (method)0L,(method)jit_gl_texture_setattr_texgen,calcoffset(t_jit_gl_texture,texgen));
00222     jit_class_addattr(_jit_gl_texture_class,attr);
00223     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"wrap",_jit_sym_symbol,3,attrflags,
00224         (method)0L,(method)jit_gl_texture_setattr_wrap,NULL,calcoffset(t_jit_gl_texture,wrap));
00225     jit_class_addattr(_jit_gl_texture_class,attr);
00226     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"function",_jit_sym_symbol,2,attrflags,
00227         (method)0L,(method)jit_gl_texture_setattr_function,NULL,calcoffset(t_jit_gl_texture,function));
00228     jit_class_addattr(_jit_gl_texture_class,attr);
00229     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"weight",_jit_sym_long,2,attrflags,
00230         (method)0L,(method)jit_gl_texture_setattr_weight,NULL,calcoffset(t_jit_gl_texture,weight));
00231     jit_class_addattr(_jit_gl_texture_class,attr);
00232     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"offset",_jit_sym_long,3,attrflags,
00233         (method)0L,(method)jit_gl_texture_setattr_offset,NULL,calcoffset(t_jit_gl_texture,offset));
00234     jit_class_addattr(_jit_gl_texture_class,attr);
00235     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"source",_jit_sym_symbol,6,attrflags,
00236         (method)0L,(method)jit_gl_texture_setattr_source,NULL,calcoffset(t_jit_gl_texture,source));
00237     jit_class_addattr(_jit_gl_texture_class,attr);
00238     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"operand",_jit_sym_symbol,6,attrflags,
00239         (method)0L,(method)jit_gl_texture_setattr_operand,NULL,calcoffset(t_jit_gl_texture,operand));
00240     jit_class_addattr(_jit_gl_texture_class,attr);
00241     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"bordercolor",_jit_sym_float32,4,attrflags,
00242         (method)0L,(method)jit_gl_texture_setattr_bordercolor,NULL,calcoffset(t_jit_gl_texture,bordercolor));
00243     jit_class_addattr(_jit_gl_texture_class,attr);
00244     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"blendcolor",_jit_sym_float32,4,attrflags,
00245         (method)0L,(method)jit_gl_texture_setattr_blendcolor,NULL,calcoffset(t_jit_gl_texture,blendcolor));
00246     jit_class_addattr(_jit_gl_texture_class,attr);
00247     attr = jit_object_new(_jit_sym_jit_attr_offset,"anisotropy",_jit_sym_long,attrflags,
00248         (method)0L,(method)jit_gl_texture_setattr_anisotropy,calcoffset(t_jit_gl_texture,anisotropy));
00249     jit_class_addattr(_jit_gl_texture_class,attr);
00250     attr = jit_object_new(_jit_sym_jit_attr_offset,"priority",_jit_sym_float32,attrflags,
00251         (method)0L,(method)jit_gl_texture_setattr_priority,calcoffset(t_jit_gl_texture,priority));
00252     jit_class_addattr(_jit_gl_texture_class,attr);
00253     attr = jit_object_new(_jit_sym_jit_attr_offset,"flip",_jit_sym_long,attrflags,
00254         (method)0L,(method)jit_gl_texture_setattr_flip,calcoffset(t_jit_gl_texture,flip));
00255     jit_class_addattr(_jit_gl_texture_class,attr);
00256     attr = jit_object_new(_jit_sym_jit_attr_offset,"debug",_jit_sym_long,attrflags,
00257         (method)0L,(method)jit_gl_texture_setattr_debug,calcoffset(t_jit_gl_texture,debug));
00258     jit_class_addattr(_jit_gl_texture_class,attr);
00259     attr = jit_object_new(_jit_sym_jit_attr_offset,"autoscale",_jit_sym_long,attrflags,
00260         (method)0L,(method)jit_gl_texture_setattr_autoscale,calcoffset(t_jit_gl_texture,autoscale));
00261     jit_class_addattr(_jit_gl_texture_class,attr);
00262     attr = jit_object_new(_jit_sym_jit_attr_offset,"share",_jit_sym_long,attrflags,
00263         (method)0L,(method)jit_gl_texture_setattr_share,calcoffset(t_jit_gl_texture,share));
00264     jit_class_addattr(_jit_gl_texture_class,attr);
00265     attr = jit_object_new(_jit_sym_jit_attr_offset,"defaultimage",_jit_sym_symbol,attrflags,
00266         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,defaultimage));
00267     jit_class_addattr(_jit_gl_texture_class,attr);
00268     attr = jit_object_new(_jit_sym_jit_attr_offset,"capture_depthbits",_jit_sym_long,attrflags,
00269         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,capture_depthbits));
00270     jit_class_addattr(_jit_gl_texture_class,attr);
00271     attr = jit_object_new(_jit_sym_jit_attr_offset,"capture_buffer",_jit_sym_symbol,attrflags,
00272         (method)0L,(method)jit_gl_texture_setattr_capture_buffer,calcoffset(t_jit_gl_texture,capture_buffer));
00273     jit_class_addattr(_jit_gl_texture_class,attr);
00274     attr = jit_object_new(_jit_sym_jit_attr_offset,"capture_source",_jit_sym_symbol,attrflags,
00275         (method)0L,(method)jit_gl_texture_setattr_capture_source,calcoffset(t_jit_gl_texture,capture_source));
00276     jit_class_addattr(_jit_gl_texture_class,attr);
00277     attr = jit_object_new(_jit_sym_jit_attr_offset,"compare_mode",_jit_sym_symbol,attrflags,
00278         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,compare_mode));
00279     jit_class_addattr(_jit_gl_texture_class,attr);
00280     attr = jit_object_new(_jit_sym_jit_attr_offset,"compare_func",_jit_sym_symbol,attrflags,
00281         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,compare_func));
00282     jit_class_addattr(_jit_gl_texture_class,attr);
00283     attr = jit_object_new(_jit_sym_jit_attr_offset,"texture_mode",_jit_sym_symbol,attrflags,
00284         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,texture_mode));
00285     jit_class_addattr(_jit_gl_texture_class,attr);
00286     
00287     
00288     // matrix-like subimage data attrs
00289     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"srcdimstart",_jit_sym_long,3,attrflags,
00290         (method)0L,(method)0L,NULL,calcoffset(t_jit_gl_texture,srcdimstart));
00291     jit_class_addattr(_jit_gl_texture_class,attr);
00292     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"srcdimend",_jit_sym_long,3,attrflags,
00293         (method)0L,(method)0L,NULL,calcoffset(t_jit_gl_texture,srcdimend));
00294     jit_class_addattr(_jit_gl_texture_class,attr);
00295     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dstdimstart",_jit_sym_long,3,attrflags,
00296         (method)0L,(method)0L,NULL,calcoffset(t_jit_gl_texture,dstdimstart));
00297     jit_class_addattr(_jit_gl_texture_class,attr);
00298     attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dstdimend",_jit_sym_long,3,attrflags,
00299         (method)0L,(method)0L,NULL,calcoffset(t_jit_gl_texture,dstdimend));
00300     jit_class_addattr(_jit_gl_texture_class,attr);
00301     attr = jit_object_new(_jit_sym_jit_attr_offset,"usesrcdim",_jit_sym_long,attrflags,
00302         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,usesrcdim));
00303     jit_class_addattr(_jit_gl_texture_class,attr);
00304     attr = jit_object_new(_jit_sym_jit_attr_offset,"usedstdim",_jit_sym_long,attrflags,
00305         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,usedstdim));
00306     jit_class_addattr(_jit_gl_texture_class,attr);
00307 
00308     // private attributes
00309     attrflags = JIT_ATTR_GET_OPAQUE_USER | JIT_ATTR_SET_OPAQUE_USER;
00310     attr = jit_object_new(_jit_sym_jit_attr_offset,"width",_jit_sym_long,attrflags,
00311         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,width));
00312     jit_class_addattr(_jit_gl_texture_class,attr);
00313     attr = jit_object_new(_jit_sym_jit_attr_offset,"height",_jit_sym_long,attrflags,
00314         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,height));
00315     jit_class_addattr(_jit_gl_texture_class,attr);
00316     attr = jit_object_new(_jit_sym_jit_attr_offset,"depth",_jit_sym_long,attrflags,
00317         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,depth));
00318     jit_class_addattr(_jit_gl_texture_class,attr);
00319     attr = jit_object_new(_jit_sym_jit_attr_offset,"gltarget",_jit_sym_long,attrflags,
00320         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,target));
00321     jit_class_addattr(_jit_gl_texture_class,attr);
00322     attr = jit_object_new(_jit_sym_jit_attr_offset,"gldatatype",_jit_sym_long,attrflags,
00323         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,datatype));
00324     jit_class_addattr(_jit_gl_texture_class,attr);
00325     attr = jit_object_new(_jit_sym_jit_attr_offset,"gldatasize",_jit_sym_long,attrflags,
00326         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,datasize));
00327     jit_class_addattr(_jit_gl_texture_class,attr);
00328     attr = jit_object_new(_jit_sym_jit_attr_offset,"glformat",_jit_sym_long,attrflags,
00329         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,format));
00330     jit_class_addattr(_jit_gl_texture_class,attr);
00331     attr = jit_object_new(_jit_sym_jit_attr_offset,"glinternal",_jit_sym_long,attrflags,
00332         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,internal));
00333     jit_class_addattr(_jit_gl_texture_class,attr);
00334     attr = jit_object_new(_jit_sym_jit_attr_offset,"glid",_jit_sym_long,attrflags,
00335         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,bindid));
00336     jit_class_addattr(_jit_gl_texture_class,attr);
00337     attr = jit_object_new(_jit_sym_jit_attr_offset,"capturing",_jit_sym_long,attrflags,
00338         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,capturing));
00339     jit_class_addattr(_jit_gl_texture_class,attr);
00340     attr = jit_object_new(_jit_sym_jit_attr_offset,"cubemap_face",_jit_sym_long,attrflags,
00341         (method)0L,(method)0L,calcoffset(t_jit_gl_texture,cubemap_face));
00342     jit_class_addattr(_jit_gl_texture_class,attr);
00343 
00344     // register class
00345     jit_class_register(_jit_gl_texture_class);
00346 
00347     // generate symbols
00348     ps_jit_gl_texture_correction_fastest = gensym("fastest");
00349     ps_jit_gl_texture_correction_nicest = gensym("nicest");
00350 
00351     ps_jit_gl_colormode_alpha = gensym("alpha");
00352     ps_jit_gl_colormode_depth = gensym("depth");
00353     ps_jit_gl_colormode_alpha = gensym("intensity");
00354     ps_jit_gl_colormode_luminance = gensym("luminance");
00355     ps_jit_gl_colormode_lumalpha = gensym("lumalpha");
00356     ps_jit_gl_colormode_rgb = gensym("rgb");
00357     ps_jit_gl_colormode_argb = gensym("argb");
00358     ps_jit_gl_colormode_uyvy = gensym("uyvy");
00359     ps_jit_gl_colormode_auto = gensym("auto");
00360 
00361     ps_jit_gl_texture_apply_replace = gensym("replace");
00362     ps_jit_gl_texture_apply_decal = gensym("decal");
00363     ps_jit_gl_texture_apply_modulate = gensym("modulate");
00364     ps_jit_gl_texture_apply_blend = gensym("blend");
00365     ps_jit_gl_texture_apply_combine = gensym("combine");
00366     
00367     ps_jit_gl_texture_mode_dynamic = gensym("dynamic");
00368     ps_jit_gl_texture_mode_static = gensym("static");
00369     ps_jit_gl_texture_mode_capture = gensym("capture");
00370 
00371     ps_jit_gl_texture_type_auto = gensym("auto");
00372     ps_jit_gl_texture_type_char = gensym("char");
00373     ps_jit_gl_texture_type_long = gensym("long");
00374     ps_jit_gl_texture_type_half = gensym("half");
00375     ps_jit_gl_texture_type_float = gensym("float");
00376     ps_jit_gl_texture_type_float16 = gensym("float16");
00377     ps_jit_gl_texture_type_float32 = gensym("float32");
00378 
00379     ps_jit_gl_texture_wrap_clamp = gensym("clamp");
00380     ps_jit_gl_texture_wrap_repeat = gensym("repeat");
00381     ps_jit_gl_texture_wrap_clampedge = gensym("clampedge");
00382     ps_jit_gl_texture_wrap_clampborder = gensym("clampborder");
00383     ps_jit_gl_texture_wrap_mirroredrepeat = gensym("mirroredrepeat");
00384     
00385     ps_jit_gl_texture_texgen_objectspace = gensym("objectspace");
00386     ps_jit_gl_texture_texgen_eyespace = gensym("eyespace");
00387     ps_jit_gl_texture_texgen_environment = gensym("environment");
00388     ps_jit_gl_texture_texgen_projected = gensym("projected");
00389 
00390     ps_jit_gl_texture_function_replace = gensym("replace");
00391     ps_jit_gl_texture_function_modulate = gensym("modulate");
00392     ps_jit_gl_texture_function_add = gensym("add");
00393     ps_jit_gl_texture_function_addsigned = gensym("addsigned");
00394     ps_jit_gl_texture_function_subtract = gensym("subtract");
00395     ps_jit_gl_texture_function_interpolate = gensym("interpolate");
00396     ps_jit_gl_texture_function_dot3rgb = gensym("dot3rgb");
00397     ps_jit_gl_texture_function_dot3rgba = gensym("dot3rgba");
00398 
00399     ps_jit_gl_texture_source_texture = gensym("texture");
00400     ps_jit_gl_texture_source_color = gensym("color");
00401     ps_jit_gl_texture_source_constant = gensym("constant");
00402     ps_jit_gl_texture_source_previous = gensym("previous");
00403 
00404     ps_jit_gl_texture_operand_color = gensym("color");
00405     ps_jit_gl_texture_operand_oneminuscolor = gensym("oneminuscolor");
00406     ps_jit_gl_texture_operand_alpha = gensym("alpha");
00407     ps_jit_gl_texture_operand_oneminusalpha = gensym("oneminusalpha");
00408 
00409     ps_jit_gl_texture_filter_none = gensym("none");
00410     ps_jit_gl_texture_filter_nearest = gensym("nearest");
00411     ps_jit_gl_texture_filter_linear = gensym("linear");
00412 
00413     ps_jit_gl_texture_mipmap_none = gensym("none");
00414     ps_jit_gl_texture_mipmap_nearest = gensym("nearest");
00415     ps_jit_gl_texture_mipmap_linear = gensym("linear");
00416     ps_jit_gl_texture_mipmap_bilinear = gensym("bilinear");
00417     ps_jit_gl_texture_mipmap_trilinear = gensym("trilinear");
00418 
00419     ps_jit_gl_texture_compare_mode_none = gensym("none");
00420     ps_jit_gl_texture_compare_mode_compare_r_to_texture = gensym("compare_r_to_texture");
00421 
00422     ps_jit_gl_texture_compare_func_lequal = gensym("lequal");
00423     ps_jit_gl_texture_compare_func_gequal = gensym("gequal");
00424     ps_jit_gl_texture_compare_func_less = gensym("less");
00425     ps_jit_gl_texture_compare_func_greater = gensym("greater");
00426     ps_jit_gl_texture_compare_func_equal = gensym("equal");
00427     ps_jit_gl_texture_compare_func_notequal = gensym("notequal");
00428     ps_jit_gl_texture_compare_func_always = gensym("always");
00429     ps_jit_gl_texture_compare_func_never = gensym("never");
00430 
00431     ps_jit_gl_texture_texture_mode_luminance = gensym("luminance");
00432     ps_jit_gl_texture_texture_mode_intensity = gensym("intensity");
00433     ps_jit_gl_texture_texture_mode_alpha = gensym("alpha");
00434 
00435     ps_jit_gl_texture_compress_none = gensym("none");
00436     ps_jit_gl_texture_compress_dxt1 = gensym("dxt1");
00437     ps_jit_gl_texture_compress_dxt3 = gensym("dxt3");
00438     ps_jit_gl_texture_compress_dxt5 = gensym("dxt5");
00439 
00440     ps_jit_gl_texture_checker = gensym("checker");
00441     ps_jit_gl_texture_black = gensym("black");
00442     ps_jit_gl_texture_white = gensym("white");
00443 
00444     ps_jit_gl_texture_getmatrix = gensym("getmatrix");
00445 
00446     ps_jit_gl_readback_rtt = gensym("rtt");
00447     ps_jit_gl_readback_ctt = gensym("ctt");
00448     ps_capture_complete = gensym("capture_complete");
00449     ps_depth = gensym("depth");
00450     ps_color = gensym("color");
00451     ps_capture_source = gensym("capture_source");
00452     ps_free = gensym("free");
00453 
00454     // init the half lookup table
00455     jit_half_init();
00456     return JIT_ERR_NONE;
00457 }
00458 
00459 t_jit_gl_texture *jit_gl_texture_new(t_symbol * dest_name)
00460 {
00461     long i, j, p;
00462     long size;
00463     float temp;
00464     t_jit_gl_texture *x;
00465 
00466     if (x=(t_jit_gl_texture *)jit_object_alloc(_jit_gl_texture_class)) 
00467     {
00468 
00469         // create and attach ob3d
00470         jit_ob3d_new(x, dest_name);
00471         
00472         // set instance variable defaults
00473         x->id = -1;
00474         x->dim[0] = JIT_GL_TEXTURE_DEFAULT_WIDTH;
00475         x->dim[1] = JIT_GL_TEXTURE_DEFAULT_HEIGHT;
00476         x->dim[2] = 0;
00477         x->adapt = TRUE;
00478         x->matrix = NULL;
00479         x->uyvy2argb = NULL;
00480         x->update = TRUE;
00481         x->recreate = FALSE;
00482         x->reuse = FALSE;
00483         x->rectangle = TRUE;
00484         x->flip = TRUE;
00485         x->debug = FALSE;
00486         x->autoscale = TRUE;
00487         x->share = TRUE;
00488         x->compress = _jit_sym_nothing;
00489         x->type = ps_jit_gl_texture_type_auto;
00490         x->colormode = ps_jit_gl_colormode_auto;
00491 #ifdef WIN_VERSION
00492         x->mode = ps_jit_gl_texture_mode_static;
00493 #else
00494         x->mode = ps_jit_gl_texture_mode_dynamic;
00495 #endif
00496         x->target = GL_TEXTURE_2D;
00497 
00498         x->priority = 0;
00499         x->format = 0;
00500         x->internal = 0;
00501         x->datatype = 0;
00502         x->datasize = 0;
00503         x->texsize = 0;
00504         x->destroy = FALSE;
00505         x->blendcolor[0] = x->blendcolor[1] = x->blendcolor[2] = 0.0;
00506         x->blendcolor[3] = 1.0;
00507         x->bordercolor[0] = x->bordercolor[1] = x->bordercolor[2] = 0.5;
00508         x->bordercolor[3] = 1.0;
00509         x->border = FALSE;
00510         x->correction = ps_jit_gl_texture_correction_nicest;
00511         x->apply = ps_jit_gl_texture_apply_modulate;
00512 
00513         x->wrap[0] = ps_jit_gl_texture_wrap_clampedge;
00514         x->wrap[1] = ps_jit_gl_texture_wrap_clampedge;
00515         x->wrap[2] = ps_jit_gl_texture_wrap_clampedge;
00516         
00517         x->filter = ps_jit_gl_texture_filter_linear;
00518         x->mipmap = ps_jit_gl_texture_mipmap_none;
00519         x->texgen = _jit_sym_nothing;
00520         x->file = _jit_sym_nothing;
00521 
00522         // function defaults
00523         x->function[0] = ps_jit_gl_texture_function_replace;
00524         x->function[1] = ps_jit_gl_texture_function_replace;
00525 
00526         // rgb defaults
00527         x->source[0] = ps_jit_gl_texture_source_texture;
00528         x->source[2] = ps_jit_gl_texture_source_texture;
00529         x->source[4] = ps_jit_gl_texture_source_texture;
00530         x->operand[0] = ps_jit_gl_texture_operand_color;
00531         x->operand[2] = ps_jit_gl_texture_operand_color;
00532         x->operand[4] = ps_jit_gl_texture_operand_color;
00533 
00534         // rgb defaults
00535         x->source[1] = ps_jit_gl_texture_source_color;
00536         x->source[3] = ps_jit_gl_texture_source_color;
00537         x->source[5] = ps_jit_gl_texture_source_color;
00538         x->operand[1] = ps_jit_gl_texture_operand_alpha;
00539         x->operand[3] = ps_jit_gl_texture_operand_alpha;
00540         x->operand[5] = ps_jit_gl_texture_operand_alpha;
00541 
00542         // weight defaults
00543         x->weight[0] = 1;
00544         x->weight[1] = 1;
00545 
00546         // offset defaults
00547         x->offset[0] = 0;
00548         x->offset[1] = 0;
00549         x->offset[2] = 0;
00550         
00551         x->anisotropy = 0;
00552         
00553         x->defaultimage = ps_jit_gl_texture_checker;
00554 
00555         // hardware pixel buffer object defaults
00556         x->pbo = NULL;
00557 
00558         // local pixel buffer defaults
00559         x->pixels = 0;
00560         x->pixelbytes = 0;
00561         x->pixelcount = 0;
00562     
00563         x->newpixels = FALSE;
00564         x->alignment = 1;
00565         x->rowlength = 1;
00566         for (i=0;i<MAX_TEXTURE_UNITS;i++)
00567             x->bound[i] = 0;
00568     
00569         // referenced texture vals
00570         x->refmatname = _jit_sym_nothing;
00571         x->refmatsize = 0;
00572         x->refmatrowlength = 0;
00573     
00574         // capture defaults
00575         x->capturing = JIT_GL_TEXTURE_CAPTURE_DISABLED;
00576         x->support = NULL;  
00577         x->gencontext = NULL;
00578 
00579         // readback matrix
00580         x->readbackmatrix = NULL;
00581         x->readback = NULL;
00582         x->bindid = 0;
00583         x->capture_depthbits = 16;
00584         x->capture_buffer = ps_color;
00585         x->capture_source = _jit_sym_nothing;
00586         x->capture_attached = 0;
00587         
00588         //depth texture parameters
00589         x->compare_mode = ps_jit_gl_texture_compare_mode_none;
00590         x->compare_func = ps_jit_gl_texture_compare_func_lequal;
00591         x->texture_mode = ps_jit_gl_texture_texture_mode_luminance;
00592         x->cubemap_face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
00593         x->submitted = 0;
00594 
00595 
00596         // matrix-like subimage data attrs
00597         x->srcdimstart[0] = 0;
00598         x->srcdimstart[1] = 0;
00599         x->srcdimstart[2] = 0;
00600         
00601         x->srcdimend[0] = 320;
00602         x->srcdimend[1] = 240;
00603         x->srcdimend[2] = 1;
00604         
00605         x->dstdimstart[0] = 0;
00606         x->dstdimstart[1] = 0;
00607         x->dstdimstart[2] = 0;
00608         
00609         x->dstdimend[0] = 320;
00610         x->dstdimend[1] = 240;
00611         x->dstdimend[2] = 1;
00612         
00613         x->usesrcdim = 0;
00614         x->usedstdim = 0;
00615         
00616         x->subtex_matrix = NULL;
00617         x->subtex_submission = FALSE;
00618         // allocate new cached matrix
00619         {
00620             t_jit_matrix_info info;
00621             
00622             info.dimcount = 2;
00623             info.dim[0] = 320;
00624             info.dim[1] = 240;
00625             info.dim[3] = 1;
00626             info.type = _jit_sym_char;
00627             info.planecount = 4;
00628             info.flags = JIT_MATRIX_DATA_PACK_TIGHT;
00629             x->subtex_matrix = jit_object_new(_jit_sym_jit_matrix, &info);
00630         }
00631 
00632         jit_gl_texture_recalc(x);
00633         jit_attr_setsym(x,_jit_sym_name,jit_symbol_unique());       
00634 
00635         jit_attr_setlong(x,gensym("automatic"),0);  
00636         jit_attr_setlong(x,gensym("layer"),-999999);
00637     
00638     } else {
00639         x = NULL;
00640     }
00641     return x;
00642 }
00643 
00644 void jit_gl_texture_free(t_jit_gl_texture *x)
00645 {
00646     GLuint id;
00647 
00648     if (x->refmatname!=_jit_sym_nothing) 
00649     {
00650         jit_object_detach(x->refmatname,x);
00651         x->refmatname = _jit_sym_nothing;
00652     }
00653 
00654     jit_gl_texture_destroy(x);
00655 
00656     if(x->matrix)
00657         jit_object_free(x->matrix);
00658 
00659     if(x->pbo)
00660         jit_gl_pbo_free(x->pbo);
00661     x->pbo = NULL;
00662 
00663     if (x->uyvy2argb)
00664         jit_object_free(x->uyvy2argb);
00665 
00666     if(x->readback)
00667         jit_gl_readback_free(x->readback);
00668     x->readback = NULL;
00669 
00670     if(x->subtex_matrix)
00671         jit_object_free(x->subtex_matrix);
00672     x->subtex_matrix = NULL;
00673 
00674     jit_ob3d_free(x);
00675 }
00676 
00677 void jit_gl_texture_destroy(t_jit_gl_texture *x)
00678 {
00679     GLuint id;
00680     t_jit_gl_context pbctx = NULL, txctx = NULL;
00681     x->submitted = 0;
00682     if (jit_ob3d_set_context(x) == JIT_ERR_NONE) 
00683     {
00684         jit_gl_texture_destroy_data(x);
00685         jit_gl_texture_destroy_readback(x);
00686 
00687         if(x->pbo)
00688         {
00689             jit_gl_pbo_free(x->pbo);
00690             x->pbo = NULL;
00691         }
00692     }
00693 }
00694 
00695 void jit_gl_texture_destroy_existing(t_jit_gl_texture *x)
00696 {
00697     x->submitted = 0;
00698     TEXTURE_VERBOSE_POST("destroying data...");
00699     jit_gl_texture_destroy_data(x);
00700     TEXTURE_VERBOSE_POST("destroying readback...");
00701     jit_gl_texture_destroy_readback(x);
00702 
00703     if(x->recreate)
00704     {
00705         jit_gl_texture_rematrix(x);
00706         jit_gl_texture_recalc(x);
00707     }
00708 
00709     x->newpixels = FALSE;
00710     x->destroy = FALSE;
00711     x->recreate = FALSE;
00712     x->reuse = FALSE;
00713     x->update = FALSE;
00714 }
00715 
00716 void jit_gl_texture_destroy_data(t_jit_gl_texture *x)
00717 {
00718     GLuint id;
00719     if(x->id > 0)
00720     {
00721         id = x->id;
00722         glDisable(x->target);
00723         glDeleteTextures(1, &id);
00724         x->id = -1;
00725     }
00726 
00727     jit_gl_texture_destroy_pixels(x);
00728 }
00729 
00730 void jit_gl_texture_destroy_readback(t_jit_gl_texture *x)
00731 {
00732     if(x->readback)
00733     {
00734         if(x->capturing == JIT_GL_TEXTURE_CAPTURE_READBACK)
00735             jit_gl_readback_unbind(x->readback);
00736 
00737         jit_gl_readback_free(x->readback);
00738     }
00739     x->readback = NULL;
00740 }
00741 
00742 void jit_gl_texture_destroy_pixels(t_jit_gl_texture *x)
00743 {
00744     if(x->pixels && x->pixelbytes)
00745         jit_freebytes(x->pixels, x->pixelbytes);
00746     x->pixels = NULL;
00747     x->pixelbytes = 0;
00748 }
00749 
00750 t_jit_err jit_gl_texture_generate(t_jit_gl_texture *x)
00751 {
00752     GLuint id;
00753 
00754     if(x->id < 0)
00755     {
00756         glGenTextures(1,&id);
00757         x->gencontext = jit_gl_get_context();
00758         x->id = id;
00759     }
00760 
00761     return JIT_ERR_NONE;
00762 }
00763 
00764 /*************************************************************************/
00765 
00766 t_jit_err jit_gl_texture_dest_closing(t_jit_gl_texture *x)
00767 {
00768     if (x->id > 0) 
00769     {
00770         x->update = 1;
00771     }
00772 
00773     x->support = jit_gl_get_support();
00774 
00775     jit_gl_texture_destroy(x);
00776 
00777     return JIT_ERR_NONE;
00778 }
00779 
00780 t_jit_err jit_gl_texture_draw(t_jit_gl_texture *x)
00781 {
00782     GLuint id = 0;
00783     t_jit_err result = JIT_ERR_NONE;
00784     
00785     //x->support = jit_gl_get_support();
00786     
00787     if(x->debug)
00788     {
00789         jit_gl_texture_bind(x, 0, 0, 0);
00790         jit_gl_texture_draw_quad(x, -1, -1, 1, 1);
00791         jit_gl_texture_unbind(x, 0, 0, 0);
00792     }
00793 
00794     return result;
00795 }
00796 
00797 t_jit_err jit_gl_texture_draw_quad(t_jit_gl_texture *x, float x0, float y0, float x1, float y1)
00798 {
00799     glBegin(GL_QUADS);
00800     {
00801         glTexCoord2f(0,0);
00802         glVertex2f(x0,y0);
00803         glTexCoord2f(1,0);
00804         glVertex2f(x1,y0);
00805         glTexCoord2f(1,1);
00806         glVertex2f(x1,y1);
00807         glTexCoord2f(0,1);
00808         glVertex2f(x0,y1);
00809     }
00810     glEnd();
00811 
00812     return JIT_ERR_NONE;
00813 }
00814 
00815 t_jit_err jit_gl_texture_dest_changed(t_jit_gl_texture *x)
00816 {
00817     x->support = jit_gl_get_support();
00818     
00819     if (x->id > 0) 
00820     {
00821         x->update = TRUE;
00822         // x->destroy = TRUE;
00823     }
00824 
00825     jit_attr_setsym(x, ps_capture_source, x->capture_source);
00826 
00827     return JIT_ERR_NONE;
00828 }
00829 
00830 t_jit_err jit_gl_texture_read(t_jit_gl_texture *x, t_symbol *s, long argc, t_atom *argv)
00831 {
00832     void *matrix;
00833     t_atom at[2];
00834     t_atom rv;
00835     t_symbol *modewas;
00836     t_symbol *filename;
00837     
00838     if(!x)
00839         return JIT_ERR_INVALID_PTR;
00840 
00841     // allocate new temp load matrix
00842     matrix = jit_object_new(gensym("jit_matrix_wrapper"),NULL,0,NULL);
00843     if(!matrix)
00844     {
00845         jit_object_error((t_object *)x,"jit.gl.texture: unable to load file: out of memory!");
00846         return JIT_ERR_GENERIC;
00847     }
00848 
00849     filename = jit_atom_getsym(argv);
00850     if( strcmp(".exr", filename->s_name + (strlen(filename->s_name)-4)) == 0) {
00851         //use openexr object for openexr files
00852         void *openexr = jit_object_new(gensym("jit_openexr"));
00853         if(!openexr) {
00854             jit_object_free(matrix);
00855             jit_object_error((t_object *)x,"jit.gl.texture: unable to load OpenEXR file. requires jit.openexr in search path");
00856             return JIT_ERR_GENERIC;
00857         }
00858         jit_attr_setlong(openexr, gensym("verbose"), 0);
00859         
00860         jit_object_method(openexr, gensym("read"), gensym("read"), argc, argv);
00861         
00862         //make an output linked list for matrix_calc
00863         {
00864             void *in_list = jit_object_new(_jit_sym_jit_linklist);
00865             void *out_list = jit_object_new(_jit_sym_jit_linklist);
00866             
00867             if(!out_list) {
00868                 jit_object_free(matrix);
00869                 jit_object_free(openexr);
00870                 jit_object_error((t_object *)x,"jit.gl.texture: unable to load file: out of memory!");
00871                 return JIT_ERR_GENERIC;
00872             }
00873             
00874             jit_object_method(out_list, _jit_sym_append, jit_object_method(matrix, gensym("getmatrix")));
00875             jit_object_method(openexr, gensym("matrix_calc"), in_list, out_list);
00876             
00877             jit_object_method(in_list, _jit_sym_chuck);
00878             jit_object_method(out_list, _jit_sym_chuck);
00879         }
00880         
00881         jit_object_free(openexr);
00882     }
00883     else {
00884         // import a quicktime movie
00885         object_method_typed(matrix, gensym("importmovie"), argc, argv, &rv);
00886         if (rv.a_type==A_OBJ) 
00887         {
00888             t_object *o = (t_object *)rv.a_w.w_obj; 
00889             if (o) 
00890                 freeobject(o);
00891         }
00892     }
00893     
00894     // get the temp load matrix name
00895     jit_atom_setsym(at,jit_attr_getsym(matrix, _jit_sym_name));
00896     
00897     modewas = x->mode;
00898     x->mode = ps_jit_gl_texture_mode_static;
00899     
00900     // copy the temp load matrix data into the texture
00901     jit_gl_texture_jit_matrix(x, _jit_sym_jit_matrix, 1, at);
00902     x->mode = modewas;
00903     
00904     // free the temp load matrix
00905     jit_object_free(matrix);
00906 
00907     // get the filename
00908     if(argc && argv)
00909         x->file = jit_atom_getsym(argv);
00910     
00911     return JIT_ERR_NONE;
00912 }
00913 
00914 t_jit_err jit_gl_texture_read_typed(t_jit_gl_texture *x, t_symbol *s, long ac, t_atom *av, t_atom *rv)
00915 {
00916     long err = JIT_ERR_NONE;
00917     t_atom a[2];
00918     long i;
00919 
00920     if (ac && av) {
00921         for (i = 0; i < ac && i < 2; i++)
00922             a[i] = av[i];
00923     } else {
00924         ac = 1;
00925         jit_atom_setsym(a, _jit_sym_nothing);
00926     }
00927         
00928     err = (long)jit_object_method(x, s, s, ac, a);
00929     
00930     if (rv) {
00931         if (err)
00932             jit_atom_setlong(&a[1], 0);
00933         else
00934             jit_atom_setlong(&a[1], 1);
00935 
00936         atom_setobj(rv,object_new(ps_nobox,ps_atomarray,2,a));
00937     }
00938     return err;
00939 }
00940 
00941 
00942 t_jit_err jit_gl_texture_copy( t_jit_gl_texture *x, t_symbol *s, int argc, t_atom *argv)
00943 {
00944     t_atom a;
00945     t_jit_gl_texture *from;
00946     t_jit_err err = JIT_ERR_NONE;
00947     char *bp = NULL;
00948 
00949     t_symbol *name = jit_atom_getsym(argv);
00950 
00951     if (name)
00952     {
00953         from = (t_jit_gl_texture*)jit_object_findregistered(name);
00954                     
00955         if (!from)
00956         {
00957             post ("jit.gl.texture: couldn't get source texture object for copy!");
00958             return JIT_ERR_GENERIC;
00959         }
00960         
00961         if(from == x)
00962             return JIT_ERR_NONE;
00963         
00964         if(!jit_gl_get_context())
00965             return JIT_ERR_GENERIC;
00966         
00967         if(!jit_gl_get_support())
00968             return JIT_ERR_GENERIC;
00969 
00970         if(x->adapt)
00971         {
00972             x->rectangle = from->rectangle;
00973             x->target = from->target;
00974             x->type = from->type;
00975 
00976             x->dim[0] = from->dim[0];
00977             x->dim[1] = from->dim[1];
00978             x->dim[2] = from->dim[2];
00979         }
00980                 
00981         // begin capturing to pbuffer
00982         err = jit_gl_texture_begin_capture(x, 0, 0, 0);
00983         if(err) return err;
00984         
00985         // setup modelview for 1-to-1 pixel map
00986         glMatrixMode(GL_MODELVIEW);         
00987         glLoadIdentity();
00988         glMatrixMode(GL_PROJECTION);
00989         glLoadIdentity();
00990         gluOrtho2D(0.0, 1.0, 0.0, 1.0);             
00991         glMatrixMode(GL_MODELVIEW);         
00992         glDisable(GL_LIGHTING);
00993         
00994         // bind source texture
00995         err = jit_gl_texture_bind(from, 0, 0, 0);
00996         if(err) return err;
00997 
00998         // draw textured quad
00999         err = jit_gl_texture_draw_quad(from, 0, 0, 1, 1);
01000         if(err) return err;
01001 
01002         // unbind source texture
01003         err = jit_gl_texture_unbind(from, 0, 0, 0);
01004         if(err) return err;
01005 
01006         // disable capture to pbuffer 
01007         err = jit_gl_texture_end_capture(x, 0, 0, 0);
01008         if(err) return err;
01009         
01010         // destination texture ready to be bound now with source contents!
01011     }
01012 
01013     return JIT_ERR_NONE;
01014 }
01015 
01016 /*************************************************************************/
01017 
01018 void jit_gl_texture_recalc( t_jit_gl_texture *x )
01019 {
01020     // reset update flag
01021     if(x->matrix)
01022         jit_gl_texture_create(x, x->matrix);
01023     x->update = FALSE;
01024 }
01025 
01026 void jit_gl_texture_notify(t_jit_gl_texture *x, t_symbol *s, t_symbol *msg, t_object *sender, void *data)
01027 {
01028     if (s == x->refmatname) 
01029     {
01030         if (msg==_jit_sym_rebuilding) 
01031         {
01032             //jit_object_post((t_object *)x,"texture informed of matrix rebuilding. copy and then detach");
01033 /*
01034             if (x->mode==ps_jit_gl_texture_mode_dynamic) {
01035                 // store off exisiting matrix in internal matrix
01036                 x->mode = ps_jit_gl_texture_mode_static;
01037                 jit_gl_texture_domatrix(x, sender, NULL);
01038                 x->mode = ps_jit_gl_texture_mode_dynamic;
01039             }
01040 */          
01041             // forget about it          
01042             jit_object_detach(x->refmatname,x);
01043             x->refmatname = _jit_sym_nothing;
01044             x->reuse = FALSE;
01045             x->pixels = 0;      
01046         } 
01047         else if ((msg == _jit_sym_modified) || (msg == _jit_sym_free)) 
01048         {
01049             //jit_object_post((t_object *)x,"texture informed of matrix modified/freed. detach");
01050 
01051             // forget about it          
01052             jit_object_detach(x->refmatname,x);
01053             x->refmatname = _jit_sym_nothing;
01054             x->reuse = FALSE;
01055             x->pixels = 0;
01056         }
01057     }
01058     else if(s == x->capture_source) {
01059         if(msg == ps_capture_complete)  {
01060             if(x->capture_buffer == ps_depth) {
01061                 jit_gl_texture_do_depth_grab(x, sender);
01062             }
01063             else if(x->capture_buffer == ps_color) {
01064                 jit_gl_texture_do_screen_grab(x, sender);
01065             }
01066         }
01067         else if(msg == ps_free) {
01068             x->capture_attached = 0;
01069         }
01070     }
01071 }
01072 
01073 
01074 t_jit_err jit_gl_texture_bind(t_jit_gl_texture *x, t_symbol *s, int argc, t_atom *argv)
01075 {
01076     t_jit_err err;
01077     t_jit_gl_context ctx;
01078     t_jit_matrix_info minfo;
01079     char *bp = NULL;
01080     GLuint id;
01081     GLint prevunit = 0;
01082     long unit = -1;
01083     long rowlength;
01084     float camera[16];
01085 
01086     // safety
01087     if(!x)
01088         return JIT_ERR_INVALID_PTR;
01089 
01090     // TEXDEBUG - jkc
01091     if (_jit_gl_texture_verbose) {
01092         TEXTURE_VERBOSE_POST("jit_gl_texture_bind: texture dim = %d %d %d", x->dim[0],x->dim[1],x->dim[2]);
01093         if (x->matrix) {
01094             t_jit_matrix_info info;
01095             jit_object_method(x->matrix, _jit_sym_getinfo, &info);
01096             TEXTURE_VERBOSE_POST("jit_gl_texture_bind: matrix dim = %d %d %d; planecount = %d", info.dim[0],info.dim[1],info.dim[2], info.planecount);
01097         }
01098     }
01099 
01100     // cache support struct
01101     x->support = jit_gl_get_support();
01102     
01103     //attach to texture source if
01104     if(x->capture_source != _jit_sym_nothing && ! x->capture_attached)
01105         jit_attr_setsym(x, ps_capture_source, x->capture_source);
01106 
01107     // cache previous unit
01108     if (x->support->multitexture)
01109         glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &prevunit);
01110 
01111     // get the texture unit to bind to
01112     unit = jit_gl_texture_enable_unit(x, s, argc, argv);
01113 
01114     // create a default matrix
01115     if(!x->matrix && !x->capturing)
01116     {
01117         err = jit_gl_texture_create_default_matrix(x);
01118         if(err) return err;
01119 
01120         jit_gl_texture_rematrix(x);
01121         jit_gl_texture_recalc(x);
01122     }
01123 
01124     // destroy existing texture
01125     if(x->destroy)
01126     {
01127         jit_gl_texture_destroy_existing(x);
01128     }
01129     
01130     // texture seen first time, generate name and create data
01131     if ( x->capturing == JIT_GL_TEXTURE_CAPTURE_RESULT || 
01132          x->update || x->id < 0 || x->target < 0 )
01133     {
01134         err = jit_gl_texture_create(x, x->matrix);
01135         if(err)
01136         { 
01137             jit_object_error((t_object *)x,"jit.gl.texture: unable to create texture!");
01138             return err; 
01139         }
01140     }
01141     
01142     // safety
01143     if(x->id < 0 || x->target < 0 )
01144         return JIT_ERR_GENERIC;
01145 
01146     if(!x->capturing)
01147     {
01148         // get the matrix info and data
01149         if( x->subtex_submission )
01150         {
01151             jit_object_method(x->subtex_matrix, _jit_sym_getinfo, &minfo);
01152             jit_object_method(x->subtex_matrix, _jit_sym_getdata, &bp);
01153         }
01154         else
01155         {
01156             jit_object_method(x->matrix, _jit_sym_getinfo, &minfo);
01157             jit_object_method(x->matrix, _jit_sym_getdata, &bp);
01158         }
01159 
01160         // reuse existing pixel data
01161         if(x->reuse) 
01162         {
01163             bp = x->pixels;
01164             x->rowlength = x->refmatrowlength;
01165         } 
01166         
01167         // safety
01168         if(!bp)
01169             return JIT_ERR_INVALID_PTR;
01170     }
01171 
01172     // record unit bind count 
01173     if (unit >= 0)
01174         x->bound[unit]++;
01175     else
01176         x->bound[0]++;
01177     
01178     // handle dynamic cache 
01179     if(!x->capturing)
01180     {
01181         if(x->newpixels && x->mode == ps_jit_gl_texture_mode_dynamic && !x->subtex_submission)
01182         {
01183             err = jit_gl_texture_submit_dynamic(x, &minfo, bp, &bp);
01184             if(err) return err;
01185         }
01186     }
01187 
01188     // enable the target
01189     err = jit_gl_texture_enable_target(x);
01190     if(err) return err;
01191 
01192     // bind texture to the target
01193     err = jit_gl_texture_bind_target(x);
01194     if(err) return err;
01195 
01196     // enable texcoord transform
01197     err = jit_gl_texture_enable_transform(x);
01198     if(err) return err;
01199 
01200     // set target
01201     if (x->newpixels) 
01202     {
01203         // set unpack alignment and rowlength
01204         glPixelStorei(GL_UNPACK_ROW_LENGTH, x->rowlength);
01205         glPixelStorei(GL_UNPACK_ALIGNMENT, x->alignment);
01206         jit_gl_report_error("jit.gl.texture: error setting unpack alignment!");
01207 
01208         // setup dynamic cache
01209         if(x->mode == ps_jit_gl_texture_mode_dynamic)
01210         {
01211             err = jit_gl_texture_enable_dynamic(x, &minfo, bp);
01212             if(err) return err;
01213         }
01214 
01215         // submit the data
01216         if(!x->capturing && !x->readback)
01217         {
01218             err = jit_gl_texture_submit_data(x, bp);
01219             if(err) return err;
01220         }
01221     }
01222     else if(x->capturing == JIT_GL_TEXTURE_CAPTURE_SETUP)
01223     {
01224         err = jit_gl_texture_create_storage(x, NULL);
01225         if(err) return err;
01226     }
01227     
01228     // setup depth texture modes
01229     err = jit_gl_texture_enable_depth_tex_mode(x);
01230     if(err) return err;
01231     
01232     // setup texture env modes
01233     err = jit_gl_texture_enable_texenv(x);
01234     if(err) return err;
01235 
01236     // setup texture coordinate generation
01237     err = jit_gl_texture_enable_texgen(x);
01238     if(err) return err;
01239 
01240     // setup texture filter mode
01241     err = jit_gl_texture_enable_filter_mode(x);
01242     if(err) return err;
01243     
01244     // clear reuse flag (don't do this one bind)
01245     x->reuse = FALSE;
01246 
01247     // restore prev unit
01248     if (x->support->multitexture)
01249         glActiveTextureARB(prevunit);
01250     
01251     
01252     // disable dynamic cache (can't do this in unbind because we will 
01253     // get GL_INVALID_OPERATION errors from other texture binds that aren't
01254     // dynamic)
01255     if(x->mode == ps_jit_gl_texture_mode_dynamic && !x->subtex_submission)
01256     {
01257         err = jit_gl_texture_disable_dynamic(x);
01258         if(err) return err;
01259     }
01260     
01261     return JIT_ERR_NONE;
01262 }
01263 
01264 t_jit_err jit_gl_texture_unbind(t_jit_gl_texture *x, t_symbol *s, int argc, t_atom *argv)
01265 {
01266     t_jit_gl_context ctx;
01267     t_jit_err err;
01268     GLuint id = x->id;
01269     GLint prevunit = 0;
01270     long unit = -1;
01271     long bound;
01272         
01273     //jit_cpost("jit_gl_texture_unbind: %d",x->id);
01274     // ignore invalid texture
01275     if(x->id < 0 || x->target < 0)
01276         return JIT_ERR_NONE;
01277 
01278     // TODO: on win we get an invalid operation the first time 
01279     // we bind/unbind a texture which we safely ignore for now 
01280 #ifdef WIN_VERSION  
01281     if(glGetError())
01282         err = JIT_ERR_NONE;
01283 #endif  
01284 
01285     // report any existing errors
01286     jit_gl_report_error("jit.gl.texture: error entering unbind");
01287 
01288     // cache support struct
01289     x->support = jit_gl_get_support();
01290 
01291     // cache previous unit
01292     if (x->support->multitexture)
01293         glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &prevunit);
01294 
01295     // release the dynamic texture
01296     if(x->capturing == JIT_GL_TEXTURE_CAPTURE_RESULT && x->readback)
01297     {
01298         err = jit_gl_readback_unbind_attachment(x->readback, 0);
01299         if(err) return err;
01300     } 
01301 
01302     // disable the indicated texture unit
01303     unit = jit_gl_texture_disable_unit(x, s, argc, argv);
01304     jit_gl_report_error("jit.gl.texture: error disabling texture unit");
01305     
01306     // get number of bindings for unit
01307     if (unit >= 0) 
01308     {
01309         bound = x->bound[unit];
01310         if (x->bound[unit])
01311             x->bound[unit]--;
01312     } 
01313     else 
01314     {
01315         bound = x->bound[0];
01316         if (x->bound[0])
01317             x->bound[0]--;
01318     }   
01319 
01320     // return if unit was not bound
01321     if(bound <= 0) 
01322     {
01323         // jit_object_post((t_object *)x,"we think were not bound. not popping texture stack");
01324         return JIT_ERR_NONE;    
01325     }
01326 
01327     if(!x->capturing)
01328     {
01329         // reset alignment/rowlength
01330         glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
01331         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
01332         jit_gl_report_error("jit.gl.texture: error disabling pixelstore");
01333     }
01334 
01335     // disable texcoord transform
01336     err = jit_gl_texture_disable_transform(x);
01337     if(err) return err;
01338 
01339     // disable texgen
01340     err = jit_gl_texture_disable_texgen(x);
01341     if(err) return err;
01342 
01343     // disable texenv
01344     err = jit_gl_texture_disable_texenv(x);
01345     if(err) return err;
01346 
01347     // disable the texture target
01348     err = jit_gl_texture_disable_target(x);
01349     if(err) return err;
01350 
01351     // restore prev unit
01352     if (x->support->multitexture)
01353         glActiveTextureARB(prevunit);
01354 
01355     return JIT_ERR_NONE;
01356 }
01357 
01358 /*************************************************************************/
01359 t_jit_err jit_gl_texture_create_storage(t_jit_gl_texture *x, char *bp)
01360 {
01361     t_jit_err err = JIT_ERR_NONE;
01362     
01363     switch(x->target)
01364     {
01365         case GL_TEXTURE_1D:
01366         {
01367             glTexImage1D(x->target, 0, x->internal, x->width, 0, x->format, x->datatype, bp);
01368             break;
01369         }
01370         case GL_TEXTURE_2D:
01371         case GL_TEXTURE_RECTANGLE_ARB:  // same as EXT
01372         {
01373             glTexImage2D(x->target, 0, x->internal, x->width, x->height, 0, x->format, x->datatype, bp);
01374             break;
01375         }
01376         case GL_TEXTURE_3D:
01377         {
01378             glTexImage3D(x->target, 0, x->internal, x->width, x->height, x->depth, 0, x->format, x->datatype, bp);
01379             break;
01380         }
01381         case GL_TEXTURE_CUBE_MAP:
01382         {
01383             gluBuild2DMipmaps(x->cubemap_face, x->internal, x->width, x->height, x->format, x->datatype, bp);
01384             break;
01385         }
01386         x->submitted = 1;
01387     };
01388 
01389     err = jit_gl_report_error("jit.gl.texture: error submitting texture data");
01390     return err;
01391 }
01392 
01393 t_jit_err jit_gl_texture_submit_data(t_jit_gl_texture *x, char *bp)
01394 {
01395     t_jit_err err = JIT_ERR_NONE;
01396 
01397     if(!bp) return err;
01398 
01399     if(!x)
01400         return JIT_ERR_INVALID_PTR;
01401 
01402     // use TexSubImage if supported (v1.3+) 
01403     if (jit_gl_support_valid(&x->support) && (x->support->version_major > 1 || x->support->version_minor > 3) 
01404 #ifdef MAC_VERSION
01405 //      && (x->mode!=ps_jit_gl_texture_mode_dynamic) // for texture range to take effect, need to use glTexImage?
01406 #endif
01407         ) // && x->submitted) seems to still cause issues. revisit for 1.7 - jkc
01408     {
01409         int subtexdimend[3];
01410     
01411         if(x->subtex_submission) {
01412             x->offset[0] = CLAMP(x->dstdimstart[0], 0, x->width-1);
01413             x->offset[1] = CLAMP(x->dstdimstart[1], 0, x->height-1);
01414             x->offset[2] = CLAMP(x->dstdimstart[2], 0, x->depth-1);
01415             
01416             subtexdimend[0] = CLAMP(x->dstdimend[0] - x->dstdimstart[0] + 1, 1, x->width - x->offset[0]);
01417             subtexdimend[1] = CLAMP(x->dstdimend[1] - x->dstdimstart[1] + 1, 1, x->height - x->offset[1]);
01418             subtexdimend[2] = CLAMP(x->dstdimend[2] - x->dstdimstart[2] + 1, 1, x->depth - x->offset[2]);
01419         }
01420         else {
01421             x->offset[0] = 0;
01422             x->offset[1] = 0;
01423             x->offset[2] = 0;
01424             
01425             subtexdimend[0] = x->width;
01426             subtexdimend[1] = x->height;
01427             subtexdimend[2] = x->depth;
01428         }
01429     
01430         switch(x->target)
01431         {
01432             case GL_TEXTURE_1D:
01433             { 
01434                 glTexSubImage1D(x->target, 0, x->offset[0], subtexdimend[0], x->format, x->datatype, bp);
01435                 break;
01436             }
01437             case GL_TEXTURE_2D:
01438             case GL_TEXTURE_RECTANGLE_ARB:  // same as EXT
01439             {
01440                 glTexSubImage2D(x->target, 0, x->offset[0], x->offset[1], 
01441                                 subtexdimend[0], subtexdimend[1], x->format, x->datatype, bp);
01442                 break;
01443             }
01444             case GL_TEXTURE_3D:
01445             {
01446                 glTexSubImage3D(x->target, 0, x->offset[0], x->offset[1], x->offset[2], 
01447                                 subtexdimend[0], subtexdimend[1], subtexdimend[2], x->format, x->datatype, bp);
01448                 break;
01449             }
01450             case GL_TEXTURE_CUBE_MAP:
01451             {
01452                 // TODO!
01453                 break;
01454             }
01455         };
01456         
01457         x->submitted = 1;
01458         err = jit_gl_report_error("jit.gl.texture: setting subteximage during submission.");
01459     } 
01460     else if(!x->subtex_submission)
01461     {
01462         switch(x->target)
01463         {
01464             case GL_TEXTURE_1D:
01465             {
01466                 glTexImage1D(x->target, 0, x->internal, x->width, 0, x->format, x->datatype, bp);
01467                 break;
01468             }
01469             case GL_TEXTURE_2D:
01470             case GL_TEXTURE_RECTANGLE_ARB:  // same as EXT
01471             {
01472                 glTexImage2D(x->target, 0, x->internal, x->width, x->height, 0, x->format,  x->datatype, bp);
01473                 break;
01474             }
01475             case GL_TEXTURE_3D:
01476             {
01477                 glTexImage3D(x->target, 0, x->internal, x->width, x->height, x->depth, 0, x->format,  x->datatype, bp);
01478                 break;
01479             }
01480             case GL_TEXTURE_CUBE_MAP:
01481             {
01482                 // TODO!
01483                 break;
01484             }
01485         };
01486         
01487         //need flag because can't call glTexSubImage first: GL_INVALID_OPERATION  is  generated  if  
01488         //the texture array has not been defined by a previous glTexImage2D operation.
01489         x->submitted = 1;
01490         err = jit_gl_report_error("jit.gl.texture: setting teximage during submission.");
01491     }
01492     
01493     // clear the new pixels flag
01494     x->newpixels = FALSE;
01495     return err;
01496 }
01497 
01498 long jit_gl_texture_enable_unit(t_jit_gl_texture *x, t_symbol *s, int argc, t_atom *argv)
01499 {
01500     long unit = -1;
01501 
01502     // get the texture unit to bind to
01503     if(x && argc && argv && jit_gl_support_valid(&x->support) && x->support->multitexture)
01504     {
01505         unit = jit_atom_getlong(argv);
01506         if(x->support->texture_units > unit)
01507         {
01508             glActiveTextureARB(GL_TEXTURE0_ARB + unit);
01509         } 
01510         else 
01511         {
01512             unit = -1;
01513         }
01514         jit_gl_report_error("jit.gl.texture: setting active texture target.");  
01515     }
01516 
01517     return unit;
01518 }
01519 
01520 long jit_gl_texture_disable_unit(t_jit_gl_texture *x, t_symbol *s, int argc, t_atom *argv)
01521 {
01522     long unit = -1;
01523 
01524 
01525     // disable the indicated texture unit
01526     if(x && argc && argv && jit_gl_support_valid(&x->support) && x->support->multitexture)
01527     {
01528         unit = jit_atom_getlong(argv);
01529 
01530         if(x->support->texture_units > unit)
01531         {
01532             glActiveTextureARB(GL_TEXTURE0_ARB + unit);
01533         } 
01534         else 
01535         {
01536             unit = -1;
01537         }
01538     } 
01539 
01540     return unit;
01541 }
01542 
01543 t_jit_err jit_gl_texture_enable_target(t_jit_gl_texture *x)
01544 {
01545     if(!x)
01546         return JIT_ERR_INVALID_PTR;
01547 
01548     if(!x->target)
01549     {
01550         jit_object_error((t_object *)x,"jit.gl.texture: unable to enable invalid texture target");
01551         return JIT_ERR_GENERIC;
01552     }
01553 
01554     // enable the target
01555     glEnable(x->target);
01556     jit_gl_report_error("jit.gl.texture: error enabling texture target");
01557 
01558     return JIT_ERR_NONE;
01559 }
01560 
01561 t_jit_err jit_gl_texture_bind_target(t_jit_gl_texture *x)
01562 {
01563     GLuint id = 0;
01564     GLenum target = 0;
01565     t_jit_err err;
01566 
01567     if(!x)
01568         return JIT_ERR_INVALID_PTR;
01569 
01570     if(x->readback && x->capturing == JIT_GL_TEXTURE_CAPTURE_RESULT)
01571     {
01572         t_jit_gl_readback *rb = x->readback;
01573         if(rb && rb->pbuffer)
01574         {
01575             // use ctt texture
01576             id = rb->pbuffer->buffertexid;
01577             target = rb->pbuffer->target;
01578             //jit_object_post((t_object *)x,"pbuffer target id=%d; regular id=%d", id, x->id); // jkc TEMPHACK
01579         }
01580     }
01581 
01582     if(id<=0)
01583     {
01584         // use localtexture
01585         id = x->id;
01586         target = x->target;
01587     }
01588 
01589     if(id)
01590     {
01591         // jkc TEMPHACK
01592         /*
01593         long unit=-1;
01594         glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &unit);
01595         jit_object_post((t_object *)x,"binding id=%d for texture unit %d",id,unit);
01596         jit_gl_report_error("TEMPHACK: bind texture");
01597         */
01598         
01599         glBindTexture(target, id);  
01600     }
01601     x->bindid = id;
01602 
01603     jit_gl_report_error("jit.gl.texture: error binding texture to target");
01604     return JIT_ERR_NONE;
01605 }
01606 
01607 t_jit_err jit_gl_texture_disable_target(t_jit_gl_texture *x)
01608 {
01609     if(!x)
01610         return JIT_ERR_INVALID_PTR;
01611 
01612     glDisable(x->target);
01613     jit_gl_report_error("jit.gl.texture: error disabling texture target.");
01614     return JIT_ERR_NONE;
01615 }
01616 
01617 t_jit_err jit_gl_texture_enable_compression(t_jit_gl_texture *x)
01618 {
01619     t_jit_err err = JIT_ERR_NONE;
01620 
01621     if(jit_gl_support_valid(&x->support) && x->support->texture_compression && JIT_SYM_IF(x->compress))
01622     {
01623         if(x->flags & JIT_GL_RGB || x->flags & JIT_GL_RGBA) 
01624         {
01625             err = jit_gl_texture_get_compress_from_symbol(x, x->compress, &x->internal);
01626             if(err) return err;
01627         }
01628         else
01629         {
01630             jit_object_error((t_object *)x,"jit.gl.texture: compression can only be used with RGB or RGBA formats.");
01631         }
01632     } 
01633 
01634     return err;
01635 }
01636 
01637 t_jit_err jit_gl_texture_enable_transform(t_jit_gl_texture *x)
01638 {
01639     GLfloat scale[] = { 1.0, 1.0, 1.0 };
01640     GLfloat rotate[] = { 0.0, 0.0, 0.0 };
01641     GLfloat translate[] = { 0.0, 0.0, 0.0 };
01642 
01643     if(!x)
01644         return JIT_ERR_INVALID_PTR;
01645         
01646     jit_gl_report_error("jit.gl.texture: error disabling transform");
01647 
01648     // scale texcoords for nonuniform rectangle texture targets
01649     if(x->rectangle && jit_gl_support_valid(&x->support) && !x->support->texture_rect_uniform)
01650     {
01651         glMatrixMode(GL_TEXTURE);
01652         glPushMatrix();
01653         glLoadIdentity();
01654         if(x->autoscale)
01655         {
01656             if(x->flip && x->capturing == JIT_GL_TEXTURE_CAPTURE_DISABLED)
01657             {
01658                 glScalef(x->width, -x->height, 1.0f);
01659                 glTranslatef(0.f, -1.0f, 0.f);
01660             }
01661             else
01662             {
01663                 glScalef(x->width, x->height, 1.0f);
01664             }
01665         }
01666         else
01667         {
01668             //jit_gl_texture_get_scale(x, scale);
01669             //jit_gl_texture_get_rotate(x, rotate);
01670             //jit_gl_texture_get_translate(x, translate);
01671             
01672             if(x->flip && x->capturing == JIT_GL_TEXTURE_CAPTURE_DISABLED)
01673             {
01674                 glTranslatef(-translate[0], -translate[1], translate[2]);           
01675                 glRotatef(rotate[0], 1.0f, 0.0f, 0.0f);     
01676                 glRotatef(rotate[1], 0.0f, 1.0f, 0.0f);     
01677                 glRotatef(rotate[2], 0.0f, 0.0f, 1.0f);
01678                 glScalef(-scale[0], -scale[1], scale[2]);
01679             }
01680             else
01681             {
01682                 glTranslatef(translate[0], translate[1], translate[2]);         
01683                 glRotatef(rotate[0], 1.0f, 0.0f, 0.0f);     
01684                 glRotatef(rotate[1], 0.0f, 1.0f, 0.0f);     
01685                 glRotatef(rotate[2], 0.0f, 0.0f, 1.0f);
01686                 glScalef(scale[0], scale[1], scale[2]);
01687             }       
01688         }
01689         glMatrixMode(GL_MODELVIEW);
01690     }
01691     else
01692     {
01693         glMatrixMode(GL_TEXTURE);
01694         glPushMatrix();
01695         glLoadIdentity();
01696 
01697         if(x->autoscale)
01698         {
01699             if(x->flip && x->capturing == JIT_GL_TEXTURE_CAPTURE_DISABLED)
01700             {
01701                 glScalef(1.0f, -1.0f, 1.0f);
01702                 glTranslatef(0.0f, -1.0f, 0.f);
01703             }
01704         } 
01705         else 
01706         {
01707             //jit_gl_texture_get_scale(x, scale);
01708             //jit_gl_texture_get_rotate(x, rotate);
01709             //jit_gl_texture_get_translate(x, translate);
01710             
01711             if(x->flip && x->capturing == JIT_GL_TEXTURE_CAPTURE_DISABLED)
01712             {
01713                 glTranslatef(-translate[0], -translate[1], translate[2]);           
01714                 glRotatef(rotate[0], 1.0f, 0.0f, 0.0f);     
01715                 glRotatef(rotate[1], 0.0f, 1.0f, 0.0f);     
01716                 glRotatef(rotate[2], 0.0f, 0.0f, 1.0f);
01717                 glScalef(-scale[0], -scale[1], scale[2]);
01718             }
01719             else
01720             {
01721                 glTranslatef(translate[0], translate[1], translate[2]);         
01722                 glRotatef(rotate[0], 1.0f, 0.0f, 0.0f);     
01723                 glRotatef(rotate[1], 0.0f, 1.0f, 0.0f);     
01724                 glRotatef(rotate[2], 0.0f, 0.0f, 1.0f);
01725                 glScalef(scale[0], scale[1], scale[2]);
01726             }
01727         }       
01728         glMatrixMode(GL_MODELVIEW);
01729     }
01730 
01731     jit_gl_report_error("jit.gl.texture: error enabling transform");
01732     return JIT_ERR_NONE;
01733 }
01734 
01735 t_jit_err jit_gl_texture_disable_transform(t_jit_gl_texture *x)
01736 {
01737     if(!x)
01738         return JIT_ERR_INVALID_PTR;
01739 
01740     // reset texture matrix
01741     glMatrixMode(GL_TEXTURE);
01742     glPopMatrix();
01743     glMatrixMode(GL_MODELVIEW);
01744 
01745     jit_gl_report_error("jit.gl.texture: error disabling transform");
01746     return JIT_ERR_NONE;
01747 }
01748 
01749 /*************************************************************************/
01750 t_jit_err jit_gl_texture_enable_wrap_mode(t_jit_gl_texture *x)
01751 {
01752     GLenum wrap;
01753     t_jit_err err = JIT_ERR_NONE;
01754 
01755     if(!x)
01756         return JIT_ERR_INVALID_PTR;
01757 
01758     // reset border flag
01759     x->border = FALSE;
01760 
01761     // setup S wrap mode
01762     err = jit_gl_texture_get_wrap_from_symbol(x, x->wrap[0], &wrap);
01763     if(!err)
01764     {
01765         glTexParameteri(x->target,GL_TEXTURE_WRAP_S,wrap);
01766         if(wrap == GL_CLAMP_TO_BORDER) x->border = TRUE;
01767     }
01768     jit_gl_report_error("jit.gl.texture: setting texture wrap mode s");
01769 
01770     // setup T wrap mode
01771     err = jit_gl_texture_get_wrap_from_symbol(x, x->wrap[1], &wrap);
01772     if(!err)
01773     {
01774         glTexParameteri(x->target,GL_TEXTURE_WRAP_T,wrap);
01775         if(wrap == GL_CLAMP_TO_BORDER) x->border = TRUE;
01776     }
01777     jit_gl_report_error("jit.gl.texture: setting texture wrap mode t");
01778     
01779     // setup R wrap mode
01780     if(!err && x->target == GL_TEXTURE_3D)
01781     {
01782         err = jit_gl_texture_get_wrap_from_symbol(x, x->wrap[2], &wrap);
01783         if(!err)
01784         {
01785             glTexParameteri(x->target,GL_TEXTURE_WRAP_R,GL_CLAMP);
01786             if(wrap == GL_CLAMP_TO_BORDER) x->border = TRUE;
01787         }   
01788     }
01789     err = jit_gl_report_error("jit.gl.texture: setting texture wrap mode r");
01790     return err;
01791 }
01792 
01793 t_jit_err jit_gl_texture_enable_border(t_jit_gl_texture *x)
01794 {
01795     t_jit_err err = JIT_ERR_NONE;
01796 
01797     if(!x)
01798         return JIT_ERR_INVALID_PTR;
01799 
01800     if( x->border )
01801     {
01802         glTexParameterfv(x->target, GL_TEXTURE_BORDER_COLOR, x->bordercolor);
01803     }
01804     err = jit_gl_report_error("jit.gl.texture: setting texture border.");
01805 
01806     return err;
01807 }
01808 
01809 t_jit_err jit_gl_texture_enable_priority(t_jit_gl_texture *x)
01810 {
01811     t_jit_err err = JIT_ERR_NONE;
01812 
01813     if(!x)
01814         return JIT_ERR_INVALID_PTR;
01815 
01816     glTexParameterf(x->target, GL_TEXTURE_PRIORITY, (GLfloat)x->priority);
01817     err = jit_gl_report_error("jit.gl.texture: setting texture priority.");
01818 
01819     return err;
01820 }
01821 
01822 t_jit_err jit_gl_texture_enable_filter_mode(t_jit_gl_texture *x)
01823 {
01824     GLenum filter;
01825     GLenum mipmap;
01826     t_jit_err err = JIT_ERR_NONE;
01827 
01828     if(!x)
01829         return JIT_ERR_INVALID_PTR;
01830 
01831     TEXTURE_VERBOSE_POST("** jit_gl_texture_enable_filter_mode");
01832 
01833     // set filter mode 
01834     err = jit_gl_texture_get_filter_from_symbol(x, x->filter, &filter);
01835     if(!err)
01836     {
01837         if(JIT_SYM_IF(x->mipmap) && x->mipmap != ps_jit_gl_texture_mipmap_none)
01838         {
01839             jit_gl_texture_get_mipmap_from_symbol(x, x->mipmap, &mipmap);
01840             glTexParameteri(x->target, GL_GENERATE_MIPMAP_SGIS,GL_TRUE);
01841             glTexParameteri(x->target, GL_TEXTURE_MAG_FILTER,filter);
01842             glTexParameteri(x->target, GL_TEXTURE_MIN_FILTER,mipmap);
01843         } 
01844         else
01845         {
01846             glTexParameteri(x->target,GL_TEXTURE_MAG_FILTER,filter);
01847             glTexParameteri(x->target,GL_TEXTURE_MIN_FILTER,filter);
01848         }
01849     }
01850     jit_gl_report_error("jit.gl.texture: setting texture filter mode.");
01851     
01852     // set anisotropy
01853     if(x->anisotropy >= 0 && jit_gl_support_valid(&x->support) && x->support->texture_anisotropic)
01854     {
01855         if(x->anisotropy >= 16) 
01856         {
01857             TEXTURE_VERBOSE_POST("anisotropy 16");
01858             glTexParameterf(x->target, GL_TEXTURE_MAX_ANISOTROPY_EXT,16.0);
01859         }
01860         else if(x->anisotropy >= 8) 
01861         {
01862             TEXTURE_VERBOSE_POST("anisotropy 8");
01863             glTexParameterf(x->target, GL_TEXTURE_MAX_ANISOTROPY_EXT,8.0);
01864         }
01865         else if(x->anisotropy >= 4) 
01866         {
01867             TEXTURE_VERBOSE_POST("anisotropy 4");
01868             glTexParameterf(x->target, GL_TEXTURE_MAX_ANISOTROPY_EXT,4.0);
01869         }
01870         else if(x->anisotropy >= 2) 
01871         {
01872             TEXTURE_VERBOSE_POST("anisotropy 2");
01873             glTexParameterf(x->target, GL_TEXTURE_MAX_ANISOTROPY_EXT,2.0);
01874         }
01875         else if(x->anisotropy >= 1)
01876         {
01877             TEXTURE_VERBOSE_POST("anisotropy 1");
01878             glTexParameterf(x->target, GL_TEXTURE_MAX_ANISOTROPY_EXT,1.0);
01879         }
01880         err = jit_gl_report_error("jit.gl.texture: setting texture anisotropy mode.");
01881     }
01882     return err;
01883 }
01884 
01885 t_jit_err jit_gl_texture_enable_texgen(t_jit_gl_texture *x)
01886 {
01887     GLfloat camera[16];
01888 
01889     if(!x)
01890         return JIT_ERR_INVALID_PTR;
01891 
01892     // set up texture coordinate generation
01893     if(x->texgen == ps_jit_gl_texture_texgen_objectspace)
01894     {
01895         glEnable(GL_TEXTURE_GEN_R);
01896         glEnable(GL_TEXTURE_GEN_S);
01897         glEnable(GL_TEXTURE_GEN_T);     
01898         glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
01899         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
01900         glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
01901         glTexGenfv(GL_R, GL_OBJECT_PLANE, JIT_GL_AXIS_Z);
01902         glTexGenfv(GL_S, GL_OBJECT_PLANE, JIT_GL_AXIS_X);
01903         glTexGenfv(GL_T, GL_OBJECT_PLANE, JIT_GL_AXIS_Y);
01904     }
01905     else if(x->texgen == ps_jit_gl_texture_texgen_eyespace)
01906     {
01907         glEnable(GL_TEXTURE_GEN_R);
01908         glEnable(GL_TEXTURE_GEN_S);
01909         glEnable(GL_TEXTURE_GEN_T);     
01910         glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
01911         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
01912         glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
01913         glTexGenfv(GL_R, GL_EYE_PLANE, JIT_GL_AXIS_Z);
01914         glTexGenfv(GL_S, GL_EYE_PLANE, JIT_GL_AXIS_X);
01915         glTexGenfv(GL_T, GL_EYE_PLANE, JIT_GL_AXIS_Y);
01916     }
01917     else if(x->texgen == ps_jit_gl_texture_texgen_environment)
01918     {
01919         glEnable(GL_TEXTURE_GEN_S);
01920         glEnable(GL_TEXTURE_GEN_T);
01921         glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP);
01922         glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP);
01923     }
01924     else if(x->texgen == ps_jit_gl_texture_texgen_projected)
01925     {
01926         glEnable(GL_TEXTURE_GEN_S);
01927         glEnable(GL_TEXTURE_GEN_T);
01928         glEnable(GL_TEXTURE_GEN_R);
01929         glEnable(GL_TEXTURE_GEN_Q);
01930 
01931         // set the camera coordinates for the projected texture coordinates
01932         glTexGenfv(GL_S,GL_EYE_PLANE, JIT_GL_AXIS_X);
01933         glTexGenfv(GL_T,GL_EYE_PLANE, JIT_GL_AXIS_Y);
01934         glTexGenfv(GL_R,GL_EYE_PLANE, JIT_GL_AXIS_Z);
01935         glTexGenfv(GL_Q,GL_EYE_PLANE, JIT_GL_AXIS_W);
01936 
01937         // enable the linear interpolation
01938         glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
01939         glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
01940         glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
01941         glTexGeni(GL_Q,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
01942 
01943         // get the current camera position
01944         glGetFloatv(GL_MODELVIEW_MATRIX,camera);
01945 
01946         // create the transformation to map (s,t,r,q) to the coordinate
01947         glMatrixMode(GL_TEXTURE);
01948         glLoadIdentity(); //no need to push, already done above
01949 
01950         // bias and scale the texture so it covers the near plane
01951         glTranslatef(0.5f,0.5f,0.0f);
01952         glScalef(0.5f,0.5f,1.0f);
01953 
01954         /* TO DO! */
01955 
01956         // set the perspective projection for the projector camera
01957         // glFrustum(left,right,bottom,top,near,far);
01958 
01959         // set the model-view matrix for the projector camera
01960         // gluLookAt( ... );
01961         glMatrixMode(GL_MODELVIEW);
01962     }
01963     else
01964     {
01965         glDisable(GL_TEXTURE_GEN_S);
01966         glDisable(GL_TEXTURE_GEN_T);
01967         glDisable(GL_TEXTURE_GEN_R);
01968         glDisable(GL_TEXTURE_GEN_Q);
01969     }
01970 
01971     jit_gl_report_error("jit.gl.texture: setting texture coordinate generation.");
01972 
01973     return JIT_ERR_NONE;
01974 }
01975 
01976 t_jit_err jit_gl_texture_disable_texgen(t_jit_gl_texture *x)
01977 {
01978     if(!x)
01979         return JIT_ERR_INVALID_PTR;
01980 
01981     if(JIT_SYM_IF(x->texgen))
01982     {
01983         glDisable(GL_TEXTURE_GEN_S);
01984         glDisable(GL_TEXTURE_GEN_T);
01985         glDisable(GL_TEXTURE_GEN_R);
01986         glDisable(GL_TEXTURE_GEN_Q);
01987     }
01988     jit_gl_report_error("jit.gl.texture: disabling texture coordinate generation.");
01989 
01990     return JIT_ERR_NONE;
01991 }
01992 
01993 /*************************************************************************/
01994 
01995 t_jit_err jit_gl_texture_enable_texenv(t_jit_gl_texture *x)
01996 {
01997     GLenum function, source, operand, texgen, correction;   
01998     GLenum apply;
01999 
02000     if(!x)
02001         return JIT_ERR_INVALID_PTR;
02002 
02003     // set up correction mode
02004     jit_gl_texture_get_correction_from_symbol(x, x->correction, &correction);
02005     glHint(GL_PERSPECTIVE_CORRECTION_HINT, correction);
02006     jit_gl_report_error("jit.gl.texture: setting correction mode.");
02007     
02008     if(jit_gl_support_valid(&x->support) && x->support->texture_env)
02009     {
02010         // set up the blend color
02011         glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR, x->blendcolor);
02012         jit_gl_report_error("jit.gl.texture: setting blend color.");
02013 
02014         // set up apply mode
02015         jit_gl_texture_get_apply_from_symbol(x, x->apply, &apply);
02016         if ( apply != GL_COMBINE )
02017         {
02018             glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, apply);
02019             jit_gl_report_error("jit.gl.texture: Setting apply MODE.");
02020         }
02021         else if(x->support->texture_env_combine)
02022         {
02023             // set combine mode
02024             glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_COMBINE);
02025             jit_gl_report_error("jit.gl.texture: Setting combine MODE.");
02026 
02027             // combine RGB function
02028             jit_gl_texture_get_function_from_symbol(x, x->function[0], &function);
02029             glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB, function);
02030             jit_gl_report_error("jit.gl.texture: Setting combine FUNCTION RGB.");
02031 
02032             // combine ALPHA function
02033             jit_gl_texture_get_function_from_symbol(x, x->function[1], &function);
02034             glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_ALPHA, function);
02035             jit_gl_report_error("jit.gl.texture: Setting combine FUNCTION ALPHA.");
02036 
02037             // combine RGB source 0
02038             jit_gl_texture_get_source_from_symbol(x, x->source[0], &source);
02039             glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB, source);
02040             jit_gl_report_error("jit.gl.texture: Setting combine SOURCE 0 RGB.");
02041                
02042             // combine RGB source 1
02043             jit_gl_texture_get_source_from_symbol(x, x->source[2], &source);
02044             glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_RGB, source);
02045             jit_gl_report_error("jit.gl.texture: Setting combine SOURCE 1 RGB.");
02046 
02047             // combine RGB source 2
02048             jit_gl_texture_get_source_from_symbol(x, x->source[4], &source);
02049             glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE2_RGB, source);
02050             jit_gl_report_error("jit.gl.texture: Setting combine SOURCE 2 RGB.");
02051 
02052             // combine ALPHA source 0
02053             jit_gl_texture_get_source_from_symbol(x, x->source[1], &source);
02054             glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_ALPHA, source);
02055             jit_gl_report_error("jit.gl.texture: Setting combine SOURCE 0 ALPHA.");
02056 
02057             // combine ALPHA source 1
02058             jit_gl_texture_get_source_from_symbol(x, x->source[3], &source);
02059             glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_ALPHA, source);
02060             jit_gl_report_error("jit.gl.texture: Setting combine SOURCE 1 ALPHA.");
02061 
02062             // combine ALPHA source 2
02063             jit_gl_texture_get_source_from_symbol(x, x->source[5], &source);
02064             glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE2_ALPHA, source);
02065             jit_gl_report_error("jit.gl.texture: Setting combine SOURCE 2 ALPHA.");
02066 
02067             // combine RGB operand 0
02068             jit_gl_texture_get_operand_from_symbol(x, x->operand[0], &operand);
02069             glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND0_RGB, operand);
02070             jit_gl_report_error("jit.gl.texture: Setting combine OPERAND 0 RGB.");
02071                 
02072             // combine RGB operand 1
02073             jit_gl_texture_get_operand_from_symbol(x, x->operand[2], &operand);
02074             glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND1_RGB, operand);
02075             jit_gl_report_error("jit.gl.texture: Setting combine OPERAND 1 RGB.");
02076 
02077             // combine RGB operand 2
02078             jit_gl_texture_get_operand_from_symbol(x, x->operand[4], &operand);
02079             glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND2_RGB, operand);
02080             jit_gl_report_error("jit.gl.texture: Setting combine OPERAND 2 RGB.");
02081 
02082             // combine ALPHA operand 0
02083             jit_gl_texture_get_operand_from_symbol(x, x->operand[1], &operand);
02084             glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND0_ALPHA, operand);
02085             jit_gl_report_error("jit.gl.texture: Setting combine OPERAND 0 ALPHA.");
02086                 
02087             // combine ALPHA operand 1
02088             jit_gl_texture_get_operand_from_symbol(x, x->operand[3], &operand);
02089             glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND1_ALPHA, operand);
02090             jit_gl_report_error("jit.gl.texture: Setting combine OPERAND 1 ALPHA.");
02091 
02092             // combine ALPHA operand 2
02093             jit_gl_texture_get_operand_from_symbol(x, x->operand[5], &operand);
02094             glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND2_ALPHA, operand);
02095             jit_gl_report_error("jit.gl.texture: Setting combine OPERAND 2 ALPHA.");
02096 
02097             // combine RGB weight
02098             glTexEnvi(GL_TEXTURE_ENV,GL_RGB_SCALE, x->weight[0]);
02099             jit_gl_report_error("jit.gl.texture: Setting combine RGB scale.");
02100 
02101             // combine RGB weight
02102             glTexEnvi(GL_TEXTURE_ENV,GL_ALPHA_SCALE, x->weight[1]);
02103             jit_gl_report_error("jit.gl.texture: setting combine ALPHA scale.");
02104         }
02105         jit_gl_report_error("jit.gl.texture: setting apply mode.");
02106     }
02107     return JIT_ERR_NONE;
02108 }
02109 
02110 t_jit_err jit_gl_texture_disable_texenv(t_jit_gl_texture *x)
02111 {
02112     // nothing to do for now
02113     return JIT_ERR_NONE;
02114 }
02115 
02116 t_jit_err jit_gl_texture_enable_depth_tex_mode(t_jit_gl_texture *x)
02117 {
02118     GLenum compare_mode, compare_func, texture_mode;
02119     
02120     if(x->support && x->support->texture_shadow)
02121     {
02122         jit_gl_texture_get_compare_mode_from_symbol(x, x->compare_mode, &compare_mode);
02123         glTexParameteri(x->target, GL_TEXTURE_COMPARE_MODE_ARB, compare_mode);
02124         jit_gl_report_error("jit.gl.texture: setting compare mode.");
02125         
02126         jit_gl_texture_get_compare_func_from_symbol(x, x->compare_func, &compare_func);
02127         glTexParameteri(x->target, GL_TEXTURE_COMPARE_FUNC_ARB, compare_func);
02128         jit_gl_report_error("jit.gl.texture: setting compare func.");
02129         
02130         jit_gl_texture_get_texture_mode_from_symbol(x, x->texture_mode, &texture_mode);
02131         glTexParameteri(x->target, GL_DEPTH_TEXTURE_MODE_ARB, texture_mode);
02132         jit_gl_report_error("jit.gl.texture: setting texture mode.");
02133     }
02134     
02135     return JIT_ERR_NONE;
02136 }
02137 
02138 /*************************************************************************/
02139 t_jit_err jit_gl_texture_force_create(t_jit_gl_texture *x)
02140 {
02141     t_jit_err err = JIT_ERR_NONE;
02142     TEXTURE_VERBOSE_POST("*** verbose_texture: jit_gl_texture_force_create");
02143 
02144     err = jit_gl_texture_create(x, x->matrix);
02145     if(err)
02146     {
02147         jit_object_error((t_object *)x,"jit.gl.texture: unable to create texture!");
02148     }
02149     
02150     return err;
02151 }
02152 
02153 t_jit_err jit_gl_texture_create(t_jit_gl_texture *x, t_jit_object *matrix)
02154 {
02155     t_jit_err err;
02156     t_jit_gl_context ctx = NULL;
02157 
02158     GLuint id = 0;
02159     GLint datasize;
02160     GLint depthsize;
02161 
02162     long i, j, k, p, n;
02163     long width, height, depth, planecount;
02164     long rowlength, alignment, texsize;
02165     t_jit_matrix_info minfo;
02166     long floatsupport = 0;
02167     char *bp = NULL;
02168     char *mdata = NULL;
02169     char *tdata = NULL;
02170 
02171     GLuint pboid = 0;
02172     void *pbomem = NULL;
02173 
02174     t_symbol *lasttype = x->type;
02175     long lastwidth = x->width;
02176     long lastheight = x->height;
02177     long lastdepth = x->depth;
02178         
02179     //jit_cpost("jit_gl_texture_create: %d",x->id);
02180     if(!x)
02181         return JIT_ERR_INVALID_PTR;
02182 
02183     TEXTURE_VERBOSE_POST("*** verbose_texture: jit_gl_texture_create");
02184 
02185     // TEXDEBUG - jkc
02186     if (_jit_gl_texture_verbose) {
02187         TEXTURE_VERBOSE_POST("jit_gl_texture_create(start): texture dim = %d %d %d", x->dim[0],x->dim[1],x->dim[2]);
02188         if (x->matrix) {
02189             t_jit_matrix_info info;
02190             jit_object_method(x->matrix, _jit_sym_getinfo, &info);
02191             TEXTURE_VERBOSE_POST("jit_gl_texture_create(start): matrix dim = %d %d %d; planecount = %d", info.dim[0],info.dim[1],info.dim[2], info.planecount);
02192         }
02193     }
02194 
02195     // disable rectangular texture attribute if not supported
02196     if(jit_gl_support_valid(&x->support) && !x->support->texture_rect)
02197     {
02198         TEXTURE_VERBOSE_POST("rectangular textures not supported");
02199         x->rectangle = 0;
02200         x->mode = ps_jit_gl_texture_mode_static;
02201     }
02202     else
02203     {
02204         TEXTURE_VERBOSE_POST("rectangular textures supported");
02205     }
02206     
02207     // restrict our dimensions in the absence of non matrix driven textures
02208     if (!x->rectangle) {
02209         for(i=0;i<3;i++)
02210             x->dim[i] = jit_math_roundup_poweroftwo(x->dim[i]);
02211     }   
02212     
02213     if(!x->capturing)
02214     {
02215         // use matrix data for texture
02216         TEXTURE_VERBOSE_POST("using matrix data for texture");
02217         jit_object_method(matrix, _jit_sym_getinfo, &minfo);
02218         jit_object_method(matrix, _jit_sym_getdata, &bp);
02219 
02220         if(bp && x->reuse && !x->pixels) {
02221             x->reuse = FALSE;
02222         }
02223 
02224         // reuse previous cached data
02225         if(x->reuse)
02226         {
02227             TEXTURE_VERBOSE_POST("reusing previous cached data");
02228             bp = x->pixels;
02229         }
02230 
02231         // safety
02232         if(!bp || minfo.dimcount > 3 || minfo.planecount > 4)
02233             return JIT_ERR_INVALID_PTR;
02234                 
02235         // get dimensions and rowstride     
02236         if(x->adapt)
02237         {
02238             // now always driving from x->dim to prevent matrix dim problems with readback textures
02239             x->width = x->dim[0];
02240             x->height = x->dim[1];  
02241             x->depth = x->dim[2];
02242             x->type = minfo.type;       
02243             
02244             if ((minfo.dim[0] != x->dim[0])||
02245                 (minfo.dim[1] != x->dim[1])||
02246                 ((minfo.dimcount>2)&&(x->dim[2]>1)&&(minfo.dim[2] != x->dim[2])))
02247             {
02248                 TEXTURE_VERBOSE_POST("adapting to matrix dimensions");
02249                 minfo.dim[0] = x->dim[0];
02250                 minfo.dim[1] = x->dim[1];   
02251                 minfo.dim[2] = x->dim[2];
02252 
02253                 // resize existing cached matrix
02254                 // using setinfo_ex for minfo.flags == JIT_MATRIX_DATA_PACK_TIGHT (might have problems)
02255                 jit_object_method(matrix, _jit_sym_setinfo_ex, &minfo);
02256 
02257                 // get all of our info and data pointers again
02258                 jit_object_method(matrix, _jit_sym_getinfo, &minfo);
02259                 jit_object_method(matrix, _jit_sym_getdata, &bp);
02260 
02261                 // reuse previous cached data
02262                 if(x->reuse)
02263                     bp = x->pixels;
02264 
02265                 // safety
02266                 if(!bp || minfo.dimcount > 3 || minfo.planecount > 4)
02267                     return JIT_ERR_INVALID_PTR;
02268             }
02269         }
02270         else
02271         {
02272             x->width = x->dim[0];
02273             x->height = x->dim[1];  
02274             x->depth = x->dim[2];
02275         }
02276 
02277         planecount = minfo.planecount;
02278 #ifdef MAC_VERSION
02279         if (x->colormode == ps_jit_gl_colormode_uyvy)   
02280             x->width *= 2;
02281 #endif
02282 
02283         if (x->width != lastwidth)
02284             x->destroy = TRUE;
02285 
02286         if (x->depth != lastdepth)
02287             x->destroy = TRUE;
02288 
02289         if (x->height != lastheight)
02290             x->destroy = TRUE;
02291         
02292         if(x->type != lasttype)
02293             x->destroy = TRUE;
02294         
02295         // determine format from flags
02296         err = jit_gl_texture_choose_internal_format(x->colormode, x->type, x->mode, &x->internal, &x->format, &x->datatype, x->flags);
02297         if(err)
02298         {
02299             jit_object_error((t_object *)x,"jit.gl.texture: unsupported texture format!");
02300             return err;
02301         }
02302 
02303         // enable compression for format if supported
02304         err = jit_gl_texture_enable_compression(x);
02305         if(err) return err;
02306 
02307         // special case uyvy 
02308 #ifdef MAC_VERSION
02309         if (x->colormode == ps_jit_gl_colormode_uyvy)   // as used by future calculations
02310             minfo.planecount = planecount = 1; 
02311 #endif
02312         datasize = jit_gl_get_datasize_from_datatype(x->datatype);
02313         texsize = x->width * x->height * MAX(1,x->depth) * planecount * datasize;
02314             
02315         // destroy if size has changed
02316         if(x->destroy || (texsize != x->texsize))
02317         {
02318             TEXTURE_VERBOSE_POST("destroying data.");
02319             jit_gl_texture_destroy_data(x);
02320         }
02321 
02322         // update
02323         x->datasize = datasize;
02324         x->texsize = texsize;
02325 
02326         // convert to data if necessary
02327         err = jit_gl_texture_convert_matrix_data(x, &minfo, bp, &bp);
02328         if(err) return err;
02329 
02330     } 
02331     else if(x->capturing && x->destroy)
02332     {
02333         x->recreate = FALSE;
02334         jit_gl_texture_destroy_existing(x);
02335     }
02336 
02337 
02338 #ifdef MAC_VERSION
02339     // disable dynamic mode for float textures on OSX
02340     if(x->datatype == GL_FLOAT ||
02341        x->datatype == GL_HALF_APPLE )
02342     {
02343         TEXTURE_VERBOSE_POST("disabling dynamic mode for float texture on OS X");
02344         x->mode = ps_jit_gl_texture_mode_static;        
02345     }
02346 #endif  
02347 
02348     //can't do this stuff if cubemap face
02349     if(x->target != GL_TEXTURE_CUBE_MAP)
02350     {
02351         // generate texture
02352         err = jit_gl_texture_generate(x);
02353         if(err) return err;
02354 
02355         // bind target
02356         err = jit_gl_texture_bind_target(x);
02357         if(err) return err;
02358     }
02359     
02360     // enable target 
02361     err = jit_gl_texture_enable_target(x);
02362     if(err) return err;
02363     // setup texture env modes 
02364     err = jit_gl_texture_enable_texenv(x);
02365     if(err) return err;
02366 
02367     // setup texture coordinate generation 
02368     err = jit_gl_texture_enable_texgen(x);
02369     if(err) return err;
02370         
02371     // set wrap mode for each coord 
02372     err = jit_gl_texture_enable_wrap_mode(x);
02373     if(err) return err;
02374 
02375     // set filter mode 
02376     err = jit_gl_texture_enable_filter_mode(x);
02377     if(err) return err;
02378 
02379 
02380     // enable captured result
02381     if(x->capturing == JIT_GL_TEXTURE_CAPTURE_RESULT && x->readback)
02382     {
02383         TEXTURE_VERBOSE_POST("enabling captured result");
02384         err = jit_gl_readback_bind_attachment(x->readback, 0);
02385         if(err) {
02386             x->destroy = TRUE; // HACK for recreation if getting pbuffer errors-jkc
02387             return err;
02388         }
02389     } 
02390     
02391     // submit data
02392     if(!x->capturing)
02393     {
02394         // set unpack row length and alignment
02395         glPixelStorei(GL_UNPACK_ROW_LENGTH, x->rowlength);
02396         glPixelStorei(GL_UNPACK_ALIGNMENT, x->alignment);
02397         
02398         // submit new texture data 
02399         err = jit_gl_texture_create_storage(x, bp);
02400         if(err) return err;
02401 
02402         // create the dynamic cache
02403         if(x->mode == ps_jit_gl_texture_mode_dynamic)
02404         {
02405             TEXTURE_VERBOSE_POST("creating the dynamic cache");
02406             err = jit_gl_texture_create_dynamic(x, &minfo, bp);
02407             if(err) return err;
02408         }
02409     }
02410 
02411     // set priority 
02412     err = jit_gl_texture_enable_priority(x);
02413     if(err) return err;
02414 
02415     // set up the border color 
02416     err = jit_gl_texture_enable_border(x);
02417     if(err) return err;
02418 
02419     // TEXDEBUG - jkc
02420     if (_jit_gl_texture_verbose) {
02421         TEXTURE_VERBOSE_POST("jit_gl_texture_create(end): texture dim = %d %d %d", x->dim[0],x->dim[1],x->dim[2]);
02422         if (x->matrix) {
02423             t_jit_matrix_info info;
02424             jit_object_method(x->matrix, _jit_sym_getinfo, &info);
02425             TEXTURE_VERBOSE_POST("jit_gl_texture_create(end): matrix dim = %d %d %d; planecount = %d", info.dim[0],info.dim[1],info.dim[2], info.planecount);
02426         }
02427     }
02428 
02429     // reset alignment
02430     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
02431     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
02432     jit_gl_report_error("jit.gl.texture: error restoring unpack alignment.");
02433 
02434     // clear flags
02435     x->update = FALSE;
02436     x->destroy = FALSE;
02437     x->newpixels = FALSE;
02438     return JIT_ERR_NONE;
02439 }
02440 
02441 
02442 /****************************************************************************/
02443 
02444 t_jit_err jit_gl_texture_get_gl_context(t_jit_gl_texture *x, t_jit_gl_context *context)
02445 {
02446     if(x && context)
02447     {
02448         // set the current context
02449         jit_ob3d_set_context(x);
02450         *context = jit_gl_get_context();
02451         return JIT_ERR_NONE;
02452     }
02453     return JIT_ERR_INVALID_PTR;
02454 }
jit.gl.texture.c
