The Tor Browser: comparison gfx/skia/trunk/src/gpu/gl/GrGLProgram.h

--1:000000000000
+:9516a0d0c5ef
+/*
+* Copyright 2011 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+#ifndef GrGLProgram_DEFINED
+#define GrGLProgram_DEFINED
+#include "GrDrawState.h"
+#include "GrGLContext.h"
+#include "GrGLProgramDesc.h"
+#include "GrGLShaderBuilder.h"
+#include "GrGLSL.h"
+#include "GrGLTexture.h"
+#include "GrGLUniformManager.h"
+#include "SkString.h"
+#include "SkXfermode.h"
+class GrBinHashKeyBuilder;
+class GrGLEffect;
+class GrGLProgramEffects;
+class GrGLShaderBuilder;
+/**
+* This class manages a GPU program and records per-program information.
+* We can specify the attribute locations so that they are constant
+* across our shaders. But the driver determines the uniform locations
+* at link time. We don't need to remember the sampler uniform location
+* because we will bind a texture slot to it and never change it
+* Uniforms are program-local so we can't rely on fHWState to hold the
+* previous uniform state after a program change.
+*/
+class GrGLProgram : public SkRefCnt {
+public:
+SK_DECLARE_INST_COUNT(GrGLProgram)
+static GrGLProgram* Create(GrGpuGL* gpu,
+const GrGLProgramDesc& desc,
+const GrEffectStage* colorStages[],
+const GrEffectStage* coverageStages[]);
+virtual ~GrGLProgram();
+/**
+* Call to abandon GL objects owned by this program.
+*/
+void abandon();
+/**
+* The shader may modify the blend coefficients. Params are in/out.
+*/
+void overrideBlend(GrBlendCoeff* srcCoeff, GrBlendCoeff* dstCoeff) const;
+const GrGLProgramDesc& getDesc() { return fDesc; }
+/**
+* Gets the GL program ID for this program.
+*/
+GrGLuint programID() const { return fProgramID; }
+bool hasVertexShader() const { return fHasVertexShader; }
+/**
+* Some GL state that is relevant to programs is not stored per-program. In particular color
+* and coverage attributes can be global state. This struct is read and updated by
+* GrGLProgram::setColor and GrGLProgram::setCoverage to allow us to avoid setting this state
+* redundantly.
+*/
+struct SharedGLState {
+GrColor fConstAttribColor;
+int     fConstAttribColorIndex;
+GrColor fConstAttribCoverage;
+int     fConstAttribCoverageIndex;
+SharedGLState() { this->invalidate(); }
+void invalidate() {
+fConstAttribColor = GrColor_ILLEGAL;
+fConstAttribColorIndex = -1;
+fConstAttribCoverage = GrColor_ILLEGAL;
+fConstAttribCoverageIndex = -1;
+}
+};
+/**
+* The GrDrawState's view matrix along with the aspects of the render target determine the
+* matrix sent to GL. The size of the render target affects the GL matrix because we must
+* convert from Skia device coords to GL's normalized coords. Also the origin of the render
+* target may require us to perform a mirror-flip.
+*/
+struct MatrixState {
+SkMatrix        fViewMatrix;
+SkISize         fRenderTargetSize;
+GrSurfaceOrigin fRenderTargetOrigin;
+MatrixState() { this->invalidate(); }
+void invalidate() {
+fViewMatrix = SkMatrix::InvalidMatrix();
+fRenderTargetSize.fWidth = -1;
+fRenderTargetSize.fHeight = -1;
+fRenderTargetOrigin = (GrSurfaceOrigin) -1;
+}
+template<int Size> void getGLMatrix(GrGLfloat* destMatrix) {
+SkMatrix combined;
+if (kBottomLeft_GrSurfaceOrigin == fRenderTargetOrigin) {
+combined.setAll(SkIntToScalar(2) / fRenderTargetSize.fWidth, 0, -SK_Scalar1,
+0, -SkIntToScalar(2) / fRenderTargetSize.fHeight, SK_Scalar1,
+0, 0, SkMatrix::I()[8]);
+} else {
+combined.setAll(SkIntToScalar(2) / fRenderTargetSize.fWidth, 0, -SK_Scalar1,
+0, SkIntToScalar(2) / fRenderTargetSize.fHeight, -SK_Scalar1,
+0, 0, SkMatrix::I()[8]);
+}
+combined.setConcat(combined, fViewMatrix);
+GrGLGetMatrix<Size>(destMatrix, combined);
+}
+};
+/**
+* This function uploads uniforms and calls each GrGLEffect's setData. It is called before a
+* draw occurs using the program after the program has already been bound. It also uses the
+* GrGpuGL object to bind the textures required by the GrGLEffects. The color and coverage
+* stages come from GrGLProgramDesc::Build().
+*/
+void setData(GrDrawState::BlendOptFlags,
+const GrEffectStage* colorStages[],
+const GrEffectStage* coverageStages[],
+const GrDeviceCoordTexture* dstCopy, // can be NULL
+SharedGLState*);
+private:
+typedef GrGLUniformManager::UniformHandle UniformHandle;
+// handles for uniforms (aside from per-effect samplers)
+struct UniformHandles {
+UniformHandle       fViewMatrixUni;
+UniformHandle       fColorUni;
+UniformHandle       fCoverageUni;
+// We use the render target height to provide a y-down frag coord when specifying
+// origin_upper_left is not supported.
+UniformHandle       fRTHeightUni;
+// Uniforms for computing texture coords to do the dst-copy lookup
+UniformHandle       fDstCopyTopLeftUni;
+UniformHandle       fDstCopyScaleUni;
+UniformHandle       fDstCopySamplerUni;
+};
+GrGLProgram(GrGpuGL* gpu,
+const GrGLProgramDesc& desc,
+const GrEffectStage* colorStages[],
+const GrEffectStage* coverageStages[]);
+bool succeeded() const { return 0 != fProgramID; }
+/**
+* This is the heavy initialization routine for building a GLProgram. colorStages and
+* coverageStages correspond to the output of GrGLProgramDesc::Build().
+*/
+bool genProgram(GrGLShaderBuilder* builder,
+const GrEffectStage* colorStages[],
+const GrEffectStage* coverageStages[]);
+// Sets the texture units for samplers
+void initSamplerUniforms();
+// Helper for setData(). Makes GL calls to specify the initial color when there is not
+// per-vertex colors.
+void setColor(const GrDrawState&, GrColor color, SharedGLState*);
+// Helper for setData(). Makes GL calls to specify the initial coverage when there is not
+// per-vertex coverages.
+void setCoverage(const GrDrawState&, GrColor coverage, SharedGLState*);
+// Helper for setData() that sets the view matrix and loads the render target height uniform
+void setMatrixAndRenderTargetHeight(const GrDrawState&);
+// GL program ID
+GrGLuint                    fProgramID;
+// these reflect the current values of uniforms (GL uniform values travel with program)
+MatrixState                       fMatrixState;
+GrColor                           fColor;
+GrColor                           fCoverage;
+int                               fDstCopyTexUnit;
+SkAutoTDelete<GrGLProgramEffects> fColorEffects;
+SkAutoTDelete<GrGLProgramEffects> fCoverageEffects;
+GrGLProgramDesc                   fDesc;
+GrGpuGL*                          fGpu;
+GrGLUniformManager                fUniformManager;
+UniformHandles                    fUniformHandles;
+bool                              fHasVertexShader;
+int                               fNumTexCoordSets;
+typedef SkRefCnt INHERITED;
+};
+#endif

The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/gpu/gl/GrGLProgram.h

gfx/skia/trunk/src/gpu/gl/GrGLProgram.h