result code = 0 standard error = { -------------------------------------------------------------------------------- # `outFunc` ## Signature ``` void outFunc(out int v); ``` ## Parameters * `v` -------------------------------------------------------------------------------- # `struct ParentStruct` ## Description Testing out nested generics ## Generic Parameters * `T` Some type -------------------------------------------------------------------------------- # `struct ParentStruct.ChildStruct` ## Description Testing out a child ## Generic Parameters * `S` Some other type ## Methods * `getValue` -------------------------------------------------------------------------------- # `ParentStruct.ChildStruct.getValue` ## Description A useless method hey ho ## Signature ``` ParentStruct.T ParentStruct.ChildStruct.getValue(ParentStruct.ChildStruct.S v); ``` ## Parameters * `v` -------------------------------------------------------------------------------- # `struct GenericStruct` ## Generic Parameters * `T` ## Fields * `value` ## Methods * `getValue` -------------------------------------------------------------------------------- # `GenericStruct.getValue` ## Signature ``` GenericStruct.T GenericStruct.getValue(); ``` -------------------------------------------------------------------------------- # `addInts` ## Description A rather silly generic function to test out doc extraction ## Signature ``` T addInts( T z, T b); ``` ## Parameters * `T` The type we are operating on * `U` Just testing out a non type based generic * `V` And another one * `z` CHECKING!! * `b` The B parameter -------------------------------------------------------------------------------- # `Hey::doAnotherThing` ## Signature ``` void Hey::doAnotherThing(int a); ``` ## Parameters * `a` -------------------------------------------------------------------------------- # inputBuffer ``` RWStructuredBuffer inputBuffer ``` ## Description Let's test indent ``` { imIndented(); } ``` -------------------------------------------------------------------------------- # `interface IDoThing` ## Description An interface to do things # Associated types * _V_ An associated type ## Methods * `add` * `sub` -------------------------------------------------------------------------------- # `IDoThing.add` ## Description Add two integers ## Signature ``` IDoThing.V IDoThing.add( IDoThing.V a, IDoThing.V b); ``` ## Parameters * `a` First parameter * `b` Second parameter -------------------------------------------------------------------------------- # `IDoThing.sub` ## Description Subtract Multi-line ## Signature ``` int IDoThing.sub( int a, int b); ``` ## Parameters * `a` First * `b` Second -------------------------------------------------------------------------------- # `interface IThing` ## Methods * `getValue` -------------------------------------------------------------------------------- # `IThing.getValue` ## Signature ``` float IThing.getValue(); ``` -------------------------------------------------------------------------------- # `extension float : IThing` *Implements:* `IThing` ## Description Implement IThing on float ## Methods * `getValue` -------------------------------------------------------------------------------- # `float.getValue` ## Description Just return the float itself! ## Signature ``` float float.getValue(); ``` -------------------------------------------------------------------------------- # `struct Thing` *Implements:* `IThing`, `IDoThing` ## Methods * `add` * `sub` * `getValue` -------------------------------------------------------------------------------- # `Thing.add` ## Signature ``` int Thing.add( int a, int b); ``` ## Parameters * `a` * `b` -------------------------------------------------------------------------------- # `Thing.sub` ## Signature ``` int Thing.sub( int a, int b); ``` ## Parameters * `a` * `b` -------------------------------------------------------------------------------- # `Thing.getValue` ## Signature ``` float Thing.getValue(); ``` -------------------------------------------------------------------------------- # `struct SomeStruct` ## Description A struct with some fields ## Fields * `aField` A field * `anotherField` Multi-line is a thing * `yetAnother` A field with stuff ## Methods * `getMethod` -------------------------------------------------------------------------------- # `SomeStruct.getMethod` ## Description Get a value ## Signature ``` int SomeStruct.getMethod(); ``` -------------------------------------------------------------------------------- # enum AnEnum ## Values * _Value_ A value * _AnotherValue_ Another value With a multi-line comment ## Description An enum -------------------------------------------------------------------------------- # outputBuffer ``` RWStructuredBuffer outputBuffer ``` ## Description An output buffer -------------------------------------------------------------------------------- # `doThing` ## Description doThing! ## Signature ``` int doThing( int a, int b); ``` ## Parameters * `a` a parameter * `b` b parameter -------------------------------------------------------------------------------- # `computeMain` ## Signature ``` void computeMain(vector dispatchThreadID); ``` ## Parameters * `dispatchThreadID` } standard output = { }