1301 lines
37 KiB
C++
1301 lines
37 KiB
C++
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES Utilities
|
|
* ------------------------------------------------
|
|
*
|
|
* Copyright 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*//*!
|
|
* \file
|
|
* \brief Shader utilities.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "gluShaderUtil.hpp"
|
|
#include "glwEnums.hpp"
|
|
#include "deArrayUtil.hpp"
|
|
|
|
namespace glu
|
|
{
|
|
|
|
// ShadingLanguageVersion
|
|
|
|
const char* getGLSLVersionName (GLSLVersion version)
|
|
{
|
|
static const char* s_names[] =
|
|
{
|
|
"GLSL ES 1.0",
|
|
"GLSL ES 3.0",
|
|
"GLSL ES 3.1",
|
|
"GLSL ES 3.2",
|
|
"GLSL 1.3",
|
|
"GLSL 1.4",
|
|
"GLSL 1.5",
|
|
"GLSL 3.3",
|
|
"GLSL 4.0",
|
|
"GLSL 4.1",
|
|
"GLSL 4.2",
|
|
"GLSL 4.3",
|
|
"GLSL 4.4",
|
|
"GLSL 4.5",
|
|
"GLSL 4.6",
|
|
};
|
|
|
|
return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_names, version);
|
|
}
|
|
|
|
const char* getGLSLVersionDeclaration (GLSLVersion version)
|
|
{
|
|
static const char* s_decl[] =
|
|
{
|
|
"#version 100",
|
|
"#version 300 es",
|
|
"#version 310 es",
|
|
"#version 320 es",
|
|
"#version 130",
|
|
"#version 140",
|
|
"#version 150",
|
|
"#version 330",
|
|
"#version 400",
|
|
"#version 410",
|
|
"#version 420",
|
|
"#version 430",
|
|
"#version 440",
|
|
"#version 450",
|
|
"#version 460",
|
|
};
|
|
|
|
return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_decl, version);
|
|
}
|
|
|
|
bool glslVersionUsesInOutQualifiers (GLSLVersion version)
|
|
{
|
|
return de::inRange<int>(version, GLSL_VERSION_300_ES, GLSL_VERSION_320_ES) || de::inRange<int>(version, GLSL_VERSION_330, GLSL_VERSION_460);
|
|
}
|
|
|
|
bool glslVersionIsES (GLSLVersion version)
|
|
{
|
|
DE_STATIC_ASSERT(GLSL_VERSION_LAST == 15);
|
|
DE_ASSERT(version != GLSL_VERSION_LAST);
|
|
|
|
if (version == GLSL_VERSION_100_ES ||
|
|
version == GLSL_VERSION_300_ES ||
|
|
version == GLSL_VERSION_310_ES ||
|
|
version == GLSL_VERSION_320_ES)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
// \todo [2014-10-06 pyry] Export this.
|
|
static ApiType getMinAPIForGLSLVersion (GLSLVersion version)
|
|
{
|
|
static const ApiType s_minApi[] =
|
|
{
|
|
ApiType::es(2,0),
|
|
ApiType::es(3,0),
|
|
ApiType::es(3,1),
|
|
ApiType::es(3,2),
|
|
ApiType::core(3,0),
|
|
ApiType::core(3,1),
|
|
ApiType::core(3,2),
|
|
ApiType::core(3,3),
|
|
ApiType::core(4,0),
|
|
ApiType::core(4,1),
|
|
ApiType::core(4,2),
|
|
ApiType::core(4,3),
|
|
ApiType::core(4,4),
|
|
ApiType::core(4,5),
|
|
ApiType::core(4,6),
|
|
};
|
|
|
|
return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_minApi, version);
|
|
}
|
|
|
|
bool isGLSLVersionSupported (ContextType type, GLSLVersion version)
|
|
{
|
|
return contextSupports(type, getMinAPIForGLSLVersion(version));
|
|
}
|
|
|
|
GLSLVersion getContextTypeGLSLVersion (ContextType type)
|
|
{
|
|
// \note From newer to older
|
|
for (int version = GLSL_VERSION_LAST-1; version >= 0; version--)
|
|
{
|
|
if (isGLSLVersionSupported(type, GLSLVersion(version)))
|
|
return GLSLVersion(version);
|
|
}
|
|
|
|
DE_ASSERT(false);
|
|
return GLSL_VERSION_LAST;
|
|
}
|
|
|
|
// ShaderType
|
|
|
|
const char* getShaderTypeName (ShaderType shaderType)
|
|
{
|
|
static const char* s_names[] =
|
|
{
|
|
"vertex",
|
|
"fragment",
|
|
"geometry",
|
|
"tess_control",
|
|
"tess_eval",
|
|
"compute",
|
|
"ray_gen",
|
|
"any_hit",
|
|
"closest_hit",
|
|
"miss",
|
|
"intersection",
|
|
"callable",
|
|
};
|
|
|
|
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == SHADERTYPE_LAST);
|
|
DE_ASSERT(deInBounds32((int)shaderType, 0, SHADERTYPE_LAST));
|
|
return s_names[(int)shaderType];
|
|
}
|
|
|
|
std::string getShaderTypePostfix (ShaderType shaderType)
|
|
{
|
|
return "_" + std::string(getShaderTypeName(shaderType));
|
|
}
|
|
|
|
// Precision
|
|
|
|
const char* getPrecisionName (Precision precision)
|
|
{
|
|
static const char* s_names[] =
|
|
{
|
|
"lowp",
|
|
"mediump",
|
|
"highp"
|
|
};
|
|
|
|
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == PRECISION_LAST);
|
|
DE_ASSERT(deInBounds32((int)precision, 0, PRECISION_LAST));
|
|
return s_names[(int)precision];
|
|
}
|
|
|
|
std::string getPrecisionPostfix (Precision precision)
|
|
{
|
|
return "_" + std::string(getPrecisionName(precision));
|
|
}
|
|
|
|
// DataType
|
|
|
|
const char* getDataTypeName (DataType dataType)
|
|
{
|
|
static const char* s_names[] =
|
|
{
|
|
"invalid",
|
|
"float",
|
|
"vec2",
|
|
"vec3",
|
|
"vec4",
|
|
"mat2",
|
|
"mat2x3",
|
|
"mat2x4",
|
|
"mat3x2",
|
|
"mat3",
|
|
"mat3x4",
|
|
"mat4x2",
|
|
"mat4x3",
|
|
"mat4",
|
|
"double",
|
|
"dvec2",
|
|
"dvec3",
|
|
"dvec4",
|
|
"dmat2",
|
|
"dmat2x3",
|
|
"dmat2x4",
|
|
"dmat3x2",
|
|
"dmat3",
|
|
"dmat3x4",
|
|
"dmat4x2",
|
|
"dmat4x3",
|
|
"dmat4",
|
|
"int",
|
|
"ivec2",
|
|
"ivec3",
|
|
"ivec4",
|
|
"uint",
|
|
"uvec2",
|
|
"uvec3",
|
|
"uvec4",
|
|
"bool",
|
|
"bvec2",
|
|
"bvec3",
|
|
"bvec4",
|
|
"sampler1D",
|
|
"sampler2D",
|
|
"samplerCube",
|
|
"sampler1DArray",
|
|
"sampler2DArray",
|
|
"sampler3D",
|
|
"samplerCubeArray",
|
|
"sampler1DShadow",
|
|
"sampler2DShadow",
|
|
"samplerCubeShadow",
|
|
"sampler1DArrayShadow",
|
|
"sampler2DArrayShadow",
|
|
"samplerCubeArrayShadow",
|
|
"isampler1D",
|
|
"isampler2D",
|
|
"isamplerCube",
|
|
"isampler1DArray",
|
|
"isampler2DArray",
|
|
"isampler3D",
|
|
"isamplerCubeArray",
|
|
"usampler1D",
|
|
"usampler2D",
|
|
"usamplerCube",
|
|
"usampler1DArray",
|
|
"usampler2DArray",
|
|
"usampler3D",
|
|
"usamplerCubeArray",
|
|
"sampler2DMS",
|
|
"isampler2DMS",
|
|
"usampler2DMS",
|
|
"image2D",
|
|
"imageCube",
|
|
"image2DArray",
|
|
"image3D",
|
|
"imageCubeArray",
|
|
"iimage2D",
|
|
"iimageCube",
|
|
"iimage2DArray",
|
|
"iimage3D",
|
|
"iimageCubeArray",
|
|
"uimage2D",
|
|
"uimageCube",
|
|
"uimage2DArray",
|
|
"uimage3D",
|
|
"uimageCubeArray",
|
|
"atomic_uint",
|
|
"samplerBuffer",
|
|
"isamplerBuffer",
|
|
"usamplerBuffer",
|
|
"sampler2DMSArray",
|
|
"isampler2DMSArray",
|
|
"usampler2DMSArray",
|
|
"imageBuffer",
|
|
"iimageBuffer",
|
|
"uimageBuffer",
|
|
"uint8_t",
|
|
"u8vec2",
|
|
"u8vec3",
|
|
"u8vec4",
|
|
"int8_t",
|
|
"i8vec2",
|
|
"i8vec3",
|
|
"i8vec4",
|
|
"uint16_t",
|
|
"u16vec2",
|
|
"u16vec3",
|
|
"u16vec4",
|
|
"int16_t",
|
|
"i16vec2",
|
|
"i16vec3",
|
|
"i16vec4",
|
|
"float16_t",
|
|
"f16vec2",
|
|
"f16vec3",
|
|
"f16vec4",
|
|
"f16mat2",
|
|
"f16mat2x3",
|
|
"f16mat2x4",
|
|
"f16mat3x2",
|
|
"f16mat3",
|
|
"f16mat3x4",
|
|
"f16mat4x2",
|
|
"f16mat4x3",
|
|
"f16mat4",
|
|
};
|
|
|
|
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == TYPE_LAST);
|
|
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_names)));
|
|
return s_names[(int)dataType];
|
|
}
|
|
|
|
int getDataTypeScalarSize (DataType dataType)
|
|
{
|
|
static const int s_sizes[] =
|
|
{
|
|
-1, // invalid
|
|
1, // float
|
|
2, // vec2
|
|
3, // vec3
|
|
4, // vec4
|
|
4, // mat2
|
|
6, // mat2x3
|
|
8, // mat2x4
|
|
6, // mat3x2
|
|
9, // mat3
|
|
12, // mat3x4
|
|
8, // mat4x2
|
|
12, // mat4x3
|
|
16, // mat4
|
|
1, // double
|
|
2, // dvec2
|
|
3, // dvec3
|
|
4, // dvec4
|
|
4, // dmat2
|
|
6, // dmat2x3
|
|
8, // dmat2x4
|
|
6, // dmat3x2
|
|
9, // dmat3
|
|
12, // dmat3x4
|
|
8, // dmat4x2
|
|
12, // dmat4x3
|
|
16, // dmat4
|
|
1, // int
|
|
2, // ivec2
|
|
3, // ivec3
|
|
4, // ivec4
|
|
1, // uint
|
|
2, // uvec2
|
|
3, // uvec3
|
|
4, // uvec4
|
|
1, // bool
|
|
2, // bvec2
|
|
3, // bvec3
|
|
4, // bvec4
|
|
1, // sampler1D
|
|
1, // sampler2D
|
|
1, // samplerCube
|
|
1, // sampler1DArray
|
|
1, // sampler2DArray
|
|
1, // sampler3D
|
|
1, // samplerCubeArray
|
|
1, // sampler1DShadow
|
|
1, // sampler2DShadow
|
|
1, // samplerCubeShadow
|
|
1, // sampler1DArrayShadow
|
|
1, // sampler2DArrayShadow
|
|
1, // samplerCubeArrayShadow
|
|
1, // isampler1D
|
|
1, // isampler2D
|
|
1, // isamplerCube
|
|
1, // isampler1DArray
|
|
1, // isampler2DArray
|
|
1, // isampler3D
|
|
1, // isamplerCubeArray
|
|
1, // usampler1D
|
|
1, // usampler2D
|
|
1, // usamplerCube
|
|
1, // usampler1DArray
|
|
1, // usampler2DArray
|
|
1, // usampler3D
|
|
1, // usamplerCubeArray
|
|
1, // sampler2DMS
|
|
1, // isampler2DMS
|
|
1, // usampler2DMS
|
|
1, // image2D
|
|
1, // imageCube
|
|
1, // image2DArray
|
|
1, // image3D
|
|
1, // imageCubeArray
|
|
1, // iimage2D
|
|
1, // iimageCube
|
|
1, // iimage2DArray
|
|
1, // iimage3D
|
|
1, // iimageCubeArray
|
|
1, // uimage2D
|
|
1, // uimageCube
|
|
1, // uimage2DArray
|
|
1, // uimage3D
|
|
1, // uimageCubeArray
|
|
1, // atomic_uint
|
|
1, // samplerBuffer
|
|
1, // isamplerBuffer
|
|
1, // usamplerBuffer
|
|
1, // sampler2DMSArray
|
|
1, // isampler2DMSArray
|
|
1, // usampler2DMSArray
|
|
1, // imageBuffer
|
|
1, // iimageBuffer
|
|
1, // uimageBuffer
|
|
1, // uint8_t
|
|
2, // u8vec2
|
|
3, // u8vec3
|
|
4, // u8vec4
|
|
1, // int8_t
|
|
2, // i8vec2
|
|
3, // i8vec3
|
|
4, // i8vec4
|
|
1, // uint16_t
|
|
2, // u16vec2
|
|
3, // u16vec3
|
|
4, // u16vec4
|
|
1, // int16_t
|
|
2, // i16vec2
|
|
3, // i16vec3
|
|
4, // i16vec4
|
|
1, // float16_t
|
|
2, // f16vec2
|
|
3, // f16vec3
|
|
4, // f16vec4
|
|
4, // f16mat2
|
|
6, // f16mat2x3
|
|
8, // f16mat2x4
|
|
6, // f16mat3x2
|
|
9, // f16mat3
|
|
12, // f16mat3x4
|
|
8, // f16mat4x2
|
|
12, // f16mat4x3
|
|
16, // f16mat4
|
|
};
|
|
|
|
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_sizes) == TYPE_LAST);
|
|
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_sizes)));
|
|
return s_sizes[(int)dataType];
|
|
}
|
|
|
|
DataType getDataTypeScalarType (DataType dataType)
|
|
{
|
|
static const DataType s_scalarTypes[] =
|
|
{
|
|
TYPE_INVALID, // invalid
|
|
TYPE_FLOAT, // float
|
|
TYPE_FLOAT, // vec2
|
|
TYPE_FLOAT, // vec3
|
|
TYPE_FLOAT, // vec4
|
|
TYPE_FLOAT, // mat2
|
|
TYPE_FLOAT, // mat2x3
|
|
TYPE_FLOAT, // mat2x4
|
|
TYPE_FLOAT, // mat3x2
|
|
TYPE_FLOAT, // mat3
|
|
TYPE_FLOAT, // mat3x4
|
|
TYPE_FLOAT, // mat4x2
|
|
TYPE_FLOAT, // mat4x3
|
|
TYPE_FLOAT, // mat4
|
|
TYPE_DOUBLE, // double
|
|
TYPE_DOUBLE, // dvec2
|
|
TYPE_DOUBLE, // dvec3
|
|
TYPE_DOUBLE, // dvec4
|
|
TYPE_DOUBLE, // dmat2
|
|
TYPE_DOUBLE, // dmat2x3
|
|
TYPE_DOUBLE, // dmat2x4
|
|
TYPE_DOUBLE, // dmat3x2
|
|
TYPE_DOUBLE, // dmat3
|
|
TYPE_DOUBLE, // dmat3x4
|
|
TYPE_DOUBLE, // dmat4x2
|
|
TYPE_DOUBLE, // dmat4x3
|
|
TYPE_DOUBLE, // dmat4
|
|
TYPE_INT, // int
|
|
TYPE_INT, // ivec2
|
|
TYPE_INT, // ivec3
|
|
TYPE_INT, // ivec4
|
|
TYPE_UINT, // uint
|
|
TYPE_UINT, // uvec2
|
|
TYPE_UINT, // uvec3
|
|
TYPE_UINT, // uvec4
|
|
TYPE_BOOL, // bool
|
|
TYPE_BOOL, // bvec2
|
|
TYPE_BOOL, // bvec3
|
|
TYPE_BOOL, // bvec4
|
|
TYPE_SAMPLER_1D, // sampler1D
|
|
TYPE_SAMPLER_2D, // sampler2D
|
|
TYPE_SAMPLER_CUBE, // samplerCube
|
|
TYPE_SAMPLER_1D_ARRAY, // sampler1DArray
|
|
TYPE_SAMPLER_2D_ARRAY, // sampler2DArray
|
|
TYPE_SAMPLER_3D, // sampler3D
|
|
TYPE_SAMPLER_CUBE_ARRAY, // samplerCubeArray
|
|
TYPE_SAMPLER_1D_SHADOW, // sampler1DShadow
|
|
TYPE_SAMPLER_2D_SHADOW, // sampler2DShadow
|
|
TYPE_SAMPLER_CUBE_SHADOW, // samplerCubeShadow
|
|
TYPE_SAMPLER_1D_ARRAY_SHADOW, // sampler1DArrayShadow
|
|
TYPE_SAMPLER_2D_ARRAY_SHADOW, // sampler2DArrayShadow
|
|
TYPE_SAMPLER_CUBE_ARRAY_SHADOW, // samplerCubeArrayShadow
|
|
TYPE_INT_SAMPLER_1D, // isampler1D
|
|
TYPE_INT_SAMPLER_2D, // isampler2D
|
|
TYPE_INT_SAMPLER_CUBE, // isamplerCube
|
|
TYPE_INT_SAMPLER_1D_ARRAY, // isampler1DArray
|
|
TYPE_INT_SAMPLER_2D_ARRAY, // isampler2DArray
|
|
TYPE_INT_SAMPLER_3D, // isampler3D
|
|
TYPE_INT_SAMPLER_CUBE_ARRAY, // isamplerCubeArray
|
|
TYPE_UINT_SAMPLER_1D, // usampler1D
|
|
TYPE_UINT_SAMPLER_2D, // usampler2D
|
|
TYPE_UINT_SAMPLER_CUBE, // usamplerCube
|
|
TYPE_UINT_SAMPLER_1D_ARRAY, // usampler1DArray
|
|
TYPE_UINT_SAMPLER_2D_ARRAY, // usampler2DArray
|
|
TYPE_UINT_SAMPLER_3D, // usampler3D
|
|
TYPE_UINT_SAMPLER_CUBE_ARRAY, // usamplerCubeArray
|
|
TYPE_SAMPLER_2D_MULTISAMPLE, // sampler2DMS
|
|
TYPE_INT_SAMPLER_2D_MULTISAMPLE, // isampler2DMS
|
|
TYPE_UINT_SAMPLER_2D_MULTISAMPLE, // usampler2DMS
|
|
TYPE_IMAGE_2D, // image2D
|
|
TYPE_IMAGE_CUBE, // imageCube
|
|
TYPE_IMAGE_2D_ARRAY, // image2DArray
|
|
TYPE_IMAGE_3D, // image3D
|
|
TYPE_IMAGE_CUBE_ARRAY, // imageCubeArray
|
|
TYPE_INT_IMAGE_2D, // iimage2D
|
|
TYPE_INT_IMAGE_CUBE, // iimageCube
|
|
TYPE_INT_IMAGE_2D_ARRAY, // iimage2DArray
|
|
TYPE_INT_IMAGE_3D, // iimage3D
|
|
TYPE_INT_IMAGE_CUBE_ARRAY, // iimageCubeArray
|
|
TYPE_UINT_IMAGE_2D, // uimage2D
|
|
TYPE_UINT_IMAGE_CUBE, // uimageCube
|
|
TYPE_UINT_IMAGE_2D_ARRAY, // uimage2DArray
|
|
TYPE_UINT_IMAGE_3D, // uimage3D
|
|
TYPE_UINT_IMAGE_CUBE_ARRAY, // uimageCubeArray
|
|
TYPE_UINT_ATOMIC_COUNTER, // atomic_uint
|
|
TYPE_SAMPLER_BUFFER, // samplerBuffer
|
|
TYPE_INT_SAMPLER_BUFFER, // isamplerBuffer
|
|
TYPE_UINT_SAMPLER_BUFFER, // usamplerBuffer
|
|
TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY, // sampler2DMSArray
|
|
TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, // isampler2DMSArray
|
|
TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY, // usampler2DMSArray
|
|
TYPE_IMAGE_BUFFER, // imageBuffer
|
|
TYPE_INT_IMAGE_BUFFER, // iimageBuffer
|
|
TYPE_UINT_IMAGE_BUFFER, // uimageBuffer
|
|
TYPE_UINT8, // uint8_t
|
|
TYPE_UINT8, // u8vec2
|
|
TYPE_UINT8, // u8vec3
|
|
TYPE_UINT8, // u8vec4
|
|
TYPE_INT8, // int8_t
|
|
TYPE_INT8, // i8vec2
|
|
TYPE_INT8, // i8vec3
|
|
TYPE_INT8, // i8vec4
|
|
TYPE_UINT16, // uint16_t
|
|
TYPE_UINT16, // u16vec2
|
|
TYPE_UINT16, // u16vec3
|
|
TYPE_UINT16, // u16vec4
|
|
TYPE_INT16, // int16_t
|
|
TYPE_INT16, // i16vec2
|
|
TYPE_INT16, // i16vec3
|
|
TYPE_INT16, // i16vec4
|
|
TYPE_FLOAT16, // float16_t
|
|
TYPE_FLOAT16, // f16vec2
|
|
TYPE_FLOAT16, // f16vec3
|
|
TYPE_FLOAT16, // f16vec4
|
|
TYPE_FLOAT16, // f16mat2
|
|
TYPE_FLOAT16, // f16mat2x3
|
|
TYPE_FLOAT16, // f16mat2x4
|
|
TYPE_FLOAT16, // f16mat3x2
|
|
TYPE_FLOAT16, // f16mat3
|
|
TYPE_FLOAT16, // f16mat3x4
|
|
TYPE_FLOAT16, // f16mat4x2
|
|
TYPE_FLOAT16, // f16mat4x3
|
|
TYPE_FLOAT16, // f16mat4
|
|
};
|
|
|
|
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_scalarTypes) == TYPE_LAST);
|
|
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_scalarTypes)));
|
|
return s_scalarTypes[(int)dataType];
|
|
}
|
|
|
|
DataType getDataTypeFloat16Scalars (DataType dataType)
|
|
{
|
|
static const DataType s_floatTypes[] =
|
|
{
|
|
TYPE_INVALID, // invalid
|
|
TYPE_FLOAT16, // float
|
|
TYPE_FLOAT16_VEC2, // vec2
|
|
TYPE_FLOAT16_VEC3, // vec3
|
|
TYPE_FLOAT16_VEC4, // vec4
|
|
TYPE_FLOAT16_MAT2, // mat2
|
|
TYPE_FLOAT16_MAT2X3, // mat2x3
|
|
TYPE_FLOAT16_MAT2X4, // mat2x4
|
|
TYPE_FLOAT16_MAT3X2, // mat3x2
|
|
TYPE_FLOAT16_MAT3, // mat3
|
|
TYPE_FLOAT16_MAT3X4, // mat3x4
|
|
TYPE_FLOAT16_MAT4X2, // mat4x2
|
|
TYPE_FLOAT16_MAT4X3, // mat4x3
|
|
TYPE_FLOAT16_MAT4, // mat4
|
|
TYPE_FLOAT16, // double
|
|
TYPE_FLOAT16_VEC2, // dvec2
|
|
TYPE_FLOAT16_VEC3, // dvec3
|
|
TYPE_FLOAT16_VEC4, // dvec4
|
|
TYPE_FLOAT16_MAT2, // dmat2
|
|
TYPE_FLOAT16_MAT2X3, // dmat2x3
|
|
TYPE_FLOAT16_MAT2X4, // dmat2x4
|
|
TYPE_FLOAT16_MAT3X2, // dmat3x2
|
|
TYPE_FLOAT16_MAT3, // dmat3
|
|
TYPE_FLOAT16_MAT3X4, // dmat3x4
|
|
TYPE_FLOAT16_MAT4X2, // dmat4x2
|
|
TYPE_FLOAT16_MAT4X3, // dmat4x3
|
|
TYPE_FLOAT16_MAT4, // dmat4
|
|
TYPE_FLOAT16, // int
|
|
TYPE_FLOAT16_VEC2, // ivec2
|
|
TYPE_FLOAT16_VEC3, // ivec3
|
|
TYPE_FLOAT16_VEC4, // ivec4
|
|
TYPE_FLOAT16, // uint
|
|
TYPE_FLOAT16_VEC2, // uvec2
|
|
TYPE_FLOAT16_VEC3, // uvec3
|
|
TYPE_FLOAT16_VEC4, // uvec4
|
|
TYPE_FLOAT16, // bool
|
|
TYPE_FLOAT16_VEC2, // bvec2
|
|
TYPE_FLOAT16_VEC3, // bvec3
|
|
TYPE_FLOAT16_VEC4, // bvec4
|
|
TYPE_INVALID, // sampler1D
|
|
TYPE_INVALID, // sampler2D
|
|
TYPE_INVALID, // samplerCube
|
|
TYPE_INVALID, // sampler1DArray
|
|
TYPE_INVALID, // sampler2DArray
|
|
TYPE_INVALID, // sampler3D
|
|
TYPE_INVALID, // samplerCubeArray
|
|
TYPE_INVALID, // sampler1DShadow
|
|
TYPE_INVALID, // sampler2DShadow
|
|
TYPE_INVALID, // samplerCubeShadow
|
|
TYPE_INVALID, // sampler1DArrayShadow
|
|
TYPE_INVALID, // sampler2DArrayShadow
|
|
TYPE_INVALID, // samplerCubeArrayShadow
|
|
TYPE_INVALID, // isampler1D
|
|
TYPE_INVALID, // isampler2D
|
|
TYPE_INVALID, // isamplerCube
|
|
TYPE_INVALID, // isampler1DArray
|
|
TYPE_INVALID, // isampler2DArray
|
|
TYPE_INVALID, // isampler3D
|
|
TYPE_INVALID, // isamplerCubeArray
|
|
TYPE_INVALID, // usampler1D
|
|
TYPE_INVALID, // usampler2D
|
|
TYPE_INVALID, // usamplerCube
|
|
TYPE_INVALID, // usampler1DArray
|
|
TYPE_INVALID, // usampler2DArray
|
|
TYPE_INVALID, // usampler3D
|
|
TYPE_INVALID, // usamplerCubeArray
|
|
TYPE_INVALID, // sampler2DMS
|
|
TYPE_INVALID, // isampler2DMS
|
|
TYPE_INVALID, // usampler2DMS
|
|
TYPE_INVALID, // image2D
|
|
TYPE_INVALID, // imageCube
|
|
TYPE_INVALID, // image2DArray
|
|
TYPE_INVALID, // image3D
|
|
TYPE_INVALID, // imageCubeArray
|
|
TYPE_INVALID, // iimage2D
|
|
TYPE_INVALID, // iimageCube
|
|
TYPE_INVALID, // iimage2DArray
|
|
TYPE_INVALID, // iimage3D
|
|
TYPE_INVALID, // iimageCubeArray
|
|
TYPE_INVALID, // uimage2D
|
|
TYPE_INVALID, // uimageCube
|
|
TYPE_INVALID, // uimage2DArray
|
|
TYPE_INVALID, // uimage3D
|
|
TYPE_INVALID, // uimageCubeArray
|
|
TYPE_INVALID, // atomic_uint
|
|
TYPE_INVALID, // samplerBuffer
|
|
TYPE_INVALID, // isamplerBuffer
|
|
TYPE_INVALID, // usamplerBuffer
|
|
TYPE_INVALID, // sampler2DMSArray
|
|
TYPE_INVALID, // isampler2DMSArray
|
|
TYPE_INVALID, // usampler2DMSArray
|
|
TYPE_INVALID, // imageBuffer
|
|
TYPE_INVALID, // iimageBuffer
|
|
TYPE_INVALID, // uimageBuffer
|
|
TYPE_FLOAT16, // uint8_t
|
|
TYPE_FLOAT16_VEC2, // u8vec2
|
|
TYPE_FLOAT16_VEC3, // u8vec3
|
|
TYPE_FLOAT16_VEC4, // u8vec4
|
|
TYPE_FLOAT16, // int8_t
|
|
TYPE_FLOAT16_VEC2, // i8vec2
|
|
TYPE_FLOAT16_VEC3, // i8vec3
|
|
TYPE_FLOAT16_VEC4, // i8vec4
|
|
TYPE_FLOAT16, // uint16_t
|
|
TYPE_FLOAT16_VEC2, // u16vec2
|
|
TYPE_FLOAT16_VEC3, // u16vec3
|
|
TYPE_FLOAT16_VEC4, // u16vec4
|
|
TYPE_FLOAT16, // int16_t
|
|
TYPE_FLOAT16_VEC2, // i16vec2
|
|
TYPE_FLOAT16_VEC3, // i16vec3
|
|
TYPE_FLOAT16_VEC4, // i16vec4
|
|
TYPE_FLOAT16, // float16_t
|
|
TYPE_FLOAT16_VEC2, // f16vec2
|
|
TYPE_FLOAT16_VEC3, // f16vec3
|
|
TYPE_FLOAT16_VEC4, // f16vec4
|
|
TYPE_FLOAT16_MAT2, // f16mat2
|
|
TYPE_FLOAT16_MAT2X3, // f16mat2x3
|
|
TYPE_FLOAT16_MAT2X4, // f16mat2x4
|
|
TYPE_FLOAT16_MAT3X2, // f16mat3x2
|
|
TYPE_FLOAT16_MAT3, // f16mat3
|
|
TYPE_FLOAT16_MAT3X4, // f16mat3x4
|
|
TYPE_FLOAT16_MAT4X2, // f16mat4x2
|
|
TYPE_FLOAT16_MAT4X3, // f16mat4x3
|
|
TYPE_FLOAT16_MAT4, // f16mat4
|
|
};
|
|
|
|
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
|
|
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
|
|
return s_floatTypes[(int)dataType];
|
|
}
|
|
|
|
DataType getDataTypeFloatScalars (DataType dataType)
|
|
{
|
|
static const DataType s_floatTypes[] =
|
|
{
|
|
TYPE_INVALID, // invalid
|
|
TYPE_FLOAT, // float
|
|
TYPE_FLOAT_VEC2, // vec2
|
|
TYPE_FLOAT_VEC3, // vec3
|
|
TYPE_FLOAT_VEC4, // vec4
|
|
TYPE_FLOAT_MAT2, // mat2
|
|
TYPE_FLOAT_MAT2X3, // mat2x3
|
|
TYPE_FLOAT_MAT2X4, // mat2x4
|
|
TYPE_FLOAT_MAT3X2, // mat3x2
|
|
TYPE_FLOAT_MAT3, // mat3
|
|
TYPE_FLOAT_MAT3X4, // mat3x4
|
|
TYPE_FLOAT_MAT4X2, // mat4x2
|
|
TYPE_FLOAT_MAT4X3, // mat4x3
|
|
TYPE_FLOAT_MAT4, // mat4
|
|
TYPE_FLOAT, // double
|
|
TYPE_FLOAT_VEC2, // dvec2
|
|
TYPE_FLOAT_VEC3, // dvec3
|
|
TYPE_FLOAT_VEC4, // dvec4
|
|
TYPE_FLOAT_MAT2, // dmat2
|
|
TYPE_FLOAT_MAT2X3, // dmat2x3
|
|
TYPE_FLOAT_MAT2X4, // dmat2x4
|
|
TYPE_FLOAT_MAT3X2, // dmat3x2
|
|
TYPE_FLOAT_MAT3, // dmat3
|
|
TYPE_FLOAT_MAT3X4, // dmat3x4
|
|
TYPE_FLOAT_MAT4X2, // dmat4x2
|
|
TYPE_FLOAT_MAT4X3, // dmat4x3
|
|
TYPE_FLOAT_MAT4, // dmat4
|
|
TYPE_FLOAT, // int
|
|
TYPE_FLOAT_VEC2, // ivec2
|
|
TYPE_FLOAT_VEC3, // ivec3
|
|
TYPE_FLOAT_VEC4, // ivec4
|
|
TYPE_FLOAT, // uint
|
|
TYPE_FLOAT_VEC2, // uvec2
|
|
TYPE_FLOAT_VEC3, // uvec3
|
|
TYPE_FLOAT_VEC4, // uvec4
|
|
TYPE_FLOAT, // bool
|
|
TYPE_FLOAT_VEC2, // bvec2
|
|
TYPE_FLOAT_VEC3, // bvec3
|
|
TYPE_FLOAT_VEC4, // bvec4
|
|
TYPE_INVALID, // sampler1D
|
|
TYPE_INVALID, // sampler2D
|
|
TYPE_INVALID, // samplerCube
|
|
TYPE_INVALID, // sampler1DArray
|
|
TYPE_INVALID, // sampler2DArray
|
|
TYPE_INVALID, // sampler3D
|
|
TYPE_INVALID, // samplerCubeArray
|
|
TYPE_INVALID, // sampler1DShadow
|
|
TYPE_INVALID, // sampler2DShadow
|
|
TYPE_INVALID, // samplerCubeShadow
|
|
TYPE_INVALID, // sampler1DArrayShadow
|
|
TYPE_INVALID, // sampler2DArrayShadow
|
|
TYPE_INVALID, // samplerCubeArrayShadow
|
|
TYPE_INVALID, // isampler1D
|
|
TYPE_INVALID, // isampler2D
|
|
TYPE_INVALID, // isamplerCube
|
|
TYPE_INVALID, // isampler1DArray
|
|
TYPE_INVALID, // isampler2DArray
|
|
TYPE_INVALID, // isampler3D
|
|
TYPE_INVALID, // isamplerCubeArray
|
|
TYPE_INVALID, // usampler1D
|
|
TYPE_INVALID, // usampler2D
|
|
TYPE_INVALID, // usamplerCube
|
|
TYPE_INVALID, // usampler1DArray
|
|
TYPE_INVALID, // usampler2DArray
|
|
TYPE_INVALID, // usampler3D
|
|
TYPE_INVALID, // usamplerCubeArray
|
|
TYPE_INVALID, // sampler2DMS
|
|
TYPE_INVALID, // isampler2DMS
|
|
TYPE_INVALID, // usampler2DMS
|
|
TYPE_INVALID, // image2D
|
|
TYPE_INVALID, // imageCube
|
|
TYPE_INVALID, // image2DArray
|
|
TYPE_INVALID, // image3D
|
|
TYPE_INVALID, // imageCubeArray
|
|
TYPE_INVALID, // iimage2D
|
|
TYPE_INVALID, // iimageCube
|
|
TYPE_INVALID, // iimage2DArray
|
|
TYPE_INVALID, // iimage3D
|
|
TYPE_INVALID, // iimageCubeArray
|
|
TYPE_INVALID, // uimage2D
|
|
TYPE_INVALID, // uimageCube
|
|
TYPE_INVALID, // uimage2DArray
|
|
TYPE_INVALID, // uimage3D
|
|
TYPE_INVALID, // uimageCubeArray
|
|
TYPE_INVALID, // atomic_uint
|
|
TYPE_INVALID, // samplerBuffer
|
|
TYPE_INVALID, // isamplerBuffer
|
|
TYPE_INVALID, // usamplerBuffer
|
|
TYPE_INVALID, // sampler2DMSArray
|
|
TYPE_INVALID, // isampler2DMSArray
|
|
TYPE_INVALID, // usampler2DMSArray
|
|
TYPE_INVALID, // imageBuffer
|
|
TYPE_INVALID, // iimageBuffer
|
|
TYPE_INVALID, // uimageBuffer
|
|
TYPE_FLOAT, // uint8_t
|
|
TYPE_FLOAT_VEC2, // u8vec2
|
|
TYPE_FLOAT_VEC3, // u8vec3
|
|
TYPE_FLOAT_VEC4, // u8vec4
|
|
TYPE_FLOAT, // int8_t
|
|
TYPE_FLOAT_VEC2, // i8vec2
|
|
TYPE_FLOAT_VEC3, // i8vec3
|
|
TYPE_FLOAT_VEC4, // i8vec4
|
|
TYPE_FLOAT, // uint16_t
|
|
TYPE_FLOAT_VEC2, // u16vec2
|
|
TYPE_FLOAT_VEC3, // u16vec3
|
|
TYPE_FLOAT_VEC4, // u16vec4
|
|
TYPE_FLOAT, // int16_t
|
|
TYPE_FLOAT_VEC2, // i16vec2
|
|
TYPE_FLOAT_VEC3, // i16vec3
|
|
TYPE_FLOAT_VEC4, // i16vec4
|
|
TYPE_FLOAT, // float16_t
|
|
TYPE_FLOAT_VEC2, // f16vec2
|
|
TYPE_FLOAT_VEC3, // f16vec3
|
|
TYPE_FLOAT_VEC4, // f16vec4
|
|
TYPE_FLOAT_MAT2, // f16mat2
|
|
TYPE_FLOAT_MAT2X3, // f16mat2x3
|
|
TYPE_FLOAT_MAT2X4, // f16mat2x4
|
|
TYPE_FLOAT_MAT3X2, // f16mat3x2
|
|
TYPE_FLOAT_MAT3, // f16mat3
|
|
TYPE_FLOAT_MAT3X4, // f16mat3x4
|
|
TYPE_FLOAT_MAT4X2, // f16mat4x2
|
|
TYPE_FLOAT_MAT4X3, // f16mat4x3
|
|
TYPE_FLOAT_MAT4, // f16mat4
|
|
};
|
|
|
|
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
|
|
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
|
|
return s_floatTypes[(int)dataType];
|
|
}
|
|
|
|
DataType getDataTypeDoubleScalars (DataType dataType)
|
|
{
|
|
static const DataType s_doubleTypes[] =
|
|
{
|
|
TYPE_INVALID, // invalid
|
|
TYPE_DOUBLE, // float
|
|
TYPE_DOUBLE_VEC2, // vec2
|
|
TYPE_DOUBLE_VEC3, // vec3
|
|
TYPE_DOUBLE_VEC4, // vec4
|
|
TYPE_DOUBLE_MAT2, // mat2
|
|
TYPE_DOUBLE_MAT2X3, // mat2x3
|
|
TYPE_DOUBLE_MAT2X4, // mat2x4
|
|
TYPE_DOUBLE_MAT3X2, // mat3x2
|
|
TYPE_DOUBLE_MAT3, // mat3
|
|
TYPE_DOUBLE_MAT3X4, // mat3x4
|
|
TYPE_DOUBLE_MAT4X2, // mat4x2
|
|
TYPE_DOUBLE_MAT4X3, // mat4x3
|
|
TYPE_DOUBLE_MAT4, // mat4
|
|
TYPE_DOUBLE, // double
|
|
TYPE_DOUBLE_VEC2, // dvec2
|
|
TYPE_DOUBLE_VEC3, // dvec3
|
|
TYPE_DOUBLE_VEC4, // dvec4
|
|
TYPE_DOUBLE_MAT2, // dmat2
|
|
TYPE_DOUBLE_MAT2X3, // dmat2x3
|
|
TYPE_DOUBLE_MAT2X4, // dmat2x4
|
|
TYPE_DOUBLE_MAT3X2, // dmat3x2
|
|
TYPE_DOUBLE_MAT3, // dmat3
|
|
TYPE_DOUBLE_MAT3X4, // dmat3x4
|
|
TYPE_DOUBLE_MAT4X2, // dmat4x2
|
|
TYPE_DOUBLE_MAT4X3, // dmat4x3
|
|
TYPE_DOUBLE_MAT4, // dmat4
|
|
TYPE_DOUBLE, // int
|
|
TYPE_DOUBLE_VEC2, // ivec2
|
|
TYPE_DOUBLE_VEC3, // ivec3
|
|
TYPE_DOUBLE_VEC4, // ivec4
|
|
TYPE_DOUBLE, // uint
|
|
TYPE_DOUBLE_VEC2, // uvec2
|
|
TYPE_DOUBLE_VEC3, // uvec3
|
|
TYPE_DOUBLE_VEC4, // uvec4
|
|
TYPE_DOUBLE, // bool
|
|
TYPE_DOUBLE_VEC2, // bvec2
|
|
TYPE_DOUBLE_VEC3, // bvec3
|
|
TYPE_DOUBLE_VEC4, // bvec4
|
|
TYPE_INVALID, // sampler1D
|
|
TYPE_INVALID, // sampler2D
|
|
TYPE_INVALID, // samplerCube
|
|
TYPE_INVALID, // sampler1DArray
|
|
TYPE_INVALID, // sampler2DArray
|
|
TYPE_INVALID, // sampler3D
|
|
TYPE_INVALID, // samplerCubeArray
|
|
TYPE_INVALID, // sampler1DShadow
|
|
TYPE_INVALID, // sampler2DShadow
|
|
TYPE_INVALID, // samplerCubeShadow
|
|
TYPE_INVALID, // sampler1DArrayShadow
|
|
TYPE_INVALID, // sampler2DArrayShadow
|
|
TYPE_INVALID, // samplerCubeArrayShadow
|
|
TYPE_INVALID, // isampler1D
|
|
TYPE_INVALID, // isampler2D
|
|
TYPE_INVALID, // isamplerCube
|
|
TYPE_INVALID, // isampler1DArray
|
|
TYPE_INVALID, // isampler2DArray
|
|
TYPE_INVALID, // isampler3D
|
|
TYPE_INVALID, // isamplerCubeArray
|
|
TYPE_INVALID, // usampler1D
|
|
TYPE_INVALID, // usampler2D
|
|
TYPE_INVALID, // usamplerCube
|
|
TYPE_INVALID, // usampler1DArray
|
|
TYPE_INVALID, // usampler2DArray
|
|
TYPE_INVALID, // usampler3D
|
|
TYPE_INVALID, // usamplerCubeArray
|
|
TYPE_INVALID, // sampler2DMS
|
|
TYPE_INVALID, // isampler2DMS
|
|
TYPE_INVALID, // usampler2DMS
|
|
TYPE_INVALID, // image2D
|
|
TYPE_INVALID, // imageCube
|
|
TYPE_INVALID, // image2DArray
|
|
TYPE_INVALID, // image3D
|
|
TYPE_INVALID, // imageCubeArray
|
|
TYPE_INVALID, // iimage2D
|
|
TYPE_INVALID, // iimageCube
|
|
TYPE_INVALID, // iimage2DArray
|
|
TYPE_INVALID, // iimage3D
|
|
TYPE_INVALID, // iimageCubeArray
|
|
TYPE_INVALID, // uimage2D
|
|
TYPE_INVALID, // uimageCube
|
|
TYPE_INVALID, // uimage2DArray
|
|
TYPE_INVALID, // uimage3D
|
|
TYPE_INVALID, // uimageCubeArray
|
|
TYPE_INVALID, // atomic_uint
|
|
TYPE_INVALID, // samplerBuffer
|
|
TYPE_INVALID, // isamplerBuffer
|
|
TYPE_INVALID, // usamplerBuffer
|
|
TYPE_INVALID, // sampler2DMSArray
|
|
TYPE_INVALID, // isampler2DMSArray
|
|
TYPE_INVALID, // usampler2DMSArray
|
|
TYPE_INVALID, // imageBuffer
|
|
TYPE_INVALID, // iimageBuffer
|
|
TYPE_INVALID, // uimageBuffer
|
|
TYPE_DOUBLE, // uint18_t
|
|
TYPE_DOUBLE_VEC2, // u8vec2
|
|
TYPE_DOUBLE_VEC3, // u8vec3
|
|
TYPE_DOUBLE_VEC4, // u8vec4
|
|
TYPE_DOUBLE, // int8_t
|
|
TYPE_DOUBLE_VEC2, // i8vec2
|
|
TYPE_DOUBLE_VEC3, // i8vec3
|
|
TYPE_DOUBLE_VEC4, // i8vec4
|
|
TYPE_DOUBLE, // uint16_t
|
|
TYPE_DOUBLE_VEC2, // u16vec2
|
|
TYPE_DOUBLE_VEC3, // u16vec3
|
|
TYPE_DOUBLE_VEC4, // u16vec4
|
|
TYPE_DOUBLE, // int16_t
|
|
TYPE_DOUBLE_VEC2, // i16vec2
|
|
TYPE_DOUBLE_VEC3, // i16vec3
|
|
TYPE_DOUBLE_VEC4, // i16vec4
|
|
TYPE_DOUBLE, // float16_t
|
|
TYPE_DOUBLE_VEC2, // f16vec2
|
|
TYPE_DOUBLE_VEC3, // f16vec3
|
|
TYPE_DOUBLE_VEC4, // f16vec4
|
|
TYPE_DOUBLE_MAT2, // f16mat2
|
|
TYPE_DOUBLE_MAT2X3, // f16mat2x3
|
|
TYPE_DOUBLE_MAT2X4, // f16mat2x4
|
|
TYPE_DOUBLE_MAT3X2, // f16mat3x2
|
|
TYPE_DOUBLE_MAT3, // f16mat3
|
|
TYPE_DOUBLE_MAT3X4, // f16mat3x4
|
|
TYPE_DOUBLE_MAT4X2, // f16mat4x2
|
|
TYPE_DOUBLE_MAT4X3, // f16mat4x3
|
|
TYPE_DOUBLE_MAT4, // f16mat4
|
|
};
|
|
|
|
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_doubleTypes) == TYPE_LAST);
|
|
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_doubleTypes)));
|
|
return s_doubleTypes[(int)dataType];
|
|
}
|
|
|
|
DataType getDataTypeVector (DataType scalarType, int size)
|
|
{
|
|
DE_ASSERT(deInRange32(size, 1, 4));
|
|
switch (scalarType)
|
|
{
|
|
case TYPE_FLOAT:
|
|
case TYPE_DOUBLE:
|
|
case TYPE_INT:
|
|
case TYPE_UINT:
|
|
case TYPE_BOOL:
|
|
case TYPE_UINT8:
|
|
case TYPE_INT8:
|
|
case TYPE_UINT16:
|
|
case TYPE_INT16:
|
|
case TYPE_FLOAT16:
|
|
return (DataType)((int)scalarType + size - 1);
|
|
default:
|
|
return TYPE_INVALID;
|
|
}
|
|
}
|
|
|
|
DataType getDataTypeFloatVec (int vecSize)
|
|
{
|
|
return getDataTypeVector(TYPE_FLOAT, vecSize);
|
|
}
|
|
|
|
DataType getDataTypeIntVec (int vecSize)
|
|
{
|
|
return getDataTypeVector(TYPE_INT, vecSize);
|
|
}
|
|
|
|
DataType getDataTypeUintVec (int vecSize)
|
|
{
|
|
return getDataTypeVector(TYPE_UINT, vecSize);
|
|
}
|
|
|
|
DataType getDataTypeBoolVec (int vecSize)
|
|
{
|
|
return getDataTypeVector(TYPE_BOOL, vecSize);
|
|
}
|
|
|
|
DataType getDataTypeMatrix (int numCols, int numRows)
|
|
{
|
|
DE_ASSERT(de::inRange(numCols, 2, 4) && de::inRange(numRows, 2, 4));
|
|
return (DataType)((int)TYPE_FLOAT_MAT2 + (numCols-2)*3 + (numRows-2));
|
|
}
|
|
|
|
int getDataTypeMatrixNumRows (DataType dataType)
|
|
{
|
|
switch (dataType)
|
|
{
|
|
case TYPE_FLOAT_MAT2: return 2;
|
|
case TYPE_FLOAT_MAT2X3: return 3;
|
|
case TYPE_FLOAT_MAT2X4: return 4;
|
|
case TYPE_FLOAT_MAT3X2: return 2;
|
|
case TYPE_FLOAT_MAT3: return 3;
|
|
case TYPE_FLOAT_MAT3X4: return 4;
|
|
case TYPE_FLOAT_MAT4X2: return 2;
|
|
case TYPE_FLOAT_MAT4X3: return 3;
|
|
case TYPE_FLOAT_MAT4: return 4;
|
|
case TYPE_DOUBLE_MAT2: return 2;
|
|
case TYPE_DOUBLE_MAT2X3: return 3;
|
|
case TYPE_DOUBLE_MAT2X4: return 4;
|
|
case TYPE_DOUBLE_MAT3X2: return 2;
|
|
case TYPE_DOUBLE_MAT3: return 3;
|
|
case TYPE_DOUBLE_MAT3X4: return 4;
|
|
case TYPE_DOUBLE_MAT4X2: return 2;
|
|
case TYPE_DOUBLE_MAT4X3: return 3;
|
|
case TYPE_DOUBLE_MAT4: return 4;
|
|
case TYPE_FLOAT16_MAT2: return 2;
|
|
case TYPE_FLOAT16_MAT2X3: return 3;
|
|
case TYPE_FLOAT16_MAT2X4: return 4;
|
|
case TYPE_FLOAT16_MAT3X2: return 2;
|
|
case TYPE_FLOAT16_MAT3: return 3;
|
|
case TYPE_FLOAT16_MAT3X4: return 4;
|
|
case TYPE_FLOAT16_MAT4X2: return 2;
|
|
case TYPE_FLOAT16_MAT4X3: return 3;
|
|
case TYPE_FLOAT16_MAT4: return 4;
|
|
default:
|
|
DE_ASSERT(false);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int getDataTypeMatrixNumColumns (DataType dataType)
|
|
{
|
|
switch (dataType)
|
|
{
|
|
case TYPE_FLOAT_MAT2: return 2;
|
|
case TYPE_FLOAT_MAT2X3: return 2;
|
|
case TYPE_FLOAT_MAT2X4: return 2;
|
|
case TYPE_FLOAT_MAT3X2: return 3;
|
|
case TYPE_FLOAT_MAT3: return 3;
|
|
case TYPE_FLOAT_MAT3X4: return 3;
|
|
case TYPE_FLOAT_MAT4X2: return 4;
|
|
case TYPE_FLOAT_MAT4X3: return 4;
|
|
case TYPE_FLOAT_MAT4: return 4;
|
|
case TYPE_DOUBLE_MAT2: return 2;
|
|
case TYPE_DOUBLE_MAT2X3: return 2;
|
|
case TYPE_DOUBLE_MAT2X4: return 2;
|
|
case TYPE_DOUBLE_MAT3X2: return 3;
|
|
case TYPE_DOUBLE_MAT3: return 3;
|
|
case TYPE_DOUBLE_MAT3X4: return 3;
|
|
case TYPE_DOUBLE_MAT4X2: return 4;
|
|
case TYPE_DOUBLE_MAT4X3: return 4;
|
|
case TYPE_DOUBLE_MAT4: return 4;
|
|
case TYPE_FLOAT16_MAT2: return 2;
|
|
case TYPE_FLOAT16_MAT2X3: return 2;
|
|
case TYPE_FLOAT16_MAT2X4: return 2;
|
|
case TYPE_FLOAT16_MAT3X2: return 3;
|
|
case TYPE_FLOAT16_MAT3: return 3;
|
|
case TYPE_FLOAT16_MAT3X4: return 3;
|
|
case TYPE_FLOAT16_MAT4X2: return 4;
|
|
case TYPE_FLOAT16_MAT4X3: return 4;
|
|
case TYPE_FLOAT16_MAT4: return 4;
|
|
default:
|
|
DE_ASSERT(false);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
DataType getDataTypeMatrixColumnType (DataType dataType)
|
|
{
|
|
switch (dataType)
|
|
{
|
|
case TYPE_FLOAT_MAT2: return TYPE_FLOAT_VEC2;
|
|
case TYPE_FLOAT_MAT2X3: return TYPE_FLOAT_VEC3;
|
|
case TYPE_FLOAT_MAT2X4: return TYPE_FLOAT_VEC4;
|
|
case TYPE_FLOAT_MAT3X2: return TYPE_FLOAT_VEC2;
|
|
case TYPE_FLOAT_MAT3: return TYPE_FLOAT_VEC3;
|
|
case TYPE_FLOAT_MAT3X4: return TYPE_FLOAT_VEC4;
|
|
case TYPE_FLOAT_MAT4X2: return TYPE_FLOAT_VEC2;
|
|
case TYPE_FLOAT_MAT4X3: return TYPE_FLOAT_VEC3;
|
|
case TYPE_FLOAT_MAT4: return TYPE_FLOAT_VEC4;
|
|
case TYPE_DOUBLE_MAT2: return TYPE_DOUBLE_VEC2;
|
|
case TYPE_DOUBLE_MAT2X3: return TYPE_DOUBLE_VEC3;
|
|
case TYPE_DOUBLE_MAT2X4: return TYPE_DOUBLE_VEC4;
|
|
case TYPE_DOUBLE_MAT3X2: return TYPE_DOUBLE_VEC2;
|
|
case TYPE_DOUBLE_MAT3: return TYPE_DOUBLE_VEC3;
|
|
case TYPE_DOUBLE_MAT3X4: return TYPE_DOUBLE_VEC4;
|
|
case TYPE_DOUBLE_MAT4X2: return TYPE_DOUBLE_VEC2;
|
|
case TYPE_DOUBLE_MAT4X3: return TYPE_DOUBLE_VEC3;
|
|
case TYPE_DOUBLE_MAT4: return TYPE_DOUBLE_VEC4;
|
|
case TYPE_FLOAT16_MAT2: return TYPE_FLOAT16_VEC2;
|
|
case TYPE_FLOAT16_MAT2X3: return TYPE_FLOAT16_VEC3;
|
|
case TYPE_FLOAT16_MAT2X4: return TYPE_FLOAT16_VEC4;
|
|
case TYPE_FLOAT16_MAT3X2: return TYPE_FLOAT16_VEC2;
|
|
case TYPE_FLOAT16_MAT3: return TYPE_FLOAT16_VEC3;
|
|
case TYPE_FLOAT16_MAT3X4: return TYPE_FLOAT16_VEC4;
|
|
case TYPE_FLOAT16_MAT4X2: return TYPE_FLOAT16_VEC2;
|
|
case TYPE_FLOAT16_MAT4X3: return TYPE_FLOAT16_VEC3;
|
|
case TYPE_FLOAT16_MAT4: return TYPE_FLOAT16_VEC4;
|
|
default:
|
|
DE_ASSERT(false);
|
|
return TYPE_INVALID;
|
|
}
|
|
}
|
|
|
|
int getDataTypeNumLocations (DataType dataType)
|
|
{
|
|
if (isDataTypeScalarOrVector(dataType))
|
|
return 1;
|
|
else if (isDataTypeMatrix(dataType))
|
|
return getDataTypeMatrixNumColumns(dataType);
|
|
|
|
DE_FATAL("Illegal datatype.");
|
|
return 0;
|
|
}
|
|
|
|
int getDataTypeNumComponents (DataType dataType)
|
|
{
|
|
if (isDataTypeScalarOrVector(dataType))
|
|
return getDataTypeScalarSize(dataType);
|
|
else if (isDataTypeMatrix(dataType))
|
|
return getDataTypeMatrixNumRows(dataType);
|
|
|
|
DE_FATAL("Illegal datatype.");
|
|
return 0;
|
|
}
|
|
|
|
DataType getDataTypeFromGLType (deUint32 glType)
|
|
{
|
|
switch (glType)
|
|
{
|
|
case GL_FLOAT: return TYPE_FLOAT;
|
|
case GL_FLOAT_VEC2: return TYPE_FLOAT_VEC2;
|
|
case GL_FLOAT_VEC3: return TYPE_FLOAT_VEC3;
|
|
case GL_FLOAT_VEC4: return TYPE_FLOAT_VEC4;
|
|
|
|
case GL_FLOAT_MAT2: return TYPE_FLOAT_MAT2;
|
|
case GL_FLOAT_MAT2x3: return TYPE_FLOAT_MAT2X3;
|
|
case GL_FLOAT_MAT2x4: return TYPE_FLOAT_MAT2X4;
|
|
|
|
case GL_FLOAT_MAT3x2: return TYPE_FLOAT_MAT3X2;
|
|
case GL_FLOAT_MAT3: return TYPE_FLOAT_MAT3;
|
|
case GL_FLOAT_MAT3x4: return TYPE_FLOAT_MAT3X4;
|
|
|
|
case GL_FLOAT_MAT4x2: return TYPE_FLOAT_MAT4X2;
|
|
case GL_FLOAT_MAT4x3: return TYPE_FLOAT_MAT4X3;
|
|
case GL_FLOAT_MAT4: return TYPE_FLOAT_MAT4;
|
|
|
|
case GL_DOUBLE: return TYPE_DOUBLE;
|
|
case GL_DOUBLE_VEC2: return TYPE_DOUBLE_VEC2;
|
|
case GL_DOUBLE_VEC3: return TYPE_DOUBLE_VEC3;
|
|
case GL_DOUBLE_VEC4: return TYPE_DOUBLE_VEC4;
|
|
|
|
case GL_DOUBLE_MAT2: return TYPE_DOUBLE_MAT2;
|
|
case GL_DOUBLE_MAT2x3: return TYPE_DOUBLE_MAT2X3;
|
|
case GL_DOUBLE_MAT2x4: return TYPE_DOUBLE_MAT2X4;
|
|
|
|
case GL_DOUBLE_MAT3x2: return TYPE_DOUBLE_MAT3X2;
|
|
case GL_DOUBLE_MAT3: return TYPE_DOUBLE_MAT3;
|
|
case GL_DOUBLE_MAT3x4: return TYPE_DOUBLE_MAT3X4;
|
|
|
|
case GL_DOUBLE_MAT4x2: return TYPE_DOUBLE_MAT4X2;
|
|
case GL_DOUBLE_MAT4x3: return TYPE_DOUBLE_MAT4X3;
|
|
case GL_DOUBLE_MAT4: return TYPE_DOUBLE_MAT4;
|
|
|
|
case GL_INT: return TYPE_INT;
|
|
case GL_INT_VEC2: return TYPE_INT_VEC2;
|
|
case GL_INT_VEC3: return TYPE_INT_VEC3;
|
|
case GL_INT_VEC4: return TYPE_INT_VEC4;
|
|
|
|
case GL_UNSIGNED_INT: return TYPE_UINT;
|
|
case GL_UNSIGNED_INT_VEC2: return TYPE_UINT_VEC2;
|
|
case GL_UNSIGNED_INT_VEC3: return TYPE_UINT_VEC3;
|
|
case GL_UNSIGNED_INT_VEC4: return TYPE_UINT_VEC4;
|
|
|
|
case GL_BOOL: return TYPE_BOOL;
|
|
case GL_BOOL_VEC2: return TYPE_BOOL_VEC2;
|
|
case GL_BOOL_VEC3: return TYPE_BOOL_VEC3;
|
|
case GL_BOOL_VEC4: return TYPE_BOOL_VEC4;
|
|
|
|
case GL_SAMPLER_1D: return TYPE_SAMPLER_1D;
|
|
case GL_SAMPLER_2D: return TYPE_SAMPLER_2D;
|
|
case GL_SAMPLER_CUBE: return TYPE_SAMPLER_CUBE;
|
|
case GL_SAMPLER_1D_ARRAY: return TYPE_SAMPLER_1D_ARRAY;
|
|
case GL_SAMPLER_2D_ARRAY: return TYPE_SAMPLER_2D_ARRAY;
|
|
case GL_SAMPLER_3D: return TYPE_SAMPLER_3D;
|
|
case GL_SAMPLER_CUBE_MAP_ARRAY: return TYPE_SAMPLER_CUBE_ARRAY;
|
|
|
|
case GL_SAMPLER_1D_SHADOW: return TYPE_SAMPLER_1D_SHADOW;
|
|
case GL_SAMPLER_2D_SHADOW: return TYPE_SAMPLER_2D_SHADOW;
|
|
case GL_SAMPLER_CUBE_SHADOW: return TYPE_SAMPLER_CUBE_SHADOW;
|
|
case GL_SAMPLER_1D_ARRAY_SHADOW: return TYPE_SAMPLER_1D_ARRAY_SHADOW;
|
|
case GL_SAMPLER_2D_ARRAY_SHADOW: return TYPE_SAMPLER_2D_ARRAY_SHADOW;
|
|
case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW: return TYPE_SAMPLER_CUBE_ARRAY_SHADOW;
|
|
|
|
case GL_INT_SAMPLER_1D: return TYPE_INT_SAMPLER_1D;
|
|
case GL_INT_SAMPLER_2D: return TYPE_INT_SAMPLER_2D;
|
|
case GL_INT_SAMPLER_CUBE: return TYPE_INT_SAMPLER_CUBE;
|
|
case GL_INT_SAMPLER_1D_ARRAY: return TYPE_INT_SAMPLER_1D_ARRAY;
|
|
case GL_INT_SAMPLER_2D_ARRAY: return TYPE_INT_SAMPLER_2D_ARRAY;
|
|
case GL_INT_SAMPLER_3D: return TYPE_INT_SAMPLER_3D;
|
|
case GL_INT_SAMPLER_CUBE_MAP_ARRAY: return TYPE_INT_SAMPLER_CUBE_ARRAY;
|
|
|
|
case GL_UNSIGNED_INT_SAMPLER_1D: return TYPE_UINT_SAMPLER_1D;
|
|
case GL_UNSIGNED_INT_SAMPLER_2D: return TYPE_UINT_SAMPLER_2D;
|
|
case GL_UNSIGNED_INT_SAMPLER_CUBE: return TYPE_UINT_SAMPLER_CUBE;
|
|
case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: return TYPE_UINT_SAMPLER_1D_ARRAY;
|
|
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: return TYPE_UINT_SAMPLER_2D_ARRAY;
|
|
case GL_UNSIGNED_INT_SAMPLER_3D: return TYPE_UINT_SAMPLER_3D;
|
|
case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: return TYPE_UINT_SAMPLER_CUBE_ARRAY;
|
|
|
|
case GL_SAMPLER_2D_MULTISAMPLE: return TYPE_SAMPLER_2D_MULTISAMPLE;
|
|
case GL_INT_SAMPLER_2D_MULTISAMPLE: return TYPE_INT_SAMPLER_2D_MULTISAMPLE;
|
|
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: return TYPE_UINT_SAMPLER_2D_MULTISAMPLE;
|
|
|
|
case GL_IMAGE_2D: return TYPE_IMAGE_2D;
|
|
case GL_IMAGE_CUBE: return TYPE_IMAGE_CUBE;
|
|
case GL_IMAGE_2D_ARRAY: return TYPE_IMAGE_2D_ARRAY;
|
|
case GL_IMAGE_3D: return TYPE_IMAGE_3D;
|
|
case GL_INT_IMAGE_2D: return TYPE_INT_IMAGE_2D;
|
|
case GL_INT_IMAGE_CUBE: return TYPE_INT_IMAGE_CUBE;
|
|
case GL_INT_IMAGE_2D_ARRAY: return TYPE_INT_IMAGE_2D_ARRAY;
|
|
case GL_INT_IMAGE_3D: return TYPE_INT_IMAGE_3D;
|
|
case GL_UNSIGNED_INT_IMAGE_2D: return TYPE_UINT_IMAGE_2D;
|
|
case GL_UNSIGNED_INT_IMAGE_CUBE: return TYPE_UINT_IMAGE_CUBE;
|
|
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY: return TYPE_UINT_IMAGE_2D_ARRAY;
|
|
case GL_UNSIGNED_INT_IMAGE_3D: return TYPE_UINT_IMAGE_3D;
|
|
|
|
case GL_UNSIGNED_INT_ATOMIC_COUNTER: return TYPE_UINT_ATOMIC_COUNTER;
|
|
|
|
case GL_SAMPLER_BUFFER: return TYPE_SAMPLER_BUFFER;
|
|
case GL_INT_SAMPLER_BUFFER: return TYPE_INT_SAMPLER_BUFFER;
|
|
case GL_UNSIGNED_INT_SAMPLER_BUFFER: return TYPE_UINT_SAMPLER_BUFFER;
|
|
|
|
case GL_SAMPLER_2D_MULTISAMPLE_ARRAY: return TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY;
|
|
case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: return TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
|
|
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: return TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY;
|
|
|
|
case GL_IMAGE_BUFFER: return TYPE_IMAGE_BUFFER;
|
|
case GL_INT_IMAGE_BUFFER: return TYPE_INT_IMAGE_BUFFER;
|
|
case GL_UNSIGNED_INT_IMAGE_BUFFER: return TYPE_UINT_IMAGE_BUFFER;
|
|
|
|
default:
|
|
return TYPE_LAST;
|
|
}
|
|
}
|
|
|
|
} // glu
|