Adjust type layout when parameter block constains member using the same resource

If we have something like to following in HLSL:

    cbuffer C { Texture2D t; ... }

and we are compiling to GLSL, then both `C` and `C.t` consume the same kind of resource (a descriptor-table slot).
The way reflection was working right now, querying the index of `C` would return its binding (let's say it is `4` just to be concrete) and then a query on `C::t` would give its offset, which was being computed as `0` because it is the first field in the logical `struct` type.

That obviously leads to bad math and requires some subtle `+1`s in cases to get things right (e.g., when scalaring during lowering, I had to carefully add one in some cases).
It is unreasonable to expect users to deal with this.

This commit changes it so that the offset of field `C::t` is `1` so that hopefully more things Just Work.
The special-case logic in lowering is now gone.

One important catch here is that this pretty much only works in the case where the element type of a parameter block is a `struct` type (which is really all that makes sense right now).
If we ever want to generalize this in the future, then it will probably be necessary to change the `TypeLayout` case for parameter blocks to store a `VarLayout` for the element, rather than just a `TypeLayout`.

1 files changed, 0 insertions, 35 deletions

diff --git a/source/slang/lower.cpp b/source/slang/lower.cpp
index c7278201a..caa1ab075 100644
--- a/source/slang/lower.cpp
+++ b/source/slang/lower.cpp
@@ -1828,25 +1828,6 @@ struct LoweringVisitor
                             needsOffset = true;
                             break;
                         }
-
-                        // Even if the base offset of the parent is zero, we may still
-                        // need to offset the child, because the parent consumes a
-                        // resources of the same kind...
-                        if (primaryVarLayout->typeLayout->type->As<UniformParameterBlockType>())
-                        {
-                            switch (rr.kind)
-                            {
-                            default:
-                                break;
-
-                            case LayoutResourceKind::ConstantBuffer:
-                            case LayoutResourceKind::DescriptorTableSlot:
-                                needsOffset = true;
-                                break;
-                            }
-                            if (needsOffset)
-                                break;
-                        }
                     }
                 }
                 if (needsOffset)
@@ -1867,22 +1848,6 @@ struct LoweringVisitor
                         {
                             newResInfo->index += parentInfo->index;
                             newResInfo->space += parentInfo->space;
-
-                            // Very special-case hack to deal with the case where the parent
-                            // itself consumes a resources of the same type as the field.
-                            if (primaryVarLayout->typeLayout->type->As<UniformParameterBlockType>())
-                            {
-                                switch (resInfo.kind)
-                                {
-                                default:
-                                    break;
-
-                                case LayoutResourceKind::ConstantBuffer:
-                                case LayoutResourceKind::DescriptorTableSlot:
-                                    newResInfo->index += 1;
-                                    break;
-                                }
-                            }
                         }
                     }