Line data    Source code

       1             : /*
       2             :  * Copyright 2014 Google Inc.
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : #include "GrGLSLGeometryProcessor.h"
       9             : 
      10             : #include "GrCoordTransform.h"
      11             : #include "glsl/GrGLSLFragmentShaderBuilder.h"
      12             : #include "glsl/GrGLSLUniformHandler.h"
      13             : #include "glsl/GrGLSLVarying.h"
      14             : #include "glsl/GrGLSLVertexShaderBuilder.h"
      15             : 
      16           0 : void GrGLSLGeometryProcessor::emitCode(EmitArgs& args) {
      17           0 :     GrGLSLVertexBuilder* vBuilder = args.fVertBuilder;
      18           0 :     GrGPArgs gpArgs;
      19           0 :     this->onEmitCode(args, &gpArgs);
      20           0 :     vBuilder->transformToNormalizedDeviceSpace(gpArgs.fPositionVar, args.fRTAdjustName);
      21           0 :     if (kVec2f_GrSLType == gpArgs.fPositionVar.getType()) {
      22           0 :         args.fVaryingHandler->setNoPerspective();
      23             :     }
      24           0 : }
      25             : 
      26           0 : void GrGLSLGeometryProcessor::emitTransforms(GrGLSLVertexBuilder* vb,
      27             :                                              GrGLSLVaryingHandler* varyingHandler,
      28             :                                              GrGLSLUniformHandler* uniformHandler,
      29             :                                              const GrShaderVar& posVar,
      30             :                                              const char* localCoords,
      31             :                                              const SkMatrix& localMatrix,
      32             :                                              FPCoordTransformHandler* handler) {
      33           0 :     int i = 0;
      34           0 :     while (const GrCoordTransform* coordTransform = handler->nextCoordTransform()) {
      35           0 :         SkString strUniName;
      36           0 :         strUniName.printf("CoordTransformMatrix_%d", i);
      37             :         GrSLType varyingType;
      38             : 
      39           0 :         uint32_t type = coordTransform->getMatrix().getType();
      40           0 :         type |= localMatrix.getType();
      41             : 
      42           0 :         varyingType = SkToBool(SkMatrix::kPerspective_Mask & type) ? kVec3f_GrSLType :
      43             :                                                                      kVec2f_GrSLType;
      44             :         // Coord transforms are always handled at high precision
      45           0 :         const GrSLPrecision precision = kHigh_GrSLPrecision;
      46             : 
      47             :         const char* uniName;
      48             : 
      49             : 
      50           0 :         fInstalledTransforms.push_back().fHandle = uniformHandler->addUniform(kVertex_GrShaderFlag,
      51             :                                                                               kMat33f_GrSLType,
      52             :                                                                               precision,
      53             :                                                                               strUniName.c_str(),
      54           0 :                                                                               &uniName).toIndex();
      55           0 :         SkString strVaryingName;
      56           0 :         strVaryingName.printf("TransformedCoords_%d", i);
      57             : 
      58           0 :         GrGLSLVertToFrag v(varyingType);
      59           0 :         varyingHandler->addVarying(strVaryingName.c_str(), &v, precision);
      60             : 
      61           0 :         SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
      62           0 :         handler->specifyCoordsForCurrCoordTransform(SkString(v.fsIn()), varyingType);
      63             : 
      64           0 :         if (kVec2f_GrSLType == varyingType) {
      65           0 :             vb->codeAppendf("%s = (%s * vec3(%s, 1)).xy;", v.vsOut(), uniName, localCoords);
      66             :         } else {
      67           0 :             vb->codeAppendf("%s = %s * vec3(%s, 1);", v.vsOut(), uniName, localCoords);
      68             :         }
      69           0 :         ++i;
      70           0 :     }
      71           0 : }
      72             : 
      73           0 : void GrGLSLGeometryProcessor::setTransformDataHelper(const SkMatrix& localMatrix,
      74             :                                                      const GrGLSLProgramDataManager& pdman,
      75             :                                                      FPCoordTransformIter* transformIter) {
      76           0 :     int i = 0;
      77           0 :     while (const GrCoordTransform* coordTransform = transformIter->next()) {
      78           0 :         const SkMatrix& m = GetTransformMatrix(localMatrix, *coordTransform);
      79           0 :         if (!fInstalledTransforms[i].fCurrentValue.cheapEqualTo(m)) {
      80           0 :             pdman.setSkMatrix(fInstalledTransforms[i].fHandle.toIndex(), m);
      81           0 :             fInstalledTransforms[i].fCurrentValue = m;
      82             :         }
      83           0 :         ++i;
      84           0 :     }
      85           0 :     SkASSERT(i == fInstalledTransforms.count());
      86           0 : }
      87             : 
      88           0 : void GrGLSLGeometryProcessor::setupPosition(GrGLSLVertexBuilder* vertBuilder,
      89             :                                             GrGPArgs* gpArgs,
      90             :                                             const char* posName) {
      91           0 :     gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2");
      92           0 :     vertBuilder->codeAppendf("vec2 %s = %s;", gpArgs->fPositionVar.c_str(), posName);
      93           0 : }
      94             : 
      95           0 : void GrGLSLGeometryProcessor::setupPosition(GrGLSLVertexBuilder* vertBuilder,
      96             :                                             GrGLSLUniformHandler* uniformHandler,
      97             :                                             GrGPArgs* gpArgs,
      98             :                                             const char* posName,
      99             :                                             const SkMatrix& mat,
     100             :                                             UniformHandle* viewMatrixUniform) {
     101           0 :     if (mat.isIdentity()) {
     102           0 :         gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2");
     103           0 :         vertBuilder->codeAppendf("vec2 %s = %s;", gpArgs->fPositionVar.c_str(), posName);
     104             :     } else {
     105             :         const char* viewMatrixName;
     106             :         *viewMatrixUniform = uniformHandler->addUniform(kVertex_GrShaderFlag,
     107             :                                                         kMat33f_GrSLType, kHigh_GrSLPrecision,
     108             :                                                         "uViewM",
     109           0 :                                                         &viewMatrixName);
     110           0 :         if (!mat.hasPerspective()) {
     111           0 :             gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2");
     112           0 :             vertBuilder->codeAppendf("vec2 %s = (%s * vec3(%s, 1)).xy;",
     113           0 :                                      gpArgs->fPositionVar.c_str(), viewMatrixName, posName);
     114             :         } else {
     115           0 :             gpArgs->fPositionVar.set(kVec3f_GrSLType, "pos3");
     116           0 :             vertBuilder->codeAppendf("vec3 %s = %s * vec3(%s, 1);",
     117           0 :                                      gpArgs->fPositionVar.c_str(), viewMatrixName, posName);
     118             :         }
     119             :     }
     120           0 : }