Full Code of alipbcs/ZetaRay for AI

gitextract_aors0i3m/

├── .gitattributes
├── .github/
│   └── workflows/
│       └── build.yml
├── .gitignore
├── Assets/
│   ├── CornellBox/
│   │   ├── compressed/
│   │   │   └── checkerboard.dds
│   │   ├── cornell.gltf
│   │   ├── cornell_emissive.gltf
│   │   └── license.txt
│   ├── Font/
│   │   ├── Font.h
│   │   ├── IconsFontAwesome6.h
│   │   └── LICENSE-bfont.ttf.txt
│   └── LUT/
│       ├── LICENSE-MIT
│       ├── rho.dds
│       └── tony_mc_mapface.dds
├── CMake/
│   ├── CompileHLSL.cmake
│   ├── Copy.cmake
│   ├── SetBuildConfigurations.cmake
│   ├── SetupAgilitySDK.cmake
│   ├── SetupDXC.cmake
│   ├── SetupDoctest.cmake
│   ├── SetupImGui.cmake
│   ├── SetupWinPIX.cmake
│   ├── Setupcgltf.cmake
│   └── SetupxxHash.cmake
├── CMakeLists.txt
├── External/
│   ├── FSR2/
│   │   └── Include/
│   │       ├── dx12/
│   │       │   └── shaders/
│   │       │       └── ffx_fsr2_shaders_dx12.h
│   │       ├── ffx_assert.h
│   │       ├── ffx_error.h
│   │       ├── ffx_fsr2.h
│   │       ├── ffx_fsr2_interface.h
│   │       ├── ffx_types.h
│   │       ├── ffx_util.h
│   │       └── shaders/
│   │           ├── ffx_fsr2_common.h
│   │           └── ffx_fsr2_resources.h
│   ├── FastDelegate/
│   │   ├── FastDelegate.h
│   │   └── FastDelegateBind.h
│   ├── ImGui/
│   │   ├── ImGuizmo.cpp
│   │   ├── ImGuizmo.h
│   │   └── imconfig.h
│   ├── concurrentqueue/
│   │   ├── blockingconcurrentqueue.h
│   │   ├── concurrentqueue.h
│   │   └── lightweightsemaphore.h
│   └── stb/
│       ├── stb_image.h
│       ├── stb_image_write.h
│       └── stb_sprintf.h
├── LICENSE
├── README.md
├── Source/
│   ├── CMakeLists.txt
│   ├── ZetaCore/
│   │   ├── App/
│   │   │   ├── App.h
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Common.h
│   │   │   ├── Filesystem.h
│   │   │   ├── Log.h
│   │   │   ├── Path.h
│   │   │   ├── Timer.h
│   │   │   └── ZetaRay.h
│   │   ├── CMakeLists.txt
│   │   ├── Core/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── CommandList.cpp
│   │   │   ├── CommandList.h
│   │   │   ├── CommandQueue.cpp
│   │   │   ├── CommandQueue.h
│   │   │   ├── Config.h
│   │   │   ├── DescriptorHeap.cpp
│   │   │   ├── DescriptorHeap.h
│   │   │   ├── Device.cpp
│   │   │   ├── Device.h
│   │   │   ├── Direct3DUtil.cpp
│   │   │   ├── Direct3DUtil.h
│   │   │   ├── GpuMemory.cpp
│   │   │   ├── GpuMemory.h
│   │   │   ├── GpuTimer.cpp
│   │   │   ├── GpuTimer.h
│   │   │   ├── HLSLCompat.h
│   │   │   ├── Material.h
│   │   │   ├── PipelineStateLibrary.cpp
│   │   │   ├── PipelineStateLibrary.h
│   │   │   ├── RenderGraph.cpp
│   │   │   ├── RenderGraph.h
│   │   │   ├── RendererCore.cpp
│   │   │   ├── RendererCore.h
│   │   │   ├── RootSignature.cpp
│   │   │   ├── RootSignature.h
│   │   │   ├── SharedShaderResources.cpp
│   │   │   ├── SharedShaderResources.h
│   │   │   ├── Vertex.h
│   │   │   └── dds.h
│   │   ├── Math/
│   │   │   ├── BVH.cpp
│   │   │   ├── BVH.h
│   │   │   ├── CMakeLists.txt
│   │   │   ├── CollisionFuncs.h
│   │   │   ├── CollisionTypes.h
│   │   │   ├── Color.cpp
│   │   │   ├── Color.h
│   │   │   ├── Common.cpp
│   │   │   ├── Common.h
│   │   │   ├── Matrix.h
│   │   │   ├── MatrixFuncs.h
│   │   │   ├── OctahedralVector.h
│   │   │   ├── Quaternion.h
│   │   │   ├── Sampling.cpp
│   │   │   ├── Sampling.h
│   │   │   ├── Surface.cpp
│   │   │   ├── Surface.h
│   │   │   ├── Vector.h
│   │   │   └── VectorFuncs.h
│   │   ├── Model/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Mesh.cpp
│   │   │   ├── Mesh.h
│   │   │   ├── glTF.cpp
│   │   │   ├── glTF.h
│   │   │   └── glTFAsset.h
│   │   ├── RayTracing/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── RtAccelerationStructure.cpp
│   │   │   ├── RtAccelerationStructure.h
│   │   │   └── RtCommon.h
│   │   ├── Scene/
│   │   │   ├── Asset.cpp
│   │   │   ├── Asset.h
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Camera.cpp
│   │   │   ├── Camera.h
│   │   │   ├── SceneCommon.h
│   │   │   ├── SceneCore.cpp
│   │   │   ├── SceneCore.h
│   │   │   └── SceneRenderer.h
│   │   ├── Support/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── FrameMemory.h
│   │   │   ├── Memory.h
│   │   │   ├── MemoryArena.cpp
│   │   │   ├── MemoryArena.h
│   │   │   ├── MemoryPool.cpp
│   │   │   ├── MemoryPool.h
│   │   │   ├── OffsetAllocator.cpp
│   │   │   ├── OffsetAllocator.h
│   │   │   ├── Param.cpp
│   │   │   ├── Param.h
│   │   │   ├── Stat.h
│   │   │   ├── Task.cpp
│   │   │   ├── Task.h
│   │   │   ├── ThreadPool.cpp
│   │   │   └── ThreadPool.h
│   │   ├── Utility/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Error.cpp
│   │   │   ├── Error.h
│   │   │   ├── Function.h
│   │   │   ├── HashTable.h
│   │   │   ├── Optional.h
│   │   │   ├── RNG.h
│   │   │   ├── SmallVector.h
│   │   │   ├── Span.h
│   │   │   ├── SynchronizedView.h
│   │   │   └── Utility.h
│   │   └── Win32/
│   │       ├── CMakeLists.txt
│   │       ├── Win32.h
│   │       ├── Win32App.cpp
│   │       ├── Win32Common.cpp
│   │       ├── Win32Filesystem.cpp
│   │       └── Win32Timer.cpp
│   ├── ZetaLab/
│   │   ├── CMakeLists.txt
│   │   └── ZetaLab.cpp
│   ├── ZetaRenderPass/
│   │   ├── AutoExposure/
│   │   │   ├── AutoExposure.cpp
│   │   │   ├── AutoExposure.h
│   │   │   ├── AutoExposure_Common.h
│   │   │   ├── AutoExposure_Histogram.hlsl
│   │   │   ├── AutoExposure_WeightedAvg.hlsl
│   │   │   └── CMakeLists.txt
│   │   ├── CMakeLists.txt
│   │   ├── Common/
│   │   │   ├── BSDF.hlsli
│   │   │   ├── BSDFSampling.hlsli
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Common.hlsli
│   │   │   ├── FrameConstants.h
│   │   │   ├── GBuffers.hlsli
│   │   │   ├── LightSource.hlsli
│   │   │   ├── LightVoxelGrid.hlsli
│   │   │   ├── Math.hlsli
│   │   │   ├── RT.hlsli
│   │   │   ├── RayQuery.hlsli
│   │   │   ├── SH.hlsli
│   │   │   ├── Sampling.hlsli
│   │   │   ├── StaticTextureSamplers.hlsli
│   │   │   └── Volumetric.hlsli
│   │   ├── Compositing/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Compositing.cpp
│   │   │   ├── Compositing.h
│   │   │   ├── Compositing.hlsl
│   │   │   ├── Compositing_Common.h
│   │   │   └── FireflyFilter.hlsl
│   │   ├── DirectLighting/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Emissive/
│   │   │   │   ├── DirectLighting.cpp
│   │   │   │   ├── DirectLighting.h
│   │   │   │   ├── DirectLighting_Common.h
│   │   │   │   ├── PairwiseMIS.hlsli
│   │   │   │   ├── Params.hlsli
│   │   │   │   ├── ReSTIR_DI_Spatial.hlsl
│   │   │   │   ├── ReSTIR_DI_Temporal.hlsl
│   │   │   │   ├── ReSTIR_DI_Temporal_WPS.hlsl
│   │   │   │   ├── Resampling.hlsli
│   │   │   │   ├── Reservoir.hlsli
│   │   │   │   └── Util.hlsli
│   │   │   └── Sky/
│   │   │       ├── PairwiseMIS.hlsli
│   │   │       ├── Params.hlsli
│   │   │       ├── Resampling.hlsli
│   │   │       ├── Reservoir.hlsli
│   │   │       ├── SkyDI.cpp
│   │   │       ├── SkyDI.h
│   │   │       ├── SkyDI_Common.h
│   │   │       ├── SkyDI_Spatial.hlsl
│   │   │       ├── SkyDI_Temporal.hlsl
│   │   │       └── Util.hlsli
│   │   ├── Display/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Display.cpp
│   │   │   ├── Display.h
│   │   │   ├── Display.hlsl
│   │   │   ├── Display_Common.h
│   │   │   ├── DrawPicked.hlsl
│   │   │   ├── Sobel.hlsl
│   │   │   └── Tonemap.hlsli
│   │   ├── FSR2/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── FSR2.cpp
│   │   │   └── FSR2.h
│   │   ├── GBuffer/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── GBufferRT.cpp
│   │   │   ├── GBufferRT.h
│   │   │   ├── GBufferRT.hlsli
│   │   │   ├── GBufferRT_Common.h
│   │   │   ├── GBufferRT_Inline.hlsl
│   │   │   ├── GenerateDepthBuffer.cpp
│   │   │   ├── GenerateDepthBuffer.h
│   │   │   └── GenerateDepthBuffer.hlsl
│   │   ├── GUI/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── GuiPass.cpp
│   │   │   ├── GuiPass.h
│   │   │   ├── GuiPass_Common.h
│   │   │   └── ImGui.hlsl
│   │   ├── IndirectLighting/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── IndirectLighting.cpp
│   │   │   ├── IndirectLighting.h
│   │   │   ├── IndirectLighting_Common.h
│   │   │   ├── NEE.hlsli
│   │   │   ├── PathTracer/
│   │   │   │   ├── Params.hlsli
│   │   │   │   ├── PathTracer.hlsl
│   │   │   │   └── Variants/
│   │   │   │       ├── PathTracer_WPS.hlsl
│   │   │   │       └── PathTracer_WoPS.hlsl
│   │   │   ├── ReSTIR_GI/
│   │   │   │   ├── PairwiseMIS.hlsli
│   │   │   │   ├── Params.hlsli
│   │   │   │   ├── PathTracing.hlsli
│   │   │   │   ├── ReSTIR_GI.hlsl
│   │   │   │   ├── ReSTIR_GI_NEE.hlsli
│   │   │   │   ├── Resampling.hlsli
│   │   │   │   ├── Reservoir.hlsli
│   │   │   │   └── Variants/
│   │   │   │       ├── ReSTIR_GI_LVG.hlsl
│   │   │   │       ├── ReSTIR_GI_WPS.hlsl
│   │   │   │       └── ReSTIR_GI_WoPS.hlsl
│   │   │   └── ReSTIR_PT/
│   │   │       ├── Params.hlsli
│   │   │       ├── ReSTIR_PT_NEE.hlsli
│   │   │       ├── ReSTIR_PT_PathTrace.hlsl
│   │   │       ├── ReSTIR_PT_Reconnect_CtS.hlsl
│   │   │       ├── ReSTIR_PT_Reconnect_CtT.hlsl
│   │   │       ├── ReSTIR_PT_Reconnect_StC.hlsl
│   │   │       ├── ReSTIR_PT_Reconnect_TtC.hlsl
│   │   │       ├── ReSTIR_PT_Replay.hlsl
│   │   │       ├── ReSTIR_PT_Sort.hlsl
│   │   │       ├── ReSTIR_PT_SpatialSearch.hlsl
│   │   │       ├── Reservoir.hlsli
│   │   │       ├── SampleSet.hlsli
│   │   │       ├── Shift.hlsli
│   │   │       ├── Util.hlsli
│   │   │       └── Variants/
│   │   │           ├── ReSTIR_PT_PathTrace_WPS.hlsl
│   │   │           ├── ReSTIR_PT_PathTrace_WoPS.hlsl
│   │   │           ├── ReSTIR_PT_Reconnect_CtS_E.hlsl
│   │   │           ├── ReSTIR_PT_Reconnect_CtT_E.hlsl
│   │   │           ├── ReSTIR_PT_Reconnect_StC_E.hlsl
│   │   │           ├── ReSTIR_PT_Reconnect_TtC_E.hlsl
│   │   │           ├── ReSTIR_PT_Replay_CtS.hlsl
│   │   │           ├── ReSTIR_PT_Replay_CtS_E.hlsl
│   │   │           ├── ReSTIR_PT_Replay_E.hlsl
│   │   │           ├── ReSTIR_PT_Replay_StC.hlsl
│   │   │           ├── ReSTIR_PT_Replay_StC_E.hlsl
│   │   │           ├── ReSTIR_PT_Replay_TtC.hlsl
│   │   │           ├── ReSTIR_PT_Replay_TtC_E.hlsl
│   │   │           ├── ReSTIR_PT_Sort_CtS.hlsl
│   │   │           ├── ReSTIR_PT_Sort_StC.hlsl
│   │   │           └── ReSTIR_PT_Sort_TtC.hlsl
│   │   ├── PreLighting/
│   │   │   ├── BuildLightVoxelGrid.hlsl
│   │   │   ├── CMakeLists.txt
│   │   │   ├── EstimateTriEmissivePower.hlsl
│   │   │   ├── PreLighting.cpp
│   │   │   ├── PreLighting.h
│   │   │   ├── PreLighting_Common.h
│   │   │   └── PresampleEmissives.hlsl
│   │   ├── RenderPass.h
│   │   ├── Sky/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── Inscattering.hlsl
│   │   │   ├── Sky.cpp
│   │   │   ├── Sky.h
│   │   │   ├── SkyViewLUT.hlsl
│   │   │   └── Sky_Common.h
│   │   └── TAA/
│   │       ├── CMakeLists.txt
│   │       ├── TAA.cpp
│   │       ├── TAA.h
│   │       ├── TAA.hlsl
│   │       └── TAA_Common.h
│   └── ZetaRenderer/
│       ├── CMakeLists.txt
│       └── Default/
│           ├── CMakeLists.txt
│           ├── DefaultRenderer.cpp
│           ├── DefaultRenderer.h
│           ├── DefaultRendererImpl.h
│           ├── GBuffer.cpp
│           ├── PathTracer.cpp
│           └── PostProcessor.cpp
├── Tests/
│   ├── CMakeLists.txt
│   ├── TestAliasTable.cpp
│   ├── TestContainer.cpp
│   ├── TestMath.cpp
│   ├── TestOffsetAllocator.cpp
│   ├── TestOptional.cpp
│   └── main.cpp
└── Tools/
    ├── BCnCompressglTF/
    │   ├── BCnCompressglTF.cpp
    │   ├── CMakeLists.txt
    │   ├── DirectXTex/
    │   │   ├── BC.cpp
    │   │   ├── BC.h
    │   │   ├── BC4BC5.cpp
    │   │   ├── BC6HBC7.cpp
    │   │   ├── BCDirectCompute.cpp
    │   │   ├── BCDirectCompute.h
    │   │   ├── DDS.h
    │   │   ├── DirectXTex.h
    │   │   ├── DirectXTex.inl
    │   │   ├── DirectXTexCompress.cpp
    │   │   ├── DirectXTexCompressGPU.cpp
    │   │   ├── DirectXTexConvert.cpp
    │   │   ├── DirectXTexD3D11.cpp
    │   │   ├── DirectXTexDDS.cpp
    │   │   ├── DirectXTexFlipRotate.cpp
    │   │   ├── DirectXTexImage.cpp
    │   │   ├── DirectXTexMipmaps.cpp
    │   │   ├── DirectXTexMisc.cpp
    │   │   ├── DirectXTexP.h
    │   │   ├── DirectXTexResize.cpp
    │   │   ├── DirectXTexUtil.cpp
    │   │   ├── DirectXTexWIC.cpp
    │   │   ├── Shaders/
    │   │   │   └── Compiled/
    │   │   │       ├── BC6HEncode_EncodeBlockCS.inc
    │   │   │       ├── BC6HEncode_TryModeG10CS.inc
    │   │   │       ├── BC6HEncode_TryModeLE10CS.inc
    │   │   │       ├── BC7Encode_EncodeBlockCS.inc
    │   │   │       ├── BC7Encode_TryMode02CS.inc
    │   │   │       ├── BC7Encode_TryMode137CS.inc
    │   │   │       └── BC7Encode_TryMode456CS.inc
    │   │   ├── filters.h
    │   │   └── scoped.h
    │   └── TexConv/
    │       ├── texconv.cpp
    │       └── texconv.h
    ├── CMakeLists.txt
    ├── Natvis/
    │   ├── App.natvis
    │   ├── Container.natvis
    │   └── imgui.natvis
    └── PrecompileShaders/
        ├── CMakeLists.txt
        └── PrecompileShaders.cpp

SYMBOL INDEX (1791 symbols across 165 files)

FILE: Assets/Font/Font.h
  type FontSpan (line 7) | struct FontSpan
  type FONT_TYPE (line 13) | enum FONT_TYPE

