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