[GEM-cvs] Gem/src/openGL GEMglProgramStringARB.cpp,NONE,1.1 GEMglProgramEnvParameter4dARB.cpp,NONE,1.1 GEMglProgramEnvParameter4fvARB.h,1.1,1.2 GEMglGenProgramsARB.h,NONE,1.1 GEMglBindProgramARB.cpp,NONE,1.1 GEMglProgramEnvParameter4fvARB.cpp,1.1,1.2 GEMglProgramLocalParameter4fvARB.cpp,NONE,1.1 GEMglGenProgramsARB.cpp,NONE,1.1 GEMglProgramLocalParameter4fvARB.h,NONE,1.1 GEMglProgramStringARB.h,NONE,1.1 GEMglBindProgramARB.h,NONE,1.1 GEMglProgramEnvParameter4dARB.h,NONE,1.1

[Jamie T. <ti...@us...>]

Update of /cvsroot/pd-gem/Gem/src/openGL
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1780

Added Files:
	GEMglProgramStringARB.cpp GEMglProgramEnvParameter4dARB.cpp 
	GEMglProgramEnvParameter4fvARB.h GEMglGenProgramsARB.h 
	GEMglBindProgramARB.cpp GEMglProgramEnvParameter4fvARB.cpp 
	GEMglProgramLocalParameter4fvARB.cpp GEMglGenProgramsARB.cpp 
	GEMglProgramLocalParameter4fvARB.h GEMglProgramStringARB.h 
	GEMglBindProgramARB.h GEMglProgramEnvParameter4dARB.h 
Log Message:
some wrappers for gl "program" stuff:  should be ok for any GL with ARB_vertex_program and/or ARB_fragment_program defined

--- NEW FILE: GEMglProgramLocalParameter4fvARB.h ---
 /* ------------------------------------------------------------------
  * GEM - Graphics Environment for Multimedia
  *
  *  Copyright (c) 2004 ti...@ma...
  *  For information on usage and redistribution, and for a DISCLAIMER
  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
  *
  * ------------------------------------------------------------------
  */

#ifndef INCLUDE_GEM_GLPROGRAMENVPARAMETER4FVARB_H_
#define INCLUDE_GEM_GLPROGRAMENVPARAMETER4FVARB_H_

#include "Base/GemGLUtil.h"
#include "Base/GemBase.h"

/*
 CLASS
	GEMglProgramLocalParameter4fvARB
 KEYWORDS
	openGL	0
 DESCRIPTION
	wrapper for the openGL-function
	"glProgramLocalParameter4fvARB( GLenum target, GLuint index, GLfloat *params)"
 */

class GEM_EXTERN GEMglProgramLocalParameter4fvARB : public GemBase
{
	CPPEXTERN_HEADER(GEMglProgramLocalParameter4fvARB, GemBase)

	public:
	  // Constructor
	  GEMglProgramLocalParameter4fvARB (t_float, t_float, t_float);	// CON

	protected:
	  // Destructor
	  virtual ~GEMglProgramLocalParameter4fvARB ();
	  // Do the rendering
	  virtual void	render (GemState *state);

	// variables
	  GLenum	target;		// VAR
	  virtual void	targetMess(t_float);	// FUN

	  GLuint	index;		// VAR
	  virtual void	indexMess(t_float);	// FUN

	  GLfloat	params[4];		// VAR
	  virtual void	paramsMess(int argc, t_atom* argv);	// FUN


	private:

	// we need some inlets
	  t_inlet *m_inlet[3];

	// static member functions
	  static void	 targetMessCallback (void*, t_floatarg);
	  static void	 indexMessCallback (void*, t_floatarg);
	  static void	 paramsMessCallback (void*, t_symbol*,int, t_atom*);
};
#endif // for header file

--- NEW FILE: GEMglProgramEnvParameter4fvARB.h ---
 /* ------------------------------------------------------------------
  * GEM - Graphics Environment for Multimedia
  *
  *  Copyright (c) 2004 ti...@ma...
  *  For information on usage and redistribution, and for a DISCLAIMER
  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
  *
  * ------------------------------------------------------------------
  */

#ifndef INCLUDE_GEM_GLPROGRAMENVPARAMETER4FVARB_H_
#define INCLUDE_GEM_GLPROGRAMENVPARAMETER4FVARB_H_

#include "Base/GemGLUtil.h"
#include "Base/GemBase.h"

