mozilla
/
moz-skia
зеркало из https://github.com/mozilla/moz-skia.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Remove dirty flags from GrGpuGL state flush 

Review URL: http://codereview.appspot.com/6255073/



git-svn-id: http://skia.googlecode.com/svn/trunk@4122 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
bsalomon@google.com 2012-06-01 19:01:37 +00:00
Родитель 0b323316ed
Коммит 890e3b58e7
5 изменённых файлов: 85 добавлений и 115 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

3
src/gpu/gl/GrGLProgram.cpp
Просмотреть файл

@ -1193,6 +1193,9 @@ void GrGLProgram::getUniformLocationsAndInitCache(const GrGLContextInfo& gl,
programData->fTextureWidth[s] = -1;
programData->fTextureHeight[s] = -1;
programData->fTextureDomain[s].setEmpty();
// this is arbitrary, just initialize to something
programData->fTextureOrientation[s] =
GrGLTexture::kBottomUp_Orientation;
// Must not reset fStageOverride[] here.
}
programData->fViewMatrix = GrMatrix::InvalidMatrix();

4
src/gpu/gl/GrGLProgram.h
Просмотреть файл

@ -12,6 +12,7 @@
#include "GrDrawState.h"
#include "GrGLContextInfo.h"
#include "GrGLSL.h"
#include "GrGLTexture.h"
#include "GrStringBuilder.h"
#include "GrGpu.h"
@ -336,6 +337,9 @@ public:
GrScalar fRadial2Radius0[GrDrawState::kNumStages];
bool fRadial2PosRoot[GrDrawState::kNumStages];
GrRect fTextureDomain[GrDrawState::kNumStages];
// The texture domain and texture matrix sent to GL depend upon the
// orientation.
GrGLTexture::Orientation fTextureOrientation[GrDrawState::kNumStages];
GrGLProgramStage* fCustomStage[GrDrawState::kNumStages];

47
src/gpu/gl/GrGpuGL.cpp
Просмотреть файл

