Docgen tool.

Author: csyonghe

docs/_layouts/stdlib-reference.html

@@ -0,0 +1,8 @@
+@titile: Slang Standard Library Reference
+@libname: Slang's Standard Library
+
+@preamble:
+---
+layout: stdlib-reference
+---
+@end

docs/stdlib-reference/config.txt

@@ -0,0 +1,19 @@
+---
+layout: user-guide
+---
+
+Slang Standard Library Reference
+=============
+
+Welcome to the Slang Standard Library Reference.
+
+Please select a topic from the table of contents to see the detailed documentation of
+system defined types, interfaces, methods and constants that can be used in a Slang
+program.
+
+This reference groups the standard library declarations as:
+- [Interfaces](interfaces/): all builtin interfaces usable as generic constraints.
+- [Types](types/): all builtin types and their members, such as `StructuredBuffer`, `Texture2D` and etc.
+- [Global Declarations](global-decls/): all other constants and functions defined in the global scope.
+
+This documentation is still a work-in-progress.

docs/stdlib-reference/index.md

@@ -0,0 +1,6 @@
+<nav>
+    <li><a href="../../">Docs</a></li>
+    <li><a href="../">Slang</a></li>
+    <li><a href="index.html">Slang Standard Library Reference</a></li>
+
+</nav>

docs/stdlib-reference/nav.html

@@ -446,6 +446,7 @@ interface IRWArray<T> : IArray<T>
 // argument. The left-to-right evaluation order guaranteed by Slang then ensures that
 // `left` is evaluated before `right`.
 //
+//@hidden:
 __generic<T,U>
 [__unsafeForceInlineEarly]
 U operator,(T left, U right)
@@ -457,20 +458,29 @@ U operator,(T left, U right)
 // follow that definition for the scalar condition overload, so this declaration just serves
 // for type-checking purpose only.
 
-__generic<T> __intrinsic_op(select) T operator?:(bool condition, T ifTrue, T ifFalse);
+//@hidden:
+__generic<T> __intrinsic_op(select) T operator?: (bool condition, T ifTrue, T ifFalse);
+
+//@hidden:
 __generic<T, let N : int> __intrinsic_op(select) vector<T,N> operator?:(vector<bool,N> condition, vector<T,N> ifTrue, vector<T,N> ifFalse);
 
 // Users are advised to use `select` instead if non-short-circuiting behavior is intended.
+//@public:
 __generic<T> __intrinsic_op(select) T select(bool condition, T ifTrue, T ifFalse);
 __generic<T, let N : int> __intrinsic_op(select) vector<T,N> select(vector<bool,N> condition, vector<T,N> ifTrue, vector<T,N> ifFalse);
 
 // Allow real-number types to be cast into each other
+//@hidden:
 __intrinsic_op($(kIROp_FloatCast))
     T __realCast<T : __BuiltinRealType, U : __BuiltinRealType>(U val);
+//@hidden:
 __intrinsic_op($(kIROp_CastIntToFloat))
-    T __realCast<T : __BuiltinRealType, U : __BuiltinIntegerType>(U val);
+T __realCast<T : __BuiltinRealType, U : __BuiltinIntegerType>(U val);
+//@hidden:
 __intrinsic_op($(kIROp_IntCast))
-    T __intCast<T : __BuiltinType, U : __BuiltinType>(U val);
+T __intCast<T : __BuiltinType, U : __BuiltinType>(U val);
+
+//@hidden:
 ${{{{
 // We are going to use code generation to produce the
 // declarations for all of our base types.
@@ -716,17 +726,20 @@ ${{{{
 // (eventually we can have the traditional syntax sugar for this)
 }}}}
 
+//@hidden:
 __magic_type(NullPtrType)
 struct NullPtr
 {
 };
 
+//@hidden:
 __magic_type(NoneType)
 __intrinsic_type($(kIROp_VoidType))
 struct __none_t
 {
 };
 
+//@public:
 __generic<T, let addrSpace : uint64_t = $( (uint64_t)AddressSpace::UserPointer)ULL>
 __magic_type(PtrType)
 __intrinsic_type($(kIROp_PtrType))
@@ -752,6 +765,7 @@ struct Ptr
     }
 };
 
+//@hidden:
 __intrinsic_op($(kIROp_Load))
 T __load<T, let addrSpace : uint64_t>(Ptr<T, addrSpace> ptr);
 
@@ -788,6 +802,7 @@ __generic<T, let addrSpace : uint64_t>
 __intrinsic_op($(kIROp_Eql))
 bool operator ==(Ptr<T, addrSpace> p1, Ptr<T, addrSpace> p2);
 
+//@public:
 extension bool : IRangedValue
 {
     __generic<T, let addrSpace : uint64_t>
@@ -847,6 +862,7 @@ extension uintptr_t : IRangedValue
     static const int size = $(SLANG_PROCESSOR_X86_64?"8":"4");
 }
 
+//@hidden:
 __generic<T>
 __magic_type(OutType)
 __intrinsic_type($(kIROp_OutType))
@@ -873,6 +889,7 @@ struct ConstRef
 
 typealias __Addr<T> = Ptr<T, $( (uint64_t)AddressSpace::Generic)ULL>;
 
+//@public:
 __generic<T>
 __magic_type(OptionalType)
 __intrinsic_type($(kIROp_OptionalType))
@@ -895,6 +912,7 @@ struct Optional
     __init(T val);
 };
 
+//@hidden:
 __generic<T>
 [__unsafeForceInlineEarly]
 bool operator==(Optional<T> val, __none_t noneVal)
@@ -920,6 +938,7 @@ bool operator!=(__none_t noneVal, Optional<T> val)
     return val.hasValue;
 }
 
+//@public:
 __generic<each T>
 __magic_type(TupleType)
 struct Tuple
@@ -936,7 +955,7 @@ Tuple<T, U> concat<each T, each U>(Tuple<T> t, Tuple<U> u)
     return makeTuple(expand each t, expand each u);
 }
 
-
+//@hidden:
 [__unsafeForceInlineEarly]
 bool __assign(inout bool v, bool newVal)
 {
@@ -978,6 +997,7 @@ void __tupleGreaterKernel<T : IComparable>(inout bool result, inout bool exit, T
     }
 }
 
+//@public:
 __generic<each T : IComparable>
 extension Tuple<T> : IComparable
 {
@@ -1027,6 +1047,7 @@ interface IDifferentiableFunc<TR : IDifferentiable, each TP : IDifferentiable> :
     TR operator()(expand each TP p);
 }
 
+//@hidden:
 __generic<T>
 __magic_type(NativeRefType)
 __intrinsic_type($(kIROp_NativePtrType))
@@ -1049,6 +1070,7 @@ T __attachToNativeRef(NativeRef<T> nativeVal)
     return result;
 }
 
+//@public:
 __magic_type(StringType)
 __intrinsic_type($(kIROp_StringType))
 struct String
@@ -1133,11 +1155,14 @@ extension Ptr<void>
     __init(NativeRef<T> ptr);
 }
 
+//@hidden:
 __magic_type(DynamicType)
 __intrinsic_type($(kIROp_DynamicType))
 struct __Dynamic
 {};
 
+//@public:
+
 extension half : IRangedValue
 {
     static const half maxValue = half(65504);
@@ -1225,9 +1250,11 @@ struct vector : IRWArray<T>
     int getCount() { return N; }
 }
 
-const int kRowMajorMatrixLayout = $(SLANG_MATRIX_LAYOUT_ROW_MAJOR);
-const int kColumnMajorMatrixLayout = $(SLANG_MATRIX_LAYOUT_COLUMN_MAJOR);
+//@hidden:
+static const int kRowMajorMatrixLayout = $(SLANG_MATRIX_LAYOUT_ROW_MAJOR);
+static const int kColumnMajorMatrixLayout = $(SLANG_MATRIX_LAYOUT_COLUMN_MAJOR);
 
+//@public:
     /// A matrix with `R` rows and `C` columns, with elements of type `T`.
 __generic<T = float, let R : int = 4, let C : int = 4, let L : int = $(SLANG_MATRIX_LAYOUT_MODE_UNKNOWN)>
 __magic_type(MatrixExpressionType)
@@ -1248,9 +1275,11 @@ struct matrix : IRWArray<vector<T,C>>
     int getCount() { return R; }
 }
 
+//@hidden:
 __intrinsic_op($(kIROp_Eql))
-vector<bool, N> __vectorEql<T, let N:int>(vector<T, N> left, vector<T,N> right);
+vector<bool, N> __vectorEql<T, let N : int>(vector<T, N> left, vector<T, N> right);
 
+//@public:
 __generic<T:__BuiltinFloatingPointType, let N : int>
 extension vector<T,N> : IFloat
 {
@@ -1360,10 +1389,12 @@ extension matrix<int16_t,R,C,L>
     __init(int value) { this = matrix<T,R,C,L>(T(value)); }
 }
 
+//@hidden:
 __intrinsic_op(makeVector)
 __generic<T, let N:int>
 vector<T,N*2> __makeVector(vector<T,N> vec1, vector<T,N> vec2);
 
+//@public:
 __generic<T>
 extension vector<T, 4>
 {
@@ -1573,7 +1604,7 @@ struct OutputPrimitives
     }
 };
 
-//@ hidden:
+//@ public:
 
 // Need to add constructors to the types above
 
@@ -1757,6 +1788,7 @@ ${{{{
 }
 }}}}
 
+//@ hidden:
 __generic<T, U>
 __intrinsic_op(0)
 T __slang_noop_cast(U u);
@@ -2267,6 +2299,8 @@ int __SyntaxError()
     }
 }
 
+//@ hidden:
+
 /// For downstream compilers that allow sizeof/alignof/offsetof
 /// Can't be called in the C/C++ style. Need to use __size_of<some_type>() as opposed to sizeof(some_type).
 __generic<T>
@@ -2350,7 +2384,7 @@ __generic<E : __EnumType>
 __intrinsic_op($(kIROp_Neq))
 bool operator!=(E left, E right);
 
-//@ public:
+//@ hidden:
 
 // public interfaces for generic arithmetic types.
 
@@ -2722,6 +2756,7 @@ __Addr<T> __getLegalizedSPIRVGlobalParamAddr(T val);
 __intrinsic_op($(kIROp_RequireComputeDerivative))
 void __requireComputeDerivative();
 
+//@ public:
 // Atomic<T>
 
 enum MemoryOrder
@@ -2793,6 +2828,8 @@ extension<T : IBitAtomicable> Atomic<T>
     [__ref] T decrement(MemoryOrder order = MemoryOrder.Relaxed);
 }
 
+//@ hidden:
+
 __generic<T : IArithmeticAtomicable>
 [ForceInline]
 T operator +=(__ref Atomic<T> v, T value)