1/*
2 * Copyright 2016 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 SKIASL_MEMORYLAYOUT
9#define SKIASL_MEMORYLAYOUT
10
11#include "src/sksl/ir/SkSLType.h"
12
13namespace SkSL {
14
15class MemoryLayout {
16public:
17 enum Standard {
18 k140_Standard,
19 k430_Standard,
20 kMetal_Standard
21 };
22
23 MemoryLayout(Standard std)
24 : fStd(std) {}
25
26 static size_t vector_alignment(size_t componentSize, int columns) {
27 return componentSize * (columns + columns % 2);
28 }
29
30 /**
31 * Rounds up to the nearest multiple of 16 if in std140, otherwise returns the parameter
32 * unchanged (std140 requires various things to be rounded up to the nearest multiple of 16,
33 * std430 does not).
34 */
35 size_t roundUpIfNeeded(size_t raw) const {
36 switch (fStd) {
37 case k140_Standard: return (raw + 15) & ~15;
38 case k430_Standard: return raw;
39 case kMetal_Standard: return raw;
40 }
41 ABORT("unreachable");
42 }
43
44 /**
45 * Returns a type's required alignment when used as a standalone variable.
46 */
47 size_t alignment(const Type& type) const {
48 // See OpenGL Spec 7.6.2.2 Standard Uniform Block Layout
49 switch (type.kind()) {
50 case Type::kScalar_Kind:
51 return this->size(type);
52 case Type::kVector_Kind:
53 return vector_alignment(this->size(type.componentType()), type.columns());
54 case Type::kMatrix_Kind:
55 return this->roundUpIfNeeded(vector_alignment(this->size(type.componentType()),
56 type.rows()));
57 case Type::kArray_Kind:
58 return this->roundUpIfNeeded(this->alignment(type.componentType()));
59 case Type::kStruct_Kind: {
60 size_t result = 0;
61 for (const auto& f : type.fields()) {
62 size_t alignment = this->alignment(*f.fType);
63 if (alignment > result) {
64 result = alignment;
65 }
66 }
67 return this->roundUpIfNeeded(result);
68 }
69 default:
70 ABORT("cannot determine size of type %s", type.name().c_str());
71 }
72 }
73
74 /**
75 * For matrices and arrays, returns the number of bytes from the start of one entry (row, in
76 * the case of matrices) to the start of the next.
77 */
78 size_t stride(const Type& type) const {
79 switch (type.kind()) {
80 case Type::kMatrix_Kind: {
81 size_t base = vector_alignment(this->size(type.componentType()), type.rows());
82 return this->roundUpIfNeeded(base);
83 }
84 case Type::kArray_Kind: {
85 int stride = this->size(type.componentType());
86 if (stride > 0) {
87 int align = this->alignment(type.componentType());
88 stride += align - 1;
89 stride -= stride % align;
90 stride = this->roundUpIfNeeded(stride);
91 }
92 return stride;
93 }
94 default:
95 ABORT("type does not have a stride");
96 }
97 }
98
99 /**
100 * Returns the size of a type in bytes.
101 */
102 size_t size(const Type& type) const {
103 switch (type.kind()) {
104 case Type::kScalar_Kind:
105 if (type.name() == "bool") {
106 return 1;
107 }
108 // FIXME need to take precision into account, once we figure out how we want to
109 // handle it...
110 return 4;
111 case Type::kVector_Kind:
112 if (fStd == kMetal_Standard && type.columns() == 3) {
113 return 4 * this->size(type.componentType());
114 }
115 return type.columns() * this->size(type.componentType());
116 case Type::kMatrix_Kind: // fall through
117 case Type::kArray_Kind:
118 return type.columns() * this->stride(type);
119 case Type::kStruct_Kind: {
120 size_t total = 0;
121 for (const auto& f : type.fields()) {
122 size_t alignment = this->alignment(*f.fType);
123 if (total % alignment != 0) {
124 total += alignment - total % alignment;
125 }
126 SkASSERT(total % alignment == 0);
127 total += this->size(*f.fType);
128 }
129 size_t alignment = this->alignment(type);
130 SkASSERT(!type.fields().size() ||
131 (0 == alignment % this->alignment(*type.fields()[0].fType)));
132 return (total + alignment - 1) & ~(alignment - 1);
133 }
134 default:
135 ABORT("cannot determine size of type %s", type.name().c_str());
136 }
137 }
138
139 const Standard fStd;
140};
141
142} // namespace SkSL
143
144#endif
145