void GrGpuGLShaders::flushTextureMatrix(int stage) {
GrAssert(NULL != fCurrDrawState.fTextures[stage]);
GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[stage];
GrMatrix m = getSamplerMatrix(stage);
GrSamplerState::SampleMode mode =
fCurrDrawState.fSamplerStates[0].getSampleMode();
AdjustTextureMatrix(texture, mode, &m);
// ES doesn't allow you to pass true to the transpose param,
// so do our own transpose
GrScalar mt[] = {
m[GrMatrix::kScaleX],
m[GrMatrix::kSkewY],
m[GrMatrix::kPersp0],
m[GrMatrix::kSkewX],
m[GrMatrix::kScaleY],
m[GrMatrix::kPersp1],
m[GrMatrix::kTransX],
m[GrMatrix::kTransY],
m[GrMatrix::kPersp2]
};
#if ATTRIBUTE_MATRIX
GR_GL(VertexAttrib4fv(TEXMAT_ATTR_LOCATION(0)+0, mt+0));
GR_GL(VertexAttrib4fv(TEXMAT_ATTR_LOCATION(0)+1, mt+3));
GR_GL(VertexAttrib4fv(TEXMAT_ATTR_LOCATION(0)+2, mt+6));
#else
GR_GL(UniformMatrix3fv(fProgramData->fUniLocations.fStages[stage].fTextureMatrixUni,
1, false, mt));
#endif
}
void GrGpuGL::flushTextureMatrix(int s) {
const GrDrawState& drawState = this->getDrawState();
// FIXME: Still assuming only a single texture per effect
const GrEffect* effect = drawState.getStage(s).getEffect();
if (0 == effect->numTextures()) {
return;
}
const GrGLTexture* texture = static_cast<const GrGLTexture*>(effect->texture(0));
if (NULL != texture) {
bool originChange = fCurrentProgram->fTextureOrigin[s] != texture->origin();
UniformHandle matrixUni = fCurrentProgram->fUniforms.fStages[s].fTextureMatrixUni;
const GrMatrix& hwMatrix = fCurrentProgram->fTextureMatrices[s];
GrMatrix samplerMatrix;
drawState.getStage(s).getTotalMatrix(&samplerMatrix);
if (kInvalidUniformHandle != matrixUni &&
(originChange || !hwMatrix.cheapEqualTo(samplerMatrix))) {
GrMatrix m = samplerMatrix;
AdjustTextureMatrix(texture, &m);
// ES doesn't allow you to pass true to the transpose param,
// so do our own transpose
GrGLfloat mt[] = {
GrScalarToFloat(m[GrMatrix::kMScaleX]),
GrScalarToFloat(m[GrMatrix::kMSkewY]),
GrScalarToFloat(m[GrMatrix::kMPersp0]),
GrScalarToFloat(m[GrMatrix::kMSkewX]),
GrScalarToFloat(m[GrMatrix::kMScaleY]),
GrScalarToFloat(m[GrMatrix::kMPersp1]),
GrScalarToFloat(m[GrMatrix::kMTransX]),
GrScalarToFloat(m[GrMatrix::kMTransY]),
GrScalarToFloat(m[GrMatrix::kMPersp2])
};
fCurrentProgram->fUniformManager.setMatrix3f(matrixUni, mt);
fCurrentProgram->fTextureMatrices[s] = samplerMatrix;
}
fCurrentProgram->fTextureOrigin[s] = texture->origin();
}
}
void GrGpuGLShaders::flushTextureMatrix(int s) {
const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTextureMatrixUni;
GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
if (NULL != texture) {
if (GrGLProgram::kUnusedUniform != uni &&
(((1 << s) & fDirtyFlags.fTextureChangedMask) ||
getHWSamplerMatrix(s) != getSamplerMatrix(s))) {
GrAssert(NULL != fCurrDrawState.fTextures[s]);
GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
GrMatrix m = getSamplerMatrix(s);
GrSamplerState::SampleMode mode =
fCurrDrawState.fSamplerStates[s].getSampleMode();
AdjustTextureMatrix(texture, mode, &m);
// ES doesn't allow you to pass true to the transpose param,
// so do our own transpose
GrGLfloat mt[] = {
GrScalarToFloat(m[GrMatrix::kMScaleX]),
GrScalarToFloat(m[GrMatrix::kMSkewY]),
GrScalarToFloat(m[GrMatrix::kMPersp0]),
GrScalarToFloat(m[GrMatrix::kMSkewX]),
GrScalarToFloat(m[GrMatrix::kMScaleY]),
GrScalarToFloat(m[GrMatrix::kMPersp1]),
GrScalarToFloat(m[GrMatrix::kMTransX]),
GrScalarToFloat(m[GrMatrix::kMTransY]),
GrScalarToFloat(m[GrMatrix::kMPersp2])
};
if (GrGLProgram::kSetAsAttribute ==
fProgramData->fUniLocations.fStages[s].fTextureMatrixUni) {
int baseIdx = GrGLProgram::TextureMatrixAttributeIdx(s);
GL_CALL(VertexAttrib4fv(baseIdx + 0, mt+0));
GL_CALL(VertexAttrib4fv(baseIdx + 1, mt+3));
GL_CALL(VertexAttrib4fv(baseIdx + 2, mt+6));
} else {
GL_CALL(UniformMatrix3fv(uni, 1, false, mt));
}
recordHWSamplerMatrix(s, getSamplerMatrix(s));
}
}
}
void GrGpuGLShaders::flushTextureMatrix(int s) {
const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTextureMatrixUni;
const GrDrawState& drawState = this->getDrawState();
const GrGLTexture* texture =
static_cast<const GrGLTexture*>(drawState.getTexture(s));
if (NULL != texture) {
const GrMatrix& hwMatrix = fProgramData->fTextureMatrices[s];
const GrMatrix& samplerMatrix = drawState.getSampler(s).getMatrix();
if (GrGLProgram::kUnusedUniform != uni &&
(((1 << s) & fDirtyFlags.fTextureChangedMask) ||
!hwMatrix.cheapEqualTo(samplerMatrix))) {
GrMatrix m = samplerMatrix;
GrSamplerState::SampleMode mode =
drawState.getSampler(s).getSampleMode();
AdjustTextureMatrix(texture, mode, &m);
// ES doesn't allow you to pass true to the transpose param,
// so do our own transpose
GrGLfloat mt[] = {
GrScalarToFloat(m[GrMatrix::kMScaleX]),
GrScalarToFloat(m[GrMatrix::kMSkewY]),
GrScalarToFloat(m[GrMatrix::kMPersp0]),
GrScalarToFloat(m[GrMatrix::kMSkewX]),
GrScalarToFloat(m[GrMatrix::kMScaleY]),
GrScalarToFloat(m[GrMatrix::kMPersp1]),
GrScalarToFloat(m[GrMatrix::kMTransX]),
GrScalarToFloat(m[GrMatrix::kMTransY]),
GrScalarToFloat(m[GrMatrix::kMPersp2])
};
GL_CALL(UniformMatrix3fv(uni, 1, false, mt));
fProgramData->fTextureMatrices[s] = samplerMatrix;
}
}
}
bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) {
bool usingTextures[kNumStages];
for (int s = 0; s < kNumStages; ++s) {
usingTextures[s] = VertexUsesStage(s, fGeometrySrc.fVertexLayout);
if (usingTextures[s] && fCurrDrawState.fSamplerStates[s].isGradient()) {
unimpl("Fixed pipe doesn't support radial/sweep gradients");
return false;
}
}
if (GR_GL_SUPPORT_ES1) {
if (BlendCoefReferencesConstant(fCurrDrawState.fSrcBlend) ||
BlendCoefReferencesConstant(fCurrDrawState.fDstBlend)) {
unimpl("ES1 doesn't support blend constant");
return false;
}
}
if (!flushGLStateCommon(type)) {
return false;
}
if (fDirtyFlags.fRenderTargetChanged) {
flushProjectionMatrix();
}
for (int s = 0; s < kNumStages; ++s) {
bool wasUsingTexture = VertexUsesStage(s, fHWGeometryState.fVertexLayout);
if (usingTextures[s] != wasUsingTexture) {
setTextureUnit(s);
if (usingTextures[s]) {
GR_GL(Enable(GR_GL_TEXTURE_2D));
} else {
GR_GL(Disable(GR_GL_TEXTURE_2D));
}
}
}
uint32_t vertColor = (fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit);
uint32_t prevVertColor = (fHWGeometryState.fVertexLayout &
kColor_VertexLayoutBit);
if (vertColor != prevVertColor) {
if (vertColor) {
GR_GL(ShadeModel(GR_GL_SMOOTH));
// invalidate the immediate mode color
fHWDrawState.fColor = GrColor_ILLEGAL;
} else {
GR_GL(ShadeModel(GR_GL_FLAT));
}
}
if (!vertColor && fHWDrawState.fColor != fCurrDrawState.fColor) {
GR_GL(Color4ub(GrColorUnpackR(fCurrDrawState.fColor),
GrColorUnpackG(fCurrDrawState.fColor),
GrColorUnpackB(fCurrDrawState.fColor),
GrColorUnpackA(fCurrDrawState.fColor)));
fHWDrawState.fColor = fCurrDrawState.fColor;
}
// set texture environment, decide whether we are modulating by RGB or A.
for (int s = 0; s < kNumStages; ++s) {
if (usingTextures[s]) {
GrGLTexture* texture = (GrGLTexture*)fCurrDrawState.fTextures[s];
if (NULL != texture) {
TextureEnvRGBOperands nextRGBOperand0 =
(GrPixelConfigIsAlphaOnly(texture->config())) ?
kAlpha_TextureEnvRGBOperand :
kColor_TextureEnvRGBOperand;
if (fHWRGBOperand0[s] != nextRGBOperand0) {
setTextureUnit(s);
GR_GL(TexEnvi(GR_GL_TEXTURE_ENV,
GR_GL_OPERAND0_RGB,
(nextRGBOperand0==kAlpha_TextureEnvRGBOperand) ?
GR_GL_SRC_ALPHA :
GR_GL_SRC_COLOR));
fHWRGBOperand0[s] = nextRGBOperand0;
}
if (((1 << s) & fDirtyFlags.fTextureChangedMask) ||
(fHWDrawState.fSamplerStates[s].getMatrix() !=
getSamplerMatrix(s))) {
GrMatrix texMat = getSamplerMatrix(s);
AdjustTextureMatrix(texture,
GrSamplerState::kNormal_SampleMode,
&texMat);
GrGpuMatrix glm;
glm.set(texMat);
setTextureUnit(s);
GR_GL(MatrixMode(GR_GL_TEXTURE));
GR_GL(LoadMatrixf(glm.fMat));
recordHWSamplerMatrix(s, getSamplerMatrix(s));
}
} else {
GrAssert(!"Rendering with texture vert flag set but no bound texture");
return false;
}
}
}
if (fHWDrawState.fViewMatrix != fCurrDrawState.fViewMatrix) {
GrGpuMatrix glm;
glm.set(fCurrDrawState.fViewMatrix);
GR_GL(MatrixMode(GR_GL_MODELVIEW));
GR_GL(LoadMatrixf(glm.fMat));
fHWDrawState.fViewMatrix =
fCurrDrawState.fViewMatrix;
}
resetDirtyFlags();
return true;
}
