Separate GL path rendering state from GrGpuGL to GrGLPathRendering

src/gpu/gl/GrGLPathRendering.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLPathRendering_DEFINED
 #define GrGLPathRendering_DEFINED
 
 #include "SkRefCnt.h"
+#include "GrPathRendering.h"
+#include "GrStencil.h"
 #include "gl/GrGLFunctions.h"
+#include "gl/GrGLProgram.h"
 
 class GrGLNameAllocator;
+class GrGpuGL;
 struct GrGLInterface;
 
 /**
  * This class wraps the NV_path_rendering extension and manages its various
  * API versions. If a method is not present in the GrGLInterface (because the
  * driver version is old), it tries to provide a backup implementation. But if
  * a backup implementation is not practical, it marks the method as not
  * supported.
  */
-class GrGLPathRendering {
+class GrGLPathRendering : public GrPathRendering {
 public:
     /**
      * Create a new GrGLPathRendering object from a given GL interface. Unless
      * otherwise specified in the caps, every method will work properly, even
      * if it did not exist in the GL interface.
      */
-    static GrGLPathRendering* Create(const GrGLInterface*);
+    static GrGLPathRendering* Create(GrGpuGL* gpu, const GrGLInterface*);
     virtual ~GrGLPathRendering();
 
+    // GrPathRendering implementations.
+    virtual GrPath* createPath(const SkPath&, const SkStrokeRec&) SK_OVERRIDE;
+    virtual GrPathRange* createPathRange(size_t size, const SkStrokeRec&) SK_OVERRIDE;
+    virtual void stencilPath(const GrPath*, SkPath::FillType) SK_OVERRIDE;
+    virtual void drawPath(const GrPath*, SkPath::FillType) SK_OVERRIDE;
+    virtual void drawPaths(const GrPathRange*, const uint32_t indices[], int count,
+                           const float transforms[], PathTransformType,
+                           SkPath::FillType) SK_OVERRIDE;
+
     /**
      * Mark certain functionality as not supported if the driver version is too
      * old and a backup implementation is not practical.
      */
     struct Caps {
         bool fragmentInputGenSupport : 1;
     };
     const Caps& caps() const { return fCaps; }
 
+
+    /* Called when the 3D context state is unknown. */
+    void onResetContext();
+
     /**
      * Called when the GPU resources have been lost and need to be abandoned
      * (for example after a context loss).
      */
     void abandonGpuResources();
 
+    enum PathTexGenComponents {
+        kS_PathTexGenComponents = 1,
+        kST_PathTexGenComponents = 2,
+        kSTR_PathTexGenComponents = 3
+    };
+    void enablePathTexGen(int unitIdx, PathTexGenComponents, const GrGLfloat* coefficients);
+    void enablePathTexGen(int unitIdx, PathTexGenComponents, const SkMatrix& matrix);
+    void flushPathTexGenSettings(int numUsedTexCoordSets);
+    void setProjectionMatrix(const SkMatrix& matrix,
+                             const SkISize& renderTargetSize,
+                             GrSurfaceOrigin renderTargetOrigin);
+
+
     // NV_path_rendering
     GrGLuint genPaths(GrGLsizei range);
     GrGLvoid deletePaths(GrGLuint path, GrGLsizei range);
     GrGLvoid pathCommands(GrGLuint path, GrGLsizei numCommands, const GrGLubyte *commands,
                           GrGLsizei numCoords, GrGLenum coordType, const GrGLvoid *coords);
     GrGLvoid pathCoords(GrGLuint path, GrGLsizei numCoords,
                         GrGLenum coordType, const GrGLvoid *coords);
     GrGLvoid pathParameteri(GrGLuint path, GrGLenum pname, GrGLint value);
     GrGLvoid pathParameterf(GrGLuint path, GrGLenum pname, GrGLfloat value);
     GrGLboolean isPath(GrGLuint path);
@@ skipping 32 matching lines @@
                          GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
                          GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode,
                          GrGLenum transformType, const GrGLfloat *transformValues);
 
     // NV_path_rendering v1.3
     virtual GrGLvoid programPathFragmentInputGen(GrGLuint program, GrGLint location,
                                                  GrGLenum genMode, GrGLint components,
                                                  const GrGLfloat *coeffs);
 
 protected:
-    GrGLPathRendering(const GrGLInterface*);
+    GrGLPathRendering(GrGpuGL* gpu, const GrGLInterface*);
 
+    GrGpuGL* fGpu;
     SkAutoTUnref<const GrGLInterface> fGLInterface;

[Chris Dalton, 2014/08/14 16:22:09]

We might not need a GrGLInterface ref now that we have a pointer to the GrGpuGL.

[Kimmo Kinnunen, 2014/08/15 06:19:26]

Done.

     SkAutoTDelete<GrGLNameAllocator> fPathNameAllocator;
     Caps fCaps;
+    GrGLProgram::MatrixState fHWProjectionMatrixState;
+    GrStencilSettings fHWPathStencilSettings;
+    struct PathTexGenData {
+        GrGLenum  fMode;
+        GrGLint   fNumComponents;
+        GrGLfloat fCoefficients[3 * 3];
+    };
+    int fHWActivePathTexGenSets;
+    SkTArray<PathTexGenData, true> fHWPathTexGenSettings;
+
+private:
+    void flushPathStencilSettings(SkPath::FillType fill);
+
 };
 
 #endif