void *max_jit_scissors_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_jit_scissors *x;
void *o, *p, *mop;
t_jit_matrix_info info;
long i;
if (x=(t_max_jit_scissors *)max_jit_obex_new(max_jit_scissors_class, gensym("jit_scissors"))) {
if (o=jit_object_new(gensym("jit_scissors"))) {
max_jit_obex_jitob_set(x, o);
max_jit_obex_dumpout_set(x, outlet_new(x, NULL));
max_jit_mop_setup(x);
max_jit_mop_inputs(x);
max_jit_attr_args(x, argc, argv); // get attr args to know rows and cols
x->maxn = jit_attr_getlong(o, ps_rows) * jit_attr_getlong(o, ps_columns);
max_jit_mop_variable_addoutputs(x, x->maxn);
max_jit_mop_outputs(x);
// don't forget the nolink!
mop = max_jit_obex_adornment_get(x, _jit_sym_jit_mop);
for (i = 1; i <= x->maxn; i++)
jit_mop_output_nolink(mop, i);
jit_attr_setlong(o, gensym("max"), x->maxn);
max_jit_mop_matrix_args(x, argc, argv); // now set matrix info
} else {
jit_object_error((t_object *)x,"jit.scissors: could not allocate object");
freeobject((t_object *) x);
x = NULL;
}
}
return (x);
}
void max_jit_str_op_mproc(t_max_jit_str_op *x, void *mop)
{
long err;
void *o;
long ac = 1;
t_atom a[2];
t_symbol *s;
o = max_jit_obex_jitob_get(x);
jit_attr_setlong(o, gensym("adaptflag"), jit_attr_getlong(mop, _jit_sym_adapt));
if (err=(t_jit_err) jit_object_method(
max_jit_obex_jitob_get(x),
_jit_sym_matrix_calc,
jit_object_method(mop,_jit_sym_getinputlist),
jit_object_method(mop,_jit_sym_getoutputlist)))
{
jit_error_code(x,err);
} else {
s = jit_attr_getsym(o, gensym("op"));
switch(jit_attr_getlong(o, gensym("outmode"))) {
case 0:
max_jit_mop_outputmatrix(x);
break;
case 2:
ac = 2;
jit_atom_setlong(&a[1], jit_attr_getlong(o, gensym("outlong2")));
case 1:
jit_atom_setlong(&a[0], jit_attr_getlong(o, gensym("outlong")));
max_jit_obex_dumpout(x, s, ac, a);
break;
}
}
}
t_jit_err jit_gl_videoplane_draw(t_jit_gl_videoplane *x)
{
t_jit_err result = JIT_ERR_NONE;
GLenum prim;
CLIP (x->nudge,0.,0.5);
prim = (x->gridmode) ? GL_TRIANGLE_STRIP : GL_QUAD_STRIP;
if (x->recalc) {
jit_gl_videoplane_recalc(x);
if (x->displaylist)
{
t_jit_gl_context ctx;
// cache/restore context in case in capture mode
ctx = jit_gl_get_context();
jit_ob3d_set_context(x);
if (x->dlref) {
glDeleteLists(x->dlref,1);
x->dlref = 0;
}
if (x->dlref=glGenLists(1)) {
glNewList(x->dlref, GL_COMPILE);
if (x->chunk&&x->chunk->m_vertex)
draw_grid(x,x->chunk->m_vertex, prim);
glEndList();
}
jit_gl_set_context(ctx);
}
x->recalc = 0;
}
// draw our chunk of OpenGL geometry.
if (x->chunk&&x->chunk->m_vertex) {
if (!jit_attr_getlong(x,gensym("matrixoutput"))) {
if (x->displaylist&&x->dlref)
glCallList(x->dlref);
else
draw_grid(x,x->chunk->m_vertex, prim);
if(jit_attr_getlong(x, _jit_sym_boundcalc))
jit_object_method(x, gensym("calcbounds"), x->chunk, NULL);
} else{
color_surface(x);
result = jit_ob3d_draw_chunk(x->ob3d, x->chunk); //output matrix
}
}
return result;
}
t_jit_err max_jit_gradient_outputmatrix(t_max_jit_gradient *x)
{
void *mop,*o,*p;
long err=JIT_ERR_NONE;
t_atom a;
if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
return JIT_ERR_GENERIC;
if (jit_attr_getlong(mop,_jit_sym_outputmode)) {
if (err=(t_jit_err) jit_object_method(
max_jit_obex_jitob_get(x),
_jit_sym_matrix_calc,
jit_object_method(mop,_jit_sym_getinputlist),
jit_object_method(mop,_jit_sym_getoutputlist)))
{
jit_error_code(x,err);
} else {
if ((p=jit_object_method(mop,_jit_sym_getoutput,1)) &&
(o=max_jit_mop_io_getoutlet(p)))
{
jit_atom_setsym(&a,jit_attr_getsym(p,_jit_sym_matrixname));
outlet_anything(o,_jit_sym_jit_matrix,1,&a);
}
}
}
return err;
}
t_jit_err jit_gl_hap_draw(t_jit_gl_hap *x)
{
t_jit_err result = JIT_ERR_NONE;
t_jit_gl_drawinfo drawinfo;
if(x->newfile) {
if(x->texture && x->deletetex) {
glDeleteTextures(1, &x->texture);
x->deletetex = 0;
}
x->texture = 0;
jit_gl_hap_load_file(x);
}
if(!x->movieloaded)
return JIT_ERR_NONE;
if(jit_gl_drawinfo_setup(x,&drawinfo))
return JIT_ERR_GENERIC;
jit_gl_hap_getcurrentframe(x);
if(x->validframe) {
GLint previousFBO; // make sure we pop out to the right FBO
#ifdef MAC_VERSION
GLint previousReadFBO;
GLint previousDrawFBO;
#endif
// We are going to bind our FBO to our internal jit.gl.texture as COLOR_0 attachment
// We need the ID, width/height.
GLuint texid = jit_attr_getlong(x->texoutput,ps_glid);
GLuint width = jit_attr_getlong(x->texoutput,ps_width);
GLuint height = jit_attr_getlong(x->texoutput,ps_height);
glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &previousFBO);
#ifdef MAC_VERSION
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &previousReadFBO);
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &previousDrawFBO);
#endif
if(width!=x->dim[0] || height!=x->dim[1]) {
width = x->dim[0];
height = x->dim[1];
jit_attr_setlong_array(x->texoutput, gensym("dim"), 2, x->dim);
jit_attr_user_touch(x, gensym("dim"));
}
if(x->hap_format == JIT_GL_HAP_PF_HAP) {
jit_gl_hap_submit_texture(x);
jit_gl_report_error("jit.gl.hap submit texture");
}
else if(x->hap_format != JIT_GL_HAP_PF_GL) {
jit_gl_hap_submit_nonhap_texture(x);
jit_gl_report_error("jit.gl.hap submit non-hap texture");
}
if(jit_gl_hap_draw_begin(x, texid, width, height)) {
jit_gl_report_error("jit.gl.hap draw begin");
jit_gl_hap_dodraw(x, width, height);
jit_gl_report_error("jit.gl.hap draw texture to FBO");
jit_gl_hap_draw_end(x);
jit_gl_report_error("jit.gl.hap draw end");
}
else {
jit_object_error((t_object*)x, "could not bind to FBO");
}
glPopClientAttrib();
glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, previousFBO);
#ifdef MAC_VERSION
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, previousReadFBO);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, previousDrawFBO);
#endif
x->validframe = 0;
jit_object_notify(x, ps_draw, NULL);
jit_gl_hap_do_report(x);
}
jit_gl_hap_releaseframe(x);
return result;
}
t_jit_err max_jit_str_op_jit_matrix(void *x, t_symbol *s, long argc, t_atom *argv)
{
void *matrix,*matrixout,*mop,*o,*p,*m;
t_atom a;
t_symbol *matrixname;
long err=JIT_ERR_NONE,inlet,i;
method ioproc,mproc;
if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
return JIT_ERR_GENERIC;
if (argc&&argv) {
//find matrix
matrixname = jit_atom_getsym(argv);
matrix = jit_object_findregistered(matrixname);
if (matrix&&jit_object_method(matrix, _jit_sym_class_jit_matrix)) {
if (inlet=max_jit_obex_inletnumber_get(x)) {
//right inputs
if ((p=jit_object_method(mop,_jit_sym_getinput,inlet+1)) &&
(m=jit_object_method(p,_jit_sym_getmatrix)))
{
if (ioproc=(method)jit_object_method(p,_jit_sym_getioproc))
(*ioproc)(mop,p,matrix);
else
jit_object_method(m,_jit_sym_frommatrix,matrix,NULL);
} else {
err=JIT_ERR_GENERIC;
}
} else {
//calculate
switch (jit_attr_getlong(mop,_jit_sym_outputmode)) {
case 0: //nada
break;
case 2: //input(no calc)
//pass input through leftmost output
if ((p=jit_object_method(mop,_jit_sym_getoutput,1)) &&
(o=max_jit_mop_io_getoutlet(p)))
{
outlet_anything(o,_jit_sym_jit_matrix,1,argv);
}
break;
case 3: //output(no calc)
max_jit_mop_outputmatrix(x);
break;
default: //calc
//if adapt, resize
// if (jit_attr_getlong(mop,_jit_sym_adapt))
// max_jit_mop_adapt_matrix_all(x,matrix);
if ((p=jit_object_method(mop,_jit_sym_getoutput,1))&&
(ioproc=(method)jit_object_method(p,_jit_sym_getioproc)))
{
(*ioproc)(mop,p,matrix);
}
p = jit_object_method(mop,_jit_sym_getinput,1);
jit_object_method(p,_jit_sym_matrix,matrix);
jit_attr_setsym(p,_jit_sym_matrixname,matrixname);
// if (mproc=(method)max_jit_mop_getmproc(mop)) {
max_jit_str_op_mproc(x,mop);
/* } else {
if (err=(t_jit_err) jit_object_method(
max_jit_obex_jitob_get(x),
_jit_sym_matrix_calc,
jit_object_method(mop,_jit_sym_getinputlist),
jit_object_method(mop,_jit_sym_getoutputlist)))
{
jit_error_code(x,err);
} else {
max_jit_mop_outputmatrix(x);
}
}*/
break;
}
}
} else {
jit_error_code(x,JIT_ERR_MATRIX_UNKNOWN);
}
}
return err;
}