/*
 CLASS
	GEMglProgramEnvParameter4fvARB
 KEYWORDS
	openGL	0
 DESCRIPTION
	wrapper for the openGL-function
	"glProgramEnvParameter4fvARB( GLenum target, GLuint index, GLfloat *params)"
		target = GL_VERTEX_PROGRAM_ARB or GL_FRAGMENT_PROGRAM_ARB
		index = id number of program
		params = vector of 4 floats
 */

class GEM_EXTERN GEMglProgramEnvParameter4fvARB : public GemBase
{
	CPPEXTERN_HEADER(GEMglProgramEnvParameter4fvARB, GemBase)

	public:
	  // Constructor
	  GEMglProgramEnvParameter4fvARB (t_float, t_float, t_float);	// CON

	protected:
	  // Destructor
	  virtual ~GEMglProgramEnvParameter4fvARB ();
	  // Do the rendering
	  virtual void	render (GemState *state);

	// variables
	  GLenum	target;		// VAR
	  virtual void	targetMess(t_float);	// FUN

	  GLuint	index;		// VAR
	  virtual void	indexMess(t_float);	// FUN

	  GLfloat	params[4];		// VAR
	  virtual void	paramsMess(int argc, t_atom* argv);	// FUN


	private:

	// we need some inlets
	  t_inlet *m_inlet[3];

	// static member functions
	  static void	 targetMessCallback (void*, t_floatarg);
	  static void	 indexMessCallback (void*, t_floatarg);
	  static void	 paramsMessCallback (void*, t_symbol*, int, t_atom*);
};
#endif // for header file

--- NEW FILE: GEMglBindProgramARB.cpp ---
////////////////////////////////////////////////////////
//
// GEM - Graphics Environment for Multimedia
//
// Implementation file
//
// Copyright (c) 2004 ti...@ma...
//  For information on usage and redistribution, and for a DISCLAIMER
//  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
//
////////////////////////////////////////////////////////

#include "GEMglBindProgramARB.h"

CPPEXTERN_NEW_WITH_TWO_ARGS ( GEMglBindProgramARB , t_floatarg, A_DEFFLOAT, t_floatarg, A_DEFFLOAT)

/////////////////////////////////////////////////////////
//
// GEMglViewport
//
/////////////////////////////////////////////////////////
// Constructor
//
GEMglBindProgramARB :: GEMglBindProgramARB	(t_floatarg arg0=0, t_floatarg arg1=0) :
		target((GLenum)arg0), 
		program((GLuint)arg1)
{
#ifndef GL_ARB_vertex_program
        error("GEMglBindProgramARB: GEM was compiled without GL_ARB_vertex_program");
        error("GEMglBindProgramARB: therefore this object will do nothing");
#endif
	m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("target"));
	m_inlet[1] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("program"));
}
/////////////////////////////////////////////////////////
// Destructor
//
GEMglBindProgramARB :: ~GEMglBindProgramARB () {
inlet_free(m_inlet[0]);
inlet_free(m_inlet[1]);
}

/////////////////////////////////////////////////////////
// Render
//
void GEMglBindProgramARB :: render(GemState *state) {
#ifdef GL_ARB_vertex_program
	glBindProgramARB (target, program);
#endif // GL_ARB_vertex_program
}

/////////////////////////////////////////////////////////
// Variables
//
void GEMglBindProgramARB :: targetMess (t_float arg1) {	// FUN
	target = (GLenum)arg1;
	setModified();
}

void GEMglBindProgramARB :: programMess (t_float arg1) {	// FUN
	program = (GLuint)arg1;
	setModified();
}


/////////////////////////////////////////////////////////
// static member functions
//

