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); }