此图展示该文件直接或间接的被哪些文件引用了:

类
struct	TypeInfo

struct	FixedArray< T, SIZE >

struct	Array< T >

struct	Vector< T, 1 >

struct	Vector< T, 2 >

struct	Vector< T, 3 >

struct	Vector< T, 4 >

struct	Matrix< T, ROWS, COLS >

宏定义
#define	SLANG_PRELUDE_ASSERT(VALUE)

#define	SLANG_BOUND_ASSERT(index, count) SLANG_PRELUDE_ASSERT(index < count);

#define	SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_PRELUDE_ASSERT(index <= (sizeInBytes - elemSize) && (index & 3) == 0);

#define	SLANG_BOUND_ZERO_INDEX(index, count) index = (index < count) ? index : 0;

#define	SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes) index = (index <= (sizeInBytes - elemSize)) ? index : 0;

#define	SLANG_BOUND_FIX(index, count)

#define	SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes)

#define	SLANG_BOUND_FIX_FIXED_ARRAY(index, count)

#define	SLANG_BOUND_CHECK(index, count) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX(index, count)

#define	SLANG_BOUND_CHECK_BYTE_ADDRESS(index, elemSize, sizeInBytes)

#define	SLANG_BOUND_CHECK_FIXED_ARRAY(index, count) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX_FIXED_ARRAY(index, count)

#define	SLANG_VECTOR_BINARY_OP(T, op)

#define	SLANG_VECTOR_BINARY_COMPARE_OP(T, op)

#define	SLANG_VECTOR_UNARY_OP(T, op)

#define	SLANG_INT_VECTOR_OPS(T)

#define	SLANG_FLOAT_VECTOR_OPS(T)

#define	SLANG_VECTOR_INT_NEG_OP(T)

#define	SLANG_FLOAT_VECTOR_MOD(T)

#define	SLANG_MATRIX_BINARY_OP(T, op)

#define	SLANG_MATRIX_BINARY_COMPARE_OP(T, op)

#define	SLANG_MATRIX_UNARY_OP(T, op)

#define	SLANG_INT_MATRIX_OPS(T)

#define	SLANG_FLOAT_MATRIX_OPS(T)

#define	SLANG_MATRIX_INT_NEG_OP(T)

#define	SLANG_FLOAT_MATRIX_MOD(T)

类型定义
typedef uint32_t	uint

函数
template<typename T , int N>
SLANG_FORCE_INLINE Vector< T, N >	_slang_select (Vector< bool, N > condition, Vector< T, N > v0, Vector< T, N > v1)

template<typename T >
SLANG_FORCE_INLINE T	_slang_select (bool condition, T v0, T v1)

template<typename T , int N>
SLANG_FORCE_INLINE T	_slang_vector_get_element (Vector< T, N > x, int index)

template<typename T , int N>
SLANG_FORCE_INLINE const T *	_slang_vector_get_element_ptr (const Vector< T, N > *x, int index)

template<typename T , int N>
SLANG_FORCE_INLINE T *	_slang_vector_get_element_ptr (Vector< T, N > *x, int index)

template<typename T , int n, typename OtherT , int m>
SLANG_FORCE_INLINE Vector< T, n >	_slang_vector_reshape (const Vector< OtherT, m > other)

template<typename TResult , typename TInput >
TResult	slang_bit_cast (TInput val)

宏定义说明

◆ SLANG_BOUND_ASSERT

#define SLANG_BOUND_ASSERT	(		index,
			count ) SLANG_PRELUDE_ASSERT(index < count);

◆ SLANG_BOUND_ASSERT_BYTE_ADDRESS

#define SLANG_BOUND_ASSERT_BYTE_ADDRESS	(	index,
		elemSize,
		sizeInBytes ) SLANG_PRELUDE_ASSERT(index <= (sizeInBytes - elemSize) && (index & 3) == 0);

◆ SLANG_BOUND_CHECK

#define SLANG_BOUND_CHECK	(		index,
			count ) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX(index, count)

