void Shader::SendDoubleArray(int location, const double* values, unsigned int count) const
{
if (location == -1)
return;
if (glProgramUniform1dv)
glProgramUniform1dv(m_program, location, count, values);
else
{
OpenGL::BindProgram(m_program);
glUniform1dv(location, count, values);
}
}
void Shader::updateShaderParameters(bool forceUpdate) {
for (int i = 0; i < shaderParameters->size(); i++) {
ShaderParameter *parameter = shaderParameters->at(i);
if (parameter->hasValueChanged() || forceUpdate) {
GLuint location = glGetUniformLocation(program, parameter->parameterName.c_str());
if (location != -1) {
switch (parameter->parameterType) {
case PARAMETER_INT:
glUniform1iv(location, parameter->valueSize, (int*) parameter->getValue());
break;
case PARAMETER_FLOAT:
glUniform1fv(location, parameter->valueSize, (float*) parameter->getValue());
break;
case PARAMETER_DOUBLE:
glUniform1dv(location, parameter->valueSize, (double*) parameter->getValue());
break;
case PARAMETER_VECTOR_2:
glUniform2fv(location, parameter->valueSize, (float*) parameter->getValue());
break;
case PARAMETER_VECTOR_3:
glUniform3fv(location, parameter->valueSize, (float*) parameter->getValue());
break;
case PARAMETER_VECTOR_4:
glUniform4fv(location, parameter->valueSize, (float*) parameter->getValue());
break;
case PARAMETER_MATRIX_3:
glUniformMatrix3fv(location, parameter->valueSize, false, (float*) parameter->getValue());
break;
case PARAMETER_MATRIX_4:
glUniformMatrix4fv(location, parameter->valueSize, false, (float*) parameter->getValue());
break;
}
}
}
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL40_nglUniform1dv(JNIEnv *__env, jclass clazz, jint location, jint count, jlong valueAddress, jlong __functionAddress) {
const GLdouble *value = (const GLdouble *)(intptr_t)valueAddress;
glUniform1dvPROC glUniform1dv = (glUniform1dvPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glUniform1dv(location, count, value);
}
//-----------------------------------------------------------------------
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();
// determine if we need to transpose matrices when binding
int transpose = GL_TRUE;
if ((fromProgType == GPT_FRAGMENT_PROGRAM && mVertexProgram && (!mVertexProgram->getGLSLProgram()->getColumnMajorMatrices())) ||
(fromProgType == GPT_VERTEX_PROGRAM && mFragmentProgram && (!mFragmentProgram->getGLSLProgram()->getColumnMajorMatrices())) ||
(fromProgType == GPT_GEOMETRY_PROGRAM && mGeometryProgram && (!mGeometryProgram->getGLSLProgram()->getColumnMajorMatrices())) ||
(fromProgType == GPT_HULL_PROGRAM && mHullProgram && (!mHullProgram->getGLSLProgram()->getColumnMajorMatrices())) ||
(fromProgType == GPT_DOMAIN_PROGRAM && mDomainProgram && (!mDomainProgram->getGLSLProgram()->getColumnMajorMatrices())) ||
(fromProgType == GPT_COMPUTE_PROGRAM && mComputeProgram && (!mComputeProgram->getGLSLProgram()->getColumnMajorMatrices())))
{
transpose = GL_FALSE;
}
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:
OGRE_CHECK_GL_ERROR(glUniform1fv(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex)));
break;
case GCT_FLOAT2:
OGRE_CHECK_GL_ERROR(glUniform2fv(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex)));
break;
case GCT_FLOAT3:
OGRE_CHECK_GL_ERROR(glUniform3fv(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex)));
break;
case GCT_FLOAT4:
OGRE_CHECK_GL_ERROR(glUniform4fv(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex)));
break;
case GCT_DOUBLE1:
OGRE_CHECK_GL_ERROR(glUniform1dv(currentUniform->mLocation, glArraySize,
params->getDoublePointer(def->physicalIndex)));
break;
case GCT_DOUBLE2:
OGRE_CHECK_GL_ERROR(glUniform2dv(currentUniform->mLocation, glArraySize,
params->getDoublePointer(def->physicalIndex)));
break;
case GCT_DOUBLE3:
OGRE_CHECK_GL_ERROR(glUniform3dv(currentUniform->mLocation, glArraySize,
params->getDoublePointer(def->physicalIndex)));
break;
case GCT_DOUBLE4:
OGRE_CHECK_GL_ERROR(glUniform4dv(currentUniform->mLocation, glArraySize,
params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_2X2:
OGRE_CHECK_GL_ERROR(glUniformMatrix2dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_2X3:
OGRE_CHECK_GL_ERROR(glUniformMatrix2x3dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_2X4:
OGRE_CHECK_GL_ERROR(glUniformMatrix2x4dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_3X2:
OGRE_CHECK_GL_ERROR(glUniformMatrix3x2dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_3X3:
OGRE_CHECK_GL_ERROR(glUniformMatrix3dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_3X4:
OGRE_CHECK_GL_ERROR(glUniformMatrix3x4dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_4X2:
OGRE_CHECK_GL_ERROR(glUniformMatrix4x2dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_4X3:
OGRE_CHECK_GL_ERROR(glUniformMatrix4x3dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_4X4:
OGRE_CHECK_GL_ERROR(glUniformMatrix4dv(currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_2X2:
OGRE_CHECK_GL_ERROR(glUniformMatrix2fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_2X3:
OGRE_CHECK_GL_ERROR(glUniformMatrix2x3fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_2X4:
OGRE_CHECK_GL_ERROR(glUniformMatrix2x4fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_3X2:
OGRE_CHECK_GL_ERROR(glUniformMatrix3x2fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_3X3:
OGRE_CHECK_GL_ERROR(glUniformMatrix3fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_3X4:
OGRE_CHECK_GL_ERROR(glUniformMatrix3x4fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_4X2:
OGRE_CHECK_GL_ERROR(glUniformMatrix4x2fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_4X3:
OGRE_CHECK_GL_ERROR(glUniformMatrix4x3fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_4X4:
OGRE_CHECK_GL_ERROR(glUniformMatrix4fv(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_INT1:
OGRE_CHECK_GL_ERROR(glUniform1iv(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex)));
break;
case GCT_INT2:
OGRE_CHECK_GL_ERROR(glUniform2iv(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex)));
break;
case GCT_INT3:
OGRE_CHECK_GL_ERROR(glUniform3iv(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex)));
break;
case GCT_INT4:
OGRE_CHECK_GL_ERROR(glUniform4iv(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex)));
break;
case GCT_SAMPLER1D:
case GCT_SAMPLER1DSHADOW:
case GCT_SAMPLER2D:
case GCT_SAMPLER2DSHADOW:
case GCT_SAMPLER2DARRAY:
case GCT_SAMPLER3D:
case GCT_SAMPLERCUBE:
case GCT_SAMPLERRECT:
// Samplers handled like 1-element ints
OGRE_CHECK_GL_ERROR(glUniform1iv(currentUniform->mLocation, 1,
(GLint*)params->getIntPointer(def->physicalIndex)));
break;
case GCT_SUBROUTINE:
case GCT_UNKNOWN:
break;
} // End switch
} // Variability & mask
} // fromProgType == currentUniform->mSourceProgType
} // End for
}