void GEMglBindProgramARB :: obj_setupCallback(t_class *classPtr) {
	 class_addmethod(classPtr, (t_method)&GEMglBindProgramARB::targetMessCallback,  	gensym("target"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglBindProgramARB::programMessCallback,  	gensym("program"), A_DEFFLOAT, A_NULL);
}

void GEMglBindProgramARB :: targetMessCallback (void* data, t_floatarg arg0){
	GetMyClass(data)->targetMess ( (t_float)    arg0);
}
void GEMglBindProgramARB :: programMessCallback (void* data, t_floatarg arg0){
	GetMyClass(data)->programMess ( (t_float)    arg0);
}

--- NEW FILE: GEMglProgramEnvParameter4dARB.cpp ---
////////////////////////////////////////////////////////
//
// GEM - Graphics Environment for Multimedia
//
// Implementation file
//
// Copyright (c) 2004 ti...@ma...
//  For information on usage and redistribution, and for a DISCLAIMER
//  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
//
////////////////////////////////////////////////////////

#include "GEMglProgramEnvParameter4dARB.h"

CPPEXTERN_NEW_WITH_GIMME ( GEMglProgramEnvParameter4dARB )

/////////////////////////////////////////////////////////
//
// GEMglProgramEnvParameter4dARB
//
/////////////////////////////////////////////////////////
// Constructor
//
GEMglProgramEnvParameter4dARB :: GEMglProgramEnvParameter4dARB	(int argc, t_atom*argv ) :
		target(0), index(0), 
		m_x(0), m_y(0), m_z(0), m_w(0)
{
#ifndef GL_ARB_vertex_program
        error("GEMglProgramEnvParameter4dARB: GEM was compiled without GL_ARB_vertex_program");
        error("GEMglProgramEnvParameter4dARB: therefore this object will do nothing");
#endif
	m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("target"));
	m_inlet[1] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("index"));
	m_inlet[2] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("x"));
	m_inlet[3] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("y"));
	m_inlet[4] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("z"));
	m_inlet[5] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("w"));
}
/////////////////////////////////////////////////////////
// Destructor
//
GEMglProgramEnvParameter4dARB :: ~GEMglProgramEnvParameter4dARB () {
inlet_free(m_inlet[0]);
inlet_free(m_inlet[1]);
inlet_free(m_inlet[2]);
inlet_free(m_inlet[3]);
inlet_free(m_inlet[4]);
inlet_free(m_inlet[5]);
}

/////////////////////////////////////////////////////////
// Render
//
void GEMglProgramEnvParameter4dARB :: render(GemState *state) {
#ifndef GL_ARB_vertex_program
	glProgramEnvParameter4dARB (target, index, m_x, m_y, m_z, m_w);
#endif
}

/////////////////////////////////////////////////////////
// Variables
//
void GEMglProgramEnvParameter4dARB :: targetMess (t_float arg1) {	// FUN
	target = (GLenum)arg1;
	post("target = %i",target);
	setModified();
}

void GEMglProgramEnvParameter4dARB :: indexMess (t_float arg2) {	// FUN
	index = (GLenum)arg2;
	post("index = %i",index);
	setModified();
}

void GEMglProgramEnvParameter4dARB :: xMess (t_float arg2) {	// FUN
	m_x = (GLdouble)arg2;
	post("m_x = %d",m_x);
	setModified();
}

void GEMglProgramEnvParameter4dARB :: yMess (t_float arg3) {	// FUN
	m_y = (GLdouble)arg3;
	post("m_y = %d",m_y);
	setModified();
}

void GEMglProgramEnvParameter4dARB :: zMess (t_float arg4) {	// FUN
	m_z = (GLdouble)arg4;
	post("m_z = %d",m_z);
	setModified();
}
void GEMglProgramEnvParameter4dARB :: wMess (t_float arg5) {	// FUN
	m_w = (GLdouble)arg5;
	post("m_w = %d",m_w);
	setModified();
}
/////////////////////////////////////////////////////////
// static member functions
//

