Home | History | Annotate | Download | only in gl 
      1 
      2 /*
      3  * Copyright 2012 Google Inc.
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 
      9 #include "GrGLPath.h"
     10 #include "GrGLPathRendering.h"
     11 #include "GrGpuGL.h"
     12 
     13 namespace {
     14 inline GrGLubyte verb_to_gl_path_cmd(SkPath::Verb verb) {
     15     static const GrGLubyte gTable[] = {
     16         GR_GL_MOVE_TO,
     17         GR_GL_LINE_TO,
     18         GR_GL_QUADRATIC_CURVE_TO,
     19         0xFF, // conic
     20         GR_GL_CUBIC_CURVE_TO,
     21         GR_GL_CLOSE_PATH,
     22     };
     23     GR_STATIC_ASSERT(0 == SkPath::kMove_Verb);
     24     GR_STATIC_ASSERT(1 == SkPath::kLine_Verb);
     25     GR_STATIC_ASSERT(2 == SkPath::kQuad_Verb);
     26     GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
     27     GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);
     28 
     29     SkASSERT(verb >= 0 && (size_t)verb < SK_ARRAY_COUNT(gTable));
     30     return gTable[verb];
     31 }
     32 
     33 #ifdef SK_DEBUG
     34 inline int num_pts(SkPath::Verb verb) {
     35     static const int gTable[] = {
     36         1, // move
     37         1, // line
     38         2, // quad
     39         2, // conic
     40         3, // cubic
     41         0, // close
     42     };
     43     GR_STATIC_ASSERT(0 == SkPath::kMove_Verb);
     44     GR_STATIC_ASSERT(1 == SkPath::kLine_Verb);
     45     GR_STATIC_ASSERT(2 == SkPath::kQuad_Verb);
     46     GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
     47     GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);
     48 
     49     SkASSERT(verb >= 0 && (size_t)verb < SK_ARRAY_COUNT(gTable));
     50     return gTable[verb];
     51 }
     52 #endif
     53 
     54 inline GrGLenum join_to_gl_join(SkPaint::Join join) {
     55     static GrGLenum gSkJoinsToGrGLJoins[] = {
     56         GR_GL_MITER_REVERT,
     57         GR_GL_ROUND,
     58         GR_GL_BEVEL
     59     };
     60     return gSkJoinsToGrGLJoins[join];
     61     GR_STATIC_ASSERT(0 == SkPaint::kMiter_Join);
     62     GR_STATIC_ASSERT(1 == SkPaint::kRound_Join);
     63     GR_STATIC_ASSERT(2 == SkPaint::kBevel_Join);
     64     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkJoinsToGrGLJoins) == SkPaint::kJoinCount);
     65 }
     66 
     67 inline GrGLenum cap_to_gl_cap(SkPaint::Cap cap) {
     68     static GrGLenum gSkCapsToGrGLCaps[] = {
     69         GR_GL_FLAT,
     70         GR_GL_ROUND,
     71         GR_GL_SQUARE
     72     };
     73     return gSkCapsToGrGLCaps[cap];
     74     GR_STATIC_ASSERT(0 == SkPaint::kButt_Cap);
     75     GR_STATIC_ASSERT(1 == SkPaint::kRound_Cap);
     76     GR_STATIC_ASSERT(2 == SkPaint::kSquare_Cap);
     77     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkCapsToGrGLCaps) == SkPaint::kCapCount);
     78 }
     79 
     80 }
     81 
     82 static const bool kIsWrapped = false; // The constructor creates the GL path object.
     83 
     84 void GrGLPath::InitPathObject(GrGpuGL* gpu,
     85                               GrGLuint pathID,
     86                               const SkPath& skPath,
     87                               const SkStrokeRec& stroke) {
     88     if (!skPath.isEmpty()) {
     89         SkSTArray<16, GrGLubyte, true> pathCommands;
     90         SkSTArray<16, SkPoint, true> pathPoints;
     91 
     92         int verbCnt = skPath.countVerbs();
     93         int pointCnt = skPath.countPoints();
     94         pathCommands.resize_back(verbCnt);
     95         pathPoints.resize_back(pointCnt);
     96 
     97         // TODO: Direct access to path points since we could pass them on directly.
     98         skPath.getPoints(&pathPoints[0], pointCnt);
     99         skPath.getVerbs(&pathCommands[0], verbCnt);
    100 
    101         SkDEBUGCODE(int numPts = 0);
    102         for (int i = 0; i < verbCnt; ++i) {
    103             SkPath::Verb v = static_cast<SkPath::Verb>(pathCommands[i]);
    104             pathCommands[i] = verb_to_gl_path_cmd(v);
    105             SkDEBUGCODE(numPts += num_pts(v));
    106         }
    107         SkASSERT(pathPoints.count() == numPts);
    108 
    109         GR_GL_CALL(gpu->glInterface(),
    110                    PathCommands(pathID, verbCnt, &pathCommands[0],
    111                                 2 * pointCnt, GR_GL_FLOAT, &pathPoints[0]));
    112     } else {
    113         GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, 0, NULL, 0, GR_GL_FLOAT, NULL));
    114     }
    115 
    116     if (stroke.needToApply()) {
    117         SkASSERT(!stroke.isHairlineStyle());
    118         GR_GL_CALL(gpu->glInterface(),
    119             PathParameterf(pathID, GR_GL_PATH_STROKE_WIDTH, SkScalarToFloat(stroke.getWidth())));
    120         GR_GL_CALL(gpu->glInterface(),
    121             PathParameterf(pathID, GR_GL_PATH_MITER_LIMIT, SkScalarToFloat(stroke.getMiter())));
    122         GrGLenum join = join_to_gl_join(stroke.getJoin());
    123         GR_GL_CALL(gpu->glInterface(),
    124             PathParameteri(pathID, GR_GL_PATH_JOIN_STYLE, join));
    125         GrGLenum cap = cap_to_gl_cap(stroke.getCap());
    126         GR_GL_CALL(gpu->glInterface(),
    127             PathParameteri(pathID, GR_GL_PATH_INITIAL_END_CAP, cap));
    128         GR_GL_CALL(gpu->glInterface(),
    129             PathParameteri(pathID, GR_GL_PATH_TERMINAL_END_CAP, cap));
    130     }
    131 }
    132 
    133 GrGLPath::GrGLPath(GrGpuGL* gpu, const SkPath& path, const SkStrokeRec& stroke)
    134     : INHERITED(gpu, kIsWrapped, path, stroke),
    135       fPathID(gpu->glPathRendering()->genPaths(1)) {
    136 
    137     InitPathObject(gpu, fPathID, fSkPath, stroke);
    138 
    139     if (stroke.needToApply()) {
    140         // FIXME: try to account for stroking, without rasterizing the stroke.
    141         fBounds.outset(stroke.getWidth(), stroke.getWidth());
    142     }
    143     this->registerWithCache();
    144 }
    145 
    146 GrGLPath::~GrGLPath() {
    147     this->release();
    148 }
    149 
    150 void GrGLPath::onRelease() {
    151     if (0 != fPathID && !this->isWrapped()) {
    152         static_cast<GrGpuGL*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
    153         fPathID = 0;
    154     }
    155 
    156     INHERITED::onRelease();
    157 }
    158 
    159 void GrGLPath::onAbandon() {
    160     fPathID = 0;
    161 
    162     INHERITED::onAbandon();
    163 }
    164