◆ SLANG_BOUND_CHECK_BYTE_ADDRESS

#define SLANG_BOUND_CHECK_BYTE_ADDRESS	(	index,
		elemSize,
		sizeInBytes )

值:

SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) \

SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes)

SLANG_BOUND_ASSERT_BYTE_ADDRESS

#define SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes)

Definition slang-cpp-types-core.h:19

◆ SLANG_BOUND_CHECK_FIXED_ARRAY

#define SLANG_BOUND_CHECK_FIXED_ARRAY	(		index,
			count ) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX_FIXED_ARRAY(index, count)

◆ SLANG_BOUND_FIX

#define SLANG_BOUND_FIX	(		index,
			count )

◆ SLANG_BOUND_FIX_BYTE_ADDRESS

#define SLANG_BOUND_FIX_BYTE_ADDRESS	(	index,
		elemSize,
		sizeInBytes )

◆ SLANG_BOUND_FIX_FIXED_ARRAY

#define SLANG_BOUND_FIX_FIXED_ARRAY	(		index,
			count )

◆ SLANG_BOUND_ZERO_INDEX

#define SLANG_BOUND_ZERO_INDEX	(		index,
			count ) index = (index < count) ? index : 0;

◆ SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS

#define SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS	(	index,
		elemSize,
		sizeInBytes ) index = (index <= (sizeInBytes - elemSize)) ? index : 0;

◆ SLANG_FLOAT_MATRIX_MOD

#define SLANG_FLOAT_MATRIX_MOD ( T )

值:

    template<int R, int C>                                                                    \
    SLANG_FORCE_INLINE Matrix<T, R, C> operator%(Matrix<T, R, C> left, Matrix<T, R, C> right) \
    {                                                                                         \
        Matrix<T, R, C> result;                                                               \
        for (int i = 0; i < R; i++)                                                           \
            for (int j = 0; j < C; j++)                                                       \
                result.rows[i][j] = _slang_fmod(left.rows[i][j], right.rows[i][j]);           \
        return result;                                                                        \
    }

◆ SLANG_FLOAT_MATRIX_OPS

#define SLANG_FLOAT_MATRIX_OPS ( T )

值:

    SLANG_MATRIX_BINARY_OP(T, +)          \
    SLANG_MATRIX_BINARY_OP(T, -)          \
    SLANG_MATRIX_BINARY_OP(T, *)          \
    SLANG_MATRIX_BINARY_OP(T, /)          \
    SLANG_MATRIX_UNARY_OP(T, -)           \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, >)  \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, <)  \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, >=) \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, <=) \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, ==) \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, !=)

◆ SLANG_FLOAT_VECTOR_MOD

#define SLANG_FLOAT_VECTOR_MOD ( T )

值:

    template<int N>                                                             \
    Vector<T, N> operator%(const Vector<T, N>& left, const Vector<T, N>& right) \
    {                                                                           \
        Vector<T, N> result;                                                    \
        for (int i = 0; i < N; i++)                                             \
            result[i] = _slang_fmod(left[i], right[i]);                         \
        return result;                                                          \
    }

◆ SLANG_FLOAT_VECTOR_OPS

#define SLANG_FLOAT_VECTOR_OPS ( T )

值:

    SLANG_VECTOR_BINARY_OP(T, +)          \
    SLANG_VECTOR_BINARY_OP(T, -)          \
    SLANG_VECTOR_BINARY_OP(T, *)          \
    SLANG_VECTOR_BINARY_OP(T, /)          \
    SLANG_VECTOR_UNARY_OP(T, -)           \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, >)  \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, <)  \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, >=) \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, <=) \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, ==) \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, !=)

◆ SLANG_INT_MATRIX_OPS

#define SLANG_INT_MATRIX_OPS ( T )

