The Tor Browser / file comparison
comparison: gfx/angle/src/libGLESv2/renderer/vertexconversion.h
gfx/angle/src/libGLESv2/renderer/vertexconversion.h
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:bd794f3fed91 |
|---|---|
| 1 // | |
| 2 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. | |
| 3 // Use of this source code is governed by a BSD-style license that can be | |
| 4 // found in the LICENSE file. | |
| 5 // | |
| 6 | |
| 7 // vertexconversion.h: A library of vertex conversion classes that can be used to build | |
| 8 // the FormatConverter objects used by the buffer conversion system. | |
| 9 | |
| 10 #ifndef LIBGLESV2_VERTEXCONVERSION_H_ | |
| 11 #define LIBGLESV2_VERTEXCONVERSION_H_ | |
| 12 | |
| 13 namespace rx | |
| 14 { | |
| 15 | |
| 16 // Conversion types: | |
| 17 // static const bool identity: true if this is an identity transform, false otherwise | |
| 18 // static U convert(T): convert a single element from the input type to the output type | |
| 19 // typedef ... OutputType: the type produced by this conversion | |
| 20 | |
| 21 template <class T> | |
| 22 struct Identity | |
| 23 { | |
| 24 static const bool identity = true; | |
| 25 | |
| 26 typedef T OutputType; | |
| 27 | |
| 28 static T convert(T x) | |
| 29 { | |
| 30 return x; | |
| 31 } | |
| 32 }; | |
| 33 | |
| 34 template <class FromT, class ToT> | |
| 35 struct Cast | |
| 36 { | |
| 37 static const bool identity = false; | |
| 38 | |
| 39 typedef ToT OutputType; | |
| 40 | |
| 41 static ToT convert(FromT x) | |
| 42 { | |
| 43 return static_cast<ToT>(x); | |
| 44 } | |
| 45 }; | |
| 46 | |
| 47 template <class T> | |
| 48 struct Cast<T, T> | |
| 49 { | |
| 50 static const bool identity = true; | |
| 51 | |
| 52 typedef T OutputType; | |
| 53 | |
| 54 static T convert(T x) | |
| 55 { | |
| 56 return static_cast<T>(x); | |
| 57 } | |
| 58 }; | |
| 59 | |
| 60 template <class T> | |
| 61 struct Normalize | |
| 62 { | |
| 63 static const bool identity = false; | |
| 64 | |
| 65 typedef float OutputType; | |
| 66 | |
| 67 static float convert(T x) | |
| 68 { | |
| 69 typedef std::numeric_limits<T> NL; | |
| 70 float f = static_cast<float>(x); | |
| 71 | |
| 72 if (NL::is_signed) | |
| 73 { | |
| 74 // const float => VC2008 computes it at compile time | |
| 75 // static const float => VC2008 computes it the first time we get here, stores it to memory with static guard and all that. | |
| 76 const float divisor = 1.0f/(2*static_cast<float>(NL::max())+1); | |
| 77 return (2*f+1)*divisor; | |
| 78 } | |
| 79 else | |
| 80 { | |
| 81 return f/NL::max(); | |
| 82 } | |
| 83 } | |
| 84 }; | |
| 85 | |
| 86 template <class FromType, std::size_t ScaleBits> | |
| 87 struct FixedToFloat | |
| 88 { | |
| 89 static const bool identity = false; | |
| 90 | |
| 91 typedef float OutputType; | |
| 92 | |
| 93 static float convert(FromType x) | |
| 94 { | |
| 95 const float divisor = 1.0f / static_cast<float>(static_cast<FromType>(1) << ScaleBits); | |
| 96 return static_cast<float>(x) * divisor; | |
| 97 } | |
| 98 }; | |
| 99 | |
| 100 // Widen types: | |
| 101 // static const unsigned int initialWidth: number of components before conversion | |
| 102 // static const unsigned int finalWidth: number of components after conversion | |
| 103 | |
| 104 // Float is supported at any size. | |
| 105 template <std::size_t N> | |
| 106 struct NoWiden | |
| 107 { | |
| 108 static const std::size_t initialWidth = N; | |
| 109 static const std::size_t finalWidth = N; | |
| 110 }; | |
| 111 | |
| 112 // SHORT, norm-SHORT, norm-UNSIGNED_SHORT are supported but only with 2 or 4 components | |
| 113 template <std::size_t N> | |
| 114 struct WidenToEven | |
| 115 { | |
| 116 static const std::size_t initialWidth = N; | |
| 117 static const std::size_t finalWidth = N+(N&1); | |
| 118 }; | |
| 119 | |
| 120 template <std::size_t N> | |
| 121 struct WidenToFour | |
| 122 { | |
| 123 static const std::size_t initialWidth = N; | |
| 124 static const std::size_t finalWidth = 4; | |
| 125 }; | |
| 126 | |
| 127 // Most types have 0 and 1 that are just that. | |
| 128 template <class T> | |
| 129 struct SimpleDefaultValues | |
| 130 { | |
| 131 static T zero() { return static_cast<T>(0); } | |
| 132 static T one() { return static_cast<T>(1); } | |
| 133 }; | |
| 134 | |
| 135 // But normalised types only store [0,1] or [-1,1] so 1.0 is represented by the max value. | |
| 136 template <class T> | |
| 137 struct NormalizedDefaultValues | |
| 138 { | |
| 139 static T zero() { return static_cast<T>(0); } | |
| 140 static T one() { return std::numeric_limits<T>::max(); } | |
| 141 }; | |
| 142 | |
| 143 // Converter: | |
| 144 // static const bool identity: true if this is an identity transform (with no widening) | |
| 145 // static const std::size_t finalSize: number of bytes per output vertex | |
| 146 // static void convertArray(const void *in, std::size_t stride, std::size_t n, void *out): convert an array of vertices. Input may be strided, but output will be unstrided. | |
| 147 | |
| 148 template <class InT, class WidenRule, class Converter, class DefaultValueRule = SimpleDefaultValues<InT> > | |
| 149 struct VertexDataConverter | |
| 150 { | |
| 151 typedef typename Converter::OutputType OutputType; | |
| 152 typedef InT InputType; | |
| 153 | |
| 154 static const bool identity = (WidenRule::initialWidth == WidenRule::finalWidth) && Converter::identity; | |
| 155 static const std::size_t finalSize = WidenRule::finalWidth * sizeof(OutputType); | |
| 156 | |
| 157 static void convertArray(const InputType *in, std::size_t stride, std::size_t n, OutputType *out) | |
| 158 { | |
| 159 for (std::size_t i = 0; i < n; i++) | |
| 160 { | |
| 161 const InputType *ein = pointerAddBytes(in, i * stride); | |
| 162 | |
| 163 copyComponent(out, ein, 0, static_cast<OutputType>(DefaultValueRule::zero())); | |
| 164 copyComponent(out, ein, 1, static_cast<OutputType>(DefaultValueRule::zero())); | |
| 165 copyComponent(out, ein, 2, static_cast<OutputType>(DefaultValueRule::zero())); | |
| 166 copyComponent(out, ein, 3, static_cast<OutputType>(DefaultValueRule::one())); | |
| 167 | |
| 168 out += WidenRule::finalWidth; | |
| 169 } | |
| 170 } | |
| 171 | |
| 172 static void convertArray(const void *in, std::size_t stride, std::size_t n, void *out) | |
| 173 { | |
| 174 return convertArray(static_cast<const InputType*>(in), stride, n, static_cast<OutputType*>(out)); | |
| 175 } | |
| 176 | |
| 177 private: | |
| 178 // Advance the given pointer by a number of bytes (not pointed-to elements). | |
| 179 template <class T> | |
| 180 static T *pointerAddBytes(T *basePtr, std::size_t numBytes) | |
| 181 { | |
| 182 return reinterpret_cast<T *>(reinterpret_cast<uintptr_t>(basePtr) + numBytes); | |
| 183 } | |
| 184 | |
| 185 static void copyComponent(OutputType *out, const InputType *in, std::size_t elementindex, OutputType defaultvalue) | |
| 186 { | |
| 187 if (WidenRule::finalWidth > elementindex) | |
| 188 { | |
| 189 if (WidenRule::initialWidth > elementindex) | |
| 190 { | |
| 191 out[elementindex] = Converter::convert(in[elementindex]); | |
| 192 } | |
| 193 else | |
| 194 { | |
| 195 out[elementindex] = defaultvalue; | |
| 196 } | |
| 197 } | |
| 198 } | |
| 199 }; | |
| 200 | |
| 201 } | |
| 202 | |
| 203 #endif // LIBGLESV2_VERTEXCONVERSION_H_ |
