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