/*
* sendUniformMatrix3fv
*
* parameter name - char*
* parameter count - GLsizei
* parameter transpose - GLboolean
* parameter values - GLfloat*
* return - bool
*/
bool ShaderObject::sendUniformMatrix3fv(const char * name, GLsizei count, GLboolean transpose, GLfloat* values) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniformMatrix3fvARB(location, count, transpose, values);
return true;
} // end sendUniformMatrix3fv()
// CBoxProxyView 绘制
void CBoxProxyView::GetDepthMapFromView()
{
glEnable(GL_DEPTH_TEST);
//glDepthFunc(GL_LEQUAL);
gettingDepth=true;
sd.setShaders();
ColorPos=sd.getAttrLocation("vColor");
VertexPos=sd.getAttrLocation("vVertex");
KRpos=sd.getUniformLocation("m_KR");
KTpos=sd.getUniformLocation("m_KT");
Matrix3d m_KR=cam.getKR();
Vector3d m_KT=cam.getKT();
float kr[9];
double kt[3];
for (int i = 0; i < 9; i++)
{
kr[i]=m_KR(i);
}
for (int i = 0; i < 3; i++)
{
kt[i]=m_KT(i);
}
glUniformMatrix3fvARB(KRpos,1,GL_FALSE,&kr[0]);
glUniform3d(KTpos,kt[0],kt[1],kt[2]);
setUpDepthCam();
CPaintDC dc(this);
OnDraw(&dc);
}
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 );
}
}
bool Shader::sendUniformMatrix3fv(char* varname, GLsizei count, GLboolean transpose, GLfloat *value)
{
GLint loc = GetUniformLocation(varname);
if (loc == -1) return false;
glUniformMatrix3fvARB(loc, count, transpose, value);
return true;
}
bool GLSLShader::setUniformMatrix33( const char *name, const float *m )
{
if (!programObj) return false;
int loc = glGetUniformLocationARB( programObj, name );
if (loc < 0)
return false;
glUniformMatrix3fvARB( loc, 1, GL_FALSE, m );
return true;
}
bool GlslProgram :: setUniformMatrix ( const char * name, const Matrix3D& value )
{
int loc = glGetUniformLocationARB ( program, name );
if ( loc < 0 )
return false;
glUniformMatrix3fvARB ( loc, 1, GL_FALSE, value [0] );
return true;
}
static void
bind_matrix_arb (cairo_gl_shader_t *shader,
const char *name,
cairo_matrix_t* m)
{
GLint location = glGetUniformLocationARB (shader->program, name);
float gl_m[9] = {
m->xx, m->xy, m->x0,
m->yx, m->yy, m->y0,
0, 0, 1
};
assert (location != -1);
glUniformMatrix3fvARB (location, 1, GL_TRUE, gl_m);
}
void BL_Shader::SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose)
{
if ( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
float value[9];
value[0] = (float)vec[0][0]; value[1] = (float)vec[1][0]; value[2] = (float)vec[2][0];
value[3] = (float)vec[0][1]; value[4] = (float)vec[1][1]; value[5] = (float)vec[2][1];
value[6] = (float)vec[0][2]; value[7] = (float)vec[1][2]; value[8] = (float)vec[2][2];
glUniformMatrix3fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, 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 void update(struct glmaxsrc_ctx *ctx, const float *audio, int audiolen)
{DEBUG_CHECK_GL_ERR;
struct priv_ctx *priv = (struct priv_ctx *)ctx;
const uint32_t now = get_ticks();
const float dt = (now - priv->lastupdate)*24/1000.0f;
priv->lastupdate = now;
float cx=cosf(priv->tx), cy=cosf(priv->ty), cz=cosf(priv->tz);
float sx=sinf(priv->tx), sy=sinf(priv->ty), sz=sinf(priv->tz);
float R[3][3] = {
{cz*cy-sz*sx*sy, -sz*cx, -sy*cz-cy*sz*sx},
{sz*cy+cz*sx*sy, cz*cx, -sy*sz+cy*cz*sx},
{cx*sy , -sx, cy*cx}
};
const float Rt[9] = {
R[0][0], R[1][0], R[2][0],
R[0][1], R[1][1], R[2][1],
R[0][2], R[1][2], R[2][2],
};
GLint src_tex = offscr_start_render(ctx->offscr);
glUseProgramObjectARB(priv->prog);
glUniformMatrix3fvARB(priv->R_loc, 1, 0, Rt);
glBindTexture(GL_TEXTURE_2D, src_tex);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2d(0,0); glVertex2d(-1, -1);
glTexCoord2d(1,0); glVertex2d( 1, -1);
glTexCoord2d(0,1); glVertex2d(-1, 1);
glTexCoord2d(1,1); glVertex2d( 1, 1);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glUseProgramObjectARB(0);
DEBUG_CHECK_GL_ERR;
render_scope(priv->glscope, R, audio, audiolen);
DEBUG_CHECK_GL_ERR;
offscr_finish_render(ctx->offscr);
priv->tx+=0.02f*dt; priv->ty+=0.01f*dt; priv->tz-=0.003f*dt;
DEBUG_CHECK_GL_ERR;
}
bool ShaderProgram::SetMatrixVariable(const char* name, int dim, const float* values, int count, bool transpose)
{
if (!_linked) return false;
if (_id)
{
GLint location = glGetUniformLocationARB(_id, name);
if (location == -1) return false;
GLboolean trans = transpose ? GL_TRUE : GL_FALSE;
switch (dim)
{
case 2: glUniformMatrix2fvARB(location, count, trans, values); break;
case 3: glUniformMatrix3fvARB(location, count, trans, values); break;
case 4: glUniformMatrix4fvARB(location, count, trans, values); break;
default:
return false;
}
return true;
} else
return false;
}
static void use_uniform(struct brush *b, struct uniform *u)
{
int L;
/* Apply the uniform values to the OpenGL state. */
if (GL_has_shader_objects && u && b->shad_prog)
{
glUseProgramObjectARB(b->shad_prog);
if ((L = glGetUniformLocationARB(b->shad_prog, u->name)) != -1)
{
const float *k = u->vals;
int r = u->rows;
int c = u->cols;
if (r == 0 && c == 0)
glUniform1iARB(L, u->indx);
else if (r == 1 && c == 1)
glUniform1fARB(L, k[0]);
else if (r == 1 && c == 2)
glUniform2fARB(L, k[0], k[1]);
else if (r == 1 && c == 3)
glUniform3fARB(L, k[0], k[1], k[2]);
else if (r == 1 && c == 4)
glUniform4fARB(L, k[0], k[1], k[2], k[3]);
else if (r == 2 && c == 2) glUniformMatrix2fvARB(L, 1, 0, k);
else if (r == 3 && c == 3) glUniformMatrix3fvARB(L, 1, 0, k);
else if (r == 4 && c == 4) glUniformMatrix4fvARB(L, 1, 0, k);
}
glUseProgramObjectARB(0);
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniformMatrix3fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
const GLfloat *matrices_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix3fvARBPROC glUniformMatrix3fvARB = (glUniformMatrix3fvARBPROC)((intptr_t)function_pointer);
glUniformMatrix3fvARB(location, count, transpose, matrices_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
}
void ProgramUniformGLSL::Set(const Matrix3x3 &mMatrix, bool bTranspose)
{
glUniformMatrix3fvARB(m_nOpenGLUniformLocation, 1, bTranspose, mMatrix);
}
void GLSLShader::setUniformMatrix33( const GLint location, const float *m )
{
glUniformMatrix3fvARB( location, 1, GL_FALSE, m );
}
void glsl_program :: renderARB()
{
if (m_linked) {
glUseProgramObjectARB( m_programARB );
for(int i=0; i<m_uniformCount; i++)
{
if(m_flag[i])
{
switch (m_type[i])
{
/* float vectors */
case GL_FLOAT:
glUniform1fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]) );
break;
case GL_FLOAT_VEC2_ARB:
glUniform2fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]) );
break;
case GL_FLOAT_VEC3_ARB:
glUniform3fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]),
static_cast<GLfloat>(m_param[i][2]) );
break;
case GL_FLOAT_VEC4_ARB:
glUniform4fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]),
static_cast<GLfloat>(m_param[i][2]), static_cast<GLfloat>(m_param[i][3]) );
break;
/* int vectors */
case GL_INT:
glUniform1iARB( m_loc[i], static_cast<GLint>(m_param[i][0]) );
break;
case GL_INT_VEC2_ARB:
glUniform2iARB( m_loc[i], static_cast<GLint>(m_param[i][0]), static_cast<GLint>(m_param[i][1]) );
break;
case GL_INT_VEC3_ARB:
glUniform3iARB( m_loc[i], static_cast<GLint>(m_param[i][0]), static_cast<GLint>(m_param[i][1]),
static_cast<GLint>(m_param[i][2]) );
break;
case GL_INT_VEC4_ARB:
glUniform4iARB( m_loc[i], static_cast<GLint>(m_param[i][0]), static_cast<GLint>(m_param[i][1]),
static_cast<GLint>(m_param[i][2]), static_cast<GLint>(m_param[i][3]) );
break;
/* bool vectors */
case GL_BOOL_ARB:
glUniform1fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]) );
break;
case GL_BOOL_VEC2_ARB:
glUniform2fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]) );
break;
case GL_BOOL_VEC3_ARB:
glUniform3fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]),
static_cast<GLfloat>(m_param[i][2]) );
break;
case GL_BOOL_VEC4_ARB:
glUniform4fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]),
static_cast<GLfloat>(m_param[i][2]), static_cast<GLfloat>(m_param[i][3]) );
break;
/* float matrices */
case GL_FLOAT_MAT2_ARB:
// GL_TRUE = row major order, GL_FALSE = column major
glUniformMatrix2fvARB( m_loc[i], 1, GL_FALSE, m_param[i] );
break;
case GL_FLOAT_MAT3_ARB:
glUniformMatrix3fvARB( m_loc[i], 1, GL_FALSE, m_param[i] );
break;
case GL_FLOAT_MAT4_ARB:
glUniformMatrix4fvARB( m_loc[i], 1, GL_FALSE, m_param[i] );
break;
/* textures */
case GL_SAMPLER_1D_ARB: break;
case GL_SAMPLER_2D_ARB:
glUniform1iARB(m_loc[i], m_param[i][0]);
break;
case GL_SAMPLER_3D_ARB: break;
case GL_SAMPLER_CUBE_ARB: break;
case GL_SAMPLER_1D_SHADOW_ARB: break;
case GL_SAMPLER_2D_SHADOW_ARB: break;
case GL_SAMPLER_2D_RECT_ARB:
glUniform1iARB(m_loc[i], m_param[i][0]);
break;
default:
;
}
// remove flag because the value is in GL's state now...
m_flag[i]=0;
}
}
// glUniform1iARB(glGetUniformLocationARB(program_object, "MyTex1"), 1);
} else {
/* JMZ: this is really annoying... */
//error("no program linked");
}
}
void ShaderProgramGl::setUniform(const string &name, const Matrix3f &value){
assertGl();
glUniformMatrix3fvARB(getLocation(name), 1, GL_FALSE, value.ptr());
assertGl();
}
//-----------------------------------------------------------------------
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
}
ShaderProgram &umt3(const char *var, GLfloat *m) { glUniformMatrix3fvARB(uniform(var), 1, GL_TRUE, m); return *this; }