@ -111,40 +111,6 @@ bool GrGpuGL::BlendCoeffReferencesConstant(GrBlendCoeff coeff) {
///////////////////////////////////////////////////////////////////////////////
void GrGpuGL::AdjustTextureMatrix(const GrGLTexture* texture,
GrSamplerState::SampleMode mode,
GrMatrix* matrix) {
GrAssert(NULL != texture);
GrAssert(NULL != matrix);
GrGLTexture::Orientation orientation = texture->orientation();
if (GrGLTexture::kBottomUp_Orientation == orientation) {
GrMatrix invY;
invY.setAll(GR_Scalar1, 0, 0,
0, -GR_Scalar1, GR_Scalar1,
0, 0, GrMatrix::I()[8]);
matrix->postConcat(invY);
} else {
GrAssert(GrGLTexture::kTopDown_Orientation == orientation);
}
}
bool GrGpuGL::TextureMatrixIsIdentity(const GrGLTexture* texture,
const GrSamplerState& sampler) {
GrAssert(NULL != texture);
if (!sampler.getMatrix().isIdentity()) {
return false;
}
GrGLTexture::Orientation orientation = texture->orientation();
if (GrGLTexture::kBottomUp_Orientation == orientation) {
return false;
} else {
GrAssert(GrGLTexture::kTopDown_Orientation == orientation);
}
return true;
}
///////////////////////////////////////////////////////////////////////////////
static bool gPrintStartupSpew;
static bool fbo_test(const GrGLInterface* gl, int w, int h) {
@ -203,8 +169,6 @@ GrGpuGL::GrGpuGL(const GrGLContextInfo& ctxInfo) : fGLContextInfo(ctxInfo) {
GrPrintf("------ EXTENSIONS\n %s \n", ext);
}
this->resetDirtyFlags();
this->initCaps();
fProgramData = NULL;
@ -1657,12 +1621,14 @@ void GrGpuGL::flushRenderTarget(const GrIRect* bound) {
GrPrintf("GrGpuGL::flushRenderTarget glCheckFramebufferStatus %x\n", status);
}
#endif
fDirtyFlags.fRenderTargetChanged = true;
fHWBoundRenderTarget = rt;
const GrGLIRect& vp = rt->getViewport();
if (fHWBounds.fViewportRect != vp) {
vp.pushToGLViewport(this->glInterface());
fHWBounds.fViewportRect = vp;
// View matrices pushed to GL depend upon the viewport. So they
// are now invalid.
fProgramCache->invalidateViewMatrices();
}
}
if (NULL == bound || !bound->isEmpty()) {
@ -2177,9 +2143,6 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) {
#endif
//GrPrintf("---- bindtexture %d\n", nextTexture->textureID());
fHWBoundTextures[s] = nextTexture;
// The texture matrix has to compensate for texture width/height
// and NPOT-embedded-in-POT
fDirtyFlags.fTextureChangedMask |= (1 << s);
}
const GrSamplerState& sampler = drawState->getSampler(s);
@ -2480,10 +2443,6 @@ void GrGpuGL::setSpareTextureUnit() {
}
}
void GrGpuGL::resetDirtyFlags() {
Gr_bzero(&fDirtyFlags, sizeof(fDirtyFlags));
}
void GrGpuGL::setBuffers(bool indexed,
int* extraVertexOffset,
int* extraIndexOffset) {

27
src/gpu/gl/GrGpuGL.h
Просмотреть файл

@ -76,26 +76,6 @@ protected:
kDownOnWrite_UpOnRead_UnpremulConversion
} fUnpremulConversion;
// The current render target and textures are bound by GrGpuGL when it
// flushes state to GL. After the bindings occur the variables that track
// the current GL state are updated to reflect the new bindings. However,
// the GrGpuGL subclass may have subsequent GL state manipulation it must
// perform whenever RT or textures change. So the GrGpuGL will set these
// dirty flags when it changes the RT or texture bindings. The subclass can
// use them to trigger its dependent state flushing. The subclass should
// call resetDirtyFlags to zero these out after it has consumed them.
//
// TODO: Merge GrGpuGLShaders into GrGpuGL and remove the need for these
// flags.
struct {
bool fRenderTargetChanged : 1;
int fTextureChangedMask;
} fDirtyFlags;
GR_STATIC_ASSERT(8 * sizeof(int) >= GrDrawState::kNumStages);
// clears the dirty flags
void resetDirtyFlags();
// last scissor / viewport scissor state seen by the GL.
struct {
bool fScissorEnabled;
@ -260,11 +240,8 @@ private:
const GrGLContextInfo& fGL;
};
// sets the texture matrix uniform for currently bound program
void flushTextureMatrix(int stage);
// sets the texture domain uniform for currently bound program
void flushTextureDomain(int stage);
// sets the texture matrix and domain for the currently bound program
void flushTextureMatrixAndDomain(int stage);
// sets the color specified by GrDrawState::setColor()
void flushColor(GrColor color);

119
src/gpu/gl/GrGpuGL_program.cpp
Просмотреть файл

