diff options
author | 2015-02-12 14:20:52 -0800 | |
---|---|---|
committer | 2015-02-12 14:20:52 -0800 | |
commit | 8072caa80384292858d31ae34b7e19768875866b (patch) | |
tree | 540934943305cb0aa1e73bfa836e260cab8b45b0 /src/gpu/GrGeometryProcessor.cpp | |
parent | b0fb935bd544b0c6f68c692c7e1ee40876184a1a (diff) |
A simple change to move a bunch of stuff out of Gr*Geometry.h
BUG=skia:
Review URL: https://codereview.chromium.org/920863002
Diffstat (limited to 'src/gpu/GrGeometryProcessor.cpp')
-rw-r--r-- | src/gpu/GrGeometryProcessor.cpp | 542 |
1 files changed, 0 insertions, 542 deletions
diff --git a/src/gpu/GrGeometryProcessor.cpp b/src/gpu/GrGeometryProcessor.cpp index c707efc6a2..23989cfe92 100644 --- a/src/gpu/GrGeometryProcessor.cpp +++ b/src/gpu/GrGeometryProcessor.cpp @@ -7,70 +7,7 @@ #include "GrGeometryProcessor.h" -#include "GrCoordTransform.h" #include "GrInvariantOutput.h" -#include "gl/GrGLGeometryProcessor.h" - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -/** - * The key for an individual coord transform is made up of a matrix type, a precision, and a bit - * that indicates the source of the input coords. - */ -enum { - kMatrixTypeKeyBits = 1, - kMatrixTypeKeyMask = (1 << kMatrixTypeKeyBits) - 1, - - kPrecisionBits = 2, - kPrecisionShift = kMatrixTypeKeyBits, - - kPositionCoords_Flag = (1 << (kPrecisionShift + kPrecisionBits)), - kDeviceCoords_Flag = kPositionCoords_Flag + kPositionCoords_Flag, - - kTransformKeyBits = kMatrixTypeKeyBits + kPrecisionBits + 2, -}; - -GR_STATIC_ASSERT(kHigh_GrSLPrecision < (1 << kPrecisionBits)); - -/** - * We specialize the vertex code for each of these matrix types. - */ -enum MatrixType { - kNoPersp_MatrixType = 0, - kGeneral_MatrixType = 1, -}; - -uint32_t -GrPrimitiveProcessor::getTransformKey(const SkTArray<const GrCoordTransform*, true>& coords) const { - uint32_t totalKey = 0; - for (int t = 0; t < coords.count(); ++t) { - uint32_t key = 0; - const GrCoordTransform* coordTransform = coords[t]; - if (coordTransform->getMatrix().hasPerspective()) { - key |= kGeneral_MatrixType; - } else { - key |= kNoPersp_MatrixType; - } - - if (kLocal_GrCoordSet == coordTransform->sourceCoords() && - !this->hasExplicitLocalCoords()) { - key |= kPositionCoords_Flag; - } else if (kDevice_GrCoordSet == coordTransform->sourceCoords()) { - key |= kDeviceCoords_Flag; - } - - GR_STATIC_ASSERT(kGrSLPrecisionCount <= (1 << kPrecisionBits)); - key |= (coordTransform->precision() << kPrecisionShift); - - key <<= kTransformKeyBits * t; - - SkASSERT(0 == (totalKey & key)); // keys for each transform ought not to overlap - totalKey |= key; - } - return totalKey; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// void GrGeometryProcessor::getInvariantOutputColor(GrInitInvariantOutput* out) const { if (fHasVertexColor) { @@ -89,483 +26,4 @@ void GrGeometryProcessor::getInvariantOutputCoverage(GrInitInvariantOutput* out) this->onGetInvariantOutputCoverage(out); } -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#include "gl/builders/GrGLProgramBuilder.h" - -SkMatrix GrGLPrimitiveProcessor::GetTransformMatrix(const SkMatrix& localMatrix, - const GrCoordTransform& coordTransform) { - SkMatrix combined; - // We only apply the localmatrix to localcoords - if (kLocal_GrCoordSet == coordTransform.sourceCoords()) { - combined.setConcat(coordTransform.getMatrix(), localMatrix); - } else { - combined = coordTransform.getMatrix(); - } - if (coordTransform.reverseY()) { - // combined.postScale(1,-1); - // combined.postTranslate(0,1); - combined.set(SkMatrix::kMSkewY, - combined[SkMatrix::kMPersp0] - combined[SkMatrix::kMSkewY]); - combined.set(SkMatrix::kMScaleY, - combined[SkMatrix::kMPersp1] - combined[SkMatrix::kMScaleY]); - combined.set(SkMatrix::kMTransY, - combined[SkMatrix::kMPersp2] - combined[SkMatrix::kMTransY]); - } - return combined; -} - -void -GrGLPrimitiveProcessor::setupColorPassThrough(GrGLGPBuilder* pb, - GrGPInput inputType, - const char* outputName, - const GrGeometryProcessor::Attribute* colorAttr, - UniformHandle* colorUniform) { - GrGLGPFragmentBuilder* fs = pb->getFragmentShaderBuilder(); - if (kUniform_GrGPInput == inputType) { - SkASSERT(colorUniform); - const char* stagedLocalVarName; - *colorUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility, - kVec4f_GrSLType, - kDefault_GrSLPrecision, - "Color", - &stagedLocalVarName); - fs->codeAppendf("%s = %s;", outputName, stagedLocalVarName); - } else if (kAttribute_GrGPInput == inputType) { - SkASSERT(colorAttr); - pb->addPassThroughAttribute(colorAttr, outputName); - } else if (kAllOnes_GrGPInput == inputType) { - fs->codeAppendf("%s = vec4(1);", outputName); - } -} - -void GrGLPrimitiveProcessor::addUniformViewMatrix(GrGLGPBuilder* pb) { - fViewMatrixUniform = pb->addUniform(GrGLProgramBuilder::kVertex_Visibility, - kMat33f_GrSLType, kDefault_GrSLPrecision, - "uViewM", - &fViewMatrixName); -} - -void GrGLPrimitiveProcessor::setUniformViewMatrix(const GrGLProgramDataManager& pdman, - const SkMatrix& viewMatrix) { - if (!fViewMatrix.cheapEqualTo(viewMatrix)) { - SkASSERT(fViewMatrixUniform.isValid()); - fViewMatrix = viewMatrix; - - GrGLfloat viewMatrix[3 * 3]; - GrGLGetMatrix<3>(viewMatrix, fViewMatrix); - pdman.setMatrix3f(fViewMatrixUniform, viewMatrix); - } -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - -void GrGLGeometryProcessor::emitCode(EmitArgs& args) { - GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); - GrGPArgs gpArgs; - this->onEmitCode(args, &gpArgs); - vsBuilder->transformToNormalizedDeviceSpace(gpArgs.fPositionVar); -} - -void GrGLGeometryProcessor::emitTransforms(GrGLGPBuilder* pb, - const GrShaderVar& posVar, - const char* localCoords, - const SkMatrix& localMatrix, - const TransformsIn& tin, - TransformsOut* tout) { - GrGLVertexBuilder* vb = pb->getVertexShaderBuilder(); - tout->push_back_n(tin.count()); - fInstalledTransforms.push_back_n(tin.count()); - for (int i = 0; i < tin.count(); i++) { - const ProcCoords& coordTransforms = tin[i]; - fInstalledTransforms[i].push_back_n(coordTransforms.count()); - for (int t = 0; t < coordTransforms.count(); t++) { - SkString strUniName("StageMatrix"); - strUniName.appendf("_%i_%i", i, t); - GrSLType varyingType; - - GrCoordSet coordType = coordTransforms[t]->sourceCoords(); - uint32_t type = coordTransforms[t]->getMatrix().getType(); - if (kLocal_GrCoordSet == coordType) { - type |= localMatrix.getType(); - } - varyingType = SkToBool(SkMatrix::kPerspective_Mask & type) ? kVec3f_GrSLType : - kVec2f_GrSLType; - GrSLPrecision precision = coordTransforms[t]->precision(); - - const char* uniName; - fInstalledTransforms[i][t].fHandle = - pb->addUniform(GrGLProgramBuilder::kVertex_Visibility, - kMat33f_GrSLType, precision, - strUniName.c_str(), - &uniName).toShaderBuilderIndex(); - - SkString strVaryingName("MatrixCoord"); - strVaryingName.appendf("_%i_%i", i, t); - - GrGLVertToFrag v(varyingType); - pb->addVarying(strVaryingName.c_str(), &v, precision); - - SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType); - SkNEW_APPEND_TO_TARRAY(&(*tout)[i], GrGLProcessor::TransformedCoords, - (SkString(v.fsIn()), varyingType)); - - // varying = matrix * coords (logically) - if (kDevice_GrCoordSet == coordType) { - if (kVec2f_GrSLType == varyingType) { - if (kVec2f_GrSLType == posVar.getType()) { - vb->codeAppendf("%s = (%s * vec3(%s, 1)).xy;", - v.vsOut(), uniName, posVar.c_str()); - } else { - // The brackets here are just to scope the temp variable - vb->codeAppendf("{ vec3 temp = %s * %s;", uniName, posVar.c_str()); - vb->codeAppendf("%s = vec2(temp.x/temp.z, temp.y/temp.z); }", v.vsOut()); - } - } else { - if (kVec2f_GrSLType == posVar.getType()) { - vb->codeAppendf("%s = %s * vec3(%s, 1);", - v.vsOut(), uniName, posVar.c_str()); - } else { - vb->codeAppendf("%s = %s * %s;", v.vsOut(), uniName, posVar.c_str()); - } - } - } else { - if (kVec2f_GrSLType == varyingType) { - vb->codeAppendf("%s = (%s * vec3(%s, 1)).xy;", v.vsOut(), uniName, localCoords); - } else { - vb->codeAppendf("%s = %s * vec3(%s, 1);", v.vsOut(), uniName, localCoords); - } - } - } - } -} - - -void -GrGLGeometryProcessor::setTransformData(const GrPrimitiveProcessor& primProc, - const GrGLProgramDataManager& pdman, - int index, - const SkTArray<const GrCoordTransform*, true>& transforms) { - SkSTArray<2, Transform, true>& procTransforms = fInstalledTransforms[index]; - int numTransforms = transforms.count(); - for (int t = 0; t < numTransforms; ++t) { - SkASSERT(procTransforms[t].fHandle.isValid()); - const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(), *transforms[t]); - if (!procTransforms[t].fCurrentValue.cheapEqualTo(transform)) { - pdman.setSkMatrix(procTransforms[t].fHandle.convertToUniformHandle(), transform); - procTransforms[t].fCurrentValue = transform; - } - } -} - -void GrGLGeometryProcessor::SetupPosition(GrGLVertexBuilder* vsBuilder, - GrGPArgs* gpArgs, - const char* posName, - const SkMatrix& mat, - const char* matName) { - if (mat.isIdentity()) { - gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2"); - - vsBuilder->codeAppendf("vec2 %s = %s;", gpArgs->fPositionVar.c_str(), posName); - } else if (!mat.hasPerspective()) { - gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2"); - - vsBuilder->codeAppendf("vec2 %s = vec2(%s * vec3(%s, 1));", - gpArgs->fPositionVar.c_str(), matName, posName); - } else { - gpArgs->fPositionVar.set(kVec3f_GrSLType, "pos3"); - - vsBuilder->codeAppendf("vec3 %s = %s * vec3(%s, 1);", - gpArgs->fPositionVar.c_str(), matName, posName); - } -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -#include "gl/GrGLGpu.h" -#include "gl/GrGLPathRendering.h" - -struct PathBatchTracker { - GrGPInput fInputColorType; - GrGPInput fInputCoverageType; - GrColor fColor; - bool fUsesLocalCoords; -}; - -GrGLPathProcessor::GrGLPathProcessor(const GrPathProcessor&, const GrBatchTracker&) - : fColor(GrColor_ILLEGAL) {} - -void GrGLPathProcessor::emitCode(EmitArgs& args) { - GrGLGPBuilder* pb = args.fPB; - GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder(); - const PathBatchTracker& local = args.fBT.cast<PathBatchTracker>(); - - // emit transforms - this->emitTransforms(args.fPB, args.fTransformsIn, args.fTransformsOut); - - // Setup uniform color - if (kUniform_GrGPInput == local.fInputColorType) { - const char* stagedLocalVarName; - fColorUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility, - kVec4f_GrSLType, - kDefault_GrSLPrecision, - "Color", - &stagedLocalVarName); - fs->codeAppendf("%s = %s;", args.fOutputColor, stagedLocalVarName); - } - - // setup constant solid coverage - if (kAllOnes_GrGPInput == local.fInputCoverageType) { - fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage); - } -} - -void GrGLPathProcessor::GenKey(const GrPathProcessor&, - const GrBatchTracker& bt, - const GrGLCaps&, - GrProcessorKeyBuilder* b) { - const PathBatchTracker& local = bt.cast<PathBatchTracker>(); - b->add32(local.fInputColorType | local.fInputCoverageType << 16); -} - -void GrGLPathProcessor::setData(const GrGLProgramDataManager& pdman, - const GrPrimitiveProcessor& primProc, - const GrBatchTracker& bt) { - const PathBatchTracker& local = bt.cast<PathBatchTracker>(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { - GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); - pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; - } -} - -class GrGLLegacyPathProcessor : public GrGLPathProcessor { -public: - GrGLLegacyPathProcessor(const GrPathProcessor& pathProc, const GrBatchTracker& bt, - int maxTexCoords) - : INHERITED(pathProc, bt) - , fTexCoordSetCnt(0) { - SkDEBUGCODE(fMaxTexCoords = maxTexCoords;) - } - - int addTexCoordSets(int count) { - int firstFreeCoordSet = fTexCoordSetCnt; - fTexCoordSetCnt += count; - SkASSERT(fMaxTexCoords >= fTexCoordSetCnt); - return firstFreeCoordSet; - } - - void emitTransforms(GrGLGPBuilder*, const TransformsIn& tin, TransformsOut* tout) SK_OVERRIDE { - tout->push_back_n(tin.count()); - fInstalledTransforms.push_back_n(tin.count()); - for (int i = 0; i < tin.count(); i++) { - const ProcCoords& coordTransforms = tin[i]; - int texCoordIndex = this->addTexCoordSets(coordTransforms.count()); - - // Use the first uniform location as the texcoord index. - fInstalledTransforms[i].push_back_n(1); - fInstalledTransforms[i][0].fHandle = ShaderVarHandle(texCoordIndex); - - SkString name; - for (int t = 0; t < coordTransforms.count(); ++t) { - GrSLType type = coordTransforms[t]->getMatrix().hasPerspective() ? kVec3f_GrSLType : - kVec2f_GrSLType; - - name.printf("%s(gl_TexCoord[%i])", GrGLSLTypeString(type), texCoordIndex++); - SkNEW_APPEND_TO_TARRAY(&(*tout)[i], GrGLProcessor::TransformedCoords, (name, type)); - } - } - } - - void setTransformData(const GrPrimitiveProcessor& primProc, - int index, - const SkTArray<const GrCoordTransform*, true>& transforms, - GrGLPathRendering* glpr, - GrGLuint) SK_OVERRIDE { - // We've hidden the texcoord index in the first entry of the transforms array for each - // effect - int texCoordIndex = fInstalledTransforms[index][0].fHandle.handle(); - for (int t = 0; t < transforms.count(); ++t) { - const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(), *transforms[t]); - GrGLPathRendering::PathTexGenComponents components = - GrGLPathRendering::kST_PathTexGenComponents; - if (transform.hasPerspective()) { - components = GrGLPathRendering::kSTR_PathTexGenComponents; - } - glpr->enablePathTexGen(texCoordIndex++, components, transform); - } - } - - void didSetData(GrGLPathRendering* glpr) SK_OVERRIDE { - glpr->flushPathTexGenSettings(fTexCoordSetCnt); - } - -private: - SkDEBUGCODE(int fMaxTexCoords;) - int fTexCoordSetCnt; - - typedef GrGLPathProcessor INHERITED; -}; - -class GrGLNormalPathProcessor : public GrGLPathProcessor { -public: - GrGLNormalPathProcessor(const GrPathProcessor& pathProc, const GrBatchTracker& bt) - : INHERITED(pathProc, bt) {} - - void emitTransforms(GrGLGPBuilder* pb, const TransformsIn& tin, - TransformsOut* tout) SK_OVERRIDE { - tout->push_back_n(tin.count()); - fInstalledTransforms.push_back_n(tin.count()); - for (int i = 0; i < tin.count(); i++) { - const ProcCoords& coordTransforms = tin[i]; - fInstalledTransforms[i].push_back_n(coordTransforms.count()); - for (int t = 0; t < coordTransforms.count(); t++) { - GrSLType varyingType = - coordTransforms[t]->getMatrix().hasPerspective() ? kVec3f_GrSLType : - kVec2f_GrSLType; - - - SkString strVaryingName("MatrixCoord"); - strVaryingName.appendf("_%i_%i", i, t); - GrGLVertToFrag v(varyingType); - pb->addVarying(strVaryingName.c_str(), &v); - SeparableVaryingInfo& varyingInfo = fSeparableVaryingInfos.push_back(); - varyingInfo.fVariable = pb->getFragmentShaderBuilder()->fInputs.back(); - varyingInfo.fLocation = fSeparableVaryingInfos.count() - 1; - varyingInfo.fType = varyingType; - fInstalledTransforms[i][t].fHandle = ShaderVarHandle(varyingInfo.fLocation); - fInstalledTransforms[i][t].fType = varyingType; - - SkNEW_APPEND_TO_TARRAY(&(*tout)[i], GrGLProcessor::TransformedCoords, - (SkString(v.fsIn()), varyingType)); - } - } - } - - void resolveSeparableVaryings(GrGLGpu* gpu, GrGLuint programId) { - int count = fSeparableVaryingInfos.count(); - for (int i = 0; i < count; ++i) { - GrGLint location; - GR_GL_CALL_RET(gpu->glInterface(), - location, - GetProgramResourceLocation(programId, - GR_GL_FRAGMENT_INPUT, - fSeparableVaryingInfos[i].fVariable.c_str())); - fSeparableVaryingInfos[i].fLocation = location; - } - } - - void setTransformData(const GrPrimitiveProcessor& primProc, - int index, - const SkTArray<const GrCoordTransform*, true>& coordTransforms, - GrGLPathRendering* glpr, - GrGLuint programID) SK_OVERRIDE { - SkSTArray<2, Transform, true>& transforms = fInstalledTransforms[index]; - int numTransforms = transforms.count(); - for (int t = 0; t < numTransforms; ++t) { - SkASSERT(transforms[t].fHandle.isValid()); - const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(), - *coordTransforms[t]); - if (transforms[t].fCurrentValue.cheapEqualTo(transform)) { - continue; - } - transforms[t].fCurrentValue = transform; - const SeparableVaryingInfo& fragmentInput = - fSeparableVaryingInfos[transforms[t].fHandle.handle()]; - SkASSERT(transforms[t].fType == kVec2f_GrSLType || - transforms[t].fType == kVec3f_GrSLType); - unsigned components = transforms[t].fType == kVec2f_GrSLType ? 2 : 3; - glpr->setProgramPathFragmentInputTransform(programID, - fragmentInput.fLocation, - GR_GL_OBJECT_LINEAR, - components, - transform); - } - } - -private: - struct SeparableVaryingInfo { - GrSLType fType; - GrGLShaderVar fVariable; - GrGLint fLocation; - }; - - - typedef SkSTArray<8, SeparableVaryingInfo, true> SeparableVaryingInfoArray; - - SeparableVaryingInfoArray fSeparableVaryingInfos; - - typedef GrGLPathProcessor INHERITED; -}; - -GrPathProcessor::GrPathProcessor(GrColor color, - const SkMatrix& viewMatrix, - const SkMatrix& localMatrix) - : INHERITED(viewMatrix, localMatrix, true) - , fColor(color) { - this->initClassID<GrPathProcessor>(); -} - -void GrPathProcessor::getInvariantOutputColor(GrInitInvariantOutput* out) const { - out->setKnownFourComponents(fColor); -} - -void GrPathProcessor::getInvariantOutputCoverage(GrInitInvariantOutput* out) const { - out->setKnownSingleComponent(0xff); -} - -void GrPathProcessor::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const { - PathBatchTracker* local = bt->cast<PathBatchTracker>(); - if (init.fColorIgnored) { - local->fInputColorType = kIgnored_GrGPInput; - local->fColor = GrColor_ILLEGAL; - } else { - local->fInputColorType = kUniform_GrGPInput; - local->fColor = GrColor_ILLEGAL == init.fOverrideColor ? this->color() : - init.fOverrideColor; - } - - local->fInputCoverageType = init.fCoverageIgnored ? kIgnored_GrGPInput : kAllOnes_GrGPInput; - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - -bool GrPathProcessor::canMakeEqual(const GrBatchTracker& m, - const GrPrimitiveProcessor& that, - const GrBatchTracker& t) const { - if (this->classID() != that.classID() || !this->hasSameTextureAccesses(that)) { - return false; - } - - if (!this->viewMatrix().cheapEqualTo(that.viewMatrix())) { - return false; - } - - const PathBatchTracker& mine = m.cast<PathBatchTracker>(); - const PathBatchTracker& theirs = t.cast<PathBatchTracker>(); - return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords, - that, theirs.fUsesLocalCoords) && - CanCombineOutput(mine.fInputColorType, mine.fColor, - theirs.fInputColorType, theirs.fColor) && - CanCombineOutput(mine.fInputCoverageType, 0xff, - theirs.fInputCoverageType, 0xff); -} - -void GrPathProcessor::getGLProcessorKey(const GrBatchTracker& bt, - const GrGLCaps& caps, - GrProcessorKeyBuilder* b) const { - GrGLPathProcessor::GenKey(*this, bt, caps, b); -} - -GrGLPrimitiveProcessor* GrPathProcessor::createGLInstance(const GrBatchTracker& bt, - const GrGLCaps& caps) const { - SkASSERT(caps.nvprSupport() != GrGLCaps::kNone_NvprSupport); - if (caps.nvprSupport() == GrGLCaps::kLegacy_NvprSupport) { - return SkNEW_ARGS(GrGLLegacyPathProcessor, (*this, bt, - caps.maxFixedFunctionTextureCoords())); - } else { - return SkNEW_ARGS(GrGLNormalPathProcessor, (*this, bt)); - } -} |