ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 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 | */ |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 7 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 8 | #ifndef SKSL_SWIZZLE |
| 9 | #define SKSL_SWIZZLE |
| 10 | |
Hal Canary | ce78bad | 2017-05-04 14:15:40 -0400 | [diff] [blame] | 11 | #include "SkSLConstructor.h" |
Hal Canary | 6b20a55 | 2017-02-07 14:09:38 -0500 | [diff] [blame] | 12 | #include "SkSLContext.h" |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 13 | #include "SkSLExpression.h" |
Hal Canary | ce78bad | 2017-05-04 14:15:40 -0400 | [diff] [blame] | 14 | #include "SkSLIRGenerator.h" |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 15 | #include "SkSLUtil.h" |
| 16 | |
| 17 | namespace SkSL { |
| 18 | |
| 19 | /** |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 20 | * Given a type and a swizzle component count, returns the type that will result from swizzling. For |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 21 | * instance, swizzling a float3with two components will result in a float2 It is possible to swizzle |
| 22 | * with more components than the source vector, as in 'float21).xxxx'. |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 23 | */ |
ethannicholas | d598f79 | 2016-07-25 10:08:54 -0700 | [diff] [blame] | 24 | static const Type& get_type(const Context& context, Expression& value, size_t count) { |
| 25 | const Type& base = value.fType.componentType(); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 26 | if (count == 1) { |
| 27 | return base; |
| 28 | } |
ethannicholas | d598f79 | 2016-07-25 10:08:54 -0700 | [diff] [blame] | 29 | if (base == *context.fFloat_Type) { |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 30 | switch (count) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 31 | case 2: return *context.fFloat2_Type; |
| 32 | case 3: return *context.fFloat3_Type; |
| 33 | case 4: return *context.fFloat4_Type; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 34 | } |
Ethan Nicholas | f7b8820 | 2017-09-18 14:10:39 -0400 | [diff] [blame] | 35 | } else if (base == *context.fHalf_Type) { |
| 36 | switch (count) { |
| 37 | case 2: return *context.fHalf2_Type; |
| 38 | case 3: return *context.fHalf3_Type; |
| 39 | case 4: return *context.fHalf4_Type; |
| 40 | } |
ethannicholas | d598f79 | 2016-07-25 10:08:54 -0700 | [diff] [blame] | 41 | } else if (base == *context.fDouble_Type) { |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 42 | switch (count) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 43 | case 2: return *context.fDouble2_Type; |
| 44 | case 3: return *context.fDouble3_Type; |
| 45 | case 4: return *context.fDouble4_Type; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 46 | } |
ethannicholas | d598f79 | 2016-07-25 10:08:54 -0700 | [diff] [blame] | 47 | } else if (base == *context.fInt_Type) { |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 48 | switch (count) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 49 | case 2: return *context.fInt2_Type; |
| 50 | case 3: return *context.fInt3_Type; |
| 51 | case 4: return *context.fInt4_Type; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 52 | } |
Ethan Nicholas | f7b8820 | 2017-09-18 14:10:39 -0400 | [diff] [blame] | 53 | } else if (base == *context.fShort_Type) { |
| 54 | switch (count) { |
| 55 | case 2: return *context.fShort2_Type; |
| 56 | case 3: return *context.fShort3_Type; |
| 57 | case 4: return *context.fShort4_Type; |
| 58 | } |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame^] | 59 | } else if (base == *context.fByte_Type) { |
| 60 | switch (count) { |
| 61 | case 2: return *context.fByte2_Type; |
| 62 | case 3: return *context.fByte3_Type; |
| 63 | case 4: return *context.fByte4_Type; |
| 64 | } |
ethannicholas | d598f79 | 2016-07-25 10:08:54 -0700 | [diff] [blame] | 65 | } else if (base == *context.fUInt_Type) { |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 66 | switch (count) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 67 | case 2: return *context.fUInt2_Type; |
| 68 | case 3: return *context.fUInt3_Type; |
| 69 | case 4: return *context.fUInt4_Type; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 70 | } |
Ethan Nicholas | f7b8820 | 2017-09-18 14:10:39 -0400 | [diff] [blame] | 71 | } else if (base == *context.fUShort_Type) { |
| 72 | switch (count) { |
| 73 | case 2: return *context.fUShort2_Type; |
| 74 | case 3: return *context.fUShort3_Type; |
| 75 | case 4: return *context.fUShort4_Type; |
| 76 | } |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame^] | 77 | } else if (base == *context.fUByte_Type) { |
| 78 | switch (count) { |
| 79 | case 2: return *context.fUByte2_Type; |
| 80 | case 3: return *context.fUByte3_Type; |
| 81 | case 4: return *context.fUByte4_Type; |
| 82 | } |
ethannicholas | d598f79 | 2016-07-25 10:08:54 -0700 | [diff] [blame] | 83 | } else if (base == *context.fBool_Type) { |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 84 | switch (count) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 85 | case 2: return *context.fBool2_Type; |
| 86 | case 3: return *context.fBool3_Type; |
| 87 | case 4: return *context.fBool4_Type; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 88 | } |
| 89 | } |
| 90 | ABORT("cannot swizzle %s\n", value.description().c_str()); |
| 91 | } |
| 92 | |
| 93 | /** |
Ethan Nicholas | 16c1196 | 2018-03-16 12:20:54 -0400 | [diff] [blame] | 94 | * Represents a vector swizzle operation such as 'float2(1, 2, 3).zyx'. |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 95 | */ |
| 96 | struct Swizzle : public Expression { |
ethannicholas | d598f79 | 2016-07-25 10:08:54 -0700 | [diff] [blame] | 97 | Swizzle(const Context& context, std::unique_ptr<Expression> base, std::vector<int> components) |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 98 | : INHERITED(base->fOffset, kSwizzle_Kind, get_type(context, *base, components.size())) |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 99 | , fBase(std::move(base)) |
| 100 | , fComponents(std::move(components)) { |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 101 | SkASSERT(fComponents.size() >= 1 && fComponents.size() <= 4); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 102 | } |
| 103 | |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 104 | std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator, |
| 105 | const DefinitionMap& definitions) override { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 106 | if (fBase->fKind == Expression::kConstructor_Kind && fBase->isConstant()) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 107 | // we're swizzling a constant vector, e.g. float4(1).x. Simplify it. |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 108 | SkASSERT(fBase->fKind == Expression::kConstructor_Kind); |
Brian Salomon | 23f9227 | 2017-08-17 14:58:40 +0000 | [diff] [blame] | 109 | if (fType == *irGenerator.fContext.fInt_Type) { |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 110 | SkASSERT(fComponents.size() == 1); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 111 | int64_t value = ((Constructor&) *fBase).getIVecComponent(fComponents[0]); |
| 112 | return std::unique_ptr<Expression>(new IntLiteral(irGenerator.fContext, |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 113 | -1, |
| 114 | value)); |
Brian Salomon | 23f9227 | 2017-08-17 14:58:40 +0000 | [diff] [blame] | 115 | } else if (fType == *irGenerator.fContext.fFloat_Type) { |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 116 | SkASSERT(fComponents.size() == 1); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 117 | double value = ((Constructor&) *fBase).getFVecComponent(fComponents[0]); |
| 118 | return std::unique_ptr<Expression>(new FloatLiteral(irGenerator.fContext, |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 119 | -1, |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 120 | value)); |
| 121 | } |
| 122 | } |
| 123 | return nullptr; |
| 124 | } |
| 125 | |
| 126 | bool hasSideEffects() const override { |
| 127 | return fBase->hasSideEffects(); |
| 128 | } |
| 129 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 130 | String description() const override { |
| 131 | String result = fBase->description() + "."; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 132 | for (int x : fComponents) { |
| 133 | result += "xyzw"[x]; |
| 134 | } |
| 135 | return result; |
| 136 | } |
| 137 | |
Ethan Nicholas | 86a4340 | 2017-01-19 13:32:00 -0500 | [diff] [blame] | 138 | std::unique_ptr<Expression> fBase; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 139 | const std::vector<int> fComponents; |
| 140 | |
| 141 | typedef Expression INHERITED; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 142 | }; |
| 143 | |
| 144 | } // namespace |
| 145 | |
| 146 | #endif |