static int program_set_uniform_number2(lua_State *L) { shader_type *p = (shader_type*)lua_touserdata(L, 1); const char *var = luaL_checkstring(L, 2); bool change = gl_c_shader != p->shader; if (change) tglUseProgramObject(p->shader); // Uniform array if (lua_istable(L, 3)) { int nb = lua_objlen(L, 3); int i; GLfloat is[2*nb]; for (i = 0; i < nb; i++) { lua_rawgeti(L, 3, i + 1); lua_rawgeti(L, -1, 1); is[i*2+0] = lua_tonumber(L, -1); lua_pop(L, 1); lua_rawgeti(L, -1, 2); is[i*2+1] = lua_tonumber(L, -1); lua_pop(L, 1); lua_pop(L, 1); } glUniform2fvARB(glGetUniformLocationARB(p->shader, var), nb, is); } else { GLfloat i[2]; i[0] = luaL_checknumber(L, 3); i[1] = luaL_checknumber(L, 4); glUniform2fvARB(glGetUniformLocationARB(p->shader, var), 1, i); } if (change) tglUseProgramObject(0); return 0; }
/* * sendUniform2fv * * parameter name - char* * parameter count - GLsizei * parameter values - GLfloat* * return - bool */ bool ShaderObject::sendUniform2fv(const char *name, GLsizei count, GLfloat* values) { GLint location = getUniLoc(name); if (location == -1) return false; glUniform2fvARB(location, count, values); return true; } // end sendUniform2fv()
void GPU::Shader::SetUniform( const std::string& name, const void *value ) { UniformMap::iterator uu = m_Uniforms.find( name ); if( uu != m_Uniforms.end() ) { GLuint activeProgBackup = glGetHandleARB( GL_PROGRAM_OBJECT_ARB ); glUseProgramObjectARB( m_Id ); Uniform &u = uu->second; switch( u.type ) { case GL_FLOAT: glUniform1fvARB( u.location, u.size, (GLfloat*) value ); break; case GL_FLOAT_VEC2_ARB: glUniform2fvARB( u.location, u.size, (GLfloat*) value ); break; case GL_FLOAT_VEC3_ARB: glUniform3fvARB( u.location, u.size, (GLfloat*) value ); break; case GL_FLOAT_VEC4_ARB: glUniform4fvARB( u.location, u.size, (GLfloat*) value ); break; case GL_INT: glUniform1ivARB( u.location, u.size, (GLint*) value ); break; case GL_INT_VEC2_ARB: glUniform2ivARB( u.location, u.size, (GLint*) value ); break; case GL_INT_VEC3_ARB: glUniform3ivARB( u.location, u.size, (GLint*) value ); break; case GL_INT_VEC4_ARB: glUniform4ivARB( u.location, u.size, (GLint*) value ); break; case GL_BOOL_ARB: glUniform1ivARB( u.location, u.size, (GLint*) value ); break; case GL_BOOL_VEC2_ARB: glUniform2ivARB( u.location, u.size, (GLint*) value ); break; case GL_BOOL_VEC3_ARB: glUniform3ivARB( u.location, u.size, (GLint*) value ); break; case GL_BOOL_VEC4_ARB: glUniform4ivARB( u.location, u.size, (GLint*) value ); break; case GL_FLOAT_MAT2_ARB: glUniformMatrix2fvARB( u.location, u.size, GL_FALSE, (GLfloat*) value ); break; case GL_FLOAT_MAT3_ARB: glUniformMatrix3fvARB( u.location, u.size, GL_FALSE, (GLfloat*) value ); break; case GL_FLOAT_MAT4_ARB: glUniformMatrix4fvARB( u.location, u.size, GL_FALSE, (GLfloat*) value ); break; } glUseProgramObjectARB( activeProgBackup ); } }
void useShader(shader_type *p, int x, int y, int w, int h, float tx, float ty, float tw, float th, float r, float g, float b, float a) { tglUseProgramObject(p->shader); GLfloat t = cur_frame_tick; glUniform1fvARB(p->p_tick, 1, &t); GLfloat d[4]; d[0] = r; d[1] = g; d[2] = b; d[3] = a; glUniform4fvARB(p->p_color, 1, d); GLfloat c[2]; c[0] = x; c[1] = y; glUniform2fvARB(p->p_mapcoord, 1, c); c[0] = w; c[1] = h; glUniform2fvARB(p->p_texsize, 1, c); d[0] = tx; d[1] = ty; d[2] = tw; d[3] = th; glUniform4fvARB(p->p_texcoord, 1, d); shader_reset_uniform *ru = p->reset_uniforms; while (ru) { switch (ru->kind) { case UNIFORM_NUMBER: glUniform1fvARB(ru->p, 1, &ru->data.number); break; case UNIFORM_VEC2: glUniform2fvARB(ru->p, 1, ru->data.vec2); break; case UNIFORM_VEC3: glUniform3fvARB(ru->p, 1, ru->data.vec3); break; case UNIFORM_VEC4: glUniform4fvARB(ru->p, 1, ru->data.vec4); break; } ru = ru->next; } }
bool Shader::sendUniform2fv(char* varname, GLsizei count, GLfloat *value) { GLint loc = GetUniformLocation(varname); if (loc == -1) return false; glUniform2fvARB(loc, count, value); return true; }
bool GlslProgram :: setUniformVector ( const char * name, const Vector2D& value ) { int loc = glGetUniformLocationARB ( program, name ); if ( loc < 0 ) return false; glUniform2fvARB ( loc, 1, value ); return true; }
void BL_Shader::SetUniform(int uniform, const MT_Tuple2& vec) { if ( GLEW_ARB_fragment_shader && GLEW_ARB_vertex_shader && GLEW_ARB_shader_objects ) { float value[2]; vec.getValue(value); glUniform2fvARB(uniform, 1, value); } }
void GPU_shader_uniform_vector(GPUShader *UNUSED(shader), int location, int length, int arraysize, float *value) { if (location == -1) return; GPU_print_error("Pre Uniform Vector"); if (length == 1) glUniform1fvARB(location, arraysize, value); else if (length == 2) glUniform2fvARB(location, arraysize, value); else if (length == 3) glUniform3fvARB(location, arraysize, value); else if (length == 4) glUniform4fvARB(location, arraysize, value); else if (length == 9) glUniformMatrix3fvARB(location, arraysize, 0, value); else if (length == 16) glUniformMatrix4fvARB(location, arraysize, 0, value); GPU_print_error("Post Uniform Vector"); }
static int program_set_uniform_number2_fast(lua_State *L) { shader_type *p = (shader_type*)lua_touserdata(L, 1); GLfloat i[2]; i[0] = luaL_checknumber(L, 2); i[1] = luaL_checknumber(L, 3); bool change = gl_c_shader != p->shader; GLint pos = lua_tonumber(L, lua_upvalueindex(1)); if (change) tglUseProgramObject(p->shader); glUniform2fvARB(pos, 1, i); if (change) tglUseProgramObject(0); return 0; }
void BL_Shader::SetUniform(int uniform, const float* val, int len) { if ( GLEW_ARB_fragment_shader && GLEW_ARB_vertex_shader && GLEW_ARB_shader_objects ) { if (len == 2) glUniform2fvARB(uniform, 1,(GLfloat*)val); else if (len == 3) glUniform3fvARB(uniform, 1,(GLfloat*)val); else if (len == 4) glUniform4fvARB(uniform, 1,(GLfloat*)val); else MT_assert(0); } }
bool ShaderProgram::SetVariable(const char* name, int varDim, const float* values, int count) { if (!_linked) return false; if (_id) { GLint location = glGetUniformLocationARB(_id, name); if (location == -1) return false; switch (varDim) { case 1: glUniform1fvARB(location, count, values); break; case 2: glUniform2fvARB(location, count, values); break; case 3: glUniform3fvARB(location, count, values); break; case 4: glUniform4fvARB(location, count, values); break; default: return false; } return true; } else return false; }
void OGLShaderProgram_GLSL::SetUniform( const String& pVariableName, const Vector2f& pValue ) { glUniform2fvARB( glGetUniformLocationARB(mShaderProgram,pVariableName.c_str()), 1, pValue ); }
void RAS_2DFilterManager::StartShaderProgram(int passindex) { GLint uniformLoc; glUseProgramObjectARB(m_filters[passindex]); uniformLoc = glGetUniformLocationARB(m_filters[passindex], "bgl_RenderedTexture"); glActiveTextureARB(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texname[0]); if (uniformLoc != -1) { glUniform1iARB(uniformLoc, 0); } /* send depth texture to glsl program if it needs */ if(texflag[passindex] & 0x1){ uniformLoc = glGetUniformLocationARB(m_filters[passindex], "bgl_DepthTexture"); glActiveTextureARB(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texname[1]); if (uniformLoc != -1) { glUniform1iARB(uniformLoc, 1); } } /* send luminance texture to glsl program if it needs */ if(texflag[passindex] & 0x2){ uniformLoc = glGetUniformLocationARB(m_filters[passindex], "bgl_LuminanceTexture"); glActiveTextureARB(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, texname[2]); if (uniformLoc != -1) { glUniform1iARB(uniformLoc, 2); } } uniformLoc = glGetUniformLocationARB(m_filters[passindex], "bgl_TextureCoordinateOffset"); if (uniformLoc != -1) { glUniform2fvARB(uniformLoc, 9, textureoffsets); } uniformLoc = glGetUniformLocationARB(m_filters[passindex], "bgl_RenderedTextureWidth"); if (uniformLoc != -1) { glUniform1fARB(uniformLoc,texturewidth); } uniformLoc = glGetUniformLocationARB(m_filters[passindex], "bgl_RenderedTextureHeight"); if (uniformLoc != -1) { glUniform1fARB(uniformLoc,textureheight); } int i, objProperties = m_properties[passindex].size(); for(i=0; i<objProperties; i++) { uniformLoc = glGetUniformLocationARB(m_filters[passindex], m_properties[passindex][i]); if(uniformLoc != -1) { float value = ((CValue*)m_gameObjects[passindex])->GetPropertyNumber(m_properties[passindex][i], 0.0); glUniform1fARB(uniformLoc,value); } } }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform2fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) { const GLfloat *values_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position; glUniform2fvARBPROC glUniform2fvARB = (glUniform2fvARBPROC)((intptr_t)function_pointer); glUniform2fvARB(location, count, values_address); }
void BL_Uniform::Apply(class BL_Shader *shader) { #ifdef SORT_UNIFORMS MT_assert(mType > UNI_NONE && mType < UNI_MAX && mData); if (!mDirty) return; switch (mType) { case UNI_FLOAT: { float *f = (float*)mData; glUniform1fARB(mLoc,(GLfloat)*f); break; } case UNI_INT: { int *f = (int*)mData; glUniform1iARB(mLoc, (GLint)*f); break; } case UNI_FLOAT2: { float *f = (float*)mData; glUniform2fvARB(mLoc,1, (GLfloat*)f); break; } case UNI_FLOAT3: { float *f = (float*)mData; glUniform3fvARB(mLoc,1,(GLfloat*)f); break; } case UNI_FLOAT4: { float *f = (float*)mData; glUniform4fvARB(mLoc,1,(GLfloat*)f); break; } case UNI_INT2: { int *f = (int*)mData; glUniform2ivARB(mLoc,1,(GLint*)f); break; } case UNI_INT3: { int *f = (int*)mData; glUniform3ivARB(mLoc,1,(GLint*)f); break; } case UNI_INT4: { int *f = (int*)mData; glUniform4ivARB(mLoc,1,(GLint*)f); break; } case UNI_MAT4: { float *f = (float*)mData; glUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f); break; } case UNI_MAT3: { float *f = (float*)mData; glUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f); break; } } mDirty = false; #endif }
// The shader must be activated before void Shader::Uniform(const std::string& ext, const vec2& value) { int id = glGetUniformLocation(m_nProgram, ext.c_str()); glUniform2fvARB(id, 1, value); }
ShaderProgram &u2(const char *var, GLfloat *f) { glUniform2fvARB(uniform(var), 1, f); return *this; }
void ProgramUniformGLSL::Set(const Vector2 &vVector) { glUniform2fvARB(m_nOpenGLUniformLocation, 1, vVector); }
void GLSLShader::SetFloatVector2(GLint variable, GLsizei count, const float *value) { if (variable!=-1) glUniform2fvARB(variable, count, value); }
void ShaderProgramGl::setUniform(const string &name, const Vec2f &value){ assertGl(); glUniform2fvARB(getLocation(name), 1, value.ptr()); assertGl(); }
void ccShaderARB::setUniform2fv(const char* uniform, float* val) { int loc = glGetUniformLocationARB(prog,uniform); glUniform2fvARB(loc,1,val); }
void DiGLShaderParam::Bind() const { if (!mShaderLinker || !mShaderLinker->GetGLHandle()) return; // bind built-in (global) uniforms auto env = Driver->GetShaderEnvironment(); for (auto it = mBuiltinFuncs.begin(); it != mBuiltinFuncs.end(); ++it) { it->second(env, it->first); } // bind custom uniforms for (uint32 i = 0; i < NUM_VARIABLE_TYPES; ++i) { for (auto it = mShaderParams[i].begin(); it != mShaderParams[i].end(); ++it) { const DiAny& data = it->second; if (data.isEmpty()) continue; GLuint location = 0; int samplerUnit = 0; if (i == VARIABLE_SAMPLER2D || i == VARIABLE_SAMPLERCUBE) { auto sampler = mShaderLinker->GetSampler(it->first); if (!sampler) continue; location = sampler->location; samplerUnit = (int)sampler->unit; } else { auto constant = mShaderLinker->GetConstant(it->first); if (!constant) continue; location = constant->location; } switch (i) { case DiShaderParameter::VARIABLE_FLOAT: { float val = any_cast<float>(data); glUniform1fvARB(location, 1, &val); break; } case DiShaderParameter::VARIABLE_FLOAT2: { DiVec2 vec2 = any_cast<DiVec2>(data); glUniform2fvARB(location, 1, vec2.ptr()); break; } case DiShaderParameter::VARIABLE_FLOAT3: { DiVec3 vec3 = any_cast<DiVec3>(data); glUniform3fvARB(location, 1, vec3.ptr()); break; } case DiShaderParameter::VARIABLE_FLOAT4: { DiVec4 vec4 = any_cast<DiVec4>(data); glUniform4fvARB(location, 1, vec4.ptr()); break; } case DiShaderParameter::VARIABLE_MAT4: { DiMat4 vec4 = any_cast<DiMat4>(data); glUniformMatrix4fvARB(location, 1, GL_TRUE, vec4[0]); break; } case DiShaderParameter::VARIABLE_COLOR: { DiColor c = any_cast<DiColor>(data); DiVec4 vec4(c.r,c.g,c.b,c.a); glUniform4fvARB(location, 1, vec4.ptr()); break; } case DiShaderParameter::VARIABLE_FLOAT4_ARRAY: { DiPair<DiVec4*,uint32> v4Arr = any_cast<DiPair<DiVec4*,uint32>>(data); glUniform4fvARB(location, v4Arr.second, v4Arr.first->ptr()); break; } case DiShaderParameter::VARIABLE_SAMPLER2D: case DiShaderParameter::VARIABLE_SAMPLERCUBE: { glUniform1ivARB(location, 1, &samplerUnit); DiTexture* tex = any_cast<DiTexture*>(data); tex->Bind((uint32)samplerUnit); } break; } } } }
//----------------------------------------------------------------------- void GLSLLinkProgram::updateUniforms(GpuProgramParametersSharedPtr params, uint16 mask, GpuProgramType fromProgType) { // iterate through uniform reference list and update uniform values GLUniformReferenceIterator currentUniform = mGLUniformReferences.begin(); GLUniformReferenceIterator endUniform = mGLUniformReferences.end(); for (; currentUniform != endUniform; ++currentUniform) { // Only pull values from buffer it's supposed to be in (vertex or fragment) // This method will be called twice, once for vertex program params, // and once for fragment program params. if (fromProgType == currentUniform->mSourceProgType) { const GpuConstantDefinition* def = currentUniform->mConstantDef; if (def->variability & mask) { GLsizei glArraySize = (GLsizei)def->arraySize; // get the index in the parameter real list switch (def->constType) { case GCT_FLOAT1: glUniform1fvARB(currentUniform->mLocation, glArraySize, params->getFloatPointer(def->physicalIndex)); break; case GCT_FLOAT2: glUniform2fvARB(currentUniform->mLocation, glArraySize, params->getFloatPointer(def->physicalIndex)); break; case GCT_FLOAT3: glUniform3fvARB(currentUniform->mLocation, glArraySize, params->getFloatPointer(def->physicalIndex)); break; case GCT_FLOAT4: glUniform4fvARB(currentUniform->mLocation, glArraySize, params->getFloatPointer(def->physicalIndex)); break; case GCT_MATRIX_2X2: glUniformMatrix2fvARB(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); break; case GCT_MATRIX_2X3: if (GLEW_VERSION_2_1) { glUniformMatrix2x3fv(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); } break; case GCT_MATRIX_2X4: if (GLEW_VERSION_2_1) { glUniformMatrix2x4fv(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); } break; case GCT_MATRIX_3X2: if (GLEW_VERSION_2_1) { glUniformMatrix3x2fv(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); } break; case GCT_MATRIX_3X3: glUniformMatrix3fvARB(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); break; case GCT_MATRIX_3X4: if (GLEW_VERSION_2_1) { glUniformMatrix3x4fv(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); } break; case GCT_MATRIX_4X2: if (GLEW_VERSION_2_1) { glUniformMatrix4x2fv(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); } break; case GCT_MATRIX_4X3: if (GLEW_VERSION_2_1) { glUniformMatrix4x3fv(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); } break; case GCT_MATRIX_4X4: glUniformMatrix4fvARB(currentUniform->mLocation, glArraySize, GL_TRUE, params->getFloatPointer(def->physicalIndex)); break; case GCT_INT1: glUniform1ivARB(currentUniform->mLocation, glArraySize, (GLint*)params->getIntPointer(def->physicalIndex)); break; case GCT_INT2: glUniform2ivARB(currentUniform->mLocation, glArraySize, (GLint*)params->getIntPointer(def->physicalIndex)); break; case GCT_INT3: glUniform3ivARB(currentUniform->mLocation, glArraySize, (GLint*)params->getIntPointer(def->physicalIndex)); break; case GCT_INT4: glUniform4ivARB(currentUniform->mLocation, glArraySize, (GLint*)params->getIntPointer(def->physicalIndex)); break; case GCT_SAMPLER1D: case GCT_SAMPLER1DSHADOW: case GCT_SAMPLER2D: case GCT_SAMPLER2DSHADOW: case GCT_SAMPLER3D: case GCT_SAMPLERCUBE: // samplers handled like 1-element ints glUniform1ivARB(currentUniform->mLocation, 1, (GLint*)params->getIntPointer(def->physicalIndex)); break; case GCT_UNKNOWN: break; } // end switch #if OGRE_DEBUG_MODE checkForGLSLError( "GLSLLinkProgram::updateUniforms", "Error updating uniform", 0 ); #endif } // variability & mask } // fromProgType == currentUniform->mSourceProgType } // end for }
void ProgramUniformGLSL::Set2(const float *pfComponents) { glUniform2fvARB(m_nOpenGLUniformLocation, 1, pfComponents); }
bool GlslProgram :: setUniformVector ( int loc, const Vector2D& value ) { glUniform2fvARB ( loc, 1, value ); return true; }
void MGLContext::sendUniformVec2(unsigned int fxId, const char * name, float * values, const int count){ GLint uValue = glGetUniformLocationARB((GLhandleARB)fxId, name); if(uValue != -1) glUniform2fvARB(uValue, count, values); }