blob: a4c13a32168e460374469285d29fe8dbbf6f4830 [file] [log] [blame]
/*
* Copyright 2010 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrVertexWriter_DEFINED
#define GrVertexWriter_DEFINED
#include "include/private/SkTemplates.h"
#include "src/gpu/GrColor.h"
#include "src/gpu/geometry/GrQuad.h"
#include <type_traits>
/**
* Helper for writing vertex data to a buffer. Usage:
* GrVertexWriter vertices{target->makeVertexSpace(...)};
* vertices.write(A0, B0, C0, ...);
* vertices.write(A1, B1, C1, ...);
*
* Supports any number of arguments. Each argument must be POD (plain old data), or an array
* thereof.
*/
struct GrVertexWriter {
constexpr static uint32_t kIEEE_32_infinity = 0x7f800000;
void* fPtr;
GrVertexWriter() = default;
GrVertexWriter(void* ptr) : fPtr(ptr) {}
GrVertexWriter(const GrVertexWriter&) = delete;
GrVertexWriter(GrVertexWriter&& that) { *this = std::move(that); }
GrVertexWriter& operator=(const GrVertexWriter&) = delete;
GrVertexWriter& operator=(GrVertexWriter&& that) {
fPtr = that.fPtr;
that.fPtr = nullptr;
return *this;
}
bool operator==(const GrVertexWriter& that) const { return fPtr == that.fPtr; }
operator bool() const { return fPtr != nullptr; }
GrVertexWriter makeOffset(ptrdiff_t offsetInBytes) const {
return {SkTAddOffset<void>(fPtr, offsetInBytes)};
}
template <typename T>
class Conditional {
public:
explicit Conditional(bool condition, const T& value)
: fCondition(condition), fValue(value) {}
private:
friend struct GrVertexWriter;
bool fCondition;
T fValue;
};
template <typename T>
static Conditional<T> If(bool condition, const T& value) {
return Conditional<T>(condition, value);
}
template <typename T>
struct Skip {};
template <typename T, typename... Args>
void write(const T& val, const Args&... remainder) {
static_assert(std::is_pod<T>::value, "");
memcpy(fPtr, &val, sizeof(T));
fPtr = SkTAddOffset<void>(fPtr, sizeof(T));
this->write(remainder...);
}
template <typename T, size_t N, typename... Args>
void write(const T(&val)[N], const Args&... remainder) {
static_assert(std::is_pod<T>::value, "");
memcpy(fPtr, val, N * sizeof(T));
fPtr = SkTAddOffset<void>(fPtr, N * sizeof(T));
this->write(remainder...);
}
template <typename... Args>
void write(const GrVertexColor& color, const Args&... remainder) {
this->write(color.fColor[0]);
if (color.fWideColor) {
this->write(color.fColor[1]);
this->write(color.fColor[2]);
this->write(color.fColor[3]);
}
this->write(remainder...);
}
template <typename T, typename... Args>
void write(const Conditional<T>& val, const Args&... remainder) {
if (val.fCondition) {
this->write(val.fValue);
}
this->write(remainder...);
}
template <typename T, typename... Args>
void write(const Skip<T>& val, const Args&... remainder) {
fPtr = SkTAddOffset<void>(fPtr, sizeof(T));
this->write(remainder...);
}
template <typename... Args>
void write(const Sk4f& vector, const Args&... remainder) {
float buffer[4];
vector.store(buffer);
this->write<float, 4>(buffer);
this->write(remainder...);
}
template <typename T>
void writeArray(const T* array, int count) {
static_assert(std::is_pod<T>::value, "");
memcpy(fPtr, array, count * sizeof(T));
fPtr = SkTAddOffset<void>(fPtr, count * sizeof(T));
}
template <typename T>
void fill(const T& val, int repeatCount) {
for (int i = 0; i < repeatCount; ++i) {
this->write(val);
}
}
void writeRaw(const void* data, size_t size) {
memcpy(fPtr, data, size);
fPtr = SkTAddOffset<void>(fPtr, size);
}
void write() {}
/**
* Specialized utility for writing a four-vertices, with some data being replicated at each
* vertex, and other data being the appropriate 2-components from an SkRect to construct a
* triangle strip.
*
* writeQuad(A, B, C, ...) is similar to write(A, B, C, ...), except that:
*
* - Four sets of data will be written
* - For any arguments of type TriStrip, a unique SkPoint will be written at each vertex,
* in this order: left-top, left-bottom, right-top, right-bottom.
*/
template <typename T>
struct TriStrip { T l, t, r, b; };
static TriStrip<float> TriStripFromRect(const SkRect& r) {
return { r.fLeft, r.fTop, r.fRight, r.fBottom };
}
static TriStrip<uint16_t> TriStripFromUVs(const std::array<uint16_t, 4>& rect) {
return { rect[0], rect[1], rect[2], rect[3] };
}
template <typename T>
struct TriFan { T l, t, r, b; };
static TriFan<float> TriFanFromRect(const SkRect& r) {
return { r.fLeft, r.fTop, r.fRight, r.fBottom };
}
template <typename... Args>
void writeQuad(const Args&... remainder) {
this->writeQuadVert<0>(remainder...);
this->writeQuadVert<1>(remainder...);
this->writeQuadVert<2>(remainder...);
this->writeQuadVert<3>(remainder...);
}
private:
template <int corner, typename T, typename... Args>
void writeQuadVert(const T& val, const Args&... remainder) {
this->writeQuadValue<corner>(val);
this->writeQuadVert<corner>(remainder...);
}
template <int corner>
void writeQuadVert() {}
template <int corner, typename T>
void writeQuadValue(const T& val) {
this->write(val);
}
template <int corner, typename T>
void writeQuadValue(const TriStrip<T>& r) {
switch (corner) {
case 0: this->write(r.l, r.t); break;
case 1: this->write(r.l, r.b); break;
case 2: this->write(r.r, r.t); break;
case 3: this->write(r.r, r.b); break;
}
}
template <int corner, typename T>
void writeQuadValue(const TriFan<T>& r) {
switch (corner) {
case 0: this->write(r.l, r.t); break;
case 1: this->write(r.l, r.b); break;
case 2: this->write(r.r, r.b); break;
case 3: this->write(r.r, r.t); break;
}
}
template <int corner>
void writeQuadValue(const GrQuad& q) {
this->write(q.point(corner));
}
};
#endif