@ -366,53 +366,61 @@ void GrGpuGL::flushViewMatrix() {
}
}
void GrGpuGL::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) {
// helpers for texture matrices
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 GrGpuGL::AdjustTextureMatrix(const GrGLTexture* texture,
GrSamplerState::SampleMode mode,
GrMatrix* matrix) {
GrAssert(NULL != texture);
GrAssert(NULL != matrix);
GrGLTexture::Orientation orientation = texture->orientation();
if (GrGLTexture::kBottomUp_Orientation == orientation) {
GrMatrix invY;
invY.setAll(GR_Scalar1, 0, 0,
0, -GR_Scalar1, GR_Scalar1,
0, 0, GrMatrix::I()[8]);
matrix->postConcat(invY);
} else {
GrAssert(GrGLTexture::kTopDown_Orientation == orientation);
}
}
void GrGpuGL::flushTextureMatrix(int s) {
const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTextureMatrixUni;
bool GrGpuGL::TextureMatrixIsIdentity(const GrGLTexture* texture,
const GrSamplerState& sampler) {
GrAssert(NULL != texture);
if (!sampler.getMatrix().isIdentity()) {
return false;
}
GrGLTexture::Orientation orientation = texture->orientation();
if (GrGLTexture::kBottomUp_Orientation == orientation) {
return false;
} else {
GrAssert(GrGLTexture::kTopDown_Orientation == orientation);
}
return true;
}
///////////////////////////////////////////////////////////////////////////////
void GrGpuGL::flushTextureMatrixAndDomain(int s) {
const GrDrawState& drawState = this->getDrawState();
const GrGLTexture* texture =
static_cast<const GrGLTexture*>(drawState.getTexture(s));
if (NULL != texture) {
bool orientationChange = fProgramData->fTextureOrientation[s] !=
texture->orientation();
const GrGLint& matrixUni =
fProgramData->fUniLocations.fStages[s].fTextureMatrixUni;
const GrMatrix& hwMatrix = fProgramData->fTextureMatrices[s];
const GrMatrix& samplerMatrix = drawState.getSampler(s).getMatrix();
if (GrGLProgram::kUnusedUniform != uni &&
(((1 << s) & fDirtyFlags.fTextureChangedMask) ||
!hwMatrix.cheapEqualTo(samplerMatrix))) {
if (GrGLProgram::kUnusedUniform != matrixUni &&
(orientationChange || !hwMatrix.cheapEqualTo(samplerMatrix))) {
GrMatrix m = samplerMatrix;
GrSamplerState::SampleMode mode =
@ -433,9 +441,36 @@ void GrGpuGL::flushTextureMatrix(int s) {
GrScalarToFloat(m[GrMatrix::kMPersp2])
};
GL_CALL(UniformMatrix3fv(uni, 1, false, mt));
GL_CALL(UniformMatrix3fv(matrixUni, 1, false, mt));
fProgramData->fTextureMatrices[s] = samplerMatrix;
}
const GrGLint& domUni =
fProgramData->fUniLocations.fStages[s].fTexDomUni;
const GrRect &texDom = drawState.getSampler(s).getTextureDomain();
if (GrGLProgram::kUnusedUniform != domUni &&
(orientationChange ||fProgramData->fTextureDomain[s] != texDom)) {
fProgramData->fTextureDomain[s] = texDom;
float values[4] = {
GrScalarToFloat(texDom.left()),
GrScalarToFloat(texDom.top()),
GrScalarToFloat(texDom.right()),
GrScalarToFloat(texDom.bottom())
};
// vertical flip if necessary
if (GrGLTexture::kBottomUp_Orientation == texture->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(domUni, 1, values));
}
fProgramData->fTextureOrientation[s] = texture->orientation();
}
}
@ -619,11 +654,6 @@ bool GrGpuGL::flushGraphicsState(GrPrimitiveType type) {
const GrDrawState& drawState = this->getDrawState();
if (fDirtyFlags.fRenderTargetChanged) {
// we assume all shader matrices may be wrong after viewport changes
fProgramCache->invalidateViewMatrices();
}
GrBlendCoeff srcCoeff;
GrBlendCoeff dstCoeff;
BlendOptFlags blendOpts = this->getBlendOpts(false, &srcCoeff, &dstCoeff);
@ -666,14 +696,12 @@ bool GrGpuGL::flushGraphicsState(GrPrimitiveType type) {
for (int s = 0; s < GrDrawState::kNumStages; ++s) {
if (this->isStageEnabled(s)) {
this->flushTextureMatrix(s);
this->flushTextureMatrixAndDomain(s);
this->flushRadial2(s);
this->flushTexelSize(s);
this->flushTextureDomain(s);
if (NULL != fProgramData->fCustomStage[s]) {
const GrSamplerState& sampler =
this->getDrawState().getSampler(s);
@ -687,7 +715,6 @@ bool GrGpuGL::flushGraphicsState(GrPrimitiveType type) {
}
}
this->flushColorMatrix();
resetDirtyFlags();
return true;
}