WIP: Preliminary Slang -> C++ code generation (#1009)

* Expanded prelude for some other resource types. Disable C++ output for ParameterGroup.

* WIP: Layout for CPU.

* Fixes to CPU layout.

* WIP: The uniform is output, but the variable definition is not.

* WIP: Entry point parameters to global scope in C++.
Handling of resource types (in so far as outputting)

* Some discussion of ABI and different input types.

* WIP: More C++ support around resource types.

* WIP: Split up variables into different structures on emit.

* WIP: Emitting C++ with wrapping up of 'Context'

* WIP: C++ code has access to semantic values.
Wrap in struct so can use method calls to pass shared state.
Disable  legalizeResourceTypes and legalizeExistentialTypeLayout

* Fix structured buffer layout for CPU.

* Remove testing/handling of global uniforms on CPU path.
Typo fix.
Changed CPU tests to use new CPU calling convention.

* Check globals are working. Initalize context to zero globals.

* Order the global parameters for C++ ouput by their layout.
Note - that layout isn't quite working correctly because the StructuredBuffer<int> the int seems to be consuming uniform space.

* Work around for reflection not having all data needed for layout ordering for C++ code.

* Output constant buffers as pointers.

* Entry point parameters accessed through pointer to struct.

* WIP: Layout for CPU is reasonable for test case.

* Only output 'f' after float literal if type marks as a float.

* Cast construction works on C++.

* Made IntrinsicOp::ConvertConstruct to make intent clearer.

* C++ handling construction from scalar.
Handle access of a scalar with .x.
Check default initialization.

* Comment about need for split of kIROp_construct.
Release build works.

* Added support from constructVectorFromScalar to C/C++ target.

* Handling of in/out in C/C++.

* First pass documentation CPU support.

* Improvements to C++/C slang code generation documentation.

* Small doc change to include need for mechansim to specify cpp compiler path.

* Better handling of swizzling - allow swizzling a scalar into a vector.

1 files changed, 42 insertions, 0 deletions

diff --git a/tests/cross-compile/cpp-resource-reflection.slang b/tests/cross-compile/cpp-resource-reflection.slang
new file mode 100644
index 000000000..122e7b4de
--- /dev/null
+++ b/tests/cross-compile/cpp-resource-reflection.slang
@@ -0,0 +1,42 @@
+//TEST:REFLECTION: -profile cs_5_0 -entry computeMain -target cpp
+
+
+struct Thing
+{
+    int a;
+    float b;
+    float c;
+};
+
+static int value;
+
+// Don't use parameter block for now
+//ParameterBlock<AnotherThing> s_paramBlock;
+
+ConstantBuffer<Thing> thing3;
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):dxbinding(0),glbinding(0),out
+RWStructuredBuffer<int> outputBuffer;
+
+Texture2D<float> tex;
+SamplerState sampler;
+    
+[numthreads(4, 1, 1)]
+void computeMain(
+    uint3 dispatchThreadID : SV_DispatchThreadID, 
+    uniform Thing thing, 
+    uniform Thing thing2)
+{
+    uint tid = dispatchThreadID.x;
+
+    // TODO(JS): Doesn't emit correctly on c++ becomes...
+    // Vector<float, 2> loc_0 = Vector<float, 2>{Vector<uint32_t, 2>{dispatchThreadID_0.x, dispatchThreadID_0.y}} * 0.50000000000000000000f;
+    //float2 loc = dispatchThreadID.xy * 0.5f;
+
+    float2 loc = float2(dispatchThreadID.x * 0.5f, dispatchThreadID.y * 0.5f);
+
+    float v = tex.Load(int3(tid, tid, 0));
+    float s = tex.Sample(sampler, loc);
+   
+    outputBuffer[tid] = int(tid * tid) + thing.a + thing3.a + int(v + s) + value; // + thing.a;
+}
\ No newline at end of file