void GEMglProgramEnvParameter4dARB :: obj_setupCallback(t_class *classPtr) {
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4dARB::targetMessCallback,  	gensym("target"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4dARB::indexMessCallback,  	gensym("index"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4dARB::xMessCallback,  	gensym("x"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4dARB::yMessCallback,  	gensym("y"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4dARB::zMessCallback,  	gensym("z"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4dARB::wMessCallback,  	gensym("w"), A_DEFFLOAT, A_NULL);
};

void GEMglProgramEnvParameter4dARB :: targetMessCallback (void* data, t_floatarg arg0){
	GetMyClass(data)->targetMess ( (t_float)    arg0);
}
void GEMglProgramEnvParameter4dARB :: indexMessCallback (void* data, t_floatarg arg1){
	GetMyClass(data)->indexMess ( (t_float)    arg1);
}
void GEMglProgramEnvParameter4dARB :: xMessCallback (void* data, t_floatarg arg2){
	GetMyClass(data)->xMess ( (t_float)    arg2);
}
void GEMglProgramEnvParameter4dARB :: yMessCallback (void* data, t_floatarg arg3){
	GetMyClass(data)->yMess ( (t_float)    arg3);
}
void GEMglProgramEnvParameter4dARB :: zMessCallback (void* data, t_floatarg arg4){
	GetMyClass(data)->zMess ( (t_float)    arg4);
}
void GEMglProgramEnvParameter4dARB :: wMessCallback (void* data, t_floatarg arg5){
	GetMyClass(data)->wMess ( (t_float)    arg5);
}
--- NEW FILE: GEMglProgramStringARB.cpp ---
////////////////////////////////////////////////////////
//
// GEM - Graphics Environment for Multimedia
//
// Implementation file
//
// Copyright (c) 2004 ti...@ma...
//  For information on usage and redistribution, and for a DISCLAIMER
//  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
//
////////////////////////////////////////////////////////

#include "GEMglProgramStringARB.h"

CPPEXTERN_NEW_WITH_FOUR_ARGS ( GEMglProgramStringARB , t_floatarg, A_DEFFLOAT, t_floatarg, A_DEFFLOAT, t_floatarg, A_DEFFLOAT, t_symbol*, A_DEFSYMBOL)

/////////////////////////////////////////////////////////
//
// GEMglProgramStringARB
//
/////////////////////////////////////////////////////////
// Constructor
//
GEMglProgramStringARB :: GEMglProgramStringARB	(t_floatarg arg0=0, t_floatarg arg1=0, t_floatarg arg2=0, t_symbol* arg3=0) :
		target((GLenum)arg0), 
		format((GLenum)arg1), 
		len((GLsizei)arg2)
{
#ifndef GL_ARB_vertex_program
        error("GEMglProgramStringARB: GEM was compiled without GL_ARB_vertex_program");
        error("GEMglProgramStringARB: therefore this object will do nothing");
#endif
    string = (GLvoid*)arg3->s_name;
	m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("target"));
	m_inlet[1] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("format"));
	m_inlet[2] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("len"));
	m_inlet[3] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_symbol, gensym("string"));
}
/////////////////////////////////////////////////////////
// Destructor
//
GEMglProgramStringARB :: ~GEMglProgramStringARB ()
{
	inlet_free(m_inlet[0]);
	inlet_free(m_inlet[1]);
	inlet_free(m_inlet[2]);
	inlet_free(m_inlet[3]);
}

/////////////////////////////////////////////////////////
// Render
//
void GEMglProgramStringARB :: render(GemState *state) 
{
#ifndef GL_ARB_vertex_program
	glProgramStringARB (target, format, len, string);
#endif
}

/////////////////////////////////////////////////////////
// Variables
//
void GEMglProgramStringARB :: targetMess (t_float arg1) {	// FUN
	target = (GLenum)arg1;
	setModified();
}

void GEMglProgramStringARB :: formatMess (t_float arg1) {	// FUN
	format = (GLenum)arg1;
	setModified();
}

void GEMglProgramStringARB :: lenMess (t_float arg1) {	// FUN
	len = (GLsizei)arg1;
	setModified();
}

void GEMglProgramStringARB :: stringMess (t_symbol* arg1) {	// FUN
	string = (GLvoid*)arg1->s_name;
	setModified();
}


/////////////////////////////////////////////////////////
// static member functions
//

