blob: 7b1ddc1d6b5e832a375abd296559faaa63ff8ccd [file] [log] [blame]
Brian Osmanf9aabff2018-11-13 16:11:38 -05001/*
2 * Copyright 2010 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#ifndef GrVertexWriter_DEFINED
9#define GrVertexWriter_DEFINED
10
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "include/private/SkTemplates.h"
Greg Danielf91aeb22019-06-18 09:58:02 -040012#include "src/gpu/GrColor.h"
Michael Ludwigfd4f4df2019-05-29 09:51:09 -040013#include "src/gpu/geometry/GrQuad.h"
Brian Osmanf9aabff2018-11-13 16:11:38 -050014#include <type_traits>
15
16/**
17 * Helper for writing vertex data to a buffer. Usage:
18 * GrVertexWriter vertices{target->makeVertexSpace(...)};
19 * vertices.write(A0, B0, C0, ...);
20 * vertices.write(A1, B1, C1, ...);
21 *
22 * Supports any number of arguments. Each argument must be POD (plain old data), or an array
23 * thereof.
24 */
25struct GrVertexWriter {
Brian Osman4486d982018-11-15 15:56:04 -050026 void* fPtr;
27
Brian Osmancfec9d52018-11-20 11:39:15 -050028 template <typename T>
29 class Conditional {
30 public:
31 explicit Conditional(bool condition, const T& value)
32 : fCondition(condition), fValue(value) {}
33 private:
34 friend struct GrVertexWriter;
35
36 bool fCondition;
37 T fValue;
38 };
39
40 template <typename T>
41 static Conditional<T> If(bool condition, const T& value) {
42 return Conditional<T>(condition, value);
43 }
44
Brian Osmand2fa2eb2018-12-26 16:48:40 -050045 template <typename T>
46 struct Skip {};
47
Brian Osmanf9aabff2018-11-13 16:11:38 -050048 template <typename T, typename... Args>
49 void write(const T& val, const Args&... remainder) {
50 static_assert(std::is_pod<T>::value, "");
Brian Osman0dd43022018-11-16 15:53:26 -050051 // This assert is barely related to what we're trying to check - that our vertex data
52 // matches our attribute layouts, where each attribute is aligned to four bytes. If this
53 // becomes a problem, just remove it.
54 static_assert(alignof(T) <= 4, "");
Brian Osmanf9aabff2018-11-13 16:11:38 -050055 memcpy(fPtr, &val, sizeof(T));
56 fPtr = SkTAddOffset<void>(fPtr, sizeof(T));
57 this->write(remainder...);
58 }
59
60 template <typename T, size_t N, typename... Args>
61 void write(const T(&val)[N], const Args&... remainder) {
62 static_assert(std::is_pod<T>::value, "");
Brian Osman0dd43022018-11-16 15:53:26 -050063 static_assert(alignof(T) <= 4, "");
Brian Osmanf9aabff2018-11-13 16:11:38 -050064 memcpy(fPtr, val, N * sizeof(T));
65 fPtr = SkTAddOffset<void>(fPtr, N * sizeof(T));
66 this->write(remainder...);
67 }
68
Brian Osman5c8a6b32018-11-19 11:56:57 -050069 template <typename... Args>
70 void write(const GrVertexColor& color, const Args&... remainder) {
71 this->write(color.fColor[0]);
72 if (color.fWideColor) {
73 this->write(color.fColor[1]);
74 }
75 this->write(remainder...);
76 }
77
Brian Osmancfec9d52018-11-20 11:39:15 -050078 template <typename T, typename... Args>
79 void write(const Conditional<T>& val, const Args&... remainder) {
80 if (val.fCondition) {
81 this->write(val.fValue);
82 }
83 this->write(remainder...);
84 }
85
Brian Osmand2fa2eb2018-12-26 16:48:40 -050086 template <typename T, typename... Args>
87 void write(const Skip<T>& val, const Args&... remainder) {
88 fPtr = SkTAddOffset<void>(fPtr, sizeof(T));
89 this->write(remainder...);
90 }
91
Michael Ludwigf995c052018-11-26 15:24:29 -050092 template <typename... Args>
93 void write(const Sk4f& vector, const Args&... remainder) {
94 float buffer[4];
95 vector.store(buffer);
96 this->write<float, 4>(buffer);
97 this->write(remainder...);
98 }
99
Brian Osmanf9aabff2018-11-13 16:11:38 -0500100 void write() {}
101
Brian Osman4486d982018-11-15 15:56:04 -0500102 /**
103 * Specialized utility for writing a four-vertices, with some data being replicated at each
104 * vertex, and other data being the appropriate 2-components from an SkRect to construct a
105 * triangle strip.
106 *
107 * writeQuad(A, B, C, ...) is similar to write(A, B, C, ...), except that:
108 *
109 * - Four sets of data will be written
110 * - For any arguments of type TriStrip, a unique SkPoint will be written at each vertex,
111 * in this order: left-top, left-bottom, right-top, right-bottom.
112 */
Brian Osman0dd43022018-11-16 15:53:26 -0500113 template <typename T>
114 struct TriStrip { T l, t, r, b; };
115
116 static TriStrip<float> TriStripFromRect(const SkRect& r) {
117 return { r.fLeft, r.fTop, r.fRight, r.fBottom };
118 }
Brian Osman4486d982018-11-15 15:56:04 -0500119
Brian Osmancfec9d52018-11-20 11:39:15 -0500120 template <typename T>
121 struct TriFan { T l, t, r, b; };
122
123 static TriFan<float> TriFanFromRect(const SkRect& r) {
124 return { r.fLeft, r.fTop, r.fRight, r.fBottom };
125 }
126
Brian Osman4486d982018-11-15 15:56:04 -0500127 template <typename... Args>
128 void writeQuad(const Args&... remainder) {
129 this->writeQuadVert<0>(remainder...);
130 this->writeQuadVert<1>(remainder...);
131 this->writeQuadVert<2>(remainder...);
132 this->writeQuadVert<3>(remainder...);
133 }
134
135private:
136 template <int corner, typename T, typename... Args>
137 void writeQuadVert(const T& val, const Args&... remainder) {
138 this->writeQuadValue<corner>(val);
139 this->writeQuadVert<corner>(remainder...);
140 }
141
142 template <int corner>
143 void writeQuadVert() {}
144
145 template <int corner, typename T>
146 void writeQuadValue(const T& val) {
147 this->write(val);
148 }
149
Brian Osman0dd43022018-11-16 15:53:26 -0500150 template <int corner, typename T>
151 void writeQuadValue(const TriStrip<T>& r) {
Brian Osman4486d982018-11-15 15:56:04 -0500152 switch (corner) {
Brian Osman0dd43022018-11-16 15:53:26 -0500153 case 0: this->write(r.l, r.t); break;
154 case 1: this->write(r.l, r.b); break;
155 case 2: this->write(r.r, r.t); break;
156 case 3: this->write(r.r, r.b); break;
Brian Osman4486d982018-11-15 15:56:04 -0500157 }
158 }
Brian Osman0dd43022018-11-16 15:53:26 -0500159
Brian Osmancfec9d52018-11-20 11:39:15 -0500160 template <int corner, typename T>
161 void writeQuadValue(const TriFan<T>& r) {
162 switch (corner) {
163 case 0: this->write(r.l, r.t); break;
164 case 1: this->write(r.l, r.b); break;
165 case 2: this->write(r.r, r.b); break;
166 case 3: this->write(r.r, r.t); break;
167 }
168 }
169
Brian Osman0dd43022018-11-16 15:53:26 -0500170 template <int corner>
171 void writeQuadValue(const GrQuad& q) {
172 this->write(q.point(corner));
173 }
Brian Osmanf9aabff2018-11-13 16:11:38 -0500174};
175
176#endif