AuroraMiddleware/glslang
1
0
Fork 0
mirror of https://github.com/KhronosGroup/glslang synced 2024-11-08 11:30:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
76cc41d26f
glslang/Test/baseResults/310.inheritMemory.frag.out

222 lines
18 KiB
Plaintext
Raw Normal View History

GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
310.inheritMemory.frag
Shader version: 310
Placeholder fix for part of #1870. Also fixes, in practice, https://github.com/KhronosGroup/GLSL/issues/83. When the specification language is correctly created, glslang can be revisited for correctness. In the meantime, this seems like the best "bug" to have relative to the specification. Memory qualifiers are only relevant to parameters when they apply to what the argument points to, as otherwise the argument is copied. This leaves the fix from #1870 in place, and then more correctly ignores memory qualifiers when something will be passed by copy.
2019-08-30 15:53:35 +00:00
0:? Sequence
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:18 Function Definition: non_ro_fun(f1[10]; ( global void)
0:18 Function Parameters:
0:18 'buff' ( in 10-element array of mediump float)
0:19 Function Definition: non_ro_funf(f1; ( global void)
0:19 Function Parameters:
0:19 'el' ( in mediump float)
0:20 Function Definition: non_ro_funS(struct-S-f1[10]1; ( global void)
0:20 Function Parameters:
0:20 's' ( in structure{ global 10-element array of mediump float buff})
0:24 Function Definition: main( ( global void)
0:24 Function Parameters:
0:? Sequence
0:28 Function Call: non_ro_fun(f1[10]; ( global void)
0:28 buff: direct index for structure ( global 10-element array of mediump float)
0:28 's' ( temp structure{ global 10-element array of mediump float buff})
0:28 Constant:
0:28 0 (const int)
0:29 Function Call: non_ro_funf(f1; ( global void)
0:29 direct index ( temp mediump float)
0:29 buff: direct index for structure ( global 10-element array of mediump float)
0:29 's' ( temp structure{ global 10-element array of mediump float buff})
0:29 Constant:
0:29 0 (const int)
0:29 Constant:
0:29 3 (const int)
0:30 Function Call: non_ro_funS(struct-S-f1[10]1; ( global void)
0:30 's' ( temp structure{ global 10-element array of mediump float buff})
0:32 Function Call: non_ro_fun(f1[10]; ( global void)
0:32 buff: direct index for structure (layout( column_major std430 offset=0) buffer 10-element array of mediump float)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:32 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:32 Constant:
0:32 0 (const int)
0:33 Function Call: non_ro_fun(f1[10]; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:33 buff: direct index for structure (layout( std430) global 10-element array of mediump float)
0:33 s: direct index for structure (layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff})
0:33 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:33 Constant:
0:33 1 (const int)
0:33 Constant:
0:33 0 (const int)
0:34 Function Call: non_ro_funf(f1; ( global void)
0:34 direct index (layout( column_major std430 offset=0) temp mediump float)
0:34 buff: direct index for structure (layout( column_major std430 offset=0) buffer 10-element array of mediump float)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:34 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:34 Constant:
0:34 0 (const int)
0:34 Constant:
0:34 3 (const int)
0:35 Function Call: non_ro_funf(f1; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:35 direct index (layout( std430) temp mediump float)
0:35 buff: direct index for structure (layout( std430) global 10-element array of mediump float)
0:35 s: direct index for structure (layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff})
0:35 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:35 Constant:
0:35 1 (const int)
0:35 Constant:
0:35 0 (const int)
0:35 Constant:
0:35 3 (const int)
0:36 Function Call: non_ro_funS(struct-S-f1[10]1; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:36 s: direct index for structure (layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff})
0:36 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:36 Constant:
0:36 1 (const int)
0:38 Function Call: non_ro_fun(f1[10]; ( global void)
0:38 buff_ro: direct index for structure (layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:38 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:38 Constant:
0:38 0 (const int)
0:39 Function Call: non_ro_fun(f1[10]; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:39 buff: direct index for structure (layout( std430) readonly global 10-element array of mediump float)
0:39 s_ro: direct index for structure (layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff})
0:39 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:39 Constant:
0:39 1 (const int)
0:39 Constant:
0:39 0 (const int)
0:40 Function Call: non_ro_funf(f1; ( global void)
0:40 direct index (layout( column_major std430 offset=0) readonly temp mediump float)
0:40 buff_ro: direct index for structure (layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:40 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:40 Constant:
0:40 0 (const int)
0:40 Constant:
0:40 3 (const int)
0:41 Function Call: non_ro_funf(f1; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:41 direct index (layout( std430) readonly temp mediump float)
0:41 buff: direct index for structure (layout( std430) readonly global 10-element array of mediump float)
0:41 s_ro: direct index for structure (layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff})
0:41 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:41 Constant:
0:41 1 (const int)
0:41 Constant:
0:41 0 (const int)
0:41 Constant:
0:41 3 (const int)
0:42 Function Call: non_ro_funS(struct-S-f1[10]1; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:42 s_ro: direct index for structure (layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff})
0:42 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:42 Constant:
0:42 1 (const int)
0:? Linker Objects
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:? 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
0:? 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:? 'fragColor' ( out mediump 4-component vector of float)
Linked fragment stage:
Shader version: 310
Placeholder fix for part of #1870. Also fixes, in practice, https://github.com/KhronosGroup/GLSL/issues/83. When the specification language is correctly created, glslang can be revisited for correctness. In the meantime, this seems like the best "bug" to have relative to the specification. Memory qualifiers are only relevant to parameters when they apply to what the argument points to, as otherwise the argument is copied. This leaves the fix from #1870 in place, and then more correctly ignores memory qualifiers when something will be passed by copy.
2019-08-30 15:53:35 +00:00
0:? Sequence
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:18 Function Definition: non_ro_fun(f1[10]; ( global void)
0:18 Function Parameters:
0:18 'buff' ( in 10-element array of mediump float)
0:19 Function Definition: non_ro_funf(f1; ( global void)
0:19 Function Parameters:
0:19 'el' ( in mediump float)
0:20 Function Definition: non_ro_funS(struct-S-f1[10]1; ( global void)
0:20 Function Parameters:
0:20 's' ( in structure{ global 10-element array of mediump float buff})
0:24 Function Definition: main( ( global void)
0:24 Function Parameters:
0:? Sequence
0:28 Function Call: non_ro_fun(f1[10]; ( global void)
0:28 buff: direct index for structure ( global 10-element array of mediump float)
0:28 's' ( temp structure{ global 10-element array of mediump float buff})
0:28 Constant:
0:28 0 (const int)
0:29 Function Call: non_ro_funf(f1; ( global void)
0:29 direct index ( temp mediump float)
0:29 buff: direct index for structure ( global 10-element array of mediump float)
0:29 's' ( temp structure{ global 10-element array of mediump float buff})
0:29 Constant:
0:29 0 (const int)
0:29 Constant:
0:29 3 (const int)
0:30 Function Call: non_ro_funS(struct-S-f1[10]1; ( global void)
0:30 's' ( temp structure{ global 10-element array of mediump float buff})
0:32 Function Call: non_ro_fun(f1[10]; ( global void)
0:32 buff: direct index for structure (layout( column_major std430 offset=0) buffer 10-element array of mediump float)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:32 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:32 Constant:
0:32 0 (const int)
0:33 Function Call: non_ro_fun(f1[10]; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:33 buff: direct index for structure (layout( std430) global 10-element array of mediump float)
0:33 s: direct index for structure (layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff})
0:33 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:33 Constant:
0:33 1 (const int)
0:33 Constant:
0:33 0 (const int)
0:34 Function Call: non_ro_funf(f1; ( global void)
0:34 direct index (layout( column_major std430 offset=0) temp mediump float)
0:34 buff: direct index for structure (layout( column_major std430 offset=0) buffer 10-element array of mediump float)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:34 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:34 Constant:
0:34 0 (const int)
0:34 Constant:
0:34 3 (const int)
0:35 Function Call: non_ro_funf(f1; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:35 direct index (layout( std430) temp mediump float)
0:35 buff: direct index for structure (layout( std430) global 10-element array of mediump float)
0:35 s: direct index for structure (layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff})
0:35 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:35 Constant:
0:35 1 (const int)
0:35 Constant:
0:35 0 (const int)
0:35 Constant:
0:35 3 (const int)
0:36 Function Call: non_ro_funS(struct-S-f1[10]1; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:36 s: direct index for structure (layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff})
0:36 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:36 Constant:
0:36 1 (const int)
0:38 Function Call: non_ro_fun(f1[10]; ( global void)
0:38 buff_ro: direct index for structure (layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:38 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:38 Constant:
0:38 0 (const int)
0:39 Function Call: non_ro_fun(f1[10]; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:39 buff: direct index for structure (layout( std430) readonly global 10-element array of mediump float)
0:39 s_ro: direct index for structure (layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff})
0:39 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:39 Constant:
0:39 1 (const int)
0:39 Constant:
0:39 0 (const int)
0:40 Function Call: non_ro_funf(f1; ( global void)
0:40 direct index (layout( column_major std430 offset=0) readonly temp mediump float)
0:40 buff_ro: direct index for structure (layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:40 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:40 Constant:
0:40 0 (const int)
0:40 Constant:
0:40 3 (const int)
0:41 Function Call: non_ro_funf(f1; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:41 direct index (layout( std430) readonly temp mediump float)
0:41 buff: direct index for structure (layout( std430) readonly global 10-element array of mediump float)
0:41 s_ro: direct index for structure (layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff})
0:41 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:41 Constant:
0:41 1 (const int)
0:41 Constant:
0:41 0 (const int)
0:41 Constant:
0:41 3 (const int)
0:42 Function Call: non_ro_funS(struct-S-f1[10]1; ( global void)
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:42 s_ro: direct index for structure (layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff})
0:42 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:42 Constant:
0:42 1 (const int)
0:? Linker Objects
Reserve unused std140 uniform block in reflection, and fix uniform block matrix layout (#2041) According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
2020-05-15 08:26:48 +00:00
0:? 'ro_buffer' (layout( binding=2 column_major std430) readonly buffer block{layout( column_major std430 offset=0) readonly buffer 10-element array of mediump float buff_ro, layout( column_major std430 offset=40) readonly buffer structure{layout( std430) global 10-element array of mediump float buff} s_ro})
0:? 'non_ro_buffer' (layout( binding=2 column_major std430) buffer block{layout( column_major std430 offset=0) buffer 10-element array of mediump float buff, layout( column_major std430 offset=40) buffer structure{layout( std430) global 10-element array of mediump float buff} s})
GLSL: Inherit memory qualifiers, both declaratively and in execution. Fixes #1870, probably others.
2019-08-22 12:58:26 +00:00
0:? 'fragColor' ( out mediump 4-component vector of float)
Reference in New Issue Copy Permalink