void GrGpuGLShaders::flushColor(GrColor color) {
const ProgramDesc& desc = fCurrentProgram.getDesc();
const GrDrawState& drawState = this->getDrawState();
if (this->getVertexLayout() & kColor_VertexLayoutBit) {
// color will be specified per-vertex as an attribute
// invalidate the const vertex attrib color
fHWDrawState.setColor(GrColor_ILLEGAL);
} else {
switch (desc.fColorInput) {
case ProgramDesc::kAttribute_ColorInput:
if (fHWDrawState.getColor() != color) {
// OpenGL ES only supports the float varieties of
// glVertexAttrib
float c[] = GR_COLOR_TO_VEC4(color);
GL_CALL(VertexAttrib4fv(GrGLProgram::ColorAttributeIdx(),
c));
fHWDrawState.setColor(color);
}
break;
case ProgramDesc::kUniform_ColorInput:
if (fProgramData->fColor != color) {
// OpenGL ES doesn't support unsigned byte varieties of
// glUniform
float c[] = GR_COLOR_TO_VEC4(color);
GrAssert(GrGLProgram::kUnusedUniform !=
fProgramData->fUniLocations.fColorUni);
GL_CALL(Uniform4fv(fProgramData->fUniLocations.fColorUni,
1, c));
fProgramData->fColor = color;
}
break;
case ProgramDesc::kSolidWhite_ColorInput:
case ProgramDesc::kTransBlack_ColorInput:
break;
default:
GrCrash("Unknown color type.");
}
}
if (fProgramData->fUniLocations.fColorFilterUni
!= GrGLProgram::kUnusedUniform
&& fProgramData->fColorFilterColor
!= drawState.getColorFilterColor()) {
float c[] = GR_COLOR_TO_VEC4(drawState.getColorFilterColor());
GL_CALL(Uniform4fv(fProgramData->fUniLocations.fColorFilterUni, 1, c));
fProgramData->fColorFilterColor = drawState.getColorFilterColor();
}
}
void GrGpuGLShaders::flushTextureDomain(int s) {
const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTexDomUni;
const GrDrawState& drawState = this->getDrawState();
if (GrGLProgram::kUnusedUniform != uni) {
const GrRect &texDom = drawState.getSampler(s).getTextureDomain();
if (((1 << s) & fDirtyFlags.fTextureChangedMask) ||
fProgramData->fTextureDomain[s] != texDom) {
fProgramData->fTextureDomain[s] = texDom;
float values[4] = {
GrScalarToFloat(texDom.left()),
GrScalarToFloat(texDom.top()),
GrScalarToFloat(texDom.right()),
GrScalarToFloat(texDom.bottom())
};
const GrGLTexture* texture =
static_cast<const GrGLTexture*>(drawState.getTexture(s));
GrGLTexture::Orientation orientation = texture->orientation();
// vertical flip if necessary
if (GrGLTexture::kBottomUp_Orientation == orientation) {
values[1] = 1.0f - values[1];
values[3] = 1.0f - values[3];
// The top and bottom were just flipped, so correct the ordering
// of elements so that values = (l, t, r, b).
SkTSwap(values[1], values[3]);
}
GL_CALL(Uniform4fv(uni, 1, values));
}
}
}
void CShaderAPIOES2::SetPixelShaderFogParams(int reg)
{
float fogParams[8];
if ((m_TransitionTable.CurrentShadowState()->m_FogMode != SHADER_FOGMODE_DISABLED) &&
(m_SceneFogMode != MATERIAL_FOG_NONE))
{
fogParams[0] = m_FogConstant[0];
fogParams[1] = m_FogConstant[1];
// Negative z means water fog (to avoid using additional boolean constant).
fogParams[2] = (m_SceneFogMode == MATERIAL_FOG_LINEAR) ? m_FogConstant[2] : -1.0f;
fogParams[3] = m_FogConstant[3];
}
else
{
fogParams[0] = 1.0f;
fogParams[1] = m_DynamicState.m_FogZ;
fogParams[2] = 1.0f;
fogParams[3] = 0.0f;
}
fogParams[4] = m_DynamicState.m_PixelFogColor[0];
fogParams[5] = m_DynamicState.m_PixelFogColor[1];
fogParams[6] = m_DynamicState.m_PixelFogColor[2];
fogParams[7] = 0.0f;
Uniform4fv(reg, 2, fogParams);
}
void HudShader::useProgram() {
Shader::useProgram();
if (_projectionMatrixDirty || _modelMatrixDirty) {
glm::mat4 mvpMatrix = _projectionMatrix * _modelMatrix;
GL(UniformMatrix4fv(_mvpMatrixLoc, 1, GL_FALSE, glm::value_ptr(mvpMatrix)));
_projectionMatrixDirty = false;
_modelMatrixDirty = false;
}
if (_colorDirty) {
GL(Uniform4fv(_colorLoc, 1, glm::value_ptr(_color)));
_colorDirty = false;
}
}
void GrGpuGLShaders::flushColorMatrix() {
const ProgramDesc& desc = fCurrentProgram.getDesc();
int matrixUni = fProgramData->fUniLocations.fColorMatrixUni;
int vecUni = fProgramData->fUniLocations.fColorMatrixVecUni;
if (GrGLProgram::kUnusedUniform != matrixUni
&& GrGLProgram::kUnusedUniform != vecUni) {
const float* m = this->getDrawState().getColorMatrix();
GrGLfloat mt[] = {
m[0], m[5], m[10], m[15],
m[1], m[6], m[11], m[16],
m[2], m[7], m[12], m[17],
m[3], m[8], m[13], m[18],
};
static float scale = 1.0f / 255.0f;
GrGLfloat vec[] = {
m[4] * scale, m[9] * scale, m[14] * scale, m[19] * scale,
};
GL_CALL(UniformMatrix4fv(matrixUni, 1, false, mt));
GL_CALL(Uniform4fv(vecUni, 1, vec));
}
}
GL_APICALL void GL_APIENTRY glUniform4fv (GLint location, GLsizei count, const GLfloat* v)
{
CONTEXT_EXEC(Uniform4fv(location, count, v));
}
//---------------------------------------------------------------------------
void Material::RegisterStaticUniform4fv( const std::string& name, const std::vector< Vec4f >& values )
{
m_uniforms4fv.push_back( Uniform4fv( name, values ) );
}
