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#include <limits>
14#include <cstdint>
15#include <cstddef>
16
17namespace rx
18{
19
20// Conversion types:
21// static const bool identity: true if this is an identity transform, false otherwise
22// static U convert(T): convert a single element from the input type to the output type
23// typedef ... OutputType: the type produced by this conversion
24
25template <class T>
26struct Identity
27{
28    static const bool identity = true;
29
30    typedef T OutputType;
31
32    static T convert(T x)
33    {
34        return x;
35    }
36};
37
38template <class FromT, class ToT>
39struct Cast
40{
41    static const bool identity = false;
42
43    typedef ToT OutputType;
44
45    static ToT convert(FromT x)
46    {
47        return static_cast<ToT>(x);
48    }
49};
50
51template <class T>
52struct Cast<T, T>
53{
54    static const bool identity = true;
55
56    typedef T OutputType;
57
58    static T convert(T x)
59    {
60        return static_cast<T>(x);
61    }
62};
63
64template <class T>
65struct Normalize
66{
67    static const bool identity = false;
68
69    typedef float OutputType;
70
71    static float convert(T x)
72    {
73        typedef std::numeric_limits<T> NL;
74        float f = static_cast<float>(x);
75
76        if (NL::is_signed)
77        {
78            // const float => VC2008 computes it at compile time
79            // static const float => VC2008 computes it the first time we get here, stores it to memory with static guard and all that.
80            const float divisor = 1.0f/(2*static_cast<float>(NL::max())+1);
81            return (2*f+1)*divisor;
82        }
83        else
84        {
85            return f/NL::max();
86        }
87    }
88};
89
90template <class FromType, std::size_t ScaleBits>
91struct FixedToFloat
92{
93    static const bool identity = false;
94
95    typedef float OutputType;
96
97    static float convert(FromType x)
98    {
99        const float divisor = 1.0f / static_cast<float>(static_cast<FromType>(1) << ScaleBits);
100        return static_cast<float>(x) * divisor;
101    }
102};
103
104// Widen types:
105// static const unsigned int initialWidth: number of components before conversion
106// static const unsigned int finalWidth: number of components after conversion
107
108// Float is supported at any size.
109template <std::size_t N>
110struct NoWiden
111{
112    static const std::size_t initialWidth = N;
113    static const std::size_t finalWidth = N;
114};
115
116// SHORT, norm-SHORT, norm-UNSIGNED_SHORT are supported but only with 2 or 4 components
117template <std::size_t N>
118struct WidenToEven
119{
120    static const std::size_t initialWidth = N;
121    static const std::size_t finalWidth = N+(N&1);
122};
123
124template <std::size_t N>
125struct WidenToFour
126{
127    static const std::size_t initialWidth = N;
128    static const std::size_t finalWidth = 4;
129};
130
131// Most types have 0 and 1 that are just that.
132template <class T>
133struct SimpleDefaultValues
134{
135    static T zero() { return static_cast<T>(0); }
136    static T one() { return static_cast<T>(1); }
137};
138
139// But normalised types only store [0,1] or [-1,1] so 1.0 is represented by the max value.
140template <class T>
141struct NormalizedDefaultValues
142{
143    static T zero() { return static_cast<T>(0); }
144    static T one() { return std::numeric_limits<T>::max(); }
145};
146
147// Converter:
148// static const bool identity: true if this is an identity transform (with no widening)
149// static const std::size_t finalSize: number of bytes per output vertex
150// 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.
151
152template <class InT, class WidenRule, class Converter, class DefaultValueRule = SimpleDefaultValues<InT> >
153struct VertexDataConverter
154{
155    typedef typename Converter::OutputType OutputType;
156    typedef InT InputType;
157
158    static const bool identity = (WidenRule::initialWidth == WidenRule::finalWidth) && Converter::identity;
159    static const std::size_t finalSize = WidenRule::finalWidth * sizeof(OutputType);
160
161    static void convertArray(const uint8_t *input, size_t stride, size_t n, uint8_t *output)
162    {
163        OutputType *out = reinterpret_cast<OutputType*>(output);
164
165        for (std::size_t i = 0; i < n; i++)
166        {
167            const InputType *ein = reinterpret_cast<const InputType*>(input + i * stride);
168
169            copyComponent(out, ein, 0, static_cast<OutputType>(DefaultValueRule::zero()));
170            copyComponent(out, ein, 1, static_cast<OutputType>(DefaultValueRule::zero()));
171            copyComponent(out, ein, 2, static_cast<OutputType>(DefaultValueRule::zero()));
172            copyComponent(out, ein, 3, static_cast<OutputType>(DefaultValueRule::one()));
173
174            out += WidenRule::finalWidth;
175        }
176    }
177
178  private:
179    static void copyComponent(OutputType *out, const InputType *in, std::size_t elementindex, OutputType defaultvalue)
180    {
181        if (WidenRule::finalWidth > elementindex)
182        {
183            if (WidenRule::initialWidth > elementindex)
184            {
185                out[elementindex] = Converter::convert(in[elementindex]);
186            }
187            else
188            {
189                out[elementindex] = defaultvalue;
190            }
191        }
192    }
193};
194
195}
196
197#endif   // LIBGLESV2_VERTEXCONVERSION_H_
198