值:

    SLANG_MATRIX_BINARY_OP(T, +)          \
    SLANG_MATRIX_BINARY_OP(T, -)          \
    SLANG_MATRIX_BINARY_OP(T, *)          \
    SLANG_MATRIX_BINARY_OP(T, /)          \
    SLANG_MATRIX_BINARY_OP(T, &)          \
    SLANG_MATRIX_BINARY_OP(T, |)          \
    SLANG_MATRIX_BINARY_OP(T, &&)         \
    SLANG_MATRIX_BINARY_OP(T, ||)         \
    SLANG_MATRIX_BINARY_OP(T, ^)          \
    SLANG_MATRIX_BINARY_OP(T, %)          \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, >)  \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, <)  \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, >=) \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, <=) \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, ==) \
    SLANG_MATRIX_BINARY_COMPARE_OP(T, !=) \
    SLANG_MATRIX_UNARY_OP(T, !)           \
    SLANG_MATRIX_UNARY_OP(T, ~)

◆ SLANG_INT_VECTOR_OPS

#define SLANG_INT_VECTOR_OPS ( T )

值:

    SLANG_VECTOR_BINARY_OP(T, +)          \
    SLANG_VECTOR_BINARY_OP(T, -)          \
    SLANG_VECTOR_BINARY_OP(T, *)          \
    SLANG_VECTOR_BINARY_OP(T, /)          \
    SLANG_VECTOR_BINARY_OP(T, &)          \
    SLANG_VECTOR_BINARY_OP(T, |)          \
    SLANG_VECTOR_BINARY_OP(T, &&)         \
    SLANG_VECTOR_BINARY_OP(T, ||)         \
    SLANG_VECTOR_BINARY_OP(T, ^)          \
    SLANG_VECTOR_BINARY_OP(T, %)          \
    SLANG_VECTOR_BINARY_OP(T, >>)         \
    SLANG_VECTOR_BINARY_OP(T, <<)         \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, >)  \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, <)  \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, >=) \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, <=) \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, ==) \
    SLANG_VECTOR_BINARY_COMPARE_OP(T, !=) \
    SLANG_VECTOR_UNARY_OP(T, !)           \
    SLANG_VECTOR_UNARY_OP(T, ~)

◆ SLANG_MATRIX_BINARY_COMPARE_OP

#define SLANG_MATRIX_BINARY_COMPARE_OP	(		T,
			op )

值:

    template<int R, int C>                                                                       \
    Matrix<bool, R, C> operator op(const Matrix<T, R, C>& thisVal, const Matrix<T, R, C>& other) \
    {                                                                                            \
        Matrix<bool, R, C> result;                                                               \
        for (int i = 0; i < R; i++)                                                              \
            for (int j = 0; j < C; j++)                                                          \
                result.rows[i][j] = thisVal.rows[i][j] op other.rows[i][j];                      \
        return result;                                                                           \
    }

◆ SLANG_MATRIX_BINARY_OP

#define SLANG_MATRIX_BINARY_OP	(		T,
			op )

值:

    template<int R, int C>                                                                    \
    Matrix<T, R, C> operator op(const Matrix<T, R, C>& thisVal, const Matrix<T, R, C>& other) \
    {                                                                                         \
        Matrix<T, R, C> result;                                                               \
        for (int i = 0; i < R; i++)                                                           \
            for (int j = 0; j < C; j++)                                                       \
                result.rows[i][j] = thisVal.rows[i][j] op other.rows[i][j];                   \
        return result;                                                                        \
    }

◆ SLANG_MATRIX_INT_NEG_OP

#define SLANG_MATRIX_INT_NEG_OP ( T )

值:

    template<int R, int C>                                                \
    SLANG_FORCE_INLINE Matrix<T, R, C> operator-(Matrix<T, R, C> thisVal) \
    {                                                                     \
        Matrix<T, R, C> result;                                           \
        for (int i = 0; i < R; i++)                                       \
            for (int j = 0; j < C; j++)                                   \
                result.rows[i][j] = 0 - thisVal.rows[i][j];               \
        return result;                                                    \
    }

◆ SLANG_MATRIX_UNARY_OP

#define SLANG_MATRIX_UNARY_OP	(		T,
			op )

