38 shader_program_ = glCreateProgram();
50 glDeleteShader(vert_shader_);
51 glDeleteShader(geom_shader_);
52 glDeleteShader(frag_shader_);
53 glDeleteShader(compute_shader_);
54 glDeleteProgram(shader_program_);
66 case Interpolation::SMOOTH:
68 case Interpolation::FLAT:
70 case Interpolation::NO_PERSPECTIVE:
71 return "noperspective";
179 return "r11f_g11f_b10f";
190 case PrimitiveIn::POINTS:
192 case PrimitiveIn::LINES:
194 case PrimitiveIn::LINES_ADJACENCY:
195 return "lines_adjacency";
196 case PrimitiveIn::TRIANGLES:
198 case PrimitiveIn::TRIANGLES_ADJACENCY:
199 return "triangles_adjacency";
208 case PrimitiveOut::POINTS:
210 case PrimitiveOut::LINE_STRIP:
212 case PrimitiveOut::TRIANGLE_STRIP:
213 return "triangle_strip";
222 case DepthWrite::ANY:
224 case DepthWrite::GREATER:
225 return "depth_greater";
226 case DepthWrite::LESS:
229 return "depth_unchanged";
238 case ImageType::INT_BUFFER:
239 case ImageType::INT_1D:
240 case ImageType::INT_1D_ARRAY:
241 case ImageType::INT_2D:
242 case ImageType::INT_2D_ARRAY:
243 case ImageType::INT_3D:
244 case ImageType::INT_CUBE:
245 case ImageType::INT_CUBE_ARRAY:
248 case ImageType::UINT_BUFFER:
249 case ImageType::UINT_1D:
250 case ImageType::UINT_1D_ARRAY:
251 case ImageType::UINT_2D:
252 case ImageType::UINT_2D_ARRAY:
253 case ImageType::UINT_3D:
254 case ImageType::UINT_CUBE:
255 case ImageType::UINT_CUBE_ARRAY:
262 if (bind_type == ShaderCreateInfo::Resource::BindType::IMAGE) {
270 case ImageType::FLOAT_BUFFER:
271 case ImageType::INT_BUFFER:
272 case ImageType::UINT_BUFFER:
275 case ImageType::FLOAT_1D:
276 case ImageType::FLOAT_1D_ARRAY:
277 case ImageType::INT_1D:
278 case ImageType::INT_1D_ARRAY:
279 case ImageType::UINT_1D:
280 case ImageType::UINT_1D_ARRAY:
283 case ImageType::FLOAT_2D:
284 case ImageType::FLOAT_2D_ARRAY:
285 case ImageType::INT_2D:
286 case ImageType::INT_2D_ARRAY:
287 case ImageType::UINT_2D:
288 case ImageType::UINT_2D_ARRAY:
289 case ImageType::SHADOW_2D:
290 case ImageType::SHADOW_2D_ARRAY:
291 case ImageType::DEPTH_2D:
292 case ImageType::DEPTH_2D_ARRAY:
295 case ImageType::FLOAT_3D:
296 case ImageType::INT_3D:
297 case ImageType::UINT_3D:
300 case ImageType::FLOAT_CUBE:
301 case ImageType::FLOAT_CUBE_ARRAY:
302 case ImageType::INT_CUBE:
303 case ImageType::INT_CUBE_ARRAY:
304 case ImageType::UINT_CUBE:
305 case ImageType::UINT_CUBE_ARRAY:
306 case ImageType::SHADOW_CUBE:
307 case ImageType::SHADOW_CUBE_ARRAY:
308 case ImageType::DEPTH_CUBE:
309 case ImageType::DEPTH_CUBE_ARRAY:
317 case ImageType::FLOAT_1D_ARRAY:
318 case ImageType::FLOAT_2D_ARRAY:
319 case ImageType::FLOAT_CUBE_ARRAY:
320 case ImageType::INT_1D_ARRAY:
321 case ImageType::INT_2D_ARRAY:
322 case ImageType::INT_CUBE_ARRAY:
323 case ImageType::UINT_1D_ARRAY:
324 case ImageType::UINT_2D_ARRAY:
325 case ImageType::UINT_CUBE_ARRAY:
326 case ImageType::SHADOW_2D_ARRAY:
327 case ImageType::SHADOW_CUBE_ARRAY:
328 case ImageType::DEPTH_2D_ARRAY:
329 case ImageType::DEPTH_CUBE_ARRAY:
337 case ImageType::SHADOW_2D:
338 case ImageType::SHADOW_2D_ARRAY:
339 case ImageType::SHADOW_CUBE:
340 case ImageType::SHADOW_CUBE_ARRAY:
351 if (
bool(qualifiers & Qualifier::NO_RESTRICT) ==
false) {
354 if (
bool(qualifiers & Qualifier::READ) ==
false) {
357 if (
bool(qualifiers & Qualifier::WRITE) ==
false) {
366 os <<
"layout(binding = " << res.
slot;
367 if (res.
bind_type == ShaderCreateInfo::Resource::BindType::IMAGE) {
370 else if (res.
bind_type == ShaderCreateInfo::Resource::BindType::UNIFORM_BUFFER) {
373 else if (res.
bind_type == ShaderCreateInfo::Resource::BindType::STORAGE_BUFFER) {
378 else if (res.
bind_type == ShaderCreateInfo::Resource::BindType::UNIFORM_BUFFER) {
379 os <<
"layout(std140) ";
386 case ShaderCreateInfo::Resource::BindType::SAMPLER:
391 case ShaderCreateInfo::Resource::BindType::IMAGE:
397 case ShaderCreateInfo::Resource::BindType::UNIFORM_BUFFER:
398 array_offset = res.
uniformbuf.name.find_first_of(
"[");
399 name_no_array = (array_offset == -1) ? res.
uniformbuf.name :
401 os <<
"uniform " << name_no_array <<
" { " << res.
uniformbuf.type_name <<
" _"
404 case ShaderCreateInfo::Resource::BindType::STORAGE_BUFFER:
405 array_offset = res.
storagebuf.name.find_first_of(
"[");
406 name_no_array = (array_offset == -1) ? res.
storagebuf.name :
422 case ShaderCreateInfo::Resource::BindType::UNIFORM_BUFFER:
423 array_offset = res.
uniformbuf.name.find_first_of(
"[");
424 name_no_array = (array_offset == -1) ? res.
uniformbuf.name :
426 os <<
"#define " << name_no_array <<
" (_" << name_no_array <<
")\n";
428 case ShaderCreateInfo::Resource::BindType::STORAGE_BUFFER:
429 array_offset = res.
storagebuf.name.find_first_of(
"[");
430 name_no_array = (array_offset == -1) ? res.
storagebuf.name :
432 os <<
"#define " << name_no_array <<
" (_" << name_no_array <<
")\n";
450 os << prefix <<
" " << iface.
name <<
"{" << std::endl;
461 std::stringstream ss;
467 ss <<
"\n/* Pass Resources. */\n";
474 ss <<
"\n/* Batch Resources. */\n";
481 ss <<
"\n/* Push Constants. */\n";
492 ss <<
"#define " << uniform.
name <<
"_ " << uniform.
name <<
"\n";
493 ss <<
"#define " << uniform.
name <<
" (" << uniform.
name <<
"_)\n";
502 std::stringstream ss;
505 ss <<
"void main_function_();\n";
507 ss <<
"void main() {\n";
509 ss <<
" main_function_();\n";
513 ss <<
"#define main main_function_\n";
520 std::stringstream ss;
521 std::string post_main;
523 ss <<
"\n/* Inputs. */\n";
528 ss <<
"layout(location = " << attr.
index <<
") ";
535 ss <<
"in float gpu_dummy_workaround;\n";
537 ss <<
"\n/* Interfaces. */\n";
542 ss <<
"out int gpu_Layer;\n";
544 if (
bool(info.
builtins_ & BuiltinBits::BARYCENTRIC_COORD)) {
548 else if (GLEW_AMD_shader_explicit_vertex_parameter) {
550 ss <<
"flat out vec4 gpu_pos_flat;\n";
551 ss <<
"out vec4 gpu_pos;\n";
553 post_main +=
" gpu_pos = gpu_pos_flat = gl_Position;\n";
558 if (post_main.empty() ==
false) {
559 std::string pre_main;
567 std::stringstream ss;
568 std::string pre_main;
570 ss <<
"\n/* Interfaces. */\n";
577 if (
bool(info.
builtins_ & BuiltinBits::BARYCENTRIC_COORD)) {
579 ss <<
"flat in vec4 gpu_pos[3];\n";
580 ss <<
"smooth in vec3 gpu_BaryCoord;\n";
581 ss <<
"noperspective in vec3 gpu_BaryCoordNoPersp;\n";
582 ss <<
"#define gpu_position_at_vertex(v) gpu_pos[v]\n";
584 else if (GLEW_AMD_shader_explicit_vertex_parameter) {
585 std::cout <<
"native" << std::endl;
588 ss <<
"\n/* Stable Barycentric Coordinates. */\n";
589 ss <<
"flat in vec4 gpu_pos_flat;\n";
590 ss <<
"__explicitInterpAMD in vec4 gpu_pos;\n";
592 ss <<
"vec3 gpu_BaryCoord;\n";
593 ss <<
"vec3 gpu_BaryCoordNoPersp;\n";
595 ss <<
"vec2 stable_bary_(vec2 in_bary) {\n";
596 ss <<
" vec3 bary = vec3(in_bary, 1.0 - in_bary.x - in_bary.y);\n";
597 ss <<
" if (interpolateAtVertexAMD(gpu_pos, 0) == gpu_pos_flat) { return bary.zxy; }\n";
598 ss <<
" if (interpolateAtVertexAMD(gpu_pos, 2) == gpu_pos_flat) { return bary.yzx; }\n";
599 ss <<
" return bary.xyz;\n";
602 ss <<
"vec4 gpu_position_at_vertex(int v) {\n";
603 ss <<
" if (interpolateAtVertexAMD(gpu_pos, 0) == gpu_pos_flat) { v = (v + 2) % 3; }\n";
604 ss <<
" if (interpolateAtVertexAMD(gpu_pos, 2) == gpu_pos_flat) { v = (v + 1) % 3; }\n";
605 ss <<
" return interpolateAtVertexAMD(gpu_pos, v);\n";
608 pre_main +=
" gpu_BaryCoord = stable_bary_(gl_BaryCoordSmoothAMD);\n";
609 pre_main +=
" gpu_BaryCoordNoPersp = stable_bary_(gl_BaryCoordNoPerspAMD);\n";
613 ss <<
"layout(early_fragment_tests) in;\n";
615 if (GLEW_ARB_conservative_depth) {
618 ss <<
"\n/* Outputs. */\n";
620 ss <<
"layout(location = " <<
output.index;
622 case DualBlend::SRC_0:
625 case DualBlend::SRC_1:
636 if (pre_main.empty() ==
false) {
637 std::string post_main;
649 max_verts *= invocations;
653 std::stringstream ss;
654 ss <<
"\n/* Geometry Layout. */\n";
656 if (invocations != -1) {
657 ss <<
", invocations = " << invocations;
662 <<
", max_vertices = " << max_verts <<
") out;\n";
670 for (
auto *iface : ifaces) {
671 if (iface->instance_name == name) {
680 std::stringstream ss;
682 ss <<
"\n/* Interfaces. */\n";
686 const char *suffix = (has_matching_output_iface) ?
"_in[]" :
"[]";
693 const char *suffix = (has_matching_input_iface) ?
"_out" :
"";
702 std::stringstream ss;
703 ss <<
"\n/* Compute Layout. */\n";
722 std::string GLShader::workaround_geometry_shader_source_create(
725 std::stringstream ss;
738 info_modified.
geometry_layout(PrimitiveIn::TRIANGLES, PrimitiveOut::TRIANGLE_STRIP, 3);
742 if (do_layer_workaround) {
743 ss <<
"in int gpu_Layer[];\n";
745 if (do_barycentric_workaround) {
746 ss <<
"flat out vec4 gpu_pos[3];\n";
747 ss <<
"smooth out vec3 gpu_BaryCoord;\n";
748 ss <<
"noperspective out vec3 gpu_BaryCoordNoPersp;\n";
752 ss <<
"void main()\n";
754 if (do_layer_workaround) {
755 ss <<
" gl_Layer = gpu_Layer[0];\n";
757 if (do_barycentric_workaround) {
758 ss <<
" gpu_pos[0] = gl_in[0].gl_Position;\n";
759 ss <<
" gpu_pos[1] = gl_in[1].gl_Position;\n";
760 ss <<
" gpu_pos[2] = gl_in[2].gl_Position;\n";
764 for (
auto &inout : iface->
inouts) {
766 ss <<
" = " << iface->
instance_name <<
"_in[" << i <<
"]." << inout.name <<
";\n";
769 if (do_barycentric_workaround) {
770 ss <<
" gpu_BaryCoordNoPersp = gpu_BaryCoord =";
771 ss <<
" vec3(" << int(i == 0) <<
", " << int(i == 1) <<
", " << int(i == 2) <<
");\n";
773 ss <<
" gl_Position = gl_in[" << i <<
"].gl_Position;\n";
774 ss <<
" EmitVertex();\n";
801 static char patch[2048] =
"\0";
802 if (patch[0] !=
'\0') {
808 if (GLEW_VERSION_4_3) {
818 STR_CONCAT(patch, slen,
"#extension GL_ARB_texture_gather: enable\n");
821 STR_CONCAT(patch, slen,
"#ifdef GL_ARB_texture_gather\n");
822 STR_CONCAT(patch, slen,
"# define GPU_ARB_texture_gather\n");
826 STR_CONCAT(patch, slen,
"#extension GL_ARB_shader_draw_parameters : enable\n");
827 STR_CONCAT(patch, slen,
"#define GPU_ARB_shader_draw_parameters\n");
828 STR_CONCAT(patch, slen,
"#define gpu_BaseInstance gl_BaseInstanceARB\n");
831 STR_CONCAT(patch, slen,
"#extension GL_ARB_gpu_shader5 : enable\n");
832 STR_CONCAT(patch, slen,
"#define GPU_ARB_gpu_shader5\n");
835 STR_CONCAT(patch, slen,
"#extension GL_ARB_texture_cube_map_array : enable\n");
836 STR_CONCAT(patch, slen,
"#define GPU_ARB_texture_cube_map_array\n");
838 if (GLEW_ARB_conservative_depth) {
839 STR_CONCAT(patch, slen,
"#extension GL_ARB_conservative_depth : enable\n");
842 STR_CONCAT(patch, slen,
"#extension GL_ARB_shader_image_load_store: enable\n");
843 STR_CONCAT(patch, slen,
"#extension GL_ARB_shading_language_420pack: enable\n");
846 STR_CONCAT(patch, slen,
"#extension GL_AMD_vertex_shader_layer: enable\n");
847 STR_CONCAT(patch, slen,
"#define gpu_Layer gl_Layer\n");
850 STR_CONCAT(patch, slen,
"#extension GL_AMD_shader_explicit_vertex_parameter: enable\n");
855 STR_CONCAT(patch, slen,
"uniform int gpu_BaseInstance;\n");
859 STR_CONCAT(patch, slen,
"#define gpu_InstanceIndex (gl_InstanceID + gpu_BaseInstance)\n");
862 STR_CONCAT(patch, slen,
"#define gpu_Array(_type) _type[]\n");
878 static char patch[2048] =
"\0";
879 if (patch[0] !=
'\0') {
886 STR_CONCAT(patch, slen,
"#extension GL_ARB_compute_shader :enable\n");
889 STR_CONCAT(patch, slen,
"#define gpu_Array(_type) _type[]\n");
897 char *GLShader::glsl_patch_get(GLenum gl_stage)
899 if (gl_stage == GL_COMPUTE_SHADER) {
907 GLuint shader = glCreateShader(gl_stage);
909 fprintf(stderr,
"GLShader: Error: Could not create shader object.\n");
914 sources[0] = glsl_patch_get(gl_stage);
916 glShaderSource(shader, sources.
size(), sources.
data(),
nullptr);
917 glCompileShader(shader);
920 glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
923 glGetShaderInfoLog(shader,
sizeof(
log),
nullptr,
log);
924 if (
log[0] !=
'\0') {
927 case GL_VERTEX_SHADER:
928 this->
print_log(sources,
log,
"VertShader", !status, &parser);
930 case GL_GEOMETRY_SHADER:
931 this->
print_log(sources,
log,
"GeomShader", !status, &parser);
933 case GL_FRAGMENT_SHADER:
934 this->
print_log(sources,
log,
"FragShader", !status, &parser);
936 case GL_COMPUTE_SHADER:
937 this->
print_log(sources,
log,
"ComputeShader", !status, &parser);
943 glDeleteShader(shader);
944 compilation_failed_ =
true;
950 glAttachShader(shader_program_, shader);
956 vert_shader_ = this->create_shader_stage(GL_VERTEX_SHADER, sources);
961 geom_shader_ = this->create_shader_stage(GL_GEOMETRY_SHADER, sources);
966 frag_shader_ = this->create_shader_stage(GL_FRAGMENT_SHADER, sources);
971 compute_shader_ = this->create_shader_stage(GL_COMPUTE_SHADER, sources);
976 if (compilation_failed_) {
980 if (info && do_geometry_shader_injection(info)) {
981 std::string source = workaround_geometry_shader_source_create(*info);
983 sources.
append(
"version");
984 sources.
append(source.c_str());
988 glLinkProgram(shader_program_);
991 glGetProgramiv(shader_program_, GL_LINK_STATUS, &status);
994 glGetProgramInfoLog(shader_program_,
sizeof(
log),
nullptr,
log);
997 this->
print_log(sources,
log,
"Linking",
true, &parser);
1020 glUseProgram(shader_program_);
1041 glTransformFeedbackVaryings(
1042 shader_program_, name_list.
size(), name_list.
data(), GL_INTERLEAVED_ATTRIBS);
1043 transform_feedback_type_ = geom_type;
1056 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf->vbo_id_);
1058 switch (transform_feedback_type_) {
1060 glBeginTransformFeedback(GL_POINTS);
1063 glBeginTransformFeedback(GL_LINES);
1066 glBeginTransformFeedback(GL_TRIANGLES);
1076 glEndTransformFeedback();
1089 glUniform1fv(location, array_size,
data);
1092 glUniform2fv(location, array_size,
data);
1095 glUniform3fv(location, array_size,
data);
1098 glUniform4fv(location, array_size,
data);
1101 glUniformMatrix3fv(location, array_size, 0,
data);
1104 glUniformMatrix4fv(location, array_size, 0,
data);
1116 glUniform1iv(location, array_size,
data);
1119 glUniform2iv(location, array_size,
data);
1122 glUniform3iv(location, array_size,
data);
1125 glUniform4iv(location, array_size,
data);
1144 case GL_UNSIGNED_INT_VEC2:
1148 case GL_UNSIGNED_INT_VEC3:
1153 case GL_UNSIGNED_INT_VEC4:
1159 case GL_FLOAT_MAT2x3:
1160 case GL_FLOAT_MAT3x2:
1162 case GL_FLOAT_MAT2x4:
1163 case GL_FLOAT_MAT4x2:
1165 case GL_FLOAT_MAT3x4:
1166 case GL_FLOAT_MAT4x3:
1185 case GL_FLOAT_MAT2x3:
1186 case GL_FLOAT_MAT2x4:
1187 case GL_FLOAT_MAT3x2:
1188 case GL_FLOAT_MAT3x4:
1189 case GL_FLOAT_MAT4x2:
1190 case GL_FLOAT_MAT4x3:
1201 case GL_UNSIGNED_INT:
1202 case GL_UNSIGNED_INT_VEC2:
1203 case GL_UNSIGNED_INT_VEC3:
1204 case GL_UNSIGNED_INT_VEC4:
1218 glGetProgramiv(shader_program_, GL_ACTIVE_ATTRIBUTES, &attr_len);
1220 for (
int i = 0; i < attr_len; i++) {
1224 glGetActiveAttrib(shader_program_, i,
sizeof(
name),
nullptr, &
size, &gl_type,
name);
1227 if (glGetAttribLocation(shader_program_,
name) == -1) {
1243 return (
int)this->shader_program_;
KDTree *BLI_kdtree_nd_() new(unsigned int maxsize)
#define STR_CONCATF(dst, len, format,...)
#define STR_CONCAT(dst, len, suffix)
typedef UINT(API *GHOST_WIN32_GetDpiForWindow)(HWND)
bool GPU_shader_image_load_store_support(void)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
@ GPU_SHADER_TFB_TRIANGLES
struct GPUVertBuf GPUVertBuf
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
constexpr int64_t size() const
constexpr T * data() const
constexpr const T * data() const
constexpr int64_t size() const
constexpr bool is_empty() const
void append(const T &value)
static bool geometry_shader_invocations
static bool layered_rendering_support
static bool shader_draw_parameters_support
static bool explicit_location_support
static float derivative_signs[2]
static bool texture_gather_support
static bool texture_cube_map_array_support
static bool native_barycentric_support
std::string geometry_layout_declare(const shader::ShaderCreateInfo &info) const override
std::string vertex_interface_declare(const shader::ShaderCreateInfo &info) const override
std::string geometry_interface_declare(const shader::ShaderCreateInfo &info) const override
void fragment_shader_from_glsl(MutableSpan< const char * > sources) override
void uniform_float(int location, int comp_len, int array_size, const float *data) override
void transform_feedback_names_set(Span< const char * > name_list, eGPUShaderTFBType geom_type) override
bool transform_feedback_enable(GPUVertBuf *buf) override
GLShader(const char *name)
void compute_shader_from_glsl(MutableSpan< const char * > sources) override
std::string compute_layout_declare(const shader::ShaderCreateInfo &info) const override
int program_handle_get() const override
std::string resources_declare(const shader::ShaderCreateInfo &info) const override
void vertformat_from_shader(GPUVertFormat *format) const override
void uniform_int(int location, int comp_len, int array_size, const int *data) override
std::string fragment_interface_declare(const shader::ShaderCreateInfo &info) const override
bool finalize(const shader::ShaderCreateInfo *info=nullptr) override
void geometry_shader_from_glsl(MutableSpan< const char * > sources) override
void vertex_shader_from_glsl(MutableSpan< const char * > sources) override
void transform_feedback_disable() override
void print_log(Span< const char * > sources, char *log, const char *stage, bool error, GPULogParser *parser)
depth_tx normal_tx diffuse_light_tx specular_light_tx volume_light_tx environment_tx ambient_occlusion_tx aov_value_tx in_weight_img GPU_RGBA16F
depth_tx normal_tx diffuse_light_tx specular_light_tx volume_light_tx environment_tx ambient_occlusion_tx aov_value_tx GPU_R32F
static void print_interface(std::ostream &os, const StringRefNull &prefix, const StageInterfaceInfo &iface, const StringRefNull &suffix="")
static StageInterfaceInfo * find_interface_by_name(const Vector< StageInterfaceInfo * > &ifaces, const StringRefNull &name)
static void print_resource(std::ostream &os, const ShaderCreateInfo::Resource &res)
static void print_resource_alias(std::ostream &os, const ShaderCreateInfo::Resource &res)
static const char * to_string(const Interpolation &interp)
static void print_image_type(std::ostream &os, const ImageType &type, const ShaderCreateInfo::Resource::BindType bind_type)
static uint calc_component_size(const GLenum gl_type)
static std::ostream & print_qualifier(std::ostream &os, const Qualifier &qualifiers)
static std::string main_function_wrapper(std::string &pre_main, std::string &post_main)
static char * glsl_patch_compute_get()
char datatoc_glsl_shader_defines_glsl[]
static void get_fetch_mode_and_comp_type(int gl_type, GPUVertCompType *r_comp_type, GPUVertFetchMode *r_fetch_mode)
static char * glsl_patch_default_get()
ccl_global KernelShaderEvalInput ccl_global float * output
ccl_device_inline float2 interp(const float2 &a, const float2 &b, float t)
ccl_device_inline float3 log(float3 v)
void object_label(GLenum type, GLuint object, const char *name)
static Context * unwrap(GPUContext *ctx)
PrimitiveOut primitive_out
Describe inputs & outputs, stage interfaces, resources and sources of a shader. If all data is correc...
Vector< StageInterfaceInfo * > vertex_out_interfaces_
Vector< VertIn > vertex_inputs_
bool early_fragment_test_
Vector< Resource > batch_resources_
StringRefNull geometry_source_
Vector< StageInterfaceInfo * > geometry_out_interfaces_
Vector< Resource > pass_resources_
bool legacy_resource_location_
GeometryStageLayout geometry_layout_
ComputeStageLayout compute_layout_
Self & geometry_layout(PrimitiveIn prim_in, PrimitiveOut prim_out, int max_vertices, int invocations=-1)
Vector< PushConst > push_constants_
Vector< FragOut > fragment_outputs_
StringRefNull instance_name