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 "SkPatchGrid.h"
9 #include "SkPatchUtils.h"
10 
SkPatchGrid(int rows,int cols,VertexType flags,SkXfermode * xfer)11 SkPatchGrid::SkPatchGrid(int rows, int cols, VertexType flags, SkXfermode* xfer)
12     : fRows(0)
13     , fCols(0)
14     , fModeFlags(kNone_VertexType)
15     , fCornerPts(NULL)
16     , fCornerColors(NULL)
17     , fTexCoords(NULL)
18     , fHrzCtrlPts(NULL)
19     , fVrtCtrlPts(NULL)
20     , fXferMode(NULL) {
21         this->reset(rows, cols, flags, xfer);
22 }
23 
~SkPatchGrid()24 SkPatchGrid::~SkPatchGrid() {
25     SkDELETE_ARRAY(fCornerPts);
26     SkDELETE_ARRAY(fCornerColors);
27     SkDELETE_ARRAY(fTexCoords);
28     SkDELETE_ARRAY(fHrzCtrlPts);
29     SkDELETE_ARRAY(fVrtCtrlPts);
30 }
31 
setPatch(int x,int y,const SkPoint cubics[12],const SkColor colors[4],const SkPoint texCoords[4])32 bool SkPatchGrid::setPatch(int x, int y, const SkPoint cubics[12], const SkColor colors[4],
33                            const SkPoint texCoords[4]) {
34     // Check for the passed paramaters to be within the range of the grid dimensions and a valid
35     // pointer for the cubics' control points.
36     if (x < 0 || y < 0 || x > fCols - 1 || y > fRows - 1 || NULL == cubics) {
37         return false;
38     }
39 
40     // setup corners and colors
41     int cornerPos = y * (fCols + 1) + x;
42     fCornerPts[cornerPos] = cubics[SkPatchUtils::kTopP0_CubicCtrlPts];
43     fCornerPts[cornerPos + 1] = cubics[SkPatchUtils::kTopP3_CubicCtrlPts];
44     fCornerPts[cornerPos + (fCols + 1)] = cubics[SkPatchUtils::kBottomP0_CubicCtrlPts];
45     fCornerPts[cornerPos + (fCols + 1) + 1] = cubics[SkPatchUtils::kBottomP3_CubicCtrlPts];
46 
47     // set horizontal control points
48     int hrzPos = y * (fCols * 2) + (x * 2);
49     fHrzCtrlPts[hrzPos] = cubics[SkPatchUtils::kTopP1_CubicCtrlPts];
50     fHrzCtrlPts[hrzPos + 1] = cubics[SkPatchUtils::kTopP2_CubicCtrlPts];
51     fHrzCtrlPts[hrzPos + (fCols * 2)] = cubics[SkPatchUtils::kBottomP1_CubicCtrlPts];
52     fHrzCtrlPts[hrzPos + (fCols * 2) + 1] = cubics[SkPatchUtils::kBottomP2_CubicCtrlPts];
53 
54     // set vertical control points
55     int vrtPos = (y*2) * (fCols + 1) + x;
56     fVrtCtrlPts[vrtPos] = cubics[SkPatchUtils::kLeftP1_CubicCtrlPts];
57     fVrtCtrlPts[vrtPos + 1] = cubics[SkPatchUtils::kRightP1_CubicCtrlPts];
58     fVrtCtrlPts[vrtPos + (fCols + 1)] = cubics[SkPatchUtils::kLeftP2_CubicCtrlPts];
59     fVrtCtrlPts[vrtPos + (fCols + 1) + 1] = cubics[SkPatchUtils::kRightP2_CubicCtrlPts];
60 
61     // set optional values (colors and texture coordinates)
62     if ((fModeFlags & kColors_VertexType)  && colors) {
63         fCornerColors[cornerPos] = colors[0];
64         fCornerColors[cornerPos + 1] = colors[1];
65         fCornerColors[cornerPos + (fCols + 1)] = colors[3];
66         fCornerColors[cornerPos + (fCols + 1) + 1] = colors[2];
67     }
68 
69     if ((fModeFlags & kTexs_VertexType) && texCoords) {
70         fTexCoords[cornerPos] = texCoords[0];
71         fTexCoords[cornerPos + 1] = texCoords[1];
72         fTexCoords[cornerPos + (fCols + 1)] = texCoords[3];
73         fTexCoords[cornerPos + (fCols + 1) + 1] = texCoords[2];
74     }
75 
76     return true;
77 }
78 
getPatch(int x,int y,SkPoint cubics[12],SkColor colors[4],SkPoint texCoords[4]) const79 bool SkPatchGrid::getPatch(int x, int y, SkPoint cubics[12], SkColor colors[4],
80                            SkPoint texCoords[4]) const {
81 
82     if (x < 0 || y < 0 || x > fCols - 1 || y > fRows - 1 || NULL == cubics) {
83         return false;
84     }
85 
86     // set the patch by building the array of points and colors with the corresponding values.
87     int cornerPos = y * (fCols + 1) + x;
88     cubics[SkPatchUtils::kTopP0_CubicCtrlPts] = fCornerPts[cornerPos];
89     cubics[SkPatchUtils::kTopP3_CubicCtrlPts] = fCornerPts[cornerPos + 1];
90     cubics[SkPatchUtils::kBottomP0_CubicCtrlPts] = fCornerPts[cornerPos + (fCols + 1)];
91     cubics[SkPatchUtils::kBottomP3_CubicCtrlPts] = fCornerPts[cornerPos + (fCols + 1) + 1];
92 
93     int hrzPos = y * (fCols * 2) + (x * 2);
94     cubics[SkPatchUtils::kTopP1_CubicCtrlPts] = fHrzCtrlPts[hrzPos];
95     cubics[SkPatchUtils::kTopP2_CubicCtrlPts] = fHrzCtrlPts[hrzPos + 1];
96     cubics[SkPatchUtils::kBottomP1_CubicCtrlPts] = fHrzCtrlPts[hrzPos + (fCols * 2)];
97     cubics[SkPatchUtils::kBottomP2_CubicCtrlPts] = fHrzCtrlPts[hrzPos + (fCols * 2) + 1];
98 
99     int vrtPos = (y*2) * (fCols + 1) + x;
100     cubics[SkPatchUtils::kLeftP1_CubicCtrlPts] = fVrtCtrlPts[vrtPos];
101     cubics[SkPatchUtils::kRightP1_CubicCtrlPts] = fVrtCtrlPts[vrtPos + 1];
102     cubics[SkPatchUtils::kLeftP2_CubicCtrlPts] = fVrtCtrlPts[vrtPos + (fCols + 1)];
103     cubics[SkPatchUtils::kRightP2_CubicCtrlPts] = fVrtCtrlPts[vrtPos + (fCols + 1) + 1];
104 
105     if ((fModeFlags & kColors_VertexType)  && colors) {
106         colors[0] = fCornerColors[cornerPos];
107         colors[1] = fCornerColors[cornerPos + 1];
108         colors[3] = fCornerColors[cornerPos + (fCols + 1)];
109         colors[2] = fCornerColors[cornerPos + (fCols + 1) + 1];
110     }
111 
112     if ((fModeFlags & kTexs_VertexType)  && texCoords) {
113         texCoords[0] = fTexCoords[cornerPos];
114         texCoords[1] = fTexCoords[cornerPos + 1];
115         texCoords[3] = fTexCoords[cornerPos + (fCols + 1)];
116         texCoords[2] = fTexCoords[cornerPos + (fCols + 1) + 1];
117     }
118 
119     return true;
120 }
121 
reset(int rows,int cols,VertexType flags,SkXfermode * xMode)122 void SkPatchGrid::reset(int rows, int cols, VertexType flags, SkXfermode* xMode) {
123     SkDELETE_ARRAY(fCornerPts);
124     SkDELETE_ARRAY(fCornerColors);
125     SkDELETE_ARRAY(fTexCoords);
126     SkDELETE_ARRAY(fHrzCtrlPts);
127     SkDELETE_ARRAY(fVrtCtrlPts);
128 
129     fCols = cols;
130     fRows = rows;
131     fModeFlags = flags;
132     fXferMode = xMode;
133 
134     fCornerPts = SkNEW_ARRAY(SkPoint, (fRows + 1) * (fCols + 1));
135     fHrzCtrlPts = SkNEW_ARRAY(SkPoint, (fRows + 1) * fCols * 2);
136     fVrtCtrlPts = SkNEW_ARRAY(SkPoint, fRows * 2 * (fCols + 1));
137     memset(fCornerPts, 0, (fRows + 1) * (fCols + 1) * sizeof(SkPoint));
138     memset(fHrzCtrlPts, 0, (fRows + 1) * fCols * 2 * sizeof(SkPoint));
139     memset(fVrtCtrlPts, 0, fRows * 2 * (fCols + 1) * sizeof(SkPoint));
140 
141     if (fModeFlags & kColors_VertexType) {
142         fCornerColors = SkNEW_ARRAY(SkColor, (fRows + 1) * (fCols + 1));
143         memset(fCornerColors, 0, (fRows + 1) * (fCols + 1) * sizeof(SkColor));
144     }
145 
146     if (fModeFlags & kTexs_VertexType) {
147         fTexCoords = SkNEW_ARRAY(SkPoint, (fRows + 1) * (fCols + 1));
148         memset(fTexCoords, 0, (fRows + 1) * (fCols + 1) * sizeof(SkPoint));
149     }
150 }
151 
draw(SkCanvas * canvas,SkPaint & paint)152 void SkPatchGrid::draw(SkCanvas* canvas, SkPaint& paint) {
153     int* maxCols = SkNEW_ARRAY(int, fCols);
154     int* maxRows = SkNEW_ARRAY(int, fRows);
155     memset(maxCols, 0, fCols * sizeof(int));
156     memset(maxRows, 0, fRows * sizeof(int));
157 
158     // Get the maximum level of detail per axis for each row and column
159     for (int y = 0; y < fRows; y++) {
160         for (int x = 0; x < fCols; x++) {
161             SkPoint cubics[12];
162             this->getPatch(x, y, cubics, NULL, NULL);
163             SkMatrix matrix = canvas->getTotalMatrix();
164             SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, &matrix);
165             maxCols[x] = SkMax32(maxCols[x], lod.width());
166             maxRows[y] = SkMax32(maxRows[y], lod.height());
167         }
168     }
169     // Draw the patches by generating their geometry with the maximum level of detail per axis.
170     for (int x = 0; x < fCols; x++) {
171         for (int y = 0; y < fRows; y++) {
172             SkPoint cubics[12];
173             SkPoint texCoords[4];
174             SkColor colors[4];
175             this->getPatch(x, y, cubics, colors, texCoords);
176             SkPatchUtils::VertexData data;
177             if (SkPatchUtils::getVertexData(&data, cubics,
178                                             fModeFlags & kColors_VertexType ? colors : NULL,
179                                             fModeFlags & kTexs_VertexType ? texCoords : NULL,
180                                             maxCols[x], maxRows[y])) {
181                 canvas->drawVertices(SkCanvas::kTriangles_VertexMode, data.fVertexCount,
182                                      data.fPoints, data.fTexCoords, data.fColors, fXferMode,
183                                      data.fIndices, data.fIndexCount, paint);
184             }
185         }
186     }
187     SkDELETE_ARRAY(maxCols);
188     SkDELETE_ARRAY(maxRows);
189 }
190