diff options
Diffstat (limited to 'src/render/backends/gl/Qt3DSOpenGLUtil.h')
| -rw-r--r-- | src/render/backends/gl/Qt3DSOpenGLUtil.h | 2201 |
1 files changed, 2201 insertions, 0 deletions
diff --git a/src/render/backends/gl/Qt3DSOpenGLUtil.h b/src/render/backends/gl/Qt3DSOpenGLUtil.h new file mode 100644 index 0000000..32f7dad --- /dev/null +++ b/src/render/backends/gl/Qt3DSOpenGLUtil.h @@ -0,0 +1,2201 @@ +/**************************************************************************** +** +** Copyright (C) 2008-2012 NVIDIA Corporation. +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt 3D Studio. +** +** $QT_BEGIN_LICENSE:GPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 or (at your option) any later version +** approved by the KDE Free Qt Foundation. The licenses are as published by +** the Free Software Foundation and appearing in the file LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QT3DSOPENGLUTIL_H +#define QT3DSOPENGLUTIL_H + +#include "render/backends/gl/Qt3DSOpenGLPrefix.h" +#include "render/backends/gl/Qt3DSOpenGLTokens.h" +#include <QtGui/QOpenGLContext> +#include <QtGui/QOpenGLExtraFunctions> + +#include "foundation/Qt3DSVec2.h" +#include "foundation/Qt3DSVec3.h" +#include "foundation/Qt3DSVec4.h" +#include "foundation/Qt3DSFoundation.h" + +// The actual binding to the hardware the does some minor conversions between gles and +// the nv render enumeration types +namespace qt3ds { +namespace render { + +#ifndef GL_TEXTURE_2D_MULTISAMPLE +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#endif + +#ifndef GL_IMAGE_2D +#define GL_IMAGE_2D 0x904D +#endif + +#ifndef GL_MULTISAMPLE_EXT +#define GL_MULTISAMPLE_EXT 0x809D +#endif + +#ifndef GL_COLOR_ATTACHMENT1 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#endif + +#ifndef GL_RED +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#endif + +#ifndef GL_PATCHES +#define GL_PATCHES 0x000E +#endif + +#ifndef GL_READ_ONLY +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#endif + +#ifndef GL_SHADER_STORAGE_BUFFER +#define GL_SHADER_STORAGE_BUFFER 0x90D2 +#endif + +#ifndef GL_ATOMIC_COUNTER_BUFFER +#define GL_ATOMIC_COUNTER_BUFFER 0x92C0 +#endif + +#ifndef GL_DRAW_INDIRECT_BUFFER +#define GL_DRAW_INDIRECT_BUFFER 0x8F3F +#endif + +#ifndef GL_VERTEX_SHADER_BIT +#define GL_VERTEX_SHADER_BIT 0x00000001 +#endif + +#ifndef GL_FRAGMENT_SHADER_BIT +#define GL_FRAGMENT_SHADER_BIT 0x00000002 +#endif + +#ifndef GL_GEOMETRY_SHADER_BIT +#define GL_GEOMETRY_SHADER_BIT 0x00000004 +#endif + +#ifndef GL_TESS_CONTROL_SHADER_BIT +#define GL_TESS_CONTROL_SHADER_BIT 0x00000008 +#endif + +#ifndef GL_TESS_EVALUATION_SHADER_BIT +#define GL_TESS_EVALUATION_SHADER_BIT 0x00000010 +#endif + +#ifndef GL_ETC1_RGB8_OES +#define GL_ETC1_RGB8_OES 0x8D64 +#endif + +#ifndef GL_COMPRESSED_RED_RGTC1 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#endif + +#ifndef GL_COMPRESSED_SIGNED_RED_RGTC1 +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#endif + +#ifndef GL_COMPRESSED_RG_RGTC2 +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#endif + +#ifndef GL_COMPRESSED_SIGNED_RG_RGTC2 +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#endif + +#ifndef GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB +#define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB 0x8E8F +#endif + +#ifndef GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB +#define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB 0x8E8E +#endif + +#ifndef GL_COMPRESSED_RGBA_BPTC_UNORM_ARB +#define GL_COMPRESSED_RGBA_BPTC_UNORM_ARB 0x8E8C +#endif + +#ifndef GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB +#define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB 0x8E8D +#endif + +#ifndef GL_COMPRESSED_RGB8_ETC2 +#define GL_COMPRESSED_RGB8_ETC2 0x9274 +#endif + +#ifndef GL_COMPRESSED_SRGB8_ETC2 +#define GL_COMPRESSED_SRGB8_ETC2 0x9275 +#endif + +#ifndef GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 +#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276 +#endif + +#ifndef GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 +#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277 +#endif + +#ifndef GL_COMPRESSED_RGBA8_ETC2_EAC +#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 +#endif + +#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC +#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279 +#endif + +#ifndef GL_COMPRESSED_R11_EAC +#define GL_COMPRESSED_R11_EAC 0x9270 +#endif + +#ifndef GL_COMPRESSED_SIGNED_R11_EAC +#define GL_COMPRESSED_SIGNED_R11_EAC 0x9271 +#endif + +#ifndef GL_COMPRESSED_RG11_EAC +#define GL_COMPRESSED_RG11_EAC 0x9272 +#endif + +#ifndef GL_COMPRESSED_SIGNED_RG11_EAC +#define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273 +#endif + +#define QT3DS_RENDER_ITERATE_QT3DS_GL_COLOR_FUNC \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_ZERO, Zero) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_ONE, One) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_SRC_COLOR, SrcColor) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_ONE_MINUS_SRC_COLOR, OneMinusSrcColor) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_DST_COLOR, DstColor) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_ONE_MINUS_DST_COLOR, OneMinusDstColor) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_SRC_ALPHA, SrcAlpha) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_ONE_MINUS_SRC_ALPHA, OneMinusSrcAlpha) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_DST_ALPHA, DstAlpha) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_ONE_MINUS_DST_ALPHA, OneMinusDstAlpha) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_CONSTANT_COLOR, ConstantColor) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_ONE_MINUS_CONSTANT_COLOR, OneMinusConstantColor) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_CONSTANT_ALPHA, ConstantAlpha) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(GL_ONE_MINUS_CONSTANT_ALPHA, OneMinusConstantAlpha) \ + QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY(GL_SRC_ALPHA_SATURATE, SrcAlphaSaturate) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_RENDER_FACE \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_FACE(GL_FRONT, Front) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_FACE(GL_BACK, Back) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_FACE(GL_FRONT_AND_BACK, FrontAndBack) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_RENDER_WINDING \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_WINDING(GL_CW, Clockwise) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_WINDING(GL_CCW, CounterClockwise) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_BOOL_OP \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(GL_NEVER, Never) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(GL_LESS, Less) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(GL_EQUAL, Equal) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(GL_LEQUAL, LessThanOrEqual) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(GL_GREATER, Greater) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(GL_NOTEQUAL, NotEqual) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(GL_GEQUAL, GreaterThanOrEqual) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(GL_ALWAYS, AlwaysTrue) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_HINT \ + QT3DS_RENDER_HANDLE_GL_QT3DS_HINT(GL_FASTEST, Fastest) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_HINT(GL_NICEST, Nicest) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_HINT(GL_DONT_CARE, Unspecified) + +#define QT3DS_RENDER_ITERATE_QT3DS_GL_STENCIL_OP \ + QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(GL_KEEP, Keep) \ + QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(GL_ZERO, Zero) \ + QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(GL_REPLACE, Replace) \ + QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(GL_INCR, Increment) \ + QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(GL_INCR_WRAP, IncrementWrap) \ + QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(GL_DECR, Decrement) \ + QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(GL_DECR_WRAP, DecrementWrap) \ + QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(GL_INVERT, Invert) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_BUFFER_COMPONENT_TYPES \ + QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE(GL_UNSIGNED_BYTE, QT3DSU8) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE(GL_BYTE, QT3DSI8) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE(GL_UNSIGNED_SHORT, QT3DSU16) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE(GL_SHORT, QT3DSI16) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE(GL_UNSIGNED_INT, QT3DSU32) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE_ALIAS(GL_INT, QT3DSI32) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE(GL_FLOAT, QT3DSF32) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_BUFFER_USAGE_TYPE \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BUFFER_USAGE_TYPE(GL_STATIC_DRAW, Static) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_BUFFER_USAGE_TYPE(GL_DYNAMIC_DRAW, Dynamic) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_TEXTURE_SCALE_OP \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP(GL_NEAREST, Nearest) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP(GL_LINEAR, Linear) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP(GL_NEAREST_MIPMAP_NEAREST, NearestMipmapNearest) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP(GL_LINEAR_MIPMAP_NEAREST, LinearMipmapNearest) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP(GL_NEAREST_MIPMAP_LINEAR, NearestMipmapLinear) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP(GL_LINEAR_MIPMAP_LINEAR, LinearMipmapLinear) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_TEXTURE_WRAP_OP \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_WRAP_OP(GL_CLAMP_TO_EDGE, ClampToEdge) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_WRAP_OP(GL_MIRRORED_REPEAT, MirroredRepeat) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_WRAP_OP(GL_REPEAT, Repeat) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_SHADER_UNIFORM_TYPES \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_FLOAT, QT3DSF32) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_FLOAT_VEC2, QT3DSVec2) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_FLOAT_VEC3, QT3DSVec3) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_FLOAT_VEC4, QT3DSVec4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_INT, QT3DSI32) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_INT_VEC2, QT3DSI32_2) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_INT_VEC3, QT3DSI32_3) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_INT_VEC4, QT3DSI32_4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_BOOL, QT3DSRenderBool) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_BOOL_VEC2, bool_2) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_BOOL_VEC3, bool_3) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_BOOL_VEC4, bool_4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_UNSIGNED_INT, QT3DSU32) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_UNSIGNED_INT_VEC2, QT3DSU32_2) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_UNSIGNED_INT_VEC3, QT3DSU32_3) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_UNSIGNED_INT_VEC4, QT3DSU32_4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_FLOAT_MAT3, QT3DSMat33) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_FLOAT_MAT4, QT3DSMat44) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_SAMPLER_2D, NVRenderTexture2DPtr) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_SAMPLER_2D_ARRAY, NVRenderTexture2DArrayPtr) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_SAMPLER_CUBE, NVRenderTextureCubePtr) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(GL_IMAGE_2D, NVRenderImage2DPtr) +// cube Sampler and mat22 unsupported + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_SHADER_ATTRIB_TYPES \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(GL_FLOAT, QT3DSF32, 1) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(GL_FLOAT_VEC2, QT3DSF32, 2) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(GL_FLOAT_VEC3, QT3DSF32, 3) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(GL_FLOAT_VEC4, QT3DSF32, 4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(GL_FLOAT_MAT2, QT3DSF32, 4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(GL_FLOAT_MAT3, QT3DSF32, 9) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(GL_FLOAT_MAT4, QT3DSF32, 16) +#if defined(GL_DEPTH_COMPONENT32) +#define QT3DS_RENDER_ITERATE_GL_QT3DS_RENDERBUFFER_FORMATS \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_RGBA4, RGBA4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_RGB565, RGB565) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_RGB5_A1, RGBA5551) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_DEPTH_COMPONENT16, Depth16) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_DEPTH_COMPONENT24, Depth24) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_DEPTH_COMPONENT32, Depth32) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_STENCIL_INDEX8, StencilIndex8) +#else +#define QT3DS_RENDER_ITERATE_GL_QT3DS_RENDERBUFFER_FORMATS \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_RGBA4, RGBA4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_RGB565, RGB565) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_RGB5_A1, RGBA5551) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_DEPTH_COMPONENT16, Depth16) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_DEPTH_COMPONENT24, Depth24) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(GL_STENCIL_INDEX8, StencilIndex8) +#endif + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_FRAMEBUFFER_ATTACHMENTS \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(Color0, 0) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(Color1, 1) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(Color2, 2) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(Color3, 3) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(Color4, 4) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(Color5, 5) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(Color6, 6) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(Color7, 7) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_ATTACHMENT(GL_DEPTH_ATTACHMENT, Depth) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_ATTACHMENT(GL_STENCIL_ATTACHMENT, Stencil) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_ATTACHMENT(GL_DEPTH_STENCIL_ATTACHMENT, DepthStencil) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_CLEAR_FLAGS \ + QT3DS_RENDER_HANDLE_GL_QT3DS_CLEAR_FLAGS(GL_COLOR_BUFFER_BIT, Color) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_CLEAR_FLAGS(GL_DEPTH_BUFFER_BIT, Depth) \ + QT3DS_RENDER_HANDLE_GL_QT3DS_CLEAR_FLAGS(GL_STENCIL_BUFFER_BIT, Stencil) + +#define QT3DS_RENDER_ITERATE_GL_QT3DS_RENDERBUFFER_COVERAGE_FORMATS +#define QT3DS_RENDER_ITERATE_GL_QT3DS_FRAMEBUFFER_COVERAGE_ATTACHMENTS +#define QT3DS_RENDER_ITERATE_GL_QT3DS_CLEAR_COVERAGE_FLAGS + + static bool IsGlEsContext(NVRenderContextType inContextType) + { + NVRenderContextType esContextTypes(NVRenderContextValues::GLES2 + | NVRenderContextValues::GLES3 + | NVRenderContextValues::GLES3PLUS); + + if ((inContextType & esContextTypes)) + return true; + + return false; + } + + struct GLConversion + { + GLConversion() + { } + + static const char *processGLError(GLenum error) + { + const char *errorString = ""; + switch (error) { +#define stringiseError(error) \ + case error: \ + errorString = #error; \ + break + stringiseError(GL_NO_ERROR); + stringiseError(GL_INVALID_ENUM); + stringiseError(GL_INVALID_VALUE); + stringiseError(GL_INVALID_OPERATION); + stringiseError(GL_INVALID_FRAMEBUFFER_OPERATION); + stringiseError(GL_OUT_OF_MEMORY); +#undef stringiseError + default: + errorString = "Unknown GL error"; + break; + } + return errorString; + } + + static NVRenderSrcBlendFunc::Enum fromGLToSrcBlendFunc(QT3DSI32 value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(srcVal, enumVal) \ + case srcVal: \ + return NVRenderSrcBlendFunc::enumVal; +#define QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY(srcVal, enumVal) \ + case srcVal: \ + return NVRenderSrcBlendFunc::enumVal; + QT3DS_RENDER_ITERATE_QT3DS_GL_COLOR_FUNC +#undef QT3DS_RENDER_HANDLE_GL_COLOR_FUNC +#undef QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY + default: + QT3DS_ASSERT(false); + return NVRenderSrcBlendFunc::Unknown; + } + } + + static GLenum fromSrcBlendFuncToGL(NVRenderSrcBlendFunc::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(srcVal, enumVal) \ + case NVRenderSrcBlendFunc::enumVal: \ + return srcVal; +#define QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY(srcVal, enumVal) \ + case NVRenderSrcBlendFunc::enumVal: \ + return srcVal; + QT3DS_RENDER_ITERATE_QT3DS_GL_COLOR_FUNC +#undef QT3DS_RENDER_HANDLE_GL_COLOR_FUNC +#undef QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY + default: + QT3DS_ASSERT(false); + return 0; + } + } + + static NVRenderDstBlendFunc::Enum fromGLToDstBlendFunc(QT3DSI32 value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(srcVal, enumVal) \ + case srcVal: \ + return NVRenderDstBlendFunc::enumVal; +#define QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY(srcVal, enumVal) + QT3DS_RENDER_ITERATE_QT3DS_GL_COLOR_FUNC +#undef QT3DS_RENDER_HANDLE_GL_COLOR_FUNC +#undef QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY + default: + QT3DS_ASSERT(false); + return NVRenderDstBlendFunc::Unknown; + } + } + + static GLenum fromDstBlendFuncToGL(NVRenderDstBlendFunc::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_COLOR_FUNC(srcVal, enumVal) \ + case NVRenderDstBlendFunc::enumVal: \ + return srcVal; +#define QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY(srcVal, enumVal) + QT3DS_RENDER_ITERATE_QT3DS_GL_COLOR_FUNC +#undef QT3DS_RENDER_HANDLE_GL_COLOR_FUNC +#undef QT3DS_RENDER_HANDLE_GL_COLOR_FUNC_SRC_ONLY + default: + QT3DS_ASSERT(false); + return 0; + } + } + + static GLenum fromBlendEquationToGL(NVRenderBlendEquation::Enum value, + bool nvAdvancedBlendSupported, + bool khrAdvancedBlendSupported) + { + switch (value) { + case NVRenderBlendEquation::Add: + return GL_FUNC_ADD; + case NVRenderBlendEquation::Subtract: + return GL_FUNC_SUBTRACT; + case NVRenderBlendEquation::ReverseSubtract: + return GL_FUNC_REVERSE_SUBTRACT; + default: + QT3DS_ASSERT(nvAdvancedBlendSupported || khrAdvancedBlendSupported); + break; + } + + if (nvAdvancedBlendSupported) { + switch (value) { + case NVRenderBlendEquation::Overlay: + return GL_OVERLAY_NV; + case NVRenderBlendEquation::ColorBurn: + return GL_COLORBURN_NV; + case NVRenderBlendEquation::ColorDodge: + return GL_COLORDODGE_NV; + default: + break; + } + } + +#if defined(GL_KHR_blend_equation_advanced) + if (khrAdvancedBlendSupported) { + switch (value) { + case NVRenderBlendEquation::Overlay: + return GL_OVERLAY_KHR; + case NVRenderBlendEquation::ColorBurn: + return GL_COLORBURN_KHR; + case NVRenderBlendEquation::ColorDodge: + return GL_COLORDODGE_KHR; + default: + break; + } + } +#endif + + QT3DS_ASSERT(false); + return GL_FUNC_ADD; + } + + static NVRenderFaces::Enum fromGLToFaces(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_FACE(x, y) \ + case x: \ + return NVRenderFaces::y; + QT3DS_RENDER_ITERATE_GL_QT3DS_RENDER_FACE +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_FACE + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderFaces::Unknown; + } + + static GLenum fromFacesToGL(NVRenderFaces::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_FACE(x, y) \ + case NVRenderFaces::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_RENDER_FACE +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_FACE + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVReadFaces::Enum fromGLToReadFaces(GLenum value) + { + switch (value) { + case GL_FRONT: + return NVReadFaces::Front; + case GL_BACK: + return NVReadFaces::Back; + case GL_COLOR_ATTACHMENT0: + return NVReadFaces::Color0; + case GL_COLOR_ATTACHMENT1: + return NVReadFaces::Color1; + case GL_COLOR_ATTACHMENT2: + return NVReadFaces::Color2; + case GL_COLOR_ATTACHMENT3: + return NVReadFaces::Color3; + case GL_COLOR_ATTACHMENT4: + return NVReadFaces::Color4; + case GL_COLOR_ATTACHMENT5: + return NVReadFaces::Color5; + case GL_COLOR_ATTACHMENT6: + return NVReadFaces::Color6; + case GL_COLOR_ATTACHMENT7: + return NVReadFaces::Color7; + + default: + break; + } + QT3DS_ASSERT(false); + return NVReadFaces::Unknown; + } + + static GLenum fromReadFacesToGL(NVReadFaces::Enum value) + { + switch (value) { + case NVReadFaces::Front: + return GL_FRONT; + case NVReadFaces::Back: + return GL_BACK; + case NVReadFaces::Color0: + return GL_COLOR_ATTACHMENT0; + case NVReadFaces::Color1: + return GL_COLOR_ATTACHMENT1; + case NVReadFaces::Color2: + return GL_COLOR_ATTACHMENT2; + case NVReadFaces::Color3: + return GL_COLOR_ATTACHMENT3; + case NVReadFaces::Color4: + return GL_COLOR_ATTACHMENT4; + case NVReadFaces::Color5: + return GL_COLOR_ATTACHMENT5; + case NVReadFaces::Color6: + return GL_COLOR_ATTACHMENT6; + case NVReadFaces::Color7: + return GL_COLOR_ATTACHMENT7; + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderWinding::Enum fromGLToWinding(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_WINDING(x, y) \ + case x: \ + return NVRenderWinding::y; + QT3DS_RENDER_ITERATE_GL_QT3DS_RENDER_WINDING +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_WINDING + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderWinding::Unknown; + } + + static GLenum fromWindingToGL(NVRenderWinding::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_WINDING(x, y) \ + case NVRenderWinding::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_RENDER_WINDING +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_RENDER_WINDING + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderBoolOp::Enum fromGLToBoolOp(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(x, y) \ + case x: \ + return NVRenderBoolOp::y; + QT3DS_RENDER_ITERATE_GL_QT3DS_BOOL_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderBoolOp::Unknown; + } + + static GLenum fromBoolOpToGL(NVRenderBoolOp::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(x, y) \ + case NVRenderBoolOp::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_BOOL_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderHint::Enum fromGLToHint(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_HINT(x, y) \ + case x: \ + return NVRenderHint::y; + QT3DS_RENDER_ITERATE_GL_QT3DS_HINT +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_HINT + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderHint::Unknown; + } + + static GLenum fromHintToGL(NVRenderHint::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_HINT(x, y) \ + case NVRenderHint::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_HINT +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_HINT + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderStencilOp::Enum fromGLToStencilOp(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(x, y) \ + case x: \ + return NVRenderStencilOp::y; + QT3DS_RENDER_ITERATE_QT3DS_GL_STENCIL_OP +#undef QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP + default: + break; + } + + QT3DS_ASSERT(false); + return NVRenderStencilOp::Unknown; + } + + static GLenum fromStencilOpToGL(NVRenderStencilOp::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP(x, y) \ + case NVRenderStencilOp::y: \ + return x; + QT3DS_RENDER_ITERATE_QT3DS_GL_STENCIL_OP +#undef QT3DS_RENDER_HANDLE_QT3DS_GL_STENCIL_OP + default: + break; + } + + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderComponentTypes::Enum fromGLToBufferComponentTypes(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE(x, y) \ + case x: \ + return NVRenderComponentTypes::y; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE_ALIAS(x, y) + QT3DS_RENDER_ITERATE_GL_QT3DS_BUFFER_COMPONENT_TYPES +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE_ALIAS + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderComponentTypes::Unknown; + } + + static GLenum fromBufferComponentTypesToGL(NVRenderComponentTypes::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE(x, y) \ + case NVRenderComponentTypes::y: \ + return x; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE_ALIAS(x, y) \ + case NVRenderComponentTypes::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_BUFFER_COMPONENT_TYPES +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_COMPONENT_TYPE + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static GLenum fromIndexBufferComponentsTypesToGL(NVRenderComponentTypes::Enum value) + { + switch (value) { + case NVRenderComponentTypes::QT3DSU8: + return GL_UNSIGNED_BYTE; + case NVRenderComponentTypes::QT3DSU16: + return GL_UNSIGNED_SHORT; + case NVRenderComponentTypes::QT3DSU32: + return GL_UNSIGNED_INT; + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static GLenum fromBindBufferFlagsToGL(NVRenderBufferBindFlags flags) + { + QT3DSU32 value = flags; + GLenum retval = GL_INVALID_ENUM; + if (value & NVRenderBufferBindValues::Vertex) + retval = GL_ARRAY_BUFFER; + else if (value & NVRenderBufferBindValues::Index) + retval = GL_ELEMENT_ARRAY_BUFFER; + else if (value & NVRenderBufferBindValues::Constant) + retval = GL_UNIFORM_BUFFER; + else if (value & NVRenderBufferBindValues::Storage) + retval = GL_SHADER_STORAGE_BUFFER; + else if (value & NVRenderBufferBindValues::Atomic_Counter) + retval = GL_ATOMIC_COUNTER_BUFFER; + else if (value & NVRenderBufferBindValues::Draw_Indirect) + retval = GL_DRAW_INDIRECT_BUFFER; + else + QT3DS_ASSERT(false); + + return retval; + } + + static NVRenderBufferBindFlags fromGLToBindBufferFlags(GLenum value) + { + QT3DSU32 retval = 0; + + if (value == GL_ARRAY_BUFFER) + retval |= NVRenderBufferBindValues::Vertex; + else if (value == GL_ELEMENT_ARRAY_BUFFER) + retval |= NVRenderBufferBindValues::Index; + else if (value == GL_UNIFORM_BUFFER) + retval |= NVRenderBufferBindValues::Constant; + else if (value == GL_SHADER_STORAGE_BUFFER) + retval |= NVRenderBufferBindValues::Storage; + else if (value == GL_ATOMIC_COUNTER_BUFFER) + retval |= NVRenderBufferBindValues::Atomic_Counter; + else if (value == GL_DRAW_INDIRECT_BUFFER) + retval |= NVRenderBufferBindValues::Draw_Indirect; + else + QT3DS_ASSERT(false); + + return NVRenderBufferBindFlags(retval); + } + + static NVRenderBufferUsageType::Enum fromGLToBufferUsageType(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_BUFFER_USAGE_TYPE(x, y) \ + case x: \ + return NVRenderBufferUsageType::y; + QT3DS_RENDER_ITERATE_GL_QT3DS_BUFFER_USAGE_TYPE +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_BUFFER_USAGE_TYPE + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderBufferUsageType::Unknown; + } + + static GLenum fromBufferUsageTypeToGL(NVRenderBufferUsageType::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_BUFFER_USAGE_TYPE(x, y) \ + case NVRenderBufferUsageType::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_BUFFER_USAGE_TYPE +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_BUFFER_USAGE_TYPE + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static GLenum fromQueryTypeToGL(NVRenderQueryType::Enum type) + { + GLenum retval = GL_INVALID_ENUM; + if (type == NVRenderQueryType::Samples) + retval = GL_ANY_SAMPLES_PASSED; +#if defined(GL_TIME_ELAPSED) + else if (type == NVRenderQueryType::Timer) + retval = GL_TIME_ELAPSED; +#elif defined(GL_TIME_ELAPSED_EXT) + else if (type == NVRenderQueryType::Timer) + retval = GL_TIME_ELAPSED_EXT; +#endif + else + QT3DS_ASSERT(false); + + return retval; + } + + static GLenum fromQueryResultTypeToGL(NVRenderQueryResultType::Enum type) + { + GLenum retval = GL_INVALID_ENUM; + if (type == NVRenderQueryResultType::ResultAvailable) + retval = GL_QUERY_RESULT_AVAILABLE; + else if (type == NVRenderQueryResultType::Result) + retval = GL_QUERY_RESULT; + else + QT3DS_ASSERT(false); + + return retval; + } + + static GLenum fromSyncTypeToGL(NVRenderSyncType::Enum type) + { + GLenum retval = GL_INVALID_ENUM; + if (type == NVRenderSyncType::GpuCommandsComplete) + retval = GL_SYNC_GPU_COMMANDS_COMPLETE; + else + QT3DS_ASSERT(false); + + return retval; + } + + static NVRenderTextureFormats::Enum + replaceDeprecatedTextureFormat(NVRenderContextType type, NVRenderTextureFormats::Enum value, + NVRenderTextureSwizzleMode::Enum &swizzleMode) + { + NVRenderContextType deprecatedContextFlags(NVRenderContextValues::GL2 + | NVRenderContextValues::GLES2); + NVRenderTextureFormats::Enum newValue = value; + swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle; + + if (!(type & deprecatedContextFlags)) { + switch (value) { + case NVRenderTextureFormats::Luminance8: + newValue = NVRenderTextureFormats::R8; + swizzleMode = NVRenderTextureSwizzleMode::L8toR8; + break; + case NVRenderTextureFormats::LuminanceAlpha8: + newValue = NVRenderTextureFormats::RG8; + swizzleMode = NVRenderTextureSwizzleMode::L8A8toRG8; + break; + case NVRenderTextureFormats::Alpha8: + newValue = NVRenderTextureFormats::R8; + swizzleMode = NVRenderTextureSwizzleMode::A8toR8; + break; + case NVRenderTextureFormats::Luminance16: + newValue = NVRenderTextureFormats::R16; + swizzleMode = NVRenderTextureSwizzleMode::L16toR16; + break; + default: + break; + } + } + + return newValue; + } + + static void + NVRenderConvertSwizzleModeToGL(const NVRenderTextureSwizzleMode::Enum swizzleMode, + GLint glSwizzle[4]) + { + switch (swizzleMode) { + case NVRenderTextureSwizzleMode::L16toR16: + case NVRenderTextureSwizzleMode::L8toR8: + glSwizzle[0] = GL_RED; + glSwizzle[1] = GL_RED; + glSwizzle[2] = GL_RED; + glSwizzle[3] = GL_ONE; + break; + case NVRenderTextureSwizzleMode::L8A8toRG8: + glSwizzle[0] = GL_RED; + glSwizzle[1] = GL_RED; + glSwizzle[2] = GL_RED; + glSwizzle[3] = GL_GREEN; + break; + case NVRenderTextureSwizzleMode::A8toR8: + glSwizzle[0] = GL_ZERO; + glSwizzle[1] = GL_ZERO; + glSwizzle[2] = GL_ZERO; + glSwizzle[3] = GL_RED; + break; + case NVRenderTextureSwizzleMode::NoSwizzle: + default: + glSwizzle[0] = GL_RED; + glSwizzle[1] = GL_GREEN; + glSwizzle[2] = GL_BLUE; + glSwizzle[3] = GL_ALPHA; + break; + } + } + + static bool fromUncompressedTextureFormatToGL(NVRenderContextType type, + NVRenderTextureFormats::Enum value, + GLenum &outFormat, GLenum &outDataType, + GLenum &outInternalFormat) + { + switch (value) { + case NVRenderTextureFormats::R8: + if (type == NVRenderContextValues::GLES2) { + outFormat = GL_ALPHA; + outInternalFormat = GL_ALPHA; + } else { + outFormat = GL_RED; + outInternalFormat = GL_R8; + } + outDataType = GL_UNSIGNED_BYTE; + return true; + case NVRenderTextureFormats::RG8: + outFormat = GL_RG; + outInternalFormat = GL_RG8; + outDataType = GL_UNSIGNED_BYTE; + return true; + case NVRenderTextureFormats::RGBA8: + outFormat = GL_RGBA; + outInternalFormat = GL_RGBA8; + outDataType = GL_UNSIGNED_BYTE; + return true; + case NVRenderTextureFormats::RGB8: + outFormat = GL_RGB; + outInternalFormat = GL_RGB8; + outDataType = GL_UNSIGNED_BYTE; + return true; + case NVRenderTextureFormats::RGB565: + outFormat = GL_RGB; + outInternalFormat = GL_RGB8; + outDataType = GL_UNSIGNED_SHORT_5_6_5; + return true; + case NVRenderTextureFormats::RGBA5551: + outFormat = GL_RGBA; + outInternalFormat = GL_RGBA8; + outDataType = GL_UNSIGNED_SHORT_5_5_5_1; + return true; + case NVRenderTextureFormats::Alpha8: + outFormat = GL_ALPHA; + outInternalFormat = GL_ALPHA; + outDataType = GL_UNSIGNED_BYTE; + return true; + case NVRenderTextureFormats::Luminance8: + outFormat = GL_LUMINANCE; + outInternalFormat = GL_LUMINANCE; + outDataType = GL_UNSIGNED_BYTE; + return true; + case NVRenderTextureFormats::LuminanceAlpha8: + outFormat = GL_LUMINANCE_ALPHA; + outInternalFormat = GL_LUMINANCE_ALPHA; + outDataType = GL_UNSIGNED_BYTE; + return true; + case NVRenderTextureFormats::Luminance16: +#if defined(QT_OPENGL_ES) + outFormat = GL_LUMINANCE16F_EXT; + outInternalFormat = GL_LUMINANCE16F_EXT; +#else + outFormat = GL_LUMINANCE; + outInternalFormat = GL_LUMINANCE; +#endif + outDataType = GL_UNSIGNED_INT; + return true; + default: + break; + } + + NVRenderContextType contextFlags(NVRenderContextValues::GL2 + | NVRenderContextValues::GLES2); + // check extented texture formats + if (!(type & contextFlags)) { + switch (value) { +#if !defined(QT_OPENGL_ES) + case NVRenderTextureFormats::R16: { + if (IsGlEsContext(type)) { + outFormat = GL_RED_INTEGER; + outInternalFormat = GL_R16UI; + } else { + outFormat = GL_RED; + outInternalFormat = GL_R16; + } + outDataType = GL_UNSIGNED_SHORT; + return true; + } +#endif + case NVRenderTextureFormats::R16F: + outFormat = GL_RED; + outInternalFormat = GL_R16F; + outDataType = GL_HALF_FLOAT; + return true; + case NVRenderTextureFormats::R32UI: + outFormat = GL_RED_INTEGER; + outInternalFormat = GL_R32UI; + outDataType = GL_UNSIGNED_INT; + return true; + case NVRenderTextureFormats::R32F: + outFormat = GL_RED; + outInternalFormat = GL_R32F; + outDataType = GL_FLOAT; + return true; + case NVRenderTextureFormats::RGBA16F: + outFormat = GL_RGBA; + outInternalFormat = GL_RGBA16F; + outDataType = GL_HALF_FLOAT; + return true; + case NVRenderTextureFormats::RG16F: + outFormat = GL_RG; + outInternalFormat = GL_RG16F; + outDataType = GL_HALF_FLOAT; + return true; + case NVRenderTextureFormats::RG32F: + outFormat = GL_RG; + outInternalFormat = GL_RG32F; + outDataType = GL_FLOAT; + return true; + case NVRenderTextureFormats::RGBA32F: + outFormat = GL_RGBA; + outInternalFormat = GL_RGBA32F; + outDataType = GL_FLOAT; + return true; + case NVRenderTextureFormats::RGB32F: + outFormat = GL_RGB; + outInternalFormat = GL_RGB32F; + outDataType = GL_FLOAT; + return true; + case NVRenderTextureFormats::R11G11B10: + outFormat = GL_RGB; + outInternalFormat = GL_R11F_G11F_B10F; + outDataType = GL_UNSIGNED_INT_10F_11F_11F_REV; + return true; + case NVRenderTextureFormats::RGB9E5: + outFormat = GL_RGB; + outInternalFormat = GL_RGB9_E5; + outDataType = GL_UNSIGNED_INT_5_9_9_9_REV; + return true; + case NVRenderTextureFormats::SRGB8: + outFormat = GL_RGB; + outInternalFormat = GL_SRGB8; + outDataType = GL_UNSIGNED_BYTE; + return true; + case NVRenderTextureFormats::SRGB8A8: + outFormat = GL_RGBA; + outInternalFormat = GL_SRGB8_ALPHA8; + outDataType = GL_UNSIGNED_BYTE; + return true; + default: + break; + } + } + + QT3DS_ASSERT(false); + return false; + } + + static GLenum fromCompressedTextureFormatToGL(NVRenderTextureFormats::Enum value) + { + switch (value) { + case NVRenderTextureFormats::RGBA_DXT1: + return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + case NVRenderTextureFormats::RGB_DXT1: + return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; + case NVRenderTextureFormats::RGBA_DXT3: + return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + case NVRenderTextureFormats::RGBA_DXT5: + return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + case NVRenderTextureFormats::R_ATI1N_UNorm: + return GL_COMPRESSED_RED_RGTC1; + case NVRenderTextureFormats::R_ATI1N_SNorm: + return GL_COMPRESSED_SIGNED_RED_RGTC1; + case NVRenderTextureFormats::RG_ATI2N_UNorm: + return GL_COMPRESSED_RG_RGTC2; + case NVRenderTextureFormats::RG_ATI2N_SNorm: + return GL_COMPRESSED_SIGNED_RG_RGTC2; + case NVRenderTextureFormats::RGB_BP_UNSIGNED_FLOAT: + return GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB; + case NVRenderTextureFormats::RGB_BP_SIGNED_FLOAT: + return GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB; + case NVRenderTextureFormats::RGB_BP_UNorm: + return GL_COMPRESSED_RGBA_BPTC_UNORM_ARB; + case NVRenderTextureFormats::R11_EAC_UNorm: + return GL_COMPRESSED_R11_EAC; + case NVRenderTextureFormats::R11_EAC_SNorm: + return GL_COMPRESSED_SIGNED_R11_EAC; + case NVRenderTextureFormats::RG11_EAC_UNorm: + return GL_COMPRESSED_RG11_EAC; + case NVRenderTextureFormats::RG11_EAC_SNorm: + return GL_COMPRESSED_SIGNED_RG11_EAC; + case NVRenderTextureFormats::RGB8_ETC2: + return GL_COMPRESSED_RGB8_ETC2; + case NVRenderTextureFormats::SRGB8_ETC2: + return GL_COMPRESSED_SRGB8_ETC2; + case NVRenderTextureFormats::RGB8_PunchThrough_Alpha1_ETC2: + return GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; + case NVRenderTextureFormats::SRGB8_PunchThrough_Alpha1_ETC2: + return GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; + case NVRenderTextureFormats::RGBA8_ETC2_EAC: + return GL_COMPRESSED_RGBA8_ETC2_EAC; + case NVRenderTextureFormats::SRGB8_Alpha8_ETC2_EAC: + return GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC; + case NVRenderTextureFormats::RGB8_ETC1: + return GL_ETC1_RGB8_OES; +#ifdef GL_KHR_texture_compression_astc_hdr + case NVRenderTextureFormats::RGBA_ASTC_4x4: + return GL_COMPRESSED_RGBA_ASTC_4x4_KHR; + case NVRenderTextureFormats::RGBA_ASTC_5x4: + return GL_COMPRESSED_RGBA_ASTC_5x4_KHR; + case NVRenderTextureFormats::RGBA_ASTC_5x5: + return GL_COMPRESSED_RGBA_ASTC_5x5_KHR; + case NVRenderTextureFormats::RGBA_ASTC_6x5: + return GL_COMPRESSED_RGBA_ASTC_6x5_KHR; + case NVRenderTextureFormats::RGBA_ASTC_6x6: + return GL_COMPRESSED_RGBA_ASTC_6x6_KHR; + case NVRenderTextureFormats::RGBA_ASTC_8x5: + return GL_COMPRESSED_RGBA_ASTC_8x5_KHR; + case NVRenderTextureFormats::RGBA_ASTC_8x6: + return GL_COMPRESSED_RGBA_ASTC_8x6_KHR; + case NVRenderTextureFormats::RGBA_ASTC_8x8: + return GL_COMPRESSED_RGBA_ASTC_8x8_KHR; + case NVRenderTextureFormats::RGBA_ASTC_10x5: + return GL_COMPRESSED_RGBA_ASTC_10x5_KHR; + case NVRenderTextureFormats::RGBA_ASTC_10x6: + return GL_COMPRESSED_RGBA_ASTC_10x6_KHR; + case NVRenderTextureFormats::RGBA_ASTC_10x8: + return GL_COMPRESSED_RGBA_ASTC_10x8_KHR; + case NVRenderTextureFormats::RGBA_ASTC_10x10: + return GL_COMPRESSED_RGBA_ASTC_10x10_KHR; + case NVRenderTextureFormats::RGBA_ASTC_12x10: + return GL_COMPRESSED_RGBA_ASTC_12x10_KHR; + case NVRenderTextureFormats::RGBA_ASTC_12x12: + return GL_COMPRESSED_RGBA_ASTC_12x12_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_4x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_5x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_5x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_6x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_6x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_8x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_8x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_8x8: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_10x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_10x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_10x8: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_10x10: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_12x10: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR; + case NVRenderTextureFormats::SRGB8_Alpha8_ASTC_12x12: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR; +#endif // GL_KHR_texture_compression_astc_hdr + default: + break; + } + + QT3DS_ASSERT(false); + return 0; + } + + static bool fromDepthTextureFormatToGL(NVRenderContextType type, + NVRenderTextureFormats::Enum value, + GLenum &outFormat, GLenum &outDataType, + GLenum &outInternalFormat) + { + NVRenderContextType theContextFlags(NVRenderContextValues::GLES2 + | NVRenderContextValues::GL2); + + bool supportDepth24 = !(type & theContextFlags); + bool supportDepth32f = !(type & theContextFlags); + bool supportDepth24Stencil8 = !(type & theContextFlags); + + switch (value) { + case NVRenderTextureFormats::Depth16: + outFormat = GL_DEPTH_COMPONENT; + outInternalFormat = GL_DEPTH_COMPONENT16; + outDataType = GL_UNSIGNED_SHORT; + return true; + case NVRenderTextureFormats::Depth24: + outFormat = GL_DEPTH_COMPONENT; + outInternalFormat = (supportDepth24) ? GL_DEPTH_COMPONENT24 : GL_DEPTH_COMPONENT16; + outDataType = (supportDepth24) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT; + return true; + case NVRenderTextureFormats::Depth32: + outFormat = GL_DEPTH_COMPONENT; + outInternalFormat = + (supportDepth32f) ? GL_DEPTH_COMPONENT32F : GL_DEPTH_COMPONENT16; + outDataType = (supportDepth32f) ? GL_FLOAT : GL_UNSIGNED_SHORT; + return true; + case NVRenderTextureFormats::Depth24Stencil8: + outFormat = (supportDepth24Stencil8) ? GL_DEPTH_STENCIL : GL_DEPTH_COMPONENT; + outInternalFormat = + (supportDepth24Stencil8) ? GL_DEPTH24_STENCIL8 : GL_DEPTH_COMPONENT16; + outDataType = (supportDepth24Stencil8) ? GL_UNSIGNED_INT_24_8 : GL_UNSIGNED_SHORT; + return true; + default: + break; + } + + QT3DS_ASSERT(false); + return false; + } + + static GLenum fromTextureTargetToGL(NVRenderTextureTargetType::Enum value) + { + GLenum retval = 0; + if (value == NVRenderTextureTargetType::Texture2D) + retval = GL_TEXTURE_2D; + else if (value == NVRenderTextureTargetType::Texture2D_MS) + retval = GL_TEXTURE_2D_MULTISAMPLE; + else if (value == NVRenderTextureTargetType::Texture2D_Array) + retval = GL_TEXTURE_2D_ARRAY; + else if (value == NVRenderTextureTargetType::TextureCube) + retval = GL_TEXTURE_CUBE_MAP; + else if (value == NVRenderTextureTargetType::TextureCubeNegX) + retval = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; + else if (value == NVRenderTextureTargetType::TextureCubePosX) + retval = GL_TEXTURE_CUBE_MAP_POSITIVE_X; + else if (value == NVRenderTextureTargetType::TextureCubeNegY) + retval = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; + else if (value == NVRenderTextureTargetType::TextureCubePosY) + retval = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; + else if (value == NVRenderTextureTargetType::TextureCubeNegZ) + retval = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; + else if (value == NVRenderTextureTargetType::TextureCubePosZ) + retval = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; + else + QT3DS_ASSERT(false); + + return retval; + } + + static NVRenderTextureTargetType::Enum fromGLToTextureTarget(GLenum value) + { + NVRenderTextureTargetType::Enum retval = NVRenderTextureTargetType::Unknown; + + if (value == GL_TEXTURE_2D) + retval = NVRenderTextureTargetType::Texture2D; + else if (value == GL_TEXTURE_2D_MULTISAMPLE) + retval = NVRenderTextureTargetType::Texture2D_MS; + else + QT3DS_ASSERT(false); + + return retval; + } + + static GLenum fromTextureUnitToGL(NVRenderTextureUnit::Enum value) + { + QT3DSU32 v = value; + GLenum retval = GL_TEXTURE0; + retval = GL_TEXTURE0 + v; + + return retval; + } + + static GLenum fromGLToTextureUnit(GLenum value) + { + QT3DS_ASSERT(value > GL_TEXTURE0); + + QT3DSU32 v = value - GL_TEXTURE0; + NVRenderTextureUnit::Enum retval = + NVRenderTextureUnit::Enum(NVRenderTextureUnit::TextureUnit_0 + v); + + return retval; + } + + static GLenum fromTextureMinifyingOpToGL(NVRenderTextureMinifyingOp::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP(x, y) \ + case NVRenderTextureMinifyingOp::y: \ + return x; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP(x, y) \ + case NVRenderTextureMinifyingOp::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_TEXTURE_SCALE_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderTextureMinifyingOp::Enum fromGLToTextureMinifyingOp(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP(x, y) \ + case x: \ + return NVRenderTextureMinifyingOp::y; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP(x, y) \ + case x: \ + return NVRenderTextureMinifyingOp::y; + QT3DS_RENDER_ITERATE_GL_QT3DS_TEXTURE_SCALE_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderTextureMinifyingOp::Unknown; + } + + static GLenum fromTextureMagnifyingOpToGL(NVRenderTextureMagnifyingOp::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP(x, y) \ + case NVRenderTextureMagnifyingOp::y: \ + return x; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP(x, y) + QT3DS_RENDER_ITERATE_GL_QT3DS_TEXTURE_SCALE_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderTextureMagnifyingOp::Enum fromGLToTextureMagnifyingOp(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP(x, y) \ + case x: \ + return NVRenderTextureMagnifyingOp::y; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP(x, y) + QT3DS_RENDER_ITERATE_GL_QT3DS_TEXTURE_SCALE_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_SCALE_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_MINIFYING_OP + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderTextureMagnifyingOp::Unknown; + } + + static GLenum fromTextureCoordOpToGL(NVRenderTextureCoordOp::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_WRAP_OP(x, y) \ + case NVRenderTextureCoordOp::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_TEXTURE_WRAP_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_WRAP_OP + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderTextureCoordOp::Enum fromGLToTextureCoordOp(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_WRAP_OP(x, y) \ + case x: \ + return NVRenderTextureCoordOp::y; + QT3DS_RENDER_ITERATE_GL_QT3DS_TEXTURE_WRAP_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_TEXTURE_WRAP_OP + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderTextureCoordOp::Unknown; + } + + static GLenum fromTextureCompareModeToGL(NVRenderTextureCompareMode::Enum value) + { + switch (value) { + case NVRenderTextureCompareMode::NoCompare: + return GL_NONE; + case NVRenderTextureCompareMode::CompareToRef: + return GL_COMPARE_REF_TO_TEXTURE; + default: + break; + } + + QT3DS_ASSERT(false); + return NVRenderTextureCompareMode::Unknown; + } + + static GLenum fromGLToTextureCompareMode(GLenum value) + { + switch (value) { + case GL_NONE: + return NVRenderTextureCompareMode::NoCompare; + case GL_COMPARE_REF_TO_TEXTURE: + return NVRenderTextureCompareMode::CompareToRef; + default: + break; + } + + QT3DS_ASSERT(false); + return GL_INVALID_ENUM; + } + + static GLenum fromTextureCompareFuncToGL(NVRenderTextureCompareOp::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP(x, y) \ + case NVRenderTextureCompareOp::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_BOOL_OP +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_BOOL_OP + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static GLenum fromImageFormatToGL(NVRenderTextureFormats::Enum value) + { + switch (value) { + case NVRenderTextureFormats::R8: + return GL_R8; + case NVRenderTextureFormats::R32I: + return GL_R32I; + case NVRenderTextureFormats::R32UI: + return GL_R32UI; + case NVRenderTextureFormats::R32F: + return GL_R32F; + case NVRenderTextureFormats::RGBA8: + return GL_RGBA8; + case NVRenderTextureFormats::SRGB8A8: + return GL_RGBA8_SNORM; + case NVRenderTextureFormats::RG16F: + return GL_RG16F; + case NVRenderTextureFormats::RGBA16F: + return GL_RGBA16F; + case NVRenderTextureFormats::RGBA32F: + return GL_RGBA32F; + default: + break; + } + + QT3DS_ASSERT(false); + return GL_INVALID_ENUM; + } + + + static GLenum fromImageAccessToGL(NVRenderImageAccessType::Enum value) + { + switch (value) { + case NVRenderImageAccessType::Read: + return GL_READ_ONLY; + case NVRenderImageAccessType::Write: + return GL_WRITE_ONLY; + case NVRenderImageAccessType::ReadWrite: + return GL_READ_WRITE; + default: + break; + } + QT3DS_ASSERT(false); + return GL_INVALID_ENUM; + } + + static GLbitfield fromBufferAccessBitToGL(NVRenderBufferAccessFlags flags) + { + QT3DSU32 value = flags; + GLbitfield retval = 0; + + if (value & NVRenderBufferAccessTypeValues::Read) + retval |= GL_MAP_READ_BIT; + if (value & NVRenderBufferAccessTypeValues::Write) + retval |= GL_MAP_WRITE_BIT; + if (value & NVRenderBufferAccessTypeValues::Invalid) + retval |= GL_MAP_INVALIDATE_BUFFER_BIT; + if (value & NVRenderBufferAccessTypeValues::InvalidRange) + retval |= GL_MAP_INVALIDATE_RANGE_BIT; + + QT3DS_ASSERT(retval); + return retval; + } + + static GLbitfield fromMemoryBarrierFlagsToGL(NVRenderBufferBarrierFlags flags) + { + QT3DSU32 value = flags; + GLbitfield retval = 0; +#if !defined(QT_OPENGL_ES) + if (value & NVRenderBufferBarrierValues::AtomicCounter) + retval |= GL_ATOMIC_COUNTER_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::BufferUpdate) + retval |= GL_BUFFER_UPDATE_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::CommandBuffer) + retval |= GL_COMMAND_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::ElementArray) + retval |= GL_ELEMENT_ARRAY_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::Framebuffer) + retval |= GL_FRAMEBUFFER_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::PixelBuffer) + retval |= GL_PIXEL_BUFFER_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::ShaderImageAccess) + retval |= GL_SHADER_IMAGE_ACCESS_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::ShaderStorage) + retval |= GL_SHADER_STORAGE_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::TextureFetch) + retval |= GL_TEXTURE_FETCH_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::TextureUpdate) + retval |= GL_TEXTURE_UPDATE_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::TransformFeedback) + retval |= GL_TRANSFORM_FEEDBACK_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::UniformBuffer) + retval |= GL_UNIFORM_BARRIER_BIT; + if (value & NVRenderBufferBarrierValues::VertexAttribArray) + retval |= GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT; +#endif + QT3DS_ASSERT(retval); + return retval; + } + + static GLbitfield fromShaderTypeFlagsToGL(NVRenderShaderTypeFlags flags) + { + QT3DSU32 value = flags; + GLbitfield retval = 0; + if (value & NVRenderShaderTypeValue::Vertex) + retval |= GL_VERTEX_SHADER_BIT; + if (value & NVRenderShaderTypeValue::Fragment) + retval |= GL_FRAGMENT_SHADER_BIT; + if (value & NVRenderShaderTypeValue::TessControl) + retval |= GL_TESS_CONTROL_SHADER_BIT; + if (value & NVRenderShaderTypeValue::TessEvaluation) + retval |= GL_TESS_EVALUATION_SHADER_BIT; + if (value & NVRenderShaderTypeValue::Geometry) +#if defined(QT_OPENGL_ES_3_1) + retval |= GL_GEOMETRY_SHADER_BIT_EXT; +#else + retval |= GL_GEOMETRY_SHADER_BIT; +#endif + QT3DS_ASSERT(retval || !value); + return retval; + } + + static GLenum fromPropertyDataTypesToShaderGL(NVRenderShaderDataTypes::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(gl, nv) \ + case NVRenderShaderDataTypes::nv: \ + return gl; + QT3DS_RENDER_ITERATE_GL_QT3DS_SHADER_UNIFORM_TYPES +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderShaderDataTypes::Enum fromShaderGLToPropertyDataTypes(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES(gl, nv) \ + case gl: \ + return NVRenderShaderDataTypes::nv; + QT3DS_RENDER_ITERATE_GL_QT3DS_SHADER_UNIFORM_TYPES +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_UNIFORM_TYPES + case GL_SAMPLER_2D_SHADOW: + return NVRenderShaderDataTypes::NVRenderTexture2DPtr; +#if !defined(QT_OPENGL_ES) + case GL_UNSIGNED_INT_ATOMIC_COUNTER: + return NVRenderShaderDataTypes::QT3DSU32; + case GL_UNSIGNED_INT_IMAGE_2D: + return NVRenderShaderDataTypes::NVRenderImage2DPtr; +#endif + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderShaderDataTypes::Unknown; + } + + static GLenum fromComponentTypeAndNumCompsToAttribGL(NVRenderComponentTypes::Enum compType, + QT3DSU32 numComps) + { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(gl, ct, nc) \ + if (compType == NVRenderComponentTypes::ct && numComps == nc) \ + return gl; + QT3DS_RENDER_ITERATE_GL_QT3DS_SHADER_ATTRIB_TYPES +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES + QT3DS_ASSERT(false); + return 0; + } + + static void fromAttribGLToComponentTypeAndNumComps( + GLenum enumVal, NVRenderComponentTypes::Enum &outCompType, QT3DSU32 &outNumComps) + { + switch (enumVal) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES(gl, ct, nc) \ + case gl: \ + outCompType = NVRenderComponentTypes::ct; \ + outNumComps = nc; \ + return; + QT3DS_RENDER_ITERATE_GL_QT3DS_SHADER_ATTRIB_TYPES +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_SHADER_ATTRIB_TYPES + default: + break; + } + QT3DS_ASSERT(false); + outCompType = NVRenderComponentTypes::Unknown; + outNumComps = 0; + } + + static GLenum + fromRenderBufferFormatsToRenderBufferGL(NVRenderRenderBufferFormats::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(gl, nv) \ + case NVRenderRenderBufferFormats::nv: \ + return gl; + QT3DS_RENDER_ITERATE_GL_QT3DS_RENDERBUFFER_FORMATS + QT3DS_RENDER_ITERATE_GL_QT3DS_RENDERBUFFER_COVERAGE_FORMATS +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderRenderBufferFormats::Enum + fromRenderBufferGLToRenderBufferFormats(GLenum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT(gl, nv) \ + case gl: \ + return NVRenderRenderBufferFormats::nv; + QT3DS_RENDER_ITERATE_GL_QT3DS_RENDERBUFFER_FORMATS + QT3DS_RENDER_ITERATE_GL_QT3DS_RENDERBUFFER_COVERAGE_FORMATS +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_RENDERBUFFER_FORMAT + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderRenderBufferFormats::Unknown; + } + + static GLenum fromFramebufferAttachmentsToGL(NVRenderFrameBufferAttachments::Enum value) + { + switch (value) { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(x, idx) \ + case NVRenderFrameBufferAttachments::x: \ + return GL_COLOR_ATTACHMENT0 + idx; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_ATTACHMENT(x, y) \ + case NVRenderFrameBufferAttachments::y: \ + return x; + QT3DS_RENDER_ITERATE_GL_QT3DS_FRAMEBUFFER_ATTACHMENTS + QT3DS_RENDER_ITERATE_GL_QT3DS_FRAMEBUFFER_COVERAGE_ATTACHMENTS +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_ATTACHMENT + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderFrameBufferAttachments::Unknown; + } + + static NVRenderFrameBufferAttachments::Enum fromGLToFramebufferAttachments(GLenum value) + { +#define QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT(x, idx) \ + if (value == GL_COLOR_ATTACHMENT0 + idx) \ + return NVRenderFrameBufferAttachments::x; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_ATTACHMENT(x, y) \ + if (value == x) \ + return NVRenderFrameBufferAttachments::y; + QT3DS_RENDER_ITERATE_GL_QT3DS_FRAMEBUFFER_ATTACHMENTS + QT3DS_RENDER_ITERATE_GL_QT3DS_FRAMEBUFFER_COVERAGE_ATTACHMENTS +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_COLOR_ATTACHMENT +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_FRAMEBUFFER_ATTACHMENT + QT3DS_ASSERT(false); + return NVRenderFrameBufferAttachments::Unknown; + } + + static GLbitfield fromClearFlagsToGL(NVRenderClearFlags flags) + { + QT3DSU32 value = flags; + GLbitfield retval = 0; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_CLEAR_FLAGS(gl, nv) \ + if ((value & NVRenderClearValues::nv)) \ + retval |= gl; + QT3DS_RENDER_ITERATE_GL_QT3DS_CLEAR_FLAGS + QT3DS_RENDER_ITERATE_GL_QT3DS_CLEAR_COVERAGE_FLAGS +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_CLEAR_FLAGS + return retval; + } + + static NVRenderClearFlags fromGLToClearFlags(GLbitfield value) + { + QT3DSU32 retval = 0; +#define QT3DS_RENDER_HANDLE_GL_QT3DS_CLEAR_FLAGS(gl, nv) \ + if ((value & gl)) \ + retval |= NVRenderClearValues::nv; + QT3DS_RENDER_ITERATE_GL_QT3DS_CLEAR_FLAGS + QT3DS_RENDER_ITERATE_GL_QT3DS_CLEAR_COVERAGE_FLAGS +#undef QT3DS_RENDER_HANDLE_GL_QT3DS_CLEAR_FLAGS + return NVRenderClearFlags(retval); + } + + static GLenum fromDrawModeToGL(NVRenderDrawMode::Enum value, bool inTesselationSupported) + { + switch (value) { + case NVRenderDrawMode::Points: + return GL_POINTS; + case NVRenderDrawMode::Lines: + return GL_LINES; + case NVRenderDrawMode::LineStrip: + return GL_LINE_STRIP; + case NVRenderDrawMode::LineLoop: + return GL_LINE_LOOP; + case NVRenderDrawMode::TriangleStrip: + return GL_TRIANGLE_STRIP; + case NVRenderDrawMode::TriangleFan: + return GL_TRIANGLE_FAN; + case NVRenderDrawMode::Triangles: + return GL_TRIANGLES; + case NVRenderDrawMode::Patches: + return (inTesselationSupported) ? GL_PATCHES : GL_TRIANGLES; + default: + break; + } + + QT3DS_ASSERT(false); + return GL_INVALID_ENUM; + } + + static NVRenderDrawMode::Enum fromGLToDrawMode(GLenum value) + { + switch (value) { + case GL_POINTS: + return NVRenderDrawMode::Points; + case GL_LINES: + return NVRenderDrawMode::Lines; + case GL_LINE_STRIP: + return NVRenderDrawMode::LineStrip; + case GL_LINE_LOOP: + return NVRenderDrawMode::LineLoop; + case GL_TRIANGLE_STRIP: + return NVRenderDrawMode::TriangleStrip; + case GL_TRIANGLE_FAN: + return NVRenderDrawMode::TriangleFan; + case GL_TRIANGLES: + return NVRenderDrawMode::Triangles; + case GL_PATCHES: + return NVRenderDrawMode::Patches; + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderDrawMode::Unknown; + } + + static GLenum fromRenderStateToGL(NVRenderState::Enum value) + { + switch (value) { + case NVRenderState::Blend: + return GL_BLEND; + case NVRenderState::CullFace: + return GL_CULL_FACE; + case NVRenderState::DepthTest: + return GL_DEPTH_TEST; + case NVRenderState::Multisample: +#if defined(QT_OPENGL_ES) + return GL_MULTISAMPLE_EXT; +#else + return GL_MULTISAMPLE; +#endif + case NVRenderState::StencilTest: + return GL_STENCIL_TEST; + case NVRenderState::ScissorTest: + return GL_SCISSOR_TEST; + default: + break; + } + QT3DS_ASSERT(false); + return 0; + } + + static NVRenderState::Enum fromGLToRenderState(GLenum value) + { + switch (value) { + case GL_BLEND: + return NVRenderState::Blend; + case GL_CULL_FACE: + return NVRenderState::CullFace; + case GL_DEPTH_TEST: + return NVRenderState::DepthTest; +#if defined(QT_OPENGL_ES) + case GL_MULTISAMPLE_EXT: +#else + case GL_MULTISAMPLE: +#endif + return NVRenderState::Multisample; + case GL_STENCIL_TEST: + return NVRenderState::StencilTest; + case GL_SCISSOR_TEST: + return NVRenderState::ScissorTest; + default: + break; + } + QT3DS_ASSERT(false); + return NVRenderState::Unknown; + } + + static bool fromReadPixelsToGlFormatAndType(NVRenderReadPixelFormats::Enum inReadPixels, + GLuint *outFormat, GLuint *outType) + { + switch (inReadPixels) { + case NVRenderReadPixelFormats::Alpha8: + *outFormat = GL_ALPHA; + *outType = GL_UNSIGNED_BYTE; + break; + case NVRenderReadPixelFormats::RGB565: + *outFormat = GL_RGB; + *outType = GL_UNSIGNED_SHORT_5_6_5; + case NVRenderReadPixelFormats::RGB8: + *outFormat = GL_RGB; + *outType = GL_UNSIGNED_BYTE; + break; + case NVRenderReadPixelFormats::RGBA4444: + *outFormat = GL_RGBA; + *outType = GL_UNSIGNED_SHORT_4_4_4_4; + break; + case NVRenderReadPixelFormats::RGBA5551: + *outFormat = GL_RGBA; + *outType = GL_UNSIGNED_SHORT_5_5_5_1; + break; + case NVRenderReadPixelFormats::RGBA8: + *outFormat = GL_RGBA; + *outType = GL_UNSIGNED_BYTE; + break; + default: + *outFormat = 0; + *outType = 0; + QT3DS_ASSERT(false); + return false; + }; + + return true; + } + + static GLenum fromPathFillModeToGL(NVRenderPathFillMode::Enum inMode) + { + GLenum glFillMode; + + switch (inMode) { +#if !defined(QT_OPENGL_ES) + case NVRenderPathFillMode::Fill: + glFillMode = GL_PATH_FILL_MODE_NV; + break; + case NVRenderPathFillMode::CountUp: + glFillMode = GL_COUNT_UP_NV; + break; + case NVRenderPathFillMode::CountDown: + glFillMode = GL_COUNT_DOWN_NV; + break; + case NVRenderPathFillMode::Invert: + glFillMode = GL_INVERT; + break; +#endif + default: + QT3DS_ASSERT(false); + break; + } + + return glFillMode; + } + + static GLenum fromPathFontTargetToGL(NVRenderPathFontTarget::Enum inFontTarget) + { + GLenum glFontTarget; + + switch (inFontTarget) { +#if !defined(QT_OPENGL_ES) + case NVRenderPathFontTarget::StandardFont: + glFontTarget = GL_STANDARD_FONT_NAME_NV; + break; + case NVRenderPathFontTarget::SystemFont: + glFontTarget = GL_SYSTEM_FONT_NAME_NV; + break; + case NVRenderPathFontTarget::FileFont: + glFontTarget = GL_FILE_NAME_NV; + break; +#endif + default: + QT3DS_ASSERT(false); + break; + } + + return glFontTarget; + } + + static NVRenderPathReturnValues::Enum fromGLToPathFontReturn(GLenum inReturnValue) + { + NVRenderPathReturnValues::Enum returnValue; + + switch (inReturnValue) { +#if !defined(QT_OPENGL_ES) + case GL_FONT_GLYPHS_AVAILABLE_NV: + returnValue = NVRenderPathReturnValues::FontGlypsAvailable; + break; + case GL_FONT_TARGET_UNAVAILABLE_NV: + returnValue = NVRenderPathReturnValues::FontTargetUnavailable; + break; + case GL_FONT_UNAVAILABLE_NV: + returnValue = NVRenderPathReturnValues::FontUnavailable; + break; + case GL_FONT_UNINTELLIGIBLE_NV: + returnValue = NVRenderPathReturnValues::FontUnintelligible; + break; +#endif + case GL_INVALID_ENUM: + case GL_INVALID_VALUE: + returnValue = NVRenderPathReturnValues::InvalidEnum; + break; + case GL_OUT_OF_MEMORY: + returnValue = NVRenderPathReturnValues::OutOfMemory; + break; + default: + QT3DS_ASSERT(false); + returnValue = NVRenderPathReturnValues::FontTargetUnavailable; + break; + } + + return returnValue; + } + + static GLenum fromPathMissingGlyphsToGL(NVRenderPathMissingGlyphs::Enum inHandleGlyphs) + { + GLenum glMissingGlyphs; + + switch (inHandleGlyphs) { +#if !defined(QT_OPENGL_ES) + case NVRenderPathMissingGlyphs::SkipMissing: + glMissingGlyphs = GL_SKIP_MISSING_GLYPH_NV; + break; + case NVRenderPathMissingGlyphs::UseMissing: + glMissingGlyphs = GL_USE_MISSING_GLYPH_NV; + break; +#endif + default: + QT3DS_ASSERT(false); + break; + } + + return glMissingGlyphs; + } + + static GLenum fromPathListModeToGL(NVRenderPathListMode::Enum inListMode) + { + GLenum glListMode; + + switch (inListMode) { +#if !defined(QT_OPENGL_ES) + case NVRenderPathListMode::AccumAdjacentPairs: + glListMode = GL_ACCUM_ADJACENT_PAIRS_NV; + break; + case NVRenderPathListMode::AdjacentPairs: + glListMode = GL_ADJACENT_PAIRS_NV; + break; + case NVRenderPathListMode::FirstToRest: + glListMode = GL_FIRST_TO_REST_NV; + break; +#endif + default: + QT3DS_ASSERT(false); + break; + } + + return glListMode; + } + + static GLenum fromPathCoverModeToGL(NVRenderPathCoverMode::Enum inMode) + { + GLenum glCoverMode; + + switch (inMode) { +#if !defined(QT_OPENGL_ES) + case NVRenderPathCoverMode::ConvexHull: + glCoverMode = GL_CONVEX_HULL_NV; + break; + case NVRenderPathCoverMode::BoundingBox: + glCoverMode = GL_BOUNDING_BOX_NV; + break; + case NVRenderPathCoverMode::BoundingBoxOfBoundingBox: + glCoverMode = GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV; + break; + case NVRenderPathCoverMode::PathFillCover: + glCoverMode = GL_PATH_FILL_COVER_MODE_NV; + break; + case NVRenderPathCoverMode::PathStrokeCover: + glCoverMode = GL_PATH_STROKE_COVER_MODE_NV; + break; +#endif + default: + QT3DS_ASSERT(false); + break; + } + + return glCoverMode; + } + + static GLenum fromPathTypeToGL(NVRenderPathFormatType::Enum value) + { + switch (value) { + case NVRenderPathFormatType::Byte: + return GL_BYTE; + case NVRenderPathFormatType::UByte: + return GL_UNSIGNED_BYTE; + case NVRenderPathFormatType::Short: + return GL_SHORT; + case NVRenderPathFormatType::UShort: + return GL_UNSIGNED_SHORT; + case NVRenderPathFormatType::Int: + return GL_INT; + case NVRenderPathFormatType::Uint: + return GL_UNSIGNED_INT; +#if !defined(QT_OPENGL_ES) + case NVRenderPathFormatType::Bytes2: + return GL_2_BYTES_NV; + case NVRenderPathFormatType::Bytes3: + return GL_3_BYTES_NV; + case NVRenderPathFormatType::Bytes4: + return GL_4_BYTES_NV; + case NVRenderPathFormatType::Utf8: + return GL_UTF8_NV; + case NVRenderPathFormatType::Utf16: + return GL_UTF16_NV; +#endif + default: + break; + } + QT3DS_ASSERT(false); + return GL_UNSIGNED_BYTE; + } + + static GLbitfield fromPathFontStyleToGL(NVRenderPathFontStyleFlags flags) + { + QT3DSU32 value = flags; + GLbitfield retval = 0; +#if !defined(QT_OPENGL_ES) + if (value & NVRenderPathFontStyleValues::Bold) + retval |= GL_BOLD_BIT_NV; + if (value & NVRenderPathFontStyleValues::Italic) + retval |= GL_ITALIC_BIT_NV; +#endif + QT3DS_ASSERT(retval || !value); + return retval; + } + + static GLenum fromPathTransformToGL(NVRenderPathTransformType::Enum value) + { + switch (value) { + case NVRenderPathTransformType::NoTransform: + return GL_NONE; +#if !defined(QT_OPENGL_ES) + case NVRenderPathTransformType::TranslateX: + return GL_TRANSLATE_X_NV; + case NVRenderPathTransformType::TranslateY: + return GL_TRANSLATE_Y_NV; + case NVRenderPathTransformType::Translate2D: + return GL_TRANSLATE_2D_NV; + case NVRenderPathTransformType::Translate3D: + return GL_TRANSLATE_3D_NV; + case NVRenderPathTransformType::Affine2D: + return GL_AFFINE_2D_NV; + case NVRenderPathTransformType::Affine3D: + return GL_AFFINE_3D_NV; + case NVRenderPathTransformType::TransposeAffine2D: + return GL_TRANSPOSE_AFFINE_2D_NV; + case NVRenderPathTransformType::TransposeAffine3D: + return GL_TRANSPOSE_AFFINE_3D_NV; +#endif + default: + break; + } + QT3DS_ASSERT(false); + return GL_UNSIGNED_BYTE; + } + + static GLbitfield fromPathMetricQueryFlagsToGL(NVRenderPathGlyphFontMetricFlags flags) + { + QT3DSU32 value = flags; + GLbitfield retval = 0; +#if !defined(QT_OPENGL_ES) + if (value & NVRenderPathGlyphFontMetricValues::GlyphWidth) + retval |= GL_GLYPH_WIDTH_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::GlyphHeight) + retval |= GL_GLYPH_HEIGHT_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::GlyphHorizontalBearingX) + retval |= GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::GlyphHorizontalBearingY) + retval |= GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::GlyphHorizontalBearingAdvance) + retval |= GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::GlyphVerticalBearingX) + retval |= GL_GLYPH_VERTICAL_BEARING_X_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::GlyphVerticalBearingY) + retval |= GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::GlyphVerticalBearingAdvance) + retval |= GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::GlyphHasKerning) + retval |= GL_GLYPH_HAS_KERNING_BIT_NV; + + if (value & NVRenderPathGlyphFontMetricValues::FontXMinBounds) + retval |= GL_FONT_X_MIN_BOUNDS_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontYMinBounds) + retval |= GL_FONT_Y_MIN_BOUNDS_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontXMaxBounds) + retval |= GL_FONT_X_MAX_BOUNDS_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontYMaxBounds) + retval |= GL_FONT_Y_MAX_BOUNDS_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontUnitsPerEm) + retval |= GL_FONT_UNITS_PER_EM_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontAscender) + retval |= GL_FONT_ASCENDER_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontDescender) + retval |= GL_FONT_DESCENDER_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontHeight) + retval |= GL_FONT_HEIGHT_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontMaxAdvanceWidth) + retval |= GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontMaxAdvanceHeight) + retval |= GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontUnderlinePosition) + retval |= GL_FONT_UNDERLINE_POSITION_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontMaxAdvanceWidth) + retval |= GL_FONT_UNDERLINE_THICKNESS_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontHasKerning) + retval |= GL_FONT_HAS_KERNING_BIT_NV; + if (value & NVRenderPathGlyphFontMetricValues::FontNumGlyphIndices) + retval |= GL_FONT_NUM_GLYPH_INDICES_BIT_NV; +#endif + QT3DS_ASSERT(retval || !value); + return retval; + } + }; +} +} + +#endif // QT3DSOPENGLUTIL_H |