static void ssaofilter(Framebuffer *mrtfbo, Texture *noise, float t, float ballsize, float darken) {
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gluePrepareflags(0);
glClear(GL_COLOR_BUFFER_BIT);
glueSet2d(GLUE_NO_DEPTH);
glUseProgramObjectARB(shader_ssao);
glUniform1fARB(glGetUniformLocationARB(shader_ssao, "t"), t);
glUniform1fARB(glGetUniformLocationARB(shader_ssao, "ballsize"), ballsize);
glUniform1fARB(glGetUniformLocationARB(shader_ssao, "darken"), darken);
glUniform2fARB(glGetUniformLocationARB(shader_ssao, "pixel"), 1.0/(float)mrtfbo->xres, 1.0/(float)mrtfbo->yres);
//glueGlsl_bindtex(shader_ssao, "colortex", mrtfbo->texnum, 0, GL_TEXTURE_2D, GLUE_CLAMP|GLUE_NO_MIPMAP|GLUE_NEAREST);
glueGlsl_bindtex(shader_ssao, "depthtex", mrtfbo->texnum2, 0, GL_TEXTURE_2D, GLUE_CLAMP|GLUE_NO_MIPMAP|GLUE_NEAREST);
glueGlsl_bindtex(shader_ssao, "noise", noise->texnum, 1, GL_TEXTURE_2D, GLUE_NO_MIPMAP|GLUE_NEAREST);
glue2dquad();
glUseProgramObjectARB(0);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
static void dstrukt(Framebuffer *src, float blockpow, float sinpow, float linepow, float colorsep, float t) {
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gluePrepareflags(0);
glClear(GL_COLOR_BUFFER_BIT);
glueSet2d(GLUE_NO_DEPTH);
glUseProgramObjectARB(shader_dstrukt);
glueGlsl_bindtex(shader_dstrukt, "t_color", src->texnum, 0, GL_TEXTURE_2D, GLUE_NO_MIPMAP|GLUE_CLAMP);
glueGlsl_bindtex(shader_dstrukt, "t_noise", noisetex->texnum, 1, GL_TEXTURE_2D, GLUE_NO_MIPMAP|GLUE_NEAREST);
glUniform1fARB(glGetUniformLocationARB(shader_dstrukt, "blockpow"), blockpow);
glUniform1fARB(glGetUniformLocationARB(shader_dstrukt, "sinpow"), sinpow);
glUniform1fARB(glGetUniformLocationARB(shader_dstrukt, "linepow"), linepow);
glUniform1fARB(glGetUniformLocationARB(shader_dstrukt, "colorsep"), colorsep);
glUniform1fARB(glGetUniformLocationARB(shader_dstrukt, "time"), t);
glue2dquad();
glUseProgramObjectARB(0);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
void setShaderVariables(GLuint bubbleShaderProg)
{
GLfloat projMatrix[16];
GLfloat viewMatrix[16];
glGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
glGetFloatv(GL_MODELVIEW_MATRIX, viewMatrix);
if(GL20Support)
{
glUniform1f(glGetUniformLocation(bubbleShaderProg, "elapsedTime"), motionClock.GetElapsedTime());
glUniform1f(glGetUniformLocation(bubbleShaderProg, "near"), _near);
glUniform1f(glGetUniformLocation(bubbleShaderProg, "far"), _far);
glUniform1f(glGetUniformLocation(bubbleShaderProg, "fov"), fov);
glUniform1f(glGetUniformLocation(bubbleShaderProg, "cursorScrollAmount"), cursorScrollAmount);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "resolution"), RES_WIDTH, RES_HEIGHT);
glUniform3f(glGetUniformLocation(bubbleShaderProg, "modelCenter"), center[0], center[1], center[2]);
glUniform3f(glGetUniformLocation(bubbleShaderProg, "cameraPos"), cameraPos[0], cameraPos[1], cameraPos[2]);
glUniform3f(glGetUniformLocation(bubbleShaderProg, "lookAtPos"), lookAtPos[0], lookAtPos[1], lookAtPos[2]);
glUniform3f(glGetUniformLocation(bubbleShaderProg, "cameraUp"), cameraUp[0], cameraUp[1], cameraUp[2]);
glUniformMatrix4fv(glGetUniformLocation(bubbleShaderProg, "projMatrix"), 1, false, projMatrix);
glUniformMatrix4fv(glGetUniformLocation(bubbleShaderProg, "viewMatrix"), 1, false, viewMatrix);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "lightPos"), lightPos[0], lightPos[1]);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "cursorAbsolutePos"), cursorAbsolutePos[0], cursorAbsolutePos[1]);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "cursorDragAmount"), cursorDragAmount[0], cursorDragAmount[1]);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "lastClickPos"), lastClickPos[0], lastClickPos[1]);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "lastFrameDragPos"), lastFrameDragPos[0], lastFrameDragPos[1]);
glUniform1i(glGetUniformLocation(bubbleShaderProg, "mouseButtonDown"), mouseButtonDown);
} else {
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "elapsedTime"), Clock.GetElapsedTime());
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "near"), _near);
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "far"), _far);
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "fov"), fov);
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "cursorScrollAmount"), cursorScrollAmount);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "resolution"), RES_WIDTH, RES_HEIGHT);
glUniform3fARB(glGetUniformLocationARB(bubbleShaderProg, "modelCenter"), center[0], center[1], center[2]);
glUniform3fARB(glGetUniformLocationARB(bubbleShaderProg, "cameraPos"), cameraPos[0], cameraPos[1], cameraPos[2]);
glUniform3fARB(glGetUniformLocationARB(bubbleShaderProg, "lookAtPos"), lookAtPos[0], lookAtPos[1], lookAtPos[2]);
glUniform3fARB(glGetUniformLocationARB(bubbleShaderProg, "cameraUp"), cameraUp[0], cameraUp[1], cameraUp[2]);
glUniformMatrix4fvARB(glGetUniformLocationARB(bubbleShaderProg, "projMatrix"), 1, false, projMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(bubbleShaderProg, "viewMatrix"), 1, false, viewMatrix);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "cursorAbsolutePos"), cursorAbsolutePos[0], cursorAbsolutePos[1]);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "cursorDragAmount"), cursorDragAmount[0], cursorDragAmount[1]);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "lastClickPos"), lastClickPos[0], lastClickPos[1]);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "lastFrameDragPos"), lastFrameDragPos[0], lastFrameDragPos[1]);
glUniform1iARB(glGetUniformLocationARB(bubbleShaderProg, "mouseButtonDown"), mouseButtonDown);
}
}
void Shader::bindResource(const char *name, float *data, int count){
int location = glGetUniformLocationARB(mProgram, name);
//LOG("Got location for %s: %d\n", name, location);
if(location == -1){
LOG("Error binding resource %s (size %d)\n", name, count);
return;
}
if(count == 3){
//Log::debug("location=%d, %f %f %f\n", location, data[0], data[1], data[2]);
}
//LOG("About to call glUniform%df\n", count);
//hacky!
//Is this really the best the GL API has to offer :|?
if(count == 1) glUniform1fARB(location, data[0]);
else if(count == 2) glUniform2fARB(location, data[0], data[1]);
else if(count == 3) glUniform3fARB(location, data[0], data[1], data[2]);
else if(count == 4) glUniform4fARB(location, data[0], data[1], data[2], data[3]);
else{
LOG("Bad count %d in bindResource(%s)\n", count, name);
}
//LOG("Called\n");
}
void WShaderProgram::setValue1f( const char *name, float v1 )
{
GLint loc = glGetUniformLocationARB( programId(), name );
glUniform1fARB( loc, v1 );
GLenum err = glGetError();
const GLubyte *msg = gluErrorString( err );
}
/*
* sendUniform1f
*
* parameter name - char*
* parameter value - GLfloat
* return - bool
*/
bool ShaderObject::sendUniform1f(const char * name, GLfloat value) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniform1fARB(location, value);
return true;
} // end sendUniform1f()
AmbientOcclusionRenderer::AmbientOcclusionRenderer(const Manifold& m, bool smooth, VertexAttributeVector<double>& field, double max_val):
SimpleShaderRenderer(vss,fss)
{
GLint old_prog;
glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
glUseProgram(prog);
GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");
glUniform1fARB(glGetUniformLocationARB(prog, "scalar_max"), max_val);
glNewList(display_list,GL_COMPILE);
for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f) {
if(!smooth)
glNormal3dv(normal(m, *f).get());
if(no_edges(m, *f)== 3)
glBegin(GL_TRIANGLES);
else
glBegin(GL_POLYGON);
for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw())
{
Vec3d n(normal(m, w.vertex()));
if(smooth)
glNormal3dv(n.get());
glVertexAttrib1d(scalar_attrib, field[w.vertex()]);
glVertex3dv(m.pos(w.vertex()).get());
}
glEnd();
}
glEndList();
glUseProgram(old_prog);
}
static void
bind_float_arb (cairo_gl_shader_t *shader,
const char *name,
float value)
{
GLint location = glGetUniformLocationARB (shader->program, name);
assert (location != -1);
glUniform1fARB (location, value);
}
void Shader::SetFloat(std::string name, float value)
{
int uloc = SIG_FindUniform(name);
if (uloc != -1) {
glUniform1fARB(uloc, value);
} else {
SIG_LOG("Could not find uniform \"" << name << "\"");
}
}
bool Shader::sendUniform1f(char* varname, GLfloat v0)
{
GLint loc = GetUniformLocation(varname);
if (loc == -1) return false;
glUniform1fARB(loc, v0);
return true;
}
bool GLSLShader::setUniformFloat( const char *name, const float value )
{
if (!programObj) return false;
int loc = glGetUniformLocationARB( programObj, name );
if (loc < 0)
return false;
glUniform1fARB( loc, value );
return true;
}
void BL_Shader::SetUniform(int uniform, const float& val)
{
if ( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
glUniform1fARB(uniform, val);
}
}
// Set a uniform global parameter of the program by name.
void STShaderProgram::SetUniform(const std::string& name, float value)
{
GLint location = GetUniformLocation(name);
if(GLEW_VERSION_2_0) {
glUniform1f(location, value);
}
else {
glUniform1fARB(location, value);
}
}
int
main()
{
GLenum shader_prog, shader_vert, shader_frag;
int i;
char buf[1024];
const GLcharARB *vertex_shader_code, *fragment_shader_code;
GLint loc;
assert((vertex_shader_code = loadShader("shader.vert")));
assert((fragment_shader_code = loadShader("shader.frag")));
assert(!SDL_Init(SDL_INIT_EVERYTHING));
atexit(SDL_Quit);
SDL_GL_SET_ATTR(RED_SIZE, 8);
SDL_GL_SET_ATTR(GREEN_SIZE, 8);
SDL_GL_SET_ATTR(BLUE_SIZE, 8);
SDL_GL_SET_ATTR(DEPTH_SIZE, 16);
SDL_GL_SET_ATTR(DOUBLEBUFFER, 1);
assert(SDL_SetVideoMode(SCRW, SCRH, SCRBPP, SDL_OPENGL /*| SDL_FULLSCREEN*/));
/* puts((const char *)glGetString(GL_EXTENSIONS));*/
DO_GL_PROCS(DEFINE_GL_PROC)
assert((shader_prog = glCreateProgramObjectARB()));
assert((shader_vert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)));
assert((shader_frag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB)));
i = strlen(vertex_shader_code);
printf("vert len: %d\n", i);
glShaderSourceARB(shader_vert, 1, &vertex_shader_code, &i);
i = strlen(fragment_shader_code);
printf("frag len: %d\n", i);
glShaderSourceARB(shader_frag, 1, &fragment_shader_code, &i);
glCompileShaderARB(shader_vert);
glCompileShaderARB(shader_frag);
glAttachObjectARB(shader_prog, shader_vert);
glAttachObjectARB(shader_prog, shader_frag);
glLinkProgramARB(shader_prog);
i = 0; glGetInfoLogARB(shader_vert, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("vert error: \"%s\"\n", buf);
i = 0; glGetInfoLogARB(shader_frag, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("frag error: \"%s\"\n", buf);
i = 0; glGetInfoLogARB(shader_prog, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("prog error: \"%s\"\n", buf);
glUseProgramObjectARB(shader_prog);
loc = glGetUniformLocationARB(shader_prog, "time");
while (!SDL_GetKeyState(0)[SDLK_ESCAPE]) {
float time = (float)SDL_GetTicks() / 2000.0f;
SDL_PumpEvents();
glUniform1fARB(loc, time);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBegin(GL_QUADS);
glVertex3f(-1.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glVertex3f(1.0f, -1.0f, 0.0f);
glVertex3f(-1.0f, -1.0f, 0.0f);
glEnd();
SDL_GL_SwapBuffers();
}
return 0;
}
bool GlslProgram :: setUniformFloat ( const char * name, float value )
{
int loc = glGetUniformLocationARB ( program, name );
if ( loc < 0 )
return false;
glUniform1fARB ( loc, value );
return true;
}
void GlazedRenderer::draw()
{
GLint old_prog;
glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
glUseProgram(prog);
glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),12.0/bsphere_rad);
glCallList(display_list);
glUseProgram(old_prog);
}
// sent float value
void Shader::uniform(const std::string& uniformName, GLfloat value)
{
GLuint id = glGetUniformLocation(_program, uniformName.c_str());
if (id == -1)
{
#ifdef DEBUG_SHADERS
FLog(FLog::WARNING, _name + " Couldn't get uniform location of " + uniformName);
#endif
}
glUniform1fARB(id, value);
}
LineFieldRenderer::LineFieldRenderer(const Manifold& m, bool smooth, VertexAttributeVector<Vec3d>& lines, float _r):
SimpleShaderRenderer(vss,fss), r(_r)
{
float noise_scale = 10.0f/r;
float line_scale = 0.003f;
GLint old_prog;
glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
glUseProgram(prog);
glUniform1fARB(glGetUniformLocationARB(prog, "scale_line"),line_scale*noise_scale);
glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),noise_scale);
glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
GLuint direction = glGetAttribLocation(prog, "direction");
glNewList(display_list,GL_COMPILE);
for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f) {
if(!smooth)
glNormal3dv(normal(m, *f).get());
if(no_edges(m, *f) == 3)
glBegin(GL_TRIANGLES);
else
glBegin(GL_POLYGON);
for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()) {
Vec3d n(normal(m, w.vertex()));
if(smooth)
glNormal3dv(n.get());
Vec3d d = lines[w.vertex()];
d = normalize(d-n*dot(n,d));
glVertexAttrib3dv(direction, d.get());
glVertex3dv(m.pos(w.vertex()).get());
}
glEnd();
}
glBindTexture(GL_TEXTURE_3D, 0);
glEndList();
glUseProgram(old_prog);
}
static void alphafade(Texture *src, float limit, float ramp) {
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glueSet2d(GLUE_NO_DEPTH|GLUE_BLEND_ALPHAADD);
glUseProgramObjectARB(shader_alphafade);
glueGlsl_bindtex(shader_alphafade, "t_color", src->texnum, 0, GL_TEXTURE_2D, GLUE_NO_MIPMAP);
glUniform1fARB(glGetUniformLocationARB(shader_alphafade, "limit"), limit);
glUniform1fARB(glGetUniformLocationARB(shader_alphafade, "ramp"), ramp);
glue2dquad();
glUseProgramObjectARB(0);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
void intro_do( long time )
{
//--- update parameters -----------------------------------------
const float t = 0.001f*(float)time;
// camera position
fparams[ 0] = 2.0f;
fparams[ 1] = 0.0f;
fparams[ 2] = 2.0f;
// camera target
fparams[ 4] = 0.0f;
fparams[ 5] = 0.0f;
fparams[ 6] = 0.0f;
// sphere
fparams[ 8] = 0.0f;
fparams[ 9] = 0.0f;
fparams[10] = 0.0f;
fparams[11] = 1.0f;
/*
// Gen renderbuffer
glGenRenderbuffersEXT(1, &frontb);
// Bind renderbuffer
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, frontb);
// Init as a depth buffer
glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, XRES, YRES);
// Attach to the FBO for depth
glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, frontb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);*/
//--- render -----------------------------------------
static float reso[4];
reso[0] = XRES;
reso[1] = YRES;
reso[2] = XRES;
reso[3] = YRES;
oglUseProgram( pid );
glUniform1fARB( oglGetUniformLocation( pid, "iGlobalTime" ), t );
oglUniform4fv( oglGetUniformLocation( pid, "iResolution" ), 1, reso );
oglUniform4fv( oglGetUniformLocation( pid, "fpar" ), 4, fparams );
glRects( -1, -1, 1, 1 );
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
void updateAnim()
{
int location;
location = getUniLoc(ProgramObject, "currentTime");
ParticleTime += 0.002f;
if (ParticleTime > 15.0)
ParticleTime = 0.0;
glUniform1fARB(location, ParticleTime);
printOpenGLError();
}
void r_composite(float negative, float contrast) {
int i;
glClear(GL_COLOR_BUFFER_BIT);
glUseProgramObjectARB(r_comp_prog);
glUniform1fARB(r_comp_neg, negative);
glUniform1fARB(r_comp_contrast, contrast);
glActiveTextureARB(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, r_2D_tex);
// mind you that the frame texture #0 is attached to FBO #1
//printf("Frames: ");
for (i = 0; i < 1 + FRAME_TRACE; i++) {
glActiveTextureARB(GL_TEXTURE1 + i);
glBindTexture(GL_TEXTURE_2D, r_frame_tex[(r_current_FBO - 1 + i)
% (1 + FRAME_TRACE)]);
//printf("%d=%d ", i, (r_currentFBO - 1 + i) % (1 + FRAME_TRACE));
}
//printf("\n");
glActiveTextureARB(GL_TEXTURE0);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0, 0);
glVertex2f(0, 0);
glTexCoord2f(0, 1);
glVertex2f(0, 1);
glTexCoord2f(1, 0);
glVertex2f(1, 0);
glTexCoord2f(1, 1);
glVertex2f(1, 1);
glEnd();
glUseProgramObjectARB(0);
// dump everything to screen
SDL_GL_SwapBuffers();
}
void moTextureFilter::SetupShader(MOint w, MOint h, moTempo *p_tempo, MOfloat p_fade, moTextFilterParam *p_params)
{
for (MOuint i = 0; i < m_src_tex.Count(); i++)
{
if (-1 < m_src_tex_unit[i]) {
if ( m_shader && m_shader->GetType() == (MOuint)MO_SHADER_GLSL ) {
glUniform1iARB(m_src_tex_unit[i], i);
} else if ( m_shader && m_shader->GetType() == (MOuint)MO_SHADER_CG ) {
//cgGLSetTextureParameter( (CGparameter)m_src_tex_unit[i], i );
//cgGLSetTextureParameter( (CGparameter)m_src_tex_unit[i], m_src_tex.GetGLId(i, (GLint)i) );
//cgGLEnableTextureParameter( (CGparameter)m_src_tex_unit[i] );
}
}
if (-1 < m_src_tex_offset[i])
if (m_glman->RectTexture(m_src_tex[i]->GetTexTarget())) glUniform2fARB(m_src_tex_offset[i], 1.0, 1.0);
else glUniform2fARB(m_src_tex_offset[i], 1.0 / float(m_src_tex[i]->GetWidth()), 1.0 / float(m_src_tex[i]->GetHeight()));
}
if (-1 < m_tempo_angle)
if (p_tempo != NULL)
{
float a = p_tempo->ang;
float f = fmod(float(a), float(2.0 * moMathf::PI)) / (2.0 * moMathf::PI);
glUniform2fARB(m_tempo_angle, a, f);
//(m_shader->GetType() == (MOuint)MO_SHADER_GLSL) ? glUniform2fARB(m_tempo_angle, a, f) : m_tempo_angle=0;/*cgGLSetParameter2f( (CGparameter)m_tempo_angle, a, f)*/
}
else {
glUniform2fARB(m_tempo_angle, 0.0, 0.0);
//(m_shader->GetType() == (MOuint)MO_SHADER_GLSL) ? glUniform2fARB(m_tempo_angle, 0.0, 0.0) : m_tempo_angle=0;/*cgGLSetParameter2f( (CGparameter)m_tempo_angle, 0.0, 0.0 )*/
}
if (-1 < m_dest_tex_size) {
glUniform2fARB(m_dest_tex_size, w, h);
//(m_shader->GetType() == (MOuint)MO_SHADER_GLSL) ? glUniform2fARB(m_dest_tex_size, w, h) : m_dest_tex_size=0;/*cgGLSetParameter2f( (CGparameter)m_dest_tex_size, w, h )*/
}
if (-1 < m_fade_const) {
glUniform1fARB(m_fade_const, p_fade);
//(m_shader->GetType() == (MOuint)MO_SHADER_GLSL) ? glUniform1fARB(m_fade_const, p_fade) : m_fade_const=0;/*cgGLSetParameter1f( (CGparameter)m_fade_const, p_fade )*/
}
if (p_params != NULL)
{
m_DefParams->CopyDefParamIDs(p_params);
p_params->setParamValues();
}
else m_DefParams->setParamValues();
}
void Shader::setParameter(const std::string &name, float x) {
if (mShaderProgram) {
ensureGLContext();
GLhandleARB program = glCheck(glGetHandleARB(glGetHandleARB(GL_PROGRAM_OBJECT_ARB)));
glCheck(glUseProgramObjectARB(mShaderProgram));
GLint location = getParamLocation(name);
if (location != -1) {
glCheck(glUniform1fARB(location, x));
}
glCheck(glUseProgramObjectARB(program));
}
}
struct glpal_ctx * pal_init_glsl(GLboolean float_packed_pixels)
{CHECK_GL_ERR;
printf("Compiling pallet shader:\n");
GLint prog = 0;
if(!float_packed_pixels)
prog = compile_program(vtx_shader, pal_frag_shader);
else
prog = compile_program(vtx_shader, pal_frag_mix);
if(!prog) return NULL;
struct pal_lst *pals = pallet_get_palettes();
struct priv_ctx *priv = malloc(sizeof(*priv) + sizeof(*priv->pal_tex)*pals->numpals);
priv->pubctx.render = render;
priv->pubctx.step = step;
priv->pubctx.start_switch = start_switch;
priv->pubctx.changing = changing;
priv->prog = prog;
priv->numpal = pals->numpals;
priv->curpal = priv->nextpal = 0;
priv->palpos = 0;
glUseProgramObjectARB(prog);
glUniform1iARB(glGetUniformLocationARB(prog, "src"), 0);
glUniform1iARB(glGetUniformLocationARB(prog, "pal1"), 1);
glUniform1iARB(glGetUniformLocationARB(prog, "pal2"), 2);
priv->palpos_loc = glGetUniformLocationARB(prog, "palpos");
glUniform1fARB(priv->palpos_loc, 0.0f);
glUseProgramObjectARB(0);
printf("Pallet shader compiled\n");
glGenTextures(pals->numpals, priv->pal_tex);
glPushAttrib(GL_TEXTURE_BIT);
for(int i=0; i<pals->numpals; i++) {
glBindTexture(GL_TEXTURE_1D, priv->pal_tex[i]);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_BGRA, GL_UNSIGNED_BYTE, pals->pallets[i]);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
glPopAttrib(); CHECK_GL_ERR;
free(pals);
return (struct glpal_ctx *)priv;
}
void Shader::setParameter(const std::string& name, float x)
{
if (m_shaderProgram)
{
ensureGlContext();
// Enable program
GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
glCheck(glUseProgramObjectARB(m_shaderProgram));
// Get parameter location and assign it new values
GLint location = getParamLocation(name);
if (location != -1)
glCheck(glUniform1fARB(location, x));
// Disable program
glCheck(glUseProgramObjectARB(program));
}
}
void Shader::SetParameter(const std::string& name, float x)
{
if (myShaderProgram)
{
// Enable program
GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
GLCheck(glUseProgramObjectARB(myShaderProgram));
// Get parameter location and assign it new values
GLint location = glGetUniformLocationARB(myShaderProgram, name.c_str());
if (location != -1)
GLCheck(glUniform1fARB(location, x));
else
Err() << "Parameter \"" << name << "\" not found in shader" << std::endl;
// Disable program
GLCheck(glUseProgramObjectARB(program));
}
}
void crossfader_render(struct crossfader * crossfader, GLuint left, GLuint right) {
GLenum e;
glLoadIdentity();
glViewport(0, 0, config.pattern.master_width, config.pattern.master_height);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, crossfader->fb);
glUseProgramObjectARB(crossfader->shader);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, left);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, right);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
GLint loc;
loc = glGetUniformLocationARB(crossfader->shader, "iResolution");
glUniform2fARB(loc, config.pattern.master_width, config.pattern.master_height);
loc = glGetUniformLocationARB(crossfader->shader, "iIntensity");
glUniform1fARB(loc, crossfader->position);
loc = glGetUniformLocationARB(crossfader->shader, "iFrameLeft");
glUniform1iARB(loc, 0);
loc = glGetUniformLocationARB(crossfader->shader, "iFrameRight");
glUniform1iARB(loc, 1);
loc = glGetUniformLocationARB(crossfader->shader, "iLeftOnTop");
glUniform1iARB(loc, crossfader->left_on_top);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glVertex2d(-1, -1);
glVertex2d(-1, 1);
glVertex2d(1, 1);
glVertex2d(1, -1);
glEnd();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
if(crossfader->position == 1.) {
crossfader->left_on_top = true;
} else if(crossfader->position == 0.) {
crossfader->left_on_top = false;
}
}
void blurfilter(Framebuffer *src, Framebuffer *work, float pixel, int rad, float minus) {
int x;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glueBeginrender(work);
gluePrepareflags(0);
glClear(GL_COLOR_BUFFER_BIT);
glueSet2d(GLUE_NO_DEPTH);
glueDisabletexture();
glUseProgramObjectARB(shader_blur);
glueGlsl_bindtex(shader_blur, "t_color", src->texnum, 0, GL_TEXTURE_2D, GLUE_CLAMP|GLUE_NO_MIPMAP);
glUniform2fARB(glGetUniformLocationARB(shader_blur, "direction"), pixel/src->xres, 0.0);
glUniform1iARB(glGetUniformLocationARB(shader_blur, "radius"), rad);
glUniform1fARB(glGetUniformLocationARB(shader_blur, "minus"), minus);
glue2dquad();
glUseProgramObjectARB(0);
glueEndrender();
glClear(GL_COLOR_BUFFER_BIT);
glueSet2d(GLUE_NO_DEPTH);
glUseProgramObjectARB(shader_blur);
glueGlsl_bindtex(shader_blur, "t_color", work->texnum, 0, GL_TEXTURE_2D, GLUE_CLAMP|GLUE_NO_MIPMAP);
glUniform2fARB(glGetUniformLocationARB(shader_blur, "direction"), 0, pixel/work->yres);
float radmultiplier=(float)work->yres/(float)src->yres;
// glueNoticef("blur multiplier shit %5.2f", radmultiplier);
glUniform1iARB(glGetUniformLocationARB(shader_blur, "radius"), rad*radmultiplier);
glue2dquad();
glUseProgramObjectARB(0);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
CircleFieldRenderer::CircleFieldRenderer(const Manifold& m,
bool smooth,
VertexAttributeVector<Vec2d>& field,
float gamma): SimpleShaderRenderer(vss, fss)
{
GLint old_prog;
glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
glUseProgram(prog);
GLuint scalar_attrib = glGetAttribLocation(prog, "circlepos");
// static float& gamma = CreateCVar("display.scalar_field_renderer.gamma",2.2f);
glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
glNewList(display_list,GL_COMPILE);
for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f) {
if(!smooth)
glNormal3dv(normal(m, *f).get());
if(no_edges(m, *f)== 3)
glBegin(GL_TRIANGLES);
else
glBegin(GL_POLYGON);
for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()) {
Vec3d n(normal(m, w.vertex()));
if(smooth)
glNormal3dv(n.get());
glVertexAttrib2dv(scalar_attrib, field[w.vertex()].get());
glVertex3dv(m.pos(w.vertex()).get());
}
glEnd();
}
glEndList();
glUseProgram(old_prog);
}
