fclem/blender
2
1
Fork 0
forked from blender/blender
Code Pull Requests 1 Activity

GPU: GLSL-C++ compilation stubs #4

Closed
Clément Foucault wants to merge 38 commits from glsl-cpp-stubs-2 into glsl-include
pull from: glsl-cpp-stubs-2
merge into: fclem:glsl-include

When changing the target branch, be careful to rebase the branch in your fork to match. See documentation.
Conversation 2 Commits 38 Files Changed 4 +109 -52
1 changed files with 109 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 9d05520391 - Show all commits

161
source/blender/gpu/shaders/gpu_glsl_cpp_stubs.hh
View File

@ -2,12 +2,32 @@
* *
* SPDX-License-Identifier: GPL-2.0-or-later */ * SPDX-License-Identifier: GPL-2.0-or-later */
/**
* GLSL to C++ stubs.
*
* The goal of this header is to make the GLSL source file compile using a modern C++ compiler.
* This allows for linting and IDE functionalities to work.
*
* This is why the implementation of each function is not needed.
*
* Some of the features of GLSL are omitted by design. They are either:
* - not needed (e.g. per component matrix multiplication)
* - against our code-style (e.g. stpq swizzle)
* - unsupported by our Metal Shading Language layer (e.g. mixed vector-scalar matrix constructor).
*
* IMPORTANT: Please ask the module team if you need some feature that are not listed in this file.
*/
#pragma once #pragma once
#if defined(__cplusplus) && !defined(GPU_SHADER) #ifndef GPU_SHADER
# include <type_traits> # include <type_traits>
/* -------------------------------------------------------------------- */
/** \name Vector Types
* \{ */
template<typename T, int Sz> struct VecBase {}; template<typename T, int Sz> struct VecBase {};
template<typename T, int Sz> struct VecOp { template<typename T, int Sz> struct VecOp {
@ -44,7 +64,7 @@ template<typename T, int Sz> struct VecOp {
friend VecT operator*(T, VecT) {} friend VecT operator*(T, VecT) {}
# define INT_OP \ # define INT_OP \
template<typename U = _T, typename std::enable_if_t<std::is_integral_v<U>> * = nullptr> template<typename U = T, typename std::enable_if_t<std::is_integral_v<U>> * = nullptr>
INT_OP VecT operator%(VecT) const {} INT_OP VecT operator%(VecT) const {}
INT_OP VecT operator&(VecT) const {} INT_OP VecT operator&(VecT) const {}
@ -254,6 +274,12 @@ using bvec2 = bool2;
using bvec3 = bool3; using bvec3 = bool3;
using bvec4 = bool4; using bvec4 = bool4;
/** \} */
/* -------------------------------------------------------------------- */
/** \name Matrix Types
* \{ */
template<int C, int R> struct MatBase {}; template<int C, int R> struct MatBase {};
template<int C, int R> struct MatOp { template<int C, int R> struct MatOp {
@ -324,25 +350,11 @@ using mat2 = float2x2;
using mat3 = float3x3; using mat3 = float3x3;
using mat4 = float4x4; using mat4 = float4x4;
template<typename T, int D> VecBase<bool, D> greaterThan(VecBase<T, D>, VecBase<T, D>) {} /** \} */
template<typename T, int D> VecBase<bool, D> lessThan(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> lessThanEqual(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> greaterThanEqual(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> equal(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> notEqual(VecBase<T, D>, VecBase<T, D>) {}
template<int D> bool any(VecBase<bool, D>) {}
template<int D> bool all(VecBase<bool, D>) {}
/* `not` is a C++ keyword. Use dirty macro to allow this. */
template<int D> VecBase<bool, D> not_impl(VecBase<bool, D>) {}
# define not not_impl
# define inout /* -------------------------------------------------------------------- */
# define in /** \name Sampler Types
# define out * \{ */
template<typename T> using Vec4 = VecBase<T, 4>;
template<int D> using VecInt = VecBase<int, D>;
template<int D> using VecFlt = VecBase<double, D>;
template<typename T, int Dimensions, bool Cube = false, bool Array = false> struct SamplerBase { template<typename T, int Dimensions, bool Cube = false, bool Array = false> struct SamplerBase {
static constexpr int coord_dim = Dimensions + int(Cube) + int(Array); static constexpr int coord_dim = Dimensions + int(Cube) + int(Array);
@ -399,14 +411,18 @@ using samplerCubeArray = SamplerBase<double, 2, true, true>;
using isamplerCubeArray = SamplerBase<int, 2, true, true>; using isamplerCubeArray = SamplerBase<int, 2, true, true>;
using usamplerCubeArray = SamplerBase<uint, 2, true, true>; using usamplerCubeArray = SamplerBase<uint, 2, true, true>;
/** \} */
/* -------------------------------------------------------------------- */
/** \name Image Types
* \{ */
template<typename T, int Dimensions, bool Array = false> struct ImageBase { template<typename T, int Dimensions, bool Array = false> struct ImageBase {
static constexpr int coord_dim = Dimensions + int(Cube) + int(Array); static constexpr int coord_dim = Dimensions + int(Array);
static constexpr int deriv_dim = Dimensions + int(Cube);
static constexpr int extent_dim = Dimensions + int(Array);
using int_coord_type = VecBase<int, coord_dim>; using int_coord_type = VecBase<int, coord_dim>;
using data_vec_type = VecBase<T, 4>; using data_vec_type = VecBase<T, 4>;
using size_vec_type = VecBase<int, extent_dim>; using size_vec_type = VecBase<int, coord_dim>;
}; };
# define IMG_TEMPLATE \ # define IMG_TEMPLATE \
@ -424,30 +440,42 @@ IMG_TEMPLATE void imageFence(T) {}
# undef IMG_TEMPLATE # undef IMG_TEMPLATE
using sampler1D = SamplerBase<double, 1>; using image1D = ImageBase<double, 1>;
using sampler2D = SamplerBase<double, 2>; using image2D = ImageBase<double, 2>;
using sampler3D = SamplerBase<double, 3>; using image3D = ImageBase<double, 3>;
using isampler1D = SamplerBase<int, 1>; using iimage1D = ImageBase<int, 1>;
using isampler2D = SamplerBase<int, 2>; using iimage2D = ImageBase<int, 2>;
using isampler3D = SamplerBase<int, 3>; using iimage3D = ImageBase<int, 3>;
using usampler1D = SamplerBase<uint, 1>; using uimage1D = ImageBase<uint, 1>;
using usampler2D = SamplerBase<uint, 2>; using uimage2D = ImageBase<uint, 2>;
using usampler3D = SamplerBase<uint, 3>; using uimage3D = ImageBase<uint, 3>;
using sampler1DArray = SamplerBase<double, 1, false, true>; using image1DArray = ImageBase<double, 1, true>;
using sampler2DArray = SamplerBase<double, 2, false, true>; using image2DArray = ImageBase<double, 2, true>;
using isampler1DArray = SamplerBase<int, 1, false, true>; using iimage1DArray = ImageBase<int, 1, true>;
using isampler2DArray = SamplerBase<int, 2, false, true>; using iimage2DArray = ImageBase<int, 2, true>;
using usampler1DArray = SamplerBase<uint, 1, false, true>; using uimage1DArray = ImageBase<uint, 1, true>;
using usampler2DArray = SamplerBase<uint, 2, false, true>; using uimage2DArray = ImageBase<uint, 2, true>;
using samplerCube = SamplerBase<double, 2, true>; /* Forbid Cube and cube arrays. Bind them as 3D textures instead. */
using isamplerCube = SamplerBase<int, 2, true>;
using usamplerCube = SamplerBase<uint, 2, true>;
using samplerCubeArray = SamplerBase<double, 2, true, true>; /** \} */
using isamplerCubeArray = SamplerBase<int, 2, true, true>;
using usamplerCubeArray = SamplerBase<uint, 2, true, true>; /* -------------------------------------------------------------------- */
/** \name Builtin Functions
* \{ */
template<typename T, int D> VecBase<bool, D> greaterThan(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> lessThan(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> lessThanEqual(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> greaterThanEqual(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> equal(VecBase<T, D>, VecBase<T, D>) {}
template<typename T, int D> VecBase<bool, D> notEqual(VecBase<T, D>, VecBase<T, D>) {}
template<int D> bool any(VecBase<bool, D>) {}
template<int D> bool all(VecBase<bool, D>) {}
/* `not` is a C++ keyword. Use dirty macro to allow this. */
template<int D> VecBase<bool, D> not_impl(VecBase<bool, D>) {}
# define not not_impl
template<int D> VecBase<int, D> bitCount(VecBase<int, D>) {} template<int D> VecBase<int, D> bitCount(VecBase<int, D>) {}
template<int D> VecBase<int, D> bitCount(VecBase<uint, D>) {} template<int D> VecBase<int, D> bitCount(VecBase<uint, D>) {}
@ -566,10 +594,22 @@ float2 unpackSnorm2x16(uint) {}
float4 unpackUnorm4x8(uint) {} float4 unpackUnorm4x8(uint) {}
float4 unpackSnorm4x8(uint) {} float4 unpackSnorm4x8(uint) {}
/* Matrices functions. */
template<int C, int R> float determinant(MatBase<C, R>) {} template<int C, int R> float determinant(MatBase<C, R>) {}
template<int C, int R> MatBase<C, R> inverse(MatBase<C, R>) {} template<int C, int R> MatBase<C, R> inverse(MatBase<C, R>) {}
template<int C, int R> MatBase<R, C> transpose(MatBase<C, R>) {} template<int C, int R> MatBase<R, C> transpose(MatBase<C, R>) {}
/* TODO(fclem): Should be in a lib instead of being impemented by each backend. */
bool is_zero(vec2) {}
bool is_zero(vec3) {}
bool is_zero(vec4) {}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Special Variables
* \{ */
/* Vertex Shader Special Variables. */ /* Vertex Shader Special Variables. */
const int gl_VertexID; const int gl_VertexID;
const int gl_InstanceID; const int gl_InstanceID;
@ -585,18 +625,33 @@ const int gl_PrimitiveID;
float gl_FragDepth; float gl_FragDepth;
/* Read-only in Fragment Shader and write-only in vertex shader. */ /* Read-only in Fragment Shader and write-only in vertex shader. */
float gl_ClipDistance[]; float gl_ClipDistance[];
float gl_CullDistance[]; /* Note: Use GPU variant as they might be emulated. */
/* Use GPU variant as they can be emulated. */
int gpu_Layer; int gpu_Layer;
int gpu_ViewportIndex; int gpu_ViewportIndex;
/* Keywords. */ /** \} */
/* -------------------------------------------------------------------- */
/** \name Keywords
* \{ */
/* Note: Cannot easily mutate them. Pass every by copy for now. */
/* Pass argument by reference. */
# define inout
/* Pass argument by reference but only write to it. Its initial value is undefined. */
# define out
/* Pass argument by copy (default). */
# define in
/* Cannot easily mutate them. Pass every by copy for now. */
void discard; void discard;
/* TODO(fclem): Should be in a lib instead of being impemented by each backend. */ /** \} */
bool is_zero(vec2) {}
bool is_zero(vec3) {} /* -------------------------------------------------------------------- */
bool is_zero(vec4) {} /** \name Compatibility
* \{ */
/* Array syntax compatibility. */ /* Array syntax compatibility. */
/* clang-format off */ /* clang-format off */
@ -618,4 +673,6 @@ bool is_zero(vec4) {}
#define bool4_array(...) { __VA_ARGS__ } #define bool4_array(...) { __VA_ARGS__ }
/* clang-format on */ /* clang-format on */
/** \} */
#endif #endif