FILE: External/FSR2/Include/dx12/shaders/ffx_fsr2_shaders_dx12.h
  type Fsr2ShaderBlobDX12 (line 32) | typedef struct Fsr2ShaderBlobDX12 {
  type Fs2ShaderPermutationOptionsDX12 (line 48) | typedef enum Fs2ShaderPermutationOptionsDX12 {

FILE: External/FSR2/Include/ffx_error.h
  type FfxErrorCode (line 27) | typedef int32_t FfxErrorCode;

FILE: External/FSR2/Include/ffx_fsr2.h
  type FfxFsr2QualityMode (line 74) | typedef enum FfxFsr2QualityMode {
  type FfxFsr2InitializationFlagBits (line 86) | typedef enum FfxFsr2InitializationFlagBits {
  type FfxFsr2ContextDescription (line 103) | typedef struct FfxFsr2ContextDescription {
  type FfxFsr2DispatchDescription (line 118) | typedef struct FfxFsr2DispatchDescription {
  type FfxFsr2GenerateReactiveDescription (line 154) | typedef struct FfxFsr2GenerateReactiveDescription {
  type FfxFsr2Context (line 179) | typedef struct FfxFsr2Context {

FILE: External/FSR2/Include/ffx_fsr2_interface.h
  type FfxFsr2Pass (line 56) | typedef enum FfxFsr2Pass {
  type FfxFsr2MsgType (line 71) | typedef enum FfxFsr2MsgType {
  type FfxErrorCode (line 91) | typedef FfxErrorCode (*FfxFsr2CreateBackendContextFunc)(
  type FfxErrorCode (line 120) | typedef FfxErrorCode(*FfxFsr2GetDeviceCapabilitiesFunc)(
  type FfxErrorCode (line 137) | typedef FfxErrorCode(*FfxFsr2DestroyBackendContextFunc)(
  type FfxErrorCode (line 164) | typedef FfxErrorCode (*FfxFsr2CreateResourceFunc)(
  type FfxErrorCode (line 188) | typedef FfxErrorCode(*FfxFsr2RegisterResourceFunc)(
  type FfxErrorCode (line 206) | typedef FfxErrorCode(*FfxFsr2UnregisterResourcesFunc)(
  type FfxResourceDescription (line 219) | typedef FfxResourceDescription (*FfxFsr2GetResourceDescriptionFunc)(
  type FfxErrorCode (line 236) | typedef FfxErrorCode (*FfxFsr2DestroyResourceFunc)(
  type FfxErrorCode (line 256) | typedef FfxErrorCode (*FfxFsr2CreatePipelineFunc)(
  type FfxErrorCode (line 273) | typedef FfxErrorCode (*FfxFsr2DestroyPipelineFunc)(
  type FfxErrorCode (line 292) | typedef FfxErrorCode (*FfxFsr2ScheduleGpuJobFunc)(
  type FfxErrorCode (line 318) | typedef FfxErrorCode (*FfxFsr2ExecuteGpuJobsFunc)(
  type FfxFsr2Interface (line 374) | typedef struct FfxFsr2Interface {

FILE: External/FSR2/Include/ffx_types.h
  type FfxSurfaceFormat (line 64) | typedef enum FfxSurfaceFormat {
  type FfxResourceUsage (line 89) | typedef enum FfxResourceUsage {
  type FfxResourceStates (line 97) | typedef enum FfxResourceStates {
  type FfxResourceDimension (line 107) | typedef enum FfxResourceDimension {
  type FfxResourceFlags (line 114) | typedef enum FfxResourceFlags {
  type FfxResourceViewType (line 121) | typedef enum FfxResourceViewType {
  type FfxFilterType (line 128) | typedef enum FfxFilterType {
  type FfxShaderModel (line 135) | typedef enum FfxShaderModel {
  type FfxResourceType (line 149) | typedef enum FfxResourceType {
  type FfxHeapType (line 158) | typedef enum FfxHeapType {
  type FfxGpuJobType (line 165) | typedef enum FfxGpuJobType {
  type FfxDeviceCapabilities (line 185) | typedef struct FfxDeviceCapabilities {
  type FfxDimensions2D (line 195) | typedef struct FfxDimensions2D {
  type FfxIntCoords2D (line 202) | typedef struct FfxIntCoords2D {
  type FfxFloatCoords2D (line 209) | typedef struct FfxFloatCoords2D {
  type FfxResourceDescription (line 216) | typedef struct FfxResourceDescription {
  type FfxResource (line 228) | typedef struct FfxResource {
  type FfxResourceInternal (line 238) | typedef struct FfxResourceInternal {
  type FfxResourceBinding (line 244) | typedef struct FfxResourceBinding
  type FfxPipelineState (line 252) | typedef struct FfxPipelineState {
  type FfxCreateResourceDescription (line 266) | typedef struct FfxCreateResourceDescription {
  type FfxPipelineDescription (line 305) | typedef struct FfxPipelineDescription {
  type FfxConstantBuffer (line 315) | typedef struct FfxConstantBuffer {
  type FfxClearFloatJobDescription (line 322) | typedef struct FfxClearFloatJobDescription {
  type FfxComputeJobDescription (line 329) | typedef struct FfxComputeJobDescription {
  type FfxCopyJobDescription (line 344) | typedef struct FfxCopyJobDescription
  type FfxGpuJobDescription (line 351) | typedef struct FfxGpuJobDescription{

FILE: External/FSR2/Include/shaders/ffx_fsr2_common.h
  type AccumulationPassCommonParams (line 58) | struct AccumulationPassCommonParams
  type LockState (line 75) | struct LockState
  function InitializeNewLockSample (line 81) | void InitializeNewLockSample(FFX_PARAMETER_OUT FfxFloat32x2 fLockStatus)
  function InitializeNewLockSample (line 87) | void InitializeNewLockSample(FFX_PARAMETER_OUT FFX_MIN16_F2 fLockStatus)
  function KillLock (line 94) | void KillLock(FFX_PARAMETER_INOUT FfxFloat32x2 fLockStatus)
  function KillLock (line 100) | void KillLock(FFX_PARAMETER_INOUT FFX_MIN16_F2 fLockStatus)
  type RectificationBox (line 106) | struct RectificationBox
  type RectificationBoxMin16 (line 115) | struct RectificationBoxMin16
  function RectificationBoxReset (line 125) | void RectificationBoxReset(FFX_PARAMETER_INOUT RectificationBox rectific...
  function RectificationBoxReset (line 135) | void RectificationBoxReset(FFX_PARAMETER_INOUT RectificationBoxMin16 rec...
  function RectificationBoxAddInitialSample (line 146) | void RectificationBoxAddInitialSample(FFX_PARAMETER_INOUT RectificationB...
  function RectificationBoxAddSample (line 157) | void RectificationBoxAddSample(FfxBoolean bInitialSample, FFX_PARAMETER_...
  function RectificationBoxAddInitialSample (line 172) | void RectificationBoxAddInitialSample(FFX_PARAMETER_INOUT RectificationB...
  function RectificationBoxAddSample (line 183) | void RectificationBoxAddSample(FfxBoolean bInitialSample, FFX_PARAMETER_...
  function RectificationBoxComputeVarianceBoxData (line 199) | void RectificationBoxComputeVarianceBoxData(FFX_PARAMETER_INOUT Rectific...
  function RectificationBoxComputeVarianceBoxData (line 208) | void RectificationBoxComputeVarianceBoxData(FFX_PARAMETER_INOUT Rectific...
  function FfxFloat32x3 (line 218) | FfxFloat32x3 SafeRcp3(FfxFloat32x3 v)
  function FFX_MIN16_F3 (line 223) | FFX_MIN16_F3 SafeRcp3(FFX_MIN16_F3 v)
  function FfxFloat32 (line 229) | FfxFloat32 MinDividedByMax(const FfxFloat32 v0, const FfxFloat32 v1)
  function FFX_MIN16_F (line 236) | FFX_MIN16_F MinDividedByMax(const FFX_MIN16_F v0, const FFX_MIN16_F v1)
  function FfxFloat32x3 (line 243) | FfxFloat32x3 YCoCgToRGB(FfxFloat32x3 fYCoCg)
  function FFX_MIN16_F3 (line 255) | FFX_MIN16_F3 YCoCgToRGB(FFX_MIN16_F3 fYCoCg)
  function FfxFloat32x3 (line 268) | FfxFloat32x3 RGBToYCoCg(FfxFloat32x3 fRgb)
  function FFX_MIN16_F3 (line 280) | FFX_MIN16_F3 RGBToYCoCg(FFX_MIN16_F3 fRgb)
  function FfxFloat32 (line 293) | FfxFloat32 RGBToLuma(FfxFloat32x3 fLinearRgb)
  function FFX_MIN16_F (line 298) | FFX_MIN16_F RGBToLuma(FFX_MIN16_F3 fLinearRgb)
  function FfxFloat32 (line 304) | FfxFloat32 RGBToPerceivedLuma(FfxFloat32x3 fLinearRgb)
  function FFX_MIN16_F (line 319) | FFX_MIN16_F RGBToPerceivedLuma(FFX_MIN16_F3 fLinearRgb)
  function FfxFloat32x3 (line 335) | FfxFloat32x3 Tonemap(FfxFloat32x3 fRgb)
  function FfxFloat32x3 (line 340) | FfxFloat32x3 InverseTonemap(FfxFloat32x3 fRgb)
  function FFX_MIN16_F3 (line 346) | FFX_MIN16_F3 Tonemap(FFX_MIN16_F3 fRgb)
  function FFX_MIN16_F3 (line 351) | FFX_MIN16_F3 InverseTonemap(FFX_MIN16_F3 fRgb)
  function FfxInt32x2 (line 357) | FfxInt32x2 ClampLoad(FfxInt32x2 iPxSample, FfxInt32x2 iPxOffset, FfxInt3...
  function FFX_MIN16_I2 (line 369) | FFX_MIN16_I2 ClampLoad(FFX_MIN16_I2 iPxSample, FFX_MIN16_I2 iPxOffset, F...
  function FfxFloat32x2 (line 382) | FfxFloat32x2 ClampUv(FfxFloat32x2 fUv, FfxInt32x2 iTextureSize, FfxInt32...
  function FfxBoolean (line 391) | FfxBoolean IsOnScreen(FfxInt32x2 pos, FfxInt32x2 size)
  function FfxBoolean (line 396) | FfxBoolean IsOnScreen(FFX_MIN16_I2 pos, FFX_MIN16_I2 size)
  function FfxFloat32 (line 402) | FfxFloat32 ComputeAutoExposureFromLavg(FfxFloat32 Lavg)
  function FFX_MIN16_F (line 416) | FFX_MIN16_F ComputeAutoExposureFromLavg(FFX_MIN16_F Lavg)
  function FfxInt32x2 (line 431) | FfxInt32x2 ComputeHrPosFromLrPos(FfxInt32x2 iPxLrPos)
  function FFX_MIN16_I2 (line 439) | FFX_MIN16_I2 ComputeHrPosFromLrPos(FFX_MIN16_I2 iPxLrPos)
  function FfxFloat32x2 (line 448) | FfxFloat32x2 ComputeNdc(FfxFloat32x2 fPxPos, FfxInt32x2 iSize)
  function FfxFloat32 (line 453) | FfxFloat32 GetViewSpaceDepth(FfxFloat32 fDeviceDepth)
  function FfxFloat32 (line 461) | FfxFloat32 GetViewSpaceDepthInMeters(FfxFloat32 fDeviceDepth)
  function FfxFloat32x3 (line 466) | FfxFloat32x3 GetViewSpacePosition(FfxInt32x2 iViewportPos, FfxInt32x2 iV...
  function FfxFloat32x3 (line 479) | FfxFloat32x3 GetViewSpacePositionInMeters(FfxInt32x2 iViewportPos, FfxIn...
  function FfxFloat32 (line 484) | FfxFloat32 GetMaxDistanceInMeters()
  function FfxFloat32x3 (line 493) | FfxFloat32x3 PrepareRgb(FfxFloat32x3 fRgb, FfxFloat32 fExposure, FfxFloa...
  function FfxFloat32x3 (line 503) | FfxFloat32x3 UnprepareRgb(FfxFloat32x3 fRgb, FfxFloat32 fExposure)
  type BilinearSamplingData (line 512) | struct BilinearSamplingData
  function BilinearSamplingData (line 519) | BilinearSamplingData GetBilinearSamplingData(FfxFloat32x2 fUv, FfxInt32x...
  type PlaneData (line 540) | struct PlaneData
  function PlaneData (line 546) | PlaneData GetPlaneFromPoints(FfxFloat32x3 fP0, FfxFloat32x3 fP1, FfxFloa...
  function FfxFloat32 (line 558) | FfxFloat32 PointToPlaneDistance(PlaneData plane, FfxFloat32x3 fPoint)

FILE: External/FastDelegate/FastDelegate.h
  function namespace (line 142) | namespace fastdelegate {
  function namespace (line 661) | namespace detail {
  type DesiredRetType (line 857) | typedef DesiredRetType (*StaticFunctionPtr)();
  type RetType (line 858) | typedef RetType (*UnvoidStaticFunctionPtr)();
  type detail (line 860) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 885) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)()) {
  function bind (line 901) | inline void bind(DesiredRetType (*function_to_bind)()) {
  type StaticFunctionPtr (line 913) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 919) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 921) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 927) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 929) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 930) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type DesiredRetType (line 942) | typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1);
  type RetType (line 943) | typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1);
  type detail (line 945) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 970) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1)) {
  function const (line 977) | void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 ...
  function bind (line 986) | inline void bind(DesiredRetType (*function_to_bind)(Param1 p1)) {
  function RetType (line 990) | RetType operator() (Param1 p1) const {
  type StaticFunctionPtr (line 998) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 1004) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 1006) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 1012) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 1014) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 1015) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type DesiredRetType (line 1027) | typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2);
  type RetType (line 1028) | typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2);
  type detail (line 1030) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 1055) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Pa...
  function const (line 1062) | void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 ...
  function bind (line 1071) | inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2...
  function RetType (line 1075) | RetType operator() (Param1 p1, Param2 p2) const {
  type StaticFunctionPtr (line 1083) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 1089) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 1091) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 1097) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 1099) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 1100) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type DesiredRetType (line 1112) | typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3...
  type RetType (line 1113) | typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 ...
  type detail (line 1115) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 1140) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Pa...
  function const (line 1147) | void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 ...
  function bind (line 1156) | inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2...
  function RetType (line 1160) | RetType operator() (Param1 p1, Param2 p2, Param3 p3) const {
  type StaticFunctionPtr (line 1168) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 1174) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 1176) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 1182) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 1184) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 1185) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type DesiredRetType (line 1197) | typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3...
  type RetType (line 1198) | typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 ...
  type detail (line 1200) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 1225) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Pa...
  function const (line 1232) | void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 ...
  function bind (line 1241) | inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2...
  function RetType (line 1245) | RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const {
  type StaticFunctionPtr (line 1253) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 1259) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 1261) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 1267) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 1269) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 1270) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type DesiredRetType (line 1282) | typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3...
  type RetType (line 1283) | typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 ...
  type detail (line 1285) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 1310) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Pa...
  function const (line 1317) | void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 ...
  function bind (line 1326) | inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2...
  function RetType (line 1330) | RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p...
  type StaticFunctionPtr (line 1338) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 1344) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 1346) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 1352) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 1354) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 1355) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type DesiredRetType (line 1367) | typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3...
  type RetType (line 1368) | typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 ...
  type detail (line 1370) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 1395) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Pa...
  function const (line 1402) | void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 ...
  function bind (line 1411) | inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2...
  function RetType (line 1415) | RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p...
  type StaticFunctionPtr (line 1423) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 1429) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 1431) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 1437) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 1439) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 1440) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type DesiredRetType (line 1452) | typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3...
  type RetType (line 1453) | typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 ...
  type detail (line 1455) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 1480) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Pa...
  function const (line 1487) | void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 ...
  function bind (line 1496) | inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2...
  function RetType (line 1500) | RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p...
  type StaticFunctionPtr (line 1508) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 1514) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 1516) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 1522) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 1524) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 1525) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type DesiredRetType (line 1537) | typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3...
  type RetType (line 1538) | typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 ...
  type detail (line 1540) | typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStatic...
  function bind (line 1565) | void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Pa...
  function const (line 1572) | void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 ...
  function bind (line 1581) | inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2...
  function RetType (line 1585) | RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p...
  type StaticFunctionPtr (line 1593) | typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  function StaticFunctionPtr (line 1599) | inline bool operator==(StaticFunctionPtr funcptr) {
  function StaticFunctionPtr (line 1601) | inline bool operator!=(StaticFunctionPtr funcptr) {
  function clear (line 1607) | void clear() { m_Closure.clear();}
  function DelegateMemento (line 1609) | const DelegateMemento & GetMemento() { return m_Closure; }
  function SetMemento (line 1610) | void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, a...
  type FastDelegate (line 1651) | typedef FastDelegate SelfType;
  function BaseType (line 1668) | BaseType(function_to_bind)  { }
  type FastDelegate (line 1688) | typedef FastDelegate SelfType;
  function BaseType (line 1705) | BaseType(function_to_bind)  { }
  type FastDelegate (line 1725) | typedef FastDelegate SelfType;
  function BaseType (line 1742) | BaseType(function_to_bind)  { }
  type FastDelegate (line 1762) | typedef FastDelegate SelfType;
  function BaseType (line 1779) | BaseType(function_to_bind)  { }
  type FastDelegate (line 1799) | typedef FastDelegate SelfType;
  function BaseType (line 1816) | BaseType(function_to_bind)  { }
  type FastDelegate (line 1836) | typedef FastDelegate SelfType;
  function BaseType (line 1853) | BaseType(function_to_bind)  { }
  type FastDelegate (line 1873) | typedef FastDelegate SelfType;
  function BaseType (line 1890) | BaseType(function_to_bind)  { }
  type FastDelegate (line 1910) | typedef FastDelegate SelfType;
  function BaseType (line 1927) | BaseType(function_to_bind)  { }
  type FastDelegate (line 1947) | typedef FastDelegate SelfType;
  function BaseType (line 1964) | BaseType(function_to_bind)  { }

FILE: External/ImGui/ImGuizmo.cpp
  type IMGUIZMO_NAMESPACE (line 54) | namespace IMGUIZMO_NAMESPACE
    function OPERATION (line 64) | static OPERATION operator&(OPERATION lhs, OPERATION rhs)
    function Intersects (line 74) | static bool Intersects(OPERATION lhs, OPERATION rhs)
    function Contains (line 80) | static bool Contains(OPERATION lhs, OPERATION rhs)
    function FPU_MatrixF_x_MatrixF (line 87) | void FPU_MatrixF_x_MatrixF(const float* a, const float* b, float* r)
    function Frustum (line 110) | void Frustum(float left, float right, float bottom, float top, float z...
    function Perspective (line 135) | void Perspective(float fovyInDegrees, float aspectRatio, float znear, ...
    function Cross (line 143) | void Cross(const float* a, const float* b, float* r)
    function Dot (line 150) | float Dot(const float* a, const float* b)
    function Normalize (line 155) | void Normalize(const float* a, float* r)
    function LookAt (line 163) | void LookAt(const float* eye, const float* at, const float* up, float*...
    function T (line 195) | T Clamp(T x, T y, T z) { return ((x < y) ? y : ((x > z) ? z : x)); }
    function T (line 196) | T max(T x, T y) { return (x > y) ? x : y; }
    function T (line 197) | T min(T x, T y) { return (x < y) ? x : y; }
    function IsWithin (line 198) | bool IsWithin(T x, T y, T z) { return (x >= y) && (x <= z); }
    type matrix_t (line 200) | struct matrix_t
      method Translation (line 352) | void Translation(float _x, float _y, float _z) { this->Translation(m...
      method Translation (line 354) | void Translation(const vec_t& vt)
      method Scale (line 362) | void Scale(float _x, float _y, float _z)
      method Scale (line 369) | void Scale(const vec_t& s) { Scale(s.x, s.y, s.z); }
      method matrix_t (line 371) | matrix_t& operator *= (const matrix_t& mat)
      method matrix_t (line 379) | matrix_t operator * (const matrix_t& mat) const
      method Multiply (line 386) | void Multiply(const matrix_t& matrix)
      method Multiply (line 394) | void Multiply(const matrix_t& m1, const matrix_t& m2)
      method GetDeterminant (line 399) | float GetDeterminant() const
      method SetToIdentity (line 406) | void SetToIdentity()
      method Transpose (line 413) | void Transpose()
      method OrthoNormalize (line 428) | void OrthoNormalize()
    type vec_t (line 201) | struct vec_t
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 299) | vec_t makeVect(float _x, float _y, float _z = 0.f, float _w = 0.f) { v...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 300) | vec_t makeVect(ImVec2 v) { vec_t res; res.x = v.x; res.y = v.y; res.z ...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 301) | vec_t vec_t::operator * (float f) const { return makeVect(x * f, y * f...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 302) | vec_t vec_t::operator - () const { return makeVect(-x, -y, -z, -w); }
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 303) | vec_t vec_t::operator - (const vec_t& v) const { return makeVect(x - v...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 304) | vec_t vec_t::operator + (const vec_t& v) const { return makeVect(x + v...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 305) | vec_t vec_t::operator * (const vec_t& v) const { return makeVect(x * v...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 306) | vec_t vec_t::Abs() const { return makeVect(fabsf(x), fabsf(y), fabsf(z...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 308) | vec_t Normalized(const vec_t& v) { vec_t res; res = v; res.Normalize()...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function vec_t (line 309) | vec_t Cross(const vec_t& v1, const vec_t& v2)
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function Dot (line 319) | float Dot(const vec_t& v1, const vec_t& v2)
    function vec_t (line 324) | vec_t BuildPlane(const vec_t& p_point1, const vec_t& p_normal)
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    type matrix_t (line 335) | struct matrix_t
      method Translation (line 352) | void Translation(float _x, float _y, float _z) { this->Translation(m...
      method Translation (line 354) | void Translation(const vec_t& vt)
      method Scale (line 362) | void Scale(float _x, float _y, float _z)
      method Scale (line 369) | void Scale(const vec_t& s) { Scale(s.x, s.y, s.z); }
      method matrix_t (line 371) | matrix_t& operator *= (const matrix_t& mat)
      method matrix_t (line 379) | matrix_t operator * (const matrix_t& mat) const
      method Multiply (line 386) | void Multiply(const matrix_t& matrix)
      method Multiply (line 394) | void Multiply(const matrix_t& m1, const matrix_t& m2)
      method GetDeterminant (line 399) | float GetDeterminant() const
      method SetToIdentity (line 406) | void SetToIdentity()
      method Transpose (line 413) | void Transpose()
      method OrthoNormalize (line 428) | void OrthoNormalize()
    type MOVETYPE (line 627) | enum MOVETYPE
    function IsTranslateType (line 647) | static bool IsTranslateType(int type)
    function IsRotateType (line 652) | static bool IsRotateType(int type)
    function IsScaleType (line 657) | static bool IsScaleType(int type)
    type Context (line 701) | struct Context
      method Context (line 703) | Context() : mbUsing(false), mbUsingViewManipulate(false), mbEnable(t...
      method ImGuiID (line 798) | inline ImGuiID GetCurrentID() {return mIDStack.back();}
    function Style (line 822) | Style& GetStyle()
    function ImU32 (line 827) | static ImU32 GetColorU32(int idx)
    function ImVec2 (line 833) | static ImVec2 worldToPos(const vec_t& worldPos, const matrix_t& mat,
    function ComputeCameraRay (line 849) | static void ComputeCameraRay(vec_t& rayOrigin, vec_t& rayDir,
    function GetSegmentLengthClipSpace (line 876) | static float GetSegmentLengthClipSpace(const vec_t& start, const vec_t...
    function GetParallelogram (line 900) | static float GetParallelogram(const vec_t& ptO, const vec_t& ptA, cons...
    function vec_t (line 920) | inline vec_t PointOnSegment(const vec_t& point, const vec_t& vertPos1,...
      method vec_t (line 206) | vec_t() = default;
      method vec_t (line 207) | vec_t(float v0, float v1, float v2, float v3)
      method vec_t (line 213) | vec_t(const float3& v)
      method vec_t (line 219) | vec_t(const float4& v)
      method Lerp (line 226) | void Lerp(const vec_t& v, float t)
      method Set (line 234) | void Set(float v) { x = y = z = w = v; }
      method Set (line 235) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
      method vec_t (line 237) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
      method vec_t (line 238) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
      method vec_t (line 239) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
      method vec_t (line 240) | vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *=...
      method vec_t (line 248) | const vec_t& operator + () const { return (*this); }
      method Length (line 249) | float Length() const { return sqrtf(x * x + y * y + z * z); }
      method LengthSq (line 250) | float LengthSq() const { return (x * x + y * y + z * z); }
      method vec_t (line 251) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
      method vec_t (line 252) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
      method Cross (line 255) | void Cross(const vec_t& v)
      method Cross (line 268) | void Cross(const vec_t& v1, const vec_t& v2)
      method Dot (line 276) | float Dot(const vec_t& v) const
      method Dot3 (line 281) | float Dot3(const vec_t& v) const
      method TransformVector (line 291) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
      method TransformPoint (line 292) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
    function IntersectRayPlane (line 938) | static float IntersectRayPlane(const vec_t& rOrigin, const vec_t& rVec...
    function IsInContextRect (line 949) | static bool IsInContextRect(ImVec2 p)
    function IsHoveringWindow (line 954) | static bool IsHoveringWindow()
    function SetRect (line 969) | void SetRect(float x, float y, float width, float height)
    function SetDrawlist (line 980) | void SetDrawlist(ImDrawList* drawlist)
    function SetImGuiContext (line 985) | void SetImGuiContext(ImGuiContext* ctx)
    function BeginFrame (line 990) | void BeginFrame()
    function IsUsing (line 1017) | bool IsUsing()
    function IsUsingViewManipulate (line 1022) | bool IsUsingViewManipulate()
    function IsUsingAny (line 1027) | bool IsUsingAny()
    function IsOver (line 1032) | bool IsOver()
    function IsOver (line 1039) | bool IsOver(OPERATION op)
    function Enable (line 1052) | void Enable(bool enable)
    function ComputeContext (line 1062) | static void ComputeContext(float4x4a& matrix, MODE mode)
    function ComputeColors (line 1124) | static void ComputeColors(ImU32* colors, int type, OPERATION operation)
    function ComputeTripodAxisAndVisibility (line 1165) | static void ComputeTripodAxisAndVisibility(const int axisIndex, vec_t&...
    function ComputeSnap (line 1235) | static void ComputeSnap(float* value, float snap)
    function ComputeSnap (line 1247) | static void ComputeSnap(vec_t& value, const float* snap)
    function ComputeAngleOnPlan (line 1253) | static float ComputeAngleOnPlan()
    function DrawRotationGizmo (line 1269) | static void DrawRotationGizmo(OPERATION op, int type)
    function DrawHatchedAxis (line 1372) | static void DrawHatchedAxis(const vec_t& axis)
    function DrawScaleGizmo (line 1388) | static void DrawScaleGizmo(OPERATION op, int type)
    function DrawScaleUniveralGizmo (line 1476) | static void DrawScaleUniveralGizmo(OPERATION op, int type)
    function DrawTranslationGizmo (line 1542) | static void DrawTranslationGizmo(OPERATION op, int type)
    function CanActivate (line 1649) | static bool CanActivate()
    function GetScaleType (line 1658) | static int GetScaleType(OPERATION op)
    function GetRotateType (line 1746) | static int GetRotateType(OPERATION op)
    function GetMoveType (line 1815) | static int GetMoveType(OPERATION op, vec_t* gizmoHitProportion)
    function HandleTranslation (line 1884) | static bool HandleTranslation(float* matrix, float3& dt, OPERATION op,...
    function HandleScale (line 1995) | static bool HandleScale(float* matrix, float3& ds, OPERATION op, int& ...
    function HandleRotation (line 2117) | static bool HandleRotation(float* matrix, float4x4a& dr, OPERATION op,...
    function SetAlternativeWindow (line 2217) | void SetAlternativeWindow(ImGuiWindow* window)
    function SetID (line 2222) | void SetID(int id)
    function ImGuiID (line 2227) | ImGuiID GetID(const char* str, const char* str_end)
    function ImGuiID (line 2234) | ImGuiID GetID(const char* str)
    function ImGuiID (line 2239) | ImGuiID GetID(const void* ptr)
    function ImGuiID (line 2246) | ImGuiID GetID(int n)
    function PushID (line 2253) | void PushID(const char* str_id)
    function PushID (line 2259) | void PushID(const char* str_id_begin, const char* str_id_end)
    function PushID (line 2265) | void PushID(const void* ptr_id)
    function PushID (line 2271) | void PushID(int int_id)
    function PopID (line 2277) | void PopID()
    function AllowAxisFlip (line 2283) | void AllowAxisFlip(bool value)
    function SetAxisLimit (line 2288) | void SetAxisLimit(float value)
    function SetAxisMask (line 2293) | void SetAxisMask(bool x, bool y, bool z)
    function SetPlaneLimit (line 2298) | void SetPlaneLimit(float value)
    function IsOver (line 2303) | bool IsOver(float* position, float pixelRadius)
    function Manipulate (line 2312) | bool Manipulate(OPERATION operation, MODE mode, float4x4a& world, floa...
    function SetGizmoSizeClipSpace (line 2360) | void SetGizmoSizeClipSpace(float value)

FILE: External/ImGui/ImGuizmo.h
  function EditTransform (line 46) | void EditTransform(const Camera& camera, matrix_t& matrix)
  type ImGuiWindow (line 119) | struct ImGuiWindow
  type ImDrawList (line 120) | struct ImDrawList
  type ImGuiContext (line 121) | struct ImGuiContext
  function namespace (line 123) | namespace ZetaRay::Math
  function namespace (line 129) | namespace IMGUIZMO_NAMESPACE

FILE: External/concurrentqueue/blockingconcurrentqueue.h
  function namespace (line 19) | namespace moodycamel
  function swap (line 100) | inline void swap(BlockingConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
  function enqueue (line 137) | inline bool enqueue(T&& item)
  function enqueue (line 150) | inline bool enqueue(producer_token_t const& token, T const& item)
  function enqueue (line 163) | inline bool enqueue(producer_token_t const& token, T&& item)
  function try_enqueue (line 209) | inline bool try_enqueue(T const& item)
  function try_enqueue (line 223) | inline bool try_enqueue(T&& item)
  function try_enqueue (line 235) | inline bool try_enqueue(producer_token_t const& token, T const& item)
  function try_enqueue (line 247) | inline bool try_enqueue(producer_token_t const& token, T&& item)
  function is_lock_free (line 547) | static constexpr bool is_lock_free()
  function destroy (line 562) | void destroy(U* p)

FILE: External/concurrentqueue/concurrentqueue.h
  function namespace (line 83) | namespace moodycamel { namespace details {
  function namespace (line 91) | namespace moodycamel { namespace details {
  function namespace (line 101) | namespace moodycamel { namespace details {
  function namespace (line 109) | namespace moodycamel { namespace details {
  function namespace (line 154) | namespace moodycamel { namespace details {
  function namespace (line 237) | namespace moodycamel { namespace details {
  function namespace (line 276) | namespace moodycamel { namespace details {
  function namespace (line 290) | namespace moodycamel {
  type ConsumerToken (line 716) | struct ConsumerToken
  function swap (line 955) | inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
  function enqueue (line 1006) | inline bool enqueue(T&& item)
  function enqueue (line 1016) | inline bool enqueue(producer_token_t const& token, T const& item)
  function enqueue (line 1025) | inline bool enqueue(producer_token_t const& token, T&& item)
  function try_enqueue (line 1060) | inline bool try_enqueue(T const& item)
  function try_enqueue (line 1071) | inline bool try_enqueue(T&& item)
  function try_enqueue (line 1080) | inline bool try_enqueue(producer_token_t const& token, T const& item)
  function try_enqueue (line 1088) | inline bool try_enqueue(producer_token_t const& token, T&& item)
  function size_approx (line 1325) | size_t size_approx() const
  function update_current_producer_after_rotation (line 1392) | inline bool update_current_producer_after_rotation(consumer_token_t& token)
  function freeListHead (line 1452) | freeListHead(nullptr) { }
  function swap (line 1454) | void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.f...
  function add (line 1459) | inline void add(N* node)
  function N (line 1473) | inline N* try_get()
  function N (line 1513) | N* head_unsafe() const { return freeListHead.load(std::memory_order_rela...
  type InnerQueueContext (line 1557) | enum InnerQueueContext { implicit_context = 0, explicit_context = 1 }
  function else (line 1559) | struct Block
  function T (line 1666) | inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_ca...
  function T (line 1667) | inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { retu...
  type MemStats (line 1690) | struct MemStats
  type ProducerBase (line 1698) | struct ProducerBase
  function virtual (line 1711) | virtual ~ProducerBase() { }
  function ProducerBase (line 1735) | inline ProducerBase* next_prod() const { return static_cast<ProducerBase...
  function size_approx (line 1737) | inline size_t size_approx() const
  function ProducerBase (line 1769) | struct ExplicitProducer : public ProducerBase
  function else (line 1890) | else if (!new_block_index(pr_blockIndexSlotsUsed)) {
  type Guard (line 2024) | struct Guard {
  function else (line 2101) | else if (full || !new_block_index(originalBlockIndexSlotsUsed)) {
  function else (line 2181) | else {
  type BlockIndexEntry (line 2341) | struct BlockIndexEntry
  type BlockIndexHeader (line 2347) | struct BlockIndexHeader
  function new_block_index (line 2356) | bool new_block_index(size_t numberOfFilledSlotsToExpose)
  function ProducerBase (line 2421) | struct ImplicitProducer : public ProducerBase
  function else (line 2720) | else {
  type BlockIndexEntry (line 2885) | struct BlockIndexEntry
  type BlockIndexHeader (line 2891) | struct BlockIndexHeader
  function else (line 2921) | else if (!new_block_index()) {
  function rewind_block_index_tail (line 2935) | inline void rewind_block_index_tail()
  function BlockIndexEntry (line 2941) | inline BlockIndexEntry* get_block_index_entry_for_index(index_t index) c...
  function get_block_index_index_for_index (line 2948) | inline size_t get_block_index_index_for_index(index_t index, BlockIndexH...
  function new_block_index (line 2966) | bool new_block_index()
  function populate_initial_block_list (line 3039) | void populate_initial_block_list(size_t blockCount)
  function Block (line 3056) | inline Block* try_get_block_from_initial_pool()
  function add_block_to_free_list (line 3067) | inline void add_block_to_free_list(Block* block)
  function add_blocks_to_free_list (line 3080) | inline void add_blocks_to_free_list(Block* block)
  function Block (line 3089) | inline Block* try_get_block_from_free_list()
  type MemStats (line 3119) | struct MemStats {
  function MemStats (line 3214) | MemStats getMemStats()
  function ProducerBase (line 3227) | ProducerBase* recycle_or_create_producer(bool isExplicit)
  function ProducerBase (line 3246) | ProducerBase* add_producer(ProducerBase* producer)
  function reown_producers (line 3279) | void reown_producers()
  type ImplicitProducerKVP (line 3294) | struct ImplicitProducerKVP
  function swap (line 3313) | inline void swap(ImplicitProducerKVP& other) MOODYCAMEL_NOEXCEPT
  type ImplicitProducerHash (line 3325) | struct ImplicitProducerHash
  function populate_initial_implicit_producer_hash (line 3332) | inline void populate_initial_implicit_producer_hash()
  function swap_implicit_producer_hashes (line 3350) | void swap_implicit_producer_hashes(ConcurrentQueue& other)
  function ImplicitProducer (line 3388) | ImplicitProducer* get_or_add_implicit_producer()
  function swap (line 3723) | inline void swap(ProducerToken& a, ProducerToken& b) MOODYCAMEL_NOEXCEPT
  function swap (line 3728) | inline void swap(ConsumerToken& a, ConsumerToken& b) MOODYCAMEL_NOEXCEPT

FILE: External/concurrentqueue/lightweightsemaphore.h
  type _SECURITY_ATTRIBUTES (line 19) | struct _SECURITY_ATTRIBUTES
  function namespace (line 37) | namespace moodycamel
  function tryWait (line 355) | bool tryWait()
  function wait (line 366) | bool wait()
  function wait (line 371) | bool wait(std::int64_t timeout_usecs)
  function tryWaitMany (line 377) | ssize_t tryWaitMany(ssize_t max)
  function waitMany (line 391) | ssize_t waitMany(ssize_t max, std::int64_t timeout_usecs)
  function waitMany (line 400) | ssize_t waitMany(ssize_t max)

FILE: External/stb/stb_image.h
  type stbi_uc (line 385) | typedef unsigned char stbi_uc;
  type stbi_us (line 386) | typedef unsigned short stbi_us;
  type stbi_io_callbacks (line 409) | typedef struct
  type stbi__uint16 (line 640) | typedef unsigned short stbi__uint16;
  type stbi__int16 (line 641) | typedef   signed short stbi__int16;
  type stbi__uint32 (line 642) | typedef unsigned int   stbi__uint32;
  type stbi__int32 (line 643) | typedef   signed int   stbi__int32;
  type stbi__uint16 (line 646) | typedef uint16_t stbi__uint16;
  type stbi__int16 (line 647) | typedef int16_t  stbi__int16;
  type stbi__uint32 (line 648) | typedef uint32_t stbi__uint32;
  type stbi__int32 (line 649) | typedef int32_t  stbi__int32;
  function stbi__cpuid3 (line 730) | static int stbi__cpuid3(void)
  function stbi__sse2_available (line 752) | static int stbi__sse2_available(void)
  function stbi__sse2_available (line 763) | static int stbi__sse2_available(void)
  type stbi__context (line 803) | typedef struct
  function stbi__start_mem (line 824) | static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int...
  function stbi__start_callbacks (line 834) | static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c...
  function stbi__stdio_read (line 848) | static int stbi__stdio_read(void *user, char *data, int size)
  function stbi__stdio_skip (line 853) | static void stbi__stdio_skip(void *user, int n)
  function stbi__stdio_eof (line 863) | static int stbi__stdio_eof(void *user)
  function stbi__start_file (line 875) | static void stbi__start_file(stbi__context *s, FILE *f)
  function stbi__rewind (line 884) | static void stbi__rewind(stbi__context *s)
  type stbi__result_info (line 899) | typedef struct
  function STBIDEF (line 970) | STBIDEF const char *stbi_failure_reason(void)
  function stbi__err (line 976) | static int stbi__err(const char *str)
  function stbi__addsizes_valid (line 1000) | static int stbi__addsizes_valid(int a, int b)
  function stbi__mul2sizes_valid (line 1012) | static int stbi__mul2sizes_valid(int a, int b)
  function stbi__mad2sizes_valid (line 1022) | static int stbi__mad2sizes_valid(int a, int b, int add)
  function stbi__mad3sizes_valid (line 1029) | static int stbi__mad3sizes_valid(int a, int b, int c, int add)
  function stbi__mad4sizes_valid (line 1037) | static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
  function stbi__addints_valid (line 1068) | static int stbi__addints_valid(int a, int b)
  function stbi__mul2shorts_valid (line 1076) | static int stbi__mul2shorts_valid(short a, short b)
  function STBIDEF (line 1099) | STBIDEF void stbi_image_free(void *retval_from_stbi_load)
  function STBIDEF (line 1114) | STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
  function STBIDEF (line 1124) | STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_sh...
  function stbi_uc (line 1188) | static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, ...
  function stbi__uint16 (line 1204) | static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, ...
  function stbi__vertical_flip (line 1220) | static void stbi__vertical_flip(void *image, int w, int h, int bytes_per...
  function stbi__vertical_flip_slices (line 1245) | static void stbi__vertical_flip_slices(void *image, int w, int h, int z,...
  function stbi__uint16 (line 1284) | static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, ...
  function stbi__float_postprocess (line 1312) | static void stbi__float_postprocess(float *result, int *x, int *y, int *...
  function STBIDEF (line 1329) | STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, c...
  function FILE (line 1335) | static FILE *stbi__fopen(char const *filename, char const *mode)
  function STBIDEF (line 1364) | STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *co...
  function STBIDEF (line 1374) | STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp,...
  function STBIDEF (line 1387) | STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, in...
  function STBIDEF (line 1400) | STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int ...
  function STBIDEF (line 1413) | STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len...
  function STBIDEF (line 1420) | STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *cl...
  function STBIDEF (line 1427) | STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, i...
  function STBIDEF (line 1434) | STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk,...
  function STBIDEF (line 1442) | STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int le...
  function STBIDEF (line 1476) | STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, in...
  function STBIDEF (line 1483) | STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, ...
  function STBIDEF (line 1491) | STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *com...
  function STBIDEF (line 1501) | STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, ...
  function STBIDEF (line 1515) | STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
  function STBIDEF (line 1529) | STBIDEF int      stbi_is_hdr          (char const *filename)
  function STBIDEF (line 1540) | STBIDEF int stbi_is_hdr_from_file(FILE *f)
  function STBIDEF (line 1557) | STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clb...
  function STBIDEF (line 1573) | STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = ga...
  function STBIDEF (line 1574) | STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = sc...
  function STBIDEF (line 1579) | STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = ...
  function STBIDEF (line 1580) | STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = ...
  function stbi__refill_buffer (line 1595) | static void stbi__refill_buffer(stbi__context *s)
  function stbi_inline (line 1612) | stbi_inline static stbi_uc stbi__get8(stbi__context *s)
  function stbi_inline (line 1626) | stbi_inline static int stbi__at_eof(stbi__context *s)
  function stbi__skip (line 1642) | static void stbi__skip(stbi__context *s, int n)
  function stbi__getn (line 1664) | static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
  function stbi__get16be (line 1692) | static int stbi__get16be(stbi__context *s)
  function stbi__uint32 (line 1702) | static stbi__uint32 stbi__get32be(stbi__context *s)
  function stbi__get16le (line 1712) | static int stbi__get16le(stbi__context *s)
  function stbi__uint32 (line 1720) | static stbi__uint32 stbi__get32le(stbi__context *s)
  function stbi_uc (line 1744) | static stbi_uc stbi__compute_y(int r, int g, int b)
  function stbi__uint16 (line 1801) | static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
  function stbi__uint16 (line 1810) | static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_...
  function stbi_uc (line 1882) | static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
  type stbi__huffman (line 1936) | typedef struct
  type stbi__jpeg (line 1947) | typedef struct
  function stbi__build_huffman (line 2001) | static int stbi__build_huffman(stbi__huffman *h, int *count)
  function stbi__build_fast_ac (line 2048) | static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
  function stbi__grow_buffer_unsafe (line 2073) | static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
  function stbi_inline (line 2095) | stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffm...
  function stbi_inline (line 2151) | stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
  function stbi_inline (line 2167) | stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
  function stbi_inline (line 2179) | stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
  function stbi__jpeg_decode_block (line 2208) | static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__...
  function stbi__jpeg_decode_block_prog_dc (line 2263) | static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64]...
  function stbi__jpeg_decode_block_prog_ac (line 2293) | static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64]...
  function stbi_inline (line 2414) | stbi_inline static stbi_uc stbi__clamp(int x)
  function stbi__idct_block (line 2465) | static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
  function stbi__idct_simd (line 2528) | static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
  function stbi__idct_simd (line 2709) | static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
  function stbi_uc (line 2917) | static stbi_uc stbi__get_marker(stbi__jpeg *j)
  function stbi__jpeg_reset (line 2934) | static void stbi__jpeg_reset(stbi__jpeg *j)
  function stbi__parse_entropy_coded_data (line 2947) | static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
  function stbi__jpeg_dequantize (line 3071) | static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
  function stbi__jpeg_finish (line 3078) | static void stbi__jpeg_finish(stbi__jpeg *z)
  function stbi__process_marker (line 3097) | static int stbi__process_marker(stbi__jpeg *z, int m)
  function stbi__process_scan_header (line 3201) | static int stbi__process_scan_header(stbi__jpeg *z)
  function stbi__free_jpeg_components (line 3240) | static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
  function stbi__process_frame_header (line 3262) | static int stbi__process_frame_header(stbi__jpeg *z, int scan)
  function stbi__decode_jpeg_header (line 3363) | static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
  function stbi__skip_jpeg_junk_at_end (line 3387) | static int stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
  function stbi__decode_jpeg_image (line 3410) | static int stbi__decode_jpeg_image(stbi__jpeg *j)
  type stbi_uc (line 3449) | typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_u...
  function stbi_uc (line 3454) | static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *...
  function stbi_uc (line 3463) | static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, s...
  function stbi_uc (line 3473) | static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, ...
  function stbi_uc (line 3503) | static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, ...
  function stbi_uc (line 3528) | static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_n...
  function stbi_uc (line 3644) | static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_nea...
  function stbi__YCbCr_to_RGB_row (line 3658) | static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const...
  function stbi__YCbCr_to_RGB_simd (line 3684) | static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi...
  function stbi__setup_jpeg (line 3819) | static void stbi__setup_jpeg(stbi__jpeg *j)
  function stbi__cleanup_jpeg (line 3841) | static void stbi__cleanup_jpeg(stbi__jpeg *j)
  type stbi__resample (line 3846) | typedef struct
  function stbi_uc (line 3857) | static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
  function stbi_uc (line 3863) | static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, i...
  function stbi__jpeg_test (line 4040) | static int stbi__jpeg_test(stbi__context *s)
  function stbi__jpeg_info_raw (line 4054) | static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
  function stbi__jpeg_info (line 4066) | static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
  type stbi__zhuffman (line 4095) | typedef struct
  function stbi_inline (line 4105) | stbi_inline static int stbi__bitreverse16(int n)
  function stbi_inline (line 4114) | stbi_inline static int stbi__bit_reverse(int v, int bits)
  function stbi__zbuild_huffman (line 4122) | static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizeli...
  type stbi__zbuf (line 4175) | typedef struct
  function stbi_inline (line 4189) | stbi_inline static int stbi__zeof(stbi__zbuf *z)
  function stbi_inline (line 4194) | stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
  function stbi__fill_bits (line 4199) | static void stbi__fill_bits(stbi__zbuf *z)
  function stbi__zreceive (line 4211) | int stbi__zreceive(stbi__zbuf *z, int n)
  function stbi__zhuffman_decode_slowpath (line 4221) | static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
  function stbi_inline (line 4240) | stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffm...
  function stbi__zexpand (line 4259) | static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to m...
  function stbi__parse_huffman_block (line 4295) | static int stbi__parse_huffman_block(stbi__zbuf *a)
  function stbi__compute_huffman_codes (line 4338) | static int stbi__compute_huffman_codes(stbi__zbuf *a)
  function stbi__parse_uncompressed_block (line 4388) | static int stbi__parse_uncompressed_block(stbi__zbuf *a)
  function stbi__parse_zlib_header (line 4417) | static int stbi__parse_zlib_header(stbi__zbuf *a)
  function stbi__parse_zlib (line 4460) | static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
  function stbi__do_zlib (line 4488) | static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, i...
  function STBIDEF (line 4498) | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int ...
  function STBIDEF (line 4514) | STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *...
  function STBIDEF (line 4519) | STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *b...
  function STBIDEF (line 4535) | STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const ...
  function STBIDEF (line 4546) | STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int l...
  function STBIDEF (line 4562) | STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, co...
  type stbi__pngchunk (line 4585) | typedef struct
  function stbi__pngchunk (line 4591) | static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
  function stbi__check_png_header (line 4599) | static int stbi__check_png_header(stbi__context *s)
  type stbi__png (line 4608) | typedef struct
  function stbi__paeth (line 4636) | static int stbi__paeth(int a, int b, int c)
  function stbi__create_png_image_raw (line 4650) | static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__...
  function stbi__create_png_image (line 4862) | static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stb...
  function stbi__compute_transparency (line 4907) | static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int o...
  function stbi__compute_transparency16 (line 4932) | static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3]...
  function stbi__expand_png_palette (line 4957) | static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int ...
  function STBIDEF (line 4997) | STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpr...
  function STBIDEF (line 5002) | STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_conv...
  function STBIDEF (line 5014) | STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_shou...
  function STBIDEF (line 5020) | STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_shou...
  function stbi__de_iphone (line 5034) | static void stbi__de_iphone(stbi__png *z)
  function stbi__parse_png_file (line 5079) | static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
  function stbi__png_test (line 5301) | static int stbi__png_test(stbi__context *s)
  function stbi__png_info_raw (line 5309) | static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
  function stbi__png_info (line 5321) | static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
  function stbi__png_is16 (line 5328) | static int stbi__png_is16(stbi__context *s)
  function stbi__bmp_test_raw (line 5345) | static int stbi__bmp_test_raw(stbi__context *s)
  function stbi__bmp_test (line 5360) | static int stbi__bmp_test(stbi__context *s)
  function stbi__high_bit (line 5369) | static int stbi__high_bit(unsigned int z)
  function stbi__bitcount (line 5381) | static int stbi__bitcount(unsigned int a)
  function stbi__shiftsigned (line 5394) | static int stbi__shiftsigned(unsigned int v, int shift, int bits)
  type stbi__bmp_data (line 5414) | typedef struct
  function stbi__bmp_set_mask_defaults (line 5421) | static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
  function stbi__tga_get_comp (line 5738) | static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_r...
  function stbi__tga_info (line 5754) | static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
  function stbi__tga_test (line 5819) | static int stbi__tga_test(stbi__context *s)
  function stbi__tga_read_rgb16 (line 5851) | static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
  function stbi__psd_test (line 6080) | static int stbi__psd_test(stbi__context *s)
  function stbi__psd_decode_rle (line 6087) | static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelC...
  function stbi__pic_is4 (line 6335) | static int stbi__pic_is4(stbi__context *s,const char *str)
  function stbi__pic_test_core (line 6345) | static int stbi__pic_test_core(stbi__context *s)
  type stbi__pic_packet (line 6361) | typedef struct
  function stbi_uc (line 6366) | static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
  function stbi__copyval (line 6380) | static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
  function stbi_uc (line 6389) | static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int heigh...
  function stbi__pic_test (line 6540) | static int stbi__pic_test(stbi__context *s)
  type stbi__gif_lzw (line 6552) | typedef struct
  type stbi__gif (line 6559) | typedef struct
  function stbi__gif_test_raw (line 6579) | static int stbi__gif_test_raw(stbi__context *s)
  function stbi__gif_test (line 6589) | static int stbi__gif_test(stbi__context *s)
  function stbi__gif_parse_colortable (line 6596) | static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256...
  function stbi__gif_header (line 6607) | static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, i...
  function stbi__gif_info_raw (line 6638) | static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
  function stbi__out_gif_code (line 6653) | static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
  function stbi_uc (line 6690) | static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
  function stbi_uc (line 6777) | static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int ...
  function stbi__gif_info (line 7076) | static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
  function stbi__hdr_test_core (line 7086) | static int stbi__hdr_test_core(stbi__context *s, const char *signature)
  function stbi__hdr_test (line 7096) | static int stbi__hdr_test(stbi__context* s)
  function stbi__hdr_convert (line 7130) | static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
  function stbi__hdr_info (line 7288) | static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
  function stbi__bmp_info (line 7334) | static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
  function stbi__psd_info (line 7358) | static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
  function stbi__psd_is16 (line 7393) | static int stbi__psd_is16(stbi__context *s)
  function stbi__pic_info (line 7422) | static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
  function stbi__pnm_test (line 7493) | static int      stbi__pnm_test(stbi__context *s)
  function stbi__pnm_isspace (line 7542) | static int      stbi__pnm_isspace(char c)
  function stbi__pnm_skip_whitespace (line 7547) | static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
  function stbi__pnm_isdigit (line 7561) | static int      stbi__pnm_isdigit(char c)
  function stbi__pnm_getinteger (line 7566) | static int      stbi__pnm_getinteger(stbi__context *s, char *c)
  function stbi__pnm_info (line 7580) | static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
  function stbi__pnm_is16 (line 7623) | static int stbi__pnm_is16(stbi__context *s)
  function stbi__info_main (line 7631) | static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
  function stbi__is_16_main (line 7673) | static int stbi__is_16_main(stbi__context *s)
  function STBIDEF (line 7690) | STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
  function STBIDEF (line 7700) | STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
  function STBIDEF (line 7711) | STBIDEF int stbi_is_16_bit(char const *filename)
  function STBIDEF (line 7721) | STBIDEF int stbi_is_16_bit_from_file(FILE *f)
  function STBIDEF (line 7733) | STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x...
  function STBIDEF (line 7740) | STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *u...
  function STBIDEF (line 7747) | STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
  function STBIDEF (line 7754) | STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, vo...

FILE: External/stb/stb_image_write.h
  function STBIWDEF (line 262) | STBIWDEF void stbi_flip_vertically_on_write(int flag)
  type stbi__write_context (line 267) | typedef struct
  function stbi__start_write_callbacks (line 276) | static void stbi__start_write_callbacks(stbi__write_context *s, stbi_wri...
  function stbi__stdio_write (line 284) | static void stbi__stdio_write(void *context, void *data, int size)
  function STBIWDEF (line 298) | STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen,...
  function FILE (line 304) | static FILE *stbiw__fopen(char const *filename, char const *mode)
  function stbi__start_write_file (line 332) | static int stbi__start_write_file(stbi__write_context *s, const char *fi...
  function stbi__end_write_file (line 339) | static void stbi__end_write_file(stbi__write_context *s)
  type stbiw_uint32 (line 346) | typedef unsigned int stbiw_uint32;
  function stbiw__writefv (line 349) | static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_l...
  function stbiw__writef (line 378) | static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)
  function stbiw__write_flush (line 386) | static void stbiw__write_flush(stbi__write_context *s)
  function stbiw__putc (line 394) | static void stbiw__putc(stbi__write_context *s, unsigned char c)
  function stbiw__write1 (line 399) | static void stbiw__write1(stbi__write_context *s, unsigned char a)
  function stbiw__write3 (line 406) | static void stbiw__write3(stbi__write_context *s, unsigned char a, unsig...
  function stbiw__write_pixel (line 418) | static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int ...
  function stbiw__write_pixels (line 451) | static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int...
  function stbiw__outfile (line 478) | static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir,...
  function stbi_write_bmp_core (line 492) | static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int...
  function STBIWDEF (line 512) | STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context...
  function STBIWDEF (line 520) | STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp...
  function stbi_write_tga_core (line 532) | static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int...
  function STBIWDEF (line 611) | STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context...
  function STBIWDEF (line 619) | STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp...
  function stbiw__linear_to_rgbe (line 639) | static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
  function stbiw__write_run_data (line 656) | static void stbiw__write_run_data(stbi__write_context *s, int length, un...
  function stbiw__write_dump_data (line 664) | static void stbiw__write_dump_data(stbi__write_context *s, int length, u...
  function stbiw__write_hdr_scanline (line 672) | static void stbiw__write_hdr_scanline(stbi__write_context *s, int width,...
  function stbi_write_hdr_core (line 761) | static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int...
  function STBIWDEF (line 787) | STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context...
  function STBIWDEF (line 794) | STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp...
  function stbiw__zlib_bitrev (line 849) | static int stbiw__zlib_bitrev(int code, int codebits)
  function stbiw__zlib_countm (line 859) | static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *...
  function stbiw__zhash (line 867) | static unsigned int stbiw__zhash(unsigned char *data)
  function stbiw__crc32 (line 1024) | static unsigned int stbiw__crc32(unsigned char *buffer, int len)
  function stbiw__wpcrc (line 1077) | static void stbiw__wpcrc(unsigned char **data, int len)
  function stbiw__paeth (line 1083) | static unsigned char stbiw__paeth(int a, int b, int c)
  function stbiw__encode_png_line (line 1092) | static void stbiw__encode_png_line(unsigned char *pixels, int stride_byt...
  function STBIWDEF (line 1215) | STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp...
  function STBIWDEF (line 1231) | STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context...
  function stbiw__jpg_writeBits (line 1253) | static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, i...
  function stbiw__jpg_DCT (line 1270) | static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3...
  function stbiw__jpg_calcBits (line 1318) | static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
  function stbiw__jpg_processDU (line 1328) | static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int...
  function stbi_write_jpg_core (line 1398) | static int stbi_write_jpg_core(stbi__write_context *s, int width, int he...
  function STBIWDEF (line 1607) | STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context...
  function STBIWDEF (line 1616) | STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp...

FILE: External/stb/stb_sprintf.h
  function STBSP__PUBLICDEF (line 259) | STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, ...
  function stbsp__lead_sign (line 279) | static void stbsp__lead_sign(stbsp__uint32 fl, char *sign)
  function STBSP__PUBLICDEF (line 294) | STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *c...
  function STBSP__PUBLICDEF (line 1349) | STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const...
  type stbsp__context (line 1359) | typedef struct stbsp__context {
  function STBSP__PUBLICDEF (line 1403) | STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int ...
  function STBSP__PUBLICDEF (line 1433) | STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count...
  function STBSP__PUBLICDEF (line 1445) | STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char cons...
  function stbsp__int32 (line 1464) | static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int3...
  function stbsp__raise_to_power10 (line 1611) | static void stbsp__raise_to_power10(double *ohi, double *olo, double d, ...
  function stbsp__int32 (line 1678) | static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32...

FILE: Source/ZetaCore/App/App.h
  function namespace (line 9) | namespace ZetaRay::Support
  function namespace (line 20) | namespace ZetaRay::App
  function namespace (line 25) | namespace ZetaRay::Util
  function namespace (line 48) | namespace ZetaRay::App
  function namespace (line 53) | namespace ZetaRay::Core
  function namespace (line 58) | namespace ZetaRay::Scene
  function namespace (line 64) | namespace ZetaRay::Scene::Renderer
  function namespace (line 69) | namespace ZetaRay::App

FILE: Source/ZetaCore/App/Common.h
  function namespace (line 5) | namespace ZetaRay::App::Common

FILE: Source/ZetaCore/App/Filesystem.h
  function namespace (line 6) | namespace ZetaRay::App::Filesystem

FILE: Source/ZetaCore/App/Path.h
  function namespace (line 3) | namespace ZetaRay::App::Filesystem
  function ConvertToBackslashes (line 193) | void ConvertToBackslashes()
  function ConvertToForwardSlashes (line 205) | void ConvertToForwardSlashes()

FILE: Source/ZetaCore/App/Timer.h
  function namespace (line 5) | namespace ZetaRay::App

FILE: Source/ZetaCore/Core/CommandList.h
  function namespace (line 9) | namespace ZetaRay::Core
  function class (line 147) | class ComputeCmdList : public CopyCmdList
  function ZetaInline (line 159) | ZetaInline void ResolveQueryData(ID3D12QueryHeap* queryHeap,
  function ZetaInline (line 169) | ZetaInline void EndQuery(ID3D12QueryHeap* queryHeap, D3D12_QUERY_TYPE ty...
  function ZetaInline (line 216) | ZetaInline void SetRootSignature(ID3D12RootSignature* rootSigObj)
  function ZetaInline (line 222) | ZetaInline void SetRootConstantBufferView(UINT rootParameterIndex, D3D12...
  function ZetaInline (line 227) | ZetaInline void SetRootShaderResourceView(UINT rootParameterIndex, D3D12...
  function ZetaInline (line 232) | ZetaInline void SetRootDescriptorTable(UINT rootParameterIndex, D3D12_GP...
  function ZetaInline (line 237) | ZetaInline void SetRootUnorderedAccessView(UINT rootParameterIndex, D3D1...
  function ZetaInline (line 242) | ZetaInline void SetRoot32BitConstants(UINT rootParameterIndex,
  function ZetaInline (line 250) | ZetaInline void SetPipelineState(ID3D12PipelineState* pipelineState)
  function ZetaInline (line 256) | ZetaInline void SetPipelineState1(ID3D12StateObject* rtPSO)
  function ZetaInline (line 262) | ZetaInline void Dispatch(UINT threadGroupCountX, UINT threadGroupCountY,...
  function ZetaInline (line 267) | ZetaInline void SetPredication(ID3D12Resource* buffer, UINT64 bufferOffs...
  function ZetaInline (line 272) | ZetaInline void BuildRaytracingAccelerationStructure(const D3D12_BUILD_R...
  function ZetaInline (line 279) | ZetaInline void CompactAccelerationStructure(D3D12_GPU_VIRTUAL_ADDRESS d...
  function ZetaInline (line 284) | ZetaInline void CopyAccelerationStructure(D3D12_GPU_VIRTUAL_ADDRESS dest...
  function ZetaInline (line 289) | ZetaInline void ExecuteIndirect(ID3D12CommandSignature* cmdSig,
  function ZetaInline (line 344) | ZetaInline void SetRootConstantBufferView(UINT rootParameterIndex, D3D12...
  function ZetaInline (line 349) | ZetaInline void SetRootShaderResourceView(UINT rootParameterIndex, D3D12...
  function ZetaInline (line 354) | ZetaInline void SetRootDescriptorTable(UINT rootParameterIndex, D3D12_GP...
  function ZetaInline (line 359) | ZetaInline void SetRootUnorderedAccessView(UINT rootParameterIndex, D3D1...
  function ZetaInline (line 364) | ZetaInline void SetRoot32BitConstants(UINT rootParameterIndex,
  function ZetaInline (line 388) | ZetaInline void IASetPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY primitiv...
  function ZetaInline (line 401) | ZetaInline void IASetIndexBuffer(const D3D12_INDEX_BUFFER_VIEW& ibv)
  function ZetaInline (line 406) | ZetaInline void DrawInstanced(UINT vertexCountPerInstance,
  function ZetaInline (line 414) | ZetaInline void DrawIndexedInstanced(UINT indexCountPerInstance,
  function ZetaInline (line 423) | ZetaInline void OMSetRenderTargets(UINT numRenderTargetDescriptors,
  function ZetaInline (line 431) | ZetaInline void RSSetViewports(UINT num, const D3D12_VIEWPORT* viewports)
  function ZetaInline (line 444) | ZetaInline void RSSetScissorRects(UINT numRects, const D3D12_RECT* rects)
  function ZetaInline (line 449) | ZetaInline void OMSetBlendFactor(float blendFactorR, float blendFactorG,...
  function ZetaInline (line 455) | ZetaInline void SetPredication(ID3D12Resource* buffer, UINT64 bufferOffs...

FILE: Source/ZetaCore/Core/CommandQueue.cpp
  function ID3D12CommandAllocator (line 75) | ID3D12CommandAllocator* CommandQueue::GetCommandAllocator()
  function CommandList (line 125) | CommandList* CommandQueue::GetCommandList()

FILE: Source/ZetaCore/Core/CommandQueue.h
  function namespace (line 9) | namespace ZetaRay::Core

FILE: Source/ZetaCore/Core/Config.h
  function namespace (line 5) | namespace ZetaRay::Core::Constants

FILE: Source/ZetaCore/Core/DescriptorHeap.cpp
  function DescriptorTable (line 47) | DescriptorTable& DescriptorTable::operator=(DescriptorTable&& other)
  function DescriptorTable (line 168) | DescriptorTable DescriptorHeap::Allocate(uint32_t count)

FILE: Source/ZetaCore/Core/DescriptorHeap.h
  function namespace (line 6) | namespace ZetaRay::Core
  type DescriptorTable (line 115) | struct DescriptorTable
  function D3D12_CPU_DESCRIPTOR_HANDLE (line 134) | D3D12_CPU_DESCRIPTOR_HANDLE CPUHandle(uint32_t offset) const
  function ZetaInline (line 140) | ZetaInline D3D12_GPU_DESCRIPTOR_HANDLE GPUHandle(uint32_t offset) const

FILE: Source/ZetaCore/Core/Device.h
  function namespace (line 76) | namespace ZetaRay::Core

FILE: Source/ZetaCore/Core/Direct3DUtil.cpp
  function ZetaInline (line 18) | ZetaInline void AdjustPlaneResource(DXGI_FORMAT fmt,
  function ZetaInline (line 61) | ZetaInline bool IsDepthStencil(DXGI_FORMAT fmt)
  function ZetaInline (line 82) | ZetaInline UINT8 D3D12GetFormatPlaneCount(ID3D12Device* pDevice, DXGI_FO...
  function ZetaInline (line 91) | ZetaInline DXGI_FORMAT GetDXGIFormat(const DDS_PIXELFORMAT& ddpf)
  function HRESULT (line 270) | HRESULT FillInitData(size_t width, size_t height, size_t depth, size_t m...
  function FillSubresourceData (line 353) | void FillSubresourceData(const DDS_HEADER* header, MutableSpan<D3D12_SUB...
  function LOAD_DDS_RESULT (line 524) | LOAD_DDS_RESULT LoadTextureDataFromFile(const char* fileName, ArenaAlloc...
  function D3D12_RESOURCE_ALLOCATION_INFO (line 641) | D3D12_RESOURCE_ALLOCATION_INFO Direct3DUtil::AllocationInfo(D3D12_RESOUR...
  function D3D12_RESOURCE_ALLOCATION_INFO (line 647) | D3D12_RESOURCE_ALLOCATION_INFO Direct3DUtil::AllocationInfo(Span<D3D12_R...
  function HRESULT (line 813) | HRESULT Direct3DUtil::GetSurfaceInfo(size_t width,
  function UINT64 (line 949) | UINT64 Direct3DUtil::GetRequiredIntermediateSize(ID3D12Resource* destina...
  function LOAD_DDS_RESULT (line 962) | LOAD_DDS_RESULT Direct3DUtil::LoadDDSFromFile(const char* path,
  function D3D12_GRAPHICS_PIPELINE_STATE_DESC (line 989) | D3D12_GRAPHICS_PIPELINE_STATE_DESC Direct3DUtil::GetPSODesc(const D3D12_...

FILE: Source/ZetaCore/Core/Direct3DUtil.h
  function namespace (line 9) | namespace ZetaRay::App
  function namespace (line 14) | namespace ZetaRay::Util
  function namespace (line 20) | namespace ZetaRay::Core::GpuMemory
  function namespace (line 26) | namespace ZetaRay::Support
  function namespace (line 31) | namespace ZetaRay::Core::Direct3DUtil
  function D3D12_RESOURCE_BARRIER (line 222) | inline D3D12_RESOURCE_BARRIER TransitionBarrier(ID3D12Resource* res,
  function D3D12_BUFFER_BARRIER (line 240) | inline D3D12_BUFFER_BARRIER BufferBarrier(ID3D12Resource* res,
  function D3D12_TEXTURE_BARRIER (line 255) | inline D3D12_TEXTURE_BARRIER TextureBarrier(ID3D12Resource* res,
  function D3D12_BARRIER_GROUP (line 283) | inline D3D12_BARRIER_GROUP BarrierGroup(D3D12_BUFFER_BARRIER& barrier)
  function D3D12_BARRIER_GROUP (line 293) | inline D3D12_BARRIER_GROUP BarrierGroup(D3D12_BUFFER_BARRIER* barriers, ...
  function D3D12_BARRIER_GROUP (line 303) | inline D3D12_BARRIER_GROUP BarrierGroup(D3D12_TEXTURE_BARRIER& barrier)
  function D3D12_BARRIER_GROUP (line 313) | inline D3D12_BARRIER_GROUP BarrierGroup(D3D12_TEXTURE_BARRIER* barriers,...
  function D3D12_RESOURCE_BARRIER (line 323) | inline D3D12_RESOURCE_BARRIER UAVBarrier(ID3D12Resource* res)
  function D3D12_BLEND_DESC (line 491) | inline D3D12_BLEND_DESC DefaultBlendDesc()
  function D3D12_RASTERIZER_DESC (line 515) | inline D3D12_RASTERIZER_DESC DefaultRasterizerDesc()
  function D3D12_DEPTH_STENCIL_DESC (line 534) | inline D3D12_DEPTH_STENCIL_DESC DefaultDepthStencilDesc()
  function DXGI_FORMAT (line 556) | inline constexpr DXGI_FORMAT NoSRGB(DXGI_FORMAT fmt)

FILE: Source/ZetaCore/Core/GpuMemory.cpp
  type ResourceUploadBatch (line 26) | struct ResourceUploadBatch
    method ResourceUploadBatch (line 28) | ResourceUploadBatch()
    method ResourceUploadBatch (line 34) | ResourceUploadBatch(ResourceUploadBatch&& other) = delete;
    method ResourceUploadBatch (line 35) | ResourceUploadBatch& operator=(ResourceUploadBatch&& other) = delete;
    method Begin (line 37) | void Begin()
    method UploadTexture (line 51) | void UploadTexture(UploadHeapArena& arena, ID3D12Resource* texture,
    method UploadTexture (line 102) | void UploadTexture(ID3D12Resource* texture, Span<D3D12_SUBRESOURCE_DAT...
    method UploadBuffer (line 153) | void UploadBuffer(ID3D12Resource* buffer, void* data, uint32_t sizeInB...
    method UploadTexture (line 187) | void UploadTexture(ID3D12Resource* dstResource, uint8_t* pixels,
    method End (line 247) | uint64_t End()
    method Recycle (line 263) | void Recycle()
    method CopyTextureFromUploadBuffer (line 271) | void CopyTextureFromUploadBuffer(ID3D12Resource* uploadBuffer, void* m...
  type GpuMemoryImplData (line 354) | struct GpuMemoryImplData
    type PendingResource (line 361) | struct PendingResource
      method ZetaInline (line 363) | ZetaInline bool IsUploadHeapBuffer() const
  function UploadHeapBuffer (line 418) | UploadHeapBuffer& UploadHeapBuffer::operator=(UploadHeapBuffer&& other)
  function Buffer (line 553) | Buffer& Buffer::operator=(Buffer&& other)
  function ReadbackHeapBuffer (line 606) | ReadbackHeapBuffer& ReadbackHeapBuffer::operator=(ReadbackHeapBuffer&& o...
  function Texture (line 698) | Texture& Texture::operator=(Texture&& other)
  function ResourceHeap (line 752) | ResourceHeap& ResourceHeap::operator=(ResourceHeap&& other)
  function UploadHeapBuffer (line 915) | UploadHeapBuffer GpuMemory::GetUploadHeapBuffer(uint32_t sizeInBytes, ui...
  function ReadbackHeapBuffer (line 1005) | ReadbackHeapBuffer GpuMemory::GetReadbackHeapBuffer(uint32_t sizeInBytes)
  function Buffer (line 1040) | Buffer GpuMemory::GetDefaultHeapBuffer(const char* name, uint32_t sizeIn...
  function Buffer (line 1065) | Buffer GpuMemory::GetDefaultHeapBuffer(const char* name, uint32_t sizeIn...
  function Buffer (line 1095) | Buffer GpuMemory::GetPlacedHeapBuffer(const char* name, uint32_t sizeInB...
  function Buffer (line 1118) | Buffer GpuMemory::GetDefaultHeapBufferAndInit(const char* name, uint32_t...
  function Buffer (line 1135) | Buffer GpuMemory::GetPlacedHeapBufferAndInit(const char* name, uint32_t ...
  function ResourceHeap (line 1163) | ResourceHeap GpuMemory::GetResourceHeap(uint64_t sizeInBytes, uint64_t a...
  function Texture (line 1218) | Texture GpuMemory::GetTexture2D(const char* name, uint64_t width, uint32...
  function Texture (line 1225) | Texture GpuMemory::GetTexture2D(Texture::ID_TYPE id, uint64_t width, uin...
  function Texture (line 1265) | Texture GpuMemory::GetPlacedTexture2D(const char* name, uint64_t width, ...
  function Texture (line 1299) | Texture GpuMemory::GetPlacedTexture2D(const char* name, uint64_t width, ...
  function Texture (line 1335) | Texture GpuMemory::GetTexture2D(const char* name, uint64_t width, uint32...
  function Texture (line 1342) | Texture GpuMemory::GetTexture2D(Texture::ID_TYPE id, uint64_t width, uin...
  function Texture (line 1385) | Texture GpuMemory::GetTexture3D(const char* name, uint64_t width, uint32...
  function LOAD_DDS_RESULT (line 1420) | LOAD_DDS_RESULT GpuMemory::GetTexture2DFromDisk(const char* texPath, Tex...
  function LOAD_DDS_RESULT (line 1444) | LOAD_DDS_RESULT GpuMemory::GetTexture2DFromDisk(const char* texPath,
  function LOAD_DDS_RESULT (line 1468) | LOAD_DDS_RESULT GpuMemory::GetDDSDataFromDisk(const char* texPath,
  function LOAD_DDS_RESULT (line 1476) | LOAD_DDS_RESULT GpuMemory::GetTexture3DFromDisk(const char* texPath, Tex...
  function Texture (line 1503) | Texture GpuMemory::GetPlacedTexture2DAndInit(Texture::ID_TYPE ID, const ...
  function Texture (line 1521) | Texture GpuMemory::GetTexture2DAndInit(const char* name, uint64_t width,...

FILE: Source/ZetaCore/Core/GpuMemory.h
  function namespace (line 7) | namespace ZetaRay::Core::GpuMemory
  type UploadHeapArena (line 98) | struct UploadHeapArena
  type ReadbackHeapBuffer (line 126) | struct ReadbackHeapBuffer
  function ZetaInline (line 141) | ZetaInline ID3D12Resource* Resource()
  function ZetaInline (line 159) | ZetaInline void* MappedMemory()
  type Buffer (line 170) | struct Buffer
  function ZetaInline (line 188) | ZetaInline ID3D12Resource* Resource()
  type Texture (line 210) | struct Texture
  function ID3D12Resource (line 225) | ID3D12Resource* Resource()
  type ResourceHeap (line 250) | struct ResourceHeap
  function ID3D12Heap (line 260) | ID3D12Heap* Heap()
  type DDS_Data (line 338) | struct DDS_Data

FILE: Source/ZetaCore/Core/GpuTimer.h
  function namespace (line 7) | namespace ZetaRay::Core

FILE: Source/ZetaCore/Core/Material.h
  function namespace (line 26) | namespace ZetaRay

FILE: Source/ZetaCore/Core/PipelineStateLibrary.cpp
  function ZetaInline (line 19) | ZetaInline void InitPipe(HANDLE& readPipe, HANDLE& writePipe)
  function ZetaInline (line 30) | ZetaInline void ReleasePipe(HANDLE readPipe, HANDLE writePipe)
  function ID3D12PipelineState (line 293) | ID3D12PipelineState* PipelineStateLibrary::CompileGraphicsPSO(uint32_t idx,
  function ID3D12PipelineState (line 341) | ID3D12PipelineState* PipelineStateLibrary::CompileComputePSO(uint32_t idx,
  function ID3D12PipelineState (line 387) | ID3D12PipelineState* PipelineStateLibrary::CompileComputePSO_MT(uint32_t...
  function ID3D12PipelineState (line 441) | ID3D12PipelineState* PipelineStateLibrary::CompileComputePSO(uint32_t idx,

FILE: Source/ZetaCore/Core/PipelineStateLibrary.h
  function namespace (line 7) | namespace ZetaRay::Core

FILE: Source/ZetaCore/Core/RenderGraph.cpp
  type Edge (line 64) | struct Edge
  function RenderNodeHandle (line 240) | RenderNodeHandle RenderGraph::RegisterRenderPass(const char* name, RENDE...

FILE: Source/ZetaCore/Core/RenderGraph.h
  function namespace (line 8) | namespace ZetaRay::Support
  function namespace (line 14) | namespace ZetaRay::Core
  type AggregateRenderNode (line 281) | struct AggregateRenderNode

FILE: Source/ZetaCore/Core/RendererCore.cpp
  function DXGI_OUTPUT_DESC (line 314) | DXGI_OUTPUT_DESC RendererCore::GetOutputMonitorDesc() const
  function GraphicsCmdList (line 344) | GraphicsCmdList* RendererCore::GetGraphicsCmdList()
  function ComputeCmdList (line 352) | ComputeCmdList* RendererCore::GetComputeCmdList()

FILE: Source/ZetaCore/Core/RendererCore.h
  function namespace (line 9) | namespace ZetaRay::Support
  function namespace (line 15) | namespace ZetaRay::Core

FILE: Source/ZetaCore/Core/RootSignature.cpp
  function End_Internal (line 15) | void End_Internal(T& ctx, uint32_t rootCBVBitMap, uint32_t rootSRVBitMap...

FILE: Source/ZetaCore/Core/RootSignature.h
  function namespace (line 5) | namespace ZetaRay::Util
  function namespace (line 11) | namespace ZetaRay::Core

FILE: Source/ZetaCore/Core/SharedShaderResources.cpp
  function UploadHeapBuffer (line 12) | const UploadHeapBuffer* SharedShaderResources::GetUploadHeapBuffer(uint6...
  function UploadHeapBuffer (line 22) | const UploadHeapBuffer* SharedShaderResources::GetUploadHeapBuffer(std::...
  function Buffer (line 40) | const Buffer* SharedShaderResources::GetDefaultHeapBuffer(uint64_t id)
  function Buffer (line 50) | const Buffer* SharedShaderResources::GetDefaultHeapBuffer(std::string_vi...
  function DescriptorTable (line 82) | const DescriptorTable* SharedShaderResources::GetDescriptorTable(uint64_...
  function DescriptorTable (line 91) | const DescriptorTable* SharedShaderResources::GetDescriptorTable(std::st...

FILE: Source/ZetaCore/Core/SharedShaderResources.h
  function namespace (line 6) | namespace ZetaRay::Core::GpuMemory
  function namespace (line 12) | namespace ZetaRay::Core

FILE: Source/ZetaCore/Core/Vertex.h
  function namespace (line 5) | namespace ZetaRay::Core

FILE: Source/ZetaCore/Core/dds.h
  function namespace (line 33) | namespace ZetaRay::Core::Direct3DUtil

FILE: Source/ZetaCore/Math/BVH.cpp
  type Bin (line 13) | struct alignas(16) Bin
    method __vectorcall (line 15) | __vectorcall Extend(v_AABB box)
    method __vectorcall (line 21) | __vectorcall Extend(Bin bin)

FILE: Source/ZetaCore/Math/BVH.h
  function namespace (line 12) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/CollisionFuncs.h
  function namespace (line 7) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/CollisionTypes.h
  function namespace (line 8) | namespace ZetaRay::Math
  type Plane (line 91) | struct Plane
  type alignas (line 116) | struct alignas
  function ViewFrustum (line 189) | static ViewFrustum Init()
  type v_ViewFrustum (line 210) | struct v_ViewFrustum
  type Ray (line 266) | struct Ray
  function v_Ray (line 278) | struct v_Ray

FILE: Source/ZetaCore/Math/Color.cpp
  function float3 (line 9) | float3 Math::sRGBToLinear(const float3& color)
  function float3 (line 27) | float3 Math::ColorTemperatureTosRGB(float temperature)

FILE: Source/ZetaCore/Math/Color.h
  function namespace (line 5) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/Common.cpp
  function float3 (line 37) | float3 Math::SphericalToCartesian(float theta, float phi)

FILE: Source/ZetaCore/Math/Common.h
  function namespace (line 9) | namespace ZetaRay::Util
  function namespace (line 18) | namespace ZetaRay::Math
  function namespace (line 23) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/Matrix.h
  function namespace (line 6) | namespace ZetaRay::Math
  function float3x4 (line 31) | struct float3x4
  type alignas (line 52) | struct alignas
  function explicit (line 63) | explicit float4x4a(const float* arr)
  function explicit (line 70) | explicit float4x4a(const double* arr)
  function explicit (line 77) | explicit float4x4a(const float4x3& M)
  function float3x3 (line 89) | struct float3x3
  function explicit (line 105) | explicit float3x3(const float4x3& M)
  type v_float4x4 (line 115) | struct v_float4x4
  function float4x3 (line 125) | inline float4x3::float4x3(const float4x4a& M)
  function float3x4 (line 133) | inline float3x4::float3x4(const float4x4a& M)
  function float4x4a (line 140) | inline float4x4a::float4x4a(const float3x3& M)
  type AffineTransformation (line 148) | struct AffineTransformation

FILE: Source/ZetaCore/Math/MatrixFuncs.h
  function namespace (line 10) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/OctahedralVector.h
  function namespace (line 5) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/Quaternion.h
  function namespace (line 6) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/Sampling.cpp
  function float3 (line 176) | float3 Math::UniformSampleSphere(float2 u)

FILE: Source/ZetaCore/Math/Sampling.h
  function namespace (line 6) | namespace ZetaRay::Util
  function namespace (line 11) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/Surface.h
  function namespace (line 7) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Math/Vector.h
  function namespace (line 8) | namespace ZetaRay::Math
  function dot (line 71) | constexpr float dot(const float2& other) const
  function normalize (line 81) | void normalize()
  type float3 (line 96) | struct float3
  function dot (line 178) | constexpr float dot(const float3& other) const
  function float3 (line 183) | constexpr float3 cross(const float3 other) const
  function normalize (line 188) | void normalize()
  type float4 (line 205) | struct float4
  function length (line 310) | float length() const
  function normalize (line 324) | void normalize()
  type alignas (line 342) | struct alignas
  type half (line 396) | struct half
  function half2 (line 414) | struct half2
  function explicit (line 440) | explicit half2(const float2& f)
  function half3 (line 458) | struct half3
  function half4 (line 522) | struct half4
  function explicit (line 550) | explicit half4(const float4& f)
  type uint3 (line 571) | struct uint3
  function FromNormalized (line 588) | struct unorm2
  function FromNormalized (line 653) | struct unorm3
  type unorm4 (line 728) | struct unorm4
  function float2 (line 777) | inline float2::float2(const half2& h)

FILE: Source/ZetaCore/Math/VectorFuncs.h
  function namespace (line 9) | namespace ZetaRay::Math

FILE: Source/ZetaCore/Model/Mesh.cpp
  type TeapotPatch (line 581) | struct TeapotPatch
  function float3 (line 612) | float3 CubicInterpolate(float3 p1, float3 p2, float3 p3, float3 p4, floa...
  function float3 (line 624) | float3 CubicTangent(float3 p1, float3 p2, float3 p3, float3 p4, float t)
  function CreatePatchVertices (line 632) | void CreatePatchVertices(Vector<Vertex>& vertices, float3 patch[16],
  function CreatePatchIndices (line 713) | void CreatePatchIndices(Vector<uint32_t>& indices, size_t vbase, size_t ...
  function TessellatePatch (line 757) | void TessellatePatch(Vector<Vertex>& vertices, Vector<uint32_t>& indices,

FILE: Source/ZetaCore/Model/Mesh.h
  function namespace (line 7) | namespace ZetaRay::Model
  function namespace (line 54) | namespace PrimitiveMesh

FILE: Source/ZetaCore/Model/glTF.cpp
  function ZetaInline (line 34) | ZetaInline const char* GetErrorMsg(cgltf_result r)
  function ZetaInline (line 75) | ZetaInline Texture::ID_TYPE IDFromTexturePath(const Filesystem::Path& te...
  type EmissiveMeshPrim (line 81) | struct EmissiveMeshPrim
  type ThreadContext (line 90) | struct ThreadContext
  function ResetEmissiveSubsets (line 121) | void ResetEmissiveSubsets(MutableSpan<EmissiveMeshPrim> subsets)
  function ProcessPositions (line 145) | void ProcessPositions(const cgltf_data& model, const cgltf_accessor& acc...
  function ProcessNormals (line 168) | void ProcessNormals(const cgltf_data& model, const cgltf_accessor& acces...
  function ProcessTexCoords (line 191) | void ProcessTexCoords(const cgltf_data& model, const cgltf_accessor& acc...
  function ProcessTangents (line 212) | void ProcessTangents(const cgltf_data& model, const cgltf_accessor& acce...
  function ProcessIndices (line 234) | void ProcessIndices(const cgltf_data& model, const cgltf_accessor& acces...
  function ProcessMeshes (line 270) | void ProcessMeshes(const cgltf_data& model, uint32_t sceneID, size_t off...
  function LoadDDSImages (line 433) | void LoadDDSImages(uint32_t sceneID, const Filesystem::Path& modelDir, c...
  function ProcessMaterials (line 523) | void ProcessMaterials(uint32_t sceneID, const Filesystem::Path& modelDir...
  function NumEmissiveInstancesAndTrianglesSubtree (line 645) | void NumEmissiveInstancesAndTrianglesSubtree(const cgltf_node& node, Thr...
  function NumEmissiveInstancesAndTriangles (line 683) | void NumEmissiveInstancesAndTriangles(ThreadContext& context)
  function ProcessEmissiveSubtree (line 692) | void ProcessEmissiveSubtree(const cgltf_node& node, ThreadContext& conte...
  function ProcessEmissives (line 769) | void ProcessEmissives(ThreadContext& context)
  function ProcessNodeSubtree (line 784) | void ProcessNodeSubtree(const cgltf_node& node, uint32_t sceneID, const ...
  function ProcessNodes (line 954) | void ProcessNodes(const cgltf_data& model, uint32_t sceneID)
  function DescendTree (line 963) | void DescendTree(const cgltf_node& node, int height, Vector<int>& treeLe...
  function PrecomputeNodeHierarchy (line 976) | void PrecomputeNodeHierarchy(const cgltf_data& model, Vector<int>& treeL...
  function TreeHeight (line 999) | int TreeHeight(const cgltf_node& node)
  function ComputeNodeHierarchyHeight (line 1012) | int ComputeNodeHierarchyHeight(const cgltf_data& model)
  function TotalNumVerticesAndIndices (line 1025) | void TotalNumVerticesAndIndices(cgltf_data* model, size_t& numVertices, ...

FILE: Source/ZetaCore/Model/glTF.h
  function namespace (line 5) | namespace ZetaRay::Model::glTF

FILE: Source/ZetaCore/Model/glTFAsset.h
  function namespace (line 11) | namespace ZetaRay::Model::glTF::Asset

FILE: Source/ZetaCore/RayTracing/RtAccelerationStructure.cpp
  type BLASTransform (line 24) | struct BLASTransform
  type DynamicBlasBuild (line 29) | struct DynamicBlasBuild
  function ZetaInline (line 39) | ZetaInline D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS BuildFlag...
  type TreePosAndIdx (line 558) | struct TreePosAndIdx

FILE: Source/ZetaCore/RayTracing/RtAccelerationStructure.h
  function namespace (line 8) | namespace ZetaRay::Core
  function namespace (line 14) | namespace ZetaRay::Util
  function namespace (line 20) | namespace ZetaRay::RT
  type TLAS (line 58) | struct TLAS
  type ArenaPage (line 68) | struct ArenaPage
  type DynamicBLAS (line 74) | struct DynamicBLAS
  function UPDATE_TYPE (line 83) | enum class UPDATE_TYPE

FILE: Source/ZetaCore/RayTracing/RtCommon.h
  function namespace (line 34) | namespace RT_AS_SUBGROUP
  function namespace (line 42) | namespace ZetaRay

FILE: Source/ZetaCore/Scene/Asset.h
  function namespace (line 9) | namespace ZetaRay::Scene::Internal
  type MaterialBuffer (line 66) | struct MaterialBuffer
  type Entry (line 103) | struct Entry
  function GetVB (line 123) | struct MeshContainer
  type EmissiveBuffer (line 162) | struct EmissiveBuffer
  function ZetaInline (line 186) | ZetaInline Util::Span<Instance> Instances() { return m_instances; }
  function ZetaInline (line 187) | ZetaInline Util::MutableSpan<RT::EmissiveTriangle> Triagnles() { return ...
  function ZetaInline (line 188) | ZetaInline Util::MutableSpan<Triangle> InitialTriPositions() { return m_...
  function ZetaInline (line 190) | ZetaInline Util::Optional<const Instance*> FindInstance(uint64_t ID)

FILE: Source/ZetaCore/Scene/Camera.cpp
  function ZetaInline (line 16) | ZetaInline void __vectorcall setCamPos(const __m128 vNewCamPos, float4x4...
  function ZetaInline (line 33) | ZetaInline v_float4x4 __vectorcall resetViewMatrix(const __m128 vBasisX,...

FILE: Source/ZetaCore/Scene/Camera.h
  function namespace (line 6) | namespace ZetaRay::Support
  function class (line 29) | class Camera

FILE: Source/ZetaCore/Scene/SceneCommon.h
  function namespace (line 5) | namespace ZetaRay::Scene

FILE: Source/ZetaCore/Scene/SceneCore.cpp
  function ZetaInline (line 25) | ZetaInline uint3 Pcg3d(uint3 v)
  type Entry (line 768) | struct Entry

FILE: Source/ZetaCore/Scene/SceneCore.h
  function namespace (line 12) | namespace ZetaRay::Model
  function namespace (line 17) | namespace ZetaRay::RT
  function namespace (line 23) | namespace ZetaRay::Support
  function namespace (line 28) | namespace ZetaRay::Scene
  function Encode (line 44) | struct RT_Flags
  type RT_AS_Info (line 73) | struct RT_AS_Info
  function ZetaInline (line 79) | ZetaInline uint64_t InstanceID(uint32_t sceneID, int nodeIdx, int mesh, ...
  function ZetaInline (line 87) | ZetaInline uint32_t MaterialID(uint32_t sceneID, int matIdx)
  function ZetaInline (line 95) | ZetaInline uint64_t MeshID(uint32_t sceneID, int meshIdx, int meshPrimIdx)
  function namespace (line 104) | namespace ZetaRay::Scene
  function ZetaInline (line 255) | ZetaInline Core::RenderGraph* GetRenderGraph() { return m_rendererInterf...
  function ZetaInline (line 256) | ZetaInline void SceneModified() { m_rendererInterface.SceneModified(); }
  function ZetaInline (line 257) | ZetaInline void DebugDrawRenderGraph() { m_rendererInterface.DebugDrawRe...
  function ZetaInline (line 262) | ZetaInline void Pick(uint16 screenPosX, uint16 screenPosY)
  function ZetaInline (line 267) | ZetaInline void MultiPick(uint16 screenPosX, uint16 screenPosY)
  function ZetaInline (line 274) | ZetaInline Util::SynchronizedSpan<uint64_t> GetPickedInstances()
  function ZetaInline (line 278) | ZetaInline void CaptureScreen() { m_rendererInterface.CaptureScreen(); }
  type TreePos (line 286) | struct TreePos
  type AnimationUpdate (line 292) | struct AnimationUpdate
  type Range (line 298) | struct Range
  type TreeLevel (line 310) | struct TreeLevel
  type AnimationMetadata (line 323) | struct AnimationMetadata
  function ZetaInline (line 332) | ZetaInline Util::Optional<TreePos> FindTreePosFromID(uint64_t id) const
  type TransformUpdate (line 378) | struct TransformUpdate

FILE: Source/ZetaCore/Scene/SceneRenderer.h
  function namespace (line 5) | namespace ZetaRay::Support
  function namespace (line 10) | namespace ZetaRay::Core
  function namespace (line 15) | namespace ZetaRay::Scene::GlobalResource
  function namespace (line 35) | namespace ZetaRay::Scene::Renderer

FILE: Source/ZetaCore/Support/FrameMemory.h
  function namespace (line 6) | namespace ZetaRay::Support

FILE: Source/ZetaCore/Support/Memory.h
  function namespace (line 7) | namespace ZetaRay::Support

FILE: Source/ZetaCore/Support/MemoryArena.cpp
  function MemoryArena (line 24) | MemoryArena& MemoryArena::operator=(MemoryArena&& other)

FILE: Source/ZetaCore/Support/MemoryArena.h
  function namespace (line 5) | namespace ZetaRay::Support
  function ArenaAllocator (line 73) | struct ArenaAllocator

FILE: Source/ZetaCore/Support/MemoryPool.cpp
  function Length (line 18) | int Length(void* head)

FILE: Source/ZetaCore/Support/MemoryPool.h
  function namespace (line 5) | namespace ZetaRay::Support

FILE: Source/ZetaCore/Support/OffsetAllocator.cpp
  type SmallFloat (line 10) | namespace SmallFloat
    function uintToFloatRoundUp (line 18) | uint32_t uintToFloatRoundUp(uint32_t size)
    function uintToFloatRoundDown (line 50) | uint32_t uintToFloatRoundDown(uint32_t size)
    function floatToUint (line 76) | uint32_t floatToUint(uint32_t floatValue)
  function ZetaInline (line 93) | ZetaInline uint32_t LowestSetBitGeIndex(uint32_t mask, uint32_t idx)
  function OffsetAllocator (line 137) | OffsetAllocator& OffsetAllocator::operator=(OffsetAllocator&& rhs)

FILE: Source/ZetaCore/Support/OffsetAllocator.h
  function namespace (line 5) | namespace ZetaRay::Support
  type StorageReport (line 30) | struct StorageReport
  type Node (line 56) | struct Node

FILE: Source/ZetaCore/Support/Param.cpp
  function FloatParam (line 164) | const FloatParam& ParamVariant::GetFloat() const
  function Float2Param (line 177) | const Float2Param& ParamVariant::GetFloat2() const
  function Float3Param (line 194) | const Float3Param& ParamVariant::GetFloat3() const
  function UnitDirParam (line 211) | const UnitDirParam& ParamVariant::GetUnitDir() const
  function Float3Param (line 225) | const Float3Param& ParamVariant::GetColor() const
  function IntParam (line 238) | const IntParam& ParamVariant::GetInt() const
  function EnumParam (line 264) | const EnumParam& ParamVariant::GetEnum() const
  function float3 (line 278) | float3 UnitDirParam::GetDir() const

FILE: Source/ZetaCore/Support/Param.h
  function namespace (line 7) | namespace ZetaRay::Support
  type Float2Param (line 34) | struct Float2Param
  type Float3Param (line 56) | struct Float3Param
  type UnitDirParam (line 78) | struct UnitDirParam
  type ColorParam (line 96) | struct ColorParam
  type EnumParam (line 137) | struct EnumParam
  function PARAM_TYPE (line 163) | enum class PARAM_TYPE

FILE: Source/ZetaCore/Support/Stat.h
  function namespace (line 6) | namespace ZetaRay::Support
  function ST_TYPE (line 53) | ST_TYPE GetType() { return m_type; }
  function GetInt (line 55) | int GetInt()
  function GetUInt (line 61) | uint32_t GetUInt()
  function GetFloat (line 67) | float GetFloat()
  function GetUInt64 (line 73) | uint64_t GetUInt64()
  function GetRatio (line 79) | void GetRatio(uint32_t& num, uint32_t& total)

FILE: Source/ZetaCore/Support/Task.cpp
  function Task (line 35) | Task& Task::operator=(Task&& other)

FILE: Source/ZetaCore/Support/Task.h
  function namespace (line 8) | namespace ZetaRay::Support
  function ZetaInline (line 122) | ZetaInline bool IsFinalized() { return m_isFinalized; }
  function ZetaInline (line 125) | ZetaInline int GetSize() { return m_currSize; }
  function ZetaInline (line 126) | ZetaInline Util::MutableSpan<Task> GetTasks() { return Util::MutableSpan...
  type TaskMetadata (line 129) | struct TaskMetadata

FILE: Source/ZetaCore/Support/ThreadPool.h
  function namespace (line 6) | namespace ZetaRay::Support

FILE: Source/ZetaCore/Utility/Error.cpp
  type dbg (line 47) | namespace dbg
    function basename (line 62) | std::string basename(const std::string& file)
    type StackFrame (line 71) | struct StackFrame
    function stack_trace (line 80) | void stack_trace(Vector<StackFrame, ArenaAllocator>& frames)
    function fail (line 167) | void fail(MutableSpan<char> buff, const char* msg)

FILE: Source/ZetaCore/Utility/Error.h
  function namespace (line 26) | namespace ZetaRay::Util

FILE: Source/ZetaCore/Utility/Function.h
  function ZetaInline (line 66) | ZetaInline void Run()
  type LambdaFuncPtrs (line 79) | struct LambdaFuncPtrs

FILE: Source/ZetaCore/Utility/HashTable.h
  function namespace (line 7) | namespace ZetaRay::Util
  function ZetaInline (line 187) | ZetaInline size_t erase(KeyType key)
  function clear (line 224) | void clear()
  function free_memory (line 247) | void free_memory()
  function swap (line 272) | void swap(HashTable& other)
  function ZetaInline (line 314) | ZetaInline Entry* begin_it()
  function ZetaInline (line 328) | ZetaInline Entry* next_it(Entry* curr)
  function ZetaInline (line 337) | ZetaInline Entry* end_it()
  function relocate (line 373) | void relocate(size_t n)

FILE: Source/ZetaCore/Utility/Optional.h
  function namespace (line 6) | namespace ZetaRay::Util
  function reset (line 109) | void reset()
  function ZetaInline (line 121) | ZetaInline T& value()
  function ZetaInline (line 126) | ZetaInline const T& value() const

FILE: Source/ZetaCore/Utility/RNG.h
  function namespace (line 6) | namespace ZetaRay::Util

FILE: Source/ZetaCore/Utility/SmallVector.h
  function namespace (line 7) | namespace ZetaRay::Util
  function free_memory (line 797) | void free_memory()
  function init_storage (line 829) | void init_storage(const T& t)
  function reset_storage (line 842) | void reset_storage()

FILE: Source/ZetaCore/Utility/Span.h
  function namespace (line 5) | namespace ZetaRay::Util
  type StrView (line 123) | struct StrView
  function ZetaInline (line 143) | ZetaInline const char* end() const
  function ZetaInline (line 147) | ZetaInline const char& operator[](size_t pos) const
  function ZetaInline (line 157) | ZetaInline const char* data() const
  type MemoryRegion (line 167) | struct MemoryRegion

FILE: Source/ZetaCore/Utility/SynchronizedView.h
  function namespace (line 6) | namespace ZetaRay::Util

FILE: Source/ZetaCore/Utility/Utility.h
  function namespace (line 5) | namespace ZetaRay::Util
  function ZetaInline (line 104) | ZetaInline uint32_t XXH3_64_To_32(uint64_t hash)

FILE: Source/ZetaCore/Win32/Win32App.cpp
  type FrameTime (line 35) | struct FrameTime
  type ParamUpdate (line 42) | struct ParamUpdate
    type OP_TYPE (line 44) | enum OP_TYPE
  type PreferredAppMode (line 55) | enum PreferredAppMode
  type WINDOWCOMPOSITIONATTRIB (line 64) | enum WINDOWCOMPOSITIONATTRIB
  type WINDOWCOMPOSITIONATTRIBDATA (line 96) | struct WINDOWCOMPOSITIONATTRIBDATA
  type FrameMemoryContext (line 118) | struct FrameMemoryContext
  type AppData (line 124) | struct AppData
    type TaskSignal (line 137) | struct alignas(64) TaskSignal
  function ImGuiMouseSource (line 214) | ImGuiMouseSource ImGui_GetMouseSourceFromMessageExtraInfo()
  function ImGui_UpdateMouseCursor (line 224) | bool ImGui_UpdateMouseCursor()
  function ImGui_UpdateMouse (line 259) | void ImGui_UpdateMouse()
  function ImGuiKey (line 287) | ImGuiKey ImGui_VirtualKeyToImGuiKey(WPARAM wParam, LPARAM lParam)
  function ImGui_IsVkDown (line 416) | bool ImGui_IsVkDown(int vk)
  function ImGui_AddKeyEvent (line 421) | void ImGui_AddKeyEvent(ImGuiKey key, bool down, int native_keycode, int ...
  function ImGui_UpdateKeyModifiers (line 430) | void ImGui_UpdateKeyModifiers()
  function ImGui_ProcessKeyEventsWorkarounds (line 439) | void ImGui_ProcessKeyEventsWorkarounds()
  type ZetaRay::AppImpl (line 457) | namespace ZetaRay::AppImpl
    function LoadFont (line 459) | void LoadFont()
    function OnActivated (line 529) | void OnActivated()
    function OnDeactivated (line 536) | void OnDeactivated()
    function OnDPIChanged (line 543) | void OnDPIChanged(uint16_t newDPI, const RECT* newRect)
    function InitImGui (line 550) | void InitImGui()
    function UpdateStats (line 609) | void UpdateStats(size_t tempMemoryUsage)
    function Update (line 648) | void Update(TaskSet& sceneTS, TaskSet& sceneRendererTS, size_t tempMem...
    function OnWindowSizeChanged (line 709) | void OnWindowSizeChanged()
    function OnKeyboard (line 739) | void OnKeyboard(UINT message, WPARAM wParam, LPARAM lParam)
    function OnMouseDown (line 810) | void OnMouseDown(UINT message, WPARAM btnState, LPARAM lParam)
    function OnMouseUp (line 850) | void OnMouseUp(UINT message, WPARAM btnState, LPARAM lParam)
    function OnMouseMove (line 886) | void OnMouseMove(UINT message, WPARAM btnState, LPARAM lParam, HWND hwnd)
    function OnMouseWheel (line 936) | void OnMouseWheel(UINT message, WPARAM btnState, LPARAM lParam)
    function OnDestroy (line 955) | void OnDestroy()
    function ApplyParamUpdates (line 979) | void ApplyParamUpdates()
    function TryInitDarkMode (line 1015) | bool TryInitDarkMode(HMODULE* uxthemeLib, HWND hWnd)
    function LRESULT (line 1064) | LRESULT WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    function CreateAppWindow (line 1213) | void CreateAppWindow(HINSTANCE instance)
    function SetCameraAcceleration (line 1255) | void SetCameraAcceleration(const ParamVariant& p)
    function ResizeIfQueued (line 1260) | void ResizeIfQueued()
    function ChangeDPIIfQueued (line 1278) | void ChangeDPIIfQueued()
    function ZetaInline (line 1300) | ZetaInline void* AllocateFrameAllocator(FrameMemory<blockSize>& frameM...
  type ZetaRay (line 1345) | namespace ZetaRay
    function CpuInfo (line 1347) | CpuInfo App::GetProcessorInfo()
    function RendererCore (line 1787) | RendererCore& App::GetRenderer() { return g_app->m_renderer; }
    function SceneCore (line 1788) | SceneCore& App::GetScene() { return g_app->m_scene; }
    function Camera (line 1789) | const Camera& App::GetCamera() { return g_app->m_camera; }

FILE: Source/ZetaLab/ZetaLab.cpp
  function WinMain (line 33) | int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevIns...

FILE: Source/ZetaRenderPass/AutoExposure/AutoExposure.h
  function namespace (line 7) | namespace ZetaRay::Core
  type class (line 14) | enum class
  type AutoExposure (line 21) | struct AutoExposure
  type class (line 23) | enum class
  function SHADER_OUT_RES (line 29) | enum class SHADER_OUT_RES

FILE: Source/ZetaRenderPass/AutoExposure/AutoExposure_Common.h
  type cbAutoExposureHist (line 11) | struct cbAutoExposureHist

FILE: Source/ZetaRenderPass/Common/FrameConstants.h
  type cbFrameConstants (line 10) | struct cbFrameConstants

FILE: Source/ZetaRenderPass/Compositing/Compositing.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 12) | namespace ZetaRay::Support
  type class (line 19) | enum class
  type Compositing (line 26) | struct Compositing
  type class (line 28) | enum class
  function SHADER_OUT_RES (line 37) | enum class SHADER_OUT_RES

FILE: Source/ZetaRenderPass/Compositing/Compositing_Common.h
  function namespace (line 12) | namespace CB_COMPOSIT_FLAGS
  type cbCompositing (line 21) | struct cbCompositing
  type cbFireflyFilter (line 36) | struct cbFireflyFilter

FILE: Source/ZetaRenderPass/DirectLighting/Emissive/DirectLighting.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 13) | namespace ZetaRay::Support
  type class (line 20) | enum class
  type DirectLighting (line 28) | struct DirectLighting
  function SHADER_OUT_RES (line 30) | enum class SHADER_OUT_RES

FILE: Source/ZetaRenderPass/DirectLighting/Emissive/DirectLighting_Common.h
  function namespace (line 12) | namespace CB_RDI_FLAGS
  type cb_ReSTIR_DI (line 21) | struct cb_ReSTIR_DI

FILE: Source/ZetaRenderPass/DirectLighting/Sky/SkyDI.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 12) | namespace ZetaRay::Support
  type class (line 19) | enum class
  type SkyDI (line 26) | struct SkyDI
  function SHADER_OUT_RES (line 28) | enum class SHADER_OUT_RES

FILE: Source/ZetaRenderPass/DirectLighting/Sky/SkyDI_Common.h
  function namespace (line 12) | namespace CB_SKY_DI_FLAGS
  type cb_SkyDI (line 19) | struct cb_SkyDI

FILE: Source/ZetaRenderPass/Display/Display.h
  function namespace (line 8) | namespace ZetaRay::Core
  function namespace (line 15) | namespace ZetaRay::Core::GpuMemory
  function namespace (line 20) | namespace ZetaRay::Support
  type class (line 27) | enum class
  type DisplayPass (line 36) | struct DisplayPass
  function SHADER_IN_CPU_DESC (line 38) | enum class SHADER_IN_CPU_DESC

FILE: Source/ZetaRenderPass/Display/Display_Common.h
  type class (line 6) | enum class
  type class (line 21) | enum class
  type cbDisplayPass (line 32) | struct cbDisplayPass
  type cbDrawPicked (line 48) | struct cbDrawPicked
  type cbSobel (line 56) | struct cbSobel

FILE: Source/ZetaRenderPass/FSR2/FSR2.cpp
  type ResourceData (line 29) | struct ResourceData
  type RenderPassData (line 39) | struct RenderPassData
  type PsoMap (line 50) | struct PsoMap
  type DllWrapper (line 56) | struct DllWrapper
    method Load (line 63) | void Load()
    method Free (line 87) | void Free()
  type FSR2_Data (line 112) | struct FSR2_Data
    method FSR2_Data (line 114) | FSR2_Data()
  function D3D12_RESOURCE_STATES (line 170) | D3D12_RESOURCE_STATES GetD3D12State(FfxResourceStates fsrState)
  function DXGI_FORMAT (line 226) | DXGI_FORMAT ToDXGIFormat(FfxSurfaceFormat surfaceFormat)
  function RecordClearJob (line 273) | void RecordClearJob(const FfxClearFloatJobDescription& job)
  function RecordComputeJob (line 334) | void RecordComputeJob(const FfxComputeJobDescription& job)
  function FfxErrorCode (line 472) | FfxErrorCode Fsr2CreateBackendContext(FfxFsr2Interface* backendInterface...
  function FfxErrorCode (line 477) | FfxErrorCode Fsr2DestroyBackendContext(FfxFsr2Interface* backendInterface)
  function FfxErrorCode (line 482) | FfxErrorCode Fsr2GetDeviceCapabilities(FfxFsr2Interface* backendInterface,
  function FfxErrorCode (line 502) | FfxErrorCode Fsr2CreateResource(FfxFsr2Interface* backendInterface,
  function FfxErrorCode (line 609) | FfxErrorCode Fsr2RegisterResource(FfxFsr2Interface* backendInterface, co...
  function FfxErrorCode (line 628) | FfxErrorCode Fsr2UnregisterResources(FfxFsr2Interface* backendInterface)
  function FfxResourceDescription (line 633) | FfxResourceDescription Fsr2GetResourceDescription(FfxFsr2Interface* back...
  function FfxErrorCode (line 725) | FfxErrorCode Fsr2DestroyResource(FfxFsr2Interface* backendInterface, Ffx...
  function FfxErrorCode (line 739) | FfxErrorCode Fsr2CreatePipeline(FfxFsr2Interface* backendInterface, FfxF...
  function FfxErrorCode (line 935) | FfxErrorCode Fsr2DestroyPipeline(FfxFsr2Interface* backendInterface, Ffx...
  function FfxErrorCode (line 940) | FfxErrorCode Fsr2ScheduleGpuJob(FfxFsr2Interface* backendInterface,
  function FfxErrorCode (line 959) | FfxErrorCode Fsr2ExecuteGpuJobs(FfxFsr2Interface* backendInterface, FfxC...
  function Texture (line 1273) | const Texture& FSR2Pass::GetOutput(SHADER_OUT_RES res)

FILE: Source/ZetaRenderPass/FSR2/FSR2.h
  function namespace (line 6) | namespace ZetaRay::Core
  function namespace (line 11) | namespace ZetaRay::RenderPass

FILE: Source/ZetaRenderPass/GBuffer/GBufferRT.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 12) | namespace ZetaRay::Support
  function namespace (line 17) | namespace ZetaRay::RenderPass

FILE: Source/ZetaRenderPass/GBuffer/GBufferRT_Common.h
  type class (line 12) | enum class
  type cbGBufferRt (line 27) | struct cbGBufferRt

FILE: Source/ZetaRenderPass/GBuffer/GenerateDepthBuffer.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 12) | namespace ZetaRay::RenderPass

FILE: Source/ZetaRenderPass/GUI/GuiPass.cpp
  function AddParamRange (line 32) | void AddParamRange(MutableSpan<ParamVariant> params, int offset, int count)
  function DrawAxis (line 124) | void DrawAxis(const float3& pos, const float3& xAxis, const float3& zAxi...
  function ShowStyles (line 200) | void ShowStyles()

FILE: Source/ZetaRenderPass/GUI/GuiPass.h
  function namespace (line 9) | namespace ZetaRay::Core
  function namespace (line 14) | namespace ZetaRay::Model
  function namespace (line 19) | namespace ZetaRay::RenderPass
  function EMISSIVE_COLOR_MODE (line 112) | enum class EMISSIVE_COLOR_MODE

FILE: Source/ZetaRenderPass/GUI/GuiPass_Common.h
  type cbGuiPass (line 6) | struct cbGuiPass

FILE: Source/ZetaRenderPass/IndirectLighting/IndirectLighting.cpp
  function EnumToSamplerIdx (line 21) | constexpr int EnumToSamplerIdx(TEXTURE_FILTER f)

FILE: Source/ZetaRenderPass/IndirectLighting/IndirectLighting.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 13) | namespace ZetaRay::Support
  type class (line 20) | enum class
  type IndirectLighting (line 56) | struct IndirectLighting
  type class (line 58) | enum class
  type class (line 64) | enum class
  function SetLightPresamplingParams (line 80) | void SetLightPresamplingParams(bool enable, int numSampleSets, int sampl...
  function SetLightVoxelGridParams (line 88) | void SetLightVoxelGridParams(bool enabled, const Math::uint3& dim,
  function Core (line 103) | const Core::GpuMemory::Texture& GetOutput(SHADER_OUT_RES i) const
  type ResourceFormats_RGI (line 120) | struct ResourceFormats_RGI
  type ResourceFormats_RPT (line 128) | struct ResourceFormats_RPT
  function DESC_TABLE_RGI (line 146) | enum class DESC_TABLE_RGI

FILE: Source/ZetaRenderPass/IndirectLighting/IndirectLighting_Common.h
  function namespace (line 34) | namespace CB_IND_FLAGS
  function namespace (line 47) | namespace PACKED_INDEX
  type class (line 58) | enum class
  type class (line 69) | enum class
  type cb_ReSTIR_GI (line 79) | struct cb_ReSTIR_GI
  type cb_ReSTIR_PT_PathTrace (line 104) | struct cb_ReSTIR_PT_PathTrace
  type cb_ReSTIR_PT_Reuse (line 119) | struct cb_ReSTIR_PT_Reuse
  type cb_ReSTIR_PT_Sort (line 145) | struct cb_ReSTIR_PT_Sort
  type cb_ReSTIR_PT_SpatialSearch (line 156) | struct cb_ReSTIR_PT_SpatialSearch

FILE: Source/ZetaRenderPass/PreLighting/PreLighting.cpp
  function BuildAliasTable (line 27) | void BuildAliasTable(MutableSpan<float> probs, MutableSpan<RT::EmissiveL...

FILE: Source/ZetaRenderPass/PreLighting/PreLighting.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 13) | namespace ZetaRay::Support
  function namespace (line 18) | namespace ZetaRay::RenderPass

FILE: Source/ZetaRenderPass/PreLighting/PreLighting_Common.h
  type cbPresampling (line 16) | struct cbPresampling
  type cbCurvature (line 21) | struct cbCurvature
  type cbLVG (line 26) | struct cbLVG

FILE: Source/ZetaRenderPass/RenderPass.h
  function namespace (line 7) | namespace ZetaRay::RenderPass

FILE: Source/ZetaRenderPass/Sky/Sky.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 12) | namespace ZetaRay::Support
  type class (line 19) | enum class
  type Sky (line 26) | struct Sky
  function SHADER_OUT_RES (line 28) | enum class SHADER_OUT_RES

FILE: Source/ZetaRenderPass/Sky/Sky_Common.h
  type cbSky (line 13) | struct cbSky

FILE: Source/ZetaRenderPass/TAA/TAA.h
  function namespace (line 7) | namespace ZetaRay::Core
  function namespace (line 12) | namespace ZetaRay::Support
  type TAA (line 19) | struct TAA
  type class (line 21) | enum class
  function SHADER_OUT_RES (line 27) | enum class SHADER_OUT_RES

FILE: Source/ZetaRenderPass/TAA/TAA_Common.h
  type cbTAA (line 8) | struct cbTAA

FILE: Source/ZetaRenderer/Default/DefaultRenderer.cpp
  type ZetaRay::DefaultRenderer (line 131) | namespace ZetaRay::DefaultRenderer
    function SetInscatteringEnablement (line 133) | void SetInscatteringEnablement(const ParamVariant& p)
    function SetAA (line 138) | void SetAA(const ParamVariant& p)
    function SetSunDir (line 170) | void SetSunDir(const ParamVariant& p)
    function SetSunLux (line 178) | void SetSunLux(const ParamVariant& p)
    function SetSunAngularDiameter (line 184) | void SetSunAngularDiameter(const ParamVariant& p)
    function SetRayleighSigmaSColor (line 191) | void SetRayleighSigmaSColor(const ParamVariant& p)
    function SetRayleighSigmaSScale (line 197) | void SetRayleighSigmaSScale(const ParamVariant& p)
    function SetMieSigmaS (line 203) | void SetMieSigmaS(const ParamVariant& p)
    function SetMieSigmaA (line 209) | void SetMieSigmaA(const ParamVariant& p)
    function SetOzoneSigmaAColor (line 215) | void SetOzoneSigmaAColor(const ParamVariant& p)
    function SetOzoneSigmaAScale (line 221) | void SetOzoneSigmaAScale(const ParamVariant& p)
    function SetgForPhaseHG (line 227) | void SetgForPhaseHG(const ParamVariant& p)
    function SetAccumulation (line 233) | void SetAccumulation(const ParamVariant& p)
    function SetIndirect (line 238) | void SetIndirect(const ParamVariant& p)
    function SetLensType (line 248) | void SetLensType(const Support::ParamVariant& p)
    function Init (line 257) | void Init()
    function Update (line 433) | void Update(TaskSet& ts)
    function Render (line 514) | void Render(TaskSet& ts)
    function Shutdown (line 519) | void Shutdown()
    function OnWindowSizeChanged (line 527) | void OnWindowSizeChanged()
    function DebugDrawRenderGraph (line 543) | void DebugDrawRenderGraph()
    function IsRTASBuilt (line 548) | bool IsRTASBuilt()
    function SceneModified (line 553) | void SceneModified()
    function Pick (line 558) | void Pick(uint16 screenPosX, uint16 screenPosY)
    function ClearPick (line 566) | void ClearPick()
    function CaptureScreen (line 571) | void CaptureScreen()
    function ToggleEmissives (line 576) | void ToggleEmissives()
  type ZetaRay::DefaultRenderer (line 255) | namespace ZetaRay::DefaultRenderer
    function SetInscatteringEnablement (line 133) | void SetInscatteringEnablement(const ParamVariant& p)
    function SetAA (line 138) | void SetAA(const ParamVariant& p)
    function SetSunDir (line 170) | void SetSunDir(const ParamVariant& p)
    function SetSunLux (line 178) | void SetSunLux(const ParamVariant& p)
    function SetSunAngularDiameter (line 184) | void SetSunAngularDiameter(const ParamVariant& p)
    function SetRayleighSigmaSColor (line 191) | void SetRayleighSigmaSColor(const ParamVariant& p)
    function SetRayleighSigmaSScale (line 197) | void SetRayleighSigmaSScale(const ParamVariant& p)
    function SetMieSigmaS (line 203) | void SetMieSigmaS(const ParamVariant& p)
    function SetMieSigmaA (line 209) | void SetMieSigmaA(const ParamVariant& p)
    function SetOzoneSigmaAColor (line 215) | void SetOzoneSigmaAColor(const ParamVariant& p)
    function SetOzoneSigmaAScale (line 221) | void SetOzoneSigmaAScale(const ParamVariant& p)
    function SetgForPhaseHG (line 227) | void SetgForPhaseHG(const ParamVariant& p)
    function SetAccumulation (line 233) | void SetAccumulation(const ParamVariant& p)
    function SetIndirect (line 238) | void SetIndirect(const ParamVariant& p)
    function SetLensType (line 248) | void SetLensType(const Support::ParamVariant& p)
    function Init (line 257) | void Init()
    function Update (line 433) | void Update(TaskSet& ts)
    function Render (line 514) | void Render(TaskSet& ts)
    function Shutdown (line 519) | void Shutdown()
    function OnWindowSizeChanged (line 527) | void OnWindowSizeChanged()
    function DebugDrawRenderGraph (line 543) | void DebugDrawRenderGraph()
    function IsRTASBuilt (line 548) | bool IsRTASBuilt()
    function SceneModified (line 553) | void SceneModified()
    function Pick (line 558) | void Pick(uint16 screenPosX, uint16 screenPosY)
    function ClearPick (line 566) | void ClearPick()
    function CaptureScreen (line 571) | void CaptureScreen()
    function ToggleEmissives (line 576) | void ToggleEmissives()

FILE: Source/ZetaRenderer/Default/DefaultRenderer.h
  function namespace (line 5) | namespace ZetaRay::DefaultRenderer

FILE: Source/ZetaRenderer/Default/DefaultRendererImpl.h
  type Defaults (line 26) | struct Defaults
  type class (line 46) | enum class
  type alignas (line 64) | struct alignas
  type alignas (line 80) | struct alignas
  type GBUFFER (line 82) | enum GBUFFER
  type alignas (line 131) | struct alignas
  function DESC_TABLE_CONST (line 152) | enum class DESC_TABLE_CONST
  type alignas (line 163) | struct alignas
  function DESC_TABLE_WND_SIZE_CONST (line 196) | enum class DESC_TABLE_WND_SIZE_CONST
  function namespace (line 239) | namespace ZetaRay::DefaultRenderer::Common
  function namespace (line 249) | namespace ZetaRay::DefaultRenderer::GBuffer
  function namespace (line 265) | namespace ZetaRay::DefaultRenderer::PathTracer
  function namespace (line 280) | namespace ZetaRay::DefaultRenderer::PostProcessor

FILE: Tests/TestContainer.cpp
  type A (line 150) | struct A
    method A (line 152) | A()
  type Temp (line 257) | struct Temp
    method Temp (line 259) | Temp() = default;
    method Temp (line 260) | Temp(float unused, int* p)

FILE: Tests/TestOptional.cpp
  type NonTrivial (line 10) | struct NonTrivial
    method NonTrivial (line 12) | NonTrivial()
    method NonTrivial (line 15) | NonTrivial(int v)
    method NonTrivial (line 22) | NonTrivial(const NonTrivial& other)
    method NonTrivial (line 25) | NonTrivial& operator=(NonTrivial&& other)

FILE: Tools/BCnCompressglTF/BCnCompressglTF.cpp
  type TEX_CONV_ARGV_NO_OVERWRITE_SRGB (line 32) | namespace TEX_CONV_ARGV_NO_OVERWRITE_SRGB
  type TEX_CONV_ARGV_OVERWRITE_SRGB (line 38) | namespace TEX_CONV_ARGV_OVERWRITE_SRGB
  type TEX_CONV_ARGV_NO_OVERWRITE (line 44) | namespace TEX_CONV_ARGV_NO_OVERWRITE
  type TEX_CONV_ARGV_OVERWRITE (line 50) | namespace TEX_CONV_ARGV_OVERWRITE
  type TEX_CONV_ARGV_NO_OVERWRITE_SWIZZLE (line 56) | namespace TEX_CONV_ARGV_NO_OVERWRITE_SWIZZLE
  type TEX_CONV_ARGV_OVERWRITE_SWIZZLE (line 62) | namespace TEX_CONV_ARGV_OVERWRITE_SWIZZLE
  type TEXTURE_TYPE (line 73) | enum TEXTURE_TYPE
  function ZetaInline (line 99) | ZetaInline void DecodeURI_Inplace(ArenaPathNoInline& str, MemoryArena& a...
  function ZetaInline (line 159) | ZetaInline bool IsASCII(const ArenaPathNoInline& path)
  function DecodeImageURIs (line 172) | void DecodeImageURIs(const ArenaPath& gltfPath, cgltf_data& model, Memor...
  function CreateDevice (line 192) | void CreateDevice(ID3D11Device** pDevice)
  function ConvertTextures (line 231) | bool ConvertTextures(TEXTURE_TYPE texType, const ArenaPath& glTFPath,
  function WriteModifiedglTF (line 351) | void WriteModifiedglTF(cgltf_data& model, const ArenaPath& gltfPath, Mem...
  function ZetaInline (line 385) | ZetaInline void ReportUsageError()
  function main (line 391) | int main(int argc, char* argv[])

FILE: Tools/BCnCompressglTF/DirectXTex/BC.cpp
  function Decode565 (line 36) | inline void Decode565(_Out_ HDRColorA *pColor, _In_ const uint16_t w565)...
  function Encode565 (line 44) | inline uint16_t Encode565(_In_ const HDRColorA *pColor) noexcept
  function OptimizeRGB (line 65) | void OptimizeRGB(
  function DecodeBC1 (line 318) | inline void DecodeBC1(
  function EncodeBC1 (line 370) | void EncodeBC1(
  function EncodeSolidBC1 (line 689) | void EncodeSolidBC1(_Out_ D3DX_BC1 *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK...
  function _Use_decl_annotations_ (line 730) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 737) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 801) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 827) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 901) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 943) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/BC.h
  function namespace (line 17) | namespace DirectX
  function HDRColorA (line 153) | inline HDRColorA* HDRColorALerp(_Out_ HDRColorA *pOut, _In_ const HDRCol...
  type D3DX_BC1 (line 164) | struct D3DX_BC1
  type D3DX_BC2 (line 171) | struct D3DX_BC2
  type D3DX_BC3 (line 178) | struct D3DX_BC3

FILE: Tools/BCnCompressglTF/DirectXTex/BC4BC5.cpp
  type BC4_UNORM (line 39) | struct BC4_UNORM
    method R (line 41) | float R(size_t uOffset) const noexcept
    method DecodeFromIndex (line 47) | float DecodeFromIndex(size_t uIndex) const noexcept
    method GetIndex (line 71) | size_t GetIndex(size_t uOffset) const noexcept
    method SetIndex (line 76) | void SetIndex(size_t uOffset, size_t uIndex) noexcept
  type BC4_SNORM (line 95) | struct BC4_SNORM
    method R (line 97) | float R(size_t uOffset) const noexcept
    method DecodeFromIndex (line 103) | float DecodeFromIndex(size_t uIndex) const noexcept
    method GetIndex (line 130) | size_t GetIndex(size_t uOffset) const noexcept
    method SetIndex (line 135) | void SetIndex(size_t uOffset, size_t uIndex) noexcept
  function FloatToSNorm (line 158) | void inline FloatToSNorm(_In_ float fVal, _Out_ int8_t *piSNorm) noexcept
  function FindEndPointsBC4U (line 183) | void FindEndPointsBC4U(
  function FindEndPointsBC4S (line 238) | void FindEndPointsBC4S(
  function FindEndPointsBC5U (line 297) | inline void FindEndPointsBC5U(
  function FindEndPointsBC5S (line 310) | inline void FindEndPointsBC5S(
  function FindClosestUNORM (line 325) | void FindClosestUNORM(
  function FindClosestSNORM (line 352) | void FindClosestSNORM(
  function _Use_decl_annotations_ (line 388) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 403) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 418) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 439) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 464) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 480) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 496) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 530) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/BC6HBC7.cpp
  type DirectX (line 332) | namespace DirectX
    class LDRColorA (line 334) | class LDRColorA
      method LDRColorA (line 339) | LDRColorA() = default;
      method LDRColorA (line 340) | LDRColorA(uint8_t _r, uint8_t _g, uint8_t _b, uint8_t _a) noexcept :...
      method LDRColorA (line 366) | LDRColorA operator = (_In_ const HDRColorA& c) noexcept
      method InterpolateRGB (line 378) | static void InterpolateRGB(_In_ const LDRColorA& c0, _In_ const LDRC...
      method InterpolateA (line 393) | static void InterpolateA(_In_ const LDRColorA& c0, _In_ const LDRCol...
      method Interpolate (line 406) | static void Interpolate(_In_ const LDRColorA& c0, _In_ const LDRColo...
    type LDREndPntPair (line 415) | struct LDREndPntPair
    function HDRColorA (line 429) | inline HDRColorA& HDRColorA::operator = (const LDRColorA& c) noexcept
    function LDRColorA (line 438) | inline LDRColorA HDRColorA::ToLDRColorA() const noexcept
      method LDRColorA (line 339) | LDRColorA() = default;
      method LDRColorA (line 340) | LDRColorA(uint8_t _r, uint8_t _g, uint8_t _b, uint8_t _a) noexcept :...
      method LDRColorA (line 366) | LDRColorA operator = (_In_ const HDRColorA& c) noexcept
      method InterpolateRGB (line 378) | static void InterpolateRGB(_In_ const LDRColorA& c0, _In_ const LDRC...
      method InterpolateA (line 393) | static void InterpolateA(_In_ const LDRColorA& c0, _In_ const LDRCol...
      method Interpolate (line 406) | static void Interpolate(_In_ const LDRColorA& c0, _In_ const LDRColo...
  class INTColor (line 446) | class INTColor
    method INTColor (line 453) | INTColor() = default;
    method INTColor (line 454) | INTColor(int nr, int ng, int nb) noexcept : r(nr), g(ng), b(nb), pad(0...
    method INTColor (line 455) | INTColor(const INTColor& c) noexcept : r(c.r), g(c.g), b(c.b), pad(0) {}
    method INTColor (line 456) | INTColor& operator=(const INTColor& c) noexcept
    method INTColor (line 466) | INTColor& operator += (_In_ const INTColor& c) noexcept
    method INTColor (line 474) | INTColor& operator -= (_In_ const INTColor& c) noexcept
    method INTColor (line 482) | INTColor& operator &= (_In_ const INTColor& c) noexcept
    method Set (line 497) | void Set(_In_ const HDRColorA& c, _In_ bool bSigned) noexcept
    method INTColor (line 509) | INTColor& Clamp(_In_ int iMin, _In_ int iMax) noexcept
    method INTColor (line 517) | INTColor& SignExtend(_In_ const LDRColorA& Prec) noexcept
    method ToF16 (line 525) | void ToF16(_Out_writes_(3) PackedVector::HALF aF16[3], _In_ bool bSign...
    method F16ToINT (line 533) | static int F16ToINT(_In_ const PackedVector::HALF& f, _In_ bool bSigne...
    method INT2F16 (line 553) | static PackedVector::HALF INT2F16(_In_ int input, _In_ bool bSigned) n...
  type INTEndPntPair (line 580) | struct INTEndPntPair
  class CBits (line 587) | class CBits
    method GetBit (line 590) | uint8_t GetBit(_Inout_ size_t& uStartBit) const noexcept
    method GetBits (line 600) | uint8_t GetBits(_Inout_ size_t& uStartBit, _In_ size_t uNumBits) const...
    method SetBit (line 623) | void SetBit(_Inout_ size_t& uStartBit, _In_ uint8_t uValue) noexcept
    method SetBits (line 634) | void SetBits(_Inout_ size_t& uStartBit, _In_ size_t uNumBits, _In_ uin...
  class D3DX_BC6H (line 665) | class D3DX_BC6H : private CBits< 16 >
    type EField (line 674) | enum EField : uint8_t
    type ModeDescriptor (line 694) | struct ModeDescriptor
    type ModeInfo (line 700) | struct ModeInfo
    type EncodeParams (line 711) | struct EncodeParams
      method EncodeParams (line 721) | EncodeParams(const HDRColorA* const aOriginal, bool bSignedFormat) n...
  class D3DX_BC7 (line 769) | class D3DX_BC7 : private CBits< 16 >
    type ModeInfo (line 776) | struct ModeInfo
    type EncodeParams (line 791) | struct EncodeParams
      method EncodeParams (line 798) | EncodeParams(const HDRColorA* const aOriginal) noexcept : uMode(0), ...
    method Quantize (line 802) | static uint8_t Quantize(_In_ uint8_t comp, _In_ uint8_t uPrec) noexcept
    method LDRColorA (line 809) | static LDRColorA Quantize(_In_ const LDRColorA& c, _In_ const LDRColor...
    method Unquantize (line 822) | static uint8_t Unquantize(_In_ uint8_t comp, _In_ size_t uPrec) noexcept
    method LDRColorA (line 829) | static LDRColorA Unquantize(_In_ const LDRColorA& c, _In_ const LDRCol...
  function TransformForward (line 1140) | inline void TransformForward(_Inout_updates_all_(BC6H_MAX_REGIONS) INTEn...
  function TransformInverse (line 1147) | inline void TransformInverse(_Inout_updates_all_(BC6H_MAX_REGIONS) INTEn...
  function Norm (line 1161) | inline float Norm(_In_ const INTColor& a, _In_ const INTColor& b) noexcept
  function NBits (line 1170) | inline int NBits(_In_ int n, _In_ bool bIsSigned) noexcept
  function OptimizeRGB (line 1192) | float OptimizeRGB(
  function OptimizeRGBA (line 1388) | float OptimizeRGBA(
  function ComputeError (line 1557) | float ComputeError(
  function FillWithErrorColors (line 1636) | void FillWithErrorColors(_Out_writes_(NUM_PIXELS_PER_BLOCK) HDRColorA* p...
  function _Use_decl_annotations_ (line 1655) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1816) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1863) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1892) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1929) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1944) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1986) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2037) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2072) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2133) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2186) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2213) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2242) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2284) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2306) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2350) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2400) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2436) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2461) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2528) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2737) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2846) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2875) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2917) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2988) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3054) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3077) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3157) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3244) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3329) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3387) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3410) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3523) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3531) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3539) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3548) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3561) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3569) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/BCDirectCompute.cpp
  type BufferBC6HBC7 (line 31) | struct BufferBC6HBC7
  type ConstantsBC6HBC7 (line 36) | struct ConstantsBC6HBC7
  function RunComputeShader (line 50) | inline void RunComputeShader(ID3D11DeviceContext* pContext,
  function ResetContext (line 69) | inline void ResetContext(ID3D11DeviceContext* pContext)
  function _Use_decl_annotations_ (line 95) | _Use_decl_annotations_
  function HRESULT (line 176) | HRESULT GPUCompressBC::Prepare(size_t width, size_t height, uint32_t fla...
  function HRESULT (line 346) | HRESULT GPUCompressBC::Compress(const Image& srcImage, const Image& dest...

FILE: Tools/BCnCompressglTF/DirectXTex/BCDirectCompute.h
  function namespace (line 12) | namespace DirectX

FILE: Tools/BCnCompressglTF/DirectXTex/DDS.h
  function namespace (line 23) | namespace DirectX

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTex.h
  type IWICImagingFactory (line 26) | struct IWICImagingFactory
  type IWICMetadataQueryReader (line 27) | struct IWICMetadataQueryReader
  function namespace (line 36) | namespace DirectX
  type DDS_FLAGS (line 172) | enum DDS_FLAGS : unsigned long
  type TGA_FLAGS (line 210) | enum TGA_FLAGS : unsigned long
  type WIC_FLAGS (line 233) | enum WIC_FLAGS : unsigned long
  type Image (line 318) | struct Image
  function class (line 328) | class ScratchImage
  function TexMetadata (line 358) | const TexMetadata& __cdecl GetMetadata() const noexcept { return m_metad...
  function Image (line 361) | const Image* __cdecl GetImages() const noexcept { return m_image; }
  function GetImageCount (line 362) | size_t __cdecl GetImageCount() const noexcept { return m_nimages; }
  function GetPixelsSize (line 365) | size_t __cdecl GetPixelsSize() const noexcept { return m_size; }
  function class (line 379) | class Blob
  function GetBufferSize (line 396) | size_t __cdecl GetBufferSize() const noexcept { return m_size; }
  type TEX_FR_FLAGS (line 500) | enum TEX_FR_FLAGS : unsigned long
  type TEX_FILTER_FLAGS (line 518) | enum TEX_FILTER_FLAGS : unsigned long
  type TEX_COMPRESS_FLAGS (line 648) | enum TEX_COMPRESS_FLAGS : unsigned long
  type CNMAP_FLAGS (line 706) | enum CNMAP_FLAGS : unsigned long
  type Rect (line 740) | struct Rect

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexCompress.cpp
  function GetBCFlags (line 26) | constexpr uint32_t GetBCFlags(_In_ TEX_COMPRESS_FLAGS compress) noexcept
  function TEX_FILTER_FLAGS (line 37) | constexpr TEX_FILTER_FLAGS GetSRGBFlags(_In_ TEX_COMPRESS_FLAGS compress...
  function DetermineEncoderSettings (line 46) | inline bool DetermineEncoderSettings(_In_ DXGI_FORMAT format, _Out_ BC_E...
  function HRESULT (line 72) | HRESULT CompressBC(
  function HRESULT (line 201) | HRESULT CompressBC_Parallel(
  function DXGI_FORMAT (line 334) | DXGI_FORMAT DefaultDecompress(_In_ DXGI_FORMAT format) noexcept
  function HRESULT (line 382) | HRESULT DecompressBC(_In_ const Image& cImage, _In_ const Image& result)...
  function _Use_decl_annotations_ (line 588) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 635) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 722) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 770) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexCompressGPU.cpp
  function TEX_FILTER_FLAGS (line 21) | constexpr TEX_FILTER_FLAGS GetSRGBFlags(_In_ TEX_COMPRESS_FLAGS compress...
  function HRESULT (line 34) | HRESULT ConvertToRGBA32(
  function HRESULT (line 98) | HRESULT ConvertToRGBAF32(
  function HRESULT (line 146) | inline HRESULT GPUCompress(
  function _Use_decl_annotations_ (line 209) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 257) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexConvert.cpp
  function FloatTo7e3 (line 21) | inline uint32_t FloatTo7e3(float Value) noexcept
  function FloatFrom7e3 (line 54) | inline float FloatFrom7e3(uint32_t Value) noexcept
  function FloatTo6e4 (line 88) | inline uint32_t FloatTo6e4(float Value) noexcept
  function FloatFrom6e4 (line 121) | inline float FloatFrom6e4(uint32_t Value) noexcept
  function _Use_decl_annotations_ (line 204) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 449) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 619) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 761) | _Use_decl_annotations_ bool DirectX::Internal::LoadScanline(
  function _Use_decl_annotations_ (line 1608) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2463) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2503) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2529) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2559) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2635) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2687) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2730) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2807) | _Use_decl_annotations_
  type ConvertData (line 2879) | struct ConvertData
  function ConvertCompare (line 2975) | int __cdecl ConvertCompare(const void* ptr1, const void *ptr2) noexcept
  function _Use_decl_annotations_ (line 2984) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3004) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3902) | _Use_decl_annotations_
  function UseWICConversion (line 4378) | inline bool UseWICConversion(
  function HRESULT (line 4540) | HRESULT ConvertUsingWIC(
  function HRESULT (line 4608) | HRESULT ConvertCustom(
  function DXGI_FORMAT (line 4695) | DXGI_FORMAT PlanarToSingle(_In_ DXGI_FORMAT format) noexcept
  function HRESULT (line 4770) | HRESULT ConvertToSinglePlane_(_In_ const Image& srcImage, _In_ const Ima...
  function _Use_decl_annotations_ (line 4857) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 4914) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 5073) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 5114) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexD3D11.cpp
  function HRESULT (line 33) | HRESULT Capture(
  function _Use_decl_annotations_ (line 206) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 406) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 420) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 615) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 629) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 733) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexDDS.cpp
  type CONVERSION_FLAGS (line 30) | enum CONVERSION_FLAGS : uint32_t
  type LegacyDDS (line 52) | struct LegacyDDS
  function DXGI_FORMAT (line 166) | DXGI_FORMAT GetDXGIFormat(const DDS_HEADER& hdr, const DDS_PIXELFORMAT& ...
  function HRESULT (line 281) | HRESULT DecodeDDSHeader(
  function _Use_decl_annotations_ (line 563) | _Use_decl_annotations_
  type TEXP_LEGACY_FORMAT (line 880) | enum TEXP_LEGACY_FORMAT
  function TEXP_LEGACY_FORMAT (line 895) | constexpr TEXP_LEGACY_FORMAT FindLegacyFormat(uint32_t flags) noexcept
  function LegacyExpandScanline (line 924) | bool LegacyExpandScanline(
  function HRESULT (line 1233) | HRESULT CopyImage(
  function HRESULT (line 1508) | HRESULT CopyImageInPlace(uint32_t convFlags, _In_ const ScratchImage& im...
  function _Use_decl_annotations_ (line 1563) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1577) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1664) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1737) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1990) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 2214) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexFlipRotate.cpp
  function HRESULT (line 23) | HRESULT PerformFlipRotateUsingWIC(
  function HRESULT (line 92) | HRESULT PerformFlipRotateViaF16(
  function HRESULT (line 134) | HRESULT PerformFlipRotateViaF32(
  function _Use_decl_annotations_ (line 185) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 282) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexImage.cpp
  function _Use_decl_annotations_ (line 33) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 136) | _Use_decl_annotations_
  function ScratchImage (line 267) | ScratchImage& ScratchImage::operator= (ScratchImage&& moveFrom) noexcept
  function _Use_decl_annotations_ (line 291) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 377) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 393) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 444) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 498) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 514) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 551) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 611) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 630) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 707) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 726) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexMipmaps.cpp
  function ispow2 (line 22) | constexpr bool ispow2(_In_ size_t x) noexcept
  function CountMips (line 28) | size_t CountMips(_In_ size_t width, _In_ size_t height) noexcept
  function CountMips3D (line 47) | size_t CountMips3D(_In_ size_t width, _In_ size_t height, _In_ size_t de...
  function HRESULT (line 69) | HRESULT EnsureWicBitmapPixelFormat(
  function XMVECTOR (line 127) | inline XMVECTOR XM_CALLCONV VectorSum
  function HRESULT (line 140) | HRESULT ScaleAlpha(
  function GenerateAlphaCoverageConvolutionVectors (line 191) | void GenerateAlphaCoverageConvolutionVectors(
  function HRESULT (line 212) | HRESULT CalculateAlphaCoverage(
  function HRESULT (line 307) | HRESULT EstimateAlphaScaleForCoverage(
  function _Use_decl_annotations_ (line 355) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 378) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 404) | _Use_decl_annotations_
  function UseWICFiltering (line 625) | bool UseWICFiltering(_In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filt...
  function HRESULT (line 704) | HRESULT GenerateMipMapsUsingWIC(
  function HRESULT (line 852) | HRESULT Setup2DMips(
  function HRESULT (line 908) | HRESULT Generate2DMipsPointFilter(size_t levels, const ScratchImage& mip...
  function HRESULT (line 992) | HRESULT Generate2DMipsBoxFilter(size_t levels, TEX_FILTER_FLAGS filter, ...
  function HRESULT (line 1088) | HRESULT Generate2DMipsLinearFilter(size_t levels, TEX_FILTER_FLAGS filte...
  function HRESULT (line 1205) | HRESULT Generate2DMipsCubicFilter(size_t levels, TEX_FILTER_FLAGS filter...
  function HRESULT (line 1393) | HRESULT Generate2DMipsTriangleFilter(size_t levels, TEX_FILTER_FLAGS fil...
  function HRESULT (line 1609) | HRESULT Setup3DMips(
  function HRESULT (line 1664) | HRESULT Generate3DMipsPointFilter(size_t depth, size_t levels, const Scr...
  function HRESULT (line 1810) | HRESULT Generate3DMipsBoxFilter(size_t depth, size_t levels, TEX_FILTER_...
  function HRESULT (line 1984) | HRESULT Generate3DMipsLinearFilter(size_t depth, size_t levels, TEX_FILT...
  function HRESULT (line 2179) | HRESULT Generate3DMipsCubicFilter(size_t depth, size_t levels, TEX_FILTE...
  function HRESULT (line 2560) | HRESULT Generate3DMipsTriangleFilter(size_t depth, size_t levels, TEX_FI...
  function _Use_decl_annotations_ (line 2810) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3002) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3236) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3343) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 3459) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexMisc.cpp
  function HRESULT (line 27) | HRESULT ComputeMSE_(
  function HRESULT (line 179) | HRESULT EvaluateImage_(
  function HRESULT (line 215) | HRESULT TransformImage_(
  function _Use_decl_annotations_ (line 274) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 387) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 474) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 508) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 605) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 639) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexP.h
  function namespace (line 157) | namespace DirectX

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexResize.cpp
  function HRESULT (line 24) | HRESULT PerformResizeUsingWIC(
  function HRESULT (line 128) | HRESULT PerformResizeViaF32(
  function UseWICFiltering (line 172) | bool UseWICFiltering(_In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filt...
  function HRESULT (line 255) | HRESULT ResizePointFilter(const Image& srcImage, const Image& destImage)...
  function HRESULT (line 312) | HRESULT ResizeBoxFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, ...
  function HRESULT (line 375) | HRESULT ResizeLinearFilter(const Image& srcImage, TEX_FILTER_FLAGS filte...
  function HRESULT (line 466) | HRESULT ResizeCubicFilter(const Image& srcImage, TEX_FILTER_FLAGS filter...
  function HRESULT (line 627) | HRESULT ResizeTriangleFilter(const Image& srcImage, TEX_FILTER_FLAGS fil...
  function HRESULT (line 807) | HRESULT PerformResizeUsingCustomFilters(const Image& srcImage, TEX_FILTE...
  function _Use_decl_annotations_ (line 853) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 942) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexUtil.cpp
  type WICTranslate (line 39) | struct WICTranslate
  function BOOL (line 76) | BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID *ifactory) noe...
  function _Use_decl_annotations_ (line 135) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 155) | _Use_decl_annotations_
  function TEX_FILTER_FLAGS (line 216) | TEX_FILTER_FLAGS DirectX::Internal::CheckWICColorSpace(_In_ const GUID& ...
  function _Use_decl_annotations_ (line 247) | _Use_decl_annotations_
  function IWICImagingFactory (line 288) | IWICImagingFactory* DirectX::GetWICFactory(bool& iswic2) noexcept
  function _Use_decl_annotations_ (line 346) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 365) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 402) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 431) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 458) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 502) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 565) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 725) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 891) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1091) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1154) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1189) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1309) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1368) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1404) | _Use_decl_annotations_
  function Blob (line 1458) | Blob& Blob::operator= (Blob&& moveFrom) noexcept
  function _Use_decl_annotations_ (line 1484) | _Use_decl_annotations_
  function HRESULT (line 1504) | HRESULT Blob::Trim(size_t size) noexcept
  function HRESULT (line 1520) | HRESULT Blob::Resize(size_t size) noexcept

FILE: Tools/BCnCompressglTF/DirectXTex/DirectXTexWIC.cpp
  type WICConvert (line 23) | struct WICConvert
  function DXGI_FORMAT (line 91) | DXGI_FORMAT DetermineFormat(
  class MemoryStreamOnBlob (line 198) | class MemoryStreamOnBlob : public IStream
    method MemoryStreamOnBlob (line 200) | MemoryStreamOnBlob(Blob& blob) noexcept :
    method MemoryStreamOnBlob (line 212) | MemoryStreamOnBlob(MemoryStreamOnBlob&&) = delete;
    method MemoryStreamOnBlob (line 213) | MemoryStreamOnBlob& operator= (MemoryStreamOnBlob&&) = delete;
    method MemoryStreamOnBlob (line 215) | MemoryStreamOnBlob(MemoryStreamOnBlob const&) = delete;
    method MemoryStreamOnBlob (line 216) | MemoryStreamOnBlob& operator= (MemoryStreamOnBlob const&) = delete;
    method QueryInterface (line 219) | QueryInterface(REFIID iid, void** ppvObject) override
    method AddRef (line 233) | AddRef() override
    method Release (line 238) | Release() override
    method Read (line 249) | Read(void* pv, ULONG cb, ULONG* pcbRead) override
    method Write (line 287) | Write(void const* pv, ULONG cb, ULONG* pcbWritten) override
    method SetSize (line 336) | SetSize(ULARGE_INTEGER size) override
    method CopyTo (line 382) | CopyTo(IStream*, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*) ove...
    method Commit (line 387) | Commit(DWORD) override
    method Revert (line 392) | Revert() override
    method LockRegion (line 397) | LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) override
    method UnlockRegion (line 402) | UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) override
    method Clone (line 407) | Clone(IStream**) override
    method Seek (line 412) | Seek(LARGE_INTEGER liDistanceToMove, DWORD dwOrigin, ULARGE_INTEGER* l...
    method Stat (line 459) | Stat(STATSTG* pStatstg, DWORD) override
    method HRESULT (line 467) | HRESULT Finialize() noexcept
    method HRESULT (line 475) | static HRESULT CreateMemoryStream(_Outptr_ MemoryStreamOnBlob** stream...
    method HRESULT (line 497) | static HRESULT ComputeGrowSize(uint64_t& newSize, const uint64_t targe...
  function HRESULT (line 521) | HRESULT DecodeMetadata(
  function HRESULT (line 665) | HRESULT DecodeSingleFrame(
  function HRESULT (line 733) | HRESULT DecodeMultiframe(
  function HRESULT (line 872) | HRESULT EncodeMetadata(
  function HRESULT (line 972) | HRESULT EncodeImage(
  function HRESULT (line 1076) | HRESULT EncodeSingleFrame(
  function HRESULT (line 1140) | HRESULT EncodeMultiframe(
  function _Use_decl_annotations_ (line 1217) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1270) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1308) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1383) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1444) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1487) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1539) | _Use_decl_annotations_
  function _Use_decl_annotations_ (line 1579) | _Use_decl_annotations_

FILE: Tools/BCnCompressglTF/DirectXTex/filters.h
  function namespace (line 20) | namespace DirectX

FILE: Tools/BCnCompressglTF/DirectXTex/scoped.h
  type aligned_deleter (line 21) | struct aligned_deleter { void operator()(void* p) noexcept { free(p); }
  function ScopedAlignedArrayFloat (line 25) | inline ScopedAlignedArrayFloat make_AlignedArrayFloat(uint64_t count)
  function ScopedAlignedArrayXMVECTOR (line 38) | inline ScopedAlignedArrayXMVECTOR make_AlignedArrayXMVECTOR(uint64_t count)
  type aligned_deleter (line 51) | struct aligned_deleter { void operator()(void* p) noexcept { _aligned_fr...
  function ScopedAlignedArrayFloat (line 55) | inline ScopedAlignedArrayFloat make_AlignedArrayFloat(uint64_t count)
  function ScopedAlignedArrayXMVECTOR (line 66) | inline ScopedAlignedArrayXMVECTOR make_AlignedArrayXMVECTOR(uint64_t count)
  type handle_closer (line 76) | struct handle_closer { void operator()(HANDLE h) noexcept { assert(h != ...
  function HANDLE (line 80) | inline HANDLE safe_handle(HANDLE h) noexcept { return (h == INVALID_HAND...
  type find_closer (line 83) | struct find_closer { void operator()(HANDLE h) noexcept { assert(h != IN...
  function class (line 88) | class auto_delete_file

FILE: Tools/BCnCompressglTF/TexConv/texconv.cpp
  type OPTIONS (line 39) | enum OPTIONS : uint64_t
  type SConversion (line 115) | struct SConversion
  type SValue (line 122) | struct SValue
  function HANDLE (line 445) | inline HANDLE safe_handle(HANDLE h) noexcept { return (h == INVALID_HAND...
  type find_closer (line 447) | struct find_closer { void operator()(HANDLE h) noexcept { assert(h != IN...
  function ispow2 (line 451) | constexpr static bool ispow2(size_t x)
  function T (line 461) | T LookupByName(const wchar_t *pName, const SValue<T> *pArray)
  function wchar_t (line 475) | const wchar_t* LookupByValue(T value, const SValue<T> *pArray)
  function SearchForFiles (line 488) | void SearchForFiles(const wchar_t* path, std::list<SConversion>& files, ...
  function ProcessFileList (line 568) | void ProcessFileList(std::wifstream& inFile, std::list<SConversion>& files)
  function PrintFormat (line 652) | void PrintFormat(DXGI_FORMAT Format)
  function PrintInfo (line 675) | void PrintInfo(const TexMetadata& info)
  function PrintList (line 734) | void PrintList(size_t cch, const SValue<uint32_t> *pValue)
  function PrintLogo (line 754) | void PrintLogo()
  function GetDXGIFactory (line 791) | bool GetDXGIFactory(_Outptr_ IDXGIFactory1** pFactory)
  function PrintUsage (line 816) | void PrintUsage()
  function wchar_t (line 930) | const wchar_t* GetErrorDesc(HRESULT hr)
  function FitPowerOf2 (line 959) | void FitPowerOf2(size_t origx, size_t origy, _Inout_ size_t& targetx, _I...
  function CountMips (line 999) | constexpr size_t CountMips(_In_ size_t width, _In_ size_t height) noexcept
  function CountMips3D (line 1017) | constexpr size_t CountMips3D(_In_ size_t width, _In_ size_t height, _In_...
  function LinearToST2084 (line 1085) | inline float LinearToST2084(float normalizedLinearValue)
  function ST2084ToLinear (line 1091) | inline float ST2084ToLinear(float ST2084)
  function TexConv (line 1199) | int TexConv(int argc, wchar_t* argv[], ID3D11Device* device)

FILE: Tools/PrecompileShaders/PrecompileShaders.cpp
  type Data (line 20) | struct Data
  function main (line 45) | int main(int argc, char* argv[])

[
  {
    "path": ".gitattributes",
    "chars": 232,
    "preview": "Tools/BCnCompressglTF/DirectXTex/Shaders/Compiled/* linguist-vendored\nTools/BCnCompressglTF/DirectXTex/** linguist-vendo"
  },
  {
    "path": ".github/workflows/build.yml",
    "chars": 1095,
    "preview": "name: build-and-test\n\non:\n  push:\n    branches:\n      - master\n    paths:\n      - 'Source/**'\n      - 'Tests/**'\n      -"
  },
  {
    "path": ".gitignore",
    "chars": 426,
    "preview": "# build files\n/.vs\n/.vscode\nbuild/\nbin/\n\n# assets\nAssets/*\n!Assets/CornellBox\n!Assets/Font\n!Assets/LUT\n!Assets/Samplers\n"
  },
  {
    "path": "Assets/CornellBox/cornell.gltf",
    "chars": 16077,
    "preview": "{\n  \"accessors\": [\n    {\n      \"bufferView\": 0,\n      \"componentType\": 5126,\n      \"type\": \"VEC3\",\n      \"count\": 54,\n  "
  },
  {
    "path": "Assets/CornellBox/cornell_emissive.gltf",
    "chars": 16316,
    "preview": "{\n  \"accessors\": [\n    {\n      \"bufferView\": 0,\n      \"componentType\": 5126,\n      \"type\": \"VEC3\",\n      \"count\": 54,\n  "
  },
  {
    "path": "Assets/CornellBox/license.txt",
    "chars": 686,
    "preview": "Model Information:\n* title:\tCornell Box- Original\n* source:\thttps://sketchfab.com/3d-models/cornell-box-original-0d18de8"
  },
  {
    "path": "Assets/Font/Font.h",
    "chars": 287,
    "preview": "#pragma once\n\n#if defined(__cplusplus)\nextern \"C\" {\n#endif\n\nstruct FontSpan\n{\n    const void* Data;\n    size_t N;\n};\n\nen"
  },
  {
    "path": "Assets/Font/IconsFontAwesome6.h",
    "chars": 73834,
    "preview": "// Generated by https://github.com/juliettef/IconFontCppHeaders script GenerateIconFontCppHeaders.py for languages C and"
  },
  {
    "path": "Assets/Font/LICENSE-bfont.ttf.txt",
    "chars": 4947,
    "preview": "Fonts are (c) Bitstream (see below). DejaVu changes are in public domain. Glyphs imported from Arev fonts are (c) Tavmju"
  },
  {
    "path": "Assets/LUT/LICENSE-MIT",
    "chars": 1061,
    "preview": "Copyright (c) 2023 Tomasz Stachowiak\n\nPermission is hereby granted, free of charge, to any\nperson obtaining a copy of th"
  },
  {
    "path": "CMake/CompileHLSL.cmake",
    "chars": 5475,
    "preview": "# Returns a list of included paths (if any)\nfunction(ParseIncludes DATA DIR RET)\n    string(REGEX MATCHALL \"#include[ \\t"
  },
  {
    "path": "CMake/Copy.cmake",
    "chars": 656,
    "preview": "function(Copy FILES DEST TARGET_NAME)\n    foreach(FULL_FILENAME ${FILES})\n        get_filename_component(FILE ${FULL_FIL"
  },
  {
    "path": "CMake/SetBuildConfigurations.cmake",
    "chars": 170,
    "preview": "get_property(isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)\nif(isMultiConfig)\n    set(CMAKE_CONFIGURATION_TYPE"
  },
  {
    "path": "CMake/SetupAgilitySDK.cmake",
    "chars": 1417,
    "preview": "function(SetupAgilitySDK SDK_VERSION)\n    set(VER \"1.615.0\")\n    set(SDK_DIR \"${EXTERNAL_DIR}/D3D12/${VER}\")\n\n    file(G"
  },
  {
    "path": "CMake/SetupDXC.cmake",
    "chars": 1121,
    "preview": "function(SetupDXC DXC_BIN_DIR)\n    set(DXC_DIR \"${TOOLS_DIR}/dxc\")\n    file(GLOB_RECURSE DXC_BIN_PATH \"${DXC_DIR}/*dxc.e"
  },
  {
    "path": "CMake/SetupDoctest.cmake",
    "chars": 465,
    "preview": "function(SetupDoctest)\n    set(DOCTEST_DIR \"${EXTERNAL_DIR}/doctest\")\n    file(GLOB_RECURSE HEADER_PATH \"${DOCTEST_DIR}/"
  },
  {
    "path": "CMake/SetupImGui.cmake",
    "chars": 3416,
    "preview": "function(SetupImGui)\n    set(IMGUI_VER \"1.91.6\")\n    set(IMPLOT_COMMIT \"47522f47054d33178e7defa780042bd2a06b09f9\")\n    s"
  },
  {
    "path": "CMake/SetupWinPIX.cmake",
    "chars": 1204,
    "preview": "function(SetupWinPIX)\n    set(PIX_DIR \"${EXTERNAL_DIR}/WinPixEventRuntime\")\n    file(GLOB_RECURSE DLL_PATH \"${PIX_DIR}/*"
  },
  {
    "path": "CMake/Setupcgltf.cmake",
    "chars": 1070,
    "preview": "function(Setupcgltf)\n    set(CGLTF_DIR \"${EXTERNAL_DIR}/cgltf\")\n    file(GLOB_RECURSE HEADER_PATH \"${CGLTF_DIR}/cgltf.h\""
  },
  {
    "path": "CMake/SetupxxHash.cmake",
    "chars": 936,
    "preview": "function(SetupxxHash)\n    set(XXHASH_DIR \"${EXTERNAL_DIR}/xxHash\")\n    file(GLOB_RECURSE HEADER_PATH \"${XXHASH_DIR}/xxHa"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 4908,
    "preview": "cmake_minimum_required(VERSION 3.21)\n\n# Enable building custom commands by Visual Studio in parallel. Introduced in CMak"
  },
  {
    "path": "External/FSR2/Include/dx12/shaders/ffx_fsr2_shaders_dx12.h",
    "chars": 3411,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FSR2/Include/ffx_assert.h",
    "chars": 5013,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FSR2/Include/ffx_error.h",
    "chars": 4094,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FSR2/Include/ffx_fsr2.h",
    "chars": 26952,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FSR2/Include/ffx_fsr2_interface.h",
    "chars": 19314,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FSR2/Include/ffx_types.h",
    "chars": 20255,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FSR2/Include/ffx_util.h",
    "chars": 3224,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FSR2/Include/shaders/ffx_fsr2_common.h",
    "chars": 18791,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FSR2/Include/shaders/ffx_fsr2_resources.h",
    "chars": 7884,
    "preview": "// This file is part of the FidelityFX SDK.\n//\n// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserv"
  },
  {
    "path": "External/FastDelegate/FastDelegate.h",
    "chars": 97393,
    "preview": "//\t\t\t\t\t\tFastDelegate.h \n//\tEfficient delegates in C++ that generate only two lines of asm code!\n//  Documentation is fou"
  },
  {
    "path": "External/FastDelegate/FastDelegateBind.h",
    "chars": 8443,
    "preview": "//\t\t\t\t\t\tFastDelegateBind.h \n//  Helper file for FastDelegates. Provides bind() function, enabling\n//  FastDelegates to b"
  },
  {
    "path": "External/ImGui/ImGuizmo.cpp",
    "chars": 89578,
    "preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v1.91.3 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric "
  },
  {
    "path": "External/ImGui/ImGuizmo.h",
    "chars": 12999,
    "preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v1.91.3 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric "
  },
  {
    "path": "External/ImGui/imconfig.h",
    "chars": 11691,
    "preview": "//-----------------------------------------------------------------------------\n// DEAR IMGUI COMPILE-TIME OPTIONS\n// Ru"
  },
  {
    "path": "External/concurrentqueue/blockingconcurrentqueue.h",
    "chars": 21515,
    "preview": "// Provides an efficient blocking version of moodycamel::ConcurrentQueue.\n// ©2015-2020 Cameron Desrochers. Distributed "
  },
  {
    "path": "External/concurrentqueue/concurrentqueue.h",
    "chars": 152838,
    "preview": "// Provides a C++11 implementation of a multi-producer, multi-consumer lock-free queue.\n// An overview, including benchm"
  },
  {
    "path": "External/concurrentqueue/lightweightsemaphore.h",
    "chars": 11756,
    "preview": "// Provides an efficient implementation of a semaphore (LightweightSemaphore).\n// This is an extension of Jeff Preshing'"
  },
  {
    "path": "External/stb/stb_image.h",
    "chars": 284762,
    "preview": "/* stb_image - v2.28 - public domain image loader - http://nothings.org/stb\n                                  no warrant"
  },
  {
    "path": "External/stb/stb_image_write.h",
    "chars": 71221,
    "preview": "/* stb_image_write - v1.16 - public domain - http://nothings.org/stb\n   writes out PNG/BMP/TGA/JPEG/HDR images to C stdi"
  },
  {
    "path": "External/stb/stb_sprintf.h",
    "chars": 57354,
    "preview": "// stb_sprintf - v1.09 - public domain snprintf() implementation\n// originally by Jeff Roberts / RAD Game Tools, 2015/10"
  },
  {
    "path": "LICENSE",
    "chars": 1076,
    "preview": "MIT License\n\nCopyright (c) 2023-2024 Ali Behnoudfar\n\nPermission is hereby granted, free of charge, to any person obtaini"
  },
  {
    "path": "README.md",
    "chars": 10062,
    "preview": "# ZetaRay\n\n[![MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)\n[![build-and"
  },
  {
    "path": "Source/CMakeLists.txt",
    "chars": 116,
    "preview": "add_subdirectory(ZetaCore)\nadd_subdirectory(ZetaRenderPass)\nadd_subdirectory(ZetaRenderer)\nadd_subdirectory(ZetaLab)"
  },
  {
    "path": "Source/ZetaCore/App/App.h",
    "chars": 5950,
    "preview": "#pragma once\n\n#include \"../Support/Memory.h\"\n#ifndef NDEBUG\n#include \"../Utility/Error.h\"\n#endif\n#include \"FastDelegate/"
  },
  {
    "path": "Source/ZetaCore/App/CMakeLists.txt",
    "chars": 260,
    "preview": "set(APP_DIR \"${ZETA_CORE_DIR}/App\")\nset(APP_SRC\n\t\"${APP_DIR}/ZetaRay.h\"\n    \"${APP_DIR}/App.h\"\n    \"${APP_DIR}/Filesyste"
  },
  {
    "path": "Source/ZetaCore/App/Common.h",
    "chars": 589,
    "preview": "#pragma once\n\n#include \"../Utility/Span.h\"\n\nnamespace ZetaRay::App::Common\n{\n    namespace CPU_Intrinsic\n    {\n        c"
  },
  {
    "path": "Source/ZetaCore/App/Filesystem.h",
    "chars": 901,
    "preview": "#pragma once\n\n#include \"../Utility/Span.h\"\n#include \"../Support/MemoryArena.h\"\n\nnamespace ZetaRay::App::Filesystem\n{\n   "
  },
  {
    "path": "Source/ZetaCore/App/Log.h",
    "chars": 918,
    "preview": "#pragma once\n\n#include \"App.h\"\n#include \"../Utility/Error.h\"\n\n#ifndef NDEBUG\n#define LOG_CONSOLE(formatStr, ...)        "
  },
  {
    "path": "Source/ZetaCore/App/Path.h",
    "chars": 6619,
    "preview": "#include \"../App/Filesystem.h\"\n\nnamespace ZetaRay::App::Filesystem\n{\n    template<Support::AllocatorType Allocator, uint"
  },
  {
    "path": "Source/ZetaCore/App/Timer.h",
    "chars": 2543,
    "preview": "#pragma once\n\n#include \"../Utility/Error.h\"\n\nnamespace ZetaRay::App\n{\n    struct Timer\n    {\n        Timer();\n        ~T"
  },
  {
    "path": "Source/ZetaCore/App/ZetaRay.h",
    "chars": 508,
    "preview": "#pragma once\n\n#define _HAS_EXCEPTIONS 0\n\n#include <cstdint>\n\n// Ref: https://www.foonathan.net/2020/09/move-forward/\n#de"
  },
  {
    "path": "Source/ZetaCore/CMakeLists.txt",
    "chars": 3177,
    "preview": "include(\"${CMAKE_INCLUDE_DIR}/Copy.cmake\")\ninclude(\"${CMAKE_INCLUDE_DIR}/SetupAgilitySDK.cmake\")\ninclude(\"${CMAKE_INCLUD"
  },
  {
    "path": "Source/ZetaCore/Core/CMakeLists.txt",
    "chars": 1054,
    "preview": "set(CORE_DIR \"${ZETA_CORE_DIR}/Core\")\nset(CORE_SRC\n    \"${CORE_DIR}/CommandList.cpp\"\n    \"${CORE_DIR}/CommandList.h\"\n   "
  },
  {
    "path": "Source/ZetaCore/Core/CommandList.cpp",
    "chars": 1579,
    "preview": "#include \"CommandList.h\"\n#include \"RendererCore.h\"\n\nusing namespace ZetaRay::Core;\n\n//----------------------------------"
  },
  {
    "path": "Source/ZetaCore/Core/CommandList.h",
    "chars": 18111,
    "preview": "#pragma once\n\n#include \"Direct3DUtil.h\"\n#include \"RootSignature.h\"\n#include \"../Utility/Error.h\"\n#define USE_PIX\n#includ"
  },
  {
    "path": "Source/ZetaCore/Core/CommandQueue.cpp",
    "chars": 4825,
    "preview": "#include \"CommandQueue.h\"\n#include \"RendererCore.h\"\n#include \"CommandList.h\"\n\nusing namespace ZetaRay;\nusing namespace Z"
  },
  {
    "path": "Source/ZetaCore/Core/CommandQueue.h",
    "chars": 2226,
    "preview": "#pragma once\n\n#include \"../Core/Device.h\"\n#include \"../Utility/SmallVector.h\"\n#include \"../App/App.h\"\n#include <shared_m"
  },
  {
    "path": "Source/ZetaCore/Core/Config.h",
    "chars": 2513,
    "preview": "#pragma once\n\n#include \"Device.h\"\n\nnamespace ZetaRay::Core::Constants\n{\n    static constexpr int NUM_BACK_BUFFERS = 3;\n "
  },
  {
    "path": "Source/ZetaCore/Core/DescriptorHeap.cpp",
    "chars": 10492,
    "preview": "#include \"DescriptorHeap.h\"\n#include \"RendererCore.h\"\n#include \"../Utility/Error.h\"\n\nusing namespace ZetaRay;\nusing name"
  },
  {
    "path": "Source/ZetaCore/Core/DescriptorHeap.h",
    "chars": 5697,
    "preview": "#pragma once\n\n#include \"../Utility/SmallVector.h\"\n#include \"Device.h\"\n\nnamespace ZetaRay::Core\n{\n    struct DescriptorTa"
  },
  {
    "path": "Source/ZetaCore/Core/Device.cpp",
    "chars": 6844,
    "preview": "#include \"Device.h\"\n#include \"Config.h\"\n#include \"../App/Common.h\"\n\n// PIX crashes & NSight doesn't work when the debug "
  },
  {
    "path": "Source/ZetaCore/Core/Device.h",
    "chars": 5185,
    "preview": "#pragma once\n\n#include \"../App/ZetaRay.h\"\n#include \"../Win32/Win32.h\"\n#include <D3D12/1.615.0/d3d12.h>\n#include <D3D12/1"
  },
  {
    "path": "Source/ZetaCore/Core/Direct3DUtil.cpp",
    "chars": 42967,
    "preview": "#include \"Direct3DUtil.h\"\n#include \"dds.h\"\n#include \"RendererCore.h\"\n#include \"../Support/MemoryArena.h\"\n#include <xxHas"
  },
  {
    "path": "Source/ZetaCore/Core/Direct3DUtil.h",
    "chars": 23446,
    "preview": "// Ref: Some of the following functions are from DirectXTK12 (MIT License):\n// https://github.com/microsoft/DirectXTK12\n"
  },
  {
    "path": "Source/ZetaCore/Core/GpuMemory.cpp",
    "chars": 55509,
    "preview": "#include \"../App/Timer.h\"\n#include \"RendererCore.h\"\n#include \"CommandList.h\"\n#include \"../Support/Task.h\"\n#include \"../A"
  },
  {
    "path": "Source/ZetaCore/Core/GpuMemory.h",
    "chars": 14481,
    "preview": "#pragma once\n\n#include \"Direct3DUtil.h\"\n#include \"../Utility/Span.h\"\n#include \"../Support/OffsetAllocator.h\"\n\nnamespace "
  },
  {
    "path": "Source/ZetaCore/Core/GpuTimer.cpp",
    "chars": 6752,
    "preview": "#include \"RendererCore.h\"\n#include \"CommandList.h\"\n#include \"../App/Timer.h\"\n\nusing namespace ZetaRay;\nusing namespace Z"
  },
  {
    "path": "Source/ZetaCore/Core/GpuTimer.h",
    "chars": 1823,
    "preview": "#pragma once\n\n#include <Core/Config.h>\n#include \"GpuMemory.h\"\n#include <atomic>\n\nnamespace ZetaRay::Core\n{\n    class Com"
  },
  {
    "path": "Source/ZetaCore/Core/HLSLCompat.h",
    "chars": 1670,
    "preview": "#ifndef HLSL_COMPAT\n#define HLSL_COMPAT\n\n#ifdef __cplusplus\n    #include <cstdint>\n    #include \"../Math/Matrix.h\"\n\n    "
  },
  {
    "path": "Source/ZetaCore/Core/Material.h",
    "chars": 14062,
    "preview": "#ifndef MATERIAL_H\n#define MATERIAL_H\n\n#include \"HLSLCompat.h\"\n\n// Metallic is treated as a binary parameter - everythin"
  },
  {
    "path": "Source/ZetaCore/Core/PipelineStateLibrary.cpp",
    "chars": 15216,
    "preview": "#include \"PipelineStateLibrary.h\"\n#include \"RendererCore.h\"\n#include \"../App/Log.h\"\n#include <App/Common.h>\n#include <Ap"
  },
  {
    "path": "Source/ZetaCore/Core/PipelineStateLibrary.h",
    "chars": 1894,
    "preview": "#pragma once\n\n#include \"../Core/Device.h\"\n#include \"../App/Path.h\"\n#include <atomic>\n\nnamespace ZetaRay::Core\n{\n    clas"
  },
  {
    "path": "Source/ZetaCore/Core/RenderGraph.cpp",
    "chars": 47285,
    "preview": "// Some of the ideas in this implementation were inspired by the following: \n// https://levelup.gitconnected.com/organiz"
  },
  {
    "path": "Source/ZetaCore/Core/RenderGraph.h",
    "chars": 11793,
    "preview": "#pragma once\n\n#include \"Direct3DUtil.h\"\n#include \"../Utility/Span.h\"\n#include <FastDelegate/FastDelegate.h>\n#include <at"
  },
  {
    "path": "Source/ZetaCore/Core/RendererCore.cpp",
    "chars": 21466,
    "preview": "#include \"RendererCore.h\"\n#include \"CommandList.h\"\n#include \"Direct3DUtil.h\"\n#include \"../Support/Task.h\"\n#include \"../S"
  },
  {
    "path": "Source/ZetaCore/Core/RendererCore.h",
    "chars": 7170,
    "preview": "#pragma once\n\n#include \"Config.h\"\n#include \"DescriptorHeap.h\"\n#include \"GpuTimer.h\"\n#include \"CommandQueue.h\"\n#include \""
  },
  {
    "path": "Source/ZetaCore/Core/RootSignature.cpp",
    "chars": 14580,
    "preview": "#include \"RootSignature.h\"\n#include \"RendererCore.h\"\n#include \"CommandList.h\"\n#include \"SharedShaderResources.h\"\n#includ"
  },
  {
    "path": "Source/ZetaCore/Core/RootSignature.h",
    "chars": 5688,
    "preview": "#pragma once\n\n#include \"Device.h\"\n\nnamespace ZetaRay::Util\n{\n    template<typename T>\n    struct Span;\n}\n\nnamespace Zeta"
  },
  {
    "path": "Source/ZetaCore/Core/SharedShaderResources.cpp",
    "chars": 3379,
    "preview": "#include \"SharedShaderResources.h\"\n#include <xxHash/xxhash.h>\n\nusing namespace ZetaRay;\nusing namespace ZetaRay::Core;\nu"
  },
  {
    "path": "Source/ZetaCore/Core/SharedShaderResources.h",
    "chars": 2328,
    "preview": "#pragma once\n\n#include \"../Utility/HashTable.h\"\n#include <shared_mutex>\n\nnamespace ZetaRay::Core::GpuMemory\n{\n    struct"
  },
  {
    "path": "Source/ZetaCore/Core/Vertex.h",
    "chars": 243,
    "preview": "#pragma once\n\n#include \"../Math/OctahedralVector.h\"\n\nnamespace ZetaRay::Core\n{\n    // 28 bytes\n    struct Vertex\n    {\n "
  },
  {
    "path": "Source/ZetaCore/Core/dds.h",
    "chars": 10500,
    "preview": "//--------------------------------------------------------------------------------------\n// dds.h\n//\n// This header defi"
  },
  {
    "path": "Source/ZetaCore/Math/BVH.cpp",
    "chars": 20762,
    "preview": "#include \"BVH.h\"\n#include \"../Math/CollisionFuncs.h\"\n#include \"../Utility/Error.h\"\n#include \"../App/Log.h\"\n#include \"../"
  },
  {
    "path": "Source/ZetaCore/Math/BVH.h",
    "chars": 4046,
    "preview": "// References:\n// 1. M. Pharr, W. Jakob, and G. Humphreys, Physically Based Rendering: From theory to implementation, Mo"
  },
  {
    "path": "Source/ZetaCore/Math/CMakeLists.txt",
    "chars": 624,
    "preview": "set(MATH_DIR \"${ZETA_CORE_DIR}/Math\")\nset(MATH_SRC\n    \"${MATH_DIR}/BVH.cpp\"\n    \"${MATH_DIR}/BVH.h\"\n    \"${MATH_DIR}/Co"
  },
  {
    "path": "Source/ZetaCore/Math/CollisionFuncs.h",
    "chars": 22057,
    "preview": "#pragma once\n\n#include \"CollisionTypes.h\"\n#include \"VectorFuncs.h\"\n#include \"MatrixFuncs.h\"\n\nnamespace ZetaRay::Math\n{\n "
  },
  {
    "path": "Source/ZetaCore/Math/CollisionTypes.h",
    "chars": 9695,
    "preview": "#pragma once\n\n#include \"Vector.h\"\n#ifndef NDEBUG\n#include <type_traits>\n#endif\n\nnamespace ZetaRay::Math\n{\n    enum class"
  },
  {
    "path": "Source/ZetaCore/Math/Color.cpp",
    "chars": 1570,
    "preview": "#include \"Color.h\"\n#include \"Color.h\"\n#include \"Common.h\"\n\nusing namespace ZetaRay;\nusing namespace ZetaRay::Math;\nusing"
  },
  {
    "path": "Source/ZetaCore/Math/Color.h",
    "chars": 2329,
    "preview": "#pragma once\n\n#include \"VectorFuncs.h\"\n\nnamespace ZetaRay::Math\n{\n    ZetaInline uint16_t __vectorcall Float2ToRG8(Math:"
  },
  {
    "path": "Source/ZetaCore/Math/Common.cpp",
    "chars": 4265,
    "preview": "#include \"Vector.h\"\n#include \"../Utility/Span.h\"\n\nusing namespace ZetaRay;\nusing namespace ZetaRay::Math;\nusing namespac"
  },
  {
    "path": "Source/ZetaCore/Math/Common.h",
    "chars": 4730,
    "preview": "#pragma once\n\n#include \"../Utility/Error.h\"\n#include <float.h>\n#include <string.h>\n#include <immintrin.h>    // AVX intr"
  },
  {
    "path": "Source/ZetaCore/Math/Matrix.h",
    "chars": 4760,
    "preview": "#pragma once\n\n#include \"Vector.h\"\n#include <math.h>\n\nnamespace ZetaRay::Math\n{\n    struct float4x4a;\n    struct float3x3"
  },
  {
    "path": "Source/ZetaCore/Math/MatrixFuncs.h",
    "chars": 33983,
    "preview": "#pragma once\n\n#include \"Matrix.h\"\n#include \"VectorFuncs.h\"\n\n//----------------------------------------------------------"
  },
  {
    "path": "Source/ZetaCore/Math/OctahedralVector.h",
    "chars": 961,
    "preview": "#pragma once\n\n#include \"VectorFuncs.h\"\n\nnamespace ZetaRay::Math\n{\n    // 3D unit vector encoded using octahedral encodin"
  },
  {
    "path": "Source/ZetaCore/Math/Quaternion.h",
    "chars": 5418,
    "preview": "#pragma once\n\n#include \"VectorFuncs.h\"\n#include \"Matrix.h\"\n\nnamespace ZetaRay::Math\n{\n    // Returns a roations quaterni"
  },
  {
    "path": "Source/ZetaCore/Math/Sampling.cpp",
    "chars": 4702,
    "preview": "#include \"Sampling.h\"\n#include <Utility/RNG.h>\n#include <cmath>\n\nusing namespace ZetaRay;\nusing namespace ZetaRay::Util;"
  },
  {
    "path": "Source/ZetaCore/Math/Sampling.h",
    "chars": 997,
    "preview": "#pragma once\n\n#include <Utility/Span.h>\n#include <Math/Vector.h>\n\nnamespace ZetaRay::Util\n{\n    struct RNG;\n}\n\nnamespace"
  },
  {
    "path": "Source/ZetaCore/Math/Surface.cpp",
    "chars": 3373,
    "preview": "#include \"Surface.h\"\n#include \"../App/Log.h\"\n#include <Math/VectorFuncs.h>\n\nusing namespace ZetaRay::Core;\nusing namespa"
  },
  {
    "path": "Source/ZetaCore/Math/Surface.h",
    "chars": 4473,
    "preview": "#pragma once\n\n#include \"Common.h\"\n#include \"../Core/Vertex.h\"\n#include \"../Utility/Span.h\"\n\nnamespace ZetaRay::Math\n{\n  "
  },
  {
    "path": "Source/ZetaCore/Math/Vector.h",
    "chars": 26404,
    "preview": "#pragma once\n\n#include \"Common.h\"\n\n#define V_SHUFFLE_XYZW(fp0, fp1, fp2, fp3) (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2"
  },
  {
    "path": "Source/ZetaCore/Math/VectorFuncs.h",
    "chars": 11871,
    "preview": "#pragma once\n\n#include \"Vector.h\"\n\n//-----------------------------------------------------------------------------------"
  },
  {
    "path": "Source/ZetaCore/Model/CMakeLists.txt",
    "chars": 234,
    "preview": "set(MODEL_DIR \"${ZETA_CORE_DIR}/Model\")\nset(MODEL_SRC\n    \"${MODEL_DIR}/glTF.cpp\"\n    \"${MODEL_DIR}/glTF.h\"\n    \"${MODEL"
  },
  {
    "path": "Source/ZetaCore/Model/Mesh.cpp",
    "chars": 28907,
    "preview": "#include \"Mesh.h\"\n#include \"../Math/Surface.h\"\n#include \"../Math/MatrixFuncs.h\"\n\nusing namespace ZetaRay;\nusing namespac"
  },
  {
    "path": "Source/ZetaCore/Model/Mesh.h",
    "chars": 3128,
    "preview": "#pragma once\n\n#include \"../Math/CollisionFuncs.h\"\n#include \"../Core/Vertex.h\"\n#include \"../Utility/Span.h\"\n\nnamespace Ze"
  },
  {
    "path": "Source/ZetaCore/Model/glTF.cpp",
    "chars": 51063,
    "preview": "#include \"glTF.h\"\n#include \"../Math/MatrixFuncs.h\"\n#include \"../Math/Surface.h\"\n#include \"../Math/Quaternion.h\"\n#include"
  },
  {
    "path": "Source/ZetaCore/Model/glTF.h",
    "chars": 121,
    "preview": "#pragma once\n\n#include \"../App/Path.h\"\n\nnamespace ZetaRay::Model::glTF\n{\n    void Load(const App::Filesystem::Path& p);\n"
  },
  {
    "path": "Source/ZetaCore/Model/glTFAsset.h",
    "chars": 2434,
    "preview": "#pragma once\n\n#include \"../Core/Vertex.h\"\n#include \"../Core/GpuMemory.h\"\n#include \"../Math/Matrix.h\"\n#include \"../App/Fi"
  },
  {
    "path": "Source/ZetaCore/RayTracing/CMakeLists.txt",
    "chars": 201,
    "preview": "set(RT_DIR \"${ZETA_CORE_DIR}/RayTracing\")\nset(RT_SRC\n    \"${RT_DIR}/RtAccelerationStructure.cpp\"\n    \"${RT_DIR}/RtAccele"
  },
  {
    "path": "Source/ZetaCore/RayTracing/RtAccelerationStructure.cpp",
    "chars": 67987,
    "preview": "#include \"RtAccelerationStructure.h\"\n#include \"../Core/RendererCore.h\"\n#include \"../Core/CommandList.h\"\n#include \"../Sce"
  },
  {
    "path": "Source/ZetaCore/RayTracing/RtAccelerationStructure.h",
    "chars": 4511,
    "preview": "#pragma once\n\n#include \"../Core/GpuMemory.h\"\n#include \"RtCommon.h\"\n#include \"../Scene/SceneCommon.h\"\n#include \"../Suppor"
  },
  {
    "path": "Source/ZetaCore/RayTracing/RtCommon.h",
    "chars": 12158,
    "preview": "#ifndef RTCOMMON_H\n#define RTCOMMON_H\n\n#include \"../Core/Material.h\"\n\n#ifdef __cplusplus\n#include \"../Math/VectorFuncs.h"
  },
  {
    "path": "Source/ZetaCore/Scene/Asset.cpp",
    "chars": 14573,
    "preview": "#include \"Asset.h\"\n#include \"../Core/RendererCore.h\"\n#include \"../Core/SharedShaderResources.h\"\n#include \"SceneCore.h\"\n#"
  },
  {
    "path": "Source/ZetaCore/Scene/Asset.h",
    "chars": 8310,
    "preview": "#pragma once\n\n#include \"../Utility/HashTable.h\"\n#include \"../Core/DescriptorHeap.h\"\n#include \"../Model/glTFAsset.h\"\n#inc"
  },
  {
    "path": "Source/ZetaCore/Scene/CMakeLists.txt",
    "chars": 342,
    "preview": "set(SCENE_DIR \"${ZETA_CORE_DIR}/Scene\")\nset(SCENE_SRC\n    \"${SCENE_DIR}/Asset.cpp\"\n    \"${SCENE_DIR}/Asset.h\"\n    \"${SCE"
  },
  {
    "path": "Source/ZetaCore/Scene/Camera.cpp",
    "chars": 11630,
    "preview": "#include \"Camera.h\"\n#include \"../App/Timer.h\"\n#include \"../Core/RendererCore.h\"\n#include \"../Math/CollisionFuncs.h\"\n#inc"
  },
  {
    "path": "Source/ZetaCore/Scene/Camera.h",
    "chars": 5083,
    "preview": "#pragma once\n\n#include \"../Math/Matrix.h\"\n#include \"../Math/CollisionTypes.h\"\n\nnamespace ZetaRay::Support\n{\n    struct P"
  },
  {
    "path": "Source/ZetaCore/Scene/SceneCommon.h",
    "chars": 294,
    "preview": "#pragma once\n\n#include <App/ZetaRay.h>\n\nnamespace ZetaRay::Scene\n{\n    static constexpr uint64_t INVALID_INSTANCE = UINT"
  },
  {
    "path": "Source/ZetaCore/Scene/SceneCore.cpp",
    "chars": 39948,
    "preview": "#include \"SceneCore.h\"\n#include \"../Math/CollisionFuncs.h\"\n#include \"../Math/Quaternion.h\"\n#include \"../Support/Task.h\"\n"
  },
  {
    "path": "Source/ZetaCore/Scene/SceneCore.h",
    "chars": 15956,
    "preview": "#pragma once\n\n#include \"../Math/BVH.h\"\n#include \"Asset.h\"\n#include \"SceneRenderer.h\"\n#include \"SceneCommon.h\"\n#include \""
  },
  {
    "path": "Source/ZetaCore/Scene/SceneRenderer.h",
    "chars": 2670,
    "preview": "#pragma once\n\n#include \"../App/ZetaRay.h\"\n\nnamespace ZetaRay::Support\n{\n    struct TaskSet;\n}\n\nnamespace ZetaRay::Core\n{"
  },
  {
    "path": "Source/ZetaCore/Support/CMakeLists.txt",
    "chars": 608,
    "preview": "set(SUPPORT_DIR \"${ZETA_CORE_DIR}/Support\")\nset(SUPPORT_SRC\n    \"${SUPPORT_DIR}/FrameMemory.h\"\n    \"${SUPPORT_DIR}/Memor"
  },
  {
    "path": "Source/ZetaCore/Support/FrameMemory.h",
    "chars": 2132,
    "preview": "#pragma once\n\n#include \"../App/App.h\"\n#include <string.h>\n\nnamespace ZetaRay::Support\n{\n    template<size_t BlockSize>\n "
  },
  {
    "path": "Source/ZetaCore/Support/Memory.h",
    "chars": 771,
    "preview": "#pragma once\n\n#include \"../App/ZetaRay.h\"\n#include <malloc.h>\n#include <concepts>\n\nnamespace ZetaRay::Support\n{\n    temp"
  },
  {
    "path": "Source/ZetaCore/Support/MemoryArena.cpp",
    "chars": 2477,
    "preview": "#include \"MemoryArena.h\"\n\nusing namespace ZetaRay::Support;\nusing namespace ZetaRay::Math;\n\n//--------------------------"
  },
  {
    "path": "Source/ZetaCore/Support/MemoryArena.h",
    "chars": 2661,
    "preview": "#pragma once\n\n#include \"../Utility/SmallVector.h\"\n\nnamespace ZetaRay::Support\n{\n    class MemoryArena\n    {\n    public:\n"
  },
  {
    "path": "Source/ZetaCore/Support/MemoryPool.cpp",
    "chars": 10196,
    "preview": "#include \"MemoryPool.h\"\n#include \"../Utility/Error.h\"\n#include \"../Math/Common.h\"\n#include <intrin.h>\n#include <cstdio>\n"
  },
  {
    "path": "Source/ZetaCore/Support/MemoryPool.h",
    "chars": 4127,
    "preview": "#pragma once\n\n#include \"Memory.h\"\n\nnamespace ZetaRay::Support\n{\n    //    Pool-based memory allocator\n    //     - A col"
  },
  {
    "path": "Source/ZetaCore/Support/OffsetAllocator.cpp",
    "chars": 14256,
    "preview": "#include \"OffsetAllocator.h\"\n#include \"../Utility/Error.h\"\n#include \"../Math/Common.h\"\n#include <intrin.h>\n#include <con"
  },
  {
    "path": "Source/ZetaCore/Support/OffsetAllocator.h",
    "chars": 2949,
    "preview": "#pragma once\n\n#include \"../App/ZetaRay.h\"\n\nnamespace ZetaRay::Support\n{\n    // Ref: https://github.com/sebbbi/OffsetAllo"
  },
  {
    "path": "Source/ZetaCore/Support/Param.cpp",
    "chars": 8289,
    "preview": "#include \"Param.h\"\n#include <xxHash/xxhash.h>\n#include <string.h>\n\nusing namespace ZetaRay::Support;\nusing namespace Zet"
  },
  {
    "path": "Source/ZetaCore/Support/Param.h",
    "chars": 9133,
    "preview": "#pragma once\n\n#include \"../Math/Vector.h\"\n#include <type_traits>\n#include <FastDelegate/FastDelegate.h>\n\nnamespace ZetaR"
  },
  {
    "path": "Source/ZetaCore/Support/Stat.h",
    "chars": 3193,
    "preview": "#pragma once\n\n#include \"../Utility/Error.h\"\n#include \"../Math/Common.h\"\n\nnamespace ZetaRay::Support\n{\n    struct Stat\n  "
  },
  {
    "path": "Source/ZetaCore/Support/Task.cpp",
    "chars": 9752,
    "preview": "#include \"Task.h\"\n#include \"../App/Timer.h\"\n#include <intrin.h>\n\nusing namespace ZetaRay::Support;\nusing namespace ZetaR"
  },
  {
    "path": "Source/ZetaCore/Support/Task.h",
    "chars": 5002,
    "preview": "#pragma once\n\n#include \"../Utility/Span.h\"\n#include \"../Utility/Function.h\"\n#include \"../App/App.h\"\n#include <atomic>\n\nn"
  },
  {
    "path": "Source/ZetaCore/Support/ThreadPool.cpp",
    "chars": 6232,
    "preview": "#include \"ThreadPool.h\"\n#include \"../App/Log.h\"\n\nusing namespace ZetaRay::Support;\nusing namespace ZetaRay::App;\nusing n"
  },
  {
    "path": "Source/ZetaCore/Support/ThreadPool.h",
    "chars": 2271,
    "preview": "#pragma once\n\n#include \"Task.h\"\n#include \"concurrentqueue/blockingconcurrentqueue.h\"\n\nnamespace ZetaRay::Support\n{\n    c"
  },
  {
    "path": "Source/ZetaCore/Utility/CMakeLists.txt",
    "chars": 381,
    "preview": "set(UTIL_DIR \"${ZETA_CORE_DIR}/Utility\")\nset(UTIL_SRC\n    \"${UTIL_DIR}/Error.cpp\"\n    \"${UTIL_DIR}/Error.h\"\n    \"${UTIL_"
  },
  {
    "path": "Source/ZetaCore/Utility/Error.cpp",
    "chars": 7138,
    "preview": "#define STB_SPRINTF_IMPLEMENTATION\n\n#include \"Error.h\"\n#include \"Span.h\"\n#include \"../Win32/Win32.h\"\n#include \"../Suppor"
  },
  {
    "path": "Source/ZetaCore/Utility/Error.h",
    "chars": 4780,
    "preview": "#pragma once\n\n#include \"../App/ZetaRay.h\"\n#include <stb/stb_sprintf.h>\n\n//----------------------------------------------"
  },
  {
    "path": "Source/ZetaCore/Utility/Function.h",
    "chars": 2800,
    "preview": "#pragma once\n\n#include \"../App/ZetaRay.h\"\n\nnamespace ZetaRay::Util\n{\n    // Ref: https://stackoverflow.com/questions/186"
  },
  {
    "path": "Source/ZetaCore/Utility/HashTable.h",
    "chars": 15316,
    "preview": "#pragma once\n\n#include \"../Math/Common.h\"\n#include \"../Support/Memory.h\"\n#include \"../Utility/Optional.h\"\n\nnamespace Zet"
  },
  {
    "path": "Source/ZetaCore/Utility/Optional.h",
    "chars": 3926,
    "preview": "#pragma once\n\n#include <Utility/Error.h>\n#include <type_traits>\n\nnamespace ZetaRay::Util\n{\n    template<typename T>\n    "
  },
  {
    "path": "Source/ZetaCore/Utility/RNG.h",
    "chars": 3494,
    "preview": "#pragma once\n\n#include \"../Math/Vector.h\"\n#include <float.h>\n\nnamespace ZetaRay::Util\n{\n    // Following is based on: ht"
  },
  {
    "path": "Source/ZetaCore/Utility/SmallVector.h",
    "chars": 28732,
    "preview": "#pragma once\n\n#include \"../Math/Common.h\"\n#include \"../Support/Memory.h\"\n#include <utility>    // std::swap\n\nnamespace Z"
  },
  {
    "path": "Source/ZetaCore/Utility/Span.h",
    "chars": 4288,
    "preview": "#pragma once\n\n#include \"SmallVector.h\"\n\nnamespace ZetaRay::Util\n{\n    // Doesn't own the data -- just a pointer and a si"
  },
  {
    "path": "Source/ZetaCore/Utility/SynchronizedView.h",
    "chars": 2337,
    "preview": "#pragma once\n\n#include \"../Win32/Win32.h\"\n#include \"Span.h\"\n\nnamespace ZetaRay::Util\n{\n    template<typename T>\n    stru"
  },
  {
    "path": "Source/ZetaCore/Utility/Utility.h",
    "chars": 3020,
    "preview": "#pragma once\n\n#include \"Span.h\"\n\nnamespace ZetaRay::Util\n{\n    // Callable type Accessor that accepts type T and returns"
  },
  {
    "path": "Source/ZetaCore/Win32/CMakeLists.txt",
    "chars": 262,
    "preview": "set(WIN32_DIR \"${ZETA_CORE_DIR}/Win32\")\nset(WIN32_SRC\n    \"${WIN32_DIR}/Win32App.cpp\"\n    \"${WIN32_DIR}/Win32Filesystem."
  },
  {
    "path": "Source/ZetaCore/Win32/Win32.h",
    "chars": 334,
    "preview": "#pragma once\n\n#define NOMINMAX\n#define NODRAWTEXT\n//#define NOGDI\n#define NOBITMAP\n#define NOMCX\n#define NOSERVICE\n#defi"
  },
  {
    "path": "Source/ZetaCore/Win32/Win32App.cpp",
    "chars": 73195,
    "preview": "#include \"../App/Log.h\"\n#include \"../Support/FrameMemory.h\"\n#include \"../App/Timer.h\"\n#include \"../App/Common.h\"\n#includ"
  },
  {
    "path": "Source/ZetaCore/Win32/Win32Common.cpp",
    "chars": 1887,
    "preview": "#include \"../App/Common.h\"\n#include \"Win32.h\"\n#include <intrin.h>\n\nusing namespace ZetaRay;\nusing namespace ZetaRay::Uti"
  },
  {
    "path": "Source/ZetaCore/Win32/Win32Filesystem.cpp",
    "chars": 5506,
    "preview": "#include \"../App/Filesystem.h\"\n#include \"../Support/MemoryArena.h\"\n#include \"Win32.h\"\n\nusing namespace ZetaRay::Util;\nus"
  },
  {
    "path": "Source/ZetaCore/Win32/Win32Timer.cpp",
    "chars": 3607,
    "preview": "#include \"../App/Timer.h\"\n#include \"Win32.h\"\n\nusing namespace ZetaRay::App;\n\n//-----------------------------------------"
  },
  {
    "path": "Source/ZetaLab/CMakeLists.txt",
    "chars": 505,
    "preview": "add_executable(ZetaLab WIN32 \"${CMAKE_SOURCE_DIR}/Source/ZetaLab/ZetaLab.cpp\")\ntarget_link_libraries(ZetaLab ZetaCore Ze"
  },
  {
    "path": "Source/ZetaLab/ZetaLab.cpp",
    "chars": 1902,
    "preview": "//\n// Main.cpp\n//\n\n#define OPEN_CONSOLE 0\n\n#include <App/Log.h>\n#include <App/Timer.h>\n#include <Scene/SceneCore.h>\n#inc"
  },
  {
    "path": "Source/ZetaRenderPass/AutoExposure/AutoExposure.cpp",
    "chars": 7662,
    "preview": "#include \"AutoExposure.h\"\n#include <Core/CommandList.h>\n#include <Scene/SceneRenderer.h>\n#include <Support/Param.h>\n#inc"
  },
  {
    "path": "Source/ZetaRenderPass/AutoExposure/AutoExposure.h",
    "chars": 3008,
    "preview": "#pragma once\n\n#include \"../RenderPass.h\"\n#include <Core/GpuMemory.h>\n#include \"AutoExposure_Common.h\"\n\nnamespace ZetaRay"
  },
  {
    "path": "Source/ZetaRenderPass/AutoExposure/AutoExposure_Common.h",
    "chars": 458,
    "preview": "#ifndef AUTO_EXPOSURE_H\n#define AUTO_EXPOSURE_H\n\n#include \"../../ZetaCore/Core/HLSLCompat.h\"\n\n#define THREAD_GROUP_SIZE_"
  },
  {
    "path": "Source/ZetaRenderPass/AutoExposure/AutoExposure_Histogram.hlsl",
    "chars": 2798,
    "preview": "// Ref: https://alextardif.com/HistogramLuminance.html\n\n#include \"AutoExposure_Common.h\"\n#include \"../Common/Math.hlsli\""
  },
  {
    "path": "Source/ZetaRenderPass/AutoExposure/AutoExposure_WeightedAvg.hlsl",
    "chars": 4050,
    "preview": "#include \"AutoExposure_Common.h\"\n#include \"../Common/Math.hlsli\"\n#include \"../Common/FrameConstants.h\"\n#include \"../Comm"
  },
  {
    "path": "Source/ZetaRenderPass/AutoExposure/CMakeLists.txt",
    "chars": 403,
    "preview": "set(RP_AUTO_EXPOSURE_DIR ${ZETA_RENDER_PASS_DIR}/AutoExposure)\nset(RP_AUTO_EXPOSURE_SRC\n    ${RP_AUTO_EXPOSURE_DIR}/Auto"
  },
  {
    "path": "Source/ZetaRenderPass/CMakeLists.txt",
    "chars": 2117,
    "preview": "include(\"${CMAKE_INCLUDE_DIR}/CompileHLSL.cmake\")\n\nadd_subdirectory(AutoExposure)\nadd_subdirectory(Common)\nadd_subdirect"
  },
  {
    "path": "Source/ZetaRenderPass/Common/BSDF.hlsli",
    "chars": 46906,
    "preview": "// Refs:\n//\n// 1. M. Pharr, W. Jakob, and G. Humphreys, Physically Based Rendering: From theory to implementation, Morga"
  },
  {
    "path": "Source/ZetaRenderPass/Common/BSDFSampling.hlsli",
    "chars": 26993,
    "preview": "#ifndef BSDF_SAMPLING_H\n#define BSDF_SAMPLING_H\n\n#include \"BSDF.hlsli\"\n#include \"RT.hlsli\"\n\nnamespace BSDF\n{\n    //-----"
  },
  {
    "path": "Source/ZetaRenderPass/Common/CMakeLists.txt",
    "chars": 629,
    "preview": "set(RP_COMMON_DIR ${ZETA_RENDER_PASS_DIR}/Common)\nset(RP_COMMON_SRC\n    ${RP_COMMON_DIR}/BSDF.hlsli\n    ${RP_COMMON_DIR}"
  },
  {
    "path": "Source/ZetaRenderPass/Common/Common.hlsli",
    "chars": 7665,
    "preview": "#ifndef COMMON_H\n#define COMMON_H\n\n// 28 bytes\nstruct Vertex\n{\n    float3 PosL;\n    float2 TexUV;\n    uint16_t2 NormalL;"
  },
  {
    "path": "Source/ZetaRenderPass/Common/FrameConstants.h",
    "chars": 2986,
    "preview": "#ifndef FRAME_CONSTANTS\n#define FRAME_CONSTANTS\n\n#include \"../../ZetaCore/Core/HLSLCompat.h\"\n\n#ifdef __cplusplus\nnamespa"
  },
  {
    "path": "Source/ZetaRenderPass/Common/GBuffers.hlsli",
    "chars": 3091,
    "preview": "#ifndef GBUFFERS_H\n#define GBUFFERS_H\n\n#include \"../../ZetaCore/Core/Material.h\"\n\nenum GBUFFER_OFFSET\n{\n    BASE_COLOR ="
  },
  {
    "path": "Source/ZetaRenderPass/Common/LightSource.hlsli",
    "chars": 8833,
    "preview": "#ifndef LIGHT_SOURCE_H\n#define LIGHT_SOURCE_H\n\n#include \"FrameConstants.h\"\n#include \"StaticTextureSamplers.hlsli\"\n#inclu"
  },
  {
    "path": "Source/ZetaRenderPass/Common/LightVoxelGrid.hlsli",
    "chars": 2337,
    "preview": "#ifndef LVG_H\n#define LVG_H\n\n#include \"LightSource.hlsli\"\n\nnamespace LVG\n{\n    uint FlattenVoxelIndex(uint3 voxelIdx, ui"
  },
  {
    "path": "Source/ZetaRenderPass/Common/Math.hlsli",
    "chars": 22328,
    "preview": "#ifndef MATH_H\n#define MATH_H\n\n#define PI                   3.141592654f\n#define TWO_PI               6.283185307f\n#defi"
  },
  {
    "path": "Source/ZetaRenderPass/Common/RT.hlsli",
    "chars": 18991,
    "preview": "#ifndef RT_H\n#define RT_H\n\n#include \"../../ZetaCore/RayTracing/RtCommon.h\"\n#include \"Math.hlsli\"\n#include \"Sampling.hlsl"
  },
  {
    "path": "Source/ZetaRenderPass/Common/RayQuery.hlsli",
    "chars": 19617,
    "preview": "#ifndef RAY_QUERY_H\n#define RAY_QUERY_H\n\n#include \"RT.hlsli\"\n#include \"Common.hlsli\"\n#include \"FrameConstants.h\"\n#includ"
  },
  {
    "path": "Source/ZetaRenderPass/Common/SH.hlsli",
    "chars": 2034,
    "preview": "//--------------------------------------------------------------------------------------\n// Constants\n//----------------"
  },
  {
    "path": "Source/ZetaRenderPass/Common/Sampling.hlsli",
    "chars": 7633,
    "preview": "#ifndef SAMPLING_H\n#define SAMPLING_H\n\n#include \"Math.hlsli\"\n\n// Refs: \n// 1. https://www.reedbeta.com/blog/hash-functio"
  },
  {
    "path": "Source/ZetaRenderPass/Common/StaticTextureSamplers.hlsli",
    "chars": 461,
    "preview": "#ifndef SAMPLERS_H\n#define SAMPLERS_H\n\nSamplerState g_samMip0 : register(s0);\nSamplerState g_samPointWrap : register(s1)"
  },
  {
    "path": "Source/ZetaRenderPass/Common/Volumetric.hlsli",
    "chars": 8820,
    "preview": "#ifndef VOLUMETRIC_H\n#define VOLUMETRIC_H\n\n// Refs:\n// 1. M. Pharr and G. Humphreys, Physically Based Rendering: From th"
  },
  {
    "path": "Source/ZetaRenderPass/Compositing/CMakeLists.txt",
    "chars": 359,
    "preview": "set(RP_COMPOSITING_DIR ${ZETA_RENDER_PASS_DIR}/Compositing)\nset(RP_COMPOSITING_SRC\n    ${RP_COMPOSITING_DIR}/Compositing"
  },
  {
    "path": "Source/ZetaRenderPass/Compositing/Compositing.cpp",
    "chars": 6905,
    "preview": "#include \"Compositing.h\"\n#include <Core/CommandList.h>\n#include <Scene/SceneRenderer.h>\n#include <Scene/SceneCore.h>\n#in"
  },
  {
    "path": "Source/ZetaRenderPass/Compositing/Compositing.h",
    "chars": 3931,
    "preview": "#pragma once\n\n#include \"../RenderPass.h\"\n#include <Core/GpuMemory.h>\n#include \"Compositing_Common.h\"\n\nnamespace ZetaRay:"
  },
  {
    "path": "Source/ZetaRenderPass/Compositing/Compositing.hlsl",
    "chars": 5222,
    "preview": "#include \"Compositing_Common.h\"\n#include \"../Common/Common.hlsli\"\n#include \"../Common/GBuffers.hlsli\"\n#include \"../Commo"
  },
  {
    "path": "Source/ZetaRenderPass/Compositing/Compositing_Common.h",
    "chars": 931,
    "preview": "#ifndef COMPOSITING_H\n#define COMPOSITING_H\n\n#include \"../../ZetaCore/Core/HLSLCompat.h\"\n\n#define COMPOSITING_THREAD_GRO"
  },
  {
    "path": "Source/ZetaRenderPass/Compositing/FireflyFilter.hlsl",
    "chars": 4711,
    "preview": "#include \"Compositing_Common.h\"\n#include \"../Common/FrameConstants.h\"\n#include \"../Common/StaticTextureSamplers.hlsli\"\n#"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/CMakeLists.txt",
    "chars": 1007,
    "preview": "set(RP_SKY_DI_DIR ${ZETA_RENDER_PASS_DIR}/DirectLighting/Sky)\nset(RP_EMISSIVE_DI_DIR ${ZETA_RENDER_PASS_DIR}/DirectLight"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/DirectLighting.cpp",
    "chars": 16864,
    "preview": "#include \"DirectLighting.h\"\n#include <Core/CommandList.h>\n#include <Scene/SceneCore.h>\n#include <Support/Param.h>\n#inclu"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/DirectLighting.h",
    "chars": 4378,
    "preview": "#pragma once\n\n#include \"../../RenderPass.h\"\n#include <Core/GpuMemory.h>\n#include \"DirectLighting_Common.h\"\n\nnamespace Ze"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/DirectLighting_Common.h",
    "chars": 1009,
    "preview": "#ifndef DIRECT_LIGHTING_COMMON_H\n#define DIRECT_LIGHTING_COMMON_H\n\n#include \"../../../ZetaCore/RayTracing/RtCommon.h\"\n\n#"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/PairwiseMIS.hlsli",
    "chars": 10332,
    "preview": "#ifndef RESTIR_DI_PAIRWISE_MIS_H\n#define RESTIR_DI_PAIRWISE_MIS_H\n\n#include \"Util.hlsli\"\n\nnamespace RDI_Util\n{\n    // Re"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/Params.hlsli",
    "chars": 634,
    "preview": "#ifndef RESTIR_DI_PARAMS_H\n#define RESTIR_DI_PARAMS_H\n\n#define NUM_LIGHT_CANDIDATES 3\n#define EXTRA_BSDF_SAMPLE_HIGHLY_G"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/ReSTIR_DI_Spatial.hlsl",
    "chars": 7540,
    "preview": "#include \"Resampling.hlsli\"\n#include \"../../Common/Common.hlsli\"\n#include \"../../Common/BSDFSampling.hlsli\"\n\n#define THR"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/ReSTIR_DI_Temporal.hlsl",
    "chars": 15562,
    "preview": "#include \"Resampling.hlsli\"\n#include \"../../Common/Common.hlsli\"\n#include \"../../Common/BSDFSampling.hlsli\"\n\n#define THR"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/ReSTIR_DI_Temporal_WPS.hlsl",
    "chars": 62,
    "preview": "#define USE_PRESAMPLED_SETS\n#include \"ReSTIR_DI_Temporal.hlsl\""
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/Resampling.hlsli",
    "chars": 21878,
    "preview": "#ifndef RESTIR_DI_RESAMPLING_H\n#define RESTIR_DI_RESAMPLING_H\n\n#include \"Params.hlsli\"\n#include \"PairwiseMIS.hlsli\"\n#inc"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/Reservoir.hlsli",
    "chars": 6776,
    "preview": "#ifndef RESTIR_DI_RESERVOIR_H\n#define RESTIR_DI_RESERVOIR_H\n\n#include \"DirectLighting_Common.h\"\n#include \"../../Common/S"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Emissive/Util.hlsli",
    "chars": 3808,
    "preview": "#ifndef RESTIR_DI_UTIL_H\n#define RESTIR_DI_UTIL_H\n\n#include \"DirectLighting_Common.h\"\n#include \"Reservoir.hlsli\"\n#includ"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Sky/PairwiseMIS.hlsli",
    "chars": 6112,
    "preview": "#ifndef SKY_DI_PAIRWISE_MIS_H\n#define SKY_DI_PAIRWISE_MIS_H\n\n#include \"Reservoir.hlsli\"\n#include \"../../Common/RayQuery."
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Sky/Params.hlsli",
    "chars": 305,
    "preview": "#ifndef SKY_DI_PARAMS_H\n#define SKY_DI_PARAMS_H\n\n#define MAX_PLANE_DIST_REUSE 5e-1\n#define MIN_NORMAL_SIMILARITY_REUSE 0"
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Sky/Resampling.hlsli",
    "chars": 17271,
    "preview": "#ifndef SKY_DI_RESAMPLING_H\n#define SKY_DI_RESAMPLING_H\n\n#include \"Params.hlsli\"\n#include \"PairwiseMIS.hlsli\"\n#include \""
  },
  {
    "path": "Source/ZetaRenderPass/DirectLighting/Sky/Reservoir.hlsli",
    "chars": 5746,
    "preview": "#ifndef SKY_DI_RESERVOIR_H\n#define SKY_DI_RESERVOIR_H\n\n#include \"SkyDI_Common.h\"\n#include \"Util.hlsli\"\n\nnamespace SkyDI_"
  }
]

// ... and 158 more files (download for full content)