void GEMglProgramStringARB :: obj_setupCallback(t_class *classPtr) {
	 class_addmethod(classPtr, (t_method)&GEMglProgramStringARB::targetMessCallback,
									gensym("target"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramStringARB::formatMessCallback, 
									gensym("format"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramStringARB::lenMessCallback, 
									gensym("len"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramStringARB::stringMessCallback, 
									gensym("string"), A_DEFSYMBOL, A_NULL);
};

void GEMglProgramStringARB :: targetMessCallback (void* data, t_floatarg arg0){
	GetMyClass(data)->targetMess ( (t_float)    arg0);
}
void GEMglProgramStringARB :: formatMessCallback (void* data, t_floatarg arg1){
	GetMyClass(data)->formatMess ( (t_float)    arg1);
}
void GEMglProgramStringARB :: lenMessCallback (void* data, t_floatarg arg2){
	GetMyClass(data)->lenMess ( (t_float)    arg2);
}
void GEMglProgramStringARB :: stringMessCallback (void* data, t_symbol* arg3){
	GetMyClass(data)->stringMess ( (t_symbol*)    arg3);
}

--- NEW FILE: GEMglProgramEnvParameter4dARB.h ---
 /* ------------------------------------------------------------------
  * GEM - Graphics Environment for Multimedia
  *
  *  Copyright (c) 2004 ti...@ma...
  *  For information on usage and redistribution, and for a DISCLAIMER
  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
  *
  * ------------------------------------------------------------------
  */

#ifndef INCLUDE_GEM_GLPROGRAMENVPARAMETER4DARB_H_
#define INCLUDE_GEM_GLPROGRAMENVPARAMETER4DARB_H_

#include "Base/GemGLUtil.h"
#include "Base/GemBase.h"

/*
 CLASS
	GEMglProgramEnvParameter4dARB
 KEYWORDS
	openGL	0
 DESCRIPTION
	wrapper for the openGL-function
	"glProgramEnvParameter4dARB( GLenum target, GLuint index, GLdouble x,
									GLdouble y, GLdouble z, GLdouble w)"
 */

class GEM_EXTERN GEMglProgramEnvParameter4dARB : public GemBase
{
	CPPEXTERN_HEADER(GEMglProgramEnvParameter4dARB, GemBase)

	public:
	  // Constructor
	  GEMglProgramEnvParameter4dARB (int, t_atom*);	// CON

	protected:
	  // Destructor
	  virtual ~GEMglProgramEnvParameter4dARB ();
	  // Do the rendering
	  virtual void	render (GemState *state);

	// variables
	  GLenum	target;		// VAR
	  virtual void	targetMess(t_float);	// FUN

	  GLuint	index;		// VAR
	  virtual void	indexMess(t_float);	// FUN

	  GLdouble	m_x, m_y, m_z, m_w;		// VAR
	  virtual void	xMess(t_float);	// FUN
	  virtual void	yMess(t_float);	// FUN
	  virtual void	zMess(t_float);	// FUN
	  virtual void	wMess(t_float);	// FUN
	  
	  // this is protected because subclasses might want to use it
	  static void 	paramMessCallback(void *data, t_symbol*, int, t_atom*);

	private:

	// we need some inlets
	  t_inlet *m_inlet[6];

	// static member functions
	  static void	 targetMessCallback (void*, t_floatarg);
	  static void	 indexMessCallback (void*, t_floatarg);
	  static void	 xMessCallback (void*, t_floatarg);
	  static void	 yMessCallback (void*, t_floatarg);
	  static void	 zMessCallback (void*, t_floatarg);
	  static void	 wMessCallback (void*, t_floatarg);
};
#endif // for header file

--- NEW FILE: GEMglProgramStringARB.h ---
 /* ------------------------------------------------------------------
  * GEM - Graphics Environment for Multimedia
  *
  *  Copyright (c) 2004 ti...@ma...
  *  For information on usage and redistribution, and for a DISCLAIMER
  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
  *
  * ------------------------------------------------------------------
  */

#ifndef INCLUDE_GEM_GLPROGRAMSTRINGARB_H_
#define INCLUDE_GEM_GLPROGRAMSTRINGARB_H_

#include "Base/GemGLUtil.h"
#include "Base/GemBase.h"

/*
 CLASS
	GEMglProgramStringARB
 KEYWORDS
	openGL	0
 DESCRIPTION
	wrapper for the openGL-function
	"glProgramStringARB( GLenum target, GLenum format, GLsizei len, GLvoid *string)"
 */

class GEM_EXTERN GEMglProgramStringARB : public GemBase
{
	CPPEXTERN_HEADER(GEMglProgramStringARB, GemBase)

	public:
	  // Constructor
	  GEMglProgramStringARB (t_float, t_float, t_float, t_symbol*);	// CON

	protected:
	  // Destructor
	  virtual ~GEMglProgramStringARB ();
	  // Do the rendering
	  virtual void	render (GemState *state);

	// variables
	  GLenum		target;		// VAR
	  virtual void	targetMess(t_float);	// FUN

	  GLenum		format;		// VAR
	  virtual void	formatMess(t_float);	// FUN

	  GLsizei		len;		// VAR
	  virtual void	lenMess(t_float);	// FUN

	  GLvoid	*string;		// VAR
	  virtual void	stringMess(t_symbol*);	// FUN


	private:

	// we need some inlets
	  t_inlet *m_inlet[4];

	// static member functions
	  static void	 targetMessCallback (void*, t_floatarg);
	  static void	 formatMessCallback (void*, t_floatarg);
	  static void	 lenMessCallback (void*, t_floatarg);
	  static void	 stringMessCallback (void*, t_symbol*);
};
#endif // for header file

--- NEW FILE: GEMglGenProgramsARB.cpp ---
////////////////////////////////////////////////////////
//
// GEM - Graphics Environment for Multimedia
//
// Implementation file
//
// Copyright (c) 2004 ti...@ma...
//  For information on usage and redistribution, and for a DISCLAIMER
//  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
//
////////////////////////////////////////////////////////

#include "GEMglGenProgramsARB.h"

CPPEXTERN_NEW_WITH_GIMME ( GEMglGenProgramsARB)

/////////////////////////////////////////////////////////
//
// GEMglGenProgramsARB
//
/////////////////////////////////////////////////////////
// Constructor
//
GEMglGenProgramsARB :: GEMglGenProgramsARB	(int argc, t_atom*argv) {
#ifndef GL_ARB_vertex_program
        error("GEMglGenProgramsARB: GEM was compiled without GL_ARB_vertex_program");
        error("GEMglGenProgramsARB: therefore this object will do nothing");
#endif
	programsMess(argc, argv);
	
	m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("programs"));

}
/////////////////////////////////////////////////////////
// Destructor
//
GEMglGenProgramsARB :: ~GEMglGenProgramsARB () {
inlet_free(m_inlet);
}

/////////////////////////////////////////////////////////
// Render
//
void GEMglGenProgramsARB :: render(GemState *state) {
#ifdef GL_ARB_vertex_program
	glGenProgramsARB (n, programs);
#endif // GL_ARB_vertex_program
}

/////////////////////////////////////////////////////////
// Variables
//
void GEMglGenProgramsARB :: programsMess (int argc, t_atom*argv) {	// FUN
  n=0;
  delete [] programs;
  programs = new GLuint[argc];
  while(argc--){
    if(argv->a_type == A_FLOAT)programs[n++] = (GLuint)atom_getint(argv);
    argv++;
  }
  setModified();
}



/////////////////////////////////////////////////////////
// static member functions
//

void GEMglGenProgramsARB :: obj_setupCallback(t_class *classPtr) {
	 class_addmethod(classPtr, (t_method)&GEMglGenProgramsARB::programsMessCallback,  	gensym("programs"), A_GIMME, A_NULL);
}
void GEMglGenProgramsARB :: programsMessCallback (void* data, int argc, t_atom*argv){
	GetMyClass(data)->programsMess (argc,argv);
}

--- NEW FILE: GEMglGenProgramsARB.h ---
 /* ------------------------------------------------------------------
  * GEM - Graphics Environment for Multimedia
  *
  *  Copyright (c) 2004 tigital -> mac.com
  *  For information on usage and redistribution, and for a DISCLAIMER
  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
  *
  * ------------------------------------------------------------------
  */

#ifndef INCLUDE_GEM_GLGENPROGRAMSARB_H_
#define INCLUDE_GEM_GLGENPROGRAMSARB_H_

#include "Base/GemGLUtil.h"
#include "Base/GemBase.h"

/*
 CLASS
	GEMglGenProgramsARB
 KEYWORDS
	openGL	1
 DESCRIPTION
	wrapper for the openGL-function
	"glGenProgramsARB( GLsizei n, GLuint *programs)"
 */

class GEM_EXTERN GEMglGenProgramsARB : public GemBase
{
	CPPEXTERN_HEADER(GEMglGenProgramsARB, GemBase)

	public:
	  // Constructor
	  GEMglGenProgramsARB (int,t_atom*);	// CON

	protected:
	  // Destructor
	  virtual ~GEMglGenProgramsARB ();
	  // Do the rendering
	  virtual void	render (GemState *state);

	// variables
	  GLsizei	n;		// VAR
	  GLuint*	programs;		// VAR
	  virtual void	programsMess(int,t_atom*);	// FUN


	private:

	// we need some inlets
	  t_inlet *m_inlet;

	// static member functions
	  static void	 programsMessCallback (void*, int, t_atom*);
};
#endif // for header file

--- NEW FILE: GEMglBindProgramARB.h ---
 /* ------------------------------------------------------------------
  * GEM - Graphics Environment for Multimedia
  *
  *  Copyright (c) 2004 ti...@ma...
  *  For information on usage and redistribution, and for a DISCLAIMER
  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
  * ------------------------------------------------------------------
  */

#ifndef INCLUDE_GEM_GLBINDPROGRAMARB_H_
#define INCLUDE_GEM_GLBINDPROGRAMARB_H_

#include "Base/GemGLUtil.h"
#include "Base/GemBase.h"

/*
 CLASS
	GEMglBindProgramARB
 KEYWORDS
	openGL	0
 DESCRIPTION
	wrapper for the openGL-function
	"glBindProgramARB( GLenum target, GLuint program)"
 */

class GEM_EXTERN GEMglBindProgramARB : public GemBase
{
	CPPEXTERN_HEADER(GEMglBindProgramARB, GemBase)

	public:
	  // Constructor
	  GEMglBindProgramARB (t_float, t_float);	// CON

	protected:
	  // Destructor
	  virtual ~GEMglBindProgramARB ();
	  // Do the rendering
	  virtual void	render (GemState *state);

	// variables
	  GLenum	target;		// VAR
	  virtual void	targetMess(t_float);	// FUN

	  GLuint	program;		// VAR
	  virtual void	programMess(t_float);	// FUN


	private:

	// we need some inlets
	  t_inlet *m_inlet[2];

	// static member functions
	  static void	 targetMessCallback (void*, t_floatarg);
	  static void	 programMessCallback (void*, t_floatarg);
};
#endif // for header file

--- NEW FILE: GEMglProgramEnvParameter4fvARB.cpp ---
////////////////////////////////////////////////////////
//
// GEM - Graphics Environment for Multimedia
//
// Implementation file
//
// Copyright (c) 2004 ti...@ma...
//  For information on usage and redistribution, and for a DISCLAIMER
//  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
//
////////////////////////////////////////////////////////

#include "GEMglProgramEnvParameter4fvARB.h"

CPPEXTERN_NEW_WITH_THREE_ARGS ( GEMglProgramEnvParameter4fvARB , t_floatarg, A_DEFFLOAT, t_floatarg, A_DEFFLOAT, t_floatarg, A_DEFFLOAT)

/////////////////////////////////////////////////////////
//
// GEMglProgramEnvParameter4fvARB
//
/////////////////////////////////////////////////////////
// Constructor
//
GEMglProgramEnvParameter4fvARB :: GEMglProgramEnvParameter4fvARB	(t_floatarg arg0=0, t_floatarg arg1=0, t_floatarg arg2=0) :
		target((GLenum)arg0), 
		index((GLenum)arg1) 
		//params((GLfloat)arg2)
{
#ifndef GL_ARB_vertex_program
        error("GEMglProgramEnvParameter4fvARB: GEM was compiled without GL_ARB_vertex_program");
        error("GEMglProgramEnvParameter4fvARB: therefore this object will do nothing");
#endif
	m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("target"));
	m_inlet[1] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("index"));
	m_inlet[2] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("params"));
}
/////////////////////////////////////////////////////////
// Destructor
//
GEMglProgramEnvParameter4fvARB :: ~GEMglProgramEnvParameter4fvARB () {
inlet_free(m_inlet[0]);
inlet_free(m_inlet[1]);
inlet_free(m_inlet[2]);
}

/////////////////////////////////////////////////////////
// Render
//
void GEMglProgramEnvParameter4fvARB :: render(GemState *state) {
#ifndef GL_ARB_vertex_program
	glProgramEnvParameter4fvARB (target, index, params);
#endif
}

/////////////////////////////////////////////////////////
// Variables
//
void GEMglProgramEnvParameter4fvARB :: targetMess (t_float arg1) {	// FUN
	target = (GLenum)arg1;
	setModified();
}

void GEMglProgramEnvParameter4fvARB :: indexMess (t_float arg1) {	// FUN
	index = (GLenum)arg1;
	setModified();
}

void GEMglProgramEnvParameter4fvARB :: paramsMess (int argc, t_atom*argv) {	// FUN
	if(argc!=4){
		post("GEMglProgramEnvParameter4vARB:  needs 4 elements");
		return;
	}
	int i;
	for (i=0;i<4;i++){
		params[i] = (GLfloat)atom_getfloat(argv+i);
		//post("params[%i] = %f\n",i,params[i]);
	}
	setModified();
}


/////////////////////////////////////////////////////////
// static member functions
//

void GEMglProgramEnvParameter4fvARB :: obj_setupCallback(t_class *classPtr) {
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4fvARB::targetMessCallback,  	gensym("target"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4fvARB::indexMessCallback,  	gensym("index"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramEnvParameter4fvARB::paramsMessCallback,  	gensym("params"), A_GIMME, A_NULL);
};

void GEMglProgramEnvParameter4fvARB :: targetMessCallback (void* data, t_floatarg arg0){
	GetMyClass(data)->targetMess ( (t_float)    arg0);
}
void GEMglProgramEnvParameter4fvARB :: indexMessCallback (void* data, t_floatarg arg0){
	GetMyClass(data)->indexMess ( (t_float)    arg0);
}
void GEMglProgramEnvParameter4fvARB :: paramsMessCallback (void* data, t_symbol*,int argc, t_atom*argv){
	GetMyClass(data)->paramsMess ( argc, argv );
}

--- NEW FILE: GEMglProgramLocalParameter4fvARB.cpp ---
////////////////////////////////////////////////////////
//
// GEM - Graphics Environment for Multimedia
//
// Implementation file
//
// Copyright (c) 2004 ti...@ma...
//  For information on usage and redistribution, and for a DISCLAIMER
//  *  OF ALL WARRANTIES, see the file, "GEM.LICENSE.TERMS"
//
////////////////////////////////////////////////////////

#include "GEMglProgramLocalParameter4fvARB.h"

CPPEXTERN_NEW_WITH_THREE_ARGS ( GEMglProgramLocalParameter4fvARB , t_floatarg, A_DEFFLOAT, t_floatarg, A_DEFFLOAT, t_floatarg, A_DEFFLOAT)

/////////////////////////////////////////////////////////
//
// GEMglProgramLocalParameter4fvARB
//
/////////////////////////////////////////////////////////
// Constructor
//
GEMglProgramLocalParameter4fvARB :: GEMglProgramLocalParameter4fvARB	(t_floatarg arg0=0, t_floatarg arg1=0, t_floatarg arg2=0) :
		target((GLenum)arg0), 
		index((GLenum)arg1)
		//params((GLfloat)arg2)
{
#ifndef GL_ARB_vertex_program
        error("GEMglProgramLocalParameter4fvARB: GEM was compiled without GL_ARB_vertex_program");
        error("GEMglProgramLocalParameter4fvARB: therefore this object will do nothing");
#endif
	m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("target"));
	m_inlet[1] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("index"));
	m_inlet[2] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("params"));
}
/////////////////////////////////////////////////////////
// Destructor
//
GEMglProgramLocalParameter4fvARB :: ~GEMglProgramLocalParameter4fvARB () {
	inlet_free(m_inlet[0]);
	inlet_free(m_inlet[1]);
	inlet_free(m_inlet[2]);
}

/////////////////////////////////////////////////////////
// Render
//
void GEMglProgramLocalParameter4fvARB :: render(GemState *state) {
#ifndef GL_ARB_vertex_program
	glProgramLocalParameter4fvARB (target, index, params);
#endif
}

/////////////////////////////////////////////////////////
// Variables
//
void GEMglProgramLocalParameter4fvARB :: targetMess (t_float arg1) {	// FUN
	target = (GLenum)arg1;
	setModified();
}

void GEMglProgramLocalParameter4fvARB :: indexMess (t_float arg1) {	// FUN
	index = (GLenum)arg1;
	setModified();
}

void GEMglProgramLocalParameter4fvARB :: paramsMess (int argc, t_atom*argv) {	// FUN
	if(argc!=4){
		post("GEMglProgramLocalParamter4vARB:  needs 4 elements");
		return;
	}
	int i;
	for (i=0;i<4;i++){
		params[i] = (GLfloat)atom_getfloat(argv+i);
		post("params[%i] = %f\n",i,params[i]);
	}
	setModified();
}


/////////////////////////////////////////////////////////
// static member functions
//

void GEMglProgramLocalParameter4fvARB :: obj_setupCallback(t_class *classPtr) {
	 class_addmethod(classPtr, (t_method)&GEMglProgramLocalParameter4fvARB::targetMessCallback,  	gensym("target"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramLocalParameter4fvARB::indexMessCallback,  	gensym("index"), A_DEFFLOAT, A_NULL);
	 class_addmethod(classPtr, (t_method)&GEMglProgramLocalParameter4fvARB::paramsMessCallback,  	gensym("params"), A_GIMME, A_NULL);
};

void GEMglProgramLocalParameter4fvARB :: targetMessCallback (void* data, t_floatarg arg0){
	GetMyClass(data)->targetMess ( (t_float)    arg0);
}
void GEMglProgramLocalParameter4fvARB :: indexMessCallback (void* data, t_floatarg arg0){
	GetMyClass(data)->indexMess ( (t_float)    arg0);
}
void GEMglProgramLocalParameter4fvARB :: paramsMessCallback (void* data, t_symbol*, int argc, t_atom* argv){
	GetMyClass(data)->paramsMess ( argc, argv);
}