193 lines
6.0 KiB
C++
193 lines
6.0 KiB
C++
/*
|
|
* Copyright (C) 2011 Google Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <limits>
|
|
#include <type_traits>
|
|
#include <wtf/Forward.h>
|
|
#include <wtf/Vector.h>
|
|
|
|
// GCGL types match the corresponding GL types as defined in OpenGL ES 2.0
|
|
// header file gl2.h from khronos.org.
|
|
typedef unsigned GCGLenum;
|
|
typedef unsigned char GCGLboolean;
|
|
typedef unsigned GCGLbitfield;
|
|
typedef signed char GCGLbyte;
|
|
typedef unsigned char GCGLubyte;
|
|
typedef short GCGLshort;
|
|
typedef unsigned short GCGLushort;
|
|
typedef int GCGLint;
|
|
typedef int GCGLsizei;
|
|
typedef unsigned GCGLuint;
|
|
typedef float GCGLfloat;
|
|
typedef unsigned short GCGLhalffloat;
|
|
typedef float GCGLclampf;
|
|
typedef char GCGLchar;
|
|
typedef struct __GLsync* GCGLsync;
|
|
typedef void GCGLvoid;
|
|
|
|
// These GCGL types do not strictly match the GL types as defined in OpenGL ES 2.0
|
|
// header file for all platforms.
|
|
typedef intptr_t GCGLintptr;
|
|
typedef intptr_t GCGLsizeiptr;
|
|
typedef intptr_t GCGLvoidptr;
|
|
typedef int64_t GCGLint64;
|
|
typedef uint64_t GCGLuint64;
|
|
|
|
typedef GCGLuint PlatformGLObject;
|
|
|
|
#if !PLATFORM(COCOA)
|
|
typedef unsigned GLuint;
|
|
#endif
|
|
|
|
inline constexpr size_t gcGLSpanDynamicExtent = std::numeric_limits<size_t>::max();
|
|
|
|
template<typename T, size_t Extent = gcGLSpanDynamicExtent>
|
|
struct GCGLSpan;
|
|
template<typename T, size_t Extent>
|
|
struct GCGLSpan {
|
|
explicit GCGLSpan(T* array, size_t size = Extent)
|
|
: data(array)
|
|
{
|
|
ASSERT_UNUSED(size, size == Extent);
|
|
}
|
|
GCGLSpan(T (&array)[Extent])
|
|
: data(array)
|
|
{ }
|
|
template<typename U>
|
|
GCGLSpan(const GCGLSpan<U, Extent>& other, std::enable_if_t<std::is_convertible_v<U(*)[], T(*)[]>, std::nullptr_t> = nullptr)
|
|
: data(other.data)
|
|
{ }
|
|
GCGLSpan(std::array<T, Extent>& array)
|
|
: data(array.data())
|
|
{ }
|
|
GCGLSpan(const std::array<T, Extent>& array)
|
|
: data(array.data())
|
|
{ }
|
|
T& operator[](size_t i) { RELEASE_ASSERT(data && i < bufSize); return data[i]; }
|
|
T& operator*() { RELEASE_ASSERT(data && bufSize); return *data; }
|
|
T* data;
|
|
constexpr static size_t bufSize = Extent;
|
|
};
|
|
|
|
template<typename T>
|
|
struct GCGLSpan<T, gcGLSpanDynamicExtent> {
|
|
GCGLSpan(T* array, size_t bufSize_)
|
|
: data(array)
|
|
, bufSize(bufSize_)
|
|
{ }
|
|
template<size_t Sz>
|
|
GCGLSpan(T (&array)[Sz])
|
|
: data(array)
|
|
, bufSize(Sz)
|
|
{ }
|
|
template<typename U, size_t UExtent>
|
|
GCGLSpan(const GCGLSpan<U, UExtent>& other, std::enable_if_t<std::is_convertible_v<U(*)[], T(*)[]>, std::nullptr_t> = nullptr)
|
|
: data(other.data)
|
|
, bufSize(other.bufSize)
|
|
{ }
|
|
template<typename U, size_t inlineCapacity>
|
|
GCGLSpan(WTF::Vector<U, inlineCapacity>& array, std::enable_if_t<std::is_convertible_v<U(*)[], T(*)[]>, std::nullptr_t> = nullptr)
|
|
: data(array.data())
|
|
, bufSize(array.size())
|
|
{ }
|
|
T& operator[](size_t i) { RELEASE_ASSERT(data && i < bufSize); return data[i]; }
|
|
T& operator*() { RELEASE_ASSERT(data && bufSize); return *data; }
|
|
T* data;
|
|
const size_t bufSize;
|
|
};
|
|
|
|
template<>
|
|
struct GCGLSpan<GCGLvoid> {
|
|
GCGLSpan(GCGLvoid* array, size_t bufSize_)
|
|
: data(array)
|
|
, bufSize(bufSize_)
|
|
{ }
|
|
template<typename U, size_t Sz>
|
|
GCGLSpan(U (&array)[Sz])
|
|
: data(array)
|
|
, bufSize(Sz * sizeof(U))
|
|
{ }
|
|
template<typename U, size_t UExtent>
|
|
GCGLSpan(const GCGLSpan<U, UExtent>& other)
|
|
: data(other.data)
|
|
, bufSize(other.bufSize * sizeof(U))
|
|
{ }
|
|
template<typename U, size_t inlineCapacity>
|
|
GCGLSpan(WTF::Vector<U, inlineCapacity>& array)
|
|
: data(array.data())
|
|
, bufSize(array.size() * sizeof(U))
|
|
{ }
|
|
GCGLvoid* data;
|
|
const size_t bufSize;
|
|
};
|
|
|
|
template<>
|
|
struct GCGLSpan<const GCGLvoid> {
|
|
GCGLSpan(const GCGLvoid* array, size_t bufSize_)
|
|
: data(array)
|
|
, bufSize(bufSize_)
|
|
{ }
|
|
template<typename U, size_t Sz>
|
|
GCGLSpan(U (&array)[Sz])
|
|
: data(array)
|
|
, bufSize(Sz * sizeof(U))
|
|
{ }
|
|
GCGLSpan(const GCGLSpan<GCGLvoid>& other)
|
|
: data(other.data)
|
|
, bufSize(other.bufSize)
|
|
{ }
|
|
template<typename U, size_t UExtent>
|
|
GCGLSpan(const GCGLSpan<U, UExtent>& other)
|
|
: data(other.data)
|
|
, bufSize(other.bufSize * sizeof(U))
|
|
{ }
|
|
const GCGLvoid* data;
|
|
const size_t bufSize;
|
|
};
|
|
|
|
template<typename T, size_t N>
|
|
GCGLSpan(T (&)[N]) -> GCGLSpan<T, N>;
|
|
|
|
template<typename T, size_t N>
|
|
GCGLSpan(std::array<T, N>&) -> GCGLSpan<T, N>;
|
|
|
|
template<typename T, size_t inlineCapacity>
|
|
GCGLSpan(WTF::Vector<T, inlineCapacity>&) -> GCGLSpan<T>;
|
|
|
|
template<typename T>
|
|
GCGLSpan<T> makeGCGLSpan(T* data, size_t count)
|
|
{
|
|
return GCGLSpan<T> { data, count };
|
|
}
|
|
|
|
template<size_t Extent, typename T>
|
|
GCGLSpan<T, Extent> makeGCGLSpan(T* data)
|
|
{
|
|
return GCGLSpan<T, Extent> { data };
|
|
}
|