值:

    template<int R, int C>                                      \
    Matrix<T, R, C> operator op(const Matrix<T, R, C>& thisVal) \
    {                                                           \
        Matrix<T, R, C> result;                                 \
        for (int i = 0; i < R; i++)                             \
            for (int j = 0; j < C; j++)                         \
                result[i].rows[i][j] = op thisVal.rows[i][j];   \
        return result;                                          \
    }

◆ SLANG_PRELUDE_ASSERT

#define SLANG_PRELUDE_ASSERT ( VALUE )

◆ SLANG_VECTOR_BINARY_COMPARE_OP

#define SLANG_VECTOR_BINARY_COMPARE_OP	(		T,
			op )

值:

    template<int n>                                 \
    SLANG_FORCE_INLINE Vector<bool, n> operator op( \
        const Vector<T, n>& thisVal,                \
        const Vector<T, n>& other)                  \
    {                                               \
        Vector<bool, n> result;                     \
        for (int i = 0; i < n; i++)                 \
            result[i] = thisVal[i] op other[i];     \
        return result;                              \
    }

◆ SLANG_VECTOR_BINARY_OP

#define SLANG_VECTOR_BINARY_OP	(		T,
			op )

值:

    template<int n>                              \
    SLANG_FORCE_INLINE Vector<T, n> operator op( \
        const Vector<T, n>& thisVal,             \
        const Vector<T, n>& other)               \
    {                                            \
        Vector<T, n> result;                     \
        for (int i = 0; i < n; i++)              \
            result[i] = thisVal[i] op other[i];  \
        return result;                           \
    }

◆ SLANG_VECTOR_INT_NEG_OP

#define SLANG_VECTOR_INT_NEG_OP ( T )

值:

    template<int N>                                     \
    Vector<T, N> operator-(const Vector<T, N>& thisVal) \
    {                                                   \
        Vector<T, N> result;                            \
        for (int i = 0; i < N; i++)                     \
            result[i] = 0 - thisVal[i];                 \
        return result;                                  \
    }

◆ SLANG_VECTOR_UNARY_OP

#define SLANG_VECTOR_UNARY_OP	(		T,
			op )

值:

    template<int n>                                                          \
    SLANG_FORCE_INLINE Vector<T, n> operator op(const Vector<T, n>& thisVal) \
    {                                                                        \
        Vector<T, n> result;                                                 \
        for (int i = 0; i < n; i++)                                          \
            result[i] = op thisVal[i];                                       \
        return result;                                                       \
    }

类型定义说明

◆ uint

typedef uint32_t uint

函数说明

◆ _slang_select() [1/2]

template<typename T >

SLANG_FORCE_INLINE T _slang_select	(	bool	condition,
		T	v0,
		T	v1 )

◆ _slang_select() [2/2]

template<typename T , int N>

SLANG_FORCE_INLINE Vector< T, N > _slang_select	(	Vector< bool, N >	condition,
		Vector< T, N >	v0,
		Vector< T, N >	v1 )

◆ _slang_vector_get_element()

template<typename T , int N>

SLANG_FORCE_INLINE T _slang_vector_get_element	(	Vector< T, N >	x,
		int	index )

这是这个函数的调用关系图:

◆ _slang_vector_get_element_ptr() [1/2]

template<typename T , int N>

SLANG_FORCE_INLINE const T * _slang_vector_get_element_ptr	(	const Vector< T, N > *	x,
		int	index )

这是这个函数的调用关系图:

◆ _slang_vector_get_element_ptr() [2/2]

template<typename T , int N>

SLANG_FORCE_INLINE T * _slang_vector_get_element_ptr	(	Vector< T, N > *	x,
		int	index )

◆ _slang_vector_reshape()

template<typename T , int n, typename OtherT , int m>

SLANG_FORCE_INLINE Vector< T, n > _slang_vector_reshape ( const Vector< OtherT, m > other )

函数调用图:

◆ slang_bit_cast()

template<typename TResult , typename TInput >

TResult slang_bit_cast ( TInput val )