Repository: Chaf-Libraries/Ilum
Branch: main
Commit: 1d26a51ac02f
Files: 546
Total size: 5.4 MB

Directory structure:
gitextract_7jr9t7gk/

├── .clang-format
├── .clang-tidy
├── .github/
│   └── workflows/
│       ├── windows_dev.yml
│       └── windows_main.yml
├── .gitignore
├── .gitmodules
├── Asset/
│   ├── BuildIn/
│   │   ├── ImGui.spv.asset
│   │   ├── MaterialBall.asset
│   │   ├── animation.icon.asset
│   │   ├── equirectangular_to_cubemap.shader.asset
│   │   ├── mesh.preview.asset
│   │   ├── pipeline.icon.asset
│   │   ├── prefab.icon.asset
│   │   └── scene.icon.asset
│   ├── Meta/
│   │   └── README.md
│   ├── MustacheTemplate/
│   │   └── Reflection.mustache
│   ├── NRD_Data/
│   │   ├── NRD.rg
│   │   └── Sample/
│   │       ├── Texture2D_89.dds
│   │       ├── blur_buffer.csv
│   │       ├── gIn_Diff.dds
│   │       ├── gIn_Diff_History.dds
│   │       ├── gIn_Normal_Roughness.dds
│   │       ├── gIn_ObjectMotion.dds
│   │       ├── gIn_Prev_AccumSpeeds_MaterialID.dds
│   │       ├── gIn_Prev_Normal_Roughness.dds
│   │       ├── gIn_Prev_ViewZ.dds
│   │       ├── gIn_ViewZ.dds
│   │       ├── history_fix_buffer.csv
│   │       ├── post_blur_buffer.csv
│   │       └── temporal_accumulate_buffer.csv
│   └── SPD/
│       └── metals/
│           ├── Ag.eta.spd
│           ├── Ag.k.spd
│           ├── Al.eta.spd
│           ├── Al.k.spd
│           ├── AlAs.eta.spd
│           ├── AlAs.k.spd
│           ├── AlSb.eta.spd
│           ├── AlSb.k.spd
│           ├── Au.eta.spd
│           ├── Au.k.spd
│           ├── Be.eta.spd
│           ├── Be.k.spd
│           ├── Cr.eta.spd
│           ├── Cr.k.spd
│           ├── CsI.eta.spd
│           ├── CsI.k.spd
│           ├── Cu.eta.spd
│           ├── Cu.k.spd
│           ├── Cu2O.eta.spd
│           ├── Cu2O.k.spd
│           ├── CuO.eta.spd
│           ├── CuO.k.spd
│           ├── Hg.eta.spd
│           ├── Hg.k.spd
│           ├── HgTe.eta.spd
│           ├── HgTe.k.spd
│           ├── Ir.eta.spd
│           ├── Ir.k.spd
│           ├── K.eta.spd
│           ├── K.k.spd
│           ├── KBr.eta.spd
│           ├── KBr.k.spd
│           ├── KCl.eta.spd
│           ├── KCl.k.spd
│           ├── Li.eta.spd
│           ├── Li.k.spd
│           ├── MgO.eta.spd
│           ├── MgO.k.spd
│           ├── Mo.eta.spd
│           ├── Mo.k.spd
│           ├── NaCl.eta.spd
│           ├── NaCl.k.spd
│           ├── Nb.eta.spd
│           ├── Nb.k.spd
│           ├── Rh.eta.spd
│           ├── Rh.k.spd
│           ├── Se-e.eta.spd
│           ├── Se-e.k.spd
│           ├── Se.eta.spd
│           ├── Se.k.spd
│           ├── SiC.eta.spd
│           ├── SiC.k.spd
│           ├── SiO.eta.spd
│           ├── SiO.k.spd
│           ├── SnTe.eta.spd
│           ├── SnTe.k.spd
│           ├── Ta.eta.spd
│           ├── Ta.k.spd
│           ├── Te-e.eta.spd
│           ├── Te-e.k.spd
│           ├── Te.eta.spd
│           ├── Te.k.spd
│           ├── ThF4.eta.spd
│           ├── ThF4.k.spd
│           ├── TiC.eta.spd
│           ├── TiC.k.spd
│           ├── TiN.eta.spd
│           ├── TiN.k.spd
│           ├── TiO2-e.eta.spd
│           ├── TiO2-e.k.spd
│           ├── TiO2.eta.spd
│           ├── TiO2.k.spd
│           ├── VC.eta.spd
│           ├── VC.k.spd
│           ├── VN.eta.spd
│           ├── VN.k.spd
│           ├── W.eta.spd
│           ├── W.k.spd
│           ├── a-C.eta.spd
│           ├── a-C.k.spd
│           ├── a-SiH.eta.spd
│           ├── a-SiH.k.spd
│           ├── d-C.eta.spd
│           └── d-C.k.spd
├── Doc/
│   ├── Material.drawio
│   ├── RHI.drawio
│   ├── RenderGraph.drawio
│   ├── Resource.drawio
│   ├── Scene.drawio
│   └── Shader.drawio
├── LICENSE.txt
├── README.md
├── Source/
│   ├── Editor/
│   │   ├── Editor.cpp
│   │   ├── Editor.hpp
│   │   ├── ImGui/
│   │   │   ├── ImGuiContext.cpp
│   │   │   └── ImGuiContext.hpp
│   │   ├── Precompile.hpp
│   │   └── Widget.hpp
│   ├── Engine/
│   │   ├── Engine.cpp
│   │   ├── Engine.hpp
│   │   ├── Precompile.hpp
│   │   └── main.cpp
│   ├── External/
│   │   ├── dxc/
│   │   │   └── inc/
│   │   │       ├── d3d12shader.h
│   │   │       ├── dxcapi.h
│   │   │       ├── dxcerrors.h
│   │   │       └── dxcisense.h
│   │   ├── imgui_tools/
│   │   │   ├── IconsFontAwesome/
│   │   │   │   └── IconsFontAwesome5.h
│   │   │   ├── imgui_impl_glfw.cpp
│   │   │   ├── imgui_impl_glfw.h
│   │   │   ├── imguizmo/
│   │   │   │   ├── GraphEditor.cpp
│   │   │   │   ├── GraphEditor.h
│   │   │   │   ├── ImCurveEdit.cpp
│   │   │   │   ├── ImCurveEdit.h
│   │   │   │   ├── ImGradient.cpp
│   │   │   │   ├── ImGradient.h
│   │   │   │   ├── ImGuizmo.cpp
│   │   │   │   ├── ImGuizmo.h
│   │   │   │   ├── ImSequencer.cpp
│   │   │   │   ├── ImSequencer.h
│   │   │   │   └── ImZoomSlider.h
│   │   │   ├── imnodes/
│   │   │   │   ├── imnodes.cpp
│   │   │   │   ├── imnodes.h
│   │   │   │   └── imnodes_internal.h
│   │   │   ├── implot/
│   │   │   │   ├── implot.cpp
│   │   │   │   ├── implot.h
│   │   │   │   ├── implot_demo.cpp
│   │   │   │   ├── implot_internal.h
│   │   │   │   └── implot_items.cpp
│   │   │   └── xmake.lua
│   │   ├── mustache/
│   │   │   └── mustache.hpp
│   │   ├── slang/
│   │   │   ├── docs/
│   │   │   │   ├── 64bit-type-support.md
│   │   │   │   ├── README.md
│   │   │   │   ├── api-users-guide.md
│   │   │   │   ├── building.md
│   │   │   │   ├── command-line-slangc.md
│   │   │   │   ├── cpu-target.md
│   │   │   │   ├── cuda-target.md
│   │   │   │   ├── doc-system.md
│   │   │   │   ├── faq.md
│   │   │   │   ├── language-guide.md
│   │   │   │   ├── layout.md
│   │   │   │   ├── linking.md
│   │   │   │   ├── nvapi-support.md
│   │   │   │   ├── repro.md
│   │   │   │   ├── shader-playground.md
│   │   │   │   ├── stdlib-doc.md
│   │   │   │   ├── target-compatibility.md
│   │   │   │   └── wave-intrinsics.md
│   │   │   ├── prelude/
│   │   │   │   ├── slang-cpp-host-prelude.h
│   │   │   │   ├── slang-cpp-prelude.h
│   │   │   │   ├── slang-cpp-scalar-intrinsics.h
│   │   │   │   ├── slang-cpp-types.h
│   │   │   │   ├── slang-cuda-prelude.h
│   │   │   │   ├── slang-hlsl-prelude.h
│   │   │   │   └── slang-llvm.h
│   │   │   ├── slang-com-helper.h
│   │   │   ├── slang-com-ptr.h
│   │   │   ├── slang-gfx.h
│   │   │   ├── slang-tag-version.h
│   │   │   └── slang.h
│   │   └── xmake.lua
│   ├── Plugin/
│   │   ├── Editor/
│   │   │   ├── AnimationEditor.cpp
│   │   │   ├── Console.cpp
│   │   │   ├── Hierarchy.cpp
│   │   │   ├── Inspector.cpp
│   │   │   ├── MainMenu.cpp
│   │   │   ├── MaterialGraphEditor.cpp
│   │   │   ├── MeshEditor.cpp
│   │   │   ├── RenderGraphEditor.cpp
│   │   │   ├── ResourceBrowser.cpp
│   │   │   ├── SceneView.cpp
│   │   │   ├── ShaderToy.cpp
│   │   │   └── xmake.lua
│   │   ├── Geometry/
│   │   │   ├── Parameterization/
│   │   │   │   ├── MinimumSurface.cpp
│   │   │   │   └── Tutte.cpp
│   │   │   ├── Subdivision/
│   │   │   │   └── Loop.cpp
│   │   │   └── xmake.lua
│   │   ├── Importer/
│   │   │   ├── Assimp.cpp
│   │   │   ├── DDS.cpp
│   │   │   ├── STB.cpp
│   │   │   └── xmake.lua
│   │   ├── MaterialNode/
│   │   │   ├── BSDF/
│   │   │   │   ├── ConductorMaterial.cpp
│   │   │   │   ├── DielectricMaterial.cpp
│   │   │   │   ├── DiffuseMaterial.cpp
│   │   │   │   ├── DisneyMaterial.cpp
│   │   │   │   ├── MaskedMaterial.cpp
│   │   │   │   ├── MixMaterial.cpp
│   │   │   │   ├── PrincipledMaterial.cpp
│   │   │   │   ├── ThinDielectricMaterial.cpp
│   │   │   │   └── Utils/
│   │   │   │       └── SPDLoader.hpp
│   │   │   ├── Converter/
│   │   │   │   ├── Calculate.cpp
│   │   │   │   ├── SRGBToLinear.cpp
│   │   │   │   ├── VectorCalculate.cpp
│   │   │   │   ├── VectorMerge.cpp
│   │   │   │   └── VectorSplit.cpp
│   │   │   ├── IMaterialNode.hpp
│   │   │   ├── Input/
│   │   │   │   ├── RGB.cpp
│   │   │   │   └── SurfaceInteraction.cpp
│   │   │   ├── Output/
│   │   │   │   └── MaterialOutput.cpp
│   │   │   ├── Texture/
│   │   │   │   └── ImageTexture.cpp
│   │   │   └── xmake.lua
│   │   ├── RHI/
│   │   │   ├── CUDA/
│   │   │   │   ├── Buffer.cpp
│   │   │   │   ├── Buffer.hpp
│   │   │   │   ├── CUDA.cpp
│   │   │   │   ├── Command.cpp
│   │   │   │   ├── Command.hpp
│   │   │   │   ├── Descriptor.cpp
│   │   │   │   ├── Descriptor.hpp
│   │   │   │   ├── Device.cpp
│   │   │   │   ├── Device.hpp
│   │   │   │   ├── Frame.cpp
│   │   │   │   ├── Frame.hpp
│   │   │   │   ├── Fwd.hpp
│   │   │   │   ├── PipelineState.cpp
│   │   │   │   ├── PipelineState.hpp
│   │   │   │   ├── Profiler.cpp
│   │   │   │   ├── Profiler.hpp
│   │   │   │   ├── Queue.cpp
│   │   │   │   ├── Queue.hpp
│   │   │   │   ├── Sampler.cpp
│   │   │   │   ├── Sampler.hpp
│   │   │   │   ├── Shader.cpp
│   │   │   │   ├── Shader.hpp
│   │   │   │   ├── Synchronization.cpp
│   │   │   │   ├── Synchronization.hpp
│   │   │   │   ├── Texture.cpp
│   │   │   │   └── Texture.hpp
│   │   │   ├── Vulkan/
│   │   │   │   ├── AccelerationStructure.cpp
│   │   │   │   ├── AccelerationStructure.hpp
│   │   │   │   ├── Buffer.cpp
│   │   │   │   ├── Buffer.hpp
│   │   │   │   ├── Command.cpp
│   │   │   │   ├── Command.hpp
│   │   │   │   ├── Definitions.cpp
│   │   │   │   ├── Definitions.hpp
│   │   │   │   ├── Descriptor.cpp
│   │   │   │   ├── Descriptor.hpp
│   │   │   │   ├── Device.cpp
│   │   │   │   ├── Device.hpp
│   │   │   │   ├── Frame.cpp
│   │   │   │   ├── Frame.hpp
│   │   │   │   ├── Fwd.cpp
│   │   │   │   ├── Fwd.hpp
│   │   │   │   ├── PipelineState.cpp
│   │   │   │   ├── PipelineState.hpp
│   │   │   │   ├── Profiler.cpp
│   │   │   │   ├── Profiler.hpp
│   │   │   │   ├── Queue.cpp
│   │   │   │   ├── Queue.hpp
│   │   │   │   ├── RenderTarget.cpp
│   │   │   │   ├── RenderTarget.hpp
│   │   │   │   ├── Sampler.cpp
│   │   │   │   ├── Sampler.hpp
│   │   │   │   ├── Shader.cpp
│   │   │   │   ├── Shader.hpp
│   │   │   │   ├── Swapchain.cpp
│   │   │   │   ├── Swapchain.hpp
│   │   │   │   ├── Synchronization.cpp
│   │   │   │   ├── Synchronization.hpp
│   │   │   │   ├── Texture.cpp
│   │   │   │   ├── Texture.hpp
│   │   │   │   ├── Vulkan.cpp
│   │   │   │   └── vk_mem_alloc.h
│   │   │   └── xmake.lua
│   │   ├── RenderPass/
│   │   │   ├── Bloom.cpp
│   │   │   ├── CompositePass.cpp
│   │   │   ├── CopyImageRGBA16.cpp
│   │   │   ├── Debug.cpp
│   │   │   ├── Deferred.cpp
│   │   │   ├── FXAA.cpp
│   │   │   ├── Forward.cpp
│   │   │   ├── ForwardPlus.cpp
│   │   │   ├── IBL.cpp
│   │   │   ├── IPass.hpp
│   │   │   ├── PassData.hpp
│   │   │   ├── PathTracing.cpp
│   │   │   ├── Present.cpp
│   │   │   ├── RayTracedAO.cpp
│   │   │   ├── RayTracingReflection.cpp
│   │   │   ├── RayTracingShadow.cpp
│   │   │   ├── SSAO.cpp
│   │   │   ├── ShadowMapPass.cpp
│   │   │   ├── SkyboxPass.cpp
│   │   │   ├── Tonemapping.cpp
│   │   │   ├── Triangle.cpp
│   │   │   ├── VisibilityBufferVisualization.cpp
│   │   │   ├── VisibilityGeometryPass.cpp
│   │   │   ├── VisibilityLightingPass.cpp
│   │   │   └── xmake.lua
│   │   └── xmake.lua
│   ├── Runtime/
│   │   ├── Core/
│   │   │   ├── Private/
│   │   │   │   ├── JobSystem.cpp
│   │   │   │   ├── Log.cpp
│   │   │   │   ├── Path.cpp
│   │   │   │   ├── Plugin.cpp
│   │   │   │   ├── Time.cpp
│   │   │   │   ├── Variant.cpp
│   │   │   │   └── Window.cpp
│   │   │   ├── Public/
│   │   │   │   └── Core/
│   │   │   │       ├── API.hpp
│   │   │   │       ├── Container.hpp
│   │   │   │       ├── Core.hpp
│   │   │   │       ├── Delegates.hpp
│   │   │   │       ├── Hash.hpp
│   │   │   │       ├── Input.hpp
│   │   │   │       ├── JobSystem.hpp
│   │   │   │       ├── Log.hpp
│   │   │   │       ├── PRECOMPILE.HPP
│   │   │   │       ├── Path.hpp
│   │   │   │       ├── Plugin.hpp
│   │   │   │       ├── Time.hpp
│   │   │   │       ├── Variant.hpp
│   │   │   │       └── Window.hpp
│   │   │   └── xmake.lua
│   │   ├── Geometry/
│   │   │   ├── Private/
│   │   │   │   ├── AABB.cpp
│   │   │   │   ├── Mesh/
│   │   │   │   │   ├── EMesh.cpp
│   │   │   │   │   ├── FMesh.cpp
│   │   │   │   │   ├── HEMesh.cpp
│   │   │   │   │   └── Mesh.cpp
│   │   │   │   └── MeshProcess.cpp
│   │   │   ├── Public/
│   │   │   │   └── Geometry/
│   │   │   │       ├── AABB.hpp
│   │   │   │       ├── Mesh/
│   │   │   │       │   ├── EMesh.hpp
│   │   │   │       │   ├── FMesh.hpp
│   │   │   │       │   ├── HEMesh.hpp
│   │   │   │       │   └── Mesh.hpp
│   │   │   │       ├── MeshProcess.hpp
│   │   │   │       ├── Meshlet.hpp
│   │   │   │       └── Precompile.hpp
│   │   │   └── xmake.lua
│   │   ├── RHI/
│   │   │   ├── Private/
│   │   │   │   ├── RHIAccelerationStructure.cpp
│   │   │   │   ├── RHIBuffer.cpp
│   │   │   │   ├── RHICommand.cpp
│   │   │   │   ├── RHIContext.cpp
│   │   │   │   ├── RHIDescriptor.cpp
│   │   │   │   ├── RHIDevice.cpp
│   │   │   │   ├── RHIFrame.cpp
│   │   │   │   ├── RHIPipelineState.cpp
│   │   │   │   ├── RHIProfiler.cpp
│   │   │   │   ├── RHIQueue.cpp
│   │   │   │   ├── RHIRenderTarget.cpp
│   │   │   │   ├── RHISampler.cpp
│   │   │   │   ├── RHIShader.cpp
│   │   │   │   ├── RHISwapchain.cpp
│   │   │   │   ├── RHISynchronization.cpp
│   │   │   │   └── RHITexture.cpp
│   │   │   └── Public/
│   │   │       └── RHI/
│   │   │           ├── Fwd.hpp
│   │   │           ├── RHIAccelerationStructure.hpp
│   │   │           ├── RHIBuffer.hpp
│   │   │           ├── RHICommand.hpp
│   │   │           ├── RHIContext.hpp
│   │   │           ├── RHIDefinitions.hpp
│   │   │           ├── RHIDescriptor.hpp
│   │   │           ├── RHIDevice.hpp
│   │   │           ├── RHIFrame.hpp
│   │   │           ├── RHIPipelineState.hpp
│   │   │           ├── RHIProfiler.hpp
│   │   │           ├── RHIQueue.hpp
│   │   │           ├── RHIRenderTarget.hpp
│   │   │           ├── RHISampler.hpp
│   │   │           ├── RHIShader.hpp
│   │   │           ├── RHISwapchain.hpp
│   │   │           ├── RHISynchronization.hpp
│   │   │           └── RHITexture.hpp
│   │   ├── Render/
│   │   │   ├── Material/
│   │   │   │   ├── Private/
│   │   │   │   │   └── Material/
│   │   │   │   │       ├── MaterialCompiler.cpp
│   │   │   │   │       ├── MaterialData.cpp
│   │   │   │   │       ├── MaterialGraph.cpp
│   │   │   │   │       ├── MaterialNode.cpp
│   │   │   │   │       └── Spectrum.cpp
│   │   │   │   └── Public/
│   │   │   │       └── Material/
│   │   │   │           ├── MaterialCompiler.hpp
│   │   │   │           ├── MaterialData.hpp
│   │   │   │           ├── MaterialGraph.hpp
│   │   │   │           ├── MaterialNode.hpp
│   │   │   │           └── Spectrum.hpp
│   │   │   ├── RenderGraph/
│   │   │   │   ├── Private/
│   │   │   │   │   ├── RenderGraph.cpp
│   │   │   │   │   ├── RenderGraphBlackboard.cpp
│   │   │   │   │   ├── RenderGraphBuilder.cpp
│   │   │   │   │   └── RenderPass.cpp
│   │   │   │   └── Public/
│   │   │   │       └── RenderGraph/
│   │   │   │           ├── Impl/
│   │   │   │           │   └── RenderGraphBuilder.inl
│   │   │   │           ├── Precompile.hpp
│   │   │   │           ├── RenderGraph.hpp
│   │   │   │           ├── RenderGraphBlackboard.hpp
│   │   │   │           ├── RenderGraphBuilder.hpp
│   │   │   │           └── RenderPass.hpp
│   │   │   ├── Renderer/
│   │   │   │   ├── Private/
│   │   │   │   │   └── Renderer.cpp
│   │   │   │   └── Public/
│   │   │   │       └── Renderer/
│   │   │   │           ├── RenderData.hpp
│   │   │   │           └── Renderer.hpp
│   │   │   ├── ShaderCompiler/
│   │   │   │   ├── Private/
│   │   │   │   │   ├── ShaderBuilder.cpp
│   │   │   │   │   ├── ShaderCompiler.cpp
│   │   │   │   │   └── SpirvReflection.cpp
│   │   │   │   └── Public/
│   │   │   │       └── ShaderCompiler/
│   │   │   │           ├── Precompile.hpp
│   │   │   │           ├── ShaderBuilder.hpp
│   │   │   │           ├── ShaderCompiler.hpp
│   │   │   │           └── SpirvReflection.hpp
│   │   │   └── xmake.lua
│   │   ├── Resource/
│   │   │   ├── Private/
│   │   │   │   └── Resource/
│   │   │   │       ├── Importer.cpp
│   │   │   │       ├── Resource/
│   │   │   │       │   ├── Animation.cpp
│   │   │   │       │   ├── Material.cpp
│   │   │   │       │   ├── Mesh.cpp
│   │   │   │       │   ├── Prefab.cpp
│   │   │   │       │   ├── RenderPipeline.cpp
│   │   │   │       │   ├── Scene.cpp
│   │   │   │       │   ├── SkinnedMesh.cpp
│   │   │   │       │   ├── Texture2D.cpp
│   │   │   │       │   └── TextureCube.cpp
│   │   │   │       ├── Resource.cpp
│   │   │   │       └── ResourceManager.cpp
│   │   │   └── Public/
│   │   │       └── Resource/
│   │   │           ├── Importer.hpp
│   │   │           ├── Resource/
│   │   │           │   ├── Animation.hpp
│   │   │           │   ├── Material.hpp
│   │   │           │   ├── Mesh.hpp
│   │   │           │   ├── Prefab.hpp
│   │   │           │   ├── RenderPipeline.hpp
│   │   │           │   ├── Scene.hpp
│   │   │           │   ├── SkinnedMesh.hpp
│   │   │           │   ├── Texture2D.hpp
│   │   │           │   └── TextureCube.hpp
│   │   │           ├── Resource.hpp
│   │   │           └── ResourceManager.hpp
│   │   ├── Scene/
│   │   │   ├── Private/
│   │   │   │   └── Scene/
│   │   │   │       ├── Component.cpp
│   │   │   │       ├── Components/
│   │   │   │       │   ├── AllComponents.cpp
│   │   │   │       │   ├── Camera/
│   │   │   │       │   │   ├── Camera.cpp
│   │   │   │       │   │   ├── OrthographicCamera.cpp
│   │   │   │       │   │   └── PerspectiveCamera.cpp
│   │   │   │       │   ├── Light/
│   │   │   │       │   │   ├── DirectionalLight.cpp
│   │   │   │       │   │   ├── EnvironmentLight.cpp
│   │   │   │       │   │   ├── Light.cpp
│   │   │   │       │   │   ├── PointLight.cpp
│   │   │   │       │   │   ├── RectLight.cpp
│   │   │   │       │   │   └── SpotLight.cpp
│   │   │   │       │   ├── Renderable/
│   │   │   │       │   │   ├── MeshRenderer.cpp
│   │   │   │       │   │   ├── Renderable.cpp
│   │   │   │       │   │   └── SkinnedMeshRenderer.cpp
│   │   │   │       │   └── Transform.cpp
│   │   │   │       ├── Node.cpp
│   │   │   │       └── Scene.cpp
│   │   │   └── Public/
│   │   │       └── Scene/
│   │   │           ├── Component.hpp
│   │   │           ├── Components/
│   │   │           │   ├── AllComponents.hpp
│   │   │           │   ├── Camera/
│   │   │           │   │   ├── Camera.hpp
│   │   │           │   │   ├── OrthographicCamera.hpp
│   │   │           │   │   └── PerspectiveCamera.hpp
│   │   │           │   ├── Light/
│   │   │           │   │   ├── DirectionalLight.hpp
│   │   │           │   │   ├── EnvironmentLight.hpp
│   │   │           │   │   ├── Light.hpp
│   │   │           │   │   ├── PointLight.hpp
│   │   │           │   │   ├── RectLight.hpp
│   │   │           │   │   └── SpotLight.hpp
│   │   │           │   ├── Renderable/
│   │   │           │   │   ├── MeshRenderer.hpp
│   │   │           │   │   ├── Renderable.hpp
│   │   │           │   │   └── SkinnedMeshRenderer.hpp
│   │   │           │   └── Transform.hpp
│   │   │           ├── Node.hpp
│   │   │           └── Scene.hpp
│   │   └── xmake.lua
│   ├── Shaders/
│   │   ├── AmbientOcclusion/
│   │   │   ├── RayTracedAO.hlsl
│   │   │   └── SSAO.hlsl
│   │   ├── Attribute.hlsli
│   │   ├── Common.hlsli
│   │   ├── Complex.hlsli
│   │   ├── Editor/
│   │   │   ├── AnimationEditor/
│   │   │   │   └── DrawSkeleton.hlsl
│   │   │   ├── AnimationEditor.hlsl
│   │   │   ├── MaterialEditor.hlsl
│   │   │   ├── MeshEditor.hlsl
│   │   │   └── Preview/
│   │   │       ├── Material.hlsl
│   │   │       └── Mesh.hlsl
│   │   ├── GlobalIllumination/
│   │   │   └── DDGI.hlsl
│   │   ├── ImGui.hlsl
│   │   ├── Interaction.hlsli
│   │   ├── Light.hlsli
│   │   ├── Material/
│   │   │   ├── BSDF/
│   │   │   │   ├── BSDF.hlsli
│   │   │   │   ├── ConductorBSDF.hlsli
│   │   │   │   ├── DielectricBSDF.hlsli
│   │   │   │   ├── DiffuseBSDF.hlsli
│   │   │   │   ├── DisneyBSDF.hlsli
│   │   │   │   ├── LayeredBSDF.hlsli
│   │   │   │   └── ThinDielectricBSDF.hlsli
│   │   │   ├── Fresnel.hlsli
│   │   │   ├── Material/
│   │   │   │   ├── ConductorMaterial.hlsli
│   │   │   │   ├── DielectricMaterial.hlsli
│   │   │   │   ├── DiffuseMaterial.hlsli
│   │   │   │   ├── DisneyMaterial.hlsli
│   │   │   │   ├── MaskedMaterial.hlsli
│   │   │   │   ├── MixMaterial.hlsli
│   │   │   │   └── ThinDielectricMaterial.hlsli
│   │   │   ├── Material.hlsli
│   │   │   ├── Scattering.hlsli
│   │   │   └── Template.material.hlsli
│   │   ├── Material.hlsli
│   │   ├── MaterialResource.hlsli
│   │   ├── Math.hlsli
│   │   ├── PostProcess/
│   │   │   ├── Bloom.hlsl
│   │   │   ├── FXAA.hlsl
│   │   │   └── Tonemapping.hlsl
│   │   ├── PreProcess/
│   │   │   ├── EquirectangularToCubemap.hlsl
│   │   │   └── GGXBRDFLUT.hlsl
│   │   ├── Random.hlsli
│   │   ├── RayTracing/
│   │   │   ├── BidirectionalPathTracing.hlsl
│   │   │   └── PathTracing.hlsl
│   │   ├── Reflection/
│   │   │   └── RayTracedReflection.hlsl
│   │   ├── RenderPath/
│   │   │   ├── VisibilityBufferVisualization.hlsl
│   │   │   ├── VisibilityGeometryPass.hlsl
│   │   │   └── VisibilityLightingPass.hlsl
│   │   ├── Shading/
│   │   │   ├── Composite.hlsl
│   │   │   ├── IBL.hlsl
│   │   │   └── Skybox.hlsl
│   │   ├── Shadow/
│   │   │   ├── CascadeShadowMap.hlsl
│   │   │   ├── OmniShadowMap.hlsl
│   │   │   ├── RayTracedShadow.hlsl
│   │   │   └── ShadowMap.hlsl
│   │   ├── SphericalHarmonic.hlsli
│   │   ├── Tonemapper.hlsli
│   │   └── UpdateBoneMatrics.hlsl
│   └── xmake.lua
├── imgui.ini
├── xmake/
│   ├── module.lua
│   ├── plugin.lua
│   ├── rule.lua
│   └── shader.lua
└── xmake.lua

================================================
FILE CONTENTS
================================================

================================================
FILE: .clang-format
================================================
---
Language:        Cpp
# BasedOnStyle:  LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: true
AlignConsecutiveDeclarations: true
AlignEscapedNewlines: Left
AlignOperands:   true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: true
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
  AfterClass:      true
  AfterControlStatement: true
  AfterEnum:       true
  AfterFunction:   true
  AfterNamespace:  true
  AfterObjCDeclaration: true
  AfterStruct:     true
  AfterUnion:      true
  AfterExternBlock: true
  BeforeCatch:     true
  BeforeElse:      true
  IndentBraces:    false
  SplitEmptyFunction: false
  SplitEmptyRecord: false
  SplitEmptyNamespace: false
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakBeforeTernaryOperators: false
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: AfterColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit:     0
CommentPragmas:  '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat:   false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
  - foreach
  - Q_FOREACH
  - BOOST_FOREACH
IncludeBlocks:   Preserve
IncludeIsMainRegex: '(Test)?$'
IndentCaseLabels: true
IndentPPDirectives: AfterHash
IndentWidth:     4
IndentWrappedFunctionNames: true
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd:   ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
ReflowComments:  true
SortIncludes:    true
SortUsingDeclarations: true
SpaceAfterCStyleCast: true
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 8
SpacesInAngles:  false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard:        Cpp11
TabWidth:        4
UseTab:          ForIndentation
...


================================================
FILE: .clang-tidy
================================================
Checks: '-*,
    misc-throw-by-value-catch-by-reference,
    misc-misplaced-const,
    misc-unconventional-assign-operator,
    misc-redundant-expression,
    misc-static-assert,
    misc-unconventional-assign-operator,
    misc-uniqueptr-reset-release,
    misc-unused-alias-decls,
    misc-unused-parameters,
    misc-unused-using-decls,

    modernize-avoid-bind,
    modernize-loop-convert,
    modernize-make-shared,
    modernize-make-unique,
    modernize-raw-string-literal,
    modernize-redundant-void-arg,
    modernize-replace-auto-ptr,
    modernize-replace-random-shuffle,
    modernize-use-bool-literals,
    modernize-use-nullptr,
    modernize-use-using,
    modernize-use-equals-default,
    modernize-use-equals-delete,

    performance-faster-string-find,
    performance-for-range-copy,
    performance-implicit-conversion-in-loop,
    performance-inefficient-algorithm,
    performance-inefficient-vector-operation,
    performance-move-constructor-init,
    performance-no-automatic-move,
    performance-trivially-destructible,
    performance-unnecessary-copy-initialization,

    readability-avoid-const-params-in-decls,
    readability-const-return-type,
    readability-container-size-empty,
    readability-convert-member-functions-to-static,
    readability-delete-null-pointer,
    readability-deleted-default,
    readability-make-member-function-const,
    readability-misplaced-array-index,
    readability-non-const-parameter,
    readability-qualified-auto,
    readability-redundant-access-specifiers,
    readability-redundant-control-flow,
    readability-redundant-function-ptr-dereference,
    readability-redundant-smartptr-get,
    readability-redundant-string-cstr,
    readability-redundant-string-init,
    readability-static-definition-in-anonymous-namespace,
    readability-string-compare,
    readability-uniqueptr-delete-release,
    readability-redundant-member-init,
    readability-simplify-subscript-expr,
    readability-simplify-boolean-expr,
    readability-inconsistent-declaration-parameter-name,
    readability-identifier-naming,

    bugprone-undelegated-constructor,
    bugprone-argument-comment,
    bugprone-bad-signal-to-kill-thread,
    bugprone-bool-pointer-implicit-conversion,
    bugprone-copy-constructor-init,
    bugprone-dangling-handle,
    bugprone-forward-declaration-namespace,
    bugprone-fold-init-type,
    bugprone-inaccurate-erase,
    bugprone-incorrect-roundings,
    bugprone-infinite-loop,
    bugprone-integer-division,
    bugprone-macro-parentheses,
    bugprone-macro-repeated-side-effects,
    bugprone-misplaced-operator-in-strlen-in-alloc,
    bugprone-misplaced-pointer-artithmetic-in-alloc,
    bugprone-misplaced-widening-cast,
    bugprone-move-forwarding-reference,
    bugprone-multiple-statement-macro,
    bugprone-parent-virtual-call,
    bugprone-posix-return,
    bugprone-reserved-identifier,
    bugprone-signed-char-misuse,
    bugprone-sizeof-container,
    bugprone-sizeof-expression,
    bugprone-string-constructor,
    bugprone-string-integer-assignment,
    bugprone-string-literal-with-embedded-nul,
    bugprone-suspicious-enum-usage,
    bugprone-suspicious-include,
    bugprone-suspicious-memset-usage,
    bugprone-suspicious-missing-comma,
    bugprone-suspicious-string-compare,
    bugprone-swapped-arguments,
    bugprone-terminating-continue,
    bugprone-throw-keyword-missing,
    bugprone-too-small-loop-variable,
    bugprone-undefined-memory-manipulation,
    bugprone-unhandled-self-assignment,
    bugprone-unused-raii,
    bugprone-unused-return-value,
    bugprone-use-after-move,
    bugprone-virtual-near-miss,

    cert-dcl21-cpp,
    cert-dcl50-cpp,
    cert-env33-c,
    cert-err34-c,
    cert-err52-cpp,
    cert-flp30-c,
    cert-mem57-cpp,
    cert-msc50-cpp,
    cert-oop58-cpp,

    google-build-explicit-make-pair,
    google-build-namespaces,
    google-default-arguments,
    google-explicit-constructor,
    google-readability-casting,
    google-readability-avoid-underscore-in-googletest-name,
    google-runtime-int,
    google-runtime-operator,

    hicpp-exception-baseclass,

    clang-analyzer-core.CallAndMessage,
    clang-analyzer-core.DivideZero,
    clang-analyzer-core.NonNullParamChecker,
    clang-analyzer-core.NullDereference,
    clang-analyzer-core.StackAddressEscape,
    clang-analyzer-core.UndefinedBinaryOperatorResult,
    clang-analyzer-core.VLASize,
    clang-analyzer-core.uninitialized.ArraySubscript,
    clang-analyzer-core.uninitialized.Assign,
    clang-analyzer-core.uninitialized.Branch,
    clang-analyzer-core.uninitialized.CapturedBlockVariable,
    clang-analyzer-core.uninitialized.UndefReturn,
    clang-analyzer-cplusplus.InnerPointer,
    clang-analyzer-cplusplus.NewDelete,
    clang-analyzer-cplusplus.NewDeleteLeaks,
    clang-analyzer-cplusplus.PlacementNewChecker,
    clang-analyzer-cplusplus.SelfAssignment,
    clang-analyzer-deadcode.DeadStores,
    clang-analyzer-optin.cplusplus.VirtualCall,
    clang-analyzer-security.insecureAPI.UncheckedReturn,
    clang-analyzer-security.insecureAPI.bcmp,
    clang-analyzer-security.insecureAPI.bcopy,
    clang-analyzer-security.insecureAPI.bzero,
    clang-analyzer-security.insecureAPI.getpw,
    clang-analyzer-security.insecureAPI.gets,
    clang-analyzer-security.insecureAPI.mkstemp,
    clang-analyzer-security.insecureAPI.mktemp,
    clang-analyzer-security.insecureAPI.rand,
    clang-analyzer-security.insecureAPI.strcpy,
    clang-analyzer-unix.Malloc,
    clang-analyzer-unix.MallocSizeof,
    clang-analyzer-unix.MismatchedDeallocator,
    clang-analyzer-unix.Vfork,
    clang-analyzer-unix.cstring.BadSizeArg,
    clang-analyzer-unix.cstring.NullArg,

    boost-use-to-string,
'
WarningsAsErrors: '*'

CheckOptions:
  - key: readability-identifier-naming.ClassCase
    value: CamelCase
  - key: readability-identifier-naming.EnumCase
    value: CamelCase
  - key: readability-identifier-naming.LocalVariableCase
    value: lower_case
  - key: readability-identifier-naming.StaticConstantCase
    value: aNy_CasE
  - key: readability-identifier-naming.MemberCase
    value: lower_case
  - key: readability-identifier-naming.ClassMemberPrefix
    value: m_
  - key: readability-identifier-naming.PrivateMemberPrefix
    value: ''
  - key: readability-identifier-naming.ProtectedMemberPrefix
    value: ''
  - key: readability-identifier-naming.PublicMemberCase
    value: lower_case
  - key: readability-identifier-naming.MethodCase
    value: camelBack
  - key: readability-identifier-naming.PrivateMethodPrefix
    value: ''
  - key: readability-identifier-naming.ProtectedMethodPrefix
    value: ''
  - key: readability-identifier-naming.ParameterPackCase
    value: lower_case
  - key: readability-identifier-naming.StructCase
    value: CamelCase
  - key: readability-identifier-naming.TemplateTemplateParameterCase
    value: CamelCase
  - key: readability-identifier-naming.TemplateUsingCase
    value: lower_case
  - key: readability-identifier-naming.TypeTemplateParameterCase
    value: CamelCase
  - key: readability-identifier-naming.TypedefCase
    value: CamelCase
  - key: readability-identifier-naming.UnionCase
    value: CamelCase
  - key: readability-identifier-naming.UsingCase
    value: CamelCase

================================================
FILE: .github/workflows/windows_dev.yml
================================================
name: Windows_dev

on:
  pull_request:
    types: [dev]
  push:
    branches: [dev]

jobs:
  build:
    runs-on: "windows-latest"
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: "recursive"
      
      - uses: Jimver/cuda-toolkit@v0.2.8
        id: cuda-toolkit
        with:
          cuda: '11.7.0'
          sub-packages: '["nvcc", "visual_studio_integration", "cudart"]'

      - uses: xmake-io/github-action-setup-xmake@v1
        with:
          xmake-version: latest
          actions-cache-folder: ".xmake-cache"

      - name: Build
        run: xmake -y

================================================
FILE: .github/workflows/windows_main.yml
================================================
name: Windows_main

on:
  pull_request:
    types: [main]
  push:
    branches: [main]

jobs:
  build:
    runs-on: "windows-latest"
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: "recursive"
      
      - uses: Jimver/cuda-toolkit@v0.2.8
        id: cuda-toolkit
        with:
          cuda: '11.7.0'
          sub-packages: '["nvcc", "visual_studio_integration", "cudart"]'

      - uses: xmake-io/github-action-setup-xmake@v1
        with:
          xmake-version: latest
          actions-cache-folder: ".xmake-cache"

      - name: Build
        run: xmake -y

================================================
FILE: .gitignore
================================================
# Prerequisites
*.d

# Compiled Object files
*.slo
*.lo
*.o

# Precompiled Headers
*.gch
*.pch

# Compiled Dynamic libraries
*.so
*.dylib
*.dll

# Fortran module files
*.mod
*.smod

# Compiled Static libraries
*.lai
*.la
*.a
*.lib

# Executables
*.exe
*.out
*.app
*.spv

# Folders
/build/*
/bin/*
/lib/*
/shared/*

**/Archive/*

*.meta

.vscode
.xmake/
build/
vsxmake**

================================================
FILE: .gitmodules
================================================
[submodule "Source/Dependencies"]
	path = Source/Dependencies
	url = https://github.com/Chaf-Libraries/Dependencies


================================================
FILE: Asset/Meta/README.md
================================================


================================================
FILE: Asset/MustacheTemplate/Reflection.mustache
================================================
{{#Header}}
{{&Include}}
{{/Header}}

namespace Ilum_{{Hash}}
{
RTTR_REGISTRATION
{
    {{#Enum}}
    rttr::registration::enumeration<{{EnumQualifiedName}}>("{{EnumName}}")
    (
        {{#EnumValue}}
        rttr::value("{{EnumValueName}}", {{EnumValueQualifiedName}}){{^IsLast}},{{/IsLast}}
        {{/EnumValue}}  
    );
    {{/Enum}}
    {{#Class}}
    rttr::registration::class_<{{ClassQualifiedName}}>("{{ClassName}}"){{#Meta}}({{#MetaData}}rttr::metadata("{{&Key}}", {{&Value}}){{^IsLast}}, {{/IsLast}}{{/MetaData}}){{/Meta}}
    {{#Field}}
        .property("{{FieldName}}", &{{FieldQualifiedName}}, rttr::registration::{{#Public}}public_access{{/Public}}{{#Private}}private_access{{/Private}}{{#Protected}}protected_access{{/Protected}}){{#Meta}}({{#MetaData}}rttr::metadata("{{&Key}}", {{&Value}}){{^IsLast}}, {{/IsLast}}{{/MetaData}}){{/Meta}}
    {{/Field}}
    {{#Constructor}}
        {{^Static}}.constructor<{{#Params}}{{&Param}}{{^IsLast}}, {{/IsLast}}{{/Params}}>(){{/Static}}{{#Static}}.constructor(&{{MethodQualifiedName}}){{/Static}}(rttr::policy::ctor::as_object)
    {{/Constructor}}
    {{#NoConstructor}}
        .constructor<>()(rttr::policy::ctor::as_object)
    {{/NoConstructor}}
    {{#Method}}
        .method("{{&MethodName}}", {{^Overload}}&{{&MethodQualifiedName}}{{/Overload}}{{#Overload}}{{^Const}}rttr::select_overload<{{&ReturnType}}({{#Params}}{{&Param}}{{^IsLast}}, {{/IsLast}}{{/Params}})>{{/Const}}{{#Const}}rttr::select_const<{{&ClassQualifiedName}}, {{&ReturnType}}, {{#Params}}{{&Param}}{{^IsLast}}, {{/IsLast}}{{/Params}}>{{/Const}}(&{{&MethodQualifiedName}}){{/Overload}}, rttr::registration::{{#Public}}public_access{{/Public}}{{#Private}}private_access{{/Private}}{{#Protected}}protected_access{{/Protected}}){{#Meta}}({{#MetaData}}rttr::metadata("{{&Key}}", {{&Value}}){{^IsLast}}, {{/IsLast}}{{/MetaData}}){{/Meta}}
    {{/Method}}
    ;
    {{/Class}}
}
}

================================================
FILE: Asset/NRD_Data/Sample/blur_buffer.csv
================================================
gViewToClip,"[1.0000, 0.0000, 0.0000, 0.0000]
[0.0000, 1.7778, 0.0000, 0.0000]
[-0.0000, -0.0000, 1.0000, 1.0000]
[0.0000, 0.0000, -0.0010, 0.0000]"
gViewToWorld,"[-0.9997, -0.0236, -0.0000, 0.0000]
[0.0031, -0.1315, 0.9913, 0.0000]
[0.0234, -0.9910, -0.1315, 0.0000]
[0.0000, 0.0000, 0.0000, 1.0000]"
gFrustum,"[-1.0000, 0.5625, 2.0000, -1.1250]"
gHitDistParams,"[3.0000, 0.1000, 20.0000, -25.0000]"
gViewVectorWorld,"[-0.0234, 0.9910, 0.1315, 0.0000]"
gViewVectorWorldPrev,"[-0.0234, 0.9910, 0.1315, 0.0000]"
gInvScreenSize,"[0.0008, 0.0014]"
gScreenSize,"[1280.0000, 720.0000]"
gInvRectSize,"[0.0008, 0.0014]"
gRectSize,"[1280.0000, 720.0000]"
gRectSizePrev,"[1280.0000, 720.0000]"
gResolutionScale,"[1.0000, 1.0000]"
gRectOffset,"[0.0000, 0.0000]"
gSensitivityToDarkness,"[0.0100, 0.1000]"
gRectOrigin,"[0, 0]"
gReference,0.0000
gOrthoMode,0.0000
gUnproject,0.0016
gDebug,0.0000
gDenoisingRange,60.6960
gPlaneDistSensitivity,0.0050
gFramerateScale,0.5000
gBlurRadius,30.0000
gMaxAccumulatedFrameNum,1.0000
gMaxFastAccumulatedFrameNum,0.0000
gAntiFirefly,0.0000
gMinConvergedStateBaseRadiusScale,0.2500
gLobeAngleFraction,0.1000
gRoughnessFraction,0.0500
gResponsiveAccumulationRoughnessThreshold,0.0000
gDiffPrepassBlurRadius,30.0000
gSpecPrepassBlurRadius,50.0000
gIsWorldSpaceMotionEnabled,1
gFrameIndex,42372
gResetHistory,0
gDiffMaterialMask,1
gSpecMaterialMask,0
gRotator,"[0.2651, -0.9642, 0.9642, 0.2651]"
gSpecLobeTrimmingParams,"[0.9500, 0.0400, 0.1100]"
gBlurRadiusScale,5.0000


================================================
FILE: Asset/NRD_Data/Sample/history_fix_buffer.csv
================================================
gViewToClip,"[1.0000, 0.0000, 0.0000, 0.0000]
[0.0000, 1.7778, 0.0000, 0.0000]
[-0.0000, -0.0000, 1.0000, 1.0000]
[0.0000, 0.0000, -0.0010, 0.0000]",-
gViewToWorld,"[-0.9997, -0.0236, -0.0000, 0.0000]
[0.0031, -0.1315, 0.9913, 0.0000]
[0.0234, -0.9910, -0.1315, 0.0000]
[0.0000, 0.0000, 0.0000, 1.0000]",-
gFrustum,"[-1.0000, 0.5625, 2.0000, -1.1250]",-
gHitDistParams,"[3.0000, 0.1000, 20.0000, -25.0000]",-
gViewVectorWorld,"[-0.0234, 0.9910, 0.1315, 0.0000]",-
gViewVectorWorldPrev,"[-0.0234, 0.9910, 0.1315, 0.0000]",-
gInvScreenSize,"[0.0008, 0.0014]",-
gScreenSize,"[1280.0000, 720.0000]",-
gInvRectSize,"[0.0008, 0.0014]",-
gRectSize,"[1280.0000, 720.0000]",-
gRectSizePrev,"[1280.0000, 720.0000]",-
gResolutionScale,"[1.0000, 1.0000]",-
gRectOffset,"[0.0000, 0.0000]",-
gSensitivityToDarkness,"[0.0100, 0.1000]",-
gRectOrigin,"[0, 0]",-
gReference,0.0000,-
gOrthoMode,0.0000,-
gUnproject,0.0016,-
gDebug,0.0000,-
gDenoisingRange,60.6960,-
gPlaneDistSensitivity,0.0050,-
gFramerateScale,0.5000,-
gBlurRadius,30.0000,-
gMaxAccumulatedFrameNum,1.0000,-
gMaxFastAccumulatedFrameNum,0.0000,-
gAntiFirefly,0.0000,-
gMinConvergedStateBaseRadiusScale,0.2500,-
gLobeAngleFraction,0.1000,-
gRoughnessFraction,0.0500,-
gResponsiveAccumulationRoughnessThreshold,0.0000,-
gDiffPrepassBlurRadius,30.0000,-
gSpecPrepassBlurRadius,50.0000,-
gIsWorldSpaceMotionEnabled,1,-
gFrameIndex,42372,-
gResetHistory,0,-
gDiffMaterialMask,1,-
gSpecMaterialMask,0,-
gHistoryFixStrength,1.0000,-


================================================
FILE: Asset/NRD_Data/Sample/post_blur_buffer.csv
================================================
gViewToClip,gViewToWorld,gFrustum,gHitDistParams,gViewVectorWorld,gViewVectorWorldPrev,gInvScreenSize,gScreenSize,gInvRectSize,gRectSize,gRectSizePrev,gResolutionScale,gRectOffset,gSensitivityToDarkness,gRectOrigin,gReference,gOrthoMode,gUnproject,gDebug,gDenoisingRange,gPlaneDistSensitivity,gFramerateScale,gBlurRadius,gMaxAccumulatedFrameNum,gMaxFastAccumulatedFrameNum,gAntiFirefly,gMinConvergedStateBaseRadiusScale,gLobeAngleFraction,gRoughnessFraction,gResponsiveAccumulationRoughnessThreshold,gDiffPrepassBlurRadius,gSpecPrepassBlurRadius,gIsWorldSpaceMotionEnabled,gFrameIndex,gResetHistory,gDiffMaterialMask,gSpecMaterialMask,gRotator,gSpecLobeTrimmingParams,gBlurRadiusScale
"[1.0000, 0.0000, 0.0000, 0.0000]
[0.0000, 1.7778, 0.0000, 0.0000]
[-0.0000, -0.0000, 1.0000, 1.0000]
[0.0000, 0.0000, -0.0010, 0.0000]","[-0.9997, -0.0236, -0.0000, 0.0000]
[0.0031, -0.1315, 0.9913, 0.0000]
[0.0234, -0.9910, -0.1315, 0.0000]
[0.0000, 0.0000, 0.0000, 1.0000]","[-1.0000, 0.5625, 2.0000, -1.1250]","[3.0000, 0.1000, 20.0000, -25.0000]","[-0.0234, 0.9910, 0.1315, 0.0000]","[-0.0234, 0.9910, 0.1315, 0.0000]","[0.0008, 0.0014]","[1280.0000, 720.0000]","[0.0008, 0.0014]","[1280.0000, 720.0000]","[1280.0000, 720.0000]","[1.0000, 1.0000]","[0.0000, 0.0000]","[0.0100, 0.1000]","[0, 0]",0.0000,0.0000,0.0016,0.0000,60.6960,0.0050,0.5000,30.0000,1.0000,0.0000,0.0000,0.2500,0.1000,0.0500,0.0000,30.0000,50.0000,1,42372,0,1,0,"[-0.9642, -0.2651, 0.2651, -0.9642]","[0.9500, 0.0400, 0.1100]",5.0000


================================================
FILE: Asset/NRD_Data/Sample/temporal_accumulate_buffer.csv
================================================
gViewToClip,"[1.0000, 0.0000, 0.0000, 0.0000]
[0.0000, 1.7778, 0.0000, 0.0000]
[-0.0000, -0.0000, 1.0000, 1.0000]
[0.0000, 0.0000, -0.0010, 0.0000]",-
gViewToWorld,"[-0.9997, -0.0236, -0.0000, 0.0000]
[0.0031, -0.1315, 0.9913, 0.0000]
[0.0234, -0.9910, -0.1315, 0.0000]
[0.0000, 0.0000, 0.0000, 1.0000]",-
gFrustum,"[-1.0000, 0.5625, 2.0000, -1.1250]",-
gHitDistParams,"[3.0000, 0.1000, 20.0000, -25.0000]",-
gViewVectorWorld,"[-0.0234, 0.9910, 0.1315, 0.0000]",-
gViewVectorWorldPrev,"[-0.0234, 0.9910, 0.1315, 0.0000]",-
gInvScreenSize,"[0.0008, 0.0014]",-
gScreenSize,"[1280.0000, 720.0000]",-
gInvRectSize,"[0.0008, 0.0014]",-
gRectSize,"[1280.0000, 720.0000]",-
gRectSizePrev,"[1280.0000, 720.0000]",-
gResolutionScale,"[1.0000, 1.0000]",-
gRectOffset,"[0.0000, 0.0000]",-
gSensitivityToDarkness,"[0.0100, 0.1000]",-
gRectOrigin,"[0, 0]",-
gReference,0.0000,-
gOrthoMode,0.0000,-
gUnproject,0.0016,-
gDebug,0.0000,-
gDenoisingRange,60.6960,-
gPlaneDistSensitivity,0.0050,-
gFramerateScale,0.5000,-
gBlurRadius,30.0000,-
gMaxAccumulatedFrameNum,1.0000,-
gMaxFastAccumulatedFrameNum,0.0000,-
gAntiFirefly,0.0000,-
gMinConvergedStateBaseRadiusScale,0.2500,-
gLobeAngleFraction,0.1000,-
gRoughnessFraction,0.0500,-
gResponsiveAccumulationRoughnessThreshold,0.0000,-
gDiffPrepassBlurRadius,30.0000,-
gSpecPrepassBlurRadius,50.0000,-
gIsWorldSpaceMotionEnabled,1,-
gFrameIndex,42372,-
gResetHistory,0,-
gDiffMaterialMask,1,-
gSpecMaterialMask,0,-
gWorldToViewPrev,"[-0.9997, 0.0031, 0.0234, 0.0000]
[-0.0236, -0.1315, -0.9910, 0.0000]
[-0.0000, 0.9913, -0.1315, 0.0000]
[0.0000, -0.0000, -0.0000, 1.0000]",-
gWorldToClipPrev,"[-0.9997, 0.0055, 0.0234, 0.0234]
[-0.0236, -0.2337, -0.9910, -0.9910]
[0.0000, 1.7623, -0.1315, -0.1315]
[0.0000, 0.0000, -0.0010, 0.0000]",-
gWorldToClip,"[-0.9997, 0.0055, 0.0234, 0.0234]
[-0.0236, -0.2337, -0.9910, -0.9910]
[0.0000, 1.7623, -0.1315, -0.1315]
[0.0000, 0.0000, -0.0010, 0.0000]",-
gWorldPrevToWorld,"[1.0000, 0.0000, 0.0000, 0.0000]
[0.0000, 1.0000, 0.0000, 0.0000]
[0.0000, 0.0000, 1.0000, 0.0000]
[0.0000, 0.0000, 0.0000, 1.0000]",-
gFrustumPrev,"[-1.0000, 0.5625, 2.0000, -1.1250]",-
gCameraDelta,"[0.0000, 0.0000, 0.0000, 0.0000]",-
gRotator,"[-0.5868, 0.8098, -0.8098, -0.5868]",-
gMotionVectorScale,"[1.0000, 1.0000]",-
gCheckerboardResolveAccumSpeed,0.6447,-
gDisocclusionThreshold,0.0071,-
gDiffCheckerboard,2,-
gSpecCheckerboard,2,-
gIsPrepassEnabled,0,-


================================================
FILE: Asset/SPD/metals/Ag.eta.spd
================================================
298.757050 1.519000
302.400421 1.496000
306.133759 1.432500
309.960449 1.323000
313.884003 1.142062
317.908142 0.932000
322.036835 0.719062
326.274139 0.526000
330.624481 0.388125
335.092377 0.294000
339.682678 0.253313
344.400482 0.238000
349.251221 0.221438
354.240509 0.209000
359.374420 0.194813
364.659332 0.186000
370.102020 0.192063
375.709625 0.200000
381.489777 0.198063
387.450562 0.192000
393.600555 0.182000
399.948975 0.173000
406.505493 0.172625
413.280579 0.173000
420.285339 0.166688
427.531647 0.160000
435.032196 0.158500
442.800629 0.157000
450.851562 0.151063
459.200653 0.144000
467.864838 0.137313
476.862213 0.132000
486.212463 0.130250
495.936707 0.130000
506.057861 0.129938
516.600769 0.130000
527.592224 0.130063
539.061646 0.129000
551.040771 0.124375
563.564453 0.120000
576.670593 0.119313
590.400818 0.121000
604.800842 0.125500
619.920898 0.131000
635.816284 0.136125
652.548279 0.140000
670.184753 0.140063
688.800964 0.140000
708.481018 0.144313
729.318665 0.148000
751.419250 0.145875
774.901123 0.143000
799.897949 0.142563
826.561157 0.145000
855.063293 0.151938
885.601257 0.163000


================================================
FILE: Asset/SPD/metals/Ag.k.spd
================================================
298.757050 1.080000
302.400421 0.882000
306.133759 0.761063
309.960449 0.647000
313.884003 0.550875
317.908142 0.504000
322.036835 0.554375
326.274139 0.663000
330.624481 0.818563
335.092377 0.986000
339.682678 1.120687
344.400482 1.240000
349.251221 1.345250
354.240509 1.440000
359.374420 1.533750
364.659332 1.610000
370.102020 1.641875
375.709625 1.670000
381.489777 1.735000
387.450562 1.810000
393.600555 1.878750
399.948975 1.950000
406.505493 2.029375
413.280579 2.110000
420.285339 2.186250
427.531647 2.260000
435.032196 2.329375
442.800629 2.400000
450.851562 2.478750
459.200653 2.560000
467.864838 2.640000
476.862213 2.720000
486.212463 2.798125
495.936707 2.880000
506.057861 2.973750
516.600769 3.070000
527.592224 3.159375
539.061646 3.250000
551.040771 3.348125
563.564453 3.450000
576.670593 3.553750
590.400818 3.660000
604.800842 3.766250
619.920898 3.880000
635.816284 4.010625
652.548279 4.150000
670.184753 4.293125
688.800964 4.440000
708.481018 4.586250
729.318665 4.740000
751.419250 4.908125
774.901123 5.090000
799.897949 5.288750
826.561157 5.500000
855.063293 5.720624
885.601257 5.950000


================================================
FILE: Asset/SPD/metals/Al.eta.spd
================================================
298.757050 0.273375
302.400421 0.280000
306.133759 0.286813
309.960449 0.294000
313.884003 0.301875
317.908142 0.310000
322.036835 0.317875
326.274139 0.326000
330.624481 0.334750
335.092377 0.344000
339.682678 0.353813
344.400482 0.364000
349.251221 0.374375
354.240509 0.385000
359.374420 0.395750
364.659332 0.407000
370.102020 0.419125
375.709625 0.432000
381.489777 0.445688
387.450562 0.460000
393.600555 0.474688
399.948975 0.490000
406.505493 0.506188
413.280579 0.523000
420.285339 0.540063
427.531647 0.558000
435.032196 0.577313
442.800629 0.598000
450.851562 0.620313
459.200653 0.644000
467.864838 0.668625
476.862213 0.695000
486.212463 0.723750
495.936707 0.755000
506.057861 0.789000
516.600769 0.826000
527.592224 0.867000
539.061646 0.912000
551.040771 0.963000
563.564453 1.020000
576.670593 1.080000
590.400818 1.150000
604.800842 1.220000
619.920898 1.300000
635.816284 1.390000
652.548279 1.490000
670.184753 1.600000
688.800964 1.740000
708.481018 1.910000
729.318665 2.140000
751.419250 2.410000
774.901123 2.630000
799.897949 2.800000
826.561157 2.740000
855.063293 2.580000
885.601257 2.240000


================================================
FILE: Asset/SPD/metals/Al.k.spd
================================================
298.757050 3.593750
302.400421 3.640000
306.133759 3.689375
309.960449 3.740000
313.884003 3.789375
317.908142 3.840000
322.036835 3.894375
326.274139 3.950000
330.624481 4.005000
335.092377 4.060000
339.682678 4.113750
344.400482 4.170000
349.251221 4.233750
354.240509 4.300000
359.374420 4.365000
364.659332 4.430000
370.102020 4.493750
375.709625 4.560000
381.489777 4.633750
387.450562 4.710000
393.600555 4.784375
399.948975 4.860000
406.505493 4.938125
413.280579 5.020000
420.285339 5.108750
427.531647 5.200000
435.032196 5.290000
442.800629 5.380000
450.851562 5.480000
459.200653 5.580000
467.864838 5.690000
476.862213 5.800000
486.212463 5.915000
495.936707 6.030000
506.057861 6.150000
516.600769 6.280000
527.592224 6.420000
539.061646 6.550000
551.040771 6.700000
563.564453 6.850000
576.670593 7.000000
590.400818 7.150000
604.800842 7.310000
619.920898 7.480000
635.816284 7.650000
652.548279 7.820000
670.184753 8.010000
688.800964 8.210000
708.481018 8.390000
729.318665 8.570000
751.419250 8.620000
774.901123 8.600000
799.897949 8.450000
826.561157 8.310000
855.063293 8.210000
885.601257 8.210000


================================================
FILE: Asset/SPD/metals/AlAs.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for cubic AlAs
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 4.470000
309.950012 4.920000
317.897003 5.350000
326.263000 5.390000
335.081024 4.990000
344.389008 4.720000
354.229004 4.480000
364.647003 4.300000
375.696991 4.130000
387.437988 3.930000
393.587006 0.000000
397.372009 0.000000
399.935028 0.000000
403.187012 0.000000
406.492004 0.000000
409.850983 0.000000
413.266998 0.000000
416.739990 0.000000
420.270996 0.000000
423.863007 0.000000
427.516998 0.000000
431.235016 0.000000
435.018036 0.000000
442.785980 3.703000
459.185028 3.570000
476.846008 3.472000
495.920013 3.394000
516.583008 3.329000
539.044006 3.273000
563.545044 3.225000
590.381042 3.183000
619.900024 3.145000
652.526001 3.112000
688.778015 3.082000
729.294006 3.056000
774.875000 3.032000
826.533020 3.010000
885.570984 2.990000


================================================
FILE: Asset/SPD/metals/AlAs.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for cubic AlAs
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 2.680000
309.950012 2.490000
317.897003 2.150000
326.263000 1.300000
335.081024 0.752000
344.389008 0.519000
354.229004 0.334000
364.647003 0.233000
375.696991 0.139000
387.437988 0.115000
393.587006 0.119000
397.372009 0.115000
399.935028 0.113000
403.187012 0.110000
406.492004 0.106000
409.850983 0.099800
413.266998 0.063800
416.739990 0.031500
420.270996 0.018900
423.863007 0.011800
427.516998 0.010500
431.235016 0.010300
435.018036 0.009930
442.785980 0.001610
459.185028 0.001560
476.846008 0.001530
495.920013 0.001250
516.583008 0.000682
539.044006 0.000275
563.545044 0.000040
590.381042 0.000002
619.900024 0.000000
652.526001 0.000000
688.778015 0.000000
729.294006 0.000000
774.875000 0.000000
826.533020 0.000000
885.570984 0.000000


================================================
FILE: Asset/SPD/metals/AlSb.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for cubic AlSb
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 3.150000
309.950012 3.500000
317.897003 3.710000
326.263000 3.810000
335.081024 3.930000
344.389008 3.960000
354.229004 3.950000
364.647003 3.970000
375.696991 4.140000
387.437988 4.510000
399.935028 4.570000
413.266998 4.520000
427.516998 4.660000
442.785980 5.270000
459.185028 5.080000
476.846008 4.810000
495.920013 4.610000
516.583008 4.440000
539.044006 4.310000
563.545044 4.200000
590.381042 4.010000


================================================
FILE: Asset/SPD/metals/AlSb.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for cubic AlSb
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 4.000000
309.950012 3.710000
317.897003 3.400000
326.263000 3.160000
335.081024 2.970000
344.389008 2.810000
354.229004 2.690000
364.647003 2.640000
375.696991 2.690000
387.437988 2.470000
399.935028 2.120000
413.266998 1.970000
427.516998 2.060000
442.785980 1.580000
459.185028 0.920000
476.846008 0.630000
495.920013 0.460000
516.583008 0.330000
539.044006 0.240000
563.545044 0.010000
590.381042 0.006000


================================================
FILE: Asset/SPD/metals/Au.eta.spd
================================================
298.757050 1.795000
302.400421 1.812000
306.133759 1.822625
309.960449 1.830000
313.884003 1.837125
317.908142 1.840000
322.036835 1.834250
326.274139 1.824000
330.624481 1.812000
335.092377 1.798000
339.682678 1.782000
344.400482 1.766000
349.251221 1.752500
354.240509 1.740000
359.374420 1.727625
364.659332 1.716000
370.102020 1.705875
375.709625 1.696000
381.489777 1.684750
387.450562 1.674000
393.600555 1.666000
399.948975 1.658000
406.505493 1.647250
413.280579 1.636000
420.285339 1.628000
427.531647 1.616000
435.032196 1.596250
442.800629 1.562000
450.851562 1.502125
459.200653 1.426000
467.864838 1.345875
476.862213 1.242000
486.212463 1.086750
495.936707 0.916000
506.057861 0.754500
516.600769 0.608000
527.592224 0.491750
539.061646 0.402000
551.040771 0.345500
563.564453 0.306000
576.670593 0.267625
590.400818 0.236000
604.800842 0.212375
619.920898 0.194000
635.816284 0.177750
652.548279 0.166000
670.184753 0.161000
688.800964 0.160000
708.481018 0.160875
729.318665 0.164000
751.419250 0.169500
774.901123 0.176000
799.897949 0.181375
826.561157 0.188000
855.063293 0.198125
885.601257 0.210000


================================================
FILE: Asset/SPD/metals/Au.k.spd
================================================
298.757050 1.920375
302.400421 1.920000
306.133759 1.918875
309.960449 1.916000
313.884003 1.911375
317.908142 1.904000
322.036835 1.891375
326.274139 1.878000
330.624481 1.868250
335.092377 1.860000
339.682678 1.851750
344.400482 1.846000
349.251221 1.845250
354.240509 1.848000
359.374420 1.852375
364.659332 1.862000
370.102020 1.883000
375.709625 1.906000
381.489777 1.922500
387.450562 1.936000
393.600555 1.947750
399.948975 1.956000
406.505493 1.959375
413.280579 1.958000
420.285339 1.951375
427.531647 1.940000
435.032196 1.924500
442.800629 1.904000
450.851562 1.875875
459.200653 1.846000
467.864838 1.814625
476.862213 1.796000
486.212463 1.797375
495.936707 1.840000
506.057861 1.956500
516.600769 2.120000
527.592224 2.326250
539.061646 2.540000
551.040771 2.730625
563.564453 2.880000
576.670593 2.940625
590.400818 2.970000
604.800842 3.015000
619.920898 3.060000
635.816284 3.070000
652.548279 3.150000
670.184753 3.445812
688.800964 3.800000
708.481018 4.087687
729.318665 4.357000
751.419250 4.610188
774.901123 4.860000
799.897949 5.125813
826.561157 5.390000
855.063293 5.631250
885.601257 5.880000


================================================
FILE: Asset/SPD/metals/Be.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for polycrystalline Be
# ;  
# ;  Concatenation of:
# ;  
# ;  Be_llnl_cxro + Be_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
310.000000 2.470000
326.300018 2.550000
344.399994 2.640000
364.600006 2.730000
387.399994 2.840000
413.300018 2.950000
442.800018 3.070000
476.800018 3.190000
516.600037 3.300000
563.500000 3.390000
619.900024 3.460000
688.799988 3.470000
774.900024 3.440000
885.600037 3.350000


================================================
FILE: Asset/SPD/metals/Be.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for polycrystalline Be
# ;  
# ;  Concatenation of:
# ;  
# ;  Be_llnl_cxro + Be_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
310.000000 3.080000
326.300018 3.080000
344.399994 3.080000
364.600006 3.100000
387.399994 3.120000
413.300018 3.140000
442.800018 3.160000
476.800018 3.160000
516.600037 3.180000
563.500000 3.170000
619.900024 3.180000
688.799988 3.230000
774.900024 3.350000
885.600037 3.550000


================================================
FILE: Asset/SPD/metals/Cr.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Cr
# ;  
# ;  Concatenation of:
# ;  
# ;  Cr_llnl_cxro + Cr_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
300.194000 0.980000
307.643005 1.020000
316.276001 1.060000
323.708008 1.120000
333.279999 1.180000
341.542999 1.260000
351.217987 1.330000
362.514984 1.390000
372.312012 1.430000
385.031006 1.440000
396.102020 1.480000
409.175018 1.540000
424.589020 1.650000
438.092010 1.800000
455.808990 1.990000
471.406982 2.220000
490.040009 2.490000
512.314026 2.750000
532.102966 2.980000
558.468018 3.180000
582.066040 3.340000
610.739014 3.480000
700.452026 3.840000
815.658020 4.230000
826.533020 4.270000
849.178040 4.310000
860.971985 4.330000
885.570984 4.380000


================================================
FILE: Asset/SPD/metals/Cr.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Cr
# ;  
# ;  Concatenation of:
# ;  
# ;  Cr_llnl_cxro + Cr_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
300.194000 2.670000
307.643005 2.760000
316.276001 2.850000
323.708008 2.950000
333.279999 3.040000
341.542999 3.120000
351.217987 3.180000
362.514984 3.240000
372.312012 3.310000
385.031006 3.400000
396.102020 3.540000
409.175018 3.710000
424.589020 3.890000
438.092010 4.060000
455.808990 4.220000
471.406982 4.360000
490.040009 4.440000
512.314026 4.460000
532.102966 4.450000
558.468018 4.410000
582.066040 4.380000
610.739014 4.360000
700.452026 4.370000
815.658020 4.340000
826.533020 4.330000
849.178040 4.320000
860.971985 4.320000
885.570984 4.310000


================================================
FILE: Asset/SPD/metals/CsI.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for CsI
# ;  
# ;  Concatenation of:
# ;  
# ;  CsI_llnl_cxro + CsI_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
304.993988 1.967310
309.950012 1.956510
314.989990 1.946580
319.947998 1.937410
324.980011 1.928930
329.997009 1.921060
334.990997 1.913730
339.951019 1.906900
344.963989 1.900510
350.028015 1.894530
354.937988 1.888910
359.988007 1.883630
364.968994 1.878660
369.979004 1.873970
375.014984 1.869540
379.957001 1.865350
385.031006 1.861380
389.997009 1.857620
394.967010 1.854040
399.935028 1.850640
409.987030 1.844330
419.985992 1.838590
430.037994 1.833360
439.957001 1.828570
450.018036 1.824170
460.037018 1.820120
469.977020 1.816370
479.985016 1.812910
490.040009 1.809700
499.919006 1.806720
509.996002 1.803930
520.049988 1.801340
530.056030 1.798910
539.983032 1.796640
550.044006 1.794510
559.981995 1.792500
570.023010 1.790620
579.888000 1.788840
590.100037 1.787170
600.097046 1.785590
619.900024 1.782680
640.062012 1.780060
659.819031 1.777700
680.088013 1.775570
700.056030 1.773630
719.976990 1.771860
740.179016 1.770250
760.147034 1.768770
779.747986 1.767410
799.871033 1.766150
819.974060 1.765000
839.973083 1.763920
859.778015 1.762930
879.915039 1.762010
899.709961 1.761150


================================================
FILE: Asset/SPD/metals/CsI.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for CsI
# ;  
# ;  Concatenation of:
# ;  
# ;  CsI_llnl_cxro + CsI_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
304.993988 0.000000
309.950012 0.000000
314.989990 0.000000
319.947998 0.000000
324.980011 0.000000
329.997009 0.000000
334.990997 0.000000
339.951019 0.000000
344.963989 0.000000
350.028015 0.000000
354.937988 0.000000
359.988007 0.000000
364.968994 0.000000
369.979004 0.000000
375.014984 0.000000
379.957001 0.000000
385.031006 0.000000
389.997009 0.000000
394.967010 0.000000
399.935028 0.000000
409.987030 0.000000
419.985992 0.000000
430.037994 0.000000
439.957001 0.000000
450.018036 0.000000
460.037018 0.000000
469.977020 0.000000
479.985016 0.000000
490.040009 0.000000
499.919006 0.000000
509.996002 0.000000
520.049988 0.000000
530.056030 0.000000
539.983032 0.000000
550.044006 0.000000
559.981995 0.000000
570.023010 0.000000
579.888000 0.000000
590.100037 0.000000
600.097046 0.000000
619.900024 0.000000
640.062012 0.000000
659.819031 0.000000
680.088013 0.000000
700.056030 0.000000
719.976990 0.000000
740.179016 0.000000
760.147034 0.000000
779.747986 0.000000
799.871033 0.000000
819.974060 0.000000
839.973083 0.000000
859.778015 0.000000
879.915039 0.000000
899.709961 0.000000


================================================
FILE: Asset/SPD/metals/Cu.eta.spd
================================================
298.757050 1.400313
302.400421 1.380000
306.133759 1.358438
309.960449 1.340000
313.884003 1.329063
317.908142 1.325000
322.036835 1.332500
326.274139 1.340000
330.624481 1.334375
335.092377 1.325000
339.682678 1.317812
344.400482 1.310000
349.251221 1.300313
354.240509 1.290000
359.374420 1.281563
364.659332 1.270000
370.102020 1.249062
375.709625 1.225000
381.489777 1.200000
387.450562 1.180000
393.600555 1.174375
399.948975 1.175000
406.505493 1.177500
413.280579 1.180000
420.285339 1.178125
427.531647 1.175000
435.032196 1.172812
442.800629 1.170000
450.851562 1.165312
459.200653 1.160000
467.864838 1.155312
476.862213 1.150000
486.212463 1.142812
495.936707 1.135000
506.057861 1.131562
516.600769 1.120000
527.592224 1.092437
539.061646 1.040000
551.040771 0.950375
563.564453 0.826000
576.670593 0.645875
590.400818 0.468000
604.800842 0.351250
619.920898 0.272000
635.816284 0.230813
652.548279 0.214000
670.184753 0.209250
688.800964 0.213000
708.481018 0.216250
729.318665 0.223000
751.419250 0.236500
774.901123 0.250000
799.897949 0.254188
826.561157 0.260000
855.063293 0.280000
885.601257 0.300000


================================================
FILE: Asset/SPD/metals/Cu.k.spd
================================================
298.757050 1.662125
302.400421 1.687000
306.133759 1.703313
309.960449 1.720000
313.884003 1.744563
317.908142 1.770000
322.036835 1.791625
326.274139 1.810000
330.624481 1.822125
335.092377 1.834000
339.682678 1.851750
344.400482 1.872000
349.251221 1.894250
354.240509 1.916000
359.374420 1.931688
364.659332 1.950000
370.102020 1.972438
375.709625 2.015000
381.489777 2.121562
387.450562 2.210000
393.600555 2.177188
399.948975 2.130000
406.505493 2.160063
413.280579 2.210000
420.285339 2.249938
427.531647 2.289000
435.032196 2.326000
442.800629 2.362000
450.851562 2.397625
459.200653 2.433000
467.864838 2.469187
476.862213 2.504000
486.212463 2.535875
495.936707 2.564000
506.057861 2.589625
516.600769 2.605000
527.592224 2.595562
539.061646 2.583000
551.040771 2.576500
563.564453 2.599000
576.670593 2.678062
590.400818 2.809000
604.800842 3.010750
619.920898 3.240000
635.816284 3.458187
652.548279 3.670000
670.184753 3.863125
688.800964 4.050000
708.481018 4.239563
729.318665 4.430000
751.419250 4.619563
774.901123 4.817000
799.897949 5.034125
826.561157 5.260000
855.063293 5.485625
885.601257 5.717000


================================================
FILE: Asset/SPD/metals/Cu2O.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Cu2O
# ;  
# ;  Concatenation of:
# ;
# ;  Cu2O_llnl_cxro + Cu2O_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
350.028015 2.400000
399.935028 2.800000
449.854980 3.060000
499.919006 3.120000
549.799988 3.100000
599.806030 3.020000
649.789978 2.900000
700.056030 2.830000
750.029968 2.770000
799.871033 2.700000
849.759949 2.660000
899.709961 2.630000


================================================
FILE: Asset/SPD/metals/Cu2O.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Cu2O
# ;  
# ;  Concatenation of:
# ;
# ;  Cu2O_llnl_cxro + Cu2O_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
350.028015 1.440000
399.935028 0.990000
449.854980 0.600000
499.919006 0.350000
549.799988 0.190000
599.806030 0.130000
649.789978 0.100000
700.056030 0.083000
750.029968 0.070000
799.871033 0.060000
849.759949 0.053000
899.709961 0.048000


================================================
FILE: Asset/SPD/metals/CuO.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for CuO
# ;  
# ;  Concatenation of:
# ;  
# ;  CuO_llnl_cxro + CuO_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
350.028015 2.240000
399.935028 2.340000
449.854980 2.450000
499.919006 2.540000
549.799988 2.580000
599.806030 2.650000
649.789978 2.720000
700.056030 2.880000
750.029968 2.970000
799.871033 2.940000
849.759949 2.810000
899.709961 2.740000


================================================
FILE: Asset/SPD/metals/CuO.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for CuO
# ;  
# ;  Concatenation of:
# ;  
# ;  CuO_llnl_cxro + CuO_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
350.028015 1.030000
399.935028 0.870000
449.854980 0.770000
499.919006 0.680000
549.799988 0.590000
599.806030 0.500000
649.789978 0.400000
700.056030 0.310000
750.029968 0.220000
799.871033 0.110000
849.759949 0.040000
899.709961 0.030000


================================================
FILE: Asset/SPD/metals/Hg.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Hg
# ;  
# ;  Concatenation of:
# ;
# ;  Hg_llnl_cxro + Hg_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 0.542000
326.263000 0.589000
344.389008 0.644000
364.647003 0.713000
387.437988 0.798000
413.266998 0.898000
442.785980 1.027000
476.846008 1.186000
516.583008 1.384000
563.545044 1.620000
619.900024 1.910000
688.778015 2.284000
774.875000 2.746000
885.570984 3.324000


================================================
FILE: Asset/SPD/metals/Hg.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Hg
# ;  
# ;  Concatenation of:
# ;
# ;  Hg_llnl_cxro + Hg_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.502000
326.263000 2.665000
344.389008 2.860000
364.647003 3.074000
387.437988 3.294000
413.266998 3.538000
442.785980 3.802000
476.846008 4.090000
516.583008 4.407000
563.545044 4.751000
619.900024 5.150000
688.778015 5.582000
774.875000 6.054000
885.570984 6.558000


================================================
FILE: Asset/SPD/metals/HgTe.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for HgTe
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
300.921997 2.481000
302.243011 2.480000
303.575012 2.479000
304.919006 2.478000
306.274994 2.476000
307.643005 2.475000
309.023010 2.474000
310.415985 2.473000
311.821014 2.471000
313.238983 2.470000
314.670013 2.470000
316.113983 2.469000
317.571991 2.468000
319.042999 2.468000
320.610016 2.467000
322.110016 2.467000
323.623016 2.467000
325.151001 2.467000
326.692993 2.467000
328.250000 2.466000
329.821991 2.467000
331.409027 2.467000
333.011017 2.467000
334.628998 2.467000
336.263000 2.468000
337.912018 2.469000
339.578003 2.470000
341.261017 2.470000
343.055023 2.472000
344.772003 2.473000
346.506012 2.474000
348.258026 2.476000
350.028015 2.478000
351.816010 2.480000
353.622009 2.481000
355.446991 2.484000
357.290985 2.487000
359.154022 2.489000
361.037018 2.492000
362.938995 2.495000
364.862030 2.499000
366.805023 2.502000
368.878021 2.506000
370.864990 2.510000
372.872009 2.515000
374.902008 2.520000
376.953003 2.525000
379.028015 2.530000
381.125000 2.536000
383.246002 2.542000
385.389984 2.548000
387.559021 2.555000
389.752014 2.563000
391.970001 2.570000
394.212982 2.578000
396.482025 2.587000
398.906006 2.596000
401.230011 2.606000
403.581024 2.616000
405.959015 2.627000
408.365997 2.639000
410.802002 2.651000
413.266998 2.664000
415.760986 2.678000
418.285980 2.694000
420.842010 2.710000
423.429016 2.727000
426.048004 2.746000
428.700012 2.768000
431.535004 2.790000
434.256012 2.816000
437.010986 2.844000
439.800995 2.874000
442.627991 2.908000
445.489990 2.945000
448.391022 2.983000
451.329010 3.020000
454.306000 3.056000
457.322021 3.088000
460.378998 3.115000
463.477020 3.138000
466.616028 3.159000
469.799042 3.175000
473.206024 3.190000
476.479980 3.203000
479.799042 3.214000
483.164032 3.223000
486.577972 3.231000
490.040009 3.239000
493.550995 3.245000
497.113007 3.252000
500.727020 3.259000
504.394012 3.265000
508.114990 3.272000
511.891022 3.279000
515.724060 3.287000
519.614014 3.294000
523.785034 3.303000
527.799011 3.313000
531.875000 3.324000
536.014038 3.335000
540.218018 3.349000
544.487976 3.364000
548.827026 3.382000
553.235046 3.402000
557.715027 3.425000
562.268005 3.454000
566.895020 3.488000
571.600037 3.532000
576.382996 3.586000
581.247009 3.650000
586.471008 3.719000
591.507996 3.785000
596.631042 3.838000
601.845032 3.876000
607.150024 3.901000
612.549011 3.917000
618.046021 3.925000
623.642029 3.929000
629.340027 3.929000
635.143005 3.924000
641.054993 3.919000
647.077026 3.911000
653.214050 3.903000
659.468018 3.892000
666.200989 3.882000
672.708008 3.870000
679.341980 3.860000
686.110046 3.848000
693.013000 3.837000
700.056030 3.826000
707.245056 3.815000
714.581970 3.805000
722.072998 3.795000
729.723022 3.786000
737.537048 3.776000
745.520020 3.767000
753.677979 3.756000
762.016052 3.747000
771.020020 3.738000
779.747986 3.729000
788.677002 3.719000
797.812012 3.711000
807.161011 3.702000
816.733032 3.691000
826.533020 3.685000


================================================
FILE: Asset/SPD/metals/HgTe.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for HgTe
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
300.921997 1.782000
302.243011 1.771000
303.575012 1.761000
304.919006 1.752000
306.274994 1.744000
307.643005 1.736000
309.023010 1.729000
310.415985 1.722000
311.821014 1.716000
313.238983 1.711000
314.670013 1.706000
316.113983 1.701000
317.571991 1.697000
319.042999 1.693000
320.610016 1.690000
322.110016 1.687000
323.623016 1.684000
325.151001 1.681000
326.692993 1.679000
328.250000 1.677000
329.821991 1.675000
331.409027 1.674000
333.011017 1.673000
334.628998 1.672000
336.263000 1.672000
337.912018 1.671000
339.578003 1.671000
341.261017 1.671000
343.055023 1.672000
344.772003 1.673000
346.506012 1.674000
348.258026 1.675000
350.028015 1.677000
351.816010 1.679000
353.622009 1.681000
355.446991 1.683000
357.290985 1.686000
359.154022 1.689000
361.037018 1.692000
362.938995 1.696000
364.862030 1.699000
366.805023 1.703000
368.878021 1.707000
370.864990 1.712000
372.872009 1.716000
374.902008 1.722000
376.953003 1.727000
379.028015 1.732000
381.125000 1.738000
383.246002 1.743000
385.389984 1.750000
387.559021 1.756000
389.752014 1.763000
391.970001 1.770000
394.212982 1.777000
396.482025 1.784000
398.906006 1.792000
401.230011 1.800000
403.581024 1.808000
405.959015 1.816000
408.365997 1.825000
410.802002 1.834000
413.266998 1.844000
415.760986 1.853000
418.285980 1.863000
420.842010 1.873000
423.429016 1.883000
426.048004 1.893000
428.700012 1.904000
431.535004 1.914000
434.256012 1.924000
437.010986 1.933000
439.800995 1.940000
442.627991 1.945000
445.489990 1.946000
448.391022 1.942000
451.329010 1.932000
454.306000 1.917000
457.322021 1.898000
460.378998 1.877000
463.477020 1.856000
466.616028 1.833000
469.799042 1.812000
473.206024 1.791000
476.479980 1.771000
479.799042 1.753000
483.164032 1.736000
486.577972 1.721000
490.040009 1.707000
493.550995 1.695000
497.113007 1.683000
500.727020 1.674000
504.394012 1.665000
508.114990 1.658000
511.891022 1.653000
515.724060 1.647000
519.614014 1.644000
523.785034 1.641000
527.799011 1.641000
531.875000 1.640000
536.014038 1.642000
540.218018 1.645000
544.487976 1.649000
548.827026 1.653000
553.235046 1.660000
557.715027 1.668000
562.268005 1.677000
566.895020 1.687000
571.600037 1.696000
576.382996 1.700000
581.247009 1.694000
586.471008 1.670000
591.507996 1.626000
596.631042 1.569000
601.845032 1.507000
607.150024 1.443000
612.549011 1.382000
618.046021 1.325000
623.642029 1.272000
629.340027 1.222000
635.143005 1.176000
641.054993 1.134000
647.077026 1.094000
653.214050 1.058000
659.468018 1.024000
666.200989 0.992300
672.708008 0.964200
679.341980 0.935800
686.110046 0.910700
693.013000 0.886300
700.056030 0.863300
707.245056 0.841900
714.581970 0.822600
722.072998 0.802400
729.723022 0.782800
737.537048 0.764400
745.520020 0.747400
753.677979 0.735100
762.016052 0.722500
771.020020 0.709700
779.747986 0.695700
788.677002 0.686400
797.812012 0.671600
807.161011 0.660000
816.733032 0.655200
826.533020 0.638200


================================================
FILE: Asset/SPD/metals/Ir.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Ir
# ;  
# ;  Concatenation of:
# ;
# ;  Ir_llnl_cxro + Ir_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 1.620000
309.950012 1.640000
317.897003 1.640000
326.263000 1.610000
335.081024 1.570000
344.389008 1.520000
354.229004 1.500000
364.647003 1.530000
375.696991 1.570000
387.437988 1.620000
399.935028 1.680000
413.266998 1.730000
427.516998 1.770000
442.785980 1.810000
459.185028 1.850000
476.846008 1.910000
495.920013 1.980000
516.583008 2.070000
539.044006 2.180000
563.545044 2.290000
590.381042 2.400000
619.900024 2.500000
652.526001 2.570000
688.778015 2.640000
729.294006 2.690000
774.875000 2.680000
826.533020 2.650000
885.570984 2.720000


================================================
FILE: Asset/SPD/metals/Ir.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Ir
# ;  
# ;  Concatenation of:
# ;
# ;  Ir_llnl_cxro + Ir_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 2.700000
309.950012 2.680000
317.897003 2.670000
326.263000 2.690000
335.081024 2.720000
344.389008 2.810000
354.229004 2.930000
364.647003 3.050000
375.696991 3.150000
387.437988 3.260000
399.935028 3.350000
413.266998 3.430000
427.516998 3.510000
442.785980 3.610000
459.185028 3.730000
476.846008 3.860000
495.920013 4.000000
516.583008 4.140000
539.044006 4.260000
563.545044 4.380000
590.381042 4.480000
619.900024 4.570000
652.526001 4.680000
688.778015 4.810000
729.294006 4.920000
774.875000 5.080000
826.533020 5.390000
885.570984 5.740000


================================================
FILE: Asset/SPD/metals/K.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for polycrystalline K
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
304.993988 0.380000
309.950012 0.340000
312.291992 0.287000
334.178009 0.089000
364.647003 0.052000
405.162994 0.041000
420.270996 0.041000
439.645020 0.043000
469.621002 0.043000
506.041016 0.046000
546.166992 0.049000
598.937012 0.053000
662.995056 0.050000
751.393982 0.044000
860.971985 0.040000


================================================
FILE: Asset/SPD/metals/K.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for polycrystalline K
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
304.993988 0.070000
309.950012 0.080000
312.291992 0.091000
334.178009 0.288000
364.647003 0.549000
405.162994 0.799000
420.270996 0.898000
439.645020 1.020000
469.621002 1.140000
506.041016 1.280000
546.166992 1.430000
598.937012 1.620000
662.995056 1.840000
751.393982 2.190000
860.971985 2.560000


================================================
FILE: Asset/SPD/metals/KBr.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for cubic KBr
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
310.027008 1.638860
320.031006 1.630710
329.997009 1.623570
339.951019 1.617270
350.028015 1.611670
359.988007 1.606680
369.979004 1.602200
379.957001 1.598160
389.997009 1.594500
399.935028 1.591170
419.985992 1.585370
439.957001 1.580480
460.037018 1.576320
479.985016 1.572740
499.919006 1.569640
520.049988 1.566940
539.983032 1.564560
559.981995 1.562470
579.888000 1.560600
600.097046 1.558940
619.900024 1.557440
640.062012 1.556100
659.819031 1.554880
680.088013 1.553780
700.056030 1.552780
719.976990 1.551860
740.179016 1.551020
760.147034 1.550250
779.747986 1.549540
799.871033 1.548880
819.974060 1.548280
839.973083 1.547720
859.778015 1.547200
879.915039 1.546710
899.709961 1.546260


================================================
FILE: Asset/SPD/metals/KBr.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for cubic KBr
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
310.027008 0.000000
320.031006 0.000000
329.997009 0.000000
339.951019 0.000000
350.028015 0.000000
359.988007 0.000000
369.979004 0.000000
379.957001 0.000000
389.997009 0.000000
399.935028 0.000000
419.985992 0.000000
439.957001 0.000000
460.037018 0.000000
479.985016 0.000000
499.919006 0.000000
520.049988 0.000000
539.983032 0.000000
559.981995 0.000000
579.888000 0.000000
600.097046 0.000000
619.900024 0.000000
640.062012 0.000000
659.819031 0.000000
680.088013 0.000000
700.056030 0.000000
719.976990 0.000000
740.179016 0.000000
760.147034 0.000000
779.747986 0.000000
799.871033 0.000000
819.974060 0.000000
839.973083 0.000000
859.778015 0.000000
879.915039 0.000000
899.709961 0.000000


================================================
FILE: Asset/SPD/metals/KCl.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for KCl
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1985.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
310.027008 1.540050
320.031006 1.535180
329.997009 1.530870
339.951019 1.527030
350.028015 1.523580
359.988007 1.520490
369.979004 1.517690
379.957001 1.515150
389.997009 1.512830
399.935028 1.510720
419.985992 1.507010
439.957001 1.503860
460.037018 1.501150
479.985016 1.498820
499.919006 1.496790
520.049988 1.495010
539.983032 1.493440
559.981995 1.492050
579.888000 1.490810
600.097046 1.489690
619.900024 1.488690
640.062012 1.487790
659.819031 1.486970
680.088013 1.486230
700.056030 1.485550
719.976990 1.484930
740.179016 1.484360
760.147034 1.483840
779.747986 1.483360
799.871033 1.482910
819.974060 1.482500
839.973083 1.482120
859.778015 1.481760
879.915039 1.481430
899.709961 1.481110


================================================
FILE: Asset/SPD/metals/KCl.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for KCl
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1985.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
310.027008 0.000000
320.031006 0.000000
329.997009 0.000000
339.951019 0.000000
350.028015 0.000000
359.988007 0.000000
369.979004 0.000000
379.957001 0.000000
389.997009 0.000000
399.935028 0.000000
419.985992 0.000000
439.957001 0.000000
460.037018 0.000000
479.985016 0.000000
499.919006 0.000000
520.049988 0.000000
539.983032 0.000000
559.981995 0.000000
579.888000 0.000000
600.097046 0.000000
619.900024 0.000000
640.062012 0.000000
659.819031 0.000000
680.088013 0.000000
700.056030 0.000000
719.976990 0.000000
740.179016 0.000000
760.147034 0.000000
779.747986 0.000000
799.871033 0.000000
819.974060 0.000000
839.973083 0.000000
859.778015 0.000000
879.915039 0.000000
899.709961 0.000000


================================================
FILE: Asset/SPD/metals/Li.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Li
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
306.123016 0.346000
330.613007 0.345000
359.362030 0.334000
393.587006 0.304000
435.018036 0.247000
486.196014 0.217000
551.022034 0.206000
635.795044 0.221000
751.393982 0.265000


================================================
FILE: Asset/SPD/metals/Li.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Li
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
306.123016 1.210000
330.613007 1.320000
359.362030 1.450000
393.587006 1.600000
435.018036 1.820000
486.196014 2.110000
551.022034 2.480000
635.795044 2.940000
751.393982 3.550000


================================================
FILE: Asset/SPD/metals/MgO.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for MgO
# ;  
# ;  Concatenation of:
# ;
# ;  MgO_llnl_cxro + MgO_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 1.798000
330.613007 1.785000
351.118988 1.776800
355.549011 1.775500
360.932007 1.773200
361.141998 1.773180
364.968994 1.771860
382.065002 1.766800
386.712006 1.765500
393.337982 1.763800
404.634003 1.761040
430.935028 1.755700
435.781982 1.754710
457.829010 1.751200
477.949036 1.748300
486.004974 1.747110
487.918030 1.746900
499.919006 1.745400
502.350006 1.745300
508.531982 1.744460
514.440002 1.743900
546.166992 1.740770
589.258972 1.737370
632.874023 1.734600
643.718018 1.734000
656.325989 1.733350
667.635986 1.732770
690.695984 1.731910
706.439026 1.731010
767.677979 1.728720


================================================
FILE: Asset/SPD/metals/MgO.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for MgO
# ;  
# ;  Concatenation of:
# ;
# ;  MgO_llnl_cxro + MgO_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 0.000000
330.613007 0.000000
351.118988 0.000000
355.549011 0.000001
360.932007 0.000001
361.141998 0.000001
364.968994 0.000000
382.065002 0.000000
386.712006 0.000000
393.337982 0.000000
404.634003 0.000000
430.935028 0.000000
435.781982 0.000000
457.829010 0.000000
477.949036 0.000000
486.004974 0.000000
487.918030 0.000000
499.919006 0.000000
502.350006 0.000000
508.531982 0.000000
514.440002 0.000000
546.166992 0.000000
589.258972 0.000000
632.874023 0.000000
643.718018 0.000000
656.325989 0.000000
667.635986 0.000000
690.695984 0.000000
706.439026 0.000000
767.677979 0.000000


================================================
FILE: Asset/SPD/metals/Mo.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for 
# ;  
# ;  Concatenation of:
# ;
# ;  Mo_llnl_cxro + Mo_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 2.910000
309.950012 3.010000
317.897003 3.040000
326.263000 3.040000
335.081024 3.040000
344.389008 3.050000
354.229004 3.060000
364.647003 3.060000
375.696991 3.060000
387.437988 3.050000
399.935028 3.030000
413.266998 3.040000
427.516998 3.050000
442.785980 3.080000
459.185028 3.130000
476.846008 3.220000
495.920013 3.360000
516.583008 3.590000
539.044006 3.790000
563.545044 3.760000
590.381042 3.680000
619.900024 3.680000
652.526001 3.740000
688.778015 3.810000
729.294006 3.840000
774.875000 3.770000
826.533020 3.530000
885.570984 3.150000


================================================
FILE: Asset/SPD/metals/Mo.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for 
# ;  
# ;  Concatenation of:
# ;
# ;  Mo_llnl_cxro + Mo_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 3.670000
309.950012 3.510000
317.897003 3.400000
326.263000 3.310000
335.081024 3.270000
344.389008 3.240000
354.229004 3.210000
364.647003 3.190000
375.696991 3.180000
387.437988 3.180000
399.935028 3.220000
413.266998 3.270000
427.516998 3.330000
442.785980 3.420000
459.185028 3.510000
476.846008 3.610000
495.920013 3.730000
516.583008 3.780000
539.044006 3.610000
563.545044 3.410000
590.381042 3.450000
619.900024 3.520000
652.526001 3.580000
688.778015 3.580000
729.294006 3.510000
774.875000 3.410000
826.533020 3.300000
885.570984 3.400000


================================================
FILE: Asset/SPD/metals/NaCl.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for NaCl
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1985.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
319.947998 1.595060
339.951019 1.585900
359.988007 1.578520
379.957001 1.572480
399.935028 1.567460
419.985992 1.563240
439.957001 1.559650
460.037018 1.556570
479.985016 1.553900
499.919006 1.551570
520.049988 1.549530
539.983032 1.547730
559.981995 1.546130
579.888000 1.544710
600.097046 1.543430
619.900024 1.542280
640.062012 1.541240
659.819031 1.540300
680.088013 1.539440
700.056030 1.538650
719.976990 1.537940
740.179016 1.537280
760.147034 1.536670
779.747986 1.536110
799.871033 1.535600
819.974060 1.535120
839.973083 1.534670
859.778015 1.534260
879.915039 1.533870
899.709961 1.533510


================================================
FILE: Asset/SPD/metals/NaCl.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for NaCl
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1985.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
319.947998 0.000000
339.951019 0.000000
359.988007 0.000000
379.957001 0.000000
399.935028 0.000000
419.985992 0.000000
439.957001 0.000000
460.037018 0.000000
479.985016 0.000000
499.919006 0.000000
520.049988 0.000000
539.983032 0.000000
559.981995 0.000000
579.888000 0.000000
600.097046 0.000000
619.900024 0.000000
640.062012 0.000000
659.819031 0.000000
680.088013 0.000000
700.056030 0.000000
719.976990 0.000000
740.179016 0.000000
760.147034 0.000000
779.747986 0.000000
799.871033 0.000000
819.974060 0.000000
839.973083 0.000000
859.778015 0.000000
879.915039 0.000000
899.709961 0.000000


================================================
FILE: Asset/SPD/metals/Nb.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Nb
# ;  
# ;  Concatenation of:
# ;
# ;  Nb_llnl_cxro + Nb_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.640000
317.897003 2.620000
326.263000 2.590000
335.081024 2.560000
344.389008 2.520000
354.229004 2.480000
364.647003 2.460000
375.696991 2.440000
387.437988 2.450000
399.935028 2.480000
413.266998 2.510000
435.018036 2.580000
450.835999 2.660000
467.849030 2.740000
486.196014 2.830000
506.041016 2.890000
527.575012 2.920000
551.022034 2.930000
576.651001 2.920000
604.781006 2.890000
635.795044 2.820000
670.162048 2.690000
708.456970 2.540000
751.393982 2.360000
799.871033 2.150000
855.033997 1.950000


================================================
FILE: Asset/SPD/metals/Nb.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Nb
# ;  
# ;  Concatenation of:
# ;
# ;  Nb_llnl_cxro + Nb_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.330000
317.897003 2.290000
326.263000 2.280000
335.081024 2.270000
344.389008 2.290000
354.229004 2.330000
364.647003 2.380000
375.696991 2.450000
387.437988 2.530000
399.935028 2.600000
413.266998 2.680000
435.018036 2.800000
450.835999 2.860000
467.849030 2.900000
486.196014 2.920000
506.041016 2.900000
527.575012 2.880000
551.022034 2.870000
576.651001 2.870000
604.781006 2.870000
635.795044 2.860000
670.162048 2.890000
708.456970 2.990000
751.393982 3.130000
799.871033 3.370000
855.033997 3.680000


================================================
FILE: Asset/SPD/metals/Rh.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Rh
# ;  
# ;  Concatenation of:
# ;
# ;  Rh_llnl_cxro + Rh_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 0.840000
309.950012 0.860000
317.897003 0.880000
326.263000 0.910000
335.081024 0.950000
344.389008 0.990000
354.229004 1.040000
364.647003 1.110000
375.696991 1.200000
387.437988 1.300000
399.935028 1.410000
413.266998 1.530000
427.516998 1.630000
459.185028 1.800000
476.846008 1.850000
495.920013 1.880000
516.583008 1.900000
539.044006 1.940000
563.545044 2.000000
590.381042 2.050000
619.900024 2.120000
652.526001 2.200000
688.778015 2.300000
729.294006 2.420000
774.875000 2.600000
826.533020 2.780000
885.570984 3.010000


================================================
FILE: Asset/SPD/metals/Rh.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Rh
# ;  
# ;  Concatenation of:
# ;
# ;  Rh_llnl_cxro + Rh_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 3.030000
309.950012 3.120000
317.897003 3.230000
326.263000 3.340000
335.081024 3.450000
344.389008 3.580000
354.229004 3.710000
364.647003 3.840000
375.696991 3.970000
387.437988 4.090000
399.935028 4.200000
413.266998 4.290000
427.516998 4.360000
459.185028 4.490000
476.846008 4.550000
495.920013 4.650000
516.583008 4.780000
539.044006 4.940000
563.545044 5.110000
590.381042 5.300000
619.900024 5.510000
652.526001 5.760000
688.778015 6.020000
729.294006 6.330000
774.875000 6.640000
826.533020 6.970000
885.570984 7.310000


================================================
FILE: Asset/SPD/metals/Se-e.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Se, extraordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
344.389008 3.390000
364.647003 3.690000
387.437988 3.920000
413.266998 4.440000
442.785980 4.590000
476.846008 4.400000
516.583008 4.280000
563.545044 4.490000
619.900024 4.790000
688.778015 4.460000


================================================
FILE: Asset/SPD/metals/Se-e.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Se, extraordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
344.389008 3.010000
364.647003 2.760000
387.437988 2.590000
413.266998 2.290000
442.785980 1.700000
476.846008 1.320000
516.583008 1.210000
563.545044 1.190000
619.900024 0.760000
688.778015 0.022000


================================================
FILE: Asset/SPD/metals/Se.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Se, ordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.670000
326.263000 2.840000
344.389008 3.060000
364.647003 3.220000
387.437988 3.350000
413.266998 3.300000
442.785980 3.120000
476.846008 3.000000
516.583008 2.930000
563.545044 3.070000
619.900024 3.380000
688.778015 3.320000


================================================
FILE: Asset/SPD/metals/Se.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Se, ordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 1.990000
326.263000 1.660000
344.389008 1.470000
364.647003 1.240000
387.437988 1.010000
413.266998 0.700000
442.785980 0.580000
476.846008 0.530000
516.583008 0.610000
563.545044 0.730000
619.900024 0.650000
688.778015 0.110000


================================================
FILE: Asset/SPD/metals/SiC.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for crystalline SiC
# ;  
# ;  Concatenation of:
# ;
# ;  SiC_llnl_cxro + SiC_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.850000
317.897003 2.923000
326.263000 2.899000
335.081024 2.877000
344.389008 2.856000
354.229004 2.836000
364.647003 2.817000
375.696991 2.799000
387.437988 2.781000
399.935028 2.765000
413.266998 2.750000
435.781982 2.730500
466.968018 2.707400
495.920013 2.684000
497.912018 2.687000
515.080994 2.678900
546.166992 2.663100
567.934021 2.655700
577.995056 2.651100
588.979004 2.648800
589.539001 2.647500
615.897034 2.641100
619.900024 2.634000
656.325989 2.629600
691.080994 2.624300
826.533020 2.598000


================================================
FILE: Asset/SPD/metals/SiC.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for crystalline SiC
# ;  
# ;  Concatenation of:
# ;
# ;  SiC_llnl_cxro + SiC_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 0.174000
317.897003 0.007650
326.263000 0.005980
335.081024 0.004930
344.389008 0.003750
354.229004 0.002890
364.647003 0.002040
375.696991 0.001380
387.437988 0.000839
399.935028 0.000191
413.266998 0.000044
435.781982 0.000000
466.968018 0.000000
495.920013 0.000012
497.912018 0.000000
515.080994 0.000000
546.166992 0.000000
567.934021 0.000000
577.995056 0.000000
588.979004 0.000000
589.539001 0.000000
615.897034 0.000000
619.900024 0.000000
656.325989 0.000000
691.080994 0.000000
826.533020 0.000000


================================================
FILE: Asset/SPD/metals/SiO.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for SiO
# ;  
# ;  Concatenation of:
# ;
# ;  SiO_llnl_cxro + SiO_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.141000
326.263000 2.157000
344.389008 2.162000
364.647003 2.160000
387.437988 2.144000
413.266998 2.116000
442.785980 2.085000
476.846008 2.053000
516.583008 2.021000
563.545044 1.994000
619.900024 1.969000
688.778015 1.948000
774.875000 1.929000
885.570984 1.913000


================================================
FILE: Asset/SPD/metals/SiO.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for SiO
# ;  
# ;  Concatenation of:
# ;
# ;  SiO_llnl_cxro + SiO_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 0.400600
326.263000 0.345300
344.389008 0.287200
364.647003 0.228700
387.437988 0.170600
413.266998 0.121100
442.785980 0.083740
476.846008 0.055440
516.583008 0.035330
563.545044 0.021530
619.900024 0.011750
688.778015 0.005230
774.875000 0.001510
885.570984 0.000000


================================================
FILE: Asset/SPD/metals/SnTe.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for SnTe
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
311.586029 0.967000
332.118988 1.007000
361.037018 1.103000
390.242004 1.228000
414.372040 1.364000
453.308990 1.551000
498.312012 1.702000
533.476990 1.813000
548.099060 1.878000
550.533020 1.989000
552.987976 2.135000
558.216980 2.442000
566.119019 2.719000
582.339050 2.991000
605.963013 3.273000
621.454041 3.479000
648.091980 3.701000
681.208984 3.912000
748.671021 4.285000
804.020996 4.541000
867.478027 4.803000


================================================
FILE: Asset/SPD/metals/SnTe.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for SnTe
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
311.586029 0.000000
332.118988 0.000000
361.037018 0.000000
390.242004 0.000000
414.372040 0.000000
453.308990 0.000000
498.312012 0.000000
533.476990 0.000000
548.099060 0.000000
550.533020 0.000000
552.987976 0.000000
558.216980 0.000000
566.119019 0.000000
582.339050 0.000000
605.963013 0.000000
621.454041 0.000000
648.091980 0.000000
681.208984 0.000000
748.671021 0.000000
804.020996 0.000000
867.478027 0.000000


================================================
FILE: Asset/SPD/metals/Ta.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Ta
# ;  
# ;  Concatenation of:
# ;
# ;  Ta_llnl_cxro + Ta_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.360000
326.263000 2.400000
344.389008 2.490000
364.647003 2.610000
387.437988 2.730000
413.266998 2.810000
427.516998 2.840000
442.785980 2.850000
459.185028 2.840000
476.846008 2.800000
495.920013 2.750000
516.583008 2.680000
539.044006 2.560000
563.545044 2.360000
590.381042 2.100000
619.900024 1.830000
652.526001 1.570000
688.778015 1.350000
729.294006 1.240000
774.875000 1.150000
826.533020 1.090000
885.570984 1.040000


================================================
FILE: Asset/SPD/metals/Ta.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for Ta
# ;  
# ;  Concatenation of:
# ;
# ;  Ta_llnl_cxro + Ta_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.140000
326.263000 2.220000
344.389008 2.300000
364.647003 2.330000
387.437988 2.310000
413.266998 2.240000
427.516998 2.200000
442.785980 2.140000
459.185028 2.080000
476.846008 2.020000
495.920013 1.980000
516.583008 1.920000
539.044006 1.860000
563.545044 1.810000
590.381042 1.840000
619.900024 1.990000
652.526001 2.240000
688.778015 2.600000
729.294006 2.950000
774.875000 3.330000
826.533020 3.730000
885.570984 4.150000


================================================
FILE: Asset/SPD/metals/Te-e.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for trigonal Te, extraordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 1.330000
330.613007 1.440000
354.229004 1.690000
381.477020 1.920000
403.975006 2.220000
413.266998 2.300000
416.599030 2.350000
430.037994 2.540000
442.785980 2.730000
444.373016 2.760000
459.696014 2.980000
476.114014 3.210000
476.846008 3.250000
489.266022 3.460000
498.512024 3.630000
507.906982 3.810000
516.583008 3.940000
517.877991 3.990000
528.024048 4.200000
538.809021 4.390000
549.799988 4.650000
561.249023 4.910000
563.545044 4.940000
573.450989 5.170000
599.226990 5.760000
612.851990 6.000000
619.900024 4.670000
627.429016 6.210000
642.382996 6.400000
658.416992 6.580000
674.904968 6.770000
688.778015 6.890000
692.625977 6.850000
710.895020 6.860000
730.583008 6.800000
750.939026 6.780000
772.943054 6.740000
774.875000 6.750000
796.275024 6.730000
820.516052 6.810000
846.858032 6.950000
874.330017 7.140000
885.570984 7.110000


================================================
FILE: Asset/SPD/metals/Te-e.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for trigonal Te, extraordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.640000
330.613007 3.060000
354.229004 3.440000
381.477020 3.780000
403.975006 3.960000
413.266998 4.160000
416.599030 4.150000
430.037994 4.270000
442.785980 4.420000
444.373016 4.390000
459.696014 4.520000
476.114014 4.710000
476.846008 4.770000
489.266022 4.850000
498.512024 4.930000
507.906982 5.010000
516.583008 5.080000
517.877991 5.080000
528.024048 5.160000
538.809021 5.200000
549.799988 5.210000
561.249023 5.200000
563.545044 5.160000
573.450989 5.160000
599.226990 4.920000
612.851990 4.770000
619.900024 4.670000
627.429016 4.600000
642.382996 4.360000
658.416992 4.100000
674.904968 3.860000
688.778015 3.700000
692.625977 3.650000
710.895020 3.470000
730.583008 3.180000
750.939026 3.030000
772.943054 2.930000
774.875000 2.910000
796.275024 2.890000
820.516052 2.860000
846.858032 2.800000
874.330017 2.560000
885.570984 2.460000


================================================
FILE: Asset/SPD/metals/Te.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for trigonal Te,ordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 1.320000
330.613007 1.500000
354.229004 1.720000
381.477020 2.020000
403.975006 2.370000
413.266998 2.510000
416.599030 2.560000
430.037994 2.770000
442.785980 3.030000
444.373016 3.010000
459.696014 3.270000
476.114014 3.550000
476.846008 3.570000
489.266022 3.760000
498.512024 3.910000
507.906982 4.070000
516.583008 4.240000
517.877991 4.250000
528.024048 4.430000
538.809021 4.620000
549.799988 4.810000
561.249023 5.010000
563.545044 5.100000
573.450989 5.260000
599.226990 5.670000
612.851990 5.820000
619.900024 5.940000
627.429016 5.970000
642.382996 6.070000
658.416992 6.110000
674.904968 6.120000
688.778015 6.100000
692.625977 6.090000
710.895020 6.040000
730.583008 5.950000
750.939026 5.870000
772.943054 5.860000
774.875000 5.880000
796.275024 5.840000
820.516052 5.780000
846.858032 5.680000
874.330017 5.590000
885.570984 5.560000


================================================
FILE: Asset/SPD/metals/Te.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for trigonal Te,ordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.010000
330.613007 2.370000
354.229004 2.700000
381.477020 3.030000
403.975006 3.290000
413.266998 3.390000
416.599030 3.390000
430.037994 3.470000
442.785980 3.630000
444.373016 3.570000
459.696014 3.660000
476.114014 3.720000
476.846008 3.750000
489.266022 3.760000
498.512024 3.770000
507.906982 3.770000
516.583008 3.770000
517.877991 3.780000
528.024048 3.760000
538.809021 3.690000
549.799988 3.630000
561.249023 3.570000
563.545044 3.610000
573.450989 3.520000
599.226990 3.160000
612.851990 2.940000
619.900024 2.690000
627.429016 2.700000
642.382996 2.450000
658.416992 2.250000
674.904968 2.020000
688.778015 1.800000
692.625977 1.720000
710.895020 1.520000
730.583008 1.360000
750.939026 1.260000
772.943054 1.170000
774.875000 1.150000
796.275024 1.060000
820.516052 0.895000
846.858032 0.760000
874.330017 0.659000
885.570984 0.630000


================================================
FILE: Asset/SPD/metals/ThF4.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for polycrystalline ThF4
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 1.545000
319.947998 1.542000
329.997009 1.540000
340.044006 1.538000
349.929016 1.536000
359.988007 1.534000
369.979004 1.532000
379.957001 1.531000
389.997009 1.530000
399.935028 1.529000
409.987030 1.528000
419.985992 1.527000
430.037994 1.526000
435.781982 1.533000
439.957001 1.526000
450.018036 1.525000
460.037018 1.524000
469.977020 1.524000
479.985016 1.523000
490.040009 1.523000
499.919006 1.523000
509.996002 1.522000
520.049988 1.522000
539.983032 1.521000
545.927002 1.521000
559.981995 1.521000
579.888000 1.520000
600.097046 1.520000
619.900024 1.520000
640.062012 1.519000
659.819031 1.519000
700.056030 1.519000
739.737000 1.518000
779.747986 1.518000
799.871033 1.518000


================================================
FILE: Asset/SPD/metals/ThF4.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for polycrystalline ThF4
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids II', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1991.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 0.000000
319.947998 0.000000
329.997009 0.000000
340.044006 0.000000
349.929016 0.000000
359.988007 0.000000
369.979004 0.000000
379.957001 0.000000
389.997009 0.000000
399.935028 0.000000
409.987030 0.000000
419.985992 0.000000
430.037994 0.000000
435.781982 0.000000
439.957001 0.000000
450.018036 0.000000
460.037018 0.000000
469.977020 0.000000
479.985016 0.000000
490.040009 0.000000
499.919006 0.000000
509.996002 0.000000
520.049988 0.000000
539.983032 0.000000
545.927002 0.000000
559.981995 0.000000
579.888000 0.000000
600.097046 0.000000
619.900024 0.000000
640.062012 0.000000
659.819031 0.000000
700.056030 0.000000
739.737000 0.000000
779.747986 0.000000
799.871033 0.000000


================================================
FILE: Asset/SPD/metals/TiC.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for TiC
# ;  
# ;  Concatenation of:
# ;
# ;  TiC_llnl_cxro + TiC_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.300000
354.229004 2.570000
413.266998 2.780000
495.920013 2.950000
619.900024 3.050000
826.533020 3.510000


================================================
FILE: Asset/SPD/metals/TiC.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for TiC
# ;  
# ;  Concatenation of:
# ;
# ;  TiC_llnl_cxro + TiC_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.330000
354.229004 2.340000
413.266998 2.430000
495.920013 2.380000
619.900024 2.670000
826.533020 3.070000


================================================
FILE: Asset/SPD/metals/TiN.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for TiN
# ;  
# ;  Concatenation of:
# ;
# ;  TiN_llnl_cxro + TiN_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.270000
354.229004 2.140000
413.266998 1.740000
495.920013 1.200000
619.900024 1.320000
826.533020 1.820000


================================================
FILE: Asset/SPD/metals/TiN.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for TiN
# ;  
# ;  Concatenation of:
# ;
# ;  TiN_llnl_cxro + TiN_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 1.230000
354.229004 1.060000
413.266998 1.040000
495.920013 1.650000
619.900024 2.690000
826.533020 3.810000


================================================
FILE: Asset/SPD/metals/TiO2-e.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for tetragonal TiO2, extraordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1985.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
307.033020 3.420000
317.979004 4.000000
327.037994 3.870000
344.007019 4.300000
358.013000 3.380000
388.044006 2.880000
399.935028 3.000000
402.010010 3.000000
419.985992 2.910000
439.957001 2.840000
460.037018 2.790000
479.985016 2.750000
499.919006 2.710000
520.049988 2.680000
539.983032 2.660000
559.981995 2.640000
579.888000 2.620000
600.097046 2.600000
619.900024 2.590000
640.062012 2.580000
659.819031 2.570000
680.088013 2.560000
700.056030 2.550000
719.976990 2.540000
740.179016 2.540000
760.147034 2.530000
779.747986 2.520000
799.871033 2.520000
819.974060 2.520000
839.973083 2.510000
859.778015 2.510000
879.915039 2.500000
899.709961 2.500000


================================================
FILE: Asset/SPD/metals/TiO2-e.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for tetragonal TiO2, extraordinary ray
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1985.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
307.033020 1.610000
317.979004 1.790000
327.037994 0.810000
344.007019 0.000000
358.013000 0.117000
388.044006 0.000000
399.935028 0.000000
402.010010 0.008000
419.985992 0.000000
439.957001 0.000000
460.037018 0.000000
479.985016 0.000000
499.919006 0.000000
520.049988 0.000000
539.983032 0.000000
559.981995 0.000000
579.888000 0.000000
600.097046 0.000000
619.900024 0.000000
640.062012 0.000000
659.819031 0.000000
680.088013 0.000000
700.056030 0.000000
719.976990 0.000000
740.179016 0.000000
760.147034 0.000000
779.747986 0.000000
799.871033 0.000000
819.974060 0.000000
839.973083 0.000000
859.778015 0.000000
879.915039 0.000000
899.709961 0.000000


================================================
FILE: Asset/SPD/metals/TiO2.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for tetragonal TiO2, ordinary ray
# ;  
# ;  Concatenation of:
# ;
# ;  TiO2_llnl_cxro + TiO2_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
305.972015 3.840000
317.979004 5.380000
334.990997 4.220000
344.007019 4.360000
359.988007 3.870000
388.044006 3.490000
399.935028 3.400000
412.031006 3.240000
419.985992 3.290000
439.957001 3.200000
460.037018 3.130000
479.985016 3.080000
499.919006 3.030000
520.049988 3.000000
539.044006 2.950000
539.983032 2.970000
559.981995 2.940000
579.888000 2.920000
600.097046 2.900000
619.900024 2.880000
640.062012 2.870000
659.819031 2.850000
680.088013 2.840000
700.056030 2.830000
719.976990 2.820000
740.179016 2.810000
760.147034 2.810000
779.747986 2.800000
799.871033 2.790000
819.974060 2.790000
839.973083 2.780000
859.778015 2.780000
879.915039 2.770000
899.709961 2.770000


================================================
FILE: Asset/SPD/metals/TiO2.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for tetragonal TiO2, ordinary ray
# ;  
# ;  Concatenation of:
# ;
# ;  TiO2_llnl_cxro + TiO2_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
305.972015 1.950000
317.979004 2.180000
334.990997 0.788000
344.007019 0.000000
359.988007 0.251000
388.044006 0.000000
399.935028 0.000000
412.031006 0.022000
419.985992 0.000000
439.957001 0.000000
460.037018 0.000000
479.985016 0.000000
499.919006 0.000000
520.049988 0.000000
539.044006 0.000000
539.983032 0.000000
559.981995 0.000000
579.888000 0.000000
600.097046 0.000000
619.900024 0.000000
640.062012 0.000000
659.819031 0.000000
680.088013 0.000000
700.056030 0.000000
719.976990 0.000000
740.179016 0.000000
760.147034 0.000000
779.747986 0.000000
799.871033 0.000000
819.974060 0.000000
839.973083 0.000000
859.778015 0.000000
879.915039 0.000000
899.709961 0.000000


================================================
FILE: Asset/SPD/metals/VC.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for VC
# ;  
# ;  Concatenation of:
# ;
# ;  VC_llnl_cxro + VC_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.470000
354.229004 2.590000
413.266998 2.770000
495.920013 2.840000
619.900024 3.010000
826.533020 3.370000


================================================
FILE: Asset/SPD/metals/VC.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for VC
# ;  
# ;  Concatenation of:
# ;
# ;  VC_llnl_cxro + VC_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.150000
354.229004 2.120000
413.266998 2.160000
495.920013 2.210000
619.900024 2.510000
826.533020 2.880000


================================================
FILE: Asset/SPD/metals/VN.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for VN
# ;  
# ;  Concatenation of:
# ;
# ;  VN_llnl_cxro + VN_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 2.200000
354.229004 2.180000
413.266998 2.130000
495.920013 2.170000
619.900024 2.350000
826.533020 2.730000


================================================
FILE: Asset/SPD/metals/VN.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for VN
# ;  
# ;  Concatenation of:
# ;
# ;  VN_llnl_cxro + VN_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 1.540000
354.229004 1.580000
413.266998 1.700000
495.920013 1.980000
619.900024 2.470000
826.533020 2.920000


================================================
FILE: Asset/SPD/metals/W.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for W
# ;  
# ;  Concatenation of:
# ;
# ;  W_llnl_cxro + W_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 2.970000
309.950012 2.950000
313.873016 2.950000
317.897003 2.960000
322.026001 2.980000
326.263000 2.990000
330.613007 3.020000
335.081024 3.050000
339.670990 3.090000
344.389008 3.130000
349.238983 3.180000
354.229004 3.240000
359.362030 3.320000
364.647003 3.390000
370.089996 3.430000
375.696991 3.450000
381.477020 3.450000
387.437988 3.430000
393.587006 3.410000
399.935028 3.390000
406.492004 3.370000
413.266998 3.350000
420.270996 3.330000
427.516998 3.320000
435.018036 3.310000
442.785980 3.300000
450.835999 3.310000
459.185028 3.310000
467.849030 3.320000
476.846008 3.340000
486.196014 3.350000
495.920013 3.380000
506.041016 3.420000
516.583008 3.450000
527.575012 3.480000
539.044006 3.500000
551.022034 3.500000
563.545044 3.490000
576.651001 3.510000
590.381042 3.540000
604.781006 3.570000
619.900024 3.600000
635.795044 3.650000
652.526001 3.700000
670.162048 3.760000
688.778015 3.820000
708.456970 3.850000
729.294006 3.840000
751.393982 3.780000
774.875000 3.670000
799.871033 3.560000
826.533020 3.480000
855.033997 3.380000
885.570984 3.290000


================================================
FILE: Asset/SPD/metals/W.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for W
# ;  
# ;  Concatenation of:
# ;
# ;  W_llnl_cxro + W_palik
# ;
# ;    Lambda (A)            n            k
# ;-----------------------------------------
302.389984 2.370000
309.950012 2.430000
313.873016 2.460000
317.897003 2.500000
322.026001 2.530000
326.263000 2.560000
330.613007 2.600000
335.081024 2.620000
339.670990 2.650000
344.389008 2.670000
349.238983 2.690000
354.229004 2.700000
359.362030 2.700000
364.647003 2.660000
370.089996 2.600000
375.696991 2.550000
381.477020 2.490000
387.437988 2.450000
393.587006 2.430000
399.935028 2.410000
406.492004 2.420000
413.266998 2.420000
420.270996 2.430000
427.516998 2.450000
435.018036 2.470000
442.785980 2.490000
450.835999 2.530000
459.185028 2.550000
467.849030 2.590000
476.846008 2.620000
486.196014 2.640000
495.920013 2.680000
506.041016 2.710000
516.583008 2.720000
527.575012 2.720000
539.044006 2.720000
551.022034 2.730000
563.545044 2.750000
576.651001 2.810000
590.381042 2.840000
604.781006 2.860000
619.900024 2.890000
635.795044 2.920000
652.526001 2.940000
670.162048 2.950000
688.778015 2.910000
708.456970 2.860000
729.294006 2.780000
751.393982 2.720000
774.875000 2.680000
799.871033 2.730000
826.533020 2.790000
855.033997 2.850000
885.570984 2.960000


================================================
FILE: Asset/SPD/metals/a-C.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for amorphous carbon
# ;  
# ;  Concatenation of:
# ;
# ;  a-C_llnl_cxro + a-C_windt88 + a-C_palik
# ;  
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 1.840000
326.263000 1.900000
344.389008 1.940000
364.647003 2.000000
387.437988 2.060000
413.266998 2.110000
442.785980 2.170000
476.846008 2.240000
516.583008 2.300000
563.545044 2.380000
619.900024 2.430000
688.778015 2.430000
774.875000 2.330000
885.570984 2.240000


================================================
FILE: Asset/SPD/metals/a-C.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for amorphous carbon
# ;  
# ;  Concatenation of:
# ;
# ;  a-C_llnl_cxro + a-C_windt88 + a-C_palik
# ;  
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 0.808000
326.263000 0.910000
344.389008 0.920000
364.647003 0.920000
387.437988 0.910000
413.266998 0.900000
442.785980 0.890000
476.846008 0.880000
516.583008 0.870000
563.545044 0.820000
619.900024 0.750000
688.778015 0.700000
774.875000 0.710000
885.570984 0.800000


================================================
FILE: Asset/SPD/metals/a-SiH.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for a-Si:H, amorphous glow-discharge Si onto
# ;  400 C substrates, ~4 at.% H
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1985.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 3.360000
354.229004 4.590000
413.266998 5.430000
495.920013 5.250000
619.900024 4.710000
826.533020 4.130000


================================================
FILE: Asset/SPD/metals/a-SiH.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for a-Si:H, amorphous glow-discharge Si onto
# ;  400 C substrates, ~4 at.% H
# ; 
# ;   taken from:
# ;
# ;   'Handbook of Optical Constants of Solids', Ed. by Edward D. Palik,
# ;   Academic Press, Inc., 1985.
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
309.950012 3.920000
354.229004 3.380000
413.266998 2.190000
495.920013 0.992000
619.900024 0.217000
826.533020 0.000000


================================================
FILE: Asset/SPD/metals/d-C.eta.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for diamond
# ;  
# ;  Concatenation of:
# ;
# ;  d-C_llnl_cxro + d-C_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
346.700012 2.495400
361.037018 2.485400
404.634003 2.462600
467.795990 2.440800
486.120026 2.435400
508.552002 2.430600
546.047058 2.423500
588.979004 2.417500
643.818054 2.411100
656.257019 2.410400


================================================
FILE: Asset/SPD/metals/d-C.k.spd
================================================
# data from www.luxpop.com database
# ;  Optical constants for diamond
# ;  
# ;  Concatenation of:
# ;
# ;  d-C_llnl_cxro + d-C_palik
# ;   
# ;    Lambda (A)            n            k
# ;-----------------------------------------
346.700012 0.000000
361.037018 0.000000
404.634003 0.000000
467.795990 0.000000
486.120026 0.000000
508.552002 0.000000
546.047058 0.000000
588.979004 0.000000
643.818054 0.000000
656.257019 0.000000


================================================
FILE: Doc/Material.drawio
================================================
<mxfile host="65bd71144e">
    <diagram id="Oj6RUKoLF9Hl1Nya2uuC" name="第 1 页">
        <mxGraphModel dx="1064" dy="674" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
            <root>
                <mxCell id="0"/>
                <mxCell id="1" parent="0"/>
                <mxCell id="48" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Diffuse&lt;br&gt;&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="80" y="440" width="200" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="59" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="50" target="55">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="60" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="50" target="56">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="50" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Dielectric&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="80" y="520" width="200" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="51" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;ThinDielectric&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="80" y="600" width="200" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="61" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="53" target="57">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="62" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="53" target="58">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="53" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Conductor&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="80" y="680" width="200" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="54" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;ThinConductor&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="80" y="760" width="200" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="55" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Smooth Dielectric&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="400" y="480" width="240" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="56" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Rough Dielectric&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="400" y="560" width="240" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="57" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Smooth&amp;nbsp;&lt;/font&gt;&lt;span style=&quot;font-size: 24px;&quot;&gt;Conductor&lt;/span&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="400" y="640" width="240" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="58" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Rough&amp;nbsp;&lt;/font&gt;&lt;span style=&quot;font-size: 24px;&quot;&gt;Conductor&lt;/span&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="400" y="720" width="240" height="80" as="geometry"/>
                </mxCell>
            </root>
        </mxGraphModel>
    </diagram>
</mxfile>

================================================
FILE: Doc/RHI.drawio
================================================
<mxfile host="65bd71144e">
    <diagram id="qQwCbRc1wy9BN8YB_Oij" name="第 1 页">
        <mxGraphModel dx="1064" dy="674" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" background="none" math="0" shadow="0">
            <root>
                <mxCell id="0"/>
                <mxCell id="1" parent="0"/>
                <mxCell id="57" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;RHI&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="80" y="280" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="58" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Device&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="200" y="280" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="59" value="Vulkan" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;" vertex="1" parent="1">
                    <mxGeometry x="80" y="340" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="60" value="&lt;font style=&quot;font-size: 12px;&quot;&gt;VkInstance&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;" vertex="1" parent="1">
                    <mxGeometry x="200" y="340" width="80" height="30" as="geometry"/>
                </mxCell>
                <mxCell id="61" value="&lt;font style=&quot;font-size: 12px;&quot;&gt;VkDevice&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;" vertex="1" parent="1">
                    <mxGeometry x="280" y="340" width="80" height="30" as="geometry"/>
                </mxCell>
                <mxCell id="62" value="&lt;font style=&quot;font-size: 12px;&quot;&gt;VkPhysicalDevice&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;" vertex="1" parent="1">
                    <mxGeometry x="200" y="370" width="160" height="30" as="geometry"/>
                </mxCell>
                <mxCell id="63" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Texture&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="360" y="280" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="64" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;VkImage&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;" vertex="1" parent="1">
                    <mxGeometry x="360" y="340" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="65" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Buffer&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="480" y="280" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="66" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;VkBuffer&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;" vertex="1" parent="1">
                    <mxGeometry x="480" y="340" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="67" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Queue&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="600" y="280" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="68" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Descriptor&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="720" y="280" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="69" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Shader&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="880" y="280" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="70" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Sampler&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="1000" y="280" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="71" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Swapchain&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="1160" y="280" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="72" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Command&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="1320" y="280" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="73" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Render Target&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="1480" y="280" width="170" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="74" value="&lt;span style=&quot;font-size: 24px;&quot;&gt;Synchronization&lt;/span&gt;" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
                    <mxGeometry x="1650" y="280" width="190" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="75" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;VkQueue&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;" vertex="1" parent="1">
                    <mxGeometry x="600" y="340" width="120" height="60" as="geometry"/>
                </mxCell>
            </root>
        </mxGraphModel>
    </diagram>
</mxfile>

================================================
FILE: Doc/RenderGraph.drawio
================================================


================================================
FILE: Doc/Resource.drawio
================================================
<mxfile host="65bd71144e">
    <diagram id="B0Vu0QsbAyju_w0uTxer" name="第 1 页">
        <mxGraphModel dx="2317" dy="944" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" background="none" math="0" shadow="0">
            <root>
                <mxCell id="0"/>
                <mxCell id="1" parent="0"/>
                <mxCell id="36" value="" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;fillColor=#647687;fontColor=#ffffff;strokeColor=#314354;" parent="1" vertex="1">
                    <mxGeometry x="-460" y="120" width="140" height="340" as="geometry"/>
                </mxCell>
                <mxCell id="12" value="" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;fillColor=#647687;fontColor=#ffffff;strokeColor=#314354;" parent="1" vertex="1">
                    <mxGeometry x="640" y="120" width="220" height="310" as="geometry"/>
                </mxCell>
                <mxCell id="21" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="2" target="5" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="2" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Mesh&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#0050ef;fontColor=#ffffff;strokeColor=#001DBC;" parent="1" vertex="1">
                    <mxGeometry x="320" y="10" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="22" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="3" target="5" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="3" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Skinned Mesh&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#0050ef;fontColor=#ffffff;strokeColor=#001DBC;" parent="1" vertex="1">
                    <mxGeometry x="320" y="90" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="15" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="4" target="2" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="16" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="4" target="3" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="17" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="4" target="6" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="25" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="4" target="9" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="4" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Prefab&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#0050ef;fontColor=#ffffff;strokeColor=#001DBC;" parent="1" vertex="1">
                    <mxGeometry y="170" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="5" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Scene&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#d80073;fontColor=#ffffff;strokeColor=#A50040;" parent="1" vertex="1">
                    <mxGeometry x="650" y="200" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="23" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="6" target="5" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="6" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Animation&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#0050ef;fontColor=#ffffff;strokeColor=#001DBC;" parent="1" vertex="1">
                    <mxGeometry x="320" y="170" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="7" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Texture2D&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#0050ef;fontColor=#ffffff;strokeColor=#001DBC;" parent="1" vertex="1">
                    <mxGeometry y="290" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="8" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;TextureCube&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#0050ef;fontColor=#ffffff;strokeColor=#001DBC;" parent="1" vertex="1">
                    <mxGeometry y="410" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="20" style="edgeStyle=none;html=1;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="9" target="7" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="24" style="edgeStyle=none;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;fontSize=24;dashed=1;" parent="1" source="9" target="5" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="9" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Material&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#d80073;fontColor=#ffffff;strokeColor=#A50040;" parent="1" vertex="1">
                    <mxGeometry x="650" y="320" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="26" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" parent="1" source="10" target="4" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="10" value="Model Importer" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;fillColor=#008a00;fontColor=#ffffff;strokeColor=#005700;" parent="1" vertex="1">
                    <mxGeometry x="-240" y="160" width="160" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="11" value="&lt;span style=&quot;font-size: 24px;&quot;&gt;Render Pipeline&lt;/span&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#d80073;fontColor=#ffffff;strokeColor=#A50040;" parent="1" vertex="1">
                    <mxGeometry x="650" y="130" width="200" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="13" value="Engine Resource" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=24;" parent="1" vertex="1">
                    <mxGeometry x="650" y="390" width="200" height="30" as="geometry"/>
                </mxCell>
                <mxCell id="28" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" parent="1" source="27" target="7" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="29" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" parent="1" source="27" target="8" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="27" value="Texture&lt;br&gt;Importer" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;fillColor=#008a00;fontColor=#ffffff;strokeColor=#005700;" parent="1" vertex="1">
                    <mxGeometry x="-240" y="340" width="160" height="80" as="geometry"/>
                </mxCell>
                <mxCell id="31" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" parent="1" source="30" target="10" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="30" value="Assimp" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" parent="1" vertex="1">
                    <mxGeometry x="-450" y="170" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="34" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" parent="1" source="32" target="27" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="32" value="STB" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" parent="1" vertex="1">
                    <mxGeometry x="-450" y="320" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="35" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" parent="1" source="33" target="27" edge="1">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="33" value="DDS" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" parent="1" vertex="1">
                    <mxGeometry x="-450" y="390" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="37" value="Plugin" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=24;" parent="1" vertex="1">
                    <mxGeometry x="-420" y="130" width="60" height="30" as="geometry"/>
                </mxCell>
            </root>
        </mxGraphModel>
    </diagram>
</mxfile>

================================================
FILE: Doc/Scene.drawio
================================================
<mxfile host="65bd71144e">
    <diagram id="DN1jI_-sQySN9qRA725S" name="第 1 页">
        <mxGraphModel dx="1973" dy="944" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" background="none" math="0" shadow="0">
            <root>
                <mxCell id="0"/>
                <mxCell id="1" parent="0"/>
                <mxCell id="34" value="" style="rounded=0;whiteSpace=wrap;html=1;fontSize=24;fillColor=#647687;fontColor=#ffffff;strokeColor=#314354;" vertex="1" parent="1">
                    <mxGeometry x="354" y="100" width="496" height="310" as="geometry"/>
                </mxCell>
                <mxCell id="21" style="edgeStyle=none;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="2" target="3">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="22" style="edgeStyle=none;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="2" target="4">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="2" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Scene&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" parent="1" vertex="1">
                    <mxGeometry x="40" y="90" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="24" style="edgeStyle=none;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="3" target="6">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="25" style="edgeStyle=none;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="3" target="5">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="3" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Entity #1&lt;/font&gt;" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#60a917;fontColor=#ffffff;strokeColor=#2D7600;" parent="1" vertex="1">
                    <mxGeometry x="-80" y="250" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="31" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.576;entryY=-0.011;entryDx=0;entryDy=0;entryPerimeter=0;fontSize=24;curved=1;" edge="1" parent="1" source="4" target="26">
                    <mxGeometry relative="1" as="geometry">
                        <Array as="points">
                            <mxPoint x="220" y="40"/>
                            <mxPoint x="612" y="40"/>
                        </Array>
                    </mxGeometry>
                </mxCell>
                <mxCell id="33" style="edgeStyle=orthogonalEdgeStyle;curved=1;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="4" target="32">
                    <mxGeometry relative="1" as="geometry">
                        <Array as="points">
                            <mxPoint x="220" y="480"/>
                            <mxPoint x="760" y="480"/>
                        </Array>
                    </mxGeometry>
                </mxCell>
                <mxCell id="4" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Entity #2&lt;/font&gt;" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#60a917;fontColor=#ffffff;strokeColor=#2D7600;" parent="1" vertex="1">
                    <mxGeometry x="160" y="250" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="5" value="&lt;span style=&quot;font-size: 24px;&quot;&gt;...&lt;/span&gt;" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#60a917;fontColor=#ffffff;strokeColor=#2D7600;" parent="1" vertex="1">
                    <mxGeometry x="40" y="410" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="6" value="&lt;span style=&quot;font-size: 24px;&quot;&gt;Entity #N&lt;/span&gt;" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#60a917;fontColor=#ffffff;strokeColor=#2D7600;" parent="1" vertex="1">
                    <mxGeometry x="-200" y="410" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="17" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Light&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#fa6800;strokeColor=#C73500;fontColor=#000000;" vertex="1" parent="1">
                    <mxGeometry x="360" y="120" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="18" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Camera&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#d80073;fontColor=#ffffff;strokeColor=#A50040;" vertex="1" parent="1">
                    <mxGeometry x="360" y="180" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="19" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Renderable&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#a20025;fontColor=#ffffff;strokeColor=#6F0000;" vertex="1" parent="1">
                    <mxGeometry x="360" y="240" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="20" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Transform&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#e51400;fontColor=#ffffff;strokeColor=#B20000;" vertex="1" parent="1">
                    <mxGeometry x="360" y="300" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="26" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;#0 Cmpt #0&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#fa6800;strokeColor=#C73500;fontColor=#000000;" vertex="1" parent="1">
                    <mxGeometry x="520" y="120" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="27" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;#1 Cmpt #0&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#d80073;fontColor=#ffffff;strokeColor=#A50040;" vertex="1" parent="1">
                    <mxGeometry x="520" y="180" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="28" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;#2 Cmpt #0&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#a20025;fontColor=#ffffff;strokeColor=#6F0000;" vertex="1" parent="1">
                    <mxGeometry x="520" y="240" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="29" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;#3 Cmpt #0&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#e51400;fontColor=#ffffff;strokeColor=#B20000;" vertex="1" parent="1">
                    <mxGeometry x="520" y="300" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="30" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;#0 Cmpt #1&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#fa6800;strokeColor=#C73500;fontColor=#000000;" vertex="1" parent="1">
                    <mxGeometry x="680" y="120" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="32" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;#3 Cmpt #1&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#e51400;fontColor=#ffffff;strokeColor=#B20000;" vertex="1" parent="1">
                    <mxGeometry x="680" y="300" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="35" value="Component Map" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=24;" vertex="1" parent="1">
                    <mxGeometry x="503" y="370" width="198" height="30" as="geometry"/>
                </mxCell>
            </root>
        </mxGraphModel>
    </diagram>
</mxfile>

================================================
FILE: Doc/Shader.drawio
================================================
<mxfile host="65bd71144e" pages="1">
    <diagram id="FqTtuIh2T_jkB8yKotZ9" name="第 1 页">
        <mxGraphModel dx="1146" dy="726" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" background="none" math="0" shadow="0">
            <root>
                <mxCell id="0"/>
                <mxCell id="1" parent="0"/>
                <mxCell id="31" style="edgeStyle=orthogonalEdgeStyle;curved=1;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;" parent="1" target="6" edge="1">
                    <mxGeometry relative="1" as="geometry">
                        <Array as="points">
                            <mxPoint x="180" y="90"/>
                            <mxPoint x="580" y="90"/>
                        </Array>
                        <mxPoint x="180" y="160.0000000000001" as="sourcePoint"/>
                    </mxGeometry>
                </mxCell>
                <mxCell id="52" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="46" target="49">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="62" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="46" target="51">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="46" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;HLSL&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" vertex="1" parent="1">
                    <mxGeometry x="40" y="260" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="53" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="47" target="50">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="47" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;GLSL&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" vertex="1" parent="1">
                    <mxGeometry x="40" y="480" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="58" style="edgeStyle=none;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="49" target="57">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="67" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="49" target="65">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="49" value="dxc" style="rounded=1;whiteSpace=wrap;html=1;fontSize=24;fillColor=#60a917;fontColor=#ffffff;strokeColor=#2D7600;" vertex="1" parent="1">
                    <mxGeometry x="240" y="260" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="66" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="50" target="65">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="50" value="glslang" style="rounded=1;whiteSpace=wrap;html=1;fontSize=24;fillColor=#60a917;fontColor=#ffffff;strokeColor=#2D7600;" vertex="1" parent="1">
                    <mxGeometry x="240" y="480" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="64" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="51" target="63">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="51" value="slang" style="rounded=1;whiteSpace=wrap;html=1;fontSize=24;fillColor=#60a917;fontColor=#ffffff;strokeColor=#2D7600;" vertex="1" parent="1">
                    <mxGeometry x="240" y="160" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="57" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;DXIL&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#647687;fontColor=#ffffff;strokeColor=#314354;" vertex="1" parent="1">
                    <mxGeometry x="440" y="260" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="63" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;PTX&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#647687;fontColor=#ffffff;strokeColor=#314354;" vertex="1" parent="1">
                    <mxGeometry x="440" y="160" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="70" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="65" target="69">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="73" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="65" target="72">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="65" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;SPIR-V&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#647687;fontColor=#ffffff;strokeColor=#314354;" vertex="1" parent="1">
                    <mxGeometry x="240" y="370" width="120" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="71" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="69" target="46">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="69" value="spirv-cross" style="rounded=1;whiteSpace=wrap;html=1;fontSize=24;fillColor=#6a00ff;fontColor=#ffffff;strokeColor=#3700CC;" vertex="1" parent="1">
                    <mxGeometry x="20" y="370" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="75" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;fontSize=24;" edge="1" parent="1" source="72" target="74">
                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>
                <mxCell id="72" value="spirv-reflect" style="rounded=1;whiteSpace=wrap;html=1;fontSize=24;fillColor=#6a00ff;fontColor=#ffffff;strokeColor=#3700CC;" vertex="1" parent="1">
                    <mxGeometry x="420" y="370" width="160" height="60" as="geometry"/>
                </mxCell>
                <mxCell id="74" value="&lt;font style=&quot;font-size: 24px;&quot;&gt;Meta Info&lt;/font&gt;" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#647687;fontColor=#ffffff;strokeColor=#314354;" vertex="1" parent="1">
                    <mxGeometry x="440" y="480" width="120" height="60" as="geometry"/>
                </mxCell>
            </root>
        </mxGraphModel>
    </diagram>
</mxfile>

================================================
FILE: LICENSE.txt
================================================
MIT License

Copyright (c) 2021 Chaf-Graphics

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
# Ilum(WIP)

[![Windows](https://github.com/Chaf-Libraries/Ilum/actions/workflows/windows_main.yml/badge.svg)](https://github.com/Chaf-Libraries/Ilum/actions/workflows/windows.yml) [![Codacy Badge](https://app.codacy.com/project/badge/Grade/b0cb3a2729ee4be783dd5feb2cc67eb6)](https://www.codacy.com/gh/Chaf-Libraries/IlumEngine/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=Chaf-Libraries/IlumEngine&amp;utm_campaign=Badge_Grade)

Ilum Graphics Playground, name after *Planet Ilum* from [star wars](https://starwars.fandom.com/wiki/Ilum).

A framework for computer graphics learning and practice (It's not a game engine!)  
[bilibili: Project demo video](https://www.bilibili.com/video/BV1Zy4y1f7PX/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=80dfe42ae16a11fb93eda40958202849)

![image-20230212023548756](Doc/Img/image-20230212023548756.png)

## Install

**Platform**

* Windows 10
* Visual Studio 2022
* xmake >= v2.7.5
* [optional] CUDA >= 11.7

**Build**

Ilum uses [xmake](https://xmake.io/#/) for building. You can compile the whole project by simply run command:

```shell
xmake -y
```

or you can open the project in Visual Studio by generating `.sln` file:

```shell
xmake project -k vsxmake
```

## Feature

### Cross-Platform RHI

* Vulkan
  * Mesh Shading
  * Dynamic Rendering
  * Ray Tracing Pipeline
  * Draw/Dispatch Indirect
  * Bindless Resource

* CUDA
  * CUDA & Vulkan Interop


### Resource Manager

![](./Doc/Img/Resource.png)

### Scene Graph

![](./Doc/Img/Scene.png)

### Shader Compilation

![shader](Doc/Img/shader.png)

### Render Graph

* Static compilation
* Automatic resource state tracking and transition
* Texture memory aliasing
* Seamless interoperation between Graphics API and CUDA
* Easy to customize render pass

**Render Pass**

* Visibility Deferred Shading Pipeline

  * Visibility Geometry Pass
    * Mesh shading with meshlet frustum culling (if device support `mesh_shader`)
    * Usual rasterization without optimization

  * Visibility Buffer Visualization
    * Visualize visibility buffer: instance and primitive
  * Visibility Buffer Lighting Pass
    * Indirect dispatch to support multiple material graphs
    * Generate lighting result and GBuffer

* Shadow

  * Classic Shadow Map (Spot Light)
  * Omnidirectional Shadow Map (Point Light)
  * Cascade Shadow Map (Directional Light)

* Ambient Occlusion
  * SSAO

* IBL
  * Spherical Harmonic Encoding Diffuse
  * Pre-Filter For Specular

* Ray Tracing
  * Path Tracing
* Post Process
  * Tone Mapping
  * Bloom
  * FXAA

**TODO**

* Resource Pool
* Runtime compilation maybe
* Multi-threading

### Material Graph

**Feature**

* Static compilation and HLSL generation
* Easy to customize material node
* Support usual BSDF models

### Plugins

You can extend the renderer features by adding these plugins:

* RHI
* Render Pass
* Material Node
* Importer
* Editor

#### Customize Render Pass



#### Customize Material Node



## Gallery

### Render Graph Editor

![image-20230210193225994](./Doc/Img/image-20230210193225994.png)

### Material Graph Editor

![image-20230210194028080](./Doc/Img/image-20230210194028080.png)

### Path Tracing

![](./Doc/Img/material.png)

## Reference

* [https://www.pbr-book.org/](https://www.pbr-book.org/)
* [http://www.realtimerendering.com/](http://www.realtimerendering.com/)
* [https://learnopengl-cn.github.io/](https://learnopengl-cn.github.io/)
* [https://hazelengine.com/](https://hazelengine.com/)
* [https://advances.realtimerendering.com/s2015/aaltonenhaar_siggraph2015_combined_final_footer_220dpi.pdf](https://advances.realtimerendering.com/s2015/aaltonenhaar_siggraph2015_combined_final_footer_220dpi.pdf)
* [https://www.gdcvault.com/play/1024612/FrameGraph-Extensible-Rendering-Architecture-in](https://www.gdcvault.com/play/1024612/FrameGraph-Extensible-Rendering-Architecture-in)
* [https://github.com/SaschaWillems/Vulkan](https://github.com/SaschaWillems/Vulkan)
* [https://github.com/KhronosGroup/Vulkan-Samples](https://github.com/KhronosGroup/Vulkan-Samples)
* [https://github.com/wdas/brdf](https://github.com/wdas/brdf)
* [http://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf.](http://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf.)
* [https://www.froyok.fr/blog/2021-12-ue4-custom-bloom/](https://www.froyok.fr/blog/2021-12-ue4-custom-bloom/)

* [https://filmicworlds.com/blog/visibility-buffer-rendering-with-material-graphs](https://filmicworlds.com/blog/visibility-buffer-rendering-with-material-graphs)


================================================
FILE: Source/Editor/Editor.cpp
================================================
#include "Editor.hpp"
#include "ImGui/ImGuiContext.hpp"
#include "Widget.hpp"

#include <Core/Plugin.hpp>
#include <Scene/Components/Camera/Camera.hpp>
#include <Scene/Node.hpp>

#include <imgui.h>

#include <filesystem>
#include <regex>

namespace Ilum
{
struct Editor::Impl
{
	std::unique_ptr<GuiContext> imgui_context = nullptr;

	RHIContext *rhi_context = nullptr;
	Renderer   *renderer    = nullptr;

	std::vector<std::unique_ptr<Widget>> widgets;

	Node *select = nullptr;

	Cmpt::Camera *main_camera = nullptr;
};

Editor::Editor(Window *window, RHIContext *rhi_context, Renderer *renderer)
{
	m_impl = new Impl;

	m_impl->imgui_context = std::make_unique<GuiContext>(rhi_context, window);
	m_impl->renderer      = renderer;
	m_impl->rhi_context   = rhi_context;

	for (const auto &file : std::filesystem::directory_iterator("shared/Editor/"))
	{
		m_impl->widgets.emplace_back(std::unique_ptr<Widget>(std::move(PluginManager::GetInstance().Call<Widget *>(file.path().string(), "Create", this, ImGui::GetCurrentContext()))));
	}
}

Editor::~Editor()
{
	m_impl->imgui_context.reset();
	delete m_impl;
}

void Editor::PreTick()
{
	m_impl->imgui_context->BeginFrame();
}

void Editor::Tick()
{
	if (ImGui::BeginMainMenuBar())
	{
		if (ImGui::BeginMenu("Widget"))
		{
			for (auto &widget : m_impl->widgets)
			{
				ImGui::MenuItem(widget->GetName().c_str(), nullptr, &widget->GetActive());
			}
			ImGui::EndMenu();
		}

		ImGui::EndMainMenuBar();
	}

	for (auto &widget : m_impl->widgets)
	{
		if (widget->GetActive())
		{
			widget->Tick();
		}
	}
}

void Editor::PostTick()
{
	m_impl->imgui_context->EndFrame();
	m_impl->imgui_context->Render();
}

Renderer *Editor::GetRenderer() const
{
	return m_impl->renderer;
}

RHIContext *Editor::GetRHIContext() const
{
	return m_impl->rhi_context;
}

Window *Editor::GetWindow() const
{
	return m_impl->imgui_context->GetWindow();
}

void Editor::SelectNode(Node *node)
{
	m_impl->select = node;
}

void Editor::SetMainCamera(Cmpt::Camera *camera)
{
	m_impl->main_camera = camera;
}

Node *Editor::GetSelectedNode() const
{
	return m_impl->select;
}

Cmpt::Camera *Editor::GetMainCamera() const
{
	return m_impl->main_camera;
}
}        // namespace Ilum

================================================
FILE: Source/Editor/Editor.hpp
================================================
#pragma once

#include <Core/Core.hpp>

#include <memory>
#include <vector>

namespace Ilum
{
class Window;
class RHIContext;
class GuiContext;
class Widget;
class Renderer;
class Node;

namespace Cmpt
{
class Camera;
}

class EXPORT_API Editor
{
  public:
	Editor(Window *window, RHIContext *rhi_context, Renderer *renderer);

	~Editor();

	void PreTick();

	void Tick();

	void PostTick();

	Renderer *GetRenderer() const;

	RHIContext *GetRHIContext() const;

	Window *GetWindow() const;

	void SelectNode(Node *node = nullptr);

	void SetMainCamera(Cmpt::Camera *camera = nullptr);

	Node *GetSelectedNode() const;

	Cmpt::Camera *GetMainCamera() const;

  private:
	struct Impl;
	Impl* m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Editor/ImGui/ImGuiContext.cpp
================================================
#include "ImGuiContext.hpp"

#include <Core/Path.hpp>
#include <ShaderCompiler/ShaderCompiler.hpp>

#include <imgui.h>
#include <imgui_impl_glfw.h>
#include <imnodes/imnodes.h>
#include <implot/implot.h>

#include <IconsFontAwesome/IconsFontAwesome5.h>

#include <GLFW/glfw3.h>
#define GLFW_EXPOSE_NATIVE_WIN32
#include <GLFW/glfw3native.h>

#undef CreateSemaphore

namespace Ilum
{
static RHIContext       *gContext       = nullptr;
static Window           *gWindow        = nullptr;
static RHIPipelineState *gPipelineState = nullptr;
static RHIDescriptor    *gDescriptor    = nullptr;
static RHISampler       *gSampler       = nullptr;
static RHIRenderTarget  *gRenderTarget  = nullptr;

struct ConstantBlock
{
	glm::vec2 scale;
	glm::vec2 translate;
};

struct ViewportResources
{
	ViewportResources(const std::string &name = "subwindow")
	{
		uniform_buffer = gContext->CreateBuffer(BufferDesc{
		    "imgui_uniform_buffer - " + name + std::to_string((uint64_t) this),
		    RHIBufferUsage::ConstantBuffer,
		    RHIMemoryUsage::CPU_TO_GPU,
		    sizeof(ConstantBlock),
		});

		for (uint32_t i = 0; i < 3; i++)
		{
			render_completes[i]  = gContext->CreateSemaphore();
			present_completes[i] = gContext->CreateSemaphore();
		}
	}

	std::unique_ptr<RHIBuffer> vertex_buffer  = nullptr;
	std::unique_ptr<RHIBuffer> index_buffer   = nullptr;
	std::unique_ptr<RHIBuffer> uniform_buffer = nullptr;

	std::array<std::unique_ptr<RHISemaphore>, 3> render_completes;
	std::array<std::unique_ptr<RHISemaphore>, 3> present_completes;

	std::vector<RHICommand *> cmd_buffers;

	uint32_t vertex_count = 0;
	uint32_t index_count  = 0;

	uint32_t frame_index = 0;
};

struct WindowData
{
	std::unique_ptr<ViewportResources> viewport_data;
	std::unique_ptr<RHISwapchain>      swapchain;
};

static std::unique_ptr<ViewportResources> gResource;

GuiContext::GuiContext(RHIContext *context, Window *window) :
    p_context(context), p_window(window)
{
	gContext = p_context;
	gWindow  = p_window;

	gResource = std::make_unique<ViewportResources>("mainwindows");

	ImGui::CreateContext();

	SetStyle();

	ImGui_ImplGlfw_InitForOther(window->GetHandle(), true);

	m_pipeline_state = context->CreatePipelineState();
	m_render_target  = context->CreateRenderTarget();
	m_sampler        = context->CreateSampler(SamplerDesc{
        RHIFilter::Linear,
        RHIFilter::Linear,
        RHIAddressMode::Clamp_To_Edge,
        RHIAddressMode::Clamp_To_Edge,
        RHIAddressMode::Clamp_To_Edge,
        RHIMipmapMode::Linear,
        RHISamplerBorderColor::Float_Opaque_White});

	// Setup pipeline state
	DepthStencilState depth_stencil_state  = {};
	depth_stencil_state.depth_test_enable  = false;
	depth_stencil_state.depth_write_enable = false;
	depth_stencil_state.compare            = RHICompareOp::Always;

	RasterizationState rasterization_state = {};
	rasterization_state.cull_mode          = RHICullMode::None;
	rasterization_state.polygon_mode       = RHIPolygonMode::Solid;
	rasterization_state.front_face         = RHIFrontFace::Clockwise;

	InputAssemblyState input_assembly_state = {};
	input_assembly_state.topology           = RHIPrimitiveTopology::Triangle;

	BlendState blend_state = {};
	blend_state.enable     = false;
	blend_state.attachment_states.push_back(BlendState::AttachmentState{
	    true,
	    RHIBlendFactor::Src_Alpha,
	    RHIBlendFactor::One_Minus_Src_Alpha,
	    RHIBlendOp::Add,
	    RHIBlendFactor::One,
	    RHIBlendFactor::One_Minus_Src_Alpha,
	    RHIBlendOp::Add,
	    1 | 2 | 4 | 8});

	VertexInputState vertex_input_state = {};
	vertex_input_state.input_attributes = {
	    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32_FLOAT, offsetof(ImDrawVert, pos)},
	    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 1, 0, RHIFormat::R32G32_FLOAT, offsetof(ImDrawVert, uv)},
	    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 2, 0, RHIFormat::R8G8B8A8_UNORM, offsetof(ImDrawVert, col)},
	};

	vertex_input_state.input_bindings = {
	    VertexInputState::InputBinding{0, sizeof(ImDrawVert), RHIVertexInputRate::Vertex}};

	/*std::vector<uint8_t> raw_shader;
	Path::GetInstance().Read("./Source/Shaders/ImGui.hlsl", raw_shader);

	std::string shader_source;
	shader_source.resize(raw_shader.size());
	std::memcpy(shader_source.data(), raw_shader.data(), raw_shader.size());
	shader_source += "\n";

	ShaderDesc vertex_shader_desc  = {};
	vertex_shader_desc.entry_point = "VSmain";
	vertex_shader_desc.stage       = RHIShaderStage::Vertex;
	vertex_shader_desc.source      = ShaderSource::HLSL;
	vertex_shader_desc.target      = ShaderTarget::SPIRV;
	vertex_shader_desc.code        = shader_source;
	vertex_shader_desc.macros      = {"VULKAN_BACKEND"};

	ShaderDesc fragment_shader_desc  = {};
	fragment_shader_desc.entry_point = "PSmain";
	fragment_shader_desc.stage       = RHIShaderStage::Fragment;
	fragment_shader_desc.source      = ShaderSource::HLSL;
	fragment_shader_desc.target      = ShaderTarget::SPIRV;
	fragment_shader_desc.code        = shader_source;
	fragment_shader_desc.macros      = {"VULKAN_BACKEND"};

	ShaderMeta vertex_meta   = {};
	ShaderMeta fragment_meta = {};

	auto vertex_shader_spirv   = ShaderCompiler::GetInstance().Compile(vertex_shader_desc, vertex_meta);
	auto fragment_shader_spirv = ShaderCompiler::GetInstance().Compile(fragment_shader_desc, fragment_meta);

	m_vertex_shader   = p_context->CreateShader("VSmain", vertex_shader_spirv);
	m_fragment_shader = p_context->CreateShader("PSmain", fragment_shader_spirv);

	ShaderMeta shader_meta= vertex_meta;
	shader_meta += fragment_meta;*/

	ShaderMeta           shader_meta;
	std::vector<uint8_t> vertex_shader_spirv;
	std::vector<uint8_t> fragment_shader_spirv;
	DESERIALIZE("Asset/BuildIn/ImGui.spv.asset", vertex_shader_spirv, fragment_shader_spirv, shader_meta);

	m_vertex_shader   = p_context->CreateShader("VSmain", vertex_shader_spirv);
	m_fragment_shader = p_context->CreateShader("PSmain", fragment_shader_spirv);

	m_descriptor = p_context->CreateDescriptor(shader_meta);

	m_pipeline_state->SetDepthStencilState(depth_stencil_state);
	m_pipeline_state->SetRasterizationState(rasterization_state);
	m_pipeline_state->SetVertexInputState(vertex_input_state);
	m_pipeline_state->SetBlendState(blend_state);
	m_pipeline_state->SetInputAssemblyState(input_assembly_state);
	m_pipeline_state->SetShader(RHIShaderStage::Vertex, m_vertex_shader.get());
	m_pipeline_state->SetShader(RHIShaderStage::Fragment, m_fragment_shader.get());

	// Font atlas
	unsigned char *pixels;
	int32_t        atlas_width, atlas_height, bpp;
	auto          &io = ImGui::GetIO();
	io.Fonts->GetTexDataAsRGBA32(&pixels, &atlas_width, &atlas_height, &bpp);

	const uint32_t size = atlas_width * atlas_height * bpp;

	auto buffer = p_context->CreateBuffer(static_cast<size_t>(size), RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
	std::memcpy(buffer->Map(), pixels, size);
	buffer->Unmap();

	m_font_atlas = p_context->CreateTexture2D(atlas_width, atlas_height, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::ShaderResource | RHITextureUsage::Transfer, false);

	auto *cmd_buffer = p_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();
	cmd_buffer->BeginMarker("UI");
	cmd_buffer->ResourceStateTransition({TextureStateTransition{
	                                        m_font_atlas.get(),
	                                        RHIResourceState::Undefined,
	                                        RHIResourceState::TransferDest,
	                                        TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
	                                    {});
	cmd_buffer->CopyBufferToTexture(buffer.get(), m_font_atlas.get(), 0, 0, 1);
	cmd_buffer->ResourceStateTransition({TextureStateTransition{
	                                        m_font_atlas.get(),
	                                        RHIResourceState::TransferDest,
	                                        RHIResourceState::ShaderResource,
	                                        TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
	                                    {});
	cmd_buffer->EndMarker();
	cmd_buffer->End();

	p_context->Execute(cmd_buffer);

	io.Fonts->TexID = static_cast<ImTextureID>(m_font_atlas.get());

	gPipelineState = m_pipeline_state.get();
	gDescriptor    = m_descriptor;
	gSampler       = m_sampler;
	gRenderTarget  = m_render_target.get();

	InitializePlatformInterface();
}

GuiContext::~GuiContext()
{
	ImGui_ImplGlfw_Shutdown();
	ImGui::DestroyContext();

	gContext       = nullptr;
	gWindow        = nullptr;
	gPipelineState = nullptr;
	gDescriptor    = nullptr;
	gSampler       = nullptr;
	gRenderTarget  = nullptr;

	gResource.reset();
}

void GuiContext::BeginFrame()
{
	ImGui_ImplGlfw_NewFrame();
	ImGui::NewFrame();

	ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoDocking;
	window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
	window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
	ImGuiViewport *viewport = ImGui::GetMainViewport();
	ImGui::SetNextWindowPos(viewport->WorkPos);
	ImGui::SetNextWindowSize(viewport->WorkSize);
	ImGui::SetNextWindowViewport(viewport->ID);
	ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
	ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
	ImGui::Begin("DockSpace", (bool *) 1, window_flags);
	ImGui::PopStyleVar();
	ImGui::PopStyleVar(2);

	ImGuiIO &io = ImGui::GetIO();
	if (io.ConfigFlags & ImGuiConfigFlags_DockingEnable)
	{
		ImGuiID dockspace_id = ImGui::GetID("DockSpace");
		ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), ImGuiDockNodeFlags_None);
	}
}

void GuiContext::EndFrame()
{
	ImGui::End();
	ImGuiIO &io    = ImGui::GetIO();
	io.DisplaySize = ImVec2(static_cast<float>(gWindow->GetWidth()), static_cast<float>(gWindow->GetHeight()));

	ImGui::EndFrame();

	ImGui::Render();

	if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
	{
		ImGui::UpdatePlatformWindows();
		ImGui::RenderPlatformWindowsDefault();
	}
}

void GuiContext::SetStyle()
{
	ImGuiIO &io = ImGui::GetIO();
	(void) io;
	io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
	io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
	io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
	io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;

	io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports;

	// Set fonts
	static const ImWchar icon_ranges[] = {ICON_MIN_FA, ICON_MAX_FA, 0};
	ImFontConfig         config;
	config.MergeMode        = true;
	config.GlyphMinAdvanceX = 13.0f;
	io.Fonts->AddFontFromFileTTF("./Asset/Font/ArialUnicodeMS.ttf", 20.0f, NULL, io.Fonts->GetGlyphRangesChineseFull());
	io.Fonts->AddFontFromFileTTF("./Asset/Font/fontawesome-webfont.ttf", 15.0f, &config, icon_ranges);

	// When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
	ImGuiStyle &style  = ImGui::GetStyle();
	auto        colors = style.Colors;

	if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
	{
		style.WindowRounding              = 0.0f;
		style.Colors[ImGuiCol_WindowBg].w = 1.0f;
	}

	colors[ImGuiCol_Text]                  = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
	colors[ImGuiCol_TextDisabled]          = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
	colors[ImGuiCol_WindowBg]              = ImVec4(0.06f, 0.06f, 0.06f, 0.94f);
	colors[ImGuiCol_ChildBg]               = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
	colors[ImGuiCol_PopupBg]               = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
	colors[ImGuiCol_Border]                = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
	colors[ImGuiCol_BorderShadow]          = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
	colors[ImGuiCol_FrameBg]               = ImVec4(0.44f, 0.44f, 0.44f, 0.60f);
	colors[ImGuiCol_FrameBgHovered]        = ImVec4(0.57f, 0.57f, 0.57f, 0.70f);
	colors[ImGuiCol_FrameBgActive]         = ImVec4(0.76f, 0.76f, 0.76f, 0.80f);
	colors[ImGuiCol_TitleBg]               = ImVec4(0.04f, 0.04f, 0.04f, 1.00f);
	colors[ImGuiCol_TitleBgActive]         = ImVec4(0.16f, 0.16f, 0.16f, 1.00f);
	colors[ImGuiCol_TitleBgCollapsed]      = ImVec4(0.00f, 0.00f, 0.00f, 0.60f);
	colors[ImGuiCol_MenuBarBg]             = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);
	colors[ImGuiCol_ScrollbarBg]           = ImVec4(0.02f, 0.02f, 0.02f, 0.53f);
	colors[ImGuiCol_ScrollbarGrab]         = ImVec4(0.31f, 0.31f, 0.31f, 1.00f);
	colors[ImGuiCol_ScrollbarGrabHovered]  = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);
	colors[ImGuiCol_ScrollbarGrabActive]   = ImVec4(0.51f, 0.51f, 0.51f, 1.00f);
	colors[ImGuiCol_CheckMark]             = ImVec4(0.13f, 0.75f, 0.55f, 0.80f);
	colors[ImGuiCol_SliderGrab]            = ImVec4(0.13f, 0.75f, 0.75f, 0.80f);
	colors[ImGuiCol_SliderGrabActive]      = ImVec4(0.13f, 0.75f, 1.00f, 0.80f);
	colors[ImGuiCol_Button]                = ImVec4(0.13f, 0.75f, 0.55f, 0.40f);
	colors[ImGuiCol_ButtonHovered]         = ImVec4(0.13f, 0.75f, 0.75f, 0.60f);
	colors[ImGuiCol_ButtonActive]          = ImVec4(0.13f, 0.75f, 1.00f, 0.80f);
	colors[ImGuiCol_Header]                = ImVec4(0.13f, 0.75f, 0.55f, 0.40f);
	colors[ImGuiCol_HeaderHovered]         = ImVec4(0.13f, 0.75f, 0.75f, 0.60f);
	colors[ImGuiCol_HeaderActive]          = ImVec4(0.13f, 0.75f, 1.00f, 0.80f);
	colors[ImGuiCol_Separator]             = ImVec4(0.13f, 0.75f, 0.55f, 0.40f);
	colors[ImGuiCol_SeparatorHovered]      = ImVec4(0.13f, 0.75f, 0.75f, 0.60f);
	colors[ImGuiCol_SeparatorActive]       = ImVec4(0.13f, 0.75f, 1.00f, 0.80f);
	colors[ImGuiCol_ResizeGrip]            = ImVec4(0.13f, 0.75f, 0.55f, 0.40f);
	colors[ImGuiCol_ResizeGripHovered]     = ImVec4(0.13f, 0.75f, 0.75f, 0.60f);
	colors[ImGuiCol_ResizeGripActive]      = ImVec4(0.13f, 0.75f, 1.00f, 0.80f);
	colors[ImGuiCol_Tab]                   = ImVec4(0.13f, 0.75f, 0.55f, 0.80f);
	colors[ImGuiCol_TabHovered]            = ImVec4(0.13f, 0.75f, 0.75f, 0.80f);
	colors[ImGuiCol_TabActive]             = ImVec4(0.13f, 0.75f, 1.00f, 0.80f);
	colors[ImGuiCol_TabUnfocused]          = ImVec4(0.18f, 0.18f, 0.18f, 1.00f);
	colors[ImGuiCol_TabUnfocusedActive]    = ImVec4(0.36f, 0.36f, 0.36f, 0.54f);
	colors[ImGuiCol_DockingPreview]        = ImVec4(0.13f, 0.75f, 0.55f, 0.80f);
	colors[ImGuiCol_DockingEmptyBg]        = ImVec4(0.13f, 0.13f, 0.13f, 0.80f);
	colors[ImGuiCol_PlotLines]             = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
	colors[ImGuiCol_PlotLinesHovered]      = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
	colors[ImGuiCol_PlotHistogram]         = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
	colors[ImGuiCol_PlotHistogramHovered]  = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
	colors[ImGuiCol_TableHeaderBg]         = ImVec4(0.19f, 0.19f, 0.20f, 1.00f);
	colors[ImGuiCol_TableBorderStrong]     = ImVec4(0.31f, 0.31f, 0.35f, 1.00f);
	colors[ImGuiCol_TableBorderLight]      = ImVec4(0.23f, 0.23f, 0.25f, 1.00f);
	colors[ImGuiCol_TableRowBg]            = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
	colors[ImGuiCol_TableRowBgAlt]         = ImVec4(1.00f, 1.00f, 1.00f, 0.07f);
	colors[ImGuiCol_TextSelectedBg]        = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
	colors[ImGuiCol_DragDropTarget]        = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
	colors[ImGuiCol_NavHighlight]          = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
	colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
	colors[ImGuiCol_NavWindowingDimBg]     = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
	colors[ImGuiCol_ModalWindowDimBg]      = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);

	style.WindowPadding     = ImVec2(8.00f, 8.00f);
	style.FramePadding      = ImVec2(5.00f, 2.00f);
	style.CellPadding       = ImVec2(6.00f, 6.00f);
	style.ItemSpacing       = ImVec2(6.00f, 6.00f);
	style.ItemInnerSpacing  = ImVec2(6.00f, 6.00f);
	style.TouchExtraPadding = ImVec2(0.00f, 0.00f);
	style.IndentSpacing     = 25;
	style.ScrollbarSize     = 15;
	style.GrabMinSize       = 10;
	style.WindowBorderSize  = 1;
	style.ChildBorderSize   = 1;
	style.PopupBorderSize   = 1;
	style.FrameBorderSize   = 1;
	style.TabBorderSize     = 1;
	style.WindowRounding    = 7;
	style.ChildRounding     = 4;
	style.FrameRounding     = 3;
	style.PopupRounding     = 4;
	style.ScrollbarRounding = 9;
	style.GrabRounding      = 3;
	style.LogSliderDeadzone = 4;
	style.TabRounding       = 4;
}

static void RHI_Render(ImDrawData *draw_data, WindowData *window_data = nullptr)
{
	size_t vertex_buffer_size = draw_data->TotalVtxCount * sizeof(ImDrawVert);
	size_t index_buffer_size  = draw_data->TotalIdxCount * sizeof(ImDrawIdx);

	if (draw_data->DisplaySize.x == 0 ||
	    draw_data->DisplaySize.y == 0)
	{
		return;
	}

	bool               is_child_window = window_data != nullptr;
	RHISwapchain      *swapchain       = is_child_window ? window_data->swapchain.get() : gContext->GetSwapchain();
	ViewportResources *resources       = is_child_window ? window_data->viewport_data.get() : gResource.get();

	auto &vertex_buffer  = resources->vertex_buffer;
	auto &index_buffer   = resources->index_buffer;
	auto &uniform_buffer = resources->uniform_buffer;

	auto &vertex_count = resources->vertex_count;
	auto &index_count  = resources->index_count;

	if (vertex_buffer == nullptr || vertex_count != static_cast<uint32_t>(draw_data->TotalVtxCount))
	{
		if (vertex_buffer_size != 0)
		{
			vertex_buffer.reset();
			vertex_buffer = gContext->CreateBuffer(vertex_buffer_size, RHIBufferUsage::Vertex, RHIMemoryUsage::CPU_TO_GPU);
			vertex_count  = draw_data->TotalVtxCount;
			vertex_buffer->Map();
		}
	}

	if (index_buffer == nullptr || index_count < static_cast<uint32_t>(draw_data->TotalIdxCount))
	{
		if (index_buffer_size != 0)
		{
			index_buffer.reset();
			index_buffer = gContext->CreateBuffer(index_buffer_size, RHIBufferUsage::Index, RHIMemoryUsage::CPU_TO_GPU);
			index_count  = draw_data->TotalIdxCount;
			index_buffer->Map();
		}
	}

	ImDrawVert *vtx_dst = vertex_buffer ? (ImDrawVert *) vertex_buffer->Map() : nullptr;
	ImDrawIdx  *idx_dst = index_buffer ? (ImDrawIdx *) index_buffer->Map() : nullptr;

	for (int n = 0; n < draw_data->CmdListsCount; n++)
	{
		const ImDrawList *cmd_list = draw_data->CmdLists[n];
		if (vtx_dst)
		{
			memcpy(vtx_dst, cmd_list->VtxBuffer.Data, cmd_list->VtxBuffer.Size * sizeof(ImDrawVert));
		}
		if (idx_dst)
		{
			memcpy(idx_dst, cmd_list->IdxBuffer.Data, cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx));
		}
		vtx_dst += cmd_list->VtxBuffer.Size;
		idx_dst += cmd_list->IdxBuffer.Size;
	}

	if (vertex_buffer)
	{
		vertex_buffer->Flush(0, vertex_buffer->GetDesc().size);
	}

	if (index_buffer)
	{
		index_buffer->Flush(0, index_buffer->GetDesc().size);
	}

	int32_t fb_width  = (int32_t) (draw_data->DisplaySize.x * draw_data->FramebufferScale.x);
	int32_t fb_height = (int32_t) (draw_data->DisplaySize.y * draw_data->FramebufferScale.y);
	if (fb_width <= 0 || fb_height <= 0)
	{
		return;
	}

	ConstantBlock constant_block = {};
	constant_block.scale         = glm::vec2(2.0f / draw_data->DisplaySize.x, 2.0f / draw_data->DisplaySize.y);
	constant_block.translate     = glm::vec2(-1.0f - draw_data->DisplayPos.x * constant_block.scale[0], -1.0f - draw_data->DisplayPos.y * constant_block.scale[1]);

	std::memcpy(uniform_buffer->Map(), &constant_block, sizeof(constant_block));

	gDescriptor->BindSampler("fontSampler", gSampler);
	gDescriptor->BindBuffer("constant", uniform_buffer.get());

	gRenderTarget->Clear();
	ColorAttachment attachment = {};
	attachment.clear_value[3]  = 1.f;
	gRenderTarget->Set(0, swapchain->GetCurrentTexture(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, ColorAttachment{});

	auto *cmd_buffer = gContext->CreateCommand(RHIQueueFamily::Graphics);

	cmd_buffer->Begin();
	cmd_buffer->BeginMarker("UI");

	cmd_buffer->ResourceStateTransition({TextureStateTransition{
	                                        swapchain->GetCurrentTexture(),
	                                        RHIResourceState::Present,
	                                        RHIResourceState::RenderTarget,
	                                        TextureRange{
	                                            RHITextureDimension::Texture2D,
	                                            0, 1, 0, 1}}},
	                                    {});

	cmd_buffer->SetViewport(draw_data->DisplaySize.x, draw_data->DisplaySize.y);

	cmd_buffer->BeginRenderPass(gRenderTarget);

	int32_t global_vtx_offset = 0;
	int32_t global_idx_offset = 0;

	const ImVec2 &clip_off   = draw_data->DisplayPos;
	ImVec2        clip_scale = draw_data->FramebufferScale;

	void *current_texture = nullptr;

	for (int32_t i = 0; i < draw_data->CmdListsCount; i++)
	{
		cmd_buffer->BindVertexBuffer(0, vertex_buffer.get());
		cmd_buffer->BindIndexBuffer(index_buffer.get(), true);

		ImDrawList *cmd_list_imgui = draw_data->CmdLists[i];
		for (int32_t cmd_i = 0; cmd_i < cmd_list_imgui->CmdBuffer.Size; cmd_i++)
		{
			const ImDrawCmd *pcmd = &cmd_list_imgui->CmdBuffer[cmd_i];
			if (pcmd->UserCallback != nullptr)
			{
				pcmd->UserCallback(cmd_list_imgui, pcmd);
			}
			else
			{
				ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x, (pcmd->ClipRect.y - clip_off.y) * clip_scale.y);
				ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x, (pcmd->ClipRect.w - clip_off.y) * clip_scale.y);

				if (clip_min.x < 0.0f)
				{
					clip_min.x = 0.0f;
				}
				if (clip_min.y < 0.0f)
				{
					clip_min.y = 0.0f;
				}
				if (clip_max.x > fb_width)
				{
					clip_max.x = (float) fb_width;
				}
				if (clip_max.y > fb_height)
				{
					clip_max.y = (float) fb_height;
				}
				if (clip_max.x < clip_min.x || clip_max.y < clip_min.y)
				{
					continue;
				}

				cmd_buffer->SetScissor((uint32_t) (clip_max.x - clip_min.x), (uint32_t) (clip_max.y - clip_min.y), (int32_t) (clip_min.x), (int32_t) (clip_min.y));

				if (current_texture != pcmd->TextureId)
				{
					auto texture = static_cast<RHITexture *>(pcmd->TextureId);
					gDescriptor->BindTexture("fontTexture", static_cast<RHITexture *>(pcmd->TextureId), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1});
					cmd_buffer->BindDescriptor(gDescriptor);
					cmd_buffer->BindPipelineState(gPipelineState);
					current_texture = pcmd->TextureId;
				}

				cmd_buffer->DrawIndexed(pcmd->ElemCount, 1, pcmd->IdxOffset + global_idx_offset, pcmd->VtxOffset + global_vtx_offset, 0);
			}
		}
		global_idx_offset += cmd_list_imgui->IdxBuffer.Size;
		global_vtx_offset += cmd_list_imgui->VtxBuffer.Size;
	}

	cmd_buffer->EndRenderPass();

	cmd_buffer->ResourceStateTransition({TextureStateTransition{
	                                        swapchain->GetCurrentTexture(),
	                                        RHIResourceState::RenderTarget,
	                                        RHIResourceState::Present,
	                                        TextureRange{
	                                            RHITextureDimension::Texture2D,
	                                            0, 1, 0, 1}}},
	                                    {});

	cmd_buffer->EndMarker();
	cmd_buffer->End();

	if (is_child_window)
	{
		resources->cmd_buffers.push_back(cmd_buffer);
	}
	else
	{
		gContext->Submit({cmd_buffer}, {}, {});
	}
}

static void ImGuiWindowCreate(ImGuiViewport *viewport)
{
	WindowData *window = new WindowData();

	window->swapchain = gContext->CreateSwapchain(
#ifdef _WIN32
	    glfwGetWin32Window((GLFWwindow *) viewport->PlatformHandle),
#endif        // _WIN32
	    static_cast<uint32_t>(viewport->Size.x),
	    static_cast<uint32_t>(viewport->Size.y),
	    gContext->IsVsync());

	window->viewport_data = std::make_unique<ViewportResources>();

	viewport->RendererUserData = window;
}

static void ImGuiWindowDestroy(ImGuiViewport *viewport)
{
	if (WindowData *window = static_cast<WindowData *>(viewport->RendererUserData))
	{
		gContext->WaitIdle();
		delete window;
	}
	viewport->RendererUserData = nullptr;
}

static void ImGuiWindowSetSize(ImGuiViewport *viewport, const ImVec2 size)
{
	static_cast<WindowData *>(viewport->RendererUserData)->swapchain->Resize(static_cast<uint32_t>(size.x), static_cast<uint32_t>(size.y), gContext->IsVsync());
}

static void ImGuiWindowRender(ImGuiViewport *viewport, void *)
{
	WindowData *window_data = static_cast<WindowData *>(viewport->RendererUserData);
	window_data->swapchain->AcquireNextTexture(window_data->viewport_data->present_completes.at(window_data->viewport_data->frame_index).get(), nullptr);
	RHI_Render(viewport->DrawData, window_data);
}

static void ImGuiWindowPresent(ImGuiViewport *viewport, void *)
{
	WindowData *window_data = static_cast<WindowData *>(viewport->RendererUserData);

	gContext->Execute(
	    std::move(window_data->viewport_data->cmd_buffers),
	    {window_data->viewport_data->present_completes.at(window_data->viewport_data->frame_index).get()},
	    {window_data->viewport_data->render_completes.at(window_data->viewport_data->frame_index).get()},
	    gContext->CreateFrameFence());
	window_data->viewport_data->cmd_buffers.clear();

	window_data->swapchain->Present(window_data->viewport_data->render_completes.at(window_data->viewport_data->frame_index).get());
	window_data->viewport_data->frame_index = (window_data->viewport_data->frame_index + 1) % 3;
}

void GuiContext::Render()
{
	RHI_Render(ImGui::GetDrawData());
}

Window *GuiContext::GetWindow() const
{
	return p_window;
}

void GuiContext::InitializePlatformInterface()
{
	ImGuiPlatformIO &platform_io       = ImGui::GetPlatformIO();
	platform_io.Renderer_CreateWindow  = ImGuiWindowCreate;
	platform_io.Renderer_DestroyWindow = ImGuiWindowDestroy;
	platform_io.Renderer_SetWindowSize = ImGuiWindowSetSize;
	platform_io.Renderer_RenderWindow  = ImGuiWindowRender;
	platform_io.Renderer_SwapBuffers   = ImGuiWindowPresent;
}
}        // namespace Ilum

================================================
FILE: Source/Editor/ImGui/ImGuiContext.hpp
================================================
#pragma once

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class GuiContext
{
  public:
	GuiContext(RHIContext *context, Window *window);

	~GuiContext();

	void BeginFrame();

	void EndFrame();

	void Render();

	Window *GetWindow() const;

  private:
	void SetStyle();

	void InitializePlatformInterface();

  private:
	RHIContext *p_context = nullptr;
	Window     *p_window  = nullptr;

	std::unique_ptr<RHIPipelineState> m_pipeline_state = nullptr;
	RHIDescriptor*    m_descriptor     = nullptr;

	RHISampler* m_sampler = nullptr;

	std::unique_ptr<RHIShader> m_vertex_shader   = nullptr;
	std::unique_ptr<RHIShader> m_fragment_shader = nullptr;

	std::unique_ptr<RHIRenderTarget> m_render_target = nullptr;

	std::unique_ptr<RHITexture> m_font_atlas = nullptr;

	size_t m_vertex_count = 0;
	size_t m_index_count  = 0;
};
}        // namespace Ilum

================================================
FILE: Source/Editor/Precompile.hpp
================================================
#pragma once

#include <Core/Core.hpp>


================================================
FILE: Source/Editor/Widget.hpp
================================================
#pragma once

#include <string>

namespace Ilum
{
class Editor;

class Widget
{
  public:
	Widget(const std::string &name, Editor *editor) :
	    m_name(name), p_editor(editor)
	{
	}

	virtual ~Widget() = default;

	virtual void Tick() = 0;

	inline bool &GetActive()
	{
		return m_active;
	}

	const std::string& GetName() const
	{
		return m_name;
	}

  protected:
	Editor *p_editor = nullptr;

	std::string m_name;

	bool m_active = true;
};
}        // namespace Ilum

================================================
FILE: Source/Engine/Engine.cpp
================================================
#include "Engine.hpp"

#include <Core/Path.hpp>
#include <Core/Window.hpp>
#include <Editor/Editor.hpp>
#include <RHI/RHIContext.hpp>
#include <Renderer/Renderer.hpp>
#include <Resource/ResourceManager.hpp>
#include <Scene/Scene.hpp>

namespace Ilum
{
Engine::Engine()
{
	m_window           = std::make_unique<Window>("Ilum", "Asset/Icon/logo.bmp");
	m_rhi_context      = std::make_unique<RHIContext>(m_window.get(), "Vulkan", true);
	m_resource_manager = std::make_unique<ResourceManager>(m_rhi_context.get());
	m_scene            = std::make_unique<Scene>("Default Scene");
	m_renderer         = std::make_unique<Renderer>(m_rhi_context.get(), m_scene.get(), m_resource_manager.get());
	m_editor           = std::make_unique<Editor>(m_window.get(), m_rhi_context.get(), m_renderer.get());

	Path::GetInstance().SetCurrent("./");
}

Engine::~Engine()
{
	m_scene.reset();
	m_editor.reset();
	m_renderer.reset();
	m_resource_manager.reset();
	m_rhi_context.reset();
	m_window.reset();
}

void Engine::Tick()
{
	while (m_window->Tick())
	{
		m_timer.Tick();

		if (m_window->GetWidth() != 0 && m_window->GetHeight() != 0)
		{
			m_rhi_context->BeginFrame();

			// Render loop
			m_renderer->Tick();

			// Update resource manager
			m_resource_manager->Tick();

			// Render UI
			m_editor->PreTick();
			m_editor->Tick();
			m_editor->PostTick();

			m_rhi_context->EndFrame();
		}
		else
		{
			std::this_thread::sleep_for(std::chrono::milliseconds(16));
		}

		m_window->SetTitle(fmt::format("IlumEngine v{} | Scene - {} | FPS - {}",
		                               "1.0Beta",
		                               m_scene->GetName(),
		                               m_timer.FrameRate()));
	}
}
}        // namespace Ilum


================================================
FILE: Source/Engine/Engine.hpp
================================================
#pragma once

#include <Core/Time.hpp>

namespace Ilum
{
class Window;
class RHIContext;
class Editor;
class ResourceManager;
class Renderer;
class Scene;

class Engine
{
  public:
	Engine();

	~Engine();

	void Tick();

  private:
	std::unique_ptr<Window>     m_window      = nullptr;
	std::unique_ptr<RHIContext> m_rhi_context = nullptr;
	std::unique_ptr<ResourceManager> m_resource_manager = nullptr;
	std::unique_ptr<Scene>      m_scene       = nullptr;
	std::unique_ptr<Renderer> m_renderer = nullptr;
	std::unique_ptr<Editor> m_editor = nullptr;

	Timer m_timer;
};
}        // namespace Ilum

================================================
FILE: Source/Engine/Precompile.hpp
================================================
#pragma once

#include <Core/Core.hpp>

================================================
FILE: Source/Engine/main.cpp
================================================
#include "Engine.hpp"

#include <ShaderCompiler/ShaderCompiler.hpp> 

int main()
{
	Ilum::Engine engine;
	//Ilum::ShaderCompiler::GetInstance();

	engine.Tick();

	return 0;
}

================================================
FILE: Source/External/dxc/inc/d3d12shader.h
================================================
//////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) Microsoft Corporation.
//  Licensed under the MIT license.
//
//  File:       D3D12Shader.h
//  Content:    D3D12 Shader Types and APIs
//
//////////////////////////////////////////////////////////////////////////////

#ifndef __D3D12SHADER_H__
#define __D3D12SHADER_H__

#include "d3dcommon.h"

typedef enum D3D12_SHADER_VERSION_TYPE
{
    D3D12_SHVER_PIXEL_SHADER          = 0,
    D3D12_SHVER_VERTEX_SHADER         = 1,
    D3D12_SHVER_GEOMETRY_SHADER       = 2,
    
    // D3D11 Shaders
    D3D12_SHVER_HULL_SHADER           = 3,
    D3D12_SHVER_DOMAIN_SHADER         = 4,
    D3D12_SHVER_COMPUTE_SHADER        = 5,

    // D3D12 Shaders
    D3D12_SHVER_LIBRARY               = 6,

    D3D12_SHVER_RAY_GENERATION_SHADER = 7,
    D3D12_SHVER_INTERSECTION_SHADER   = 8,
    D3D12_SHVER_ANY_HIT_SHADER        = 9,
    D3D12_SHVER_CLOSEST_HIT_SHADER    = 10,
    D3D12_SHVER_MISS_SHADER           = 11,
    D3D12_SHVER_CALLABLE_SHADER       = 12,

    D3D12_SHVER_MESH_SHADER           = 13,
    D3D12_SHVER_AMPLIFICATION_SHADER  = 14,

    D3D12_SHVER_RESERVED0             = 0xFFF0,
} D3D12_SHADER_VERSION_TYPE;

#define D3D12_SHVER_GET_TYPE(_Version) \
    (((_Version) >> 16) & 0xffff)
#define D3D12_SHVER_GET_MAJOR(_Version) \
    (((_Version) >> 4) & 0xf)
#define D3D12_SHVER_GET_MINOR(_Version) \
    (((_Version) >> 0) & 0xf)

// Slot ID for library function return
#define D3D_RETURN_PARAMETER_INDEX (-1)

typedef D3D_RESOURCE_RETURN_TYPE D3D12_RESOURCE_RETURN_TYPE;

typedef D3D_CBUFFER_TYPE D3D12_CBUFFER_TYPE;


typedef struct _D3D12_SIGNATURE_PARAMETER_DESC
{
    LPCSTR                      SemanticName;   // Name of the semantic
    UINT                        SemanticIndex;  // Index of the semantic
    UINT                        Register;       // Number of member variables
    D3D_NAME                    SystemValueType;// A predefined system value, or D3D_NAME_UNDEFINED if not applicable
    D3D_REGISTER_COMPONENT_TYPE ComponentType;  // Scalar type (e.g. uint, float, etc.)
    BYTE                        Mask;           // Mask to indicate which components of the register
                                                // are used (combination of D3D10_COMPONENT_MASK values)
    BYTE                        ReadWriteMask;  // Mask to indicate whether a given component is 
                                                // never written (if this is an output signature) or
                                                // always read (if this is an input signature).
                                                // (combination of D3D_MASK_* values)
    UINT                        Stream;         // Stream index
    D3D_MIN_PRECISION           MinPrecision;   // Minimum desired interpolation precision
} D3D12_SIGNATURE_PARAMETER_DESC;

typedef struct _D3D12_SHADER_BUFFER_DESC
{
    LPCSTR                  Name;           // Name of the constant buffer
    D3D_CBUFFER_TYPE        Type;           // Indicates type of buffer content
    UINT                    Variables;      // Number of member variables
    UINT                    Size;           // Size of CB (in bytes)
    UINT                    uFlags;         // Buffer description flags
} D3D12_SHADER_BUFFER_DESC;

typedef struct _D3D12_SHADER_VARIABLE_DESC
{
    LPCSTR                  Name;           // Name of the variable
    UINT                    StartOffset;    // Offset in constant buffer's backing store
    UINT                    Size;           // Size of variable (in bytes)
    UINT                    uFlags;         // Variable flags
    LPVOID                  DefaultValue;   // Raw pointer to default value
    UINT                    StartTexture;   // First texture index (or -1 if no textures used)
    UINT                    TextureSize;    // Number of texture slots possibly used.
    UINT                    StartSampler;   // First sampler index (or -1 if no textures used)
    UINT                    SamplerSize;    // Number of sampler slots possibly used.
} D3D12_SHADER_VARIABLE_DESC;

typedef struct _D3D12_SHADER_TYPE_DESC
{
    D3D_SHADER_VARIABLE_CLASS   Class;          // Variable class (e.g. object, matrix, etc.)
    D3D_SHADER_VARIABLE_TYPE    Type;           // Variable type (e.g. float, sampler, etc.)
    UINT                        Rows;           // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)
    UINT                        Columns;        // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)
    UINT                        Elements;       // Number of elements (0 if not an array)
    UINT                        Members;        // Number of members (0 if not a structure)
    UINT                        Offset;         // Offset from the start of structure (0 if not a structure member)
    LPCSTR                      Name;           // Name of type, can be NULL
} D3D12_SHADER_TYPE_DESC;

typedef D3D_TESSELLATOR_DOMAIN D3D12_TESSELLATOR_DOMAIN;

typedef D3D_TESSELLATOR_PARTITIONING D3D12_TESSELLATOR_PARTITIONING;

typedef D3D_TESSELLATOR_OUTPUT_PRIMITIVE D3D12_TESSELLATOR_OUTPUT_PRIMITIVE;

typedef struct _D3D12_SHADER_DESC
{
    UINT                    Version;                     // Shader version
    LPCSTR                  Creator;                     // Creator string
    UINT                    Flags;                       // Shader compilation/parse flags
    
    UINT                    ConstantBuffers;             // Number of constant buffers
    UINT                    BoundResources;              // Number of bound resources
    UINT                    InputParameters;             // Number of parameters in the input signature
    UINT                    OutputParameters;            // Number of parameters in the output signature

    UINT                    InstructionCount;            // Number of emitted instructions
    UINT                    TempRegisterCount;           // Number of temporary registers used 
    UINT                    TempArrayCount;              // Number of temporary arrays used
    UINT                    DefCount;                    // Number of constant defines 
    UINT                    DclCount;                    // Number of declarations (input + output)
    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
    UINT                    TextureLoadInstructions;     // Number of texture load instructions
    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
    UINT                    MacroInstructionCount;       // Number of macro instructions used
    UINT                    ArrayInstructionCount;       // Number of array instructions used
    UINT                    CutInstructionCount;         // Number of cut instructions used
    UINT                    EmitInstructionCount;        // Number of emit instructions used
    D3D_PRIMITIVE_TOPOLOGY  GSOutputTopology;            // Geometry shader output topology
    UINT                    GSMaxOutputVertexCount;      // Geometry shader maximum output vertex count
    D3D_PRIMITIVE           InputPrimitive;              // GS/HS input primitive
    UINT                    PatchConstantParameters;     // Number of parameters in the patch constant signature
    UINT                    cGSInstanceCount;            // Number of Geometry shader instances
    UINT                    cControlPoints;              // Number of control points in the HS->DS stage
    D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive;  // Primitive output by the tessellator
    D3D_TESSELLATOR_PARTITIONING HSPartitioning;         // Partitioning mode of the tessellator
    D3D_TESSELLATOR_DOMAIN  TessellatorDomain;           // Domain of the tessellator (quad, tri, isoline)
    // instruction counts
    UINT cBarrierInstructions;                           // Number of barrier instructions in a compute shader
    UINT cInterlockedInstructions;                       // Number of interlocked instructions
    UINT cTextureStoreInstructions;                      // Number of texture writes
} D3D12_SHADER_DESC;

typedef struct _D3D12_SHADER_INPUT_BIND_DESC
{
    LPCSTR                      Name;           // Name of the resource
    D3D_SHADER_INPUT_TYPE       Type;           // Type of resource (e.g. texture, cbuffer, etc.)
    UINT                        BindPoint;      // Starting bind point
    UINT                        BindCount;      // Number of contiguous bind points (for arrays)

    UINT                        uFlags;         // Input binding flags
    D3D_RESOURCE_RETURN_TYPE    ReturnType;     // Return type (if texture)
    D3D_SRV_DIMENSION           Dimension;      // Dimension (if texture)
    UINT                        NumSamples;     // Number of samples (0 if not MS texture)
    UINT                        Space;          // Register space
    UINT uID;                                   // Range ID in the bytecode
} D3D12_SHADER_INPUT_BIND_DESC;

#define D3D_SHADER_REQUIRES_DOUBLES                                                         0x00000001
#define D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL                                             0x00000002
#define D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE                                             0x00000004
#define D3D_SHADER_REQUIRES_64_UAVS                                                         0x00000008
#define D3D_SHADER_REQUIRES_MINIMUM_PRECISION                                               0x00000010
#define D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS                                          0x00000020
#define D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS                                          0x00000040
#define D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING                                    0x00000080
#define D3D_SHADER_REQUIRES_TILED_RESOURCES                                                 0x00000100
#define D3D_SHADER_REQUIRES_STENCIL_REF                                                     0x00000200
#define D3D_SHADER_REQUIRES_INNER_COVERAGE                                                  0x00000400
#define D3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                               0x00000800
#define D3D_SHADER_REQUIRES_ROVS                                                            0x00001000
#define D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER  0x00002000
#define D3D_SHADER_REQUIRES_WAVE_OPS                                                        0x00004000
#define D3D_SHADER_REQUIRES_INT64_OPS                                                       0x00008000
#define D3D_SHADER_REQUIRES_VIEW_ID                                                         0x00010000
#define D3D_SHADER_REQUIRES_BARYCENTRICS                                                    0x00020000
#define D3D_SHADER_REQUIRES_NATIVE_16BIT_OPS                                                0x00040000
#define D3D_SHADER_REQUIRES_SHADING_RATE                                                    0x00080000
#define D3D_SHADER_REQUIRES_RAYTRACING_TIER_1_1                                             0x00100000
#define D3D_SHADER_REQUIRES_SAMPLER_FEEDBACK                                                0x00200000
#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_TYPED_RESOURCE                                  0x00400000
#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_GROUP_SHARED                                    0x00800000
#define D3D_SHADER_REQUIRES_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                   0x01000000
#define D3D_SHADER_REQUIRES_RESOURCE_DESCRIPTOR_HEAP_INDEXING                               0x02000000
#define D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING                                0x04000000
#define D3D_SHADER_REQUIRES_WAVE_MMA                                                        0x08000000
#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                        0x10000000

typedef struct _D3D12_LIBRARY_DESC
{
    LPCSTR    Creator;           // The name of the originator of the library.
    UINT      Flags;             // Compilation flags.
    UINT      FunctionCount;     // Number of functions exported from the library.
} D3D12_LIBRARY_DESC;

typedef struct _D3D12_FUNCTION_DESC
{
    UINT                    Version;                     // Shader version
    LPCSTR                  Creator;                     // Creator string
    UINT                    Flags;                       // Shader compilation/parse flags
    
    UINT                    ConstantBuffers;             // Number of constant buffers
    UINT                    BoundResources;              // Number of bound resources

    UINT                    InstructionCount;            // Number of emitted instructions
    UINT                    TempRegisterCount;           // Number of temporary registers used 
    UINT                    TempArrayCount;              // Number of temporary arrays used
    UINT                    DefCount;                    // Number of constant defines 
    UINT                    DclCount;                    // Number of declarations (input + output)
    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
    UINT                    TextureLoadInstructions;     // Number of texture load instructions
    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
    UINT                    MacroInstructionCount;       // Number of macro instructions used
    UINT                    ArrayInstructionCount;       // Number of array instructions used
    UINT                    MovInstructionCount;         // Number of mov instructions used
    UINT                    MovcInstructionCount;        // Number of movc instructions used
    UINT                    ConversionInstructionCount;  // Number of type conversion instructions used
    UINT                    BitwiseInstructionCount;     // Number of bitwise arithmetic instructions used
    D3D_FEATURE_LEVEL       MinFeatureLevel;             // Min target of the function byte code
    UINT64                  RequiredFeatureFlags;        // Required feature flags

    LPCSTR                  Name;                        // Function name
    INT                     FunctionParameterCount;      // Number of logical parameters in the function signature (not including return)
    BOOL                    HasReturn;                   // TRUE, if function returns a value, false - it is a subroutine
    BOOL                    Has10Level9VertexShader;     // TRUE, if there is a 10L9 VS blob
    BOOL                    Has10Level9PixelShader;      // TRUE, if there is a 10L9 PS blob
} D3D12_FUNCTION_DESC;

typedef struct _D3D12_PARAMETER_DESC
{
    LPCSTR                      Name;               // Parameter name.
    LPCSTR                      SemanticName;       // Parameter semantic name (+index).
    D3D_SHADER_VARIABLE_TYPE    Type;               // Element type.
    D3D_SHADER_VARIABLE_CLASS   Class;              // Scalar/Vector/Matrix.
    UINT                        Rows;               // Rows are for matrix parameters.
    UINT                        Columns;            // Components or Columns in matrix.
    D3D_INTERPOLATION_MODE      InterpolationMode;  // Interpolation mode.
    D3D_PARAMETER_FLAGS         Flags;              // Parameter modifiers.

    UINT                        FirstInRegister;    // The first input register for this parameter.
    UINT                        FirstInComponent;   // The first input register component for this parameter.
    UINT                        FirstOutRegister;   // The first output register for this parameter.
    UINT                        FirstOutComponent;  // The first output register component for this parameter.
} D3D12_PARAMETER_DESC;


//////////////////////////////////////////////////////////////////////////////
// Interfaces ////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

typedef interface ID3D12ShaderReflectionType ID3D12ShaderReflectionType;
typedef interface ID3D12ShaderReflectionType *LPD3D12SHADERREFLECTIONTYPE;

typedef interface ID3D12ShaderReflectionVariable ID3D12ShaderReflectionVariable;
typedef interface ID3D12ShaderReflectionVariable *LPD3D12SHADERREFLECTIONVARIABLE;

typedef interface ID3D12ShaderReflectionConstantBuffer ID3D12ShaderReflectionConstantBuffer;
typedef interface ID3D12ShaderReflectionConstantBuffer *LPD3D12SHADERREFLECTIONCONSTANTBUFFER;

typedef interface ID3D12ShaderReflection ID3D12ShaderReflection;
typedef interface ID3D12ShaderReflection *LPD3D12SHADERREFLECTION;

typedef interface ID3D12LibraryReflection ID3D12LibraryReflection;
typedef interface ID3D12LibraryReflection *LPD3D12LIBRARYREFLECTION;

typedef interface ID3D12FunctionReflection ID3D12FunctionReflection;
typedef interface ID3D12FunctionReflection *LPD3D12FUNCTIONREFLECTION;

typedef interface ID3D12FunctionParameterReflection ID3D12FunctionParameterReflection;
typedef interface ID3D12FunctionParameterReflection *LPD3D12FUNCTIONPARAMETERREFLECTION;


// {E913C351-783D-48CA-A1D1-4F306284AD56}
interface DECLSPEC_UUID("E913C351-783D-48CA-A1D1-4F306284AD56") ID3D12ShaderReflectionType;
DEFINE_GUID(IID_ID3D12ShaderReflectionType, 
0xe913c351, 0x783d, 0x48ca, 0xa1, 0xd1, 0x4f, 0x30, 0x62, 0x84, 0xad, 0x56);

#undef INTERFACE
#define INTERFACE ID3D12ShaderReflectionType

DECLARE_INTERFACE(ID3D12ShaderReflectionType)
{
    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_TYPE_DESC *pDesc) PURE;
    
    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByIndex)(THIS_ _In_ UINT Index) PURE;
    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByName)(THIS_ _In_ LPCSTR Name) PURE;
    STDMETHOD_(LPCSTR, GetMemberTypeName)(THIS_ _In_ UINT Index) PURE;

    STDMETHOD(IsEqual)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
    STDMETHOD_(ID3D12ShaderReflectionType*, GetSubType)(THIS) PURE;
    STDMETHOD_(ID3D12ShaderReflectionType*, GetBaseClass)(THIS) PURE;
    STDMETHOD_(UINT, GetNumInterfaces)(THIS) PURE;
    STDMETHOD_(ID3D12ShaderReflectionType*, GetInterfaceByIndex)(THIS_ _In_ UINT uIndex) PURE;
    STDMETHOD(IsOfType)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
    STDMETHOD(ImplementsInterface)(THIS_ _In_ ID3D12ShaderReflectionType* pBase) PURE;
};

// {8337A8A6-A216-444A-B2F4-314733A73AEA}
interface DECLSPEC_UUID("8337A8A6-A216-444A-B2F4-314733A73AEA") ID3D12ShaderReflectionVariable;
DEFINE_GUID(IID_ID3D12ShaderReflectionVariable, 
0x8337a8a6, 0xa216, 0x444a, 0xb2, 0xf4, 0x31, 0x47, 0x33, 0xa7, 0x3a, 0xea);

#undef INTERFACE
#define INTERFACE ID3D12ShaderReflectionVariable

DECLARE_INTERFACE(ID3D12ShaderReflectionVariable)
{
    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_VARIABLE_DESC *pDesc) PURE;
    
    STDMETHOD_(ID3D12ShaderReflectionType*, GetType)(THIS) PURE;
    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetBuffer)(THIS) PURE;

    STDMETHOD_(UINT, GetInterfaceSlot)(THIS_ _In_ UINT uArrayIndex) PURE;
};

// {C59598B4-48B3-4869-B9B1-B1618B14A8B7}
interface DECLSPEC_UUID("C59598B4-48B3-4869-B9B1-B1618B14A8B7") ID3D12ShaderReflectionConstantBuffer;
DEFINE_GUID(IID_ID3D12ShaderReflectionConstantBuffer, 
0xc59598b4, 0x48b3, 0x4869, 0xb9, 0xb1, 0xb1, 0x61, 0x8b, 0x14, 0xa8, 0xb7);

#undef INTERFACE
#define INTERFACE ID3D12ShaderReflectionConstantBuffer

DECLARE_INTERFACE(ID3D12ShaderReflectionConstantBuffer)
{
    STDMETHOD(GetDesc)(THIS_ D3D12_SHADER_BUFFER_DESC *pDesc) PURE;
    
    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByIndex)(THIS_ _In_ UINT Index) PURE;
    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
};

// The ID3D12ShaderReflection IID may change from SDK version to SDK version
// if the reflection API changes.  This prevents new code with the new API
// from working with an old binary.  Recompiling with the new header
// will pick up the new IID.

// {5A58797D-A72C-478D-8BA2-EFC6B0EFE88E}
interface DECLSPEC_UUID("5A58797D-A72C-478D-8BA2-EFC6B0EFE88E") ID3D12ShaderReflection;
DEFINE_GUID(IID_ID3D12ShaderReflection, 
0x5a58797d, 0xa72c, 0x478d, 0x8b, 0xa2, 0xef, 0xc6, 0xb0, 0xef, 0xe8, 0x8e);

#undef INTERFACE
#define INTERFACE ID3D12ShaderReflection

DECLARE_INTERFACE_(ID3D12ShaderReflection, IUnknown)
{
    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid,
                              _Out_ LPVOID *ppv) PURE;
    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
    STDMETHOD_(ULONG, Release)(THIS) PURE;

    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_DESC *pDesc) PURE;
    
    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ _In_ UINT Index) PURE;
    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
    
    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
    
    STDMETHOD(GetInputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
                                     _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
    STDMETHOD(GetOutputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
                                      _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
    STDMETHOD(GetPatchConstantParameterDesc)(THIS_ _In_ UINT ParameterIndex,
                                             _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;

    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;

    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;

    STDMETHOD_(UINT, GetMovInstructionCount)(THIS) PURE;
    STDMETHOD_(UINT, GetMovcInstructionCount)(THIS) PURE;
    STDMETHOD_(UINT, GetConversionInstructionCount)(THIS) PURE;
    STDMETHOD_(UINT, GetBitwiseInstructionCount)(THIS) PURE;
    
    STDMETHOD_(D3D_PRIMITIVE, GetGSInputPrimitive)(THIS) PURE;
    STDMETHOD_(BOOL, IsSampleFrequencyShader)(THIS) PURE;

    STDMETHOD_(UINT, GetNumInterfaceSlots)(THIS) PURE;
    STDMETHOD(GetMinFeatureLevel)(THIS_ _Out_ enum D3D_FEATURE_LEVEL* pLevel) PURE;

    STDMETHOD_(UINT, GetThreadGroupSize)(THIS_
                                         _Out_opt_ UINT* pSizeX,
                                         _Out_opt_ UINT* pSizeY,
                                         _Out_opt_ UINT* pSizeZ) PURE;

    STDMETHOD_(UINT64, GetRequiresFlags)(THIS) PURE;
};

// {8E349D19-54DB-4A56-9DC9-119D87BDB804}
interface DECLSPEC_UUID("8E349D19-54DB-4A56-9DC9-119D87BDB804") ID3D12LibraryReflection;
DEFINE_GUID(IID_ID3D12LibraryReflection, 
0x8e349d19, 0x54db, 0x4a56, 0x9d, 0xc9, 0x11, 0x9d, 0x87, 0xbd, 0xb8, 0x4);

#undef INTERFACE
#define INTERFACE ID3D12LibraryReflection

DECLARE_INTERFACE_(ID3D12LibraryReflection, IUnknown)
{
    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
    STDMETHOD_(ULONG, Release)(THIS) PURE;

    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_LIBRARY_DESC * pDesc) PURE;
    
    STDMETHOD_(ID3D12FunctionReflection *, GetFunctionByIndex)(THIS_ _In_ INT FunctionIndex) PURE;
};

// {1108795C-2772-4BA9-B2A8-D464DC7E2799}
interface DECLSPEC_UUID("1108795C-2772-4BA9-B2A8-D464DC7E2799") ID3D12FunctionReflection;
DEFINE_GUID(IID_ID3D12FunctionReflection, 
0x1108795c, 0x2772, 0x4ba9, 0xb2, 0xa8, 0xd4, 0x64, 0xdc, 0x7e, 0x27, 0x99);

#undef INTERFACE
#define INTERFACE ID3D12FunctionReflection

DECLARE_INTERFACE(ID3D12FunctionReflection)
{
    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_FUNCTION_DESC * pDesc) PURE;
    
    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByIndex)(THIS_ _In_ UINT BufferIndex) PURE;
    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
    
    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
    
    STDMETHOD_(ID3D12ShaderReflectionVariable *, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;

    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;

    // Use D3D_RETURN_PARAMETER_INDEX to get description of the return value.
    STDMETHOD_(ID3D12FunctionParameterReflection *, GetFunctionParameter)(THIS_ _In_ INT ParameterIndex) PURE;
};

// {EC25F42D-7006-4F2B-B33E-02CC3375733F}
interface DECLSPEC_UUID("EC25F42D-7006-4F2B-B33E-02CC3375733F") ID3D12FunctionParameterReflection;
DEFINE_GUID(IID_ID3D12FunctionParameterReflection, 
0xec25f42d, 0x7006, 0x4f2b, 0xb3, 0x3e, 0x2, 0xcc, 0x33, 0x75, 0x73, 0x3f);

#undef INTERFACE
#define INTERFACE ID3D12FunctionParameterReflection

DECLARE_INTERFACE(ID3D12FunctionParameterReflection)
{
    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_PARAMETER_DESC * pDesc) PURE;
};


//////////////////////////////////////////////////////////////////////////////
// APIs //////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifdef __cplusplus
extern "C" {
#endif //__cplusplus

#ifdef __cplusplus
}
#endif //__cplusplus
    
#endif //__D3D12SHADER_H__



================================================
FILE: Source/External/dxc/inc/dxcapi.h
================================================

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// dxcapi.h                                                                  //
// Copyright (C) Microsoft Corporation. All rights reserved.                 //
// This file is distributed under the University of Illinois Open Source     //
// License. See LICENSE.TXT for details.                                     //
//                                                                           //
// Provides declarations for the DirectX Compiler API entry point.           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#ifndef __DXC_API__
#define __DXC_API__

#ifdef _WIN32
#ifndef DXC_API_IMPORT
#define DXC_API_IMPORT __declspec(dllimport)
#endif
#else
#ifndef DXC_API_IMPORT
#define DXC_API_IMPORT __attribute__ ((visibility ("default")))
#endif
#endif

#ifdef _WIN32

#ifndef CROSS_PLATFORM_UUIDOF
// Warning: This macro exists in WinAdapter.h as well
#define CROSS_PLATFORM_UUIDOF(interface, spec)                                 \
  struct __declspec(uuid(spec)) interface;
#endif

#else

#include <dlfcn.h>
#include "dxc/Support/WinAdapter.h"
#endif

struct IMalloc;

struct IDxcIncludeHandler;

typedef HRESULT (__stdcall *DxcCreateInstanceProc)(
    _In_ REFCLSID   rclsid,
    _In_ REFIID     riid,
    _Out_ LPVOID*   ppv
);

typedef HRESULT(__stdcall *DxcCreateInstance2Proc)(
  _In_ IMalloc    *pMalloc,
  _In_ REFCLSID   rclsid,
  _In_ REFIID     riid,
  _Out_ LPVOID*   ppv
  );

/// <summary>
/// Creates a single uninitialized object of the class associated with a specified CLSID.
/// </summary>
/// <param name="rclsid">
/// The CLSID associated with the data and code that will be used to create the object.
/// </param>
/// <param name="riid">
/// A reference to the identifier of the interface to be used to communicate
/// with the object.
/// </param>
/// <param name="ppv">
/// Address of pointer variable that receives the interface pointer requested
/// in riid. Upon successful return, *ppv contains the requested interface
/// pointer. Upon failure, *ppv contains NULL.</param>
/// <remarks>
/// While this function is similar to CoCreateInstance, there is no COM involvement.
/// </remarks>

extern "C"
DXC_API_IMPORT HRESULT __stdcall DxcCreateInstance(
  _In_ REFCLSID   rclsid,
  _In_ REFIID     riid,
  _Out_ LPVOID*   ppv
  );

extern "C"
DXC_API_IMPORT HRESULT __stdcall DxcCreateInstance2(
  _In_ IMalloc    *pMalloc,
  _In_ REFCLSID   rclsid,
  _In_ REFIID     riid,
  _Out_ LPVOID*   ppv
);

// For convenience, equivalent definitions to CP_UTF8 and CP_UTF16.
#define DXC_CP_UTF8 65001
#define DXC_CP_UTF16 1200
#define DXC_CP_UTF32 12000
// Use DXC_CP_ACP for: Binary;  ANSI Text;  Autodetect UTF with BOM
#define DXC_CP_ACP 0

#ifdef _WIN32
#define DXC_CP_WIDE DXC_CP_UTF16
#else
#define DXC_CP_WIDE DXC_CP_UTF32
#endif

// This flag indicates that the shader hash was computed taking into account source information (-Zss)
#define DXC_HASHFLAG_INCLUDES_SOURCE  1

// Hash digest type for ShaderHash
typedef struct DxcShaderHash {
  UINT32 Flags; // DXC_HASHFLAG_*
  BYTE HashDigest[16];
} DxcShaderHash;

#define DXC_FOURCC(ch0, ch1, ch2, ch3) (                     \
  (UINT32)(UINT8)(ch0)        | (UINT32)(UINT8)(ch1) << 8  | \
  (UINT32)(UINT8)(ch2) << 16  | (UINT32)(UINT8)(ch3) << 24   \
  )
#define DXC_PART_PDB                      DXC_FOURCC('I', 'L', 'D', 'B')
#define DXC_PART_PDB_NAME                 DXC_FOURCC('I', 'L', 'D', 'N')
#define DXC_PART_PRIVATE_DATA             DXC_FOURCC('P', 'R', 'I', 'V')
#define DXC_PART_ROOT_SIGNATURE           DXC_FOURCC('R', 'T', 'S', '0')
#define DXC_PART_DXIL                     DXC_FOURCC('D', 'X', 'I', 'L')
#define DXC_PART_REFLECTION_DATA          DXC_FOURCC('S', 'T', 'A', 'T')
#define DXC_PART_SHADER_HASH              DXC_FOURCC('H', 'A', 'S', 'H')
#define DXC_PART_INPUT_SIGNATURE          DXC_FOURCC('I', 'S', 'G', '1')
#define DXC_PART_OUTPUT_SIGNATURE         DXC_FOURCC('O', 'S', 'G', '1')
#define DXC_PART_PATCH_CONSTANT_SIGNATURE DXC_FOURCC('P', 'S', 'G', '1')

// Some option arguments are defined here for continuity with D3DCompile interface
#define DXC_ARG_DEBUG L"-Zi"
#define DXC_ARG_SKIP_VALIDATION L"-Vd"
#define DXC_ARG_SKIP_OPTIMIZATIONS L"-Od"
#define DXC_ARG_PACK_MATRIX_ROW_MAJOR L"-Zpr"
#define DXC_ARG_PACK_MATRIX_COLUMN_MAJOR L"-Zpc"
#define DXC_ARG_AVOID_FLOW_CONTROL L"-Gfa"
#define DXC_ARG_PREFER_FLOW_CONTROL L"-Gfp"
#define DXC_ARG_ENABLE_STRICTNESS L"-Ges"
#define DXC_ARG_ENABLE_BACKWARDS_COMPATIBILITY L"-Gec"
#define DXC_ARG_IEEE_STRICTNESS L"-Gis"
#define DXC_ARG_OPTIMIZATION_LEVEL0 L"-O0"
#define DXC_ARG_OPTIMIZATION_LEVEL1 L"-O1"
#define DXC_ARG_OPTIMIZATION_LEVEL2 L"-O2"
#define DXC_ARG_OPTIMIZATION_LEVEL3 L"-O3"
#define DXC_ARG_WARNINGS_ARE_ERRORS L"-WX"
#define DXC_ARG_RESOURCES_MAY_ALIAS L"-res_may_alias"
#define DXC_ARG_ALL_RESOURCES_BOUND L"-all_resources_bound"
#define DXC_ARG_DEBUG_NAME_FOR_SOURCE L"-Zss"
#define DXC_ARG_DEBUG_NAME_FOR_BINARY L"-Zsb"

// IDxcBlob is an alias of ID3D10Blob and ID3DBlob
CROSS_PLATFORM_UUIDOF(IDxcBlob, "8BA5FB08-5195-40e2-AC58-0D989C3A0102")
struct IDxcBlob : public IUnknown {
public:
  virtual LPVOID STDMETHODCALLTYPE GetBufferPointer(void) = 0;
  virtual SIZE_T STDMETHODCALLTYPE GetBufferSize(void) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcBlobEncoding, "7241d424-2646-4191-97c0-98e96e42fc68")
struct IDxcBlobEncoding : public IDxcBlob {
public:
  virtual HRESULT STDMETHODCALLTYPE GetEncoding(_Out_ BOOL *pKnown,
                                                _Out_ UINT32 *pCodePage) = 0;
};

// Notes on IDxcBlobWide and IDxcBlobUtf8
// These guarantee null-terminated text and eithre utf8 or the native wide char encoding.
// GetBufferSize() will return the size in bytes, including null-terminator
// GetStringLength() will return the length in characters, excluding the null-terminator
// Name strings will use IDxcBlobWide, while other string output blobs,
// such as errors/warnings, preprocessed HLSL, or other text will be based
// on the -encoding option.

// The API will use this interface for output name strings
CROSS_PLATFORM_UUIDOF(IDxcBlobWide, "A3F84EAB-0FAA-497E-A39C-EE6ED60B2D84")
struct IDxcBlobWide : public IDxcBlobEncoding {
public:
  virtual LPCWSTR STDMETHODCALLTYPE GetStringPointer(void) = 0;
  virtual SIZE_T STDMETHODCALLTYPE GetStringLength(void) = 0;
};
CROSS_PLATFORM_UUIDOF(IDxcBlobUtf8, "3DA636C9-BA71-4024-A301-30CBF125305B")
struct IDxcBlobUtf8 : public IDxcBlobEncoding {
public:
  virtual LPCSTR STDMETHODCALLTYPE GetStringPointer(void) = 0;
  virtual SIZE_T STDMETHODCALLTYPE GetStringLength(void) = 0;
};

// Define legacy name IDxcBlobUtf16 as IDxcBlobWide for Win32
#ifdef _WIN32
typedef IDxcBlobWide IDxcBlobUtf16;
#endif

CROSS_PLATFORM_UUIDOF(IDxcIncludeHandler, "7f61fc7d-950d-467f-b3e3-3c02fb49187c")
struct IDxcIncludeHandler : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE LoadSource(
    _In_z_ LPCWSTR pFilename,                                 // Candidate filename.
    _COM_Outptr_result_maybenull_ IDxcBlob **ppIncludeSource  // Resultant source object for included file, nullptr if not found.
    ) = 0;
};

// Structure for supplying bytes or text input to Dxc APIs.
// Use Encoding = 0 for non-text bytes, ANSI text, or unknown with BOM.
typedef struct DxcBuffer {
  LPCVOID Ptr;
  SIZE_T Size;
  UINT Encoding;
} DxcText;

struct DxcDefine {
  LPCWSTR Name;
  _Maybenull_ LPCWSTR Value;
};

CROSS_PLATFORM_UUIDOF(IDxcCompilerArgs, "73EFFE2A-70DC-45F8-9690-EFF64C02429D")
struct IDxcCompilerArgs : public IUnknown {
  // Pass GetArguments() and GetCount() to Compile
  virtual LPCWSTR* STDMETHODCALLTYPE GetArguments() = 0;
  virtual UINT32 STDMETHODCALLTYPE GetCount() = 0;

  // Add additional arguments or defines here, if desired.
  virtual HRESULT STDMETHODCALLTYPE AddArguments(
    _In_opt_count_(argCount) LPCWSTR *pArguments,       // Array of pointers to arguments to add
    _In_ UINT32 argCount                                // Number of arguments to add
  ) = 0;
  virtual HRESULT STDMETHODCALLTYPE AddArgumentsUTF8(
    _In_opt_count_(argCount)LPCSTR *pArguments,         // Array of pointers to UTF-8 arguments to add
    _In_ UINT32 argCount                                // Number of arguments to add
  ) = 0;
  virtual HRESULT STDMETHODCALLTYPE AddDefines(
      _In_count_(defineCount) const DxcDefine *pDefines, // Array of defines
      _In_ UINT32 defineCount                            // Number of defines
  ) = 0;
};

//////////////////////////
// Legacy Interfaces
/////////////////////////

// NOTE: IDxcUtils replaces IDxcLibrary
CROSS_PLATFORM_UUIDOF(IDxcLibrary, "e5204dc7-d18c-4c3c-bdfb-851673980fe7")
struct IDxcLibrary : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE SetMalloc(_In_opt_ IMalloc *pMalloc) = 0;
  virtual HRESULT STDMETHODCALLTYPE CreateBlobFromBlob(
    _In_ IDxcBlob *pBlob, UINT32 offset, UINT32 length, _COM_Outptr_ IDxcBlob **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE CreateBlobFromFile(
    _In_z_ LPCWSTR pFileName, _In_opt_ UINT32* codePage,
    _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
  virtual HRESULT STDMETHODCALLTYPE CreateBlobWithEncodingFromPinned(
    _In_bytecount_(size) LPCVOID pText, UINT32 size, UINT32 codePage,
    _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
  virtual HRESULT STDMETHODCALLTYPE CreateBlobWithEncodingOnHeapCopy(
    _In_bytecount_(size) LPCVOID pText, UINT32 size, UINT32 codePage,
    _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
  virtual HRESULT STDMETHODCALLTYPE CreateBlobWithEncodingOnMalloc(
    _In_bytecount_(size) LPCVOID pText, IMalloc *pIMalloc, UINT32 size, UINT32 codePage,
    _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
  virtual HRESULT STDMETHODCALLTYPE CreateIncludeHandler(
    _COM_Outptr_ IDxcIncludeHandler **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE CreateStreamFromBlobReadOnly(
    _In_ IDxcBlob *pBlob, _COM_Outptr_ IStream **ppStream) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetBlobAsUtf8(
    _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;

  // Renamed from GetBlobAsUtf16 to GetBlobAsWide
  virtual HRESULT STDMETHODCALLTYPE GetBlobAsWide(
    _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;

#ifdef _WIN32
  // Alias to GetBlobAsWide on Win32
  inline HRESULT GetBlobAsUtf16(
    _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) {
    return this->GetBlobAsWide(pBlob, pBlobEncoding);
  }
#endif
};

// NOTE: IDxcResult replaces IDxcOperationResult
CROSS_PLATFORM_UUIDOF(IDxcOperationResult, "CEDB484A-D4E9-445A-B991-CA21CA157DC2")
struct IDxcOperationResult : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE GetStatus(_Out_ HRESULT *pStatus) = 0;

  // GetResult returns the main result of the operation.
  // This corresponds to:
  // DXC_OUT_OBJECT - Compile() with shader or library target
  // DXC_OUT_DISASSEMBLY - Disassemble()
  // DXC_OUT_HLSL - Compile() with -P
  // DXC_OUT_ROOT_SIGNATURE - Compile() with rootsig_* target
  virtual HRESULT STDMETHODCALLTYPE GetResult(_COM_Outptr_result_maybenull_ IDxcBlob **ppResult) = 0;

  // GetErrorBuffer Corresponds to DXC_OUT_ERRORS.
  virtual HRESULT STDMETHODCALLTYPE GetErrorBuffer(_COM_Outptr_result_maybenull_ IDxcBlobEncoding **ppErrors) = 0;
};

// NOTE: IDxcCompiler3 replaces IDxcCompiler and IDxcCompiler2
CROSS_PLATFORM_UUIDOF(IDxcCompiler, "8c210bf3-011f-4422-8d70-6f9acb8db617")
struct IDxcCompiler : public IUnknown {
  // Compile a single entry point to the target shader model
  virtual HRESULT STDMETHODCALLTYPE Compile(
    _In_ IDxcBlob *pSource,                       // Source text to compile
    _In_opt_z_ LPCWSTR pSourceName,               // Optional file name for pSource. Used in errors and include handlers.
    _In_opt_z_ LPCWSTR pEntryPoint,               // entry point name
    _In_z_ LPCWSTR pTargetProfile,                // shader profile to compile
    _In_opt_count_(argCount) LPCWSTR *pArguments, // Array of pointers to arguments
    _In_ UINT32 argCount,                         // Number of arguments
    _In_count_(defineCount)
      const DxcDefine *pDefines,                  // Array of defines
    _In_ UINT32 defineCount,                      // Number of defines
    _In_opt_ IDxcIncludeHandler *pIncludeHandler, // user-provided interface to handle #include directives (optional)
    _COM_Outptr_ IDxcOperationResult **ppResult   // Compiler output status, buffer, and errors
  ) = 0;

  // Preprocess source text
  virtual HRESULT STDMETHODCALLTYPE Preprocess(
    _In_ IDxcBlob *pSource,                       // Source text to preprocess
    _In_opt_z_ LPCWSTR pSourceName,               // Optional file name for pSource. Used in errors and include handlers.
    _In_opt_count_(argCount) LPCWSTR *pArguments, // Array of pointers to arguments
    _In_ UINT32 argCount,                         // Number of arguments
    _In_count_(defineCount)
      const DxcDefine *pDefines,                  // Array of defines
    _In_ UINT32 defineCount,                      // Number of defines
    _In_opt_ IDxcIncludeHandler *pIncludeHandler, // user-provided interface to handle #include directives (optional)
    _COM_Outptr_ IDxcOperationResult **ppResult   // Preprocessor output status, buffer, and errors
  ) = 0;

  // Disassemble a program.
  virtual HRESULT STDMETHODCALLTYPE Disassemble(
    _In_ IDxcBlob *pSource,                         // Program to disassemble.
    _COM_Outptr_ IDxcBlobEncoding **ppDisassembly   // Disassembly text.
    ) = 0;
};

// NOTE: IDxcCompiler3 replaces IDxcCompiler and IDxcCompiler2
CROSS_PLATFORM_UUIDOF(IDxcCompiler2, "A005A9D9-B8BB-4594-B5C9-0E633BEC4D37")
struct IDxcCompiler2 : public IDxcCompiler {
  // Compile a single entry point to the target shader model with debug information.
  virtual HRESULT STDMETHODCALLTYPE CompileWithDebug(
    _In_ IDxcBlob *pSource,                       // Source text to compile
    _In_opt_z_ LPCWSTR pSourceName,               // Optional file name for pSource. Used in errors and include handlers.
    _In_opt_z_ LPCWSTR pEntryPoint,               // Entry point name
    _In_z_ LPCWSTR pTargetProfile,                // Shader profile to compile
    _In_opt_count_(argCount) LPCWSTR *pArguments, // Array of pointers to arguments
    _In_ UINT32 argCount,                         // Number of arguments
    _In_count_(defineCount)
      const DxcDefine *pDefines,                  // Array of defines
    _In_ UINT32 defineCount,                      // Number of defines
    _In_opt_ IDxcIncludeHandler *pIncludeHandler, // user-provided interface to handle #include directives (optional)
    _COM_Outptr_ IDxcOperationResult **ppResult,  // Compiler output status, buffer, and errors
    _Outptr_opt_result_z_ LPWSTR *ppDebugBlobName,// Suggested file name for debug blob. (Must be CoTaskMemFree()'d!)
    _COM_Outptr_opt_ IDxcBlob **ppDebugBlob       // Debug blob
  ) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcLinker, "F1B5BE2A-62DD-4327-A1C2-42AC1E1E78E6")
struct IDxcLinker : public IUnknown {
public:
  // Register a library with name to ref it later.
  virtual HRESULT RegisterLibrary(
    _In_opt_ LPCWSTR pLibName,          // Name of the library.
    _In_ IDxcBlob *pLib                 // Library blob.
  ) = 0;

  // Links the shader and produces a shader blob that the Direct3D runtime can
  // use.
  virtual HRESULT STDMETHODCALLTYPE Link(
    _In_opt_ LPCWSTR pEntryName,        // Entry point name
    _In_ LPCWSTR pTargetProfile,        // shader profile to link
    _In_count_(libCount)
        const LPCWSTR *pLibNames,       // Array of library names to link
    _In_ UINT32 libCount,               // Number of libraries to link
    _In_opt_count_(argCount) const LPCWSTR *pArguments, // Array of pointers to arguments
    _In_ UINT32 argCount,               // Number of arguments
    _COM_Outptr_
        IDxcOperationResult **ppResult  // Linker output status, buffer, and errors
  ) = 0;
};

/////////////////////////
// Latest interfaces. Please use these
////////////////////////

// NOTE: IDxcUtils replaces IDxcLibrary
CROSS_PLATFORM_UUIDOF(IDxcUtils, "4605C4CB-2019-492A-ADA4-65F20BB7D67F")
struct IDxcUtils : public IUnknown {
  // Create a sub-blob that holds a reference to the outer blob and points to its memory.
  virtual HRESULT STDMETHODCALLTYPE CreateBlobFromBlob(
    _In_ IDxcBlob *pBlob, UINT32 offset, UINT32 length, _COM_Outptr_ IDxcBlob **ppResult) = 0;

  // For codePage, use 0 (or DXC_CP_ACP) for raw binary or ANSI code page

  // Creates a blob referencing existing memory, with no copy.
  // User must manage the memory lifetime separately.
  // (was: CreateBlobWithEncodingFromPinned)
  virtual HRESULT STDMETHODCALLTYPE CreateBlobFromPinned(
    _In_bytecount_(size) LPCVOID pData, UINT32 size, UINT32 codePage,
    _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;

  // Create blob, taking ownership of memory allocated with supplied allocator.
  // (was: CreateBlobWithEncodingOnMalloc)
  virtual HRESULT STDMETHODCALLTYPE MoveToBlob(
    _In_bytecount_(size) LPCVOID pData, IMalloc *pIMalloc, UINT32 size, UINT32 codePage,
    _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;

  ////
  // New blobs and copied contents are allocated with the current allocator

  // Copy blob contents to memory owned by the new blob.
  // (was: CreateBlobWithEncodingOnHeapCopy)
  virtual HRESULT STDMETHODCALLTYPE CreateBlob(
    _In_bytecount_(size) LPCVOID pData, UINT32 size, UINT32 codePage,
    _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;

  // (was: CreateBlobFromFile)
  virtual HRESULT STDMETHODCALLTYPE LoadFile(
    _In_z_ LPCWSTR pFileName, _In_opt_ UINT32* pCodePage,
    _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;

  virtual HRESULT STDMETHODCALLTYPE CreateReadOnlyStreamFromBlob(
    _In_ IDxcBlob *pBlob, _COM_Outptr_ IStream **ppStream) = 0;

  // Create default file-based include handler
  virtual HRESULT STDMETHODCALLTYPE CreateDefaultIncludeHandler(
    _COM_Outptr_ IDxcIncludeHandler **ppResult) = 0;

  // Convert or return matching encoded text blobs
  virtual HRESULT STDMETHODCALLTYPE GetBlobAsUtf8(
    _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobUtf8 **pBlobEncoding) = 0;

  // Renamed from GetBlobAsUtf16 to GetBlobAsWide
  virtual HRESULT STDMETHODCALLTYPE GetBlobAsWide(
    _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobWide **pBlobEncoding) = 0;

#ifdef _WIN32
  // Alias to GetBlobAsWide on Win32
  inline HRESULT GetBlobAsUtf16(
    _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobWide **pBlobEncoding) {
    return this->GetBlobAsWide(pBlob, pBlobEncoding);
  }
#endif

  virtual HRESULT STDMETHODCALLTYPE GetDxilContainerPart(
    _In_ const DxcBuffer *pShader,
    _In_ UINT32 DxcPart,
    _Outptr_result_nullonfailure_ void **ppPartData,
    _Out_ UINT32 *pPartSizeInBytes) = 0;

  // Create reflection interface from serialized Dxil container, or DXC_PART_REFLECTION_DATA.
  // TBD: Require part header for RDAT?  (leaning towards yes)
  virtual HRESULT STDMETHODCALLTYPE CreateReflection(
    _In_ const DxcBuffer *pData, REFIID iid, void **ppvReflection) = 0;

  virtual HRESULT STDMETHODCALLTYPE BuildArguments(
    _In_opt_z_ LPCWSTR pSourceName,               // Optional file name for pSource. Used in errors and include handlers.
    _In_opt_z_ LPCWSTR pEntryPoint,               // Entry point name. (-E)
    _In_z_ LPCWSTR pTargetProfile,                // Shader profile to compile. (-T)
    _In_opt_count_(argCount) LPCWSTR *pArguments, // Array of pointers to arguments
    _In_ UINT32 argCount,                         // Number of arguments
    _In_count_(defineCount)
      const DxcDefine *pDefines,                  // Array of defines
    _In_ UINT32 defineCount,                      // Number of defines
    _COM_Outptr_ IDxcCompilerArgs **ppArgs        // Arguments you can use with Compile() method
  ) = 0;

  // Takes the shader PDB and returns the hash and the container inside it
  virtual HRESULT STDMETHODCALLTYPE GetPDBContents(
    _In_ IDxcBlob *pPDBBlob, _COM_Outptr_ IDxcBlob **ppHash, _COM_Outptr_ IDxcBlob **ppContainer) = 0;
};

// For use with IDxcResult::[Has|Get]Output dxcOutKind argument
// Note: text outputs returned from version 2 APIs are UTF-8 or UTF-16 based on -encoding option
typedef enum DXC_OUT_KIND {
  DXC_OUT_NONE = 0,
  DXC_OUT_OBJECT = 1,         // IDxcBlob - Shader or library object
  DXC_OUT_ERRORS = 2,         // IDxcBlobUtf8 or IDxcBlobWide
  DXC_OUT_PDB = 3,            // IDxcBlob
  DXC_OUT_SHADER_HASH = 4,    // IDxcBlob - DxcShaderHash of shader or shader with source info (-Zsb/-Zss)
  DXC_OUT_DISASSEMBLY = 5,    // IDxcBlobUtf8 or IDxcBlobWide - from Disassemble
  DXC_OUT_HLSL = 6,           // IDxcBlobUtf8 or IDxcBlobWide - from Preprocessor or Rewriter
  DXC_OUT_TEXT = 7,           // IDxcBlobUtf8 or IDxcBlobWide - other text, such as -ast-dump or -Odump
  DXC_OUT_REFLECTION = 8,     // IDxcBlob - RDAT part with reflection data
  DXC_OUT_ROOT_SIGNATURE = 9, // IDxcBlob - Serialized root signature output
  DXC_OUT_EXTRA_OUTPUTS  = 10,// IDxcExtraResults - Extra outputs
  DXC_OUT_REMARKS = 11,       // IDxcBlobUtf8 or IDxcBlobWide - text directed at stdout
  DXC_OUT_TIME_REPORT = 12,   // IDxcBlobUtf8 or IDxcBlobWide - text directed at stdout
  DXC_OUT_TIME_TRACE = 13,   // IDxcBlobUtf8 or IDxcBlobWide - text directed at stdout

  DXC_OUT_LAST = DXC_OUT_TIME_TRACE, // Last value for a counter

  DXC_OUT_NUM_ENUMS,
  DXC_OUT_FORCE_DWORD = 0xFFFFFFFF
} DXC_OUT_KIND;

static_assert(DXC_OUT_NUM_ENUMS == DXC_OUT_LAST + 1,
              "DXC_OUT_* Enum added and last value not updated.");

CROSS_PLATFORM_UUIDOF(IDxcResult, "58346CDA-DDE7-4497-9461-6F87AF5E0659")
struct IDxcResult : public IDxcOperationResult {
  virtual BOOL STDMETHODCALLTYPE HasOutput(_In_ DXC_OUT_KIND dxcOutKind) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetOutput(_In_ DXC_OUT_KIND dxcOutKind,
    _In_ REFIID iid, _COM_Outptr_opt_result_maybenull_ void **ppvObject,
    _COM_Outptr_ IDxcBlobWide **ppOutputName) = 0;

  virtual UINT32 GetNumOutputs() = 0;
  virtual DXC_OUT_KIND GetOutputByIndex(UINT32 Index) = 0;
  virtual DXC_OUT_KIND PrimaryOutput() = 0;
};

// Special names for extra output that should get written to specific streams
#define DXC_EXTRA_OUTPUT_NAME_STDOUT L"*stdout*"
#define DXC_EXTRA_OUTPUT_NAME_STDERR L"*stderr*"

CROSS_PLATFORM_UUIDOF(IDxcExtraOutputs, "319b37a2-a5c2-494a-a5de-4801b2faf989")
struct IDxcExtraOutputs : public IUnknown {

  virtual UINT32 STDMETHODCALLTYPE GetOutputCount() = 0;
  virtual HRESULT STDMETHODCALLTYPE GetOutput(_In_ UINT32 uIndex,
    _In_ REFIID iid, _COM_Outptr_opt_result_maybenull_ void **ppvObject,
    _COM_Outptr_opt_result_maybenull_ IDxcBlobWide **ppOutputType,
    _COM_Outptr_opt_result_maybenull_ IDxcBlobWide **ppOutputName) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcCompiler3, "228B4687-5A6A-4730-900C-9702B2203F54")
struct IDxcCompiler3 : public IUnknown {
  // Compile a single entry point to the target shader model,
  // Compile a library to a library target (-T lib_*),
  // Compile a root signature (-T rootsig_*), or
  // Preprocess HLSL source (-P)
  virtual HRESULT STDMETHODCALLTYPE Compile(
    _In_ const DxcBuffer *pSource,                // Source text to compile
    _In_opt_count_(argCount) LPCWSTR *pArguments, // Array of pointers to arguments
    _In_ UINT32 argCount,                         // Number of arguments
    _In_opt_ IDxcIncludeHandler *pIncludeHandler, // user-provided interface to handle #include directives (optional)
    _In_ REFIID riid, _Out_ LPVOID *ppResult      // IDxcResult: status, buffer, and errors
  ) = 0;

  // Disassemble a program.
  virtual HRESULT STDMETHODCALLTYPE Disassemble(
    _In_ const DxcBuffer *pObject,                // Program to disassemble: dxil container or bitcode.
    _In_ REFIID riid, _Out_ LPVOID *ppResult      // IDxcResult: status, disassembly text, and errors
    ) = 0;
};

static const UINT32 DxcValidatorFlags_Default = 0;
static const UINT32 DxcValidatorFlags_InPlaceEdit = 1;  // Validator is allowed to update shader blob in-place.
static const UINT32 DxcValidatorFlags_RootSignatureOnly = 2;
static const UINT32 DxcValidatorFlags_ModuleOnly = 4;
static const UINT32 DxcValidatorFlags_ValidMask = 0x7;

CROSS_PLATFORM_UUIDOF(IDxcValidator, "A6E82BD2-1FD7-4826-9811-2857E797F49A")
struct IDxcValidator : public IUnknown {
  // Validate a shader.
  virtual HRESULT STDMETHODCALLTYPE Validate(
    _In_ IDxcBlob *pShader,                       // Shader to validate.
    _In_ UINT32 Flags,                            // Validation flags.
    _COM_Outptr_ IDxcOperationResult **ppResult   // Validation output status, buffer, and errors
    ) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcValidator2, "458e1fd1-b1b2-4750-a6e1-9c10f03bed92")
struct IDxcValidator2 : public IDxcValidator {
  // Validate a shader.
  virtual HRESULT STDMETHODCALLTYPE ValidateWithDebug(
    _In_ IDxcBlob *pShader,                       // Shader to validate.
    _In_ UINT32 Flags,                            // Validation flags.
    _In_opt_ DxcBuffer *pOptDebugBitcode,         // Optional debug module bitcode to provide line numbers
    _COM_Outptr_ IDxcOperationResult **ppResult   // Validation output status, buffer, and errors
    ) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcContainerBuilder, "334b1f50-2292-4b35-99a1-25588d8c17fe")
struct IDxcContainerBuilder : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE Load(_In_ IDxcBlob *pDxilContainerHeader) = 0;                // Loads DxilContainer to the builder
  virtual HRESULT STDMETHODCALLTYPE AddPart(_In_ UINT32 fourCC, _In_ IDxcBlob *pSource) = 0;      // Part to add to the container
  virtual HRESULT STDMETHODCALLTYPE RemovePart(_In_ UINT32 fourCC) = 0;                           // Remove the part with fourCC
  virtual HRESULT STDMETHODCALLTYPE SerializeContainer(_Out_ IDxcOperationResult **ppResult) = 0; // Builds a container of the given container builder state
};

CROSS_PLATFORM_UUIDOF(IDxcAssembler, "091f7a26-1c1f-4948-904b-e6e3a8a771d5")
struct IDxcAssembler : public IUnknown {
  // Assemble dxil in ll or llvm bitcode to DXIL container.
  virtual HRESULT STDMETHODCALLTYPE AssembleToContainer(
    _In_ IDxcBlob *pShader,                       // Shader to assemble.
    _COM_Outptr_ IDxcOperationResult **ppResult   // Assembly output status, buffer, and errors
    ) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcContainerReflection, "d2c21b26-8350-4bdc-976a-331ce6f4c54c")
struct IDxcContainerReflection : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE Load(_In_ IDxcBlob *pContainer) = 0; // Container to load.
  virtual HRESULT STDMETHODCALLTYPE GetPartCount(_Out_ UINT32 *pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetPartKind(UINT32 idx, _Out_ UINT32 *pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetPartContent(UINT32 idx, _COM_Outptr_ IDxcBlob **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE FindFirstPartKind(UINT32 kind, _Out_ UINT32 *pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetPartReflection(UINT32 idx, REFIID iid, void **ppvObject) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcOptimizerPass, "AE2CD79F-CC22-453F-9B6B-B124E7A5204C")
struct IDxcOptimizerPass : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE GetOptionName(_COM_Outptr_ LPWSTR *ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetDescription(_COM_Outptr_ LPWSTR *ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetOptionArgCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetOptionArgName(UINT32 argIndex, _COM_Outptr_ LPWSTR *ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetOptionArgDescription(UINT32 argIndex, _COM_Outptr_ LPWSTR *ppResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcOptimizer, "25740E2E-9CBA-401B-9119-4FB42F39F270")
struct IDxcOptimizer : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE GetAvailablePassCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetAvailablePass(UINT32 index, _COM_Outptr_ IDxcOptimizerPass** ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE RunOptimizer(IDxcBlob *pBlob,
    _In_count_(optionCount) LPCWSTR *ppOptions, UINT32 optionCount,
    _COM_Outptr_ IDxcBlob **pOutputModule,
    _COM_Outptr_opt_ IDxcBlobEncoding **ppOutputText) = 0;
};

static const UINT32 DxcVersionInfoFlags_None = 0;
static const UINT32 DxcVersionInfoFlags_Debug = 1; // Matches VS_FF_DEBUG
static const UINT32 DxcVersionInfoFlags_Internal = 2; // Internal Validator (non-signing)

CROSS_PLATFORM_UUIDOF(IDxcVersionInfo, "b04f5b50-2059-4f12-a8ff-a1e0cde1cc7e")
struct IDxcVersionInfo : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE GetVersion(_Out_ UINT32 *pMajor, _Out_ UINT32 *pMinor) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetFlags(_Out_ UINT32 *pFlags) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcVersionInfo2, "fb6904c4-42f0-4b62-9c46-983af7da7c83")
struct IDxcVersionInfo2 : public IDxcVersionInfo {
  virtual HRESULT STDMETHODCALLTYPE GetCommitInfo(
    _Out_ UINT32 *pCommitCount,           // The total number commits.
    _Outptr_result_z_ char **pCommitHash  // The SHA of the latest commit. (Must be CoTaskMemFree()'d!)
  ) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcVersionInfo3, "5e13e843-9d25-473c-9ad2-03b2d0b44b1e")
struct IDxcVersionInfo3 : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE GetCustomVersionString(
    _Outptr_result_z_ char **pVersionString // Custom version string for compiler. (Must be CoTaskMemFree()'d!)
  ) = 0;
};

struct DxcArgPair {
  const WCHAR *pName;
  const WCHAR *pValue;
};

CROSS_PLATFORM_UUIDOF(IDxcPdbUtils, "E6C9647E-9D6A-4C3B-B94C-524B5A6C343D")
struct IDxcPdbUtils : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE Load(_In_ IDxcBlob *pPdbOrDxil) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetSourceCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSource(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobEncoding **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSourceName(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetFlagCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetFlag(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetArgCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetArg(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetArgPairCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetArgPair(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pName, _Outptr_result_z_ BSTR *pValue) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetDefineCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetDefine(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetTargetProfile(_Outptr_result_z_ BSTR *pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetEntryPoint(_Outptr_result_z_ BSTR *pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetMainFileName(_Outptr_result_z_ BSTR *pResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetHash(_COM_Outptr_ IDxcBlob **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetName(_Outptr_result_z_ BSTR *pResult) = 0;

  virtual BOOL STDMETHODCALLTYPE IsFullPDB() = 0;
  virtual HRESULT STDMETHODCALLTYPE GetFullPDB(_COM_Outptr_ IDxcBlob **ppFullPDB) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetVersionInfo(_COM_Outptr_ IDxcVersionInfo **ppVersionInfo) = 0;

  virtual HRESULT STDMETHODCALLTYPE SetCompiler(_In_ IDxcCompiler3 *pCompiler) = 0;
  virtual HRESULT STDMETHODCALLTYPE CompileForFullPDB(_COM_Outptr_ IDxcResult **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE OverrideArgs(_In_ DxcArgPair *pArgPairs, UINT32 uNumArgPairs) = 0;
  virtual HRESULT STDMETHODCALLTYPE OverrideRootSignature(_In_ const WCHAR *pRootSignature) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcPdbUtils2, "4315D938-F369-4F93-95A2-252017CC3807")
struct IDxcPdbUtils2 : public IUnknown {
  virtual HRESULT STDMETHODCALLTYPE Load(_In_ IDxcBlob *pPdbOrDxil) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetSourceCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSource(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobEncoding **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSourceName(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobWide **ppResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetLibraryPDBCount(UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetLibraryPDB(_In_ UINT32 uIndex, _COM_Outptr_ IDxcPdbUtils2 **ppOutPdbUtils, _COM_Outptr_opt_result_maybenull_ IDxcBlobWide **ppLibraryName) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetFlagCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetFlag(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobWide **ppResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetArgCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetArg(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobWide **ppResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetArgPairCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetArgPair(_In_ UINT32 uIndex, _COM_Outptr_result_maybenull_ IDxcBlobWide **ppName, _COM_Outptr_result_maybenull_ IDxcBlobWide **ppValue) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetDefineCount(_Out_ UINT32 *pCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetDefine(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobWide **ppResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetTargetProfile(_COM_Outptr_result_maybenull_ IDxcBlobWide **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetEntryPoint(_COM_Outptr_result_maybenull_ IDxcBlobWide **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetMainFileName(_COM_Outptr_result_maybenull_ IDxcBlobWide **ppResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetHash(_COM_Outptr_result_maybenull_ IDxcBlob **ppResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetName(_COM_Outptr_result_maybenull_ IDxcBlobWide **ppResult) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetVersionInfo(_COM_Outptr_result_maybenull_ IDxcVersionInfo **ppVersionInfo) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetCustomToolchainID(_Out_ UINT32 *pID) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetCustomToolchainData(_COM_Outptr_result_maybenull_ IDxcBlob **ppBlob) = 0;

  virtual HRESULT STDMETHODCALLTYPE GetWholeDxil(_COM_Outptr_result_maybenull_ IDxcBlob **ppResult) = 0;

  virtual BOOL STDMETHODCALLTYPE IsFullPDB() = 0;
  virtual BOOL STDMETHODCALLTYPE IsPDBRef() = 0;
};

// Note: __declspec(selectany) requires 'extern'
// On Linux __declspec(selectany) is removed and using 'extern' results in link error.
#ifdef _MSC_VER
#define CLSID_SCOPE __declspec(selectany) extern
#else
#define CLSID_SCOPE
#endif

CLSID_SCOPE const CLSID CLSID_DxcCompiler = {
    0x73e22d93,
    0xe6ce,
    0x47f3,
    {0xb5, 0xbf, 0xf0, 0x66, 0x4f, 0x39, 0xc1, 0xb0}};

// {EF6A8087-B0EA-4D56-9E45-D07E1A8B7806}
CLSID_SCOPE const GUID CLSID_DxcLinker = {
    0xef6a8087,
    0xb0ea,
    0x4d56,
    {0x9e, 0x45, 0xd0, 0x7e, 0x1a, 0x8b, 0x78, 0x6}};

// {CD1F6B73-2AB0-484D-8EDC-EBE7A43CA09F}
CLSID_SCOPE const CLSID CLSID_DxcDiaDataSource = {
    0xcd1f6b73,
    0x2ab0,
    0x484d,
    {0x8e, 0xdc, 0xeb, 0xe7, 0xa4, 0x3c, 0xa0, 0x9f}};

// {3E56AE82-224D-470F-A1A1-FE3016EE9F9D}
CLSID_SCOPE const CLSID CLSID_DxcCompilerArgs = {
    0x3e56ae82,
    0x224d,
    0x470f,
    {0xa1, 0xa1, 0xfe, 0x30, 0x16, 0xee, 0x9f, 0x9d}};

// {6245D6AF-66E0-48FD-80B4-4D271796748C}
CLSID_SCOPE const GUID CLSID_DxcLibrary = {
    0x6245d6af,
    0x66e0,
    0x48fd,
    {0x80, 0xb4, 0x4d, 0x27, 0x17, 0x96, 0x74, 0x8c}};

CLSID_SCOPE const GUID CLSID_DxcUtils = CLSID_DxcLibrary;

// {8CA3E215-F728-4CF3-8CDD-88AF917587A1}
CLSID_SCOPE const GUID CLSID_DxcValidator = {
    0x8ca3e215,
    0xf728,
    0x4cf3,
    {0x8c, 0xdd, 0x88, 0xaf, 0x91, 0x75, 0x87, 0xa1}};

// {D728DB68-F903-4F80-94CD-DCCF76EC7151}
CLSID_SCOPE const GUID CLSID_DxcAssembler = {
    0xd728db68,
    0xf903,
    0x4f80,
    {0x94, 0xcd, 0xdc, 0xcf, 0x76, 0xec, 0x71, 0x51}};

// {b9f54489-55b8-400c-ba3a-1675e4728b91}
CLSID_SCOPE const GUID CLSID_DxcContainerReflection = {
    0xb9f54489,
    0x55b8,
    0x400c,
    {0xba, 0x3a, 0x16, 0x75, 0xe4, 0x72, 0x8b, 0x91}};

// {AE2CD79F-CC22-453F-9B6B-B124E7A5204C}
CLSID_SCOPE const GUID CLSID_DxcOptimizer = {
    0xae2cd79f,
    0xcc22,
    0x453f,
    {0x9b, 0x6b, 0xb1, 0x24, 0xe7, 0xa5, 0x20, 0x4c}};

// {94134294-411f-4574-b4d0-8741e25240d2}
CLSID_SCOPE const GUID CLSID_DxcContainerBuilder = {
    0x94134294,
    0x411f,
    0x4574,
    {0xb4, 0xd0, 0x87, 0x41, 0xe2, 0x52, 0x40, 0xd2}};

// {54621dfb-f2ce-457e-ae8c-ec355faeec7c}
CLSID_SCOPE const GUID CLSID_DxcPdbUtils = {
    0x54621dfb,
    0xf2ce,
    0x457e,
    {0xae, 0x8c, 0xec, 0x35, 0x5f, 0xae, 0xec, 0x7c}};

#endif


================================================
FILE: Source/External/dxc/inc/dxcerrors.h
================================================
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// dxcerror.h                                                                //
// Copyright (C) Microsoft Corporation. All rights reserved.                 //
// This file is distributed under the University of Illinois Open Source     //
// License. See LICENSE.TXT for details.                                     //
//                                                                           //
// Provides definition of error codes.                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#ifndef __DXC_ERRORS__
#define __DXC_ERRORS__

#ifndef FACILITY_GRAPHICS
#define FACILITY_GRAPHICS 36
#endif

#define DXC_EXCEPTION_CODE(name, status)                                 \
    static constexpr DWORD EXCEPTION_##name =                 \
    (0xc0000000u | (FACILITY_GRAPHICS << 16) | (0xff00u | (status & 0xffu)));

DXC_EXCEPTION_CODE(LOAD_LIBRARY_FAILED, 0x00u)
DXC_EXCEPTION_CODE(NO_HMODULE,          0x01u)
DXC_EXCEPTION_CODE(GET_PROC_FAILED,     0x02u)

#undef DXC_EXCEPTION_CODE

#endif


================================================
FILE: Source/External/dxc/inc/dxcisense.h
================================================
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// dxcisense.h                                                               //
// Copyright (C) Microsoft Corporation. All rights reserved.                 //
// This file is distributed under the University of Illinois Open Source     //
// License. See LICENSE.TXT for details.                                     //
//                                                                           //
// Provides declarations for the DirectX Compiler IntelliSense component.    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#ifndef __DXC_ISENSE__
#define __DXC_ISENSE__

#include "dxcapi.h"
#ifndef _WIN32
#include "Support/WinAdapter.h"
#endif

typedef enum DxcGlobalOptions
{
  DxcGlobalOpt_None = 0x0,
  DxcGlobalOpt_ThreadBackgroundPriorityForIndexing = 0x1,
  DxcGlobalOpt_ThreadBackgroundPriorityForEditing = 0x2,
  DxcGlobalOpt_ThreadBackgroundPriorityForAll =
    DxcGlobalOpt_ThreadBackgroundPriorityForIndexing | DxcGlobalOpt_ThreadBackgroundPriorityForEditing
} DxcGlobalOptions;

typedef enum DxcTokenKind
{
  DxcTokenKind_Punctuation = 0, // A token that contains some kind of punctuation.
  DxcTokenKind_Keyword = 1,     // A language keyword.
  DxcTokenKind_Identifier = 2,  // An identifier (that is not a keyword).
  DxcTokenKind_Literal = 3,     // A numeric, string, or character literal.
  DxcTokenKind_Comment = 4,     // A comment.
  DxcTokenKind_Unknown = 5,     // An unknown token (possibly known to a future version).
  DxcTokenKind_BuiltInType = 6, // A built-in type like int, void or float3.
} DxcTokenKind;

typedef enum DxcTypeKind
{
  DxcTypeKind_Invalid = 0, // Reprents an invalid type (e.g., where no type is available).
  DxcTypeKind_Unexposed = 1, // A type whose specific kind is not exposed via this interface.
  // Builtin types
  DxcTypeKind_Void = 2,
  DxcTypeKind_Bool = 3,
  DxcTypeKind_Char_U = 4,
  DxcTypeKind_UChar = 5,
  DxcTypeKind_Char16 = 6,
  DxcTypeKind_Char32 = 7,
  DxcTypeKind_UShort = 8,
  DxcTypeKind_UInt = 9,
  DxcTypeKind_ULong = 10,
  DxcTypeKind_ULongLong = 11,
  DxcTypeKind_UInt128 = 12,
  DxcTypeKind_Char_S = 13,
  DxcTypeKind_SChar = 14,
  DxcTypeKind_WChar = 15,
  DxcTypeKind_Short = 16,
  DxcTypeKind_Int = 17,
  DxcTypeKind_Long = 18,
  DxcTypeKind_LongLong = 19,
  DxcTypeKind_Int128 = 20,
  DxcTypeKind_Float = 21,
  DxcTypeKind_Double = 22,
  DxcTypeKind_LongDouble = 23,
  DxcTypeKind_NullPtr = 24,
  DxcTypeKind_Overload = 25,
  DxcTypeKind_Dependent = 26,
  DxcTypeKind_ObjCId = 27,
  DxcTypeKind_ObjCClass = 28,
  DxcTypeKind_ObjCSel = 29,
  DxcTypeKind_FirstBuiltin = DxcTypeKind_Void,
  DxcTypeKind_LastBuiltin = DxcTypeKind_ObjCSel,

  DxcTypeKind_Complex = 100,
  DxcTypeKind_Pointer = 101,
  DxcTypeKind_BlockPointer = 102,
  DxcTypeKind_LValueReference = 103,
  DxcTypeKind_RValueReference = 104,
  DxcTypeKind_Record = 105,
  DxcTypeKind_Enum = 106,
  DxcTypeKind_Typedef = 107,
  DxcTypeKind_ObjCInterface = 108,
  DxcTypeKind_ObjCObjectPointer = 109,
  DxcTypeKind_FunctionNoProto = 110,
  DxcTypeKind_FunctionProto = 111,
  DxcTypeKind_ConstantArray = 112,
  DxcTypeKind_Vector = 113,
  DxcTypeKind_IncompleteArray = 114,
  DxcTypeKind_VariableArray = 115,
  DxcTypeKind_DependentSizedArray = 116,
  DxcTypeKind_MemberPointer = 117
} DxcTypeKind;

// Describes the severity of a particular diagnostic.
typedef enum DxcDiagnosticSeverity
{
  // A diagnostic that has been suppressed, e.g., by a command-line option.
  DxcDiagnostic_Ignored = 0,

  // This diagnostic is a note that should be attached to the previous (non-note) diagnostic.
  DxcDiagnostic_Note = 1,

  // This diagnostic indicates suspicious code that may not be wrong.
  DxcDiagnostic_Warning = 2,

  // This diagnostic indicates that the code is ill-formed.
  DxcDiagnostic_Error = 3,

  // This diagnostic indicates that the code is ill-formed such that future
  // parser rec unlikely to produce useful results.
  DxcDiagnostic_Fatal = 4

} DxcDiagnosticSeverity;

// Options to control the display of diagnostics.
typedef enum DxcDiagnosticDisplayOptions
{
  // Display the source-location information where the diagnostic was located.
  DxcDiagnostic_DisplaySourceLocation = 0x01,

  // If displaying the source-location information of the diagnostic,
  // also include the column number.
  DxcDiagnostic_DisplayColumn = 0x02,

  // If displaying the source-location information of the diagnostic,
  // also include information about source ranges in a machine-parsable format.
  DxcDiagnostic_DisplaySourceRanges = 0x04,

  // Display the option name associated with this diagnostic, if any.
  DxcDiagnostic_DisplayOption = 0x08,

  // Display the category number associated with this diagnostic, if any.
  DxcDiagnostic_DisplayCategoryId = 0x10,

  // Display the category name associated with this diagnostic, if any.
  DxcDiagnostic_DisplayCategoryName = 0x20,

  // Display the severity of the diagnostic message.
  DxcDiagnostic_DisplaySeverity = 0x200
} DxcDiagnosticDisplayOptions;

typedef enum DxcTranslationUnitFlags
{
  // Used to indicate that no special translation-unit options are needed.
  DxcTranslationUnitFlags_None = 0x0,

  // Used to indicate that the parser should construct a "detailed"
  // preprocessing record, including all macro definitions and instantiations.
  DxcTranslationUnitFlags_DetailedPreprocessingRecord = 0x01,

  // Used to indicate that the translation unit is incomplete.
  DxcTranslationUnitFlags_Incomplete = 0x02,

  // Used to indicate that the translation unit should be built with an
  // implicit precompiled header for the preamble.
  DxcTranslationUnitFlags_PrecompiledPreamble = 0x04,

  // Used to indicate that the translation unit should cache some
  // code-completion results with each reparse of the source file.
  DxcTranslationUnitFlags_CacheCompletionResults = 0x08,

  // Used to indicate that the translation unit will be serialized with
  // SaveTranslationUnit.
  DxcTranslationUnitFlags_ForSerialization = 0x10,

  // DEPRECATED
  DxcTranslationUnitFlags_CXXChainedPCH = 0x20,

  // Used to indicate that function/method bodies should be skipped while parsing.
  DxcTranslationUnitFlags_SkipFunctionBodies = 0x40,

  // Used to indicate that brief documentation comments should be
  // included into the set of code completions returned from this translation
  // unit.
  DxcTranslationUnitFlags_IncludeBriefCommentsInCodeCompletion = 0x80,

  // Used to indicate that compilation should occur on the caller's thread.
  DxcTranslationUnitFlags_UseCallerThread = 0x800
} DxcTranslationUnitFlags;

typedef enum DxcCursorFormatting
{
  DxcCursorFormatting_Default = 0x0,             // Default rules, language-insensitive formatting.
  DxcCursorFormatting_UseLanguageOptions = 0x1,  // Language-sensitive formatting.
  DxcCursorFormatting_SuppressSpecifiers = 0x2,  // Supresses type specifiers.
  DxcCursorFormatting_SuppressTagKeyword = 0x4,  // Suppressed tag keyword (eg, 'class').
  DxcCursorFormatting_IncludeNamespaceKeyword = 0x8,  // Include namespace keyword.
} DxcCursorFormatting;

enum DxcCursorKind {
  /* Declarations */
  DxcCursor_UnexposedDecl = 1, // A declaration whose specific kind is not exposed via this interface.
  DxcCursor_StructDecl = 2, // A C or C++ struct.
  DxcCursor_UnionDecl = 3, // A C or C++ union.
  DxcCursor_ClassDecl = 4, // A C++ class.
  DxcCursor_EnumDecl = 5, // An enumeration.
  DxcCursor_FieldDecl = 6, // A field (in C) or non-static data member (in C++) in a struct, union, or C++ class.
  DxcCursor_EnumConstantDecl = 7, // An enumerator constant.
  DxcCursor_FunctionDecl = 8, // A function.
  DxcCursor_VarDecl = 9, // A variable.
  DxcCursor_ParmDecl = 10, // A function or method parameter.
  DxcCursor_ObjCInterfaceDecl = 11, // An Objective-C interface.
  DxcCursor_ObjCCategoryDecl = 12, // An Objective-C interface for a category.
  DxcCursor_ObjCProtocolDecl = 13, // An Objective-C protocol declaration.
  DxcCursor_ObjCPropertyDecl = 14, // An Objective-C property declaration.
  DxcCursor_ObjCIvarDecl = 15, // An Objective-C instance variable.
  DxcCursor_ObjCInstanceMethodDecl = 16, // An Objective-C instance method.
  DxcCursor_ObjCClassMethodDecl = 17, // An Objective-C class method.
  DxcCursor_ObjCImplementationDecl = 18, // An Objective-C \@implementation.
  DxcCursor_ObjCCategoryImplDecl = 19, // An Objective-C \@implementation for a category.
  DxcCursor_TypedefDecl = 20, // A typedef
  DxcCursor_CXXMethod = 21, // A C++ class method.
  DxcCursor_Namespace = 22, // A C++ namespace.
  DxcCursor_LinkageSpec = 23, // A linkage specification, e.g. 'extern "C"'.
  DxcCursor_Constructor = 24, // A C++ constructor.
  DxcCursor_Destructor = 25, // A C++ destructor.
  DxcCursor_ConversionFunction = 26, // A C++ conversion function.
  DxcCursor_TemplateTypeParameter = 27, // A C++ template type parameter.
  DxcCursor_NonTypeTemplateParameter = 28, // A C++ non-type template parameter.
  DxcCursor_TemplateTemplateParameter = 29, // A C++ template template parameter.
  DxcCursor_FunctionTemplate = 30, // A C++ function template.
  DxcCursor_ClassTemplate = 31, // A C++ class template.
  DxcCursor_ClassTemplatePartialSpecialization = 32, // A C++ class template partial specialization.
  DxcCursor_NamespaceAlias = 33, // A C++ namespace alias declaration.
  DxcCursor_UsingDirective = 34, // A C++ using directive.
  DxcCursor_UsingDeclaration = 35, // A C++ using declaration.
  DxcCursor_TypeAliasDecl = 36, // A C++ alias declaration
  DxcCursor_ObjCSynthesizeDecl = 37, // An Objective-C \@synthesize definition.
  DxcCursor_ObjCDynamicDecl = 38, // An Objective-C \@dynamic definition.
  DxcCursor_CXXAccessSpecifier = 39, // An access specifier.

  DxcCursor_FirstDecl = DxcCursor_UnexposedDecl,
  DxcCursor_LastDecl = DxcCursor_CXXAccessSpecifier,

  /* References */
  DxcCursor_FirstRef = 40, /* Decl references */
  DxcCursor_ObjCSuperClassRef = 40,
  DxcCursor_ObjCProtocolRef = 41,
  DxcCursor_ObjCClassRef = 42,
  /**
  * \brief A reference to a type declaration.
  *
  * A type reference occurs anywhere where a type is named but not
  * declared. For example, given:
  *
  * \code
  * typedef unsigned size_type;
  * size_type size;
  * \endcode
  *
  * The typedef is a declaration of size_type (DxcCursor_TypedefDecl),
  * while the type of the variable "size" is referenced. The cursor
  * referenced by the type of size is the typedef for size_type.
  */
  DxcCursor_TypeRef = 43, // A reference to a type declaration.
  DxcCursor_CXXBaseSpecifier = 44,
  DxcCursor_TemplateRef = 45, // A reference to a class template, function template, template template parameter, or class template partial specialization.
  DxcCursor_NamespaceRef = 46, // A reference to a namespace or namespace alias.
  DxcCursor_MemberRef = 47, // A reference to a member of a struct, union, or class that occurs in some non-expression context, e.g., a designated initializer.
  /**
  * \brief A reference to a labeled statement.
  *
  * This cursor kind is used to describe the jump to "start_over" in the
  * goto statement in the following example:
  *
  * \code
  *   start_over:
  *     ++counter;
  *
  *     goto start_over;
  * \endcode
  *
  * A label reference cursor refers to a label statement.
  */
  DxcCursor_LabelRef = 48, // A reference to a labeled statement.

  // A reference to a set of overloaded functions or function templates
  // that has not yet been resolved to a specific function or function template.
  //
  // An overloaded declaration reference cursor occurs in C++ templates where
  // a dependent name refers to a function.
  DxcCursor_OverloadedDeclRef = 49,
  DxcCursor_VariableRef = 50, // A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.

  DxcCursor_LastRef = DxcCursor_VariableRef,

  /* Error conditions */
  DxcCursor_FirstInvalid = 70,
  DxcCursor_InvalidFile = 70,
  DxcCursor_NoDeclFound = 71,
  DxcCursor_NotImplemented = 72,
  DxcCursor_InvalidCode = 73,
  DxcCursor_LastInvalid = DxcCursor_InvalidCode,

  /* Expressions */
  DxcCursor_FirstExpr = 100,

  /**
  * \brief An expression whose specific kind is not exposed via this
  * interface.
  *
  * Unexposed expressions have the same operations as any other kind
  * of expression; one can extract their location information,
  * spelling, children, etc. However, the specific kind of the
  * expression is not reported.
  */
  DxcCursor_UnexposedExpr = 100, // An expression whose specific kind is not exposed via this interface.
  DxcCursor_DeclRefExpr = 101, // An expression that refers to some value declaration, such as a function, varible, or enumerator.
  DxcCursor_MemberRefExpr = 102, // An expression that refers to a member of a struct, union, class, Objective-C class, etc.
  DxcCursor_CallExpr = 103, // An expression that calls a function.
  DxcCursor_ObjCMessageExpr = 104, // An expression that sends a message to an Objective-C object or class.
  DxcCursor_BlockExpr = 105, // An expression that represents a block literal.
  DxcCursor_IntegerLiteral = 106, // An integer literal.
  DxcCursor_FloatingLiteral = 107, // A floating point number literal.
  DxcCursor_ImaginaryLiteral = 108, // An imaginary number literal.
  DxcCursor_StringLiteral = 109, // A string literal.
  DxcCursor_CharacterLiteral = 110, // A character literal.
  DxcCursor_ParenExpr = 111, // A parenthesized expression, e.g. "(1)". This AST node is only formed if full location information is requested.
  DxcCursor_UnaryOperator = 112, // This represents the unary-expression's (except sizeof and alignof).
  DxcCursor_ArraySubscriptExpr = 113, // [C99 6.5.2.1] Array Subscripting.
  DxcCursor_BinaryOperator = 114, // A builtin binary operation expression such as "x + y" or "x <= y".
  DxcCursor_CompoundAssignOperator = 115, // Compound assignment such as "+=".
  DxcCursor_ConditionalOperator = 116, // The ?: ternary operator.
  DxcCursor_CStyleCastExpr = 117, // An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr, eg: (int)f.
  DxcCursor_CompoundLiteralExpr = 118, // [C99 6.5.2.5]
  DxcCursor_InitListExpr = 119, // Describes an C or C++ initializer list.
  DxcCursor_AddrLabelExpr = 120, // The GNU address of label extension, representing &&label.
  DxcCursor_StmtExpr = 121, // This is the GNU Statement Expression extension: ({int X=4; X;})
  DxcCursor_GenericSelectionExpr = 122, // Represents a C11 generic selection.

  /** \brief Implements the GNU __null extension, which is a name for a null
  * pointer constant that has integral type (e.g., int or long) and is the same
  * size and alignment as a pointer.
  *
  * The __null extension is typically only used by system headers, which define
  * NULL as __null in C++ rather than using 0 (which is an integer that may not
  * match the size of a pointer).
  */
  DxcCursor_GNUNullExpr = 123,
  DxcCursor_CXXStaticCastExpr = 124, // C++'s static_cast<> expression.
  DxcCursor_CXXDynamicCastExpr = 125, // C++'s dynamic_cast<> expression.
  DxcCursor_CXXReinterpretCastExpr = 126, // C++'s reinterpret_cast<> expression.
  DxcCursor_CXXConstCastExpr = 127, // C++'s const_cast<> expression.

  /** \brief Represents an explicit C++ type conversion that uses "functional"
  * notion (C++ [expr.type.conv]).
  *
  * Example:
  * \code
  *   x = int(0.5);
  * \endcode
  */
  DxcCursor_CXXFunctionalCastExpr = 128,
  DxcCursor_CXXTypeidExpr = 129, // A C++ typeid expression (C++ [expr.typeid]).
  DxcCursor_CXXBoolLiteralExpr = 130, // [C++ 2.13.5] C++ Boolean Literal.
  DxcCursor_CXXNullPtrLiteralExpr = 131, // [C++0x 2.14.7] C++ Pointer Literal.
  DxcCursor_CXXThisExpr = 132, // Represents the "this" expression in C++
  DxcCursor_CXXThrowExpr = 133, // [C++ 15] C++ Throw Expression, both 'throw' and 'throw' assignment-expression.
  DxcCursor_CXXNewExpr = 134, // A new expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
  DxcCursor_CXXDeleteExpr = 135, // A delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray".
  DxcCursor_UnaryExpr = 136, // A unary expression.
  DxcCursor_ObjCStringLiteral = 137, // An Objective-C string literal i.e. @"foo".
  DxcCursor_ObjCEncodeExpr = 138, // An Objective-C \@encode expression.
  DxcCursor_ObjCSelectorExpr = 139, // An Objective-C \@selector expression.
  DxcCursor_ObjCProtocolExpr = 140, // An Objective-C \@protocol expression.

  /** \brief An Objective-C "bridged" cast expression, which casts between
  * Objective-C pointers and C pointers, transferring ownership in the process.
  *
  * \code
  *   NSString *str = (__bridge_transfer NSString *)CFCreateString();
  * \endcode
  */
  DxcCursor_ObjCBridgedCastExpr = 141,

  /** \brief Represents a C++0x pack expansion that produces a sequence of
  * expressions.
  *
  * A pack expansion expression contains a pattern (which itself is an
  * expression) followed by an ellipsis. For example:
  *
  * \code
  * template<typename F, typename ...Types>
  * void forward(F f, Types &&...args) {
  *  f(static_cast<Types&&>(args)...);
  * }
  * \endcode
  */
  DxcCursor_PackExpansionExpr = 142,

  /** \brief Represents an expression that computes the length of a parameter
  * pack.
  *
  * \code
  * template<typename ...Types>
  * struct count {
  *   static const unsigned value = sizeof...(Types);
  * };
  * \endcode
  */
  DxcCursor_SizeOfPackExpr = 143,

  /* \brief Represents a C++ lambda expression that produces a local function
  * object.
  *
  * \code
  * void abssort(float *x, unsigned N) {
  *   std::sort(x, x + N,
  *             [](float a, float b) {
  *               return std::abs(a) < std::abs(b);
  *             });
  * }
  * \endcode
  */
  DxcCursor_LambdaExpr = 144,
  DxcCursor_ObjCBoolLiteralExpr = 145, // Objective-c Boolean Literal.
  DxcCursor_ObjCSelfExpr = 146, // Represents the "self" expression in a ObjC method.
  DxcCursor_LastExpr = DxcCursor_ObjCSelfExpr,

  /* Statements */
  DxcCursor_FirstStmt = 200,
  /**
  * \brief A statement whose specific kind is not exposed via this
  * interface.
  *
  * Unexposed statements have the same operations as any other kind of
  * statement; one can extract their location information, spelling,
  * children, etc. However, the specific kind of the statement is not
  * reported.
  */
  DxcCursor_UnexposedStmt = 200,

  /** \brief A labelled statement in a function.
  *
  * This cursor kind is used to describe the "start_over:" label statement in
  * the following example:
  *
  * \code
  *   start_over:
  *     ++counter;
  * \endcode
  *
  */
  DxcCursor_LabelStmt = 201,
  DxcCursor_CompoundStmt = 202, // A group of statements like { stmt stmt }. This cursor kind is used to describe compound statements, e.g. function bodies.
  DxcCursor_CaseStmt = 203, // A case statement.
  DxcCursor_DefaultStmt = 204, // A default statement.
  DxcCursor_IfStmt = 205, // An if statement
  DxcCursor_SwitchStmt = 206, // A switch statement.
  DxcCursor_WhileStmt = 207, // A while statement.
  DxcCursor_DoStmt = 208, // A do statement.
  DxcCursor_ForStmt = 209, // A for statement.
  DxcCursor_GotoStmt = 210, // A goto statement.
  DxcCursor_IndirectGotoStmt = 211, // An indirect goto statement.
  DxcCursor_ContinueStmt = 212, // A continue statement.
  DxcCursor_BreakStmt = 213, // A break statement.
  DxcCursor_ReturnStmt = 214, // A return statement.
  DxcCursor_GCCAsmStmt = 215, // A GCC inline assembly statement extension.
  DxcCursor_AsmStmt = DxcCursor_GCCAsmStmt,

  DxcCursor_ObjCAtTryStmt = 216, // Objective-C's overall \@try-\@catch-\@finally statement.
  DxcCursor_ObjCAtCatchStmt = 217, // Objective-C's \@catch statement.
  DxcCursor_ObjCAtFinallyStmt = 218, // Objective-C's \@finally statement.
  DxcCursor_ObjCAtThrowStmt = 219, // Objective-C's \@throw statement.
  DxcCursor_ObjCAtSynchronizedStmt = 220, // Objective-C's \@synchronized statement.
  DxcCursor_ObjCAutoreleasePoolStmt = 221, // Objective-C's autorelease pool statement.
  DxcCursor_ObjCForCollectionStmt = 222, // Objective-C's collection statement.

  DxcCursor_CXXCatchStmt = 223, // C++'s catch statement.
  DxcCursor_CXXTryStmt = 224, // C++'s try statement.
  DxcCursor_CXXForRangeStmt = 225, // C++'s for (* : *) statement.

  DxcCursor_SEHTryStmt = 226, // Windows Structured Exception Handling's try statement.
  DxcCursor_SEHExceptStmt = 227, // Windows Structured Exception Handling's except statement.
  DxcCursor_SEHFinallyStmt = 228, // Windows Structured Exception Handling's finally statement.

  DxcCursor_MSAsmStmt = 229, // A MS inline assembly statement extension.
  DxcCursor_NullStmt = 230, // The null satement ";": C99 6.8.3p3.
  DxcCursor_DeclStmt = 231, // Adaptor class for mixing declarations with statements and expressions.
  DxcCursor_OMPParallelDirective = 232, // OpenMP parallel directive.
  DxcCursor_OMPSimdDirective = 233,  // OpenMP SIMD directive.
  DxcCursor_OMPForDirective = 234,  // OpenMP for directive.
  DxcCursor_OMPSectionsDirective = 235,  // OpenMP sections directive.
  DxcCursor_OMPSectionDirective = 236,  // OpenMP section directive.
  DxcCursor_OMPSingleDirective = 237,  // OpenMP single directive.
  DxcCursor_OMPParallelForDirective = 238,  // OpenMP parallel for directive.
  DxcCursor_OMPParallelSectionsDirective = 239,  // OpenMP parallel sections directive.
  DxcCursor_OMPTaskDirective = 240,  // OpenMP task directive.
  DxcCursor_OMPMasterDirective = 241,  // OpenMP master directive.
  DxcCursor_OMPCriticalDirective = 242,  // OpenMP critical directive.
  DxcCursor_OMPTaskyieldDirective = 243,  // OpenMP taskyield directive.
  DxcCursor_OMPBarrierDirective = 244,  // OpenMP barrier directive.
  DxcCursor_OMPTaskwaitDirective = 245,  // OpenMP taskwait directive.
  DxcCursor_OMPFlushDirective = 246,  // OpenMP flush directive.
  DxcCursor_SEHLeaveStmt = 247,  // Windows Structured Exception Handling's leave statement.
  DxcCursor_OMPOrderedDirective = 248,  // OpenMP ordered directive.
  DxcCursor_OMPAtomicDirective = 249,  // OpenMP atomic directive.
  DxcCursor_OMPForSimdDirective = 250,  // OpenMP for SIMD directive.
  DxcCursor_OMPParallelForSimdDirective = 251,  // OpenMP parallel for SIMD directive.
  DxcCursor_OMPTargetDirective = 252,  // OpenMP target directive.
  DxcCursor_OMPTeamsDirective = 253,  // OpenMP teams directive.
  DxcCursor_OMPTaskgroupDirective = 254,  // OpenMP taskgroup directive.
  DxcCursor_OMPCancellationPointDirective = 255,  // OpenMP cancellation point directive.
  DxcCursor_OMPCancelDirective = 256,  // OpenMP cancel directive.
  DxcCursor_LastStmt = DxcCursor_OMPCancelDirective,

  DxcCursor_TranslationUnit = 300, // Cursor that represents the translation unit itself.

  /* Attributes */
  DxcCursor_FirstAttr = 400,
  /**
  * \brief An attribute whose specific kind is not exposed via this
  * interface.
  */
  DxcCursor_UnexposedAttr = 400,

  DxcCursor_IBActionAttr = 401,
  DxcCursor_IBOutletAttr = 402,
  DxcCursor_IBOutletCollectionAttr = 403,
  DxcCursor_CXXFinalAttr = 404,
  DxcCursor_CXXOverrideAttr = 405,
  DxcCursor_AnnotateAttr = 406,
  DxcCursor_AsmLabelAttr = 407,
  DxcCursor_PackedAttr = 408,
  DxcCursor_PureAttr = 409,
  DxcCursor_ConstAttr = 410,
  DxcCursor_NoDuplicateAttr = 411,
  DxcCursor_CUDAConstantAttr = 412,
  DxcCursor_CUDADeviceAttr = 413,
  DxcCursor_CUDAGlobalAttr = 414,
  DxcCursor_CUDAHostAttr = 415,
  DxcCursor_CUDASharedAttr = 416,
  DxcCursor_LastAttr = DxcCursor_CUDASharedAttr,

  /* Preprocessing */
  DxcCursor_PreprocessingDirective = 500,
  DxcCursor_MacroDefinition = 501,
  DxcCursor_MacroExpansion = 502,
  DxcCursor_MacroInstantiation = DxcCursor_MacroExpansion,
  DxcCursor_InclusionDirective = 503,
  DxcCursor_FirstPreprocessing = DxcCursor_PreprocessingDirective,
  DxcCursor_LastPreprocessing = DxcCursor_InclusionDirective,

  /* Extra Declarations */
  /**
  * \brief A module import declaration.
  */
  DxcCursor_ModuleImportDecl = 600,
  DxcCursor_FirstExtraDecl = DxcCursor_ModuleImportDecl,
  DxcCursor_LastExtraDecl = DxcCursor_ModuleImportDecl
};

enum DxcCursorKindFlags
{
  DxcCursorKind_None = 0,
  DxcCursorKind_Declaration = 0x1,
  DxcCursorKind_Reference = 0x2,
  DxcCursorKind_Expression = 0x4,
  DxcCursorKind_Statement = 0x8,
  DxcCursorKind_Attribute = 0x10,
  DxcCursorKind_Invalid = 0x20,
  DxcCursorKind_TranslationUnit = 0x40,
  DxcCursorKind_Preprocessing = 0x80,
  DxcCursorKind_Unexposed = 0x100,
};

enum DxcCodeCompleteFlags
{
  DxcCodeCompleteFlags_None = 0,
  DxcCodeCompleteFlags_IncludeMacros = 0x1,
  DxcCodeCompleteFlags_IncludeCodePatterns = 0x2,
  DxcCodeCompleteFlags_IncludeBriefComments = 0x4,
};

enum DxcCompletionChunkKind
{
  DxcCompletionChunk_Optional = 0,
  DxcCompletionChunk_TypedText = 1,
  DxcCompletionChunk_Text = 2,
  DxcCompletionChunk_Placeholder = 3,
  DxcCompletionChunk_Informative = 4,
  DxcCompletionChunk_CurrentParameter = 5,
  DxcCompletionChunk_LeftParen = 6,
  DxcCompletionChunk_RightParen = 7,
  DxcCompletionChunk_LeftBracket = 8,
  DxcCompletionChunk_RightBracket = 9,
  DxcCompletionChunk_LeftBrace = 10,
  DxcCompletionChunk_RightBrace = 11,
  DxcCompletionChunk_LeftAngle = 12,
  DxcCompletionChunk_RightAngle = 13,
  DxcCompletionChunk_Comma = 14,
  DxcCompletionChunk_ResultType = 15,
  DxcCompletionChunk_Colon = 16,
  DxcCompletionChunk_SemiColon = 17,
  DxcCompletionChunk_Equal = 18,
  DxcCompletionChunk_HorizontalSpace = 19,
  DxcCompletionChunk_VerticalSpace = 20,
};

struct IDxcCursor;
struct IDxcDiagnostic;
struct IDxcFile;
struct IDxcInclusion;
struct IDxcIntelliSense;
struct IDxcIndex;
struct IDxcSourceLocation;
struct IDxcSourceRange;
struct IDxcToken;
struct IDxcTranslationUnit;
struct IDxcType;
struct IDxcUnsavedFile;
struct IDxcCodeCompleteResults;
struct IDxcCompletionResult;
struct IDxcCompletionString;

CROSS_PLATFORM_UUIDOF(IDxcCursor, "1467b985-288d-4d2a-80c1-ef89c42c40bc")
struct IDxcCursor : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetExtent(_Outptr_result_nullonfailure_ IDxcSourceRange** pRange) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetLocation(_Outptr_result_nullonfailure_ IDxcSourceLocation** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetKind(_Out_ DxcCursorKind* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetKindFlags(_Out_ DxcCursorKindFlags* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSemanticParent(_Outptr_result_nullonfailure_ IDxcCursor** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetLexicalParent(_Outptr_result_nullonfailure_ IDxcCursor** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetCursorType(_Outptr_result_nullonfailure_ IDxcType** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetNumArguments(_Out_ int* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetArgumentAt(int index, _Outptr_result_nullonfailure_ IDxcCursor** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetReferencedCursor(_Outptr_result_nullonfailure_ IDxcCursor** pResult) = 0;
  /// <summary>For a cursor that is either a reference to or a declaration of some entity, retrieve a cursor that describes the definition of that entity.</summary>
  /// <remarks>Some entities can be declared multiple times within a translation unit, but only one of those declarations can also be a definition.</remarks>
  /// <returns>A cursor to the definition of this entity; nullptr if there is no definition in this translation unit.</returns>
  virtual HRESULT STDMETHODCALLTYPE GetDefinitionCursor(_Outptr_result_nullonfailure_ IDxcCursor** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE FindReferencesInFile(
    _In_ IDxcFile* file, unsigned skip, unsigned top,
    _Out_ unsigned* pResultLength, _Outptr_result_buffer_maybenull_(*pResultLength) IDxcCursor*** pResult) = 0;
  /// <summary>Gets the name for the entity references by the cursor, e.g. foo for an 'int foo' variable.</summary>
  virtual HRESULT STDMETHODCALLTYPE GetSpelling(_Outptr_result_maybenull_ LPSTR* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE IsEqualTo(_In_ IDxcCursor* other, _Out_ BOOL* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE IsNull(_Out_ BOOL* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE IsDefinition(_Out_ BOOL* pResult) = 0;
  /// <summary>Gets the display name for the cursor, including e.g. parameter types for a function.</summary>
  virtual HRESULT STDMETHODCALLTYPE GetDisplayName(_Out_ BSTR* pResult) = 0;
  /// <summary>Gets the qualified name for the symbol the cursor refers to.</summary>
  virtual HRESULT STDMETHODCALLTYPE GetQualifiedName(BOOL includeTemplateArgs, _Outptr_result_maybenull_ BSTR* pResult) = 0;
  /// <summary>Gets a name for the cursor, applying the specified formatting flags.</summary>
  virtual HRESULT STDMETHODCALLTYPE GetFormattedName(DxcCursorFormatting formatting , _Outptr_result_maybenull_ BSTR* pResult) = 0;
  /// <summary>Gets children in pResult up to top elements.</summary>
  virtual HRESULT STDMETHODCALLTYPE GetChildren(
    unsigned skip, unsigned top,
    _Out_ unsigned* pResultLength, _Outptr_result_buffer_maybenull_(*pResultLength) IDxcCursor*** pResult) = 0;
  /// <summary>Gets the cursor following a location within a compound cursor.</summary>
  virtual HRESULT STDMETHODCALLTYPE GetSnappedChild(_In_ IDxcSourceLocation* location, _Outptr_result_maybenull_ IDxcCursor** pResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcDiagnostic, "4f76b234-3659-4d33-99b0-3b0db994b564")
struct IDxcDiagnostic : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE FormatDiagnostic(
    DxcDiagnosticDisplayOptions options,
    _Outptr_result_maybenull_ LPSTR* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSeverity(_Out_ DxcDiagnosticSeverity* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetLocation(_Outptr_result_nullonfailure_ IDxcSourceLocation** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSpelling(_Outptr_result_maybenull_ LPSTR* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetCategoryText(_Outptr_result_maybenull_ LPSTR* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetNumRanges(_Out_ unsigned* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetRangeAt(unsigned index, _Outptr_result_nullonfailure_ IDxcSourceRange** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetNumFixIts(_Out_ unsigned* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetFixItAt(unsigned index,
    _Outptr_result_nullonfailure_ IDxcSourceRange** pReplacementRange, _Outptr_result_maybenull_ LPSTR* pText) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcFile, "bb2fca9e-1478-47ba-b08c-2c502ada4895")
struct IDxcFile : public IUnknown
{
  /// <summary>Gets the file name for this file.</summary>
  virtual HRESULT STDMETHODCALLTYPE GetName(_Outptr_result_maybenull_ LPSTR* pResult) = 0;
  /// <summary>Checks whether this file is equal to the other specified file.</summary>
  virtual HRESULT STDMETHODCALLTYPE IsEqualTo(_In_ IDxcFile* other, _Out_ BOOL* pResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcInclusion, "0c364d65-df44-4412-888e-4e552fc5e3d6")
struct IDxcInclusion : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetIncludedFile(_Outptr_result_nullonfailure_ IDxcFile** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetStackLength(_Out_ unsigned *pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetStackItem(unsigned index, _Outptr_result_nullonfailure_ IDxcSourceLocation **pResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcIntelliSense, "b1f99513-46d6-4112-8169-dd0d6053f17d")
struct IDxcIntelliSense : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE CreateIndex(_Outptr_result_nullonfailure_ IDxcIndex** index) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetNullLocation(_Outptr_result_nullonfailure_ IDxcSourceLocation** location) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetNullRange(_Outptr_result_nullonfailure_ IDxcSourceRange** location) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetRange(
    _In_ IDxcSourceLocation* start,
    _In_ IDxcSourceLocation* end,
    _Outptr_result_nullonfailure_ IDxcSourceRange** location) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetDefaultDiagnosticDisplayOptions(
    _Out_ DxcDiagnosticDisplayOptions* pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetDefaultEditingTUOptions(_Out_ DxcTranslationUnitFlags* pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE CreateUnsavedFile(_In_ LPCSTR fileName, _In_ LPCSTR contents, unsigned contentLength, _Outptr_result_nullonfailure_ IDxcUnsavedFile** pResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcIndex, "937824a0-7f5a-4815-9ba7-7fc0424f4173")
struct IDxcIndex : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE SetGlobalOptions(DxcGlobalOptions options) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetGlobalOptions(_Out_ DxcGlobalOptions* options) = 0;
  virtual HRESULT STDMETHODCALLTYPE ParseTranslationUnit(
      _In_z_ const char *source_filename,
      _In_count_(num_command_line_args) const char * const *command_line_args,
      int num_command_line_args,
      _In_count_(num_unsaved_files) IDxcUnsavedFile** unsaved_files,
      unsigned num_unsaved_files,
      DxcTranslationUnitFlags options,
      _Out_ IDxcTranslationUnit** pTranslationUnit) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcSourceLocation, "8e7ddf1c-d7d3-4d69-b286-85fccba1e0cf")
struct IDxcSourceLocation : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE IsEqualTo(_In_ IDxcSourceLocation* other, _Out_ BOOL* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSpellingLocation(
    _Outptr_opt_ IDxcFile** pFile,
    _Out_opt_ unsigned* pLine,
    _Out_opt_ unsigned* pCol,
    _Out_opt_ unsigned* pOffset) = 0;
  virtual HRESULT STDMETHODCALLTYPE IsNull(_Out_ BOOL* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetPresumedLocation(
    _Outptr_opt_ LPSTR* pFilename,
    _Out_opt_ unsigned* pLine,
    _Out_opt_ unsigned* pCol) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcSourceRange, "f1359b36-a53f-4e81-b514-b6b84122a13f")
struct IDxcSourceRange : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE IsNull(_Out_ BOOL* pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetStart(_Out_ IDxcSourceLocation** pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetEnd(_Out_ IDxcSourceLocation** pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetOffsets(_Out_ unsigned* startOffset, _Out_ unsigned* endOffset) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcToken, "7f90b9ff-a275-4932-97d8-3cfd234482a2")
struct IDxcToken : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetKind(_Out_ DxcTokenKind* pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetLocation(_Out_ IDxcSourceLocation** pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetExtent(_Out_ IDxcSourceRange** pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSpelling(_Out_ LPSTR* pValue) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcTranslationUnit, "9677dee0-c0e5-46a1-8b40-3db3168be63d")
struct IDxcTranslationUnit : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetCursor(_Out_ IDxcCursor** pCursor) = 0;
  virtual HRESULT STDMETHODCALLTYPE Tokenize(
    _In_ IDxcSourceRange* range,
    _Outptr_result_buffer_maybenull_(*pTokenCount) IDxcToken*** pTokens,
    _Out_ unsigned* pTokenCount) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetLocation(
    _In_ IDxcFile* file,
    unsigned line, unsigned column,
    _Outptr_result_nullonfailure_ IDxcSourceLocation** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetNumDiagnostics(_Out_ unsigned* pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetDiagnostic(unsigned index, _Outptr_result_nullonfailure_ IDxcDiagnostic** pValue) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetFile(_In_ const char* name, _Outptr_result_nullonfailure_ IDxcFile** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetFileName(_Outptr_result_maybenull_ LPSTR* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE Reparse(
    _In_count_(num_unsaved_files) IDxcUnsavedFile** unsaved_files,
    unsigned num_unsaved_files) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetCursorForLocation(_In_ IDxcSourceLocation* location, _Outptr_result_nullonfailure_ IDxcCursor** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetLocationForOffset(_In_ IDxcFile* file, unsigned offset, _Outptr_result_nullonfailure_ IDxcSourceLocation** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetSkippedRanges(_In_ IDxcFile* file, _Out_ unsigned* pResultCount, _Outptr_result_buffer_(*pResultCount) IDxcSourceRange*** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetDiagnosticDetails(unsigned index, DxcDiagnosticDisplayOptions options,
    _Out_ unsigned* errorCode,
    _Out_ unsigned* errorLine,
    _Out_ unsigned* errorColumn,
    _Out_ BSTR* errorFile,
    _Out_ unsigned* errorOffset,
    _Out_ unsigned* errorLength,
    _Out_ BSTR* errorMessage) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetInclusionList(_Out_ unsigned* pResultCount, _Outptr_result_buffer_(*pResultCount) IDxcInclusion*** pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE CodeCompleteAt(
      _In_ const char *fileName, unsigned line, unsigned column,
      _In_ IDxcUnsavedFile** pUnsavedFiles, unsigned numUnsavedFiles,
      _In_ DxcCodeCompleteFlags options,
      _Outptr_result_nullonfailure_ IDxcCodeCompleteResults **pResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcType, "2ec912fd-b144-4a15-ad0d-1c5439c81e46")
struct IDxcType : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetSpelling(_Outptr_result_z_ LPSTR* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE IsEqualTo(_In_ IDxcType* other, _Out_ BOOL* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetKind(_Out_ DxcTypeKind* pResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcUnsavedFile, "8ec00f98-07d0-4e60-9d7c-5a50b5b0017f")
struct IDxcUnsavedFile : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetFileName(_Outptr_result_z_ LPSTR* pFileName) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetContents(_Outptr_result_z_ LPSTR* pContents) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetLength(_Out_ unsigned* pLength) = 0;
};


CROSS_PLATFORM_UUIDOF(IDxcCodeCompleteResults, "1E06466A-FD8B-45F3-A78F-8A3F76EBB552")
struct IDxcCodeCompleteResults : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetNumResults(_Out_ unsigned* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetResultAt(unsigned index, _Outptr_result_nullonfailure_ IDxcCompletionResult** pResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcCompletionResult, "943C0588-22D0-4784-86FC-701F802AC2B6")
struct IDxcCompletionResult : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetCursorKind(_Out_ DxcCursorKind* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetCompletionString(_Outptr_result_nullonfailure_ IDxcCompletionString** pResult) = 0;
};

CROSS_PLATFORM_UUIDOF(IDxcCompletionString, "06B51E0F-A605-4C69-A110-CD6E14B58EEC")
struct IDxcCompletionString : public IUnknown
{
  virtual HRESULT STDMETHODCALLTYPE GetNumCompletionChunks(_Out_ unsigned* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetCompletionChunkKind(unsigned chunkNumber, _Out_ DxcCompletionChunkKind* pResult) = 0;
  virtual HRESULT STDMETHODCALLTYPE GetCompletionChunkText(unsigned chunkNumber, _Out_ LPSTR* pResult) = 0;
};

// Fun fact: 'extern' is required because const is by default static in C++, so
// CLSID_DxcIntelliSense is not visible externally (this is OK in C, since const is
// not by default static in C)

#ifdef _MSC_VER
#define CLSID_SCOPE __declspec(selectany) extern
#else
#define CLSID_SCOPE
#endif

CLSID_SCOPE const CLSID
    CLSID_DxcIntelliSense = {/* 3047833c-d1c0-4b8e-9d40-102878605985 */
                             0x3047833c,
                             0xd1c0,
                             0x4b8e,
                             {0x9d, 0x40, 0x10, 0x28, 0x78, 0x60, 0x59, 0x85}};

#endif


================================================
FILE: Source/External/imgui_tools/IconsFontAwesome/IconsFontAwesome5.h
================================================
// Generated by https://github.com/juliettef/IconFontCppHeaders script GenerateIconFontCppHeaders.py for languages C and C++
// from https://github.com/FortAwesome/Font-Awesome/raw/5.x/metadata/icons.yml
// for use with https://github.com/FortAwesome/Font-Awesome/blob/5.x/webfonts/fa-regular-400.ttf, https://github.com/FortAwesome/Font-Awesome/blob/5.x/webfonts/fa-solid-900.ttf
#pragma once

#define FONT_ICON_FILE_NAME_FAR "fa-regular-400.ttf"
#define FONT_ICON_FILE_NAME_FAS "fa-solid-900.ttf"

#define ICON_MIN_FA 0xe005
#define ICON_MAX_16_FA 0xf8ff
#define ICON_MAX_FA 0xf8ff
#define ICON_FA_AD "\xef\x99\x81"	// U+f641
#define ICON_FA_ADDRESS_BOOK "\xef\x8a\xb9"	// U+f2b9
#define ICON_FA_ADDRESS_CARD "\xef\x8a\xbb"	// U+f2bb
#define ICON_FA_ADJUST "\xef\x81\x82"	// U+f042
#define ICON_FA_AIR_FRESHENER "\xef\x97\x90"	// U+f5d0
#define ICON_FA_ALIGN_CENTER "\xef\x80\xb7"	// U+f037
#define ICON_FA_ALIGN_JUSTIFY "\xef\x80\xb9"	// U+f039
#define ICON_FA_ALIGN_LEFT "\xef\x80\xb6"	// U+f036
#define ICON_FA_ALIGN_RIGHT "\xef\x80\xb8"	// U+f038
#define ICON_FA_ALLERGIES "\xef\x91\xa1"	// U+f461
#define ICON_FA_AMBULANCE "\xef\x83\xb9"	// U+f0f9
#define ICON_FA_AMERICAN_SIGN_LANGUAGE_INTERPRETING "\xef\x8a\xa3"	// U+f2a3
#define ICON_FA_ANCHOR "\xef\x84\xbd"	// U+f13d
#define ICON_FA_ANGLE_DOUBLE_DOWN "\xef\x84\x83"	// U+f103
#define ICON_FA_ANGLE_DOUBLE_LEFT "\xef\x84\x80"	// U+f100
#define ICON_FA_ANGLE_DOUBLE_RIGHT "\xef\x84\x81"	// U+f101
#define ICON_FA_ANGLE_DOUBLE_UP "\xef\x84\x82"	// U+f102
#define ICON_FA_ANGLE_DOWN "\xef\x84\x87"	// U+f107
#define ICON_FA_ANGLE_LEFT "\xef\x84\x84"	// U+f104
#define ICON_FA_ANGLE_RIGHT "\xef\x84\x85"	// U+f105
#define ICON_FA_ANGLE_UP "\xef\x84\x86"	// U+f106
#define ICON_FA_ANGRY "\xef\x95\x96"	// U+f556
#define ICON_FA_ANKH "\xef\x99\x84"	// U+f644
#define ICON_FA_APPLE_ALT "\xef\x97\x91"	// U+f5d1
#define ICON_FA_ARCHIVE "\xef\x86\x87"	// U+f187
#define ICON_FA_ARCHWAY "\xef\x95\x97"	// U+f557
#define ICON_FA_ARROW_ALT_CIRCLE_DOWN "\xef\x8d\x98"	// U+f358
#define ICON_FA_ARROW_ALT_CIRCLE_LEFT "\xef\x8d\x99"	// U+f359
#define ICON_FA_ARROW_ALT_CIRCLE_RIGHT "\xef\x8d\x9a"	// U+f35a
#define ICON_FA_ARROW_ALT_CIRCLE_UP "\xef\x8d\x9b"	// U+f35b
#define ICON_FA_ARROW_CIRCLE_DOWN "\xef\x82\xab"	// U+f0ab
#define ICON_FA_ARROW_CIRCLE_LEFT "\xef\x82\xa8"	// U+f0a8
#define ICON_FA_ARROW_CIRCLE_RIGHT "\xef\x82\xa9"	// U+f0a9
#define ICON_FA_ARROW_CIRCLE_UP "\xef\x82\xaa"	// U+f0aa
#define ICON_FA_ARROW_DOWN "\xef\x81\xa3"	// U+f063
#define ICON_FA_ARROW_LEFT "\xef\x81\xa0"	// U+f060
#define ICON_FA_ARROW_RIGHT "\xef\x81\xa1"	// U+f061
#define ICON_FA_ARROW_UP "\xef\x81\xa2"	// U+f062
#define ICON_FA_ARROWS_ALT "\xef\x82\xb2"	// U+f0b2
#define ICON_FA_ARROWS_ALT_H "\xef\x8c\xb7"	// U+f337
#define ICON_FA_ARROWS_ALT_V "\xef\x8c\xb8"	// U+f338
#define ICON_FA_ASSISTIVE_LISTENING_SYSTEMS "\xef\x8a\xa2"	// U+f2a2
#define ICON_FA_ASTERISK "\xef\x81\xa9"	// U+f069
#define ICON_FA_AT "\xef\x87\xba"	// U+f1fa
#define ICON_FA_ATLAS "\xef\x95\x98"	// U+f558
#define ICON_FA_ATOM "\xef\x97\x92"	// U+f5d2
#define ICON_FA_AUDIO_DESCRIPTION "\xef\x8a\x9e"	// U+f29e
#define ICON_FA_AWARD "\xef\x95\x99"	// U+f559
#define ICON_FA_BABY "\xef\x9d\xbc"	// U+f77c
#define ICON_FA_BABY_CARRIAGE "\xef\x9d\xbd"	// U+f77d
#define ICON_FA_BACKSPACE "\xef\x95\x9a"	// U+f55a
#define ICON_FA_BACKWARD "\xef\x81\x8a"	// U+f04a
#define ICON_FA_BACON "\xef\x9f\xa5"	// U+f7e5
#define ICON_FA_BACTERIA "\xee\x81\x99"	// U+e059
#define ICON_FA_BACTERIUM "\xee\x81\x9a"	// U+e05a
#define ICON_FA_BAHAI "\xef\x99\xa6"	// U+f666
#define ICON_FA_BALANCE_SCALE "\xef\x89\x8e"	// U+f24e
#define ICON_FA_BALANCE_SCALE_LEFT "\xef\x94\x95"	// U+f515
#define ICON_FA_BALANCE_SCALE_RIGHT "\xef\x94\x96"	// U+f516
#define ICON_FA_BAN "\xef\x81\x9e"	// U+f05e
#define ICON_FA_BAND_AID "\xef\x91\xa2"	// U+f462
#define ICON_FA_BARCODE "\xef\x80\xaa"	// U+f02a
#define ICON_FA_BARS "\xef\x83\x89"	// U+f0c9
#define ICON_FA_BASEBALL_BALL "\xef\x90\xb3"	// U+f433
#define ICON_FA_BASKETBALL_BALL "\xef\x90\xb4"	// U+f434
#define ICON_FA_BATH "\xef\x8b\x8d"	// U+f2cd
#define ICON_FA_BATTERY_EMPTY "\xef\x89\x84"	// U+f244
#define ICON_FA_BATTERY_FULL "\xef\x89\x80"	// U+f240
#define ICON_FA_BATTERY_HALF "\xef\x89\x82"	// U+f242
#define ICON_FA_BATTERY_QUARTER "\xef\x89\x83"	// U+f243
#define ICON_FA_BATTERY_THREE_QUARTERS "\xef\x89\x81"	// U+f241
#define ICON_FA_BED "\xef\x88\xb6"	// U+f236
#define ICON_FA_BEER "\xef\x83\xbc"	// U+f0fc
#define ICON_FA_BELL "\xef\x83\xb3"	// U+f0f3
#define ICON_FA_BELL_SLASH "\xef\x87\xb6"	// U+f1f6
#define ICON_FA_BEZIER_CURVE "\xef\x95\x9b"	// U+f55b
#define ICON_FA_BIBLE "\xef\x99\x87"	// U+f647
#define ICON_FA_BICYCLE "\xef\x88\x86"	// U+f206
#define ICON_FA_BIKING "\xef\xa1\x8a"	// U+f84a
#define ICON_FA_BINOCULARS "\xef\x87\xa5"	// U+f1e5
#define ICON_FA_BIOHAZARD "\xef\x9e\x80"	// U+f780
#define ICON_FA_BIRTHDAY_CAKE "\xef\x87\xbd"	// U+f1fd
#define ICON_FA_BLENDER "\xef\x94\x97"	// U+f517
#define ICON_FA_BLENDER_PHONE "\xef\x9a\xb6"	// U+f6b6
#define ICON_FA_BLIND "\xef\x8a\x9d"	// U+f29d
#define ICON_FA_BLOG "\xef\x9e\x81"	// U+f781
#define ICON_FA_BOLD "\xef\x80\xb2"	// U+f032
#define ICON_FA_BOLT "\xef\x83\xa7"	// U+f0e7
#define ICON_FA_BOMB "\xef\x87\xa2"	// U+f1e2
#define ICON_FA_BONE "\xef\x97\x97"	// U+f5d7
#define ICON_FA_BONG "\xef\x95\x9c"	// U+f55c
#define ICON_FA_BOOK "\xef\x80\xad"	// U+f02d
#define ICON_FA_BOOK_DEAD "\xef\x9a\xb7"	// U+f6b7
#define ICON_FA_BOOK_MEDICAL "\xef\x9f\xa6"	// U+f7e6
#define ICON_FA_BOOK_OPEN "\xef\x94\x98"	// U+f518
#define ICON_FA_BOOK_READER "\xef\x97\x9a"	// U+f5da
#define ICON_FA_BOOKMARK "\xef\x80\xae"	// U+f02e
#define ICON_FA_BORDER_ALL "\xef\xa1\x8c"	// U+f84c
#define ICON_FA_BORDER_NONE "\xef\xa1\x90"	// U+f850
#define ICON_FA_BORDER_STYLE "\xef\xa1\x93"	// U+f853
#define ICON_FA_BOWLING_BALL "\xef\x90\xb6"	// U+f436
#define ICON_FA_BOX "\xef\x91\xa6"	// U+f466
#define ICON_FA_BOX_OPEN "\xef\x92\x9e"	// U+f49e
#define ICON_FA_BOX_TISSUE "\xee\x81\x9b"	// U+e05b
#define ICON_FA_BOXES "\xef\x91\xa8"	// U+f468
#define ICON_FA_BRAILLE "\xef\x8a\xa1"	// U+f2a1
#define ICON_FA_BRAIN "\xef\x97\x9c"	// U+f5dc
#define ICON_FA_BREAD_SLICE "\xef\x9f\xac"	// U+f7ec
#define ICON_FA_BRIEFCASE "\xef\x82\xb1"	// U+f0b1
#define ICON_FA_BRIEFCASE_MEDICAL "\xef\x91\xa9"	// U+f469
#define ICON_FA_BROADCAST_TOWER "\xef\x94\x99"	// U+f519
#define ICON_FA_BROOM "\xef\x94\x9a"	// U+f51a
#define ICON_FA_BRUSH "\xef\x95\x9d"	// U+f55d
#define ICON_FA_BUG "\xef\x86\x88"	// U+f188
#define ICON_FA_BUILDING "\xef\x86\xad"	// U+f1ad
#define ICON_FA_BULLHORN "\xef\x82\xa1"	// U+f0a1
#define ICON_FA_BULLSEYE "\xef\x85\x80"	// U+f140
#define ICON_FA_BURN "\xef\x91\xaa"	// U+f46a
#define ICON_FA_BUS "\xef\x88\x87"	// U+f207
#define ICON_FA_BUS_ALT "\xef\x95\x9e"	// U+f55e
#define ICON_FA_BUSINESS_TIME "\xef\x99\x8a"	// U+f64a
#define ICON_FA_CALCULATOR "\xef\x87\xac"	// U+f1ec
#define ICON_FA_CALENDAR "\xef\x84\xb3"	// U+f133
#define ICON_FA_CALENDAR_ALT "\xef\x81\xb3"	// U+f073
#define ICON_FA_CALENDAR_CHECK "\xef\x89\xb4"	// U+f274
#define ICON_FA_CALENDAR_DAY "\xef\x9e\x83"	// U+f783
#define ICON_FA_CALENDAR_MINUS "\xef\x89\xb2"	// U+f272
#define ICON_FA_CALENDAR_PLUS "\xef\x89\xb1"	// U+f271
#define ICON_FA_CALENDAR_TIMES "\xef\x89\xb3"	// U+f273
#define ICON_FA_CALENDAR_WEEK "\xef\x9e\x84"	// U+f784
#define ICON_FA_CAMERA "\xef\x80\xb0"	// U+f030
#define ICON_FA_CAMERA_RETRO "\xef\x82\x83"	// U+f083
#define ICON_FA_CAMPGROUND "\xef\x9a\xbb"	// U+f6bb
#define ICON_FA_CANDY_CANE "\xef\x9e\x86"	// U+f786
#define ICON_FA_CANNABIS "\xef\x95\x9f"	// U+f55f
#define ICON_FA_CAPSULES "\xef\x91\xab"	// U+f46b
#define ICON_FA_CAR "\xef\x86\xb9"	// U+f1b9
#define ICON_FA_CAR_ALT "\xef\x97\x9e"	// U+f5de
#define ICON_FA_CAR_BATTERY "\xef\x97\x9f"	// U+f5df
#define ICON_FA_CAR_CRASH "\xef\x97\xa1"	// U+f5e1
#define ICON_FA_CAR_SIDE "\xef\x97\xa4"	// U+f5e4
#define ICON_FA_CARAVAN "\xef\xa3\xbf"	// U+f8ff
#define ICON_FA_CARET_DOWN "\xef\x83\x97"	// U+f0d7
#define ICON_FA_CARET_LEFT "\xef\x83\x99"	// U+f0d9
#define ICON_FA_CARET_RIGHT "\xef\x83\x9a"	// U+f0da
#define ICON_FA_CARET_SQUARE_DOWN "\xef\x85\x90"	// U+f150
#define ICON_FA_CARET_SQUARE_LEFT "\xef\x86\x91"	// U+f191
#define ICON_FA_CARET_SQUARE_RIGHT "\xef\x85\x92"	// U+f152
#define ICON_FA_CARET_SQUARE_UP "\xef\x85\x91"	// U+f151
#define ICON_FA_CARET_UP "\xef\x83\x98"	// U+f0d8
#define ICON_FA_CARROT "\xef\x9e\x87"	// U+f787
#define ICON_FA_CART_ARROW_DOWN "\xef\x88\x98"	// U+f218
#define ICON_FA_CART_PLUS "\xef\x88\x97"	// U+f217
#define ICON_FA_CASH_REGISTER "\xef\x9e\x88"	// U+f788
#define ICON_FA_CAT "\xef\x9a\xbe"	// U+f6be
#define ICON_FA_CERTIFICATE "\xef\x82\xa3"	// U+f0a3
#define ICON_FA_CHAIR "\xef\x9b\x80"	// U+f6c0
#define ICON_FA_CHALKBOARD "\xef\x94\x9b"	// U+f51b
#define ICON_FA_CHALKBOARD_TEACHER "\xef\x94\x9c"	// U+f51c
#define ICON_FA_CHARGING_STATION "\xef\x97\xa7"	// U+f5e7
#define ICON_FA_CHART_AREA "\xef\x87\xbe"	// U+f1fe
#define ICON_FA_CHART_BAR "\xef\x82\x80"	// U+f080
#define ICON_FA_CHART_LINE "\xef\x88\x81"	// U+f201
#define ICON_FA_CHART_PIE "\xef\x88\x80"	// U+f200
#define ICON_FA_CHECK "\xef\x80\x8c"	// U+f00c
#define ICON_FA_CHECK_CIRCLE "\xef\x81\x98"	// U+f058
#define ICON_FA_CHECK_DOUBLE "\xef\x95\xa0"	// U+f560
#define ICON_FA_CHECK_SQUARE "\xef\x85\x8a"	// U+f14a
#define ICON_FA_CHEESE "\xef\x9f\xaf"	// U+f7ef
#define ICON_FA_CHESS "\xef\x90\xb9"	// U+f439
#define ICON_FA_CHESS_BISHOP "\xef\x90\xba"	// U+f43a
#define ICON_FA_CHESS_BOARD "\xef\x90\xbc"	// U+f43c
#define ICON_FA_CHESS_KING "\xef\x90\xbf"	// U+f43f
#define ICON_FA_CHESS_KNIGHT "\xef\x91\x81"	// U+f441
#define ICON_FA_CHESS_PAWN "\xef\x91\x83"	// U+f443
#define ICON_FA_CHESS_QUEEN "\xef\x91\x85"	// U+f445
#define ICON_FA_CHESS_ROOK "\xef\x91\x87"	// U+f447
#define ICON_FA_CHEVRON_CIRCLE_DOWN "\xef\x84\xba"	// U+f13a
#define ICON_FA_CHEVRON_CIRCLE_LEFT "\xef\x84\xb7"	// U+f137
#define ICON_FA_CHEVRON_CIRCLE_RIGHT "\xef\x84\xb8"	// U+f138
#define ICON_FA_CHEVRON_CIRCLE_UP "\xef\x84\xb9"	// U+f139
#define ICON_FA_CHEVRON_DOWN "\xef\x81\xb8"	// U+f078
#define ICON_FA_CHEVRON_LEFT "\xef\x81\x93"	// U+f053
#define ICON_FA_CHEVRON_RIGHT "\xef\x81\x94"	// U+f054
#define ICON_FA_CHEVRON_UP "\xef\x81\xb7"	// U+f077
#define ICON_FA_CHILD "\xef\x86\xae"	// U+f1ae
#define ICON_FA_CHURCH "\xef\x94\x9d"	// U+f51d
#define ICON_FA_CIRCLE "\xef\x84\x91"	// U+f111
#define ICON_FA_CIRCLE_NOTCH "\xef\x87\x8e"	// U+f1ce
#define ICON_FA_CITY "\xef\x99\x8f"	// U+f64f
#define ICON_FA_CLINIC_MEDICAL "\xef\x9f\xb2"	// U+f7f2
#define ICON_FA_CLIPBOARD "\xef\x8c\xa8"	// U+f328
#define ICON_FA_CLIPBOARD_CHECK "\xef\x91\xac"	// U+f46c
#define ICON_FA_CLIPBOARD_LIST "\xef\x91\xad"	// U+f46d
#define ICON_FA_CLOCK "\xef\x80\x97"	// U+f017
#define ICON_FA_CLONE "\xef\x89\x8d"	// U+f24d
#define ICON_FA_CLOSED_CAPTIONING "\xef\x88\x8a"	// U+f20a
#define ICON_FA_CLOUD "\xef\x83\x82"	// U+f0c2
#define ICON_FA_CLOUD_DOWNLOAD_ALT "\xef\x8e\x81"	// U+f381
#define ICON_FA_CLOUD_MEATBALL "\xef\x9c\xbb"	// U+f73b
#define ICON_FA_CLOUD_MOON "\xef\x9b\x83"	// U+f6c3
#define ICON_FA_CLOUD_MOON_RAIN "\xef\x9c\xbc"	// U+f73c
#define ICON_FA_CLOUD_RAIN "\xef\x9c\xbd"	// U+f73d
#define ICON_FA_CLOUD_SHOWERS_HEAVY "\xef\x9d\x80"	// U+f740
#define ICON_FA_CLOUD_SUN "\xef\x9b\x84"	// U+f6c4
#define ICON_FA_CLOUD_SUN_RAIN "\xef\x9d\x83"	// U+f743
#define ICON_FA_CLOUD_UPLOAD_ALT "\xef\x8e\x82"	// U+f382
#define ICON_FA_COCKTAIL "\xef\x95\xa1"	// U+f561
#define ICON_FA_CODE "\xef\x84\xa1"	// U+f121
#define ICON_FA_CODE_BRANCH "\xef\x84\xa6"	// U+f126
#define ICON_FA_COFFEE "\xef\x83\xb4"	// U+f0f4
#define ICON_FA_COG "\xef\x80\x93"	// U+f013
#define ICON_FA_COGS "\xef\x82\x85"	// U+f085
#define ICON_FA_COINS "\xef\x94\x9e"	// U+f51e
#define ICON_FA_COLUMNS "\xef\x83\x9b"	// U+f0db
#define ICON_FA_COMMENT "\xef\x81\xb5"	// U+f075
#define ICON_FA_COMMENT_ALT "\xef\x89\xba"	// U+f27a
#define ICON_FA_COMMENT_DOLLAR "\xef\x99\x91"	// U+f651
#define ICON_FA_COMMENT_DOTS "\xef\x92\xad"	// U+f4ad
#define ICON_FA_COMMENT_MEDICAL "\xef\x9f\xb5"	// U+f7f5
#define ICON_FA_COMMENT_SLASH "\xef\x92\xb3"	// U+f4b3
#define ICON_FA_COMMENTS "\xef\x82\x86"	// U+f086
#define ICON_FA_COMMENTS_DOLLAR "\xef\x99\x93"	// U+f653
#define ICON_FA_COMPACT_DISC "\xef\x94\x9f"	// U+f51f
#define ICON_FA_COMPASS "\xef\x85\x8e"	// U+f14e
#define ICON_FA_COMPRESS "\xef\x81\xa6"	// U+f066
#define ICON_FA_COMPRESS_ALT "\xef\x90\xa2"	// U+f422
#define ICON_FA_COMPRESS_ARROWS_ALT "\xef\x9e\x8c"	// U+f78c
#define ICON_FA_CONCIERGE_BELL "\xef\x95\xa2"	// U+f562
#define ICON_FA_COOKIE "\xef\x95\xa3"	// U+f563
#define ICON_FA_COOKIE_BITE "\xef\x95\xa4"	// U+f564
#define ICON_FA_COPY "\xef\x83\x85"	// U+f0c5
#define ICON_FA_COPYRIGHT "\xef\x87\xb9"	// U+f1f9
#define ICON_FA_COUCH "\xef\x92\xb8"	// U+f4b8
#define ICON_FA_CREDIT_CARD "\xef\x82\x9d"	// U+f09d
#define ICON_FA_CROP "\xef\x84\xa5"	// U+f125
#define ICON_FA_CROP_ALT "\xef\x95\xa5"	// U+f565
#define ICON_FA_CROSS "\xef\x99\x94"	// U+f654
#define ICON_FA_CROSSHAIRS "\xef\x81\x9b"	// U+f05b
#define ICON_FA_CROW "\xef\x94\xa0"	// U+f520
#define ICON_FA_CROWN "\xef\x94\xa1"	// U+f521
#define ICON_FA_CRUTCH "\xef\x9f\xb7"	// U+f7f7
#define ICON_FA_CUBE "\xef\x86\xb2"	// U+f1b2
#define ICON_FA_CUBES "\xef\x86\xb3"	// U+f1b3
#define ICON_FA_CUT "\xef\x83\x84"	// U+f0c4
#define ICON_FA_DATABASE "\xef\x87\x80"	// U+f1c0
#define ICON_FA_DEAF "\xef\x8a\xa4"	// U+f2a4
#define ICON_FA_DEMOCRAT "\xef\x9d\x87"	// U+f747
#define ICON_FA_DESKTOP "\xef\x84\x88"	// U+f108
#define ICON_FA_DHARMACHAKRA "\xef\x99\x95"	// U+f655
#define ICON_FA_DIAGNOSES "\xef\x91\xb0"	// U+f470
#define ICON_FA_DICE "\xef\x94\xa2"	// U+f522
#define ICON_FA_DICE_D20 "\xef\x9b\x8f"	// U+f6cf
#define ICON_FA_DICE_D6 "\xef\x9b\x91"	// U+f6d1
#define ICON_FA_DICE_FIVE "\xef\x94\xa3"	// U+f523
#define ICON_FA_DICE_FOUR "\xef\x94\xa4"	// U+f524
#define ICON_FA_DICE_ONE "\xef\x94\xa5"	// U+f525
#define ICON_FA_DICE_SIX "\xef\x94\xa6"	// U+f526
#define ICON_FA_DICE_THREE "\xef\x94\xa7"	// U+f527
#define ICON_FA_DICE_TWO "\xef\x94\xa8"	// U+f528
#define ICON_FA_DIGITAL_TACHOGRAPH "\xef\x95\xa6"	// U+f566
#define ICON_FA_DIRECTIONS "\xef\x97\xab"	// U+f5eb
#define ICON_FA_DISEASE "\xef\x9f\xba"	// U+f7fa
#define ICON_FA_DIVIDE "\xef\x94\xa9"	// U+f529
#define ICON_FA_DIZZY "\xef\x95\xa7"	// U+f567
#define ICON_FA_DNA "\xef\x91\xb1"	// U+f471
#define ICON_FA_DOG "\xef\x9b\x93"	// U+f6d3
#define ICON_FA_DOLLAR_SIGN "\xef\x85\x95"	// U+f155
#define ICON_FA_DOLLY "\xef\x91\xb2"	// U+f472
#define ICON_FA_DOLLY_FLATBED "\xef\x91\xb4"	// U+f474
#define ICON_FA_DONATE "\xef\x92\xb9"	// U+f4b9
#define ICON_FA_DOOR_CLOSED "\xef\x94\xaa"	// U+f52a
#define ICON_FA_DOOR_OPEN "\xef\x94\xab"	// U+f52b
#define ICON_FA_DOT_CIRCLE "\xef\x86\x92"	// U+f192
#define ICON_FA_DOVE "\xef\x92\xba"	// U+f4ba
#define ICON_FA_DOWNLOAD "\xef\x80\x99"	// U+f019
#define ICON_FA_DRAFTING_COMPASS "\xef\x95\xa8"	// U+f568
#define ICON_FA_DRAGON "\xef\x9b\x95"	// U+f6d5
#define ICON_FA_DRAW_POLYGON "\xef\x97\xae"	// U+f5ee
#define ICON_FA_DRUM "\xef\x95\xa9"	// U+f569
#define ICON_FA_DRUM_STEELPAN "\xef\x95\xaa"	// U+f56a
#define ICON_FA_DRUMSTICK_BITE "\xef\x9b\x97"	// U+f6d7
#define ICON_FA_DUMBBELL "\xef\x91\x8b"	// U+f44b
#define ICON_FA_DUMPSTER "\xef\x9e\x93"	// U+f793
#define ICON_FA_DUMPSTER_FIRE "\xef\x9e\x94"	// U+f794
#define ICON_FA_DUNGEON "\xef\x9b\x99"	// U+f6d9
#define ICON_FA_EDIT "\xef\x81\x84"	// U+f044
#define ICON_FA_EGG "\xef\x9f\xbb"	// U+f7fb
#define ICON_FA_EJECT "\xef\x81\x92"	// U+f052
#define ICON_FA_ELLIPSIS_H "\xef\x85\x81"	// U+f141
#define ICON_FA_ELLIPSIS_V "\xef\x85\x82"	// U+f142
#define ICON_FA_ENVELOPE "\xef\x83\xa0"	// U+f0e0
#define ICON_FA_ENVELOPE_OPEN "\xef\x8a\xb6"	// U+f2b6
#define ICON_FA_ENVELOPE_OPEN_TEXT "\xef\x99\x98"	// U+f658
#define ICON_FA_ENVELOPE_SQUARE "\xef\x86\x99"	// U+f199
#define ICON_FA_EQUALS "\xef\x94\xac"	// U+f52c
#define ICON_FA_ERASER "\xef\x84\xad"	// U+f12d
#define ICON_FA_ETHERNET "\xef\x9e\x96"	// U+f796
#define ICON_FA_EURO_SIGN "\xef\x85\x93"	// U+f153
#define ICON_FA_EXCHANGE_ALT "\xef\x8d\xa2"	// U+f362
#define ICON_FA_EXCLAMATION "\xef\x84\xaa"	// U+f12a
#define ICON_FA_EXCLAMATION_CIRCLE "\xef\x81\xaa"	// U+f06a
#define ICON_FA_EXCLAMATION_TRIANGLE "\xef\x81\xb1"	// U+f071
#define ICON_FA_EXPAND "\xef\x81\xa5"	// U+f065
#define ICON_FA_EXPAND_ALT "\xef\x90\xa4"	// U+f424
#define ICON_FA_EXPAND_ARROWS_ALT "\xef\x8c\x9e"	// U+f31e
#define ICON_FA_EXTERNAL_LINK_ALT "\xef\x8d\x9d"	// U+f35d
#define ICON_FA_EXTERNAL_LINK_SQUARE_ALT "\xef\x8d\xa0"	// U+f360
#define ICON_FA_EYE "\xef\x81\xae"	// U+f06e
#define ICON_FA_EYE_DROPPER "\xef\x87\xbb"	// U+f1fb
#define ICON_FA_EYE_SLASH "\xef\x81\xb0"	// U+f070
#define ICON_FA_FAN "\xef\xa1\xa3"	// U+f863
#define ICON_FA_FAST_BACKWARD "\xef\x81\x89"	// U+f049
#define ICON_FA_FAST_FORWARD "\xef\x81\x90"	// U+f050
#define ICON_FA_FAUCET "\xee\x80\x85"	// U+e005
#define ICON_FA_FAX "\xef\x86\xac"	// U+f1ac
#define ICON_FA_FEATHER "\xef\x94\xad"	// U+f52d
#define ICON_FA_FEATHER_ALT "\xef\x95\xab"	// U+f56b
#define ICON_FA_FEMALE "\xef\x86\x82"	// U+f182
#define ICON_FA_FIGHTER_JET "\xef\x83\xbb"	// U+f0fb
#define ICON_FA_FILE "\xef\x85\x9b"	// U+f15b
#define ICON_FA_FILE_ALT "\xef\x85\x9c"	// U+f15c
#define ICON_FA_FILE_ARCHIVE "\xef\x87\x86"	// U+f1c6
#define ICON_FA_FILE_AUDIO "\xef\x87\x87"	// U+f1c7
#define ICON_FA_FILE_CODE "\xef\x87\x89"	// U+f1c9
#define ICON_FA_FILE_CONTRACT "\xef\x95\xac"	// U+f56c
#define ICON_FA_FILE_CSV "\xef\x9b\x9d"	// U+f6dd
#define ICON_FA_FILE_DOWNLOAD "\xef\x95\xad"	// U+f56d
#define ICON_FA_FILE_EXCEL "\xef\x87\x83"	// U+f1c3
#define ICON_FA_FILE_EXPORT "\xef\x95\xae"	// U+f56e
#define ICON_FA_FILE_IMAGE "\xef\x87\x85"	// U+f1c5
#define ICON_FA_FILE_IMPORT "\xef\x95\xaf"	// U+f56f
#define ICON_FA_FILE_INVOICE "\xef\x95\xb0"	// U+f570
#define ICON_FA_FILE_INVOICE_DOLLAR "\xef\x95\xb1"	// U+f571
#define ICON_FA_FILE_MEDICAL "\xef\x91\xb7"	// U+f477
#define ICON_FA_FILE_MEDICAL_ALT "\xef\x91\xb8"	// U+f478
#define ICON_FA_FILE_PDF "\xef\x87\x81"	// U+f1c1
#define ICON_FA_FILE_POWERPOINT "\xef\x87\x84"	// U+f1c4
#define ICON_FA_FILE_PRESCRIPTION "\xef\x95\xb2"	// U+f572
#define ICON_FA_FILE_SIGNATURE "\xef\x95\xb3"	// U+f573
#define ICON_FA_FILE_UPLOAD "\xef\x95\xb4"	// U+f574
#define ICON_FA_FILE_VIDEO "\xef\x87\x88"	// U+f1c8
#define ICON_FA_FILE_WORD "\xef\x87\x82"	// U+f1c2
#define ICON_FA_FILL "\xef\x95\xb5"	// U+f575
#define ICON_FA_FILL_DRIP "\xef\x95\xb6"	// U+f576
#define ICON_FA_FILM "\xef\x80\x88"	// U+f008
#define ICON_FA_FILTER "\xef\x82\xb0"	// U+f0b0
#define ICON_FA_FINGERPRINT "\xef\x95\xb7"	// U+f577
#define ICON_FA_FIRE "\xef\x81\xad"	// U+f06d
#define ICON_FA_FIRE_ALT "\xef\x9f\xa4"	// U+f7e4
#define ICON_FA_FIRE_EXTINGUISHER "\xef\x84\xb4"	// U+f134
#define ICON_FA_FIRST_AID "\xef\x91\xb9"	// U+f479
#define ICON_FA_FISH "\xef\x95\xb8"	// U+f578
#define ICON_FA_FIST_RAISED "\xef\x9b\x9e"	// U+f6de
#define ICON_FA_FLAG "\xef\x80\xa4"	// U+f024
#define ICON_FA_FLAG_CHECKERED "\xef\x84\x9e"	// U+f11e
#define ICON_FA_FLAG_USA "\xef\x9d\x8d"	// U+f74d
#define ICON_FA_FLASK "\xef\x83\x83"	// U+f0c3
#define ICON_FA_FLUSHED "\xef\x95\xb9"	// U+f579
#define ICON_FA_FOLDER "\xef\x81\xbb"	// U+f07b
#define ICON_FA_FOLDER_MINUS "\xef\x99\x9d"	// U+f65d
#define ICON_FA_FOLDER_OPEN "\xef\x81\xbc"	// U+f07c
#define ICON_FA_FOLDER_PLUS "\xef\x99\x9e"	// U+f65e
#define ICON_FA_FONT "\xef\x80\xb1"	// U+f031
#define ICON_FA_FONT_AWESOME_LOGO_FULL "\xef\x93\xa6"	// U+f4e6
#define ICON_FA_FOOTBALL_BALL "\xef\x91\x8e"	// U+f44e
#define ICON_FA_FORWARD "\xef\x81\x8e"	// U+f04e
#define ICON_FA_FROG "\xef\x94\xae"	// U+f52e
#define ICON_FA_FROWN "\xef\x84\x99"	// U+f119
#define ICON_FA_FROWN_OPEN "\xef\x95\xba"	// U+f57a
#define ICON_FA_FUNNEL_DOLLAR "\xef\x99\xa2"	// U+f662
#define ICON_FA_FUTBOL "\xef\x87\xa3"	// U+f1e3
#define ICON_FA_GAMEPAD "\xef\x84\x9b"	// U+f11b
#define ICON_FA_GAS_PUMP "\xef\x94\xaf"	// U+f52f
#define ICON_FA_GAVEL "\xef\x83\xa3"	// U+f0e3
#define ICON_FA_GEM "\xef\x8e\xa5"	// U+f3a5
#define ICON_FA_GENDERLESS "\xef\x88\xad"	// U+f22d
#define ICON_FA_GHOST "\xef\x9b\xa2"	// U+f6e2
#define ICON_FA_GIFT "\xef\x81\xab"	// U+f06b
#define ICON_FA_GIFTS "\xef\x9e\x9c"	// U+f79c
#define ICON_FA_GLASS_CHEERS "\xef\x9e\x9f"	// U+f79f
#define ICON_FA_GLASS_MARTINI "\xef\x80\x80"	// U+f000
#define ICON_FA_GLASS_MARTINI_ALT "\xef\x95\xbb"	// U+f57b
#define ICON_FA_GLASS_WHISKEY "\xef\x9e\xa0"	// U+f7a0
#define ICON_FA_GLASSES "\xef\x94\xb0"	// U+f530
#define ICON_FA_GLOBE "\xef\x82\xac"	// U+f0ac
#define ICON_FA_GLOBE_AFRICA "\xef\x95\xbc"	// U+f57c
#define ICON_FA_GLOBE_AMERICAS "\xef\x95\xbd"	// U+f57d
#define ICON_FA_GLOBE_ASIA "\xef\x95\xbe"	// U+f57e
#define ICON_FA_GLOBE_EUROPE "\xef\x9e\xa2"	// U+f7a2
#define ICON_FA_GOLF_BALL "\xef\x91\x90"	// U+f450
#define ICON_FA_GOPURAM "\xef\x99\xa4"	// U+f664
#define ICON_FA_GRADUATION_CAP "\xef\x86\x9d"	// U+f19d
#define ICON_FA_GREATER_THAN "\xef\x94\xb1"	// U+f531
#define ICON_FA_GREATER_THAN_EQUAL "\xef\x94\xb2"	// U+f532
#define ICON_FA_GRIMACE "\xef\x95\xbf"	// U+f57f
#define ICON_FA_GRIN "\xef\x96\x80"	// U+f580
#define ICON_FA_GRIN_ALT "\xef\x96\x81"	// U+f581
#define ICON_FA_GRIN_BEAM "\xef\x96\x82"	// U+f582
#define ICON_FA_GRIN_BEAM_SWEAT "\xef\x96\x83"	// U+f583
#define ICON_FA_GRIN_HEARTS "\xef\x96\x84"	// U+f584
#define ICON_FA_GRIN_SQUINT "\xef\x96\x85"	// U+f585
#define ICON_FA_GRIN_SQUINT_TEARS "\xef\x96\x86"	// U+f586
#define ICON_FA_GRIN_STARS "\xef\x96\x87"	// U+f587
#define ICON_FA_GRIN_TEARS "\xef\x96\x88"	// U+f588
#define ICON_FA_GRIN_TONGUE "\xef\x96\x89"	// U+f589
#define ICON_FA_GRIN_TONGUE_SQUINT "\xef\x96\x8a"	// U+f58a
#define ICON_FA_GRIN_TONGUE_WINK "\xef\x96\x8b"	// U+f58b
#define ICON_FA_GRIN_WINK "\xef\x96\x8c"	// U+f58c
#define ICON_FA_GRIP_HORIZONTAL "\xef\x96\x8d"	// U+f58d
#define ICON_FA_GRIP_LINES "\xef\x9e\xa4"	// U+f7a4
#define ICON_FA_GRIP_LINES_VERTICAL "\xef\x9e\xa5"	// U+f7a5
#define ICON_FA_GRIP_VERTICAL "\xef\x96\x8e"	// U+f58e
#define ICON_FA_GUITAR "\xef\x9e\xa6"	// U+f7a6
#define ICON_FA_H_SQUARE "\xef\x83\xbd"	// U+f0fd
#define ICON_FA_HAMBURGER "\xef\xa0\x85"	// U+f805
#define ICON_FA_HAMMER "\xef\x9b\xa3"	// U+f6e3
#define ICON_FA_HAMSA "\xef\x99\xa5"	// U+f665
#define ICON_FA_HAND_HOLDING "\xef\x92\xbd"	// U+f4bd
#define ICON_FA_HAND_HOLDING_HEART "\xef\x92\xbe"	// U+f4be
#define ICON_FA_HAND_HOLDING_MEDICAL "\xee\x81\x9c"	// U+e05c
#define ICON_FA_HAND_HOLDING_USD "\xef\x93\x80"	// U+f4c0
#define ICON_FA_HAND_HOLDING_WATER "\xef\x93\x81"	// U+f4c1
#define ICON_FA_HAND_LIZARD "\xef\x89\x98"	// U+f258
#define ICON_FA_HAND_MIDDLE_FINGER "\xef\xa0\x86"	// U+f806
#define ICON_FA_HAND_PAPER "\xef\x89\x96"	// U+f256
#define ICON_FA_HAND_PEACE "\xef\x89\x9b"	// U+f25b
#define ICON_FA_HAND_POINT_DOWN "\xef\x82\xa7"	// U+f0a7
#define ICON_FA_HAND_POINT_LEFT "\xef\x82\xa5"	// U+f0a5
#define ICON_FA_HAND_POINT_RIGHT "\xef\x82\xa4"	// U+f0a4
#define ICON_FA_HAND_POINT_UP "\xef\x82\xa6"	// U+f0a6
#define ICON_FA_HAND_POINTER "\xef\x89\x9a"	// U+f25a
#define ICON_FA_HAND_ROCK "\xef\x89\x95"	// U+f255
#define ICON_FA_HAND_SCISSORS "\xef\x89\x97"	// U+f257
#define ICON_FA_HAND_SPARKLES "\xee\x81\x9d"	// U+e05d
#define ICON_FA_HAND_SPOCK "\xef\x89\x99"	// U+f259
#define ICON_FA_HANDS "\xef\x93\x82"	// U+f4c2
#define ICON_FA_HANDS_HELPING "\xef\x93\x84"	// U+f4c4
#define ICON_FA_HANDS_WASH "\xee\x81\x9e"	// U+e05e
#define ICON_FA_HANDSHAKE "\xef\x8a\xb5"	// U+f2b5
#define ICON_FA_HANDSHAKE_ALT_SLASH "\xee\x81\x9f"	// U+e05f
#define ICON_FA_HANDSHAKE_SLASH "\xee\x81\xa0"	// U+e060
#define ICON_FA_HANUKIAH "\xef\x9b\xa6"	// U+f6e6
#define ICON_FA_HARD_HAT "\xef\xa0\x87"	// U+f807
#define ICON_FA_HASHTAG "\xef\x8a\x92"	// U+f292
#define ICON_FA_HAT_COWBOY "\xef\xa3\x80"	// U+f8c0
#define ICON_FA_HAT_COWBOY_SIDE "\xef\xa3\x81"	// U+f8c1
#define ICON_FA_HAT_WIZARD "\xef\x9b\xa8"	// U+f6e8
#define ICON_FA_HDD "\xef\x82\xa0"	// U+f0a0
#define ICON_FA_HEAD_SIDE_COUGH "\xee\x81\xa1"	// U+e061
#define ICON_FA_HEAD_SIDE_COUGH_SLASH "\xee\x81\xa2"	// U+e062
#define ICON_FA_HEAD_SIDE_MASK "\xee\x81\xa3"	// U+e063
#define ICON_FA_HEAD_SIDE_VIRUS "\xee\x81\xa4"	// U+e064
#define ICON_FA_HEADING "\xef\x87\x9c"	// U+f1dc
#define ICON_FA_HEADPHONES "\xef\x80\xa5"	// U+f025
#define ICON_FA_HEADPHONES_ALT "\xef\x96\x8f"	// U+f58f
#define ICON_FA_HEADSET "\xef\x96\x90"	// U+f590
#define ICON_FA_HEART "\xef\x80\x84"	// U+f004
#define ICON_FA_HEART_BROKEN "\xef\x9e\xa9"	// U+f7a9
#define ICON_FA_HEARTBEAT "\xef\x88\x9e"	// U+f21e
#define ICON_FA_HELICOPTER "\xef\x94\xb3"	// U+f533
#define ICON_FA_HIGHLIGHTER "\xef\x96\x91"	// U+f591
#define ICON_FA_HIKING "\xef\x9b\xac"	// U+f6ec
#define ICON_FA_HIPPO "\xef\x9b\xad"	// U+f6ed
#define ICON_FA_HISTORY "\xef\x87\x9a"	// U+f1da
#define ICON_FA_HOCKEY_PUCK "\xef\x91\x93"	// U+f453
#define ICON_FA_HOLLY_BERRY "\xef\x9e\xaa"	// U+f7aa
#define ICON_FA_HOME "\xef\x80\x95"	// U+f015
#define ICON_FA_HORSE "\xef\x9b\xb0"	// U+f6f0
#define ICON_FA_HORSE_HEAD "\xef\x9e\xab"	// U+f7ab
#define ICON_FA_HOSPITAL "\xef\x83\xb8"	// U+f0f8
#define ICON_FA_HOSPITAL_ALT "\xef\x91\xbd"	// U+f47d
#define ICON_FA_HOSPITAL_SYMBOL "\xef\x91\xbe"	// U+f47e
#define ICON_FA_HOSPITAL_USER "\xef\xa0\x8d"	// U+f80d
#define ICON_FA_HOT_TUB "\xef\x96\x93"	// U+f593
#define ICON_FA_HOTDOG "\xef\xa0\x8f"	// U+f80f
#define ICON_FA_HOTEL "\xef\x96\x94"	// U+f594
#define ICON_FA_HOURGLASS "\xef\x89\x94"	// U+f254
#define ICON_FA_HOURGLASS_END "\xef\x89\x93"	// U+f253
#define ICON_FA_HOURGLASS_HALF "\xef\x89\x92"	// U+f252
#define ICON_FA_HOURGLASS_START "\xef\x89\x91"	// U+f251
#define ICON_FA_HOUSE_DAMAGE "\xef\x9b\xb1"	// U+f6f1
#define ICON_FA_HOUSE_USER "\xee\x81\xa5"	// U+e065
#define ICON_FA_HRYVNIA "\xef\x9b\xb2"	// U+f6f2
#define ICON_FA_I_CURSOR "\xef\x89\x86"	// U+f246
#define ICON_FA_ICE_CREAM "\xef\xa0\x90"	// U+f810
#define ICON_FA_ICICLES "\xef\x9e\xad"	// U+f7ad
#define ICON_FA_ICONS "\xef\xa1\xad"	// U+f86d
#define ICON_FA_ID_BADGE "\xef\x8b\x81"	// U+f2c1
#define ICON_FA_ID_CARD "\xef\x8b\x82"	// U+f2c2
#define ICON_FA_ID_CARD_ALT "\xef\x91\xbf"	// U+f47f
#define ICON_FA_IGLOO "\xef\x9e\xae"	// U+f7ae
#define ICON_FA_IMAGE "\xef\x80\xbe"	// U+f03e
#define ICON_FA_IMAGES "\xef\x8c\x82"	// U+f302
#define ICON_FA_INBOX "\xef\x80\x9c"	// U+f01c
#define ICON_FA_INDENT "\xef\x80\xbc"	// U+f03c
#define ICON_FA_INDUSTRY "\xef\x89\xb5"	// U+f275
#define ICON_FA_INFINITY "\xef\x94\xb4"	// U+f534
#define ICON_FA_INFO "\xef\x84\xa9"	// U+f129
#define ICON_FA_INFO_CIRCLE "\xef\x81\x9a"	// U+f05a
#define ICON_FA_ITALIC "\xef\x80\xb3"	// U+f033
#define ICON_FA_JEDI "\xef\x99\xa9"	// U+f669
#define ICON_FA_JOINT "\xef\x96\x95"	// U+f595
#define ICON_FA_JOURNAL_WHILLS "\xef\x99\xaa"	// U+f66a
#define ICON_FA_KAABA "\xef\x99\xab"	// U+f66b
#define ICON_FA_KEY "\xef\x82\x84"	// U+f084
#define ICON_FA_KEYBOARD "\xef\x84\x9c"	// U+f11c
#define ICON_FA_KHANDA "\xef\x99\xad"	// U+f66d
#define ICON_FA_KISS "\xef\x96\x96"	// U+f596
#define ICON_FA_KISS_BEAM "\xef\x96\x97"	// U+f597
#define ICON_FA_KISS_WINK_HEART "\xef\x96\x98"	// U+f598
#define ICON_FA_KIWI_BIRD "\xef\x94\xb5"	// U+f535
#define ICON_FA_LANDMARK "\xef\x99\xaf"	// U+f66f
#define ICON_FA_LANGUAGE "\xef\x86\xab"	// U+f1ab
#define ICON_FA_LAPTOP "\xef\x84\x89"	// U+f109
#define ICON_FA_LAPTOP_CODE "\xef\x97\xbc"	// U+f5fc
#define ICON_FA_LAPTOP_HOUSE "\xee\x81\xa6"	// U+e066
#define ICON_FA_LAPTOP_MEDICAL "\xef\xa0\x92"	// U+f812
#define ICON_FA_LAUGH "\xef\x96\x99"	// U+f599
#define ICON_FA_LAUGH_BEAM "\xef\x96\x9a"	// U+f59a
#define ICON_FA_LAUGH_SQUINT "\xef\x96\x9b"	// U+f59b
#define ICON_FA_LAUGH_WINK "\xef\x96\x9c"	// U+f59c
#define ICON_FA_LAYER_GROUP "\xef\x97\xbd"	// U+f5fd
#define ICON_FA_LEAF "\xef\x81\xac"	// U+f06c
#define ICON_FA_LEMON "\xef\x82\x94"	// U+f094
#define ICON_FA_LESS_THAN "\xef\x94\xb6"	// U+f536
#define ICON_FA_LESS_THAN_EQUAL "\xef\x94\xb7"	// U+f537
#define ICON_FA_LEVEL_DOWN_ALT "\xef\x8e\xbe"	// U+f3be
#define ICON_FA_LEVEL_UP_ALT "\xef\x8e\xbf"	// U+f3bf
#define ICON_FA_LIFE_RING "\xef\x87\x8d"	// U+f1cd
#define ICON_FA_LIGHTBULB "\xef\x83\xab"	// U+f0eb
#define ICON_FA_LINK "\xef\x83\x81"	// U+f0c1
#define ICON_FA_LIRA_SIGN "\xef\x86\x95"	// U+f195
#define ICON_FA_LIST "\xef\x80\xba"	// U+f03a
#define ICON_FA_LIST_ALT "\xef\x80\xa2"	// U+f022
#define ICON_FA_LIST_OL "\xef\x83\x8b"	// U+f0cb
#define ICON_FA_LIST_UL "\xef\x83\x8a"	// U+f0ca
#define ICON_FA_LOCATION_ARROW "\xef\x84\xa4"	// U+f124
#define ICON_FA_LOCK "\xef\x80\xa3"	// U+f023
#define ICON_FA_LOCK_OPEN "\xef\x8f\x81"	// U+f3c1
#define ICON_FA_LONG_ARROW_ALT_DOWN "\xef\x8c\x89"	// U+f309
#define ICON_FA_LONG_ARROW_ALT_LEFT "\xef\x8c\x8a"	// U+f30a
#define ICON_FA_LONG_ARROW_ALT_RIGHT "\xef\x8c\x8b"	// U+f30b
#define ICON_FA_LONG_ARROW_ALT_UP "\xef\x8c\x8c"	// U+f30c
#define ICON_FA_LOW_VISION "\xef\x8a\xa8"	// U+f2a8
#define ICON_FA_LUGGAGE_CART "\xef\x96\x9d"	// U+f59d
#define ICON_FA_LUNGS "\xef\x98\x84"	// U+f604
#define ICON_FA_LUNGS_VIRUS "\xee\x81\xa7"	// U+e067
#define ICON_FA_MAGIC "\xef\x83\x90"	// U+f0d0
#define ICON_FA_MAGNET "\xef\x81\xb6"	// U+f076
#define ICON_FA_MAIL_BULK "\xef\x99\xb4"	// U+f674
#define ICON_FA_MALE "\xef\x86\x83"	// U+f183
#define ICON_FA_MAP "\xef\x89\xb9"	// U+f279
#define ICON_FA_MAP_MARKED "\xef\x96\x9f"	// U+f59f
#define ICON_FA_MAP_MARKED_ALT "\xef\x96\xa0"	// U+f5a0
#define ICON_FA_MAP_MARKER "\xef\x81\x81"	// U+f041
#define ICON_FA_MAP_MARKER_ALT "\xef\x8f\x85"	// U+f3c5
#define ICON_FA_MAP_PIN "\xef\x89\xb6"	// U+f276
#define ICON_FA_MAP_SIGNS "\xef\x89\xb7"	// U+f277
#define ICON_FA_MARKER "\xef\x96\xa1"	// U+f5a1
#define ICON_FA_MARS "\xef\x88\xa2"	// U+f222
#define ICON_FA_MARS_DOUBLE "\xef\x88\xa7"	// U+f227
#define ICON_FA_MARS_STROKE "\xef\x88\xa9"	// U+f229
#define ICON_FA_MARS_STROKE_H "\xef\x88\xab"	// U+f22b
#define ICON_FA_MARS_STROKE_V "\xef\x88\xaa"	// U+f22a
#define ICON_FA_MASK "\xef\x9b\xba"	// U+f6fa
#define ICON_FA_MEDAL "\xef\x96\xa2"	// U+f5a2
#define ICON_FA_MEDKIT "\xef\x83\xba"	// U+f0fa
#define ICON_FA_MEH "\xef\x84\x9a"	// U+f11a
#define ICON_FA_MEH_BLANK "\xef\x96\xa4"	// U+f5a4
#define ICON_FA_MEH_ROLLING_EYES "\xef\x96\xa5"	// U+f5a5
#define ICON_FA_MEMORY "\xef\x94\xb8"	// U+f538
#define ICON_FA_MENORAH "\xef\x99\xb6"	// U+f676
#define ICON_FA_MERCURY "\xef\x88\xa3"	// U+f223
#define ICON_FA_METEOR "\xef\x9d\x93"	// U+f753
#define ICON_FA_MICROCHIP "\xef\x8b\x9b"	// U+f2db
#define ICON_FA_MICROPHONE "\xef\x84\xb0"	// U+f130
#define ICON_FA_MICROPHONE_ALT "\xef\x8f\x89"	// U+f3c9
#define ICON_FA_MICROPHONE_ALT_SLASH "\xef\x94\xb9"	// U+f539
#define ICON_FA_MICROPHONE_SLASH "\xef\x84\xb1"	// U+f131
#define ICON_FA_MICROSCOPE "\xef\x98\x90"	// U+f610
#define ICON_FA_MINUS "\xef\x81\xa8"	// U+f068
#define ICON_FA_MINUS_CIRCLE "\xef\x81\x96"	// U+f056
#define ICON_FA_MINUS_SQUARE "\xef\x85\x86"	// U+f146
#define ICON_FA_MITTEN "\xef\x9e\xb5"	// U+f7b5
#define ICON_FA_MOBILE "\xef\x84\x8b"	// U+f10b
#define ICON_FA_MOBILE_ALT "\xef\x8f\x8d"	// U+f3cd
#define ICON_FA_MONEY_BILL "\xef\x83\x96"	// U+f0d6
#define ICON_FA_MONEY_BILL_ALT "\xef\x8f\x91"	// U+f3d1
#define ICON_FA_MONEY_BILL_WAVE "\xef\x94\xba"	// U+f53a
#define ICON_FA_MONEY_BILL_WAVE_ALT "\xef\x94\xbb"	// U+f53b
#define ICON_FA_MONEY_CHECK "\xef\x94\xbc"	// U+f53c
#define ICON_FA_MONEY_CHECK_ALT "\xef\x94\xbd"	// U+f53d
#define ICON_FA_MONUMENT "\xef\x96\xa6"	// U+f5a6
#define ICON_FA_MOON "\xef\x86\x86"	// U+f186
#define ICON_FA_MORTAR_PESTLE "\xef\x96\xa7"	// U+f5a7
#define ICON_FA_MOSQUE "\xef\x99\xb8"	// U+f678
#define ICON_FA_MOTORCYCLE "\xef\x88\x9c"	// U+f21c
#define ICON_FA_MOUNTAIN "\xef\x9b\xbc"	// U+f6fc
#define ICON_FA_MOUSE "\xef\xa3\x8c"	// U+f8cc
#define ICON_FA_MOUSE_POINTER "\xef\x89\x85"	// U+f245
#define ICON_FA_MUG_HOT "\xef\x9e\xb6"	// U+f7b6
#define ICON_FA_MUSIC "\xef\x80\x81"	// U+f001
#define ICON_FA_NETWORK_WIRED "\xef\x9b\xbf"	// U+f6ff
#define ICON_FA_NEUTER "\xef\x88\xac"	// U+f22c
#define ICON_FA_NEWSPAPER "\xef\x87\xaa"	// U+f1ea
#define ICON_FA_NOT_EQUAL "\xef\x94\xbe"	// U+f53e
#define ICON_FA_NOTES_MEDICAL "\xef\x92\x81"	// U+f481
#define ICON_FA_OBJECT_GROUP "\xef\x89\x87"	// U+f247
#define ICON_FA_OBJECT_UNGROUP "\xef\x89\x88"	// U+f248
#define ICON_FA_OIL_CAN "\xef\x98\x93"	// U+f613
#define ICON_FA_OM "\xef\x99\xb9"	// U+f679
#define ICON_FA_OTTER "\xef\x9c\x80"	// U+f700
#define ICON_FA_OUTDENT "\xef\x80\xbb"	// U+f03b
#define ICON_FA_PAGER "\xef\xa0\x95"	// U+f815
#define ICON_FA_PAINT_BRUSH "\xef\x87\xbc"	// U+f1fc
#define ICON_FA_PAINT_ROLLER "\xef\x96\xaa"	// U+f5aa
#define ICON_FA_PALETTE "\xef\x94\xbf"	// U+f53f
#define ICON_FA_PALLET "\xef\x92\x82"	// U+f482
#define ICON_FA_PAPER_PLANE "\xef\x87\x98"	// U+f1d8
#define ICON_FA_PAPERCLIP "\xef\x83\x86"	// U+f0c6
#define ICON_FA_PARACHUTE_BOX "\xef\x93\x8d"	// U+f4cd
#define ICON_FA_PARAGRAPH "\xef\x87\x9d"	// U+f1dd
#define ICON_FA_PARKING "\xef\x95\x80"	// U+f540
#define ICON_FA_PASSPORT "\xef\x96\xab"	// U+f5ab
#define ICON_FA_PASTAFARIANISM "\xef\x99\xbb"	// U+f67b
#define ICON_FA_PASTE "\xef\x83\xaa"	// U+f0ea
#define ICON_FA_PAUSE "\xef\x81\x8c"	// U+f04c
#define ICON_FA_PAUSE_CIRCLE "\xef\x8a\x8b"	// U+f28b
#define ICON_FA_PAW "\xef\x86\xb0"	// U+f1b0
#define ICON_FA_PEACE "\xef\x99\xbc"	// U+f67c
#define ICON_FA_PEN "\xef\x8c\x84"	// U+f304
#define ICON_FA_PEN_ALT "\xef\x8c\x85"	// U+f305
#define ICON_FA_PEN_FANCY "\xef\x96\xac"	// U+f5ac
#define ICON_FA_PEN_NIB "\xef\x96\xad"	// U+f5ad
#define ICON_FA_PEN_SQUARE "\xef\x85\x8b"	// U+f14b
#define ICON_FA_PENCIL_ALT "\xef\x8c\x83"	// U+f303
#define ICON_FA_PENCIL_RULER "\xef\x96\xae"	// U+f5ae
#define ICON_FA_PEOPLE_ARROWS "\xee\x81\xa8"	// U+e068
#define ICON_FA_PEOPLE_CARRY "\xef\x93\x8e"	// U+f4ce
#define ICON_FA_PEPPER_HOT "\xef\xa0\x96"	// U+f816
#define ICON_FA_PERCENT "\xef\x8a\x95"	// U+f295
#define ICON_FA_PERCENTAGE "\xef\x95\x81"	// U+f541
#define ICON_FA_PERSON_BOOTH "\xef\x9d\x96"	// U+f756
#define ICON_FA_PHONE "\xef\x82\x95"	// U+f095
#define ICON_FA_PHONE_ALT "\xef\xa1\xb9"	// U+f879
#define ICON_FA_PHONE_SLASH "\xef\x8f\x9d"	// U+f3dd
#define ICON_FA_PHONE_SQUARE "\xef\x82\x98"	// U+f098
#define ICON_FA_PHONE_SQUARE_ALT "\xef\xa1\xbb"	// U+f87b
#define ICON_FA_PHONE_VOLUME "\xef\x8a\xa0"	// U+f2a0
#define ICON_FA_PHOTO_VIDEO "\xef\xa1\xbc"	// U+f87c
#define ICON_FA_PIGGY_BANK "\xef\x93\x93"	// U+f4d3
#define ICON_FA_PILLS "\xef\x92\x84"	// U+f484
#define ICON_FA_PIZZA_SLICE "\xef\xa0\x98"	// U+f818
#define ICON_FA_PLACE_OF_WORSHIP "\xef\x99\xbf"	// U+f67f
#define ICON_FA_PLANE "\xef\x81\xb2"	// U+f072
#define ICON_FA_PLANE_ARRIVAL "\xef\x96\xaf"	// U+f5af
#define ICON_FA_PLANE_DEPARTURE "\xef\x96\xb0"	// U+f5b0
#define ICON_FA_PLANE_SLASH "\xee\x81\xa9"	// U+e069
#define ICON_FA_PLAY "\xef\x81\x8b"	// U+f04b
#define ICON_FA_PLAY_CIRCLE "\xef\x85\x84"	// U+f144
#define ICON_FA_PLUG "\xef\x87\xa6"	// U+f1e6
#define ICON_FA_PLUS "\xef\x81\xa7"	// U+f067
#define ICON_FA_PLUS_CIRCLE "\xef\x81\x95"	// U+f055
#define ICON_FA_PLUS_SQUARE "\xef\x83\xbe"	// U+f0fe
#define ICON_FA_PODCAST "\xef\x8b\x8e"	// U+f2ce
#define ICON_FA_POLL "\xef\x9a\x81"	// U+f681
#define ICON_FA_POLL_H "\xef\x9a\x82"	// U+f682
#define ICON_FA_POO "\xef\x8b\xbe"	// U+f2fe
#define ICON_FA_POO_STORM "\xef\x9d\x9a"	// U+f75a
#define ICON_FA_POOP "\xef\x98\x99"	// U+f619
#define ICON_FA_PORTRAIT "\xef\x8f\xa0"	// U+f3e0
#define ICON_FA_POUND_SIGN "\xef\x85\x94"	// U+f154
#define ICON_FA_POWER_OFF "\xef\x80\x91"	// U+f011
#define ICON_FA_PRAY "\xef\x9a\x83"	// U+f683
#define ICON_FA_PRAYING_HANDS "\xef\x9a\x84"	// U+f684
#define ICON_FA_PRESCRIPTION "\xef\x96\xb1"	// U+f5b1
#define ICON_FA_PRESCRIPTION_BOTTLE "\xef\x92\x85"	// U+f485
#define ICON_FA_PRESCRIPTION_BOTTLE_ALT "\xef\x92\x86"	// U+f486
#define ICON_FA_PRINT "\xef\x80\xaf"	// U+f02f
#define ICON_FA_PROCEDURES "\xef\x92\x87"	// U+f487
#define ICON_FA_PROJECT_DIAGRAM "\xef\x95\x82"	// U+f542
#define ICON_FA_PUMP_MEDICAL "\xee\x81\xaa"	// U+e06a
#define ICON_FA_PUMP_SOAP "\xee\x81\xab"	// U+e06b
#define ICON_FA_PUZZLE_PIECE "\xef\x84\xae"	// U+f12e
#define ICON_FA_QRCODE "\xef\x80\xa9"	// U+f029
#define ICON_FA_QUESTION "\xef\x84\xa8"	// U+f128
#define ICON_FA_QUESTION_CIRCLE "\xef\x81\x99"	// U+f059
#define ICON_FA_QUIDDITCH "\xef\x91\x98"	// U+f458
#define ICON_FA_QUOTE_LEFT "\xef\x84\x8d"	// U+f10d
#define ICON_FA_QUOTE_RIGHT "\xef\x84\x8e"	// U+f10e
#define ICON_FA_QURAN "\xef\x9a\x87"	// U+f687
#define ICON_FA_RADIATION "\xef\x9e\xb9"	// U+f7b9
#define ICON_FA_RADIATION_ALT "\xef\x9e\xba"	// U+f7ba
#define ICON_FA_RAINBOW "\xef\x9d\x9b"	// U+f75b
#define ICON_FA_RANDOM "\xef\x81\xb4"	// U+f074
#define ICON_FA_RECEIPT "\xef\x95\x83"	// U+f543
#define ICON_FA_RECORD_VINYL "\xef\xa3\x99"	// U+f8d9
#define ICON_FA_RECYCLE "\xef\x86\xb8"	// U+f1b8
#define ICON_FA_REDO "\xef\x80\x9e"	// U+f01e
#define ICON_FA_REDO_ALT "\xef\x8b\xb9"	// U+f2f9
#define ICON_FA_REGISTERED "\xef\x89\x9d"	// U+f25d
#define ICON_FA_REMOVE_FORMAT "\xef\xa1\xbd"	// U+f87d
#define ICON_FA_REPLY "\xef\x8f\xa5"	// U+f3e5
#define ICON_FA_REPLY_ALL "\xef\x84\xa2"	// U+f122
#define ICON_FA_REPUBLICAN "\xef\x9d\x9e"	// U+f75e
#define ICON_FA_RESTROOM "\xef\x9e\xbd"	// U+f7bd
#define ICON_FA_RETWEET "\xef\x81\xb9"	// U+f079
#define ICON_FA_RIBBON "\xef\x93\x96"	// U+f4d6
#define ICON_FA_RING "\xef\x9c\x8b"	// U+f70b
#define ICON_FA_ROAD "\xef\x80\x98"	// U+f018
#define ICON_FA_ROBOT "\xef\x95\x84"	// U+f544
#define ICON_FA_ROCKET "\xef\x84\xb5"	// U+f135
#define ICON_FA_ROUTE "\xef\x93\x97"	// U+f4d7
#define ICON_FA_RSS "\xef\x82\x9e"	// U+f09e
#define ICON_FA_RSS_SQUARE "\xef\x85\x83"	// U+f143
#define ICON_FA_RUBLE_SIGN "\xef\x85\x98"	// U+f158
#define ICON_FA_RULER "\xef\x95\x85"	// U+f545
#define ICON_FA_RULER_COMBINED "\xef\x95\x86"	// U+f546
#define ICON_FA_RULER_HORIZONTAL "\xef\x95\x87"	// U+f547
#define ICON_FA_RULER_VERTICAL "\xef\x95\x88"	// U+f548
#define ICON_FA_RUNNING "\xef\x9c\x8c"	// U+f70c
#define ICON_FA_RUPEE_SIGN "\xef\x85\x96"	// U+f156
#define ICON_FA_SAD_CRY "\xef\x96\xb3"	// U+f5b3
#define ICON_FA_SAD_TEAR "\xef\x96\xb4"	// U+f5b4
#define ICON_FA_SATELLITE "\xef\x9e\xbf"	// U+f7bf
#define ICON_FA_SATELLITE_DISH "\xef\x9f\x80"	// U+f7c0
#define ICON_FA_SAVE "\xef\x83\x87"	// U+f0c7
#define ICON_FA_SCHOOL "\xef\x95\x89"	// U+f549
#define ICON_FA_SCREWDRIVER "\xef\x95\x8a"	// U+f54a
#define ICON_FA_SCROLL "\xef\x9c\x8e"	// U+f70e
#define ICON_FA_SD_CARD "\xef\x9f\x82"	// U+f7c2
#define ICON_FA_SEARCH "\xef\x80\x82"	// U+f002
#define ICON_FA_SEARCH_DOLLAR "\xef\x9a\x88"	// U+f688
#define ICON_FA_SEARCH_LOCATION "\xef\x9a\x89"	// U+f689
#define ICON_FA_SEARCH_MINUS "\xef\x80\x90"	// U+f010
#define ICON_FA_SEARCH_PLUS "\xef\x80\x8e"	// U+f00e
#define ICON_FA_SEEDLING "\xef\x93\x98"	// U+f4d8
#define ICON_FA_SERVER "\xef\x88\xb3"	// U+f233
#define ICON_FA_SHAPES "\xef\x98\x9f"	// U+f61f
#define ICON_FA_SHARE "\xef\x81\xa4"	// U+f064
#define ICON_FA_SHARE_ALT "\xef\x87\xa0"	// U+f1e0
#define ICON_FA_SHARE_ALT_SQUARE "\xef\x87\xa1"	// U+f1e1
#define ICON_FA_SHARE_SQUARE "\xef\x85\x8d"	// U+f14d
#define ICON_FA_SHEKEL_SIGN "\xef\x88\x8b"	// U+f20b
#define ICON_FA_SHIELD_ALT "\xef\x8f\xad"	// U+f3ed
#define ICON_FA_SHIELD_VIRUS "\xee\x81\xac"	// U+e06c
#define ICON_FA_SHIP "\xef\x88\x9a"	// U+f21a
#define ICON_FA_SHIPPING_FAST "\xef\x92\x8b"	// U+f48b
#define ICON_FA_SHOE_PRINTS "\xef\x95\x8b"	// U+f54b
#define ICON_FA_SHOPPING_BAG "\xef\x8a\x90"	// U+f290
#define ICON_FA_SHOPPING_BASKET "\xef\x8a\x91"	// U+f291
#define ICON_FA_SHOPPING_CART "\xef\x81\xba"	// U+f07a
#define ICON_FA_SHOWER "\xef\x8b\x8c"	// U+f2cc
#define ICON_FA_SHUTTLE_VAN "\xef\x96\xb6"	// U+f5b6
#define ICON_FA_SIGN "\xef\x93\x99"	// U+f4d9
#define ICON_FA_SIGN_IN_ALT "\xef\x8b\xb6"	// U+f2f6
#define ICON_FA_SIGN_LANGUAGE "\xef\x8a\xa7"	// U+f2a7
#define ICON_FA_SIGN_OUT_ALT "\xef\x8b\xb5"	// U+f2f5
#define ICON_FA_SIGNAL "\xef\x80\x92"	// U+f012
#define ICON_FA_SIGNATURE "\xef\x96\xb7"	// U+f5b7
#define ICON_FA_SIM_CARD "\xef\x9f\x84"	// U+f7c4
#define ICON_FA_SINK "\xee\x81\xad"	// U+e06d
#define ICON_FA_SITEMAP "\xef\x83\xa8"	// U+f0e8
#define ICON_FA_SKATING "\xef\x9f\x85"	// U+f7c5
#define ICON_FA_SKIING "\xef\x9f\x89"	// U+f7c9
#define ICON_FA_SKIING_NORDIC "\xef\x9f\x8a"	// U+f7ca
#define ICON_FA_SKULL "\xef\x95\x8c"	// U+f54c
#define ICON_FA_SKULL_CROSSBONES "\xef\x9c\x94"	// U+f714
#define ICON_FA_SLASH "\xef\x9c\x95"	// U+f715
#define ICON_FA_SLEIGH "\xef\x9f\x8c"	// U+f7cc
#define ICON_FA_SLIDERS_H "\xef\x87\x9e"	// U+f1de
#define ICON_FA_SMILE "\xef\x84\x98"	// U+f118
#define ICON_FA_SMILE_BEAM "\xef\x96\xb8"	// U+f5b8
#define ICON_FA_SMILE_WINK "\xef\x93\x9a"	// U+f4da
#define ICON_FA_SMOG "\xef\x9d\x9f"	// U+f75f
#define ICON_FA_SMOKING "\xef\x92\x8d"	// U+f48d
#define ICON_FA_SMOKING_BAN "\xef\x95\x8d"	// U+f54d
#define ICON_FA_SMS "\xef\x9f\x8d"	// U+f7cd
#define ICON_FA_SNOWBOARDING "\xef\x9f\x8e"	// U+f7ce
#define ICON_FA_SNOWFLAKE "\xef\x8b\x9c"	// U+f2dc
#define ICON_FA_SNOWMAN "\xef\x9f\x90"	// U+f7d0
#define ICON_FA_SNOWPLOW "\xef\x9f\x92"	// U+f7d2
#define ICON_FA_SOAP "\xee\x81\xae"	// U+e06e
#define ICON_FA_SOCKS "\xef\x9a\x96"	// U+f696
#define ICON_FA_SOLAR_PANEL "\xef\x96\xba"	// U+f5ba
#define ICON_FA_SORT "\xef\x83\x9c"	// U+f0dc
#define ICON_FA_SORT_ALPHA_DOWN "\xef\x85\x9d"	// U+f15d
#define ICON_FA_SORT_ALPHA_DOWN_ALT "\xef\xa2\x81"	// U+f881
#define ICON_FA_SORT_ALPHA_UP "\xef\x85\x9e"	// U+f15e
#define ICON_FA_SORT_ALPHA_UP_ALT "\xef\xa2\x82"	// U+f882
#define ICON_FA_SORT_AMOUNT_DOWN "\xef\x85\xa0"	// U+f160
#define ICON_FA_SORT_AMOUNT_DOWN_ALT "\xef\xa2\x84"	// U+f884
#define ICON_FA_SORT_AMOUNT_UP "\xef\x85\xa1"	// U+f161
#define ICON_FA_SORT_AMOUNT_UP_ALT "\xef\xa2\x85"	// U+f885
#define ICON_FA_SORT_DOWN "\xef\x83\x9d"	// U+f0dd
#define ICON_FA_SORT_NUMERIC_DOWN "\xef\x85\xa2"	// U+f162
#define ICON_FA_SORT_NUMERIC_DOWN_ALT "\xef\xa2\x86"	// U+f886
#define ICON_FA_SORT_NUMERIC_UP "\xef\x85\xa3"	// U+f163
#define ICON_FA_SORT_NUMERIC_UP_ALT "\xef\xa2\x87"	// U+f887
#define ICON_FA_SORT_UP "\xef\x83\x9e"	// U+f0de
#define ICON_FA_SPA "\xef\x96\xbb"	// U+f5bb
#define ICON_FA_SPACE_SHUTTLE "\xef\x86\x97"	// U+f197
#define ICON_FA_SPELL_CHECK "\xef\xa2\x91"	// U+f891
#define ICON_FA_SPIDER "\xef\x9c\x97"	// U+f717
#define ICON_FA_SPINNER "\xef\x84\x90"	// U+f110
#define ICON_FA_SPLOTCH "\xef\x96\xbc"	// U+f5bc
#define ICON_FA_SPRAY_CAN "\xef\x96\xbd"	// U+f5bd
#define ICON_FA_SQUARE "\xef\x83\x88"	// U+f0c8
#define ICON_FA_SQUARE_FULL "\xef\x91\x9c"	// U+f45c
#define ICON_FA_SQUARE_ROOT_ALT "\xef\x9a\x98"	// U+f698
#define ICON_FA_STAMP "\xef\x96\xbf"	// U+f5bf
#define ICON_FA_STAR "\xef\x80\x85"	// U+f005
#define ICON_FA_STAR_AND_CRESCENT "\xef\x9a\x99"	// U+f699
#define ICON_FA_STAR_HALF "\xef\x82\x89"	// U+f089
#define ICON_FA_STAR_HALF_ALT "\xef\x97\x80"	// U+f5c0
#define ICON_FA_STAR_OF_DAVID "\xef\x9a\x9a"	// U+f69a
#define ICON_FA_STAR_OF_LIFE "\xef\x98\xa1"	// U+f621
#define ICON_FA_STEP_BACKWARD "\xef\x81\x88"	// U+f048
#define ICON_FA_STEP_FORWARD "\xef\x81\x91"	// U+f051
#define ICON_FA_STETHOSCOPE "\xef\x83\xb1"	// U+f0f1
#define ICON_FA_STICKY_NOTE "\xef\x89\x89"	// U+f249
#define ICON_FA_STOP "\xef\x81\x8d"	// U+f04d
#define ICON_FA_STOP_CIRCLE "\xef\x8a\x8d"	// U+f28d
#define ICON_FA_STOPWATCH "\xef\x8b\xb2"	// U+f2f2
#define ICON_FA_STOPWATCH_20 "\xee\x81\xaf"	// U+e06f
#define ICON_FA_STORE "\xef\x95\x8e"	// U+f54e
#define ICON_FA_STORE_ALT "\xef\x95\x8f"	// U+f54f
#define ICON_FA_STORE_ALT_SLASH "\xee\x81\xb0"	// U+e070
#define ICON_FA_STORE_SLASH "\xee\x81\xb1"	// U+e071
#define ICON_FA_STREAM "\xef\x95\x90"	// U+f550
#define ICON_FA_STREET_VIEW "\xef\x88\x9d"	// U+f21d
#define ICON_FA_STRIKETHROUGH "\xef\x83\x8c"	// U+f0cc
#define ICON_FA_STROOPWAFEL "\xef\x95\x91"	// U+f551
#define ICON_FA_SUBSCRIPT "\xef\x84\xac"	// U+f12c
#define ICON_FA_SUBWAY "\xef\x88\xb9"	// U+f239
#define ICON_FA_SUITCASE "\xef\x83\xb2"	// U+f0f2
#define ICON_FA_SUITCASE_ROLLING "\xef\x97\x81"	// U+f5c1
#define ICON_FA_SUN "\xef\x86\x85"	// U+f185
#define ICON_FA_SUPERSCRIPT "\xef\x84\xab"	// U+f12b
#define ICON_FA_SURPRISE "\xef\x97\x82"	// U+f5c2
#define ICON_FA_SWATCHBOOK "\xef\x97\x83"	// U+f5c3
#define ICON_FA_SWIMMER "\xef\x97\x84"	// U+f5c4
#define ICON_FA_SWIMMING_POOL "\xef\x97\x85"	// U+f5c5
#define ICON_FA_SYNAGOGUE "\xef\x9a\x9b"	// U+f69b
#define ICON_FA_SYNC "\xef\x80\xa1"	// U+f021
#define ICON_FA_SYNC_ALT "\xef\x8b\xb1"	// U+f2f1
#define ICON_FA_SYRINGE "\xef\x92\x8e"	// U+f48e
#define ICON_FA_TABLE "\xef\x83\x8e"	// U+f0ce
#define ICON_FA_TABLE_TENNIS "\xef\x91\x9d"	// U+f45d
#define ICON_FA_TABLET "\xef\x84\x8a"	// U+f10a
#define ICON_FA_TABLET_ALT "\xef\x8f\xba"	// U+f3fa
#define ICON_FA_TABLETS "\xef\x92\x90"	// U+f490
#define ICON_FA_TACHOMETER_ALT "\xef\x8f\xbd"	// U+f3fd
#define ICON_FA_TAG "\xef\x80\xab"	// U+f02b
#define ICON_FA_TAGS "\xef\x80\xac"	// U+f02c
#define ICON_FA_TAPE "\xef\x93\x9b"	// U+f4db
#define ICON_FA_TASKS "\xef\x82\xae"	// U+f0ae
#define ICON_FA_TAXI "\xef\x86\xba"	// U+f1ba
#define ICON_FA_TEETH "\xef\x98\xae"	// U+f62e
#define ICON_FA_TEETH_OPEN "\xef\x98\xaf"	// U+f62f
#define ICON_FA_TEMPERATURE_HIGH "\xef\x9d\xa9"	// U+f769
#define ICON_FA_TEMPERATURE_LOW "\xef\x9d\xab"	// U+f76b
#define ICON_FA_TENGE "\xef\x9f\x97"	// U+f7d7
#define ICON_FA_TERMINAL "\xef\x84\xa0"	// U+f120
#define ICON_FA_TEXT_HEIGHT "\xef\x80\xb4"	// U+f034
#define ICON_FA_TEXT_WIDTH "\xef\x80\xb5"	// U+f035
#define ICON_FA_TH "\xef\x80\x8a"	// U+f00a
#define ICON_FA_TH_LARGE "\xef\x80\x89"	// U+f009
#define ICON_FA_TH_LIST "\xef\x80\x8b"	// U+f00b
#define ICON_FA_THEATER_MASKS "\xef\x98\xb0"	// U+f630
#define ICON_FA_THERMOMETER "\xef\x92\x91"	// U+f491
#define ICON_FA_THERMOMETER_EMPTY "\xef\x8b\x8b"	// U+f2cb
#define ICON_FA_THERMOMETER_FULL "\xef\x8b\x87"	// U+f2c7
#define ICON_FA_THERMOMETER_HALF "\xef\x8b\x89"	// U+f2c9
#define ICON_FA_THERMOMETER_QUARTER "\xef\x8b\x8a"	// U+f2ca
#define ICON_FA_THERMOMETER_THREE_QUARTERS "\xef\x8b\x88"	// U+f2c8
#define ICON_FA_THUMBS_DOWN "\xef\x85\xa5"	// U+f165
#define ICON_FA_THUMBS_UP "\xef\x85\xa4"	// U+f164
#define ICON_FA_THUMBTACK "\xef\x82\x8d"	// U+f08d
#define ICON_FA_TICKET_ALT "\xef\x8f\xbf"	// U+f3ff
#define ICON_FA_TIMES "\xef\x80\x8d"	// U+f00d
#define ICON_FA_TIMES_CIRCLE "\xef\x81\x97"	// U+f057
#define ICON_FA_TINT "\xef\x81\x83"	// U+f043
#define ICON_FA_TINT_SLASH "\xef\x97\x87"	// U+f5c7
#define ICON_FA_TIRED "\xef\x97\x88"	// U+f5c8
#define ICON_FA_TOGGLE_OFF "\xef\x88\x84"	// U+f204
#define ICON_FA_TOGGLE_ON "\xef\x88\x85"	// U+f205
#define ICON_FA_TOILET "\xef\x9f\x98"	// U+f7d8
#define ICON_FA_TOILET_PAPER "\xef\x9c\x9e"	// U+f71e
#define ICON_FA_TOILET_PAPER_SLASH "\xee\x81\xb2"	// U+e072
#define ICON_FA_TOOLBOX "\xef\x95\x92"	// U+f552
#define ICON_FA_TOOLS "\xef\x9f\x99"	// U+f7d9
#define ICON_FA_TOOTH "\xef\x97\x89"	// U+f5c9
#define ICON_FA_TORAH "\xef\x9a\xa0"	// U+f6a0
#define ICON_FA_TORII_GATE "\xef\x9a\xa1"	// U+f6a1
#define ICON_FA_TRACTOR "\xef\x9c\xa2"	// U+f722
#define ICON_FA_TRADEMARK "\xef\x89\x9c"	// U+f25c
#define ICON_FA_TRAFFIC_LIGHT "\xef\x98\xb7"	// U+f637
#define ICON_FA_TRAILER "\xee\x81\x81"	// U+e041
#define ICON_FA_TRAIN "\xef\x88\xb8"	// U+f238
#define ICON_FA_TRAM "\xef\x9f\x9a"	// U+f7da
#define ICON_FA_TRANSGENDER "\xef\x88\xa4"	// U+f224
#define ICON_FA_TRANSGENDER_ALT "\xef\x88\xa5"	// U+f225
#define ICON_FA_TRASH "\xef\x87\xb8"	// U+f1f8
#define ICON_FA_TRASH_ALT "\xef\x8b\xad"	// U+f2ed
#define ICON_FA_TRASH_RESTORE "\xef\xa0\xa9"	// U+f829
#define ICON_FA_TRASH_RESTORE_ALT "\xef\xa0\xaa"	// U+f82a
#define ICON_FA_TREE "\xef\x86\xbb"	// U+f1bb
#define ICON_FA_TROPHY "\xef\x82\x91"	// U+f091
#define ICON_FA_TRUCK "\xef\x83\x91"	// U+f0d1
#define ICON_FA_TRUCK_LOADING "\xef\x93\x9e"	// U+f4de
#define ICON_FA_TRUCK_MONSTER "\xef\x98\xbb"	// U+f63b
#define ICON_FA_TRUCK_MOVING "\xef\x93\x9f"	// U+f4df
#define ICON_FA_TRUCK_PICKUP "\xef\x98\xbc"	// U+f63c
#define ICON_FA_TSHIRT "\xef\x95\x93"	// U+f553
#define ICON_FA_TTY "\xef\x87\xa4"	// U+f1e4
#define ICON_FA_TV "\xef\x89\xac"	// U+f26c
#define ICON_FA_UMBRELLA "\xef\x83\xa9"	// U+f0e9
#define ICON_FA_UMBRELLA_BEACH "\xef\x97\x8a"	// U+f5ca
#define ICON_FA_UNDERLINE "\xef\x83\x8d"	// U+f0cd
#define ICON_FA_UNDO "\xef\x83\xa2"	// U+f0e2
#define ICON_FA_UNDO_ALT "\xef\x8b\xaa"	// U+f2ea
#define ICON_FA_UNIVERSAL_ACCESS "\xef\x8a\x9a"	// U+f29a
#define ICON_FA_UNIVERSITY "\xef\x86\x9c"	// U+f19c
#define ICON_FA_UNLINK "\xef\x84\xa7"	// U+f127
#define ICON_FA_UNLOCK "\xef\x82\x9c"	// U+f09c
#define ICON_FA_UNLOCK_ALT "\xef\x84\xbe"	// U+f13e
#define ICON_FA_UPLOAD "\xef\x82\x93"	// U+f093
#define ICON_FA_USER "\xef\x80\x87"	// U+f007
#define ICON_FA_USER_ALT "\xef\x90\x86"	// U+f406
#define ICON_FA_USER_ALT_SLASH "\xef\x93\xba"	// U+f4fa
#define ICON_FA_USER_ASTRONAUT "\xef\x93\xbb"	// U+f4fb
#define ICON_FA_USER_CHECK "\xef\x93\xbc"	// U+f4fc
#define ICON_FA_USER_CIRCLE "\xef\x8a\xbd"	// U+f2bd
#define ICON_FA_USER_CLOCK "\xef\x93\xbd"	// U+f4fd
#define ICON_FA_USER_COG "\xef\x93\xbe"	// U+f4fe
#define ICON_FA_USER_EDIT "\xef\x93\xbf"	// U+f4ff
#define ICON_FA_USER_FRIENDS "\xef\x94\x80"	// U+f500
#define ICON_FA_USER_GRADUATE "\xef\x94\x81"	// U+f501
#define ICON_FA_USER_INJURED "\xef\x9c\xa8"	// U+f728
#define ICON_FA_USER_LOCK "\xef\x94\x82"	// U+f502
#define ICON_FA_USER_MD "\xef\x83\xb0"	// U+f0f0
#define ICON_FA_USER_MINUS "\xef\x94\x83"	// U+f503
#define ICON_FA_USER_NINJA "\xef\x94\x84"	// U+f504
#define ICON_FA_USER_NURSE "\xef\xa0\xaf"	// U+f82f
#define ICON_FA_USER_PLUS "\xef\x88\xb4"	// U+f234
#define ICON_FA_USER_SECRET "\xef\x88\x9b"	// U+f21b
#define ICON_FA_USER_SHIELD "\xef\x94\x85"	// U+f505
#define ICON_FA_USER_SLASH "\xef\x94\x86"	// U+f506
#define ICON_FA_USER_TAG "\xef\x94\x87"	// U+f507
#define ICON_FA_USER_TIE "\xef\x94\x88"	// U+f508
#define ICON_FA_USER_TIMES "\xef\x88\xb5"	// U+f235
#define ICON_FA_USERS "\xef\x83\x80"	// U+f0c0
#define ICON_FA_USERS_COG "\xef\x94\x89"	// U+f509
#define ICON_FA_USERS_SLASH "\xee\x81\xb3"	// U+e073
#define ICON_FA_UTENSIL_SPOON "\xef\x8b\xa5"	// U+f2e5
#define ICON_FA_UTENSILS "\xef\x8b\xa7"	// U+f2e7
#define ICON_FA_VECTOR_SQUARE "\xef\x97\x8b"	// U+f5cb
#define ICON_FA_VENUS "\xef\x88\xa1"	// U+f221
#define ICON_FA_VENUS_DOUBLE "\xef\x88\xa6"	// U+f226
#define ICON_FA_VENUS_MARS "\xef\x88\xa8"	// U+f228
#define ICON_FA_VEST "\xee\x82\x85"	// U+e085
#define ICON_FA_VEST_PATCHES "\xee\x82\x86"	// U+e086
#define ICON_FA_VIAL "\xef\x92\x92"	// U+f492
#define ICON_FA_VIALS "\xef\x92\x93"	// U+f493
#define ICON_FA_VIDEO "\xef\x80\xbd"	// U+f03d
#define ICON_FA_VIDEO_SLASH "\xef\x93\xa2"	// U+f4e2
#define ICON_FA_VIHARA "\xef\x9a\xa7"	// U+f6a7
#define ICON_FA_VIRUS "\xee\x81\xb4"	// U+e074
#define ICON_FA_VIRUS_SLASH "\xee\x81\xb5"	// U+e075
#define ICON_FA_VIRUSES "\xee\x81\xb6"	// U+e076
#define ICON_FA_VOICEMAIL "\xef\xa2\x97"	// U+f897
#define ICON_FA_VOLLEYBALL_BALL "\xef\x91\x9f"	// U+f45f
#define ICON_FA_VOLUME_DOWN "\xef\x80\xa7"	// U+f027
#define ICON_FA_VOLUME_MUTE "\xef\x9a\xa9"	// U+f6a9
#define ICON_FA_VOLUME_OFF "\xef\x80\xa6"	// U+f026
#define ICON_FA_VOLUME_UP "\xef\x80\xa8"	// U+f028
#define ICON_FA_VOTE_YEA "\xef\x9d\xb2"	// U+f772
#define ICON_FA_VR_CARDBOARD "\xef\x9c\xa9"	// U+f729
#define ICON_FA_WALKING "\xef\x95\x94"	// U+f554
#define ICON_FA_WALLET "\xef\x95\x95"	// U+f555
#define ICON_FA_WAREHOUSE "\xef\x92\x94"	// U+f494
#define ICON_FA_WATER "\xef\x9d\xb3"	// U+f773
#define ICON_FA_WAVE_SQUARE "\xef\xa0\xbe"	// U+f83e
#define ICON_FA_WEIGHT "\xef\x92\x96"	// U+f496
#define ICON_FA_WEIGHT_HANGING "\xef\x97\x8d"	// U+f5cd
#define ICON_FA_WHEELCHAIR "\xef\x86\x93"	// U+f193
#define ICON_FA_WIFI "\xef\x87\xab"	// U+f1eb
#define ICON_FA_WIND "\xef\x9c\xae"	// U+f72e
#define ICON_FA_WINDOW_CLOSE "\xef\x90\x90"	// U+f410
#define ICON_FA_WINDOW_MAXIMIZE "\xef\x8b\x90"	// U+f2d0
#define ICON_FA_WINDOW_MINIMIZE "\xef\x8b\x91"	// U+f2d1
#define ICON_FA_WINDOW_RESTORE "\xef\x8b\x92"	// U+f2d2
#define ICON_FA_WINE_BOTTLE "\xef\x9c\xaf"	// U+f72f
#define ICON_FA_WINE_GLASS "\xef\x93\xa3"	// U+f4e3
#define ICON_FA_WINE_GLASS_ALT "\xef\x97\x8e"	// U+f5ce
#define ICON_FA_WON_SIGN "\xef\x85\x99"	// U+f159
#define ICON_FA_WRENCH "\xef\x82\xad"	// U+f0ad
#define ICON_FA_X_RAY "\xef\x92\x97"	// U+f497
#define ICON_FA_YEN_SIGN "\xef\x85\x97"	// U+f157
#define ICON_FA_YIN_YANG "\xef\x9a\xad"	// U+f6ad


================================================
FILE: Source/External/imgui_tools/imgui_impl_glfw.cpp
================================================
// dear imgui: Platform Backend for GLFW
// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
// (Requires: GLFW 3.1+. Prefer GLFW 3.3+ for full feature support.)

// Implemented features:
//  [X] Platform: Clipboard support.
//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
//  [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.

// Issues:
//  [ ] Platform: Multi-viewport support: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).

// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs

// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
//  2022-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
//  2022-11-22: Perform a dummy glfwGetError() read to cancel missing names with glfwGetKeyName(). (#5908)
//  2022-10-18: Perform a dummy glfwGetError() read to cancel missing mouse cursors errors. Using GLFW_VERSION_COMBINED directly. (#5785)
//  2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
//  2022-09-26: Inputs: Renamed ImGuiKey_ModXXX introduced in 1.87 to ImGuiMod_XXX (old names still supported).
//  2022-09-01: Inputs: Honor GLFW_CURSOR_DISABLED by not setting mouse position.
//  2022-04-30: Inputs: Fixed ImGui_ImplGlfw_TranslateUntranslatedKey() for lower case letters on OSX.
//  2022-03-23: Inputs: Fixed a regression in 1.87 which resulted in keyboard modifiers events being reported incorrectly on Linux/X11.
//  2022-02-07: Added ImGui_ImplGlfw_InstallCallbacks()/ImGui_ImplGlfw_RestoreCallbacks() helpers to facilitate user installing callbacks after initializing backend.
//  2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago) with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
//  2021-01-20: Inputs: calling new io.AddKeyAnalogEvent() for gamepad support, instead of writing directly to io.NavInputs[].
//  2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
//  2022-01-17: Inputs: always update key mods next and before key event (not in NewFrame) to fix input queue with very low framerates.
//  2022-01-12: *BREAKING CHANGE*: Now using glfwSetCursorPosCallback(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetCursorPosCallback() and forward it to the backend via ImGui_ImplGlfw_CursorPosCallback().
//  2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
//  2022-01-05: Inputs: Converting GLFW untranslated keycodes back to translated keycodes (in the ImGui_ImplGlfw_KeyCallback() function) in order to match the behavior of every other backend, and facilitate the use of GLFW with lettered-shortcuts API.
//  2021-08-17: *BREAKING CHANGE*: Now using glfwSetWindowFocusCallback() to calling io.AddFocusEvent(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() and forward it to the backend via ImGui_ImplGlfw_WindowFocusCallback().
//  2021-07-29: *BREAKING CHANGE*: Now using glfwSetCursorEnterCallback(). MousePos is correctly reported when the host platform window is hovered but not focused. If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() callback and forward it to the backend via ImGui_ImplGlfw_CursorEnterCallback().
//  2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
//  2020-01-17: Inputs: Disable error callback while assigning mouse cursors because some X11 setup don't have them and it generates errors.
//  2019-12-05: Inputs: Added support for new mouse cursors added in GLFW 3.4+ (resizing cursors, not allowed cursor).
//  2019-10-18: Misc: Previously installed user callbacks are now restored on shutdown.
//  2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
//  2019-05-11: Inputs: Don't filter value from character callback before calling AddInputCharacter().
//  2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
//  2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
//  2018-11-07: Inputs: When installing our GLFW callbacks, we save user's previously installed ones - if any - and chain call them.
//  2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
//  2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
//  2018-06-08: Misc: Extracted imgui_impl_glfw.cpp/.h away from the old combined GLFW+OpenGL/Vulkan examples.
//  2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
//  2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value, passed to glfwSetCursor()).
//  2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
//  2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
//  2018-01-25: Inputs: Added gamepad support if ImGuiConfigFlags_NavEnableGamepad is set.
//  2018-01-25: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
//  2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
//  2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
//  2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
//  2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.

#include "imgui.h"
#include "imgui_impl_glfw.h"

// Clang warnings with -Weverything
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wold-style-cast"     // warning: use of old-style cast
#pragma clang diagnostic ignored "-Wsign-conversion"    // warning: implicit conversion changes signedness
#endif

// GLFW
#include <GLFW/glfw3.h>

#ifdef _WIN32
#undef APIENTRY
#define GLFW_EXPOSE_NATIVE_WIN32
#include <GLFW/glfw3native.h>   // for glfwGetWin32Window()
#endif
#ifdef __APPLE__
#define GLFW_EXPOSE_NATIVE_COCOA
#include <GLFW/glfw3native.h>   // for glfwGetCocoaWindow()
#endif

// We gather version tests as define in order to easily see which features are version-dependent.
#define GLFW_VERSION_COMBINED           (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 + GLFW_VERSION_REVISION)
#define GLFW_HAS_WINDOW_TOPMOST         (GLFW_VERSION_COMBINED >= 3200) // 3.2+ GLFW_FLOATING
#define GLFW_HAS_WINDOW_HOVERED         (GLFW_VERSION_COMBINED >= 3300) // 3.3+ GLFW_HOVERED
#define GLFW_HAS_WINDOW_ALPHA           (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwSetWindowOpacity
#define GLFW_HAS_PER_MONITOR_DPI        (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetMonitorContentScale
#define GLFW_HAS_VULKAN                 (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwCreateWindowSurface
#define GLFW_HAS_FOCUS_WINDOW           (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwFocusWindow
#define GLFW_HAS_FOCUS_ON_SHOW          (GLFW_VERSION_COMBINED >= 3300) // 3.3+ GLFW_FOCUS_ON_SHOW
#define GLFW_HAS_MONITOR_WORK_AREA      (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetMonitorWorkarea
#define GLFW_HAS_OSX_WINDOW_POS_FIX     (GLFW_VERSION_COMBINED >= 3301) // 3.3.1+ Fixed: Resizing window repositions it on MacOS #1553
#ifdef GLFW_RESIZE_NESW_CURSOR          // Let's be nice to people who pulled GLFW between 2019-04-16 (3.4 define) and 2019-11-29 (cursors defines) // FIXME: Remove when GLFW 3.4 is released?
#define GLFW_HAS_NEW_CURSORS            (GLFW_VERSION_COMBINED >= 3400) // 3.4+ GLFW_RESIZE_ALL_CURSOR, GLFW_RESIZE_NESW_CURSOR, GLFW_RESIZE_NWSE_CURSOR, GLFW_NOT_ALLOWED_CURSOR
#else
#define GLFW_HAS_NEW_CURSORS            (0)
#endif
#ifdef GLFW_MOUSE_PASSTHROUGH           // Let's be nice to people who pulled GLFW between 2019-04-16 (3.4 define) and 2020-07-17 (passthrough)
#define GLFW_HAS_MOUSE_PASSTHROUGH      (GLFW_VERSION_COMBINED >= 3400) // 3.4+ GLFW_MOUSE_PASSTHROUGH
#else
#define GLFW_HAS_MOUSE_PASSTHROUGH      (0)
#endif
#define GLFW_HAS_GAMEPAD_API            (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetGamepadState() new api
#define GLFW_HAS_GETKEYNAME             (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwGetKeyName()

// GLFW data
enum GlfwClientApi
{
    GlfwClientApi_Unknown,
    GlfwClientApi_OpenGL,
    GlfwClientApi_Vulkan
};

struct ImGui_ImplGlfw_Data
{
    GLFWwindow*             Window;
    GlfwClientApi           ClientApi;
    double                  Time;
    GLFWwindow*             MouseWindow;
    GLFWcursor*             MouseCursors[ImGuiMouseCursor_COUNT];
    ImVec2                  LastValidMousePos;
    GLFWwindow*             KeyOwnerWindows[GLFW_KEY_LAST];
    bool                    InstalledCallbacks;
    bool                    WantUpdateMonitors;
#ifdef _WIN32
    WNDPROC                 GlfwWndProc;
#endif

    // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
    GLFWwindowfocusfun      PrevUserCallbackWindowFocus;
    GLFWcursorposfun        PrevUserCallbackCursorPos;
    GLFWcursorenterfun      PrevUserCallbackCursorEnter;
    GLFWmousebuttonfun      PrevUserCallbackMousebutton;
    GLFWscrollfun           PrevUserCallbackScroll;
    GLFWkeyfun              PrevUserCallbackKey;
    GLFWcharfun             PrevUserCallbackChar;
    GLFWmonitorfun          PrevUserCallbackMonitor;

    ImGui_ImplGlfw_Data()   { memset((void*)this, 0, sizeof(*this)); }
};

// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
// - Because glfwPollEvents() process all windows and some events may be called outside of it, you will need to register your own callbacks
//   (passing install_callbacks=false in ImGui_ImplGlfw_InitXXX functions), set the current dear imgui context and then call our callbacks.
// - Otherwise we may need to store a GLFWWindow* -> ImGuiContext* map and handle this in the backend, adding a little bit of extra complexity to it.
// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
static ImGui_ImplGlfw_Data* ImGui_ImplGlfw_GetBackendData()
{
    return ImGui::GetCurrentContext() ? (ImGui_ImplGlfw_Data*)ImGui::GetIO().BackendPlatformUserData : nullptr;
}

// Forward Declarations
static void ImGui_ImplGlfw_UpdateMonitors();
static void ImGui_ImplGlfw_InitPlatformInterface();
static void ImGui_ImplGlfw_ShutdownPlatformInterface();

// Functions
static const char* ImGui_ImplGlfw_GetClipboardText(void* user_data)
{
    return glfwGetClipboardString((GLFWwindow*)user_data);
}

static void ImGui_ImplGlfw_SetClipboardText(void* user_data, const char* text)
{
    glfwSetClipboardString((GLFWwindow*)user_data, text);
}

static ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey(int key)
{
    switch (key)
    {
        case GLFW_KEY_TAB: return ImGuiKey_Tab;
        case GLFW_KEY_LEFT: return ImGuiKey_LeftArrow;
        case GLFW_KEY_RIGHT: return ImGuiKey_RightArrow;
        case GLFW_KEY_UP: return ImGuiKey_UpArrow;
        case GLFW_KEY_DOWN: return ImGuiKey_DownArrow;
        case GLFW_KEY_PAGE_UP: return ImGuiKey_PageUp;
        case GLFW_KEY_PAGE_DOWN: return ImGuiKey_PageDown;
        case GLFW_KEY_HOME: return ImGuiKey_Home;
        case GLFW_KEY_END: return ImGuiKey_End;
        case GLFW_KEY_INSERT: return ImGuiKey_Insert;
        case GLFW_KEY_DELETE: return ImGuiKey_Delete;
        case GLFW_KEY_BACKSPACE: return ImGuiKey_Backspace;
        case GLFW_KEY_SPACE: return ImGuiKey_Space;
        case GLFW_KEY_ENTER: return ImGuiKey_Enter;
        case GLFW_KEY_ESCAPE: return ImGuiKey_Escape;
        case GLFW_KEY_APOSTROPHE: return ImGuiKey_Apostrophe;
        case GLFW_KEY_COMMA: return ImGuiKey_Comma;
        case GLFW_KEY_MINUS: return ImGuiKey_Minus;
        case GLFW_KEY_PERIOD: return ImGuiKey_Period;
        case GLFW_KEY_SLASH: return ImGuiKey_Slash;
        case GLFW_KEY_SEMICOLON: return ImGuiKey_Semicolon;
        case GLFW_KEY_EQUAL: return ImGuiKey_Equal;
        case GLFW_KEY_LEFT_BRACKET: return ImGuiKey_LeftBracket;
        case GLFW_KEY_BACKSLASH: return ImGuiKey_Backslash;
        case GLFW_KEY_RIGHT_BRACKET: return ImGuiKey_RightBracket;
        case GLFW_KEY_GRAVE_ACCENT: return ImGuiKey_GraveAccent;
        case GLFW_KEY_CAPS_LOCK: return ImGuiKey_CapsLock;
        case GLFW_KEY_SCROLL_LOCK: return ImGuiKey_ScrollLock;
        case GLFW_KEY_NUM_LOCK: return ImGuiKey_NumLock;
        case GLFW_KEY_PRINT_SCREEN: return ImGuiKey_PrintScreen;
        case GLFW_KEY_PAUSE: return ImGuiKey_Pause;
        case GLFW_KEY_KP_0: return ImGuiKey_Keypad0;
        case GLFW_KEY_KP_1: return ImGuiKey_Keypad1;
        case GLFW_KEY_KP_2: return ImGuiKey_Keypad2;
        case GLFW_KEY_KP_3: return ImGuiKey_Keypad3;
        case GLFW_KEY_KP_4: return ImGuiKey_Keypad4;
        case GLFW_KEY_KP_5: return ImGuiKey_Keypad5;
        case GLFW_KEY_KP_6: return ImGuiKey_Keypad6;
        case GLFW_KEY_KP_7: return ImGuiKey_Keypad7;
        case GLFW_KEY_KP_8: return ImGuiKey_Keypad8;
        case GLFW_KEY_KP_9: return ImGuiKey_Keypad9;
        case GLFW_KEY_KP_DECIMAL: return ImGuiKey_KeypadDecimal;
        case GLFW_KEY_KP_DIVIDE: return ImGuiKey_KeypadDivide;
        case GLFW_KEY_KP_MULTIPLY: return ImGuiKey_KeypadMultiply;
        case GLFW_KEY_KP_SUBTRACT: return ImGuiKey_KeypadSubtract;
        case GLFW_KEY_KP_ADD: return ImGuiKey_KeypadAdd;
        case GLFW_KEY_KP_ENTER: return ImGuiKey_KeypadEnter;
        case GLFW_KEY_KP_EQUAL: return ImGuiKey_KeypadEqual;
        case GLFW_KEY_LEFT_SHIFT: return ImGuiKey_LeftShift;
        case GLFW_KEY_LEFT_CONTROL: return ImGuiKey_LeftCtrl;
        case GLFW_KEY_LEFT_ALT: return ImGuiKey_LeftAlt;
        case GLFW_KEY_LEFT_SUPER: return ImGuiKey_LeftSuper;
        case GLFW_KEY_RIGHT_SHIFT: return ImGuiKey_RightShift;
        case GLFW_KEY_RIGHT_CONTROL: return ImGuiKey_RightCtrl;
        case GLFW_KEY_RIGHT_ALT: return ImGuiKey_RightAlt;
        case GLFW_KEY_RIGHT_SUPER: return ImGuiKey_RightSuper;
        case GLFW_KEY_MENU: return ImGuiKey_Menu;
        case GLFW_KEY_0: return ImGuiKey_0;
        case GLFW_KEY_1: return ImGuiKey_1;
        case GLFW_KEY_2: return ImGuiKey_2;
        case GLFW_KEY_3: return ImGuiKey_3;
        case GLFW_KEY_4: return ImGuiKey_4;
        case GLFW_KEY_5: return ImGuiKey_5;
        case GLFW_KEY_6: return ImGuiKey_6;
        case GLFW_KEY_7: return ImGuiKey_7;
        case GLFW_KEY_8: return ImGuiKey_8;
        case GLFW_KEY_9: return ImGuiKey_9;
        case GLFW_KEY_A: return ImGuiKey_A;
        case GLFW_KEY_B: return ImGuiKey_B;
        case GLFW_KEY_C: return ImGuiKey_C;
        case GLFW_KEY_D: return ImGuiKey_D;
        case GLFW_KEY_E: return ImGuiKey_E;
        case GLFW_KEY_F: return ImGuiKey_F;
        case GLFW_KEY_G: return ImGuiKey_G;
        case GLFW_KEY_H: return ImGuiKey_H;
        case GLFW_KEY_I: return ImGuiKey_I;
        case GLFW_KEY_J: return ImGuiKey_J;
        case GLFW_KEY_K: return ImGuiKey_K;
        case GLFW_KEY_L: return ImGuiKey_L;
        case GLFW_KEY_M: return ImGuiKey_M;
        case GLFW_KEY_N: return ImGuiKey_N;
        case GLFW_KEY_O: return ImGuiKey_O;
        case GLFW_KEY_P: return ImGuiKey_P;
        case GLFW_KEY_Q: return ImGuiKey_Q;
        case GLFW_KEY_R: return ImGuiKey_R;
        case GLFW_KEY_S: return ImGuiKey_S;
        case GLFW_KEY_T: return ImGuiKey_T;
        case GLFW_KEY_U: return ImGuiKey_U;
        case GLFW_KEY_V: return ImGuiKey_V;
        case GLFW_KEY_W: return ImGuiKey_W;
        case GLFW_KEY_X: return ImGuiKey_X;
        case GLFW_KEY_Y: return ImGuiKey_Y;
        case GLFW_KEY_Z: return ImGuiKey_Z;
        case GLFW_KEY_F1: return ImGuiKey_F1;
        case GLFW_KEY_F2: return ImGuiKey_F2;
        case GLFW_KEY_F3: return ImGuiKey_F3;
        case GLFW_KEY_F4: return ImGuiKey_F4;
        case GLFW_KEY_F5: return ImGuiKey_F5;
        case GLFW_KEY_F6: return ImGuiKey_F6;
        case GLFW_KEY_F7: return ImGuiKey_F7;
        case GLFW_KEY_F8: return ImGuiKey_F8;
        case GLFW_KEY_F9: return ImGuiKey_F9;
        case GLFW_KEY_F10: return ImGuiKey_F10;
        case GLFW_KEY_F11: return ImGuiKey_F11;
        case GLFW_KEY_F12: return ImGuiKey_F12;
        default: return ImGuiKey_None;
    }
}

static int ImGui_ImplGlfw_KeyToModifier(int key)
{
    if (key == GLFW_KEY_LEFT_CONTROL || key == GLFW_KEY_RIGHT_CONTROL)
        return GLFW_MOD_CONTROL;
    if (key == GLFW_KEY_LEFT_SHIFT || key == GLFW_KEY_RIGHT_SHIFT)
        return GLFW_MOD_SHIFT;
    if (key == GLFW_KEY_LEFT_ALT || key == GLFW_KEY_RIGHT_ALT)
        return GLFW_MOD_ALT;
    if (key == GLFW_KEY_LEFT_SUPER || key == GLFW_KEY_RIGHT_SUPER)
        return GLFW_MOD_SUPER;
    return 0;
}

static void ImGui_ImplGlfw_UpdateKeyModifiers(int mods)
{
    ImGuiIO& io = ImGui::GetIO();
    io.AddKeyEvent(ImGuiMod_Ctrl, (mods & GLFW_MOD_CONTROL) != 0);
    io.AddKeyEvent(ImGuiMod_Shift, (mods & GLFW_MOD_SHIFT) != 0);
    io.AddKeyEvent(ImGuiMod_Alt, (mods & GLFW_MOD_ALT) != 0);
    io.AddKeyEvent(ImGuiMod_Super, (mods & GLFW_MOD_SUPER) != 0);
}

void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (bd->PrevUserCallbackMousebutton != nullptr && window == bd->Window)
        bd->PrevUserCallbackMousebutton(window, button, action, mods);

    ImGui_ImplGlfw_UpdateKeyModifiers(mods);

    ImGuiIO& io = ImGui::GetIO();
    if (button >= 0 && button < ImGuiMouseButton_COUNT)
        io.AddMouseButtonEvent(button, action == GLFW_PRESS);
}

void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (bd->PrevUserCallbackScroll != nullptr && window == bd->Window)
        bd->PrevUserCallbackScroll(window, xoffset, yoffset);

    ImGuiIO& io = ImGui::GetIO();
    io.AddMouseWheelEvent((float)xoffset, (float)yoffset);
}

static int ImGui_ImplGlfw_TranslateUntranslatedKey(int key, int scancode)
{
#if GLFW_HAS_GETKEYNAME && !defined(__EMSCRIPTEN__)
    // GLFW 3.1+ attempts to "untranslate" keys, which goes the opposite of what every other framework does, making using lettered shortcuts difficult.
    // (It had reasons to do so: namely GLFW is/was more likely to be used for WASD-type game controls rather than lettered shortcuts, but IHMO the 3.1 change could have been done differently)
    // See https://github.com/glfw/glfw/issues/1502 for details.
    // Adding a workaround to undo this (so our keys are translated->untranslated->translated, likely a lossy process).
    // This won't cover edge cases but this is at least going to cover common cases.
    if (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_EQUAL)
        return key;
    GLFWerrorfun prev_error_callback = glfwSetErrorCallback(nullptr);
    const char* key_name = glfwGetKeyName(key, scancode);
    glfwSetErrorCallback(prev_error_callback);
#if (GLFW_VERSION_COMBINED >= 3300) // Eat errors (see #5908)
    (void)glfwGetError(NULL);
#endif
    if (key_name && key_name[0] != 0 && key_name[1] == 0)
    {
        const char char_names[] = "`-=[]\\,;\'./";
        const int char_keys[] = { GLFW_KEY_GRAVE_ACCENT, GLFW_KEY_MINUS, GLFW_KEY_EQUAL, GLFW_KEY_LEFT_BRACKET, GLFW_KEY_RIGHT_BRACKET, GLFW_KEY_BACKSLASH, GLFW_KEY_COMMA, GLFW_KEY_SEMICOLON, GLFW_KEY_APOSTROPHE, GLFW_KEY_PERIOD, GLFW_KEY_SLASH, 0 };
        IM_ASSERT(IM_ARRAYSIZE(char_names) == IM_ARRAYSIZE(char_keys));
        if (key_name[0] >= '0' && key_name[0] <= '9')               { key = GLFW_KEY_0 + (key_name[0] - '0'); }
        else if (key_name[0] >= 'A' && key_name[0] <= 'Z')          { key = GLFW_KEY_A + (key_name[0] - 'A'); }
        else if (key_name[0] >= 'a' && key_name[0] <= 'z')          { key = GLFW_KEY_A + (key_name[0] - 'a'); }
        else if (const char* p = strchr(char_names, key_name[0]))   { key = char_keys[p - char_names]; }
    }
    // if (action == GLFW_PRESS) printf("key %d scancode %d name '%s'\n", key, scancode, key_name);
#else
    IM_UNUSED(scancode);
#endif
    return key;
}

void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int keycode, int scancode, int action, int mods)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (bd->PrevUserCallbackKey != nullptr && window == bd->Window)
        bd->PrevUserCallbackKey(window, keycode, scancode, action, mods);

    if (action != GLFW_PRESS && action != GLFW_RELEASE)
        return;

    // Workaround: X11 does not include current pressed/released modifier key in 'mods' flags. https://github.com/glfw/glfw/issues/1630
    if (int keycode_to_mod = ImGui_ImplGlfw_KeyToModifier(keycode))
        mods = (action == GLFW_PRESS) ? (mods | keycode_to_mod) : (mods & ~keycode_to_mod);
    ImGui_ImplGlfw_UpdateKeyModifiers(mods);

    if (keycode >= 0 && keycode < IM_ARRAYSIZE(bd->KeyOwnerWindows))
        bd->KeyOwnerWindows[keycode] = (action == GLFW_PRESS) ? window : nullptr;

    keycode = ImGui_ImplGlfw_TranslateUntranslatedKey(keycode, scancode);

    ImGuiIO& io = ImGui::GetIO();
    ImGuiKey imgui_key = ImGui_ImplGlfw_KeyToImGuiKey(keycode);
    io.AddKeyEvent(imgui_key, (action == GLFW_PRESS));
    io.SetKeyEventNativeData(imgui_key, keycode, scancode); // To support legacy indexing (<1.87 user code)
}

void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (bd->PrevUserCallbackWindowFocus != nullptr && window == bd->Window)
        bd->PrevUserCallbackWindowFocus(window, focused);

    ImGuiIO& io = ImGui::GetIO();
    io.AddFocusEvent(focused != 0);
}

void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (bd->PrevUserCallbackCursorPos != nullptr && window == bd->Window)
        bd->PrevUserCallbackCursorPos(window, x, y);
    if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
        return;

    ImGuiIO& io = ImGui::GetIO();
    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
    {
        int window_x, window_y;
        glfwGetWindowPos(window, &window_x, &window_y);
        x += window_x;
        y += window_y;
    }
    io.AddMousePosEvent((float)x, (float)y);
    bd->LastValidMousePos = ImVec2((float)x, (float)y);
}

// Workaround: X11 seems to send spurious Leave/Enter events which would make us lose our position,
// so we back it up and restore on Leave/Enter (see https://github.com/ocornut/imgui/issues/4984)
void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (bd->PrevUserCallbackCursorEnter != nullptr && window == bd->Window)
        bd->PrevUserCallbackCursorEnter(window, entered);
    if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
        return;

    ImGuiIO& io = ImGui::GetIO();
    if (entered)
    {
        bd->MouseWindow = window;
        io.AddMousePosEvent(bd->LastValidMousePos.x, bd->LastValidMousePos.y);
    }
    else if (!entered && bd->MouseWindow == window)
    {
        bd->LastValidMousePos = io.MousePos;
        bd->MouseWindow = nullptr;
        io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
    }
}

void ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (bd->PrevUserCallbackChar != nullptr && window == bd->Window)
        bd->PrevUserCallbackChar(window, c);

    ImGuiIO& io = ImGui::GetIO();
    io.AddInputCharacter(c);
}

void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor*, int)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    bd->WantUpdateMonitors = true;
}

void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    IM_ASSERT(bd->InstalledCallbacks == false && "Callbacks already installed!");
    IM_ASSERT(bd->Window == window);

    bd->PrevUserCallbackWindowFocus = glfwSetWindowFocusCallback(window, ImGui_ImplGlfw_WindowFocusCallback);
    bd->PrevUserCallbackCursorEnter = glfwSetCursorEnterCallback(window, ImGui_ImplGlfw_CursorEnterCallback);
    bd->PrevUserCallbackCursorPos = glfwSetCursorPosCallback(window, ImGui_ImplGlfw_CursorPosCallback);
    bd->PrevUserCallbackMousebutton = glfwSetMouseButtonCallback(window, ImGui_ImplGlfw_MouseButtonCallback);
    bd->PrevUserCallbackScroll = glfwSetScrollCallback(window, ImGui_ImplGlfw_ScrollCallback);
    bd->PrevUserCallbackKey = glfwSetKeyCallback(window, ImGui_ImplGlfw_KeyCallback);
    bd->PrevUserCallbackChar = glfwSetCharCallback(window, ImGui_ImplGlfw_CharCallback);
    bd->PrevUserCallbackMonitor = glfwSetMonitorCallback(ImGui_ImplGlfw_MonitorCallback);
    bd->InstalledCallbacks = true;
}

void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    IM_ASSERT(bd->InstalledCallbacks == true && "Callbacks not installed!");
    IM_ASSERT(bd->Window == window);

    glfwSetWindowFocusCallback(window, bd->PrevUserCallbackWindowFocus);
    glfwSetCursorEnterCallback(window, bd->PrevUserCallbackCursorEnter);
    glfwSetCursorPosCallback(window, bd->PrevUserCallbackCursorPos);
    glfwSetMouseButtonCallback(window, bd->PrevUserCallbackMousebutton);
    glfwSetScrollCallback(window, bd->PrevUserCallbackScroll);
    glfwSetKeyCallback(window, bd->PrevUserCallbackKey);
    glfwSetCharCallback(window, bd->PrevUserCallbackChar);
    glfwSetMonitorCallback(bd->PrevUserCallbackMonitor);
    bd->InstalledCallbacks = false;
    bd->PrevUserCallbackWindowFocus = nullptr;
    bd->PrevUserCallbackCursorEnter = nullptr;
    bd->PrevUserCallbackCursorPos = nullptr;
    bd->PrevUserCallbackMousebutton = nullptr;
    bd->PrevUserCallbackScroll = nullptr;
    bd->PrevUserCallbackKey = nullptr;
    bd->PrevUserCallbackChar = nullptr;
    bd->PrevUserCallbackMonitor = nullptr;
}

static bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks, GlfwClientApi client_api)
{
    ImGuiIO& io = ImGui::GetIO();
    IM_ASSERT(io.BackendPlatformUserData == nullptr && "Already initialized a platform backend!");
    //printf("GLFW_VERSION: %d.%d.%d (%d)", GLFW_VERSION_MAJOR, GLFW_VERSION_MINOR, GLFW_VERSION_REVISION, GLFW_VERSION_COMBINED);

    // Setup backend capabilities flags
    ImGui_ImplGlfw_Data* bd = IM_NEW(ImGui_ImplGlfw_Data)();
    io.BackendPlatformUserData = (void*)bd;
    io.BackendPlatformName = "imgui_impl_glfw";
    io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;         // We can honor GetMouseCursor() values (optional)
    io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;          // We can honor io.WantSetMousePos requests (optional, rarely used)
    io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports;    // We can create multi-viewports on the Platform side (optional)
#if GLFW_HAS_MOUSE_PASSTHROUGH || (GLFW_HAS_WINDOW_HOVERED && defined(_WIN32))
    io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport; // We can call io.AddMouseViewportEvent() with correct data (optional)
#endif

    bd->Window = window;
    bd->Time = 0.0;
    bd->WantUpdateMonitors = true;

    io.SetClipboardTextFn = ImGui_ImplGlfw_SetClipboardText;
    io.GetClipboardTextFn = ImGui_ImplGlfw_GetClipboardText;
    io.ClipboardUserData = bd->Window;

    // Create mouse cursors
    // (By design, on X11 cursors are user configurable and some cursors may be missing. When a cursor doesn't exist,
    // GLFW will emit an error which will often be printed by the app, so we temporarily disable error reporting.
    // Missing cursors will return nullptr and our _UpdateMouseCursor() function will use the Arrow cursor instead.)
    GLFWerrorfun prev_error_callback = glfwSetErrorCallback(nullptr);
    bd->MouseCursors[ImGuiMouseCursor_Arrow] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_TextInput] = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_ResizeNS] = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_ResizeEW] = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_Hand] = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
#if GLFW_HAS_NEW_CURSORS
    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_RESIZE_ALL_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_RESIZE_NESW_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_RESIZE_NWSE_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_NOT_ALLOWED_CURSOR);
#else
    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
#endif
    glfwSetErrorCallback(prev_error_callback);
#if (GLFW_VERSION_COMBINED >= 3300) // Eat errors (see #5785)
    (void)glfwGetError(NULL);
#endif

    // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
    if (install_callbacks)
        ImGui_ImplGlfw_InstallCallbacks(window);

    // Update monitors the first time (note: monitor callback are broken in GLFW 3.2 and earlier, see github.com/glfw/glfw/issues/784)
    ImGui_ImplGlfw_UpdateMonitors();
    glfwSetMonitorCallback(ImGui_ImplGlfw_MonitorCallback);

    // Our mouse update function expect PlatformHandle to be filled for the main viewport
    ImGuiViewport* main_viewport = ImGui::GetMainViewport();
    main_viewport->PlatformHandle = (void*)bd->Window;
#ifdef _WIN32
    main_viewport->PlatformHandleRaw = glfwGetWin32Window(bd->Window);
#elif defined(__APPLE__)
    main_viewport->PlatformHandleRaw = (void*)glfwGetCocoaWindow(bd->Window);
#endif
    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
        ImGui_ImplGlfw_InitPlatformInterface();

    bd->ClientApi = client_api;
    return true;
}

bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks)
{
    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_OpenGL);
}

bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks)
{
    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Vulkan);
}

bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks)
{
    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Unknown);
}

void ImGui_ImplGlfw_Shutdown()
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
    ImGuiIO& io = ImGui::GetIO();

    ImGui_ImplGlfw_ShutdownPlatformInterface();

    if (bd->InstalledCallbacks)
        ImGui_ImplGlfw_RestoreCallbacks(bd->Window);

    for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
        glfwDestroyCursor(bd->MouseCursors[cursor_n]);

    io.BackendPlatformName = nullptr;
    io.BackendPlatformUserData = nullptr;
    IM_DELETE(bd);
}

static void ImGui_ImplGlfw_UpdateMouseData()
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    ImGuiIO& io = ImGui::GetIO();
    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();

    if (glfwGetInputMode(bd->Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
    {
        io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
        return;
    }

    ImGuiID mouse_viewport_id = 0;
    const ImVec2 mouse_pos_prev = io.MousePos;
    for (int n = 0; n < platform_io.Viewports.Size; n++)
    {
        ImGuiViewport* viewport = platform_io.Viewports[n];
        GLFWwindow* window = (GLFWwindow*)viewport->PlatformHandle;

#ifdef __EMSCRIPTEN__
        const bool is_window_focused = true;
#else
        const bool is_window_focused = glfwGetWindowAttrib(window, GLFW_FOCUSED) != 0;
#endif
        if (is_window_focused)
        {
            // (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
            // When multi-viewports are enabled, all Dear ImGui positions are same as OS positions.
            if (io.WantSetMousePos)
                glfwSetCursorPos(window, (double)(mouse_pos_prev.x - viewport->Pos.x), (double)(mouse_pos_prev.y - viewport->Pos.y));

            // (Optional) Fallback to provide mouse position when focused (ImGui_ImplGlfw_CursorPosCallback already provides this when hovered or captured)
            if (bd->MouseWindow == nullptr)
            {
                double mouse_x, mouse_y;
                glfwGetCursorPos(window, &mouse_x, &mouse_y);
                if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
                {
                    // Single viewport mode: mouse position in client window coordinates (io.MousePos is (0,0) when the mouse is on the upper-left corner of the app window)
                    // Multi-viewport mode: mouse position in OS absolute coordinates (io.MousePos is (0,0) when the mouse is on the upper-left of the primary monitor)
                    int window_x, window_y;
                    glfwGetWindowPos(window, &window_x, &window_y);
                    mouse_x += window_x;
                    mouse_y += window_y;
                }
                bd->LastValidMousePos = ImVec2((float)mouse_x, (float)mouse_y);
                io.AddMousePosEvent((float)mouse_x, (float)mouse_y);
            }
        }

        // (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
        // If ImGuiBackendFlags_HasMouseHoveredViewport is not set by the backend, Dear imGui will ignore this field and infer the information using its flawed heuristic.
        // - [X] GLFW >= 3.3 backend ON WINDOWS ONLY does correctly ignore viewports with the _NoInputs flag.
        // - [!] GLFW <= 3.2 backend CANNOT correctly ignore viewports with the _NoInputs flag, and CANNOT reported Hovered Viewport because of mouse capture.
        //       Some backend are not able to handle that correctly. If a backend report an hovered viewport that has the _NoInputs flag (e.g. when dragging a window
        //       for docking, the viewport has the _NoInputs flag in order to allow us to find the viewport under), then Dear ImGui is forced to ignore the value reported
        //       by the backend, and use its flawed heuristic to guess the viewport behind.
        // - [X] GLFW backend correctly reports this regardless of another viewport behind focused and dragged from (we need this to find a useful drag and drop target).
        // FIXME: This is currently only correct on Win32. See what we do below with the WM_NCHITTEST, missing an equivalent for other systems.
        // See https://github.com/glfw/glfw/issues/1236 if you want to help in making this a GLFW feature.
#if GLFW_HAS_MOUSE_PASSTHROUGH || (GLFW_HAS_WINDOW_HOVERED && defined(_WIN32))
        const bool window_no_input = (viewport->Flags & ImGuiViewportFlags_NoInputs) != 0;
#if GLFW_HAS_MOUSE_PASSTHROUGH
        glfwSetWindowAttrib(window, GLFW_MOUSE_PASSTHROUGH, window_no_input);
#endif
        if (glfwGetWindowAttrib(window, GLFW_HOVERED) && !window_no_input)
            mouse_viewport_id = viewport->ID;
#else
        // We cannot use bd->MouseWindow maintained from CursorEnter/Leave callbacks, because it is locked to the window capturing mouse.
#endif
    }

    if (io.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport)
        io.AddMouseViewportEvent(mouse_viewport_id);
}

static void ImGui_ImplGlfw_UpdateMouseCursor()
{
    ImGuiIO& io = ImGui::GetIO();
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(bd->Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
        return;

    ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
    for (int n = 0; n < platform_io.Viewports.Size; n++)
    {
        GLFWwindow* window = (GLFWwindow*)platform_io.Viewports[n]->PlatformHandle;
        if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
        {
            // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
            glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
        }
        else
        {
            // Show OS mouse cursor
            // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
            glfwSetCursor(window, bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow]);
            glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
        }
    }
}

// Update gamepad inputs
static inline float Saturate(float v) { return v < 0.0f ? 0.0f : v  > 1.0f ? 1.0f : v; }
static void ImGui_ImplGlfw_UpdateGamepads()
{
    ImGuiIO& io = ImGui::GetIO();
    if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0) // FIXME: Technically feeding gamepad shouldn't depend on this now that they are regular inputs.
        return;

    io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
#if GLFW_HAS_GAMEPAD_API
    GLFWgamepadstate gamepad;
    if (!glfwGetGamepadState(GLFW_JOYSTICK_1, &gamepad))
        return;
    #define MAP_BUTTON(KEY_NO, BUTTON_NO, _UNUSED)          do { io.AddKeyEvent(KEY_NO, gamepad.buttons[BUTTON_NO] != 0); } while (0)
    #define MAP_ANALOG(KEY_NO, AXIS_NO, _UNUSED, V0, V1)    do { float v = gamepad.axes[AXIS_NO]; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
#else
    int axes_count = 0, buttons_count = 0;
    const float* axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1, &axes_count);
    const unsigned char* buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1, &buttons_count);
    if (axes_count == 0 || buttons_count == 0)
        return;
    #define MAP_BUTTON(KEY_NO, _UNUSED, BUTTON_NO)          do { io.AddKeyEvent(KEY_NO, (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS)); } while (0)
    #define MAP_ANALOG(KEY_NO, _UNUSED, AXIS_NO, V0, V1)    do { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
#endif
    io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
    MAP_BUTTON(ImGuiKey_GamepadStart,       GLFW_GAMEPAD_BUTTON_START,          7);
    MAP_BUTTON(ImGuiKey_GamepadBack,        GLFW_GAMEPAD_BUTTON_BACK,           6);
    MAP_BUTTON(ImGuiKey_GamepadFaceLeft,    GLFW_GAMEPAD_BUTTON_X,              2);     // Xbox X, PS Square
    MAP_BUTTON(ImGuiKey_GamepadFaceRight,   GLFW_GAMEPAD_BUTTON_B,              1);     // Xbox B, PS Circle
    MAP_BUTTON(ImGuiKey_GamepadFaceUp,      GLFW_GAMEPAD_BUTTON_Y,              3);     // Xbox Y, PS Triangle
    MAP_BUTTON(ImGuiKey_GamepadFaceDown,    GLFW_GAMEPAD_BUTTON_A,              0);     // Xbox A, PS Cross
    MAP_BUTTON(ImGuiKey_GamepadDpadLeft,    GLFW_GAMEPAD_BUTTON_DPAD_LEFT,      13);
    MAP_BUTTON(ImGuiKey_GamepadDpadRight,   GLFW_GAMEPAD_BUTTON_DPAD_RIGHT,     11);
    MAP_BUTTON(ImGuiKey_GamepadDpadUp,      GLFW_GAMEPAD_BUTTON_DPAD_UP,        10);
    MAP_BUTTON(ImGuiKey_GamepadDpadDown,    GLFW_GAMEPAD_BUTTON_DPAD_DOWN,      12);
    MAP_BUTTON(ImGuiKey_GamepadL1,          GLFW_GAMEPAD_BUTTON_LEFT_BUMPER,    4);
    MAP_BUTTON(ImGuiKey_GamepadR1,          GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER,   5);
    MAP_ANALOG(ImGuiKey_GamepadL2,          GLFW_GAMEPAD_AXIS_LEFT_TRIGGER,     4,      -0.75f,  +1.0f);
    MAP_ANALOG(ImGuiKey_GamepadR2,          GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER,    5,      -0.75f,  +1.0f);
    MAP_BUTTON(ImGuiKey_GamepadL3,          GLFW_GAMEPAD_BUTTON_LEFT_THUMB,     8);
    MAP_BUTTON(ImGuiKey_GamepadR3,          GLFW_GAMEPAD_BUTTON_RIGHT_THUMB,    9);
    MAP_ANALOG(ImGuiKey_GamepadLStickLeft,  GLFW_GAMEPAD_AXIS_LEFT_X,           0,      -0.25f,  -1.0f);
    MAP_ANALOG(ImGuiKey_GamepadLStickRight, GLFW_GAMEPAD_AXIS_LEFT_X,           0,      +0.25f,  +1.0f);
    MAP_ANALOG(ImGuiKey_GamepadLStickUp,    GLFW_GAMEPAD_AXIS_LEFT_Y,           1,      -0.25f,  -1.0f);
    MAP_ANALOG(ImGuiKey_GamepadLStickDown,  GLFW_GAMEPAD_AXIS_LEFT_Y,           1,      +0.25f,  +1.0f);
    MAP_ANALOG(ImGuiKey_GamepadRStickLeft,  GLFW_GAMEPAD_AXIS_RIGHT_X,          2,      -0.25f,  -1.0f);
    MAP_ANALOG(ImGuiKey_GamepadRStickRight, GLFW_GAMEPAD_AXIS_RIGHT_X,          2,      +0.25f,  +1.0f);
    MAP_ANALOG(ImGuiKey_GamepadRStickUp,    GLFW_GAMEPAD_AXIS_RIGHT_Y,          3,      -0.25f,  -1.0f);
    MAP_ANALOG(ImGuiKey_GamepadRStickDown,  GLFW_GAMEPAD_AXIS_RIGHT_Y,          3,      +0.25f,  +1.0f);
    #undef MAP_BUTTON
    #undef MAP_ANALOG
}

static void ImGui_ImplGlfw_UpdateMonitors()
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
    int monitors_count = 0;
    GLFWmonitor** glfw_monitors = glfwGetMonitors(&monitors_count);
    platform_io.Monitors.resize(0);
    for (int n = 0; n < monitors_count; n++)
    {
        ImGuiPlatformMonitor monitor;
        int x, y;
        glfwGetMonitorPos(glfw_monitors[n], &x, &y);
        const GLFWvidmode* vid_mode = glfwGetVideoMode(glfw_monitors[n]);
        monitor.MainPos = monitor.WorkPos = ImVec2((float)x, (float)y);
        monitor.MainSize = monitor.WorkSize = ImVec2((float)vid_mode->width, (float)vid_mode->height);
#if GLFW_HAS_MONITOR_WORK_AREA
        int w, h;
        glfwGetMonitorWorkarea(glfw_monitors[n], &x, &y, &w, &h);
        if (w > 0 && h > 0) // Workaround a small GLFW issue reporting zero on monitor changes: https://github.com/glfw/glfw/pull/1761
        {
            monitor.WorkPos = ImVec2((float)x, (float)y);
            monitor.WorkSize = ImVec2((float)w, (float)h);
        }
#endif
#if GLFW_HAS_PER_MONITOR_DPI
        // Warning: the validity of monitor DPI information on Windows depends on the application DPI awareness settings, which generally needs to be set in the manifest or at runtime.
        float x_scale, y_scale;
        glfwGetMonitorContentScale(glfw_monitors[n], &x_scale, &y_scale);
        monitor.DpiScale = x_scale;
#endif
        platform_io.Monitors.push_back(monitor);
    }
    bd->WantUpdateMonitors = false;
}

void ImGui_ImplGlfw_NewFrame()
{
    ImGuiIO& io = ImGui::GetIO();
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    IM_ASSERT(bd != nullptr && "Did you call ImGui_ImplGlfw_InitForXXX()?");

    // Setup display size (every frame to accommodate for window resizing)
    int w, h;
    int display_w, display_h;
    glfwGetWindowSize(bd->Window, &w, &h);
    glfwGetFramebufferSize(bd->Window, &display_w, &display_h);
    io.DisplaySize = ImVec2((float)w, (float)h);
    if (w > 0 && h > 0)
        io.DisplayFramebufferScale = ImVec2((float)display_w / (float)w, (float)display_h / (float)h);
    if (bd->WantUpdateMonitors)
        ImGui_ImplGlfw_UpdateMonitors();

    // Setup time step
    double current_time = glfwGetTime();
    io.DeltaTime = bd->Time > 0.0 ? (float)(current_time - bd->Time) : (float)(1.0f / 60.0f);
    bd->Time = current_time;

    ImGui_ImplGlfw_UpdateMouseData();
    ImGui_ImplGlfw_UpdateMouseCursor();

    // Update game controllers (if enabled and available)
    ImGui_ImplGlfw_UpdateGamepads();
}

//--------------------------------------------------------------------------------------------------------
// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
// If you are new to dear imgui or creating a new binding for dear imgui, it is recommended that you completely ignore this section first..
//--------------------------------------------------------------------------------------------------------

// Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data.
struct ImGui_ImplGlfw_ViewportData
{
    GLFWwindow* Window;
    bool        WindowOwned;
    int         IgnoreWindowPosEventFrame;
    int         IgnoreWindowSizeEventFrame;

    ImGui_ImplGlfw_ViewportData()  { Window = nullptr; WindowOwned = false; IgnoreWindowSizeEventFrame = IgnoreWindowPosEventFrame = -1; }
    ~ImGui_ImplGlfw_ViewportData() { IM_ASSERT(Window == nullptr); }
};

static void ImGui_ImplGlfw_WindowCloseCallback(GLFWwindow* window)
{
    if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
        viewport->PlatformRequestClose = true;
}

// GLFW may dispatch window pos/size events after calling glfwSetWindowPos()/glfwSetWindowSize().
// However: depending on the platform the callback may be invoked at different time:
// - on Windows it appears to be called within the glfwSetWindowPos()/glfwSetWindowSize() call
// - on Linux it is queued and invoked during glfwPollEvents()
// Because the event doesn't always fire on glfwSetWindowXXX() we use a frame counter tag to only
// ignore recent glfwSetWindowXXX() calls.
static void ImGui_ImplGlfw_WindowPosCallback(GLFWwindow* window, int, int)
{
    if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
    {
        if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
        {
            bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowPosEventFrame + 1);
            //data->IgnoreWindowPosEventFrame = -1;
            if (ignore_event)
                return;
        }
        viewport->PlatformRequestMove = true;
    }
}

static void ImGui_ImplGlfw_WindowSizeCallback(GLFWwindow* window, int, int)
{
    if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
    {
        if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
        {
            bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowSizeEventFrame + 1);
            //data->IgnoreWindowSizeEventFrame = -1;
            if (ignore_event)
                return;
        }
        viewport->PlatformRequestResize = true;
    }
}

static void ImGui_ImplGlfw_CreateWindow(ImGuiViewport* viewport)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)();
    viewport->PlatformUserData = vd;

    // GLFW 3.2 unfortunately always set focus on glfwCreateWindow() if GLFW_VISIBLE is set, regardless of GLFW_FOCUSED
    // With GLFW 3.3, the hint GLFW_FOCUS_ON_SHOW fixes this problem
    glfwWindowHint(GLFW_VISIBLE, false);
    glfwWindowHint(GLFW_FOCUSED, false);
#if GLFW_HAS_FOCUS_ON_SHOW
    glfwWindowHint(GLFW_FOCUS_ON_SHOW, false);
 #endif
    glfwWindowHint(GLFW_DECORATED, (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? false : true);
#if GLFW_HAS_WINDOW_TOPMOST
    glfwWindowHint(GLFW_FLOATING, (viewport->Flags & ImGuiViewportFlags_TopMost) ? true : false);
#endif
    GLFWwindow* share_window = (bd->ClientApi == GlfwClientApi_OpenGL) ? bd->Window : nullptr;
    vd->Window = glfwCreateWindow((int)viewport->Size.x, (int)viewport->Size.y, "No Title Yet", nullptr, share_window);
    vd->WindowOwned = true;
    viewport->PlatformHandle = (void*)vd->Window;
#ifdef _WIN32
    viewport->PlatformHandleRaw = glfwGetWin32Window(vd->Window);
#elif defined(__APPLE__)
    viewport->PlatformHandleRaw = (void*)glfwGetCocoaWindow(vd->Window);
#endif
    glfwSetWindowPos(vd->Window, (int)viewport->Pos.x, (int)viewport->Pos.y);

    // Install GLFW callbacks for secondary viewports
    glfwSetWindowFocusCallback(vd->Window, ImGui_ImplGlfw_WindowFocusCallback);
    glfwSetCursorEnterCallback(vd->Window, ImGui_ImplGlfw_CursorEnterCallback);
    glfwSetCursorPosCallback(vd->Window, ImGui_ImplGlfw_CursorPosCallback);
    glfwSetMouseButtonCallback(vd->Window, ImGui_ImplGlfw_MouseButtonCallback);
    glfwSetScrollCallback(vd->Window, ImGui_ImplGlfw_ScrollCallback);
    glfwSetKeyCallback(vd->Window, ImGui_ImplGlfw_KeyCallback);
    glfwSetCharCallback(vd->Window, ImGui_ImplGlfw_CharCallback);
    glfwSetWindowCloseCallback(vd->Window, ImGui_ImplGlfw_WindowCloseCallback);
    glfwSetWindowPosCallback(vd->Window, ImGui_ImplGlfw_WindowPosCallback);
    glfwSetWindowSizeCallback(vd->Window, ImGui_ImplGlfw_WindowSizeCallback);
    if (bd->ClientApi == GlfwClientApi_OpenGL)
    {
        glfwMakeContextCurrent(vd->Window);
        glfwSwapInterval(0);
    }
}

static void ImGui_ImplGlfw_DestroyWindow(ImGuiViewport* viewport)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
    {
        if (vd->WindowOwned)
        {
#if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
            HWND hwnd = (HWND)viewport->PlatformHandleRaw;
            ::RemovePropA(hwnd, "IMGUI_VIEWPORT");
#endif

            // Release any keys that were pressed in the window being destroyed and are still held down,
            // because we will not receive any release events after window is destroyed.
            for (int i = 0; i < IM_ARRAYSIZE(bd->KeyOwnerWindows); i++)
                if (bd->KeyOwnerWindows[i] == vd->Window)
                    ImGui_ImplGlfw_KeyCallback(vd->Window, i, 0, GLFW_RELEASE, 0); // Later params are only used for main viewport, on which this function is never called.

            glfwDestroyWindow(vd->Window);
        }
        vd->Window = nullptr;
        IM_DELETE(vd);
    }
    viewport->PlatformUserData = viewport->PlatformHandle = nullptr;
}

// We have submitted https://github.com/glfw/glfw/pull/1568 to allow GLFW to support "transparent inputs".
// In the meanwhile we implement custom per-platform workarounds here (FIXME-VIEWPORT: Implement same work-around for Linux/OSX!)
#if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
static LRESULT CALLBACK WndProcNoInputs(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    if (msg == WM_NCHITTEST)
    {
        // Let mouse pass-through the window. This will allow the backend to call io.AddMouseViewportEvent() properly (which is OPTIONAL).
        // The ImGuiViewportFlags_NoInputs flag is set while dragging a viewport, as want to detect the window behind the one we are dragging.
        // If you cannot easily access those viewport flags from your windowing/event code: you may manually synchronize its state e.g. in
        // your main loop after calling UpdatePlatformWindows(). Iterate all viewports/platform windows and pass the flag to your windowing system.
        ImGuiViewport* viewport = (ImGuiViewport*)::GetPropA(hWnd, "IMGUI_VIEWPORT");
        if (viewport->Flags & ImGuiViewportFlags_NoInputs)
            return HTTRANSPARENT;
    }
    return ::CallWindowProc(bd->GlfwWndProc, hWnd, msg, wParam, lParam);
}
#endif

static void ImGui_ImplGlfw_ShowWindow(ImGuiViewport* viewport)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;

#if defined(_WIN32)
    // GLFW hack: Hide icon from task bar
    HWND hwnd = (HWND)viewport->PlatformHandleRaw;
    if (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon)
    {
        LONG ex_style = ::GetWindowLong(hwnd, GWL_EXSTYLE);
        ex_style &= ~WS_EX_APPWINDOW;
        ex_style |= WS_EX_TOOLWINDOW;
        ::SetWindowLong(hwnd, GWL_EXSTYLE, ex_style);
    }

    // GLFW hack: install hook for WM_NCHITTEST message handler
#if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    ::SetPropA(hwnd, "IMGUI_VIEWPORT", viewport);
    if (bd->GlfwWndProc == nullptr)
        bd->GlfwWndProc = (WNDPROC)::GetWindowLongPtr(hwnd, GWLP_WNDPROC);
    ::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)WndProcNoInputs);
#endif

#if !GLFW_HAS_FOCUS_ON_SHOW
    // GLFW hack: GLFW 3.2 has a bug where glfwShowWindow() also activates/focus the window.
    // The fix was pushed to GLFW repository on 2018/01/09 and should be included in GLFW 3.3 via a GLFW_FOCUS_ON_SHOW window attribute.
    // See https://github.com/glfw/glfw/issues/1189
    // FIXME-VIEWPORT: Implement same work-around for Linux/OSX in the meanwhile.
    if (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing)
    {
        ::ShowWindow(hwnd, SW_SHOWNA);
        return;
    }
#endif
#endif

    glfwShowWindow(vd->Window);
}

static ImVec2 ImGui_ImplGlfw_GetWindowPos(ImGuiViewport* viewport)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    int x = 0, y = 0;
    glfwGetWindowPos(vd->Window, &x, &y);
    return ImVec2((float)x, (float)y);
}

static void ImGui_ImplGlfw_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    vd->IgnoreWindowPosEventFrame = ImGui::GetFrameCount();
    glfwSetWindowPos(vd->Window, (int)pos.x, (int)pos.y);
}

static ImVec2 ImGui_ImplGlfw_GetWindowSize(ImGuiViewport* viewport)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    int w = 0, h = 0;
    glfwGetWindowSize(vd->Window, &w, &h);
    return ImVec2((float)w, (float)h);
}

static void ImGui_ImplGlfw_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
#if __APPLE__ && !GLFW_HAS_OSX_WINDOW_POS_FIX
    // Native OS windows are positioned from the bottom-left corner on macOS, whereas on other platforms they are
    // positioned from the upper-left corner. GLFW makes an effort to convert macOS style coordinates, however it
    // doesn't handle it when changing size. We are manually moving the window in order for changes of size to be based
    // on the upper-left corner.
    int x, y, width, height;
    glfwGetWindowPos(vd->Window, &x, &y);
    glfwGetWindowSize(vd->Window, &width, &height);
    glfwSetWindowPos(vd->Window, x, y - height + size.y);
#endif
    vd->IgnoreWindowSizeEventFrame = ImGui::GetFrameCount();
    glfwSetWindowSize(vd->Window, (int)size.x, (int)size.y);
}

static void ImGui_ImplGlfw_SetWindowTitle(ImGuiViewport* viewport, const char* title)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    glfwSetWindowTitle(vd->Window, title);
}

static void ImGui_ImplGlfw_SetWindowFocus(ImGuiViewport* viewport)
{
#if GLFW_HAS_FOCUS_WINDOW
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    glfwFocusWindow(vd->Window);
#else
    // FIXME: What are the effect of not having this function? At the moment imgui doesn't actually call SetWindowFocus - we set that up ahead, will answer that question later.
    (void)viewport;
#endif
}

static bool ImGui_ImplGlfw_GetWindowFocus(ImGuiViewport* viewport)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    return glfwGetWindowAttrib(vd->Window, GLFW_FOCUSED) != 0;
}

static bool ImGui_ImplGlfw_GetWindowMinimized(ImGuiViewport* viewport)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    return glfwGetWindowAttrib(vd->Window, GLFW_ICONIFIED) != 0;
}

#if GLFW_HAS_WINDOW_ALPHA
static void ImGui_ImplGlfw_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
{
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    glfwSetWindowOpacity(vd->Window, alpha);
}
#endif

static void ImGui_ImplGlfw_RenderWindow(ImGuiViewport* viewport, void*)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    if (bd->ClientApi == GlfwClientApi_OpenGL)
        glfwMakeContextCurrent(vd->Window);
}

static void ImGui_ImplGlfw_SwapBuffers(ImGuiViewport* viewport, void*)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    if (bd->ClientApi == GlfwClientApi_OpenGL)
    {
        glfwMakeContextCurrent(vd->Window);
        glfwSwapBuffers(vd->Window);
    }
}

//--------------------------------------------------------------------------------------------------------
// Vulkan support (the Vulkan renderer needs to call a platform-side support function to create the surface)
//--------------------------------------------------------------------------------------------------------

// Avoid including <vulkan.h> so we can build without it
#if GLFW_HAS_VULKAN
#ifndef VULKAN_H_
#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
#else
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
#endif
VK_DEFINE_HANDLE(VkInstance)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
struct VkAllocationCallbacks;
enum VkResult { VK_RESULT_MAX_ENUM = 0x7FFFFFFF };
#endif // VULKAN_H_
extern "C" { extern GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface); }
static int ImGui_ImplGlfw_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_instance, const void* vk_allocator, ImU64* out_vk_surface)
{
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
    IM_UNUSED(bd);
    IM_ASSERT(bd->ClientApi == GlfwClientApi_Vulkan);
    VkResult err = glfwCreateWindowSurface((VkInstance)vk_instance, vd->Window, (const VkAllocationCallbacks*)vk_allocator, (VkSurfaceKHR*)out_vk_surface);
    return (int)err;
}
#endif // GLFW_HAS_VULKAN

static void ImGui_ImplGlfw_InitPlatformInterface()
{
    // Register platform interface (will be coupled with a renderer interface)
    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
    platform_io.Platform_CreateWindow = ImGui_ImplGlfw_CreateWindow;
    platform_io.Platform_DestroyWindow = ImGui_ImplGlfw_DestroyWindow;
    platform_io.Platform_ShowWindow = ImGui_ImplGlfw_ShowWindow;
    platform_io.Platform_SetWindowPos = ImGui_ImplGlfw_SetWindowPos;
    platform_io.Platform_GetWindowPos = ImGui_ImplGlfw_GetWindowPos;
    platform_io.Platform_SetWindowSize = ImGui_ImplGlfw_SetWindowSize;
    platform_io.Platform_GetWindowSize = ImGui_ImplGlfw_GetWindowSize;
    platform_io.Platform_SetWindowFocus = ImGui_ImplGlfw_SetWindowFocus;
    platform_io.Platform_GetWindowFocus = ImGui_ImplGlfw_GetWindowFocus;
    platform_io.Platform_GetWindowMinimized = ImGui_ImplGlfw_GetWindowMinimized;
    platform_io.Platform_SetWindowTitle = ImGui_ImplGlfw_SetWindowTitle;
    platform_io.Platform_RenderWindow = ImGui_ImplGlfw_RenderWindow;
    platform_io.Platform_SwapBuffers = ImGui_ImplGlfw_SwapBuffers;
#if GLFW_HAS_WINDOW_ALPHA
    platform_io.Platform_SetWindowAlpha = ImGui_ImplGlfw_SetWindowAlpha;
#endif
#if GLFW_HAS_VULKAN
    platform_io.Platform_CreateVkSurface = ImGui_ImplGlfw_CreateVkSurface;
#endif

    // Register main window handle (which is owned by the main application, not by us)
    // This is mostly for simplicity and consistency, so that our code (e.g. mouse handling etc.) can use same logic for main and secondary viewports.
    ImGuiViewport* main_viewport = ImGui::GetMainViewport();
    ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)();
    vd->Window = bd->Window;
    vd->WindowOwned = false;
    main_viewport->PlatformUserData = vd;
    main_viewport->PlatformHandle = (void*)bd->Window;
}

static void ImGui_ImplGlfw_ShutdownPlatformInterface()
{
    ImGui::DestroyPlatformWindows();
}

#if defined(__clang__)
#pragma clang diagnostic pop
#endif


================================================
FILE: Source/External/imgui_tools/imgui_impl_glfw.h
================================================
// dear imgui: Platform Backend for GLFW
// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
// (Requires: GLFW 3.1+. Prefer GLFW 3.3+ for full feature support.)

// Implemented features:
//  [X] Platform: Clipboard support.
//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
//  [x] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
//  [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.

// Issues:
//  [ ] Platform: Multi-viewport support: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).

// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs

#pragma once
#include "imgui.h"      // IMGUI_IMPL_API

struct GLFWwindow;
struct GLFWmonitor;

IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks);
IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks);
IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks);
IMGUI_IMPL_API void     ImGui_ImplGlfw_Shutdown();
IMGUI_IMPL_API void     ImGui_ImplGlfw_NewFrame();

// GLFW callbacks (installer)
// - When calling Init with 'install_callbacks=true': ImGui_ImplGlfw_InstallCallbacks() is called. GLFW callbacks will be installed for you. They will chain-call user's previously installed callbacks, if any.
// - When calling Init with 'install_callbacks=false': GLFW callbacks won't be installed. You will need to call individual function yourself from your own GLFW callbacks.
IMGUI_IMPL_API void     ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
IMGUI_IMPL_API void     ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);

// GLFW callbacks (individual callbacks to call if you didn't install callbacks)
IMGUI_IMPL_API void     ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused);        // Since 1.84
IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered);        // Since 1.84
IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y);   // Since 1.87
IMGUI_IMPL_API void     ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
IMGUI_IMPL_API void     ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
IMGUI_IMPL_API void     ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
IMGUI_IMPL_API void     ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c);
IMGUI_IMPL_API void     ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor, int event);


================================================
FILE: Source/External/imgui_tools/imguizmo/GraphEditor.cpp
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//

#define IMGUI_DEFINE_MATH_OPERATORS
#include "imgui.h"
#include "imgui_internal.h"
#include <math.h>
#include <vector>
#include <float.h>
#include <array>
#include "GraphEditor.h"

namespace GraphEditor {

static inline float Distance(const ImVec2& a, const ImVec2& b)
{
    return sqrtf((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

static inline float sign(float v)
{
    return (v >= 0.f) ? 1.f : -1.f;
}

static ImVec2 GetInputSlotPos(Delegate& delegate, const Node& node, SlotIndex slotIndex, float factor)
{
    ImVec2 Size = node.mRect.GetSize() * factor;
    size_t InputsCount = delegate.GetTemplate(node.mTemplateIndex).mInputCount;
    return ImVec2(node.mRect.Min.x * factor,
                  node.mRect.Min.y * factor + Size.y * ((float)slotIndex + 1) / ((float)InputsCount + 1) + 8.f);
}

static ImVec2 GetOutputSlotPos(Delegate& delegate, const Node& node, SlotIndex slotIndex, float factor)
{
    ImVec2 Size = node.mRect.GetSize() * factor;
    size_t OutputsCount = delegate.GetTemplate(node.mTemplateIndex).mOutputCount;
    return ImVec2(node.mRect.Min.x * factor + Size.x,
                  node.mRect.Min.y * factor + Size.y * ((float)slotIndex + 1) / ((float)OutputsCount + 1) + 8.f);
}

static ImRect GetNodeRect(const Node& node, float factor)
{
    ImVec2 Size = node.mRect.GetSize() * factor;
    return ImRect(node.mRect.Min * factor, node.mRect.Min * factor + Size);
}

static ImVec2 editingNodeSource;
static bool editingInput = false;
static ImVec2 captureOffset;

enum NodeOperation
{
    NO_None,
    NO_EditingLink,
    NO_QuadSelecting,
    NO_MovingNodes,
    NO_EditInput,
    NO_PanView,
};
static NodeOperation nodeOperation = NO_None;

static void HandleZoomScroll(ImRect regionRect, ViewState& viewState, const Options& options)
{
    ImGuiIO& io = ImGui::GetIO();

    if (regionRect.Contains(io.MousePos))
    {
        if (io.MouseWheel < -FLT_EPSILON)
        {
            viewState.mFactorTarget *= 1.f - options.mZoomRatio;
        }

        if (io.MouseWheel > FLT_EPSILON)
        {
            viewState.mFactorTarget *= 1.0f + options.mZoomRatio;
        }
    }

    ImVec2 mouseWPosPre = (io.MousePos - ImGui::GetCursorScreenPos()) / viewState.mFactor;
    viewState.mFactorTarget = ImClamp(viewState.mFactorTarget, options.mMinZoom, options.mMaxZoom);
    viewState.mFactor = ImLerp(viewState.mFactor, viewState.mFactorTarget, options.mZoomLerpFactor);
    ImVec2 mouseWPosPost = (io.MousePos - ImGui::GetCursorScreenPos()) / viewState.mFactor;
    if (ImGui::IsMousePosValid())
    {
        viewState.mPosition += mouseWPosPost - mouseWPosPre;
    }
}

void GraphEditorClear()
{
    nodeOperation = NO_None;
}

static void FitNodes(Delegate& delegate, ViewState& viewState, const ImVec2 viewSize, bool selectedNodesOnly)
{
    const size_t nodeCount = delegate.GetNodeCount();

    if (!nodeCount)
    {
        return;
    }

    bool validNode = false;
    ImVec2 min(FLT_MAX, FLT_MAX);
    ImVec2 max(-FLT_MAX, -FLT_MAX);
    for (NodeIndex nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
    {
        const Node& node = delegate.GetNode(nodeIndex);
        
        if (selectedNodesOnly && !node.mSelected)
        {
            continue;
        }
        
        min = ImMin(min, node.mRect.Min);
        min = ImMin(min, node.mRect.Max);
        max = ImMax(max, node.mRect.Min);
        max = ImMax(max, node.mRect.Max);
        validNode = true;
    }
    
    if (!validNode)
    {
        return;
    }
    
    min -= viewSize * 0.05f;
    max += viewSize * 0.05f;
    ImVec2 nodesSize = max - min;
    ImVec2 nodeCenter = (max + min) * 0.5f;
    
    float ratioY = viewSize.y / nodesSize.y;
    float ratioX = viewSize.x / nodesSize.x;

    viewState.mFactor = viewState.mFactorTarget = ImMin(ImMin(ratioY, ratioX), 1.f);
    viewState.mPosition = ImVec2(-nodeCenter.x, -nodeCenter.y) + (viewSize * 0.5f) / viewState.mFactorTarget;
}

static void DisplayLinks(Delegate& delegate,
                         ImDrawList* drawList,
                         const ImVec2 offset,
                         const float factor,
                         const ImRect regionRect,
                         NodeIndex hoveredNode,
                         const Options& options)
{
    const size_t linkCount = delegate.GetLinkCount();
    for (LinkIndex linkIndex = 0; linkIndex < linkCount; linkIndex++)
    {
        const auto link = delegate.GetLink(linkIndex);
        const auto nodeInput = delegate.GetNode(link.mInputNodeIndex);
        const auto nodeOutput = delegate.GetNode(link.mOutputNodeIndex);
        ImVec2 p1 = offset + GetOutputSlotPos(delegate, nodeInput, link.mInputSlotIndex, factor);
        ImVec2 p2 = offset + GetInputSlotPos(delegate, nodeOutput, link.mOutputSlotIndex, factor);

        // con. view clipping
        if ((p1.y < 0.f && p2.y < 0.f) || (p1.y > regionRect.Max.y && p2.y > regionRect.Max.y) ||
            (p1.x < 0.f && p2.x < 0.f) || (p1.x > regionRect.Max.x && p2.x > regionRect.Max.x))
            continue;

        bool highlightCons = hoveredNode == link.mInputNodeIndex || hoveredNode == link.mOutputNodeIndex;
        uint32_t col = delegate.GetTemplate(nodeInput.mTemplateIndex).mHeaderColor | (highlightCons ? 0xF0F0F0 : 0);
        if (options.mDisplayLinksAsCurves)
        {
            // curves
             drawList->AddBezierCubic(p1, p1 + ImVec2(50, 0) * factor, p2 + ImVec2(-50, 0) * factor, p2, 0xFF000000, options.mLineThickness * 1.5f * factor);
             drawList->AddBezierCubic(p1, p1 + ImVec2(50, 0) * factor, p2 + ImVec2(-50, 0) * factor, p2, col, options.mLineThickness * 1.5f * factor);
             /*
            ImVec2 p10 = p1 + ImVec2(20.f * factor, 0.f);
            ImVec2 p20 = p2 - ImVec2(20.f * factor, 0.f);

            ImVec2 dif = p20 - p10;
            ImVec2 p1a, p1b;
            if (fabsf(dif.x) > fabsf(dif.y))
            {
                p1a = p10 + ImVec2(fabsf(fabsf(dif.x) - fabsf(dif.y)) * 0.5 * sign(dif.x), 0.f);
                p1b = p1a + ImVec2(fabsf(dif.y) * sign(dif.x) , dif.y);
            }
            else
            {
                p1a = p10 + ImVec2(0.f, fabsf(fabsf(dif.y) - fabsf(dif.x)) * 0.5 * sign(dif.y));
                p1b = p1a + ImVec2(dif.x, fabsf(dif.x) * sign(dif.y));
            }
            drawList->AddLine(p1,  p10, col, 3.f * factor);
            drawList->AddLine(p10, p1a, col, 3.f * factor);
            drawList->AddLine(p1a, p1b, col, 3.f * factor);
            drawList->AddLine(p1b, p20, col, 3.f * factor);
            drawList->AddLine(p20,  p2, col, 3.f * factor);
            */
        }
        else
        {
            // straight lines
            std::array<ImVec2, 6> pts;
            int ptCount = 0;
            ImVec2 dif = p2 - p1;

            ImVec2 p1a, p1b;
            const float limitx = 12.f * factor;
            if (dif.x < limitx)
            {
                ImVec2 p10 = p1 + ImVec2(limitx, 0.f);
                ImVec2 p20 = p2 - ImVec2(limitx, 0.f);

                dif = p20 - p10;
                p1a = p10 + ImVec2(0.f, dif.y * 0.5f);
                p1b = p1a + ImVec2(dif.x, 0.f);

                pts = { p1, p10, p1a, p1b, p20, p2 };
                ptCount = 6;
            }
            else
            {
                if (fabsf(dif.y) < 1.f)
                {
                    pts = { p1, (p1 + p2) * 0.5f, p2 };
                    ptCount = 3;
                }
                else
                {
                    if (fabsf(dif.y) < 10.f)
                    {
                        if (fabsf(dif.x) > fabsf(dif.y))
                        {
                            p1a = p1 + ImVec2(fabsf(fabsf(dif.x) - fabsf(dif.y)) * 0.5f * sign(dif.x), 0.f);
                            p1b = p1a + ImVec2(fabsf(dif.y) * sign(dif.x), dif.y);
                        }
                        else
                        {
                            p1a = p1 + ImVec2(0.f, fabsf(fabsf(dif.y) - fabsf(dif.x)) * 0.5f * sign(dif.y));
                            p1b = p1a + ImVec2(dif.x, fabsf(dif.x) * sign(dif.y));
                        }
                    }
                    else
                    {
                        if (fabsf(dif.x) > fabsf(dif.y))
                        {
                            float d = fabsf(dif.y) * sign(dif.x) * 0.5f;
                            p1a = p1 + ImVec2(d, dif.y * 0.5f);
                            p1b = p1a + ImVec2(fabsf(fabsf(dif.x) - fabsf(d) * 2.f) * sign(dif.x), 0.f);
                        }
                        else
                        {
                            float d = fabsf(dif.x) * sign(dif.y) * 0.5f;
                            p1a = p1 + ImVec2(dif.x * 0.5f, d);
                            p1b = p1a + ImVec2(0.f, fabsf(fabsf(dif.y) - fabsf(d) * 2.f) * sign(dif.y));
                        }
                    }
                    pts = { p1, p1a, p1b, p2 };
                    ptCount = 4;
                }
            }
            float highLightFactor = factor * (highlightCons ? 2.0f : 1.f);
            for (int pass = 0; pass < 2; pass++)
            {
                drawList->AddPolyline(pts.data(), ptCount, pass ? col : 0xFF000000, false, (pass ? options.mLineThickness : (options.mLineThickness * 1.5f)) * highLightFactor);
            }
        }
    }
}

static void HandleQuadSelection(Delegate& delegate, ImDrawList* drawList, const ImVec2 offset, const float factor, ImRect contentRect, const Options& options)
{
    if (!options.mAllowQuadSelection)
    {
        return;
    }
    ImGuiIO& io = ImGui::GetIO();
    static ImVec2 quadSelectPos;
    //auto& nodes = delegate->GetNodes();
    auto nodeCount = delegate.GetNodeCount();

    if (nodeOperation == NO_QuadSelecting && ImGui::IsWindowFocused())
    {
        const ImVec2 bmin = ImMin(quadSelectPos, io.MousePos);
        const ImVec2 bmax = ImMax(quadSelectPos, io.MousePos);
        drawList->AddRectFilled(bmin, bmax, options.mQuadSelection, 1.f);
        drawList->AddRect(bmin, bmax, options.mQuadSelectionBorder, 1.f);
        if (!io.MouseDown[0])
        {
            if (!io.KeyCtrl && !io.KeyShift)
            {
                for (size_t nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
                {
                    delegate.SelectNode(nodeIndex, false);
                }
            }

            nodeOperation = NO_None;
            ImRect selectionRect(bmin, bmax);
            for (int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
            {
                const auto node = delegate.GetNode(nodeIndex);
                ImVec2 nodeRectangleMin = offset + node.mRect.Min * factor;
                ImVec2 nodeRectangleMax = nodeRectangleMin + node.mRect.GetSize() * factor;
                if (selectionRect.Overlaps(ImRect(nodeRectangleMin, nodeRectangleMax)))
                {
                    if (io.KeyCtrl)
                    {
                        delegate.SelectNode(nodeIndex, false);
                    }
                    else
                    {
                        delegate.SelectNode(nodeIndex, true);
                    }
                }
                else
                {
                    if (!io.KeyShift)
                    {
                        delegate.SelectNode(nodeIndex, false);
                    }
                }
            }
        }
    }
    else if (nodeOperation == NO_None && io.MouseDown[0] && ImGui::IsWindowFocused() &&
             contentRect.Contains(io.MousePos))
    {
        nodeOperation = NO_QuadSelecting;
        quadSelectPos = io.MousePos;
    }
}

static bool HandleConnections(ImDrawList* drawList,
                       NodeIndex nodeIndex,
                       const ImVec2 offset,
                       const float factor,
                       Delegate& delegate,
                       const Options& options,
                       bool bDrawOnly,
                       SlotIndex& inputSlotOver,
                       SlotIndex& outputSlotOver,
                       const bool inMinimap)
{
    static NodeIndex editingNodeIndex;
    static SlotIndex editingSlotIndex;

    ImGuiIO& io = ImGui::GetIO();
    const auto node = delegate.GetNode(nodeIndex);
    const auto nodeTemplate = delegate.GetTemplate(node.mTemplateIndex);
    const auto linkCount = delegate.GetLinkCount();

    size_t InputsCount = nodeTemplate.mInputCount;
    size_t OutputsCount = nodeTemplate.mOutputCount;
    inputSlotOver = -1;
    outputSlotOver = -1;

    // draw/use inputs/outputs
    bool hoverSlot = false;
    for (int i = 0; i < 2; i++)
    {
        float closestDistance = FLT_MAX;
        SlotIndex closestConn = -1;
        ImVec2 closestTextPos;
        ImVec2 closestPos;
        const size_t slotCount[2] = {InputsCount, OutputsCount};
        
        for (SlotIndex slotIndex = 0; slotIndex < slotCount[i]; slotIndex++)
        {
            const char** con = i ? nodeTemplate.mOutputNames : nodeTemplate.mInputNames;
            const char* conText = (con && con[slotIndex]) ? con[slotIndex] : "";

            ImVec2 p =
                offset + (i ? GetOutputSlotPos(delegate, node, slotIndex, factor) : GetInputSlotPos(delegate, node, slotIndex, factor));
            float distance = Distance(p, io.MousePos);
            bool overCon = (nodeOperation == NO_None || nodeOperation == NO_EditingLink) &&
                           (distance < options.mNodeSlotRadius * 2.f) && (distance < closestDistance);

            
            ImVec2 textSize;
            textSize = ImGui::CalcTextSize(conText);
            ImVec2 textPos =
                p + ImVec2(-options.mNodeSlotRadius * (i ? -1.f : 1.f) * (overCon ? 3.f : 2.f) - (i ? 0 : textSize.x),
                           -textSize.y / 2);

            ImRect nodeRect = GetNodeRect(node, factor);
            if (!inMinimap && (overCon || (nodeRect.Contains(io.MousePos - offset) && closestConn == -1 &&
                            (editingInput == (i != 0)) && nodeOperation == NO_EditingLink)))
            {
                closestDistance = distance;
                closestConn = slotIndex;
                closestTextPos = textPos;
                closestPos = p;
                
                if (i)
                {
                    outputSlotOver = slotIndex;
                }
                else
                {
                    inputSlotOver = slotIndex;
                }
            }
            else
            {
               const ImU32* slotColorSource = i ? nodeTemplate.mOutputColors : nodeTemplate.mInputColors;
               const ImU32 slotColor = slotColorSource ? slotColorSource[slotIndex] : options.mDefaultSlotColor;
               drawList->AddCircleFilled(p, options.mNodeSlotRadius, IM_COL32(0, 0, 0, 200));
               drawList->AddCircleFilled(p, options.mNodeSlotRadius * 0.75f, slotColor);
               if (!options.mDrawIONameOnHover)
               {
                    drawList->AddText(io.FontDefault, 14, textPos + ImVec2(2, 2), IM_COL32(0, 0, 0, 255), conText);
                    drawList->AddText(io.FontDefault, 14, textPos, IM_COL32(150, 150, 150, 255), conText);
               }
            }
        }

        if (closestConn != -1)
        {
            const char** con = i ? nodeTemplate.mOutputNames : nodeTemplate.mInputNames;
            const char* conText = (con && con[closestConn]) ? con[closestConn] : "";
            const ImU32* slotColorSource = i ? nodeTemplate.mOutputColors : nodeTemplate.mInputColors;
            const ImU32 slotColor = slotColorSource ? slotColorSource[closestConn] : options.mDefaultSlotColor;
            hoverSlot = true;
            drawList->AddCircleFilled(closestPos, options.mNodeSlotRadius * options.mNodeSlotHoverFactor * 0.75f, IM_COL32(0, 0, 0, 200));
            drawList->AddCircleFilled(closestPos, options.mNodeSlotRadius * options.mNodeSlotHoverFactor, slotColor);
            drawList->AddText(io.FontDefault, 16, closestTextPos + ImVec2(1, 1), IM_COL32(0, 0, 0, 255), conText);
            drawList->AddText(io.FontDefault, 16, closestTextPos, IM_COL32(250, 250, 250, 255), conText);
            bool inputToOutput = (!editingInput && !i) || (editingInput && i);
            if (nodeOperation == NO_EditingLink && !io.MouseDown[0] && !bDrawOnly)
            {
                if (inputToOutput)
                {
                    // check loopback
                    Link nl;
                    if (editingInput)
                        nl = Link{nodeIndex, closestConn, editingNodeIndex, editingSlotIndex};
                    else
                        nl = Link{editingNodeIndex, editingSlotIndex, nodeIndex, closestConn};

                    if (!delegate.AllowedLink(nl.mOutputNodeIndex, nl.mInputNodeIndex))
                    {
                        break;
                    }
                    bool alreadyExisting = false;
                    for (size_t linkIndex = 0; linkIndex < linkCount; linkIndex++)
                    {
                        const auto link = delegate.GetLink(linkIndex);
                        if (!memcmp(&link, &nl, sizeof(Link)))
                        {
                            alreadyExisting = true;
                            break;
                        }
                    }

                    if (!alreadyExisting)
                    {
                        for (int linkIndex = 0; linkIndex < linkCount; linkIndex++)
                        {
                            const auto link = delegate.GetLink(linkIndex);
                            if (link.mOutputNodeIndex == nl.mOutputNodeIndex && link.mOutputSlotIndex == nl.mOutputSlotIndex)
                            {
                                delegate.DelLink(linkIndex);
                                
                                break;
                            }
                        }

                        delegate.AddLink(nl.mInputNodeIndex, nl.mInputSlotIndex, nl.mOutputNodeIndex, nl.mOutputSlotIndex);
                    }
                }
            }
            // when ImGui::IsWindowHovered() && !ImGui::IsAnyItemActive() is uncommented, one can't click the node
            // input/output when mouse is over the node itself.
            if (nodeOperation == NO_None &&
                /*ImGui::IsWindowHovered() && !ImGui::IsAnyItemActive() &&*/ io.MouseClicked[0] && !bDrawOnly)
            {
                nodeOperation = NO_EditingLink;
                editingInput = i == 0;
                editingNodeSource = closestPos;
                editingNodeIndex = nodeIndex;
                editingSlotIndex = closestConn;
                if (editingInput)
                {
                    // remove existing link
                    for (int linkIndex = 0; linkIndex < linkCount; linkIndex++)
                    {
                        const auto link = delegate.GetLink(linkIndex);
                        if (link.mOutputNodeIndex == nodeIndex && link.mOutputSlotIndex == closestConn)
                        {
                            delegate.DelLink(linkIndex);
                            break;
                        }
                    }
                }
            }
        }
    }
    return hoverSlot;
}

static void DrawGrid(ImDrawList* drawList, ImVec2 windowPos, const ViewState& viewState, const ImVec2 canvasSize, ImU32 gridColor, ImU32 gridColor2, float gridSize)
{
    float gridSpace = gridSize * viewState.mFactor;
    int divx = static_cast<int>(-viewState.mPosition.x / gridSize);
    int divy = static_cast<int>(-viewState.mPosition.y / gridSize);
    for (float x = fmodf(viewState.mPosition.x * viewState.mFactor, gridSpace); x < canvasSize.x; x += gridSpace, divx ++)
    {
        bool tenth = !(divx % 10);
        drawList->AddLine(ImVec2(x, 0.0f) + windowPos, ImVec2(x, canvasSize.y) + windowPos, tenth ? gridColor2 : gridColor);
    }
    for (float y = fmodf(viewState.mPosition.y * viewState.mFactor, gridSpace); y < canvasSize.y; y += gridSpace, divy ++)
    {
        bool tenth = !(divy % 10);
        drawList->AddLine(ImVec2(0.0f, y) + windowPos, ImVec2(canvasSize.x, y) + windowPos, tenth ? gridColor2 : gridColor);
    }
}

// return true if node is hovered
static bool DrawNode(ImDrawList* drawList,
                     NodeIndex nodeIndex,
                     const ImVec2 offset,
                     const float factor,
                     Delegate& delegate,
                     bool overInput,
                     const Options& options,
                     const bool inMinimap,
                     const ImRect& viewPort)
{
    ImGuiIO& io = ImGui::GetIO();
    const auto node = delegate.GetNode(nodeIndex);
    IM_ASSERT((node.mRect.GetWidth() != 0.f) && (node.mRect.GetHeight() != 0.f) && "Nodes must have a non-zero rect.");
    const auto nodeTemplate = delegate.GetTemplate(node.mTemplateIndex);
    const ImVec2 nodeRectangleMin = offset + node.mRect.Min * factor;

    const bool old_any_active = ImGui::IsAnyItemActive();
    ImGui::SetCursorScreenPos(nodeRectangleMin);
    const ImVec2 nodeSize = node.mRect.GetSize() * factor;

    // test nested IO
    drawList->ChannelsSetCurrent(1); // Background
    const size_t InputsCount = nodeTemplate.mInputCount;
    const size_t OutputsCount = nodeTemplate.mOutputCount;

    /*
    for (int i = 0; i < 2; i++)
    {
        const size_t slotCount[2] = {InputsCount, OutputsCount};
        
        for (size_t slotIndex = 0; slotIndex < slotCount[i]; slotIndex++)
        {
            const char* con = i ? nodeTemplate.mOutputNames[slotIndex] : nodeTemplate.mInputNames[slotIndex];//node.mOutputs[slot_idx] : node->mInputs[slot_idx];
            if (!delegate->IsIOPinned(nodeIndex, slot_idx, i == 1))
            {
               
            }
            continue;

            ImVec2 p = offset + (i ? GetOutputSlotPos(delegate, node, slotIndex, factor) : GetInputSlotPos(delegate, node, slotIndex, factor));
            const float arc = 28.f * (float(i) * 0.3f + 1.0f) * (i ? 1.f : -1.f);
            const float ofs = 0.f;

            ImVec2 pts[3] = {p + ImVec2(arc + ofs, 0.f), p + ImVec2(0.f + ofs, -arc), p + ImVec2(0.f + ofs, arc)};
            drawList->AddTriangleFilled(pts[0], pts[1], pts[2], i ? 0xFFAA5030 : 0xFF30AA50);
            drawList->AddTriangle(pts[0], pts[1], pts[2], 0xFF000000, 2.f);
        }
    }
    */

    ImGui::SetCursorScreenPos(nodeRectangleMin);
    float maxHeight = ImMin(viewPort.Max.y, nodeRectangleMin.y + nodeSize.y) - nodeRectangleMin.y;
    float maxWidth = ImMin(viewPort.Max.x, nodeRectangleMin.x + nodeSize.x) - nodeRectangleMin.x;
    ImGui::InvisibleButton("node", ImVec2(maxWidth, maxHeight));
    // must be called right after creating the control we want to be able to move
    bool nodeMovingActive = ImGui::IsItemActive();

    // Save the size of what we have emitted and whether any of the widgets are being used
    bool nodeWidgetsActive = (!old_any_active && ImGui::IsAnyItemActive());
    ImVec2 nodeRectangleMax = nodeRectangleMin + nodeSize;

    bool nodeHovered = false;
    if (ImGui::IsItemHovered() && nodeOperation == NO_None && !overInput)
    {
        nodeHovered = true;
    }

    if (ImGui::IsWindowFocused())
    {
        if ((nodeWidgetsActive || nodeMovingActive) && !inMinimap)
        {
            if (!node.mSelected)
            {
                if (!io.KeyShift)
                {
                    const auto nodeCount = delegate.GetNodeCount();
                    for (size_t i = 0; i < nodeCount; i++)
                    {
                        delegate.SelectNode(i, false);
                    }
                }
                delegate.SelectNode(nodeIndex, true);
            }
        }
    }
    if (nodeMovingActive && io.MouseDown[0] && nodeHovered && !inMinimap)
    {
        if (nodeOperation != NO_MovingNodes)
        {
            nodeOperation = NO_MovingNodes;
        }
    }

    const bool currentSelectedNode = node.mSelected;
    const ImU32 node_bg_color = nodeHovered ? nodeTemplate.mBackgroundColorOver : nodeTemplate.mBackgroundColor;

    drawList->AddRect(nodeRectangleMin,
                      nodeRectangleMax,
                      currentSelectedNode ? options.mSelectedNodeBorderColor : options.mNodeBorderColor,
                      options.mRounding,
                      ImDrawFlags_RoundCornersAll,
                      currentSelectedNode ? options.mBorderSelectionThickness : options.mBorderThickness);

    ImVec2 imgPos = nodeRectangleMin + ImVec2(14, 25);
    ImVec2 imgSize = nodeRectangleMax + ImVec2(-5, -5) - imgPos;
    float imgSizeComp = std::min(imgSize.x, imgSize.y);

    drawList->AddRectFilled(nodeRectangleMin, nodeRectangleMax, node_bg_color, options.mRounding);
    /*float progress = delegate->NodeProgress(nodeIndex);
    if (progress > FLT_EPSILON && progress < 1.f - FLT_EPSILON)
    {
        ImVec2 progressLineA = nodeRectangleMax - ImVec2(nodeSize.x - 2.f, 3.f);
        ImVec2 progressLineB = progressLineA + ImVec2(nodeSize.x * factor - 4.f, 0.f);
        drawList->AddLine(progressLineA, progressLineB, 0xFF400000, 3.f);
        drawList->AddLine(progressLineA, ImLerp(progressLineA, progressLineB, progress), 0xFFFF0000, 3.f);
    }*/
    ImVec2 imgPosMax = imgPos + ImVec2(imgSizeComp, imgSizeComp);

    //ImVec2 imageSize = delegate->GetEvaluationSize(nodeIndex);
    /*float imageRatio = 1.f;
    if (imageSize.x > 0.f && imageSize.y > 0.f)
    {
        imageRatio = imageSize.y / imageSize.x;
    }
    ImVec2 quadSize = imgPosMax - imgPos;
    ImVec2 marge(0.f, 0.f);
    if (imageRatio > 1.f)
    {
        marge.x = (quadSize.x - quadSize.y / imageRatio) * 0.5f;
    }
    else
    {
        marge.y = (quadSize.y - quadSize.y * imageRatio) * 0.5f;
    }*/

    //delegate->DrawNodeImage(drawList, ImRect(imgPos, imgPosMax), marge, nodeIndex);

    drawList->AddRectFilled(nodeRectangleMin,
                            ImVec2(nodeRectangleMax.x, nodeRectangleMin.y + 20),
                            nodeTemplate.mHeaderColor, options.mRounding);

    drawList->PushClipRect(nodeRectangleMin, ImVec2(nodeRectangleMax.x, nodeRectangleMin.y + 20), true);
    drawList->AddText(nodeRectangleMin + ImVec2(2, 2), IM_COL32(0, 0, 0, 255), node.mName);
    drawList->PopClipRect();

    ImRect customDrawRect(nodeRectangleMin + ImVec2(options.mRounding, 20 + options.mRounding), nodeRectangleMax - ImVec2(options.mRounding, options.mRounding));
    if (customDrawRect.Max.y > customDrawRect.Min.y && customDrawRect.Max.x > customDrawRect.Min.x)
    {
        delegate.CustomDraw(drawList, customDrawRect, nodeIndex);
    }
/*
    const ImTextureID bmpInfo = (ImTextureID)(uint64_t)delegate->GetBitmapInfo(nodeIndex).idx;
    if (bmpInfo)
    {
        ImVec2 bmpInfoPos(nodeRectangleMax - ImVec2(26, 12));
        ImVec2 bmpInfoSize(20, 20);
        if (delegate->NodeIsCompute(nodeIndex))
        {
            drawList->AddImageQuad(bmpInfo,
                                   bmpInfoPos,
                                   bmpInfoPos + ImVec2(bmpInfoSize.x, 0.f),
                                   bmpInfoPos + bmpInfoSize,
                                   bmpInfoPos + ImVec2(0., bmpInfoSize.y));
        }
        else if (delegate->NodeIs2D(nodeIndex))
        {
            drawList->AddImageQuad(bmpInfo,
                                   bmpInfoPos,
                                   bmpInfoPos + ImVec2(bmpInfoSize.x, 0.f),
                                   bmpInfoPos + bmpInfoSize,
                                   bmpInfoPos + ImVec2(0., bmpInfoSize.y));
        }
        else if (delegate->NodeIsCubemap(nodeIndex))
        {
            drawList->AddImageQuad(bmpInfo,
                                   bmpInfoPos + ImVec2(0., bmpInfoSize.y),
                                   bmpInfoPos + bmpInfoSize,
                                   bmpInfoPos + ImVec2(bmpInfoSize.x, 0.f),
                                   bmpInfoPos);
        }
    }*/
    return nodeHovered;
}

bool DrawMiniMap(ImDrawList* drawList, Delegate& delegate, ViewState& viewState, const Options& options, const ImVec2 windowPos, const ImVec2 canvasSize)
{
    if (Distance(options.mMinimap.Min, options.mMinimap.Max) <= FLT_EPSILON)
    {
        return false;
    }

    const size_t nodeCount = delegate.GetNodeCount();

    if (!nodeCount)
    {
        return false;
    }

    ImVec2 min(FLT_MAX, FLT_MAX);
    ImVec2 max(-FLT_MAX, -FLT_MAX);
    const ImVec2 margin(50, 50);
    for (NodeIndex nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
    {
        const Node& node = delegate.GetNode(nodeIndex);
        min = ImMin(min, node.mRect.Min - margin);
        min = ImMin(min, node.mRect.Max + margin);
        max = ImMax(max, node.mRect.Min - margin);
        max = ImMax(max, node.mRect.Max + margin);
    }

    // add view in world space
    const ImVec2 worldSizeView = canvasSize / viewState.mFactor;
    const ImVec2 viewMin(-viewState.mPosition.x, -viewState.mPosition.y);
    const ImVec2 viewMax = viewMin + worldSizeView;
    min = ImMin(min, viewMin);
    max = ImMax(max, viewMax);
    const ImVec2 nodesSize = max - min;
    const ImVec2 middleWorld = (min + max) * 0.5f;
    const ImVec2 minScreen = windowPos + options.mMinimap.Min * canvasSize;
    const ImVec2 maxScreen = windowPos + options.mMinimap.Max * canvasSize;
    const ImVec2 viewSize = maxScreen - minScreen;
    const ImVec2 middleScreen = (minScreen + maxScreen) * 0.5f;
    const float ratioY = viewSize.y / nodesSize.y;
    const float ratioX = viewSize.x / nodesSize.x;
    const float factor = ImMin(ImMin(ratioY, ratioX), 1.f);

    drawList->AddRectFilled(minScreen, maxScreen, IM_COL32(30, 30, 30, 200), 3, ImDrawFlags_RoundCornersAll);

    for (NodeIndex nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
    {
        const Node& node = delegate.GetNode(nodeIndex);
        const auto nodeTemplate = delegate.GetTemplate(node.mTemplateIndex);

        ImRect rect = node.mRect;
        rect.Min -= middleWorld;
        rect.Min *= factor;
        rect.Min += middleScreen;

        rect.Max -= middleWorld;
        rect.Max *= factor;
        rect.Max += middleScreen;

        drawList->AddRectFilled(rect.Min, rect.Max, nodeTemplate.mBackgroundColor, 1, ImDrawFlags_RoundCornersAll);
        if (node.mSelected)
        {
            drawList->AddRect(rect.Min, rect.Max, options.mSelectedNodeBorderColor, 1, ImDrawFlags_RoundCornersAll);
        }
    }

    // add view
    ImVec2 viewMinScreen = (viewMin - middleWorld) * factor + middleScreen;
    ImVec2 viewMaxScreen = (viewMax - middleWorld) * factor + middleScreen;
    drawList->AddRectFilled(viewMinScreen, viewMaxScreen, IM_COL32(255, 255, 255, 32), 1, ImDrawFlags_RoundCornersAll);
    drawList->AddRect(viewMinScreen, viewMaxScreen, IM_COL32(255, 255, 255, 128), 1, ImDrawFlags_RoundCornersAll);
    
    ImGuiIO& io = ImGui::GetIO();
    const bool mouseInMinimap = ImRect(minScreen, maxScreen).Contains(io.MousePos);
    if (mouseInMinimap && io.MouseClicked[0])
    {
        const ImVec2 clickedRatio = (io.MousePos - minScreen) / viewSize;
        const ImVec2 worldPosCenter = ImVec2(ImLerp(min.x, max.x, clickedRatio.x), ImLerp(min.y, max.y, clickedRatio.y));
        
        ImVec2 worldPosViewMin = worldPosCenter - worldSizeView * 0.5;
        ImVec2 worldPosViewMax = worldPosCenter + worldSizeView * 0.5;
        if (worldPosViewMin.x < min.x)
        {
            worldPosViewMin.x = min.x;
            worldPosViewMax.x = worldPosViewMin.x + worldSizeView.x;
        }
        if (worldPosViewMin.y < min.y)
        {
            worldPosViewMin.y = min.y;
            worldPosViewMax.y = worldPosViewMin.y + worldSizeView.y;
        }
        if (worldPosViewMax.x > max.x)
        {
            worldPosViewMax.x = max.x;
            worldPosViewMin.x = worldPosViewMax.x - worldSizeView.x;
        }
        if (worldPosViewMax.y > max.y)
        {
            worldPosViewMax.y = max.y;
            worldPosViewMin.y = worldPosViewMax.y - worldSizeView.y;
        }
        viewState.mPosition = ImVec2(-worldPosViewMin.x, -worldPosViewMin.y);
    }
    return mouseInMinimap;
}

void Show(Delegate& delegate, const Options& options, ViewState& viewState, bool enabled, FitOnScreen* fit)
{
    ImGui::PushStyleVar(ImGuiStyleVar_ChildBorderSize, 0.f);
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.f, 0.f));
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.f);

    const ImVec2 windowPos = ImGui::GetCursorScreenPos();
    const ImVec2 canvasSize = ImGui::GetContentRegionAvail();
    const ImVec2 scrollRegionLocalPos(0, 0);

    ImRect regionRect(windowPos, windowPos + canvasSize);

    HandleZoomScroll(regionRect, viewState, options);
    ImVec2 offset = ImGui::GetCursorScreenPos() + viewState.mPosition * viewState.mFactor;
    captureOffset = viewState.mPosition * viewState.mFactor;

    //ImGui::InvisibleButton("GraphEditorButton", canvasSize);
    ImGui::BeginChildFrame(71711, canvasSize);

    ImGui::SetCursorPos(windowPos);
    ImGui::BeginGroup();

    ImGuiIO& io = ImGui::GetIO();

    // Create our child canvas
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(1, 1));
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
    ImGui::PushStyleColor(ImGuiCol_ChildBg, IM_COL32(30, 30, 30, 200));

    ImDrawList* drawList = ImGui::GetWindowDrawList();
    ImGui::PushClipRect(regionRect.Min, regionRect.Max, true);
    drawList->AddRectFilled(windowPos, windowPos + canvasSize, options.mBackgroundColor);

    // Background or Display grid
    if (options.mRenderGrid)
    {
        DrawGrid(drawList, windowPos, viewState, canvasSize, options.mGridColor, options.mGridColor2, options.mGridSize);
    }
    
    // Fit view
    if (fit && ((*fit == Fit_AllNodes) || (*fit == Fit_SelectedNodes)))
    {
        FitNodes(delegate, viewState, canvasSize, (*fit == Fit_SelectedNodes));
    }

    if (enabled)
    {
        static NodeIndex hoveredNode = -1;
        // Display links
        drawList->ChannelsSplit(3);

        // minimap
        drawList->ChannelsSetCurrent(2); // minimap
        const bool inMinimap = DrawMiniMap(drawList, delegate, viewState, options, windowPos, canvasSize);

        // Focus rectangle
        if (ImGui::IsWindowFocused())
        {
           drawList->AddRect(regionRect.Min, regionRect.Max, options.mFrameFocus, 1.f, 0, 2.f);
        }

        drawList->ChannelsSetCurrent(1); // Background

        // Links
        DisplayLinks(delegate, drawList, offset, viewState.mFactor, regionRect, hoveredNode, options);

        // edit node link
        if (nodeOperation == NO_EditingLink)
        {
            ImVec2 p1 = editingNodeSource;
            ImVec2 p2 = io.MousePos;
            drawList->AddLine(p1, p2, IM_COL32(200, 200, 200, 255), 3.0f);
        }

        // Display nodes
        drawList->PushClipRect(regionRect.Min, regionRect.Max, true);
        hoveredNode = -1;
        
        SlotIndex inputSlotOver = -1;
        SlotIndex outputSlotOver = -1;
        NodeIndex nodeOver = -1;

        const auto nodeCount = delegate.GetNodeCount();
        for (int i = 0; i < 2; i++)
        {
            for (NodeIndex nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
            {
                //const auto* node = &nodes[nodeIndex];
                const auto node = delegate.GetNode(nodeIndex);
                if (node.mSelected != (i != 0))
                {
                    continue;
                }

                // node view clipping
                ImRect nodeRect = GetNodeRect(node, viewState.mFactor);
                nodeRect.Min += offset;
                nodeRect.Max += offset;
                if (!regionRect.Overlaps(nodeRect))
                {
                    continue;
                }

                ImGui::PushID((int)nodeIndex);
                SlotIndex inputSlot = -1;
                SlotIndex outputSlot = -1;

                bool overInput = (!inMinimap) && HandleConnections(drawList, nodeIndex, offset, viewState.mFactor, delegate, options, false, inputSlot, outputSlot, inMinimap);

                // shadow
                /*
                ImVec2 shadowOffset = ImVec2(30, 30);
                ImVec2 shadowPivot = (nodeRect.Min + nodeRect.Max) /2.f;
                ImVec2 shadowPointMiddle = shadowPivot + shadowOffset;
                ImVec2 shadowPointTop = ImVec2(shadowPivot.x, nodeRect.Min.y) + shadowOffset;
                ImVec2 shadowPointBottom = ImVec2(shadowPivot.x, nodeRect.Max.y) + shadowOffset;
                ImVec2 shadowPointLeft = ImVec2(nodeRect.Min.x, shadowPivot.y) + shadowOffset;
                ImVec2 shadowPointRight = ImVec2(nodeRect.Max.x, shadowPivot.y) + shadowOffset;

                // top left
                drawList->AddRectFilledMultiColor(nodeRect.Min + shadowOffset, shadowPointMiddle, IM_COL32(0 ,0, 0, 0), IM_COL32(0,0,0,0), IM_COL32(0, 0, 0, 255), IM_COL32(0, 0, 0, 0));

                // top right
                drawList->AddRectFilledMultiColor(shadowPointTop, shadowPointRight, IM_COL32(0 ,0, 0, 0), IM_COL32(0,0,0,0), IM_COL32(0, 0, 0, 0), IM_COL32(0, 0, 0, 255));

                // bottom left
                drawList->AddRectFilledMultiColor(shadowPointLeft, shadowPointBottom, IM_COL32(0 ,0, 0, 0), IM_COL32(0, 0, 0, 255), IM_COL32(0, 0, 0, 0), IM_COL32(0,0,0,0));

                // bottom right
                drawList->AddRectFilledMultiColor(shadowPointMiddle, nodeRect.Max + shadowOffset, IM_COL32(0, 0, 0, 255), IM_COL32(0 ,0, 0, 0), IM_COL32(0,0,0,0), IM_COL32(0, 0, 0, 0));
                */
                if (DrawNode(drawList, nodeIndex, offset, viewState.mFactor, delegate, overInput, options, inMinimap, regionRect))
                {
                    hoveredNode = nodeIndex;
                }

                HandleConnections(drawList, nodeIndex, offset, viewState.mFactor, delegate, options, true, inputSlot, outputSlot, inMinimap);
                if (inputSlot != -1 || outputSlot != -1)
                {
                    inputSlotOver = inputSlot;
                    outputSlotOver = outputSlot;
                    nodeOver = nodeIndex;
                }

                ImGui::PopID();
            }
        }
        

        
        drawList->PopClipRect();

        if (nodeOperation == NO_MovingNodes)
        {
            if (ImGui::IsMouseDragging(0, 1))
            {
                ImVec2 delta = io.MouseDelta / viewState.mFactor;
                if (fabsf(delta.x) >= 1.f || fabsf(delta.y) >= 1.f)
                {
                    delegate.MoveSelectedNodes(delta);
                }
            }
        }

        drawList->ChannelsSetCurrent(0);

        // quad selection
        if (!inMinimap)
        {
            HandleQuadSelection(delegate, drawList, offset, viewState.mFactor, regionRect, options);
        }

        drawList->ChannelsMerge();

        // releasing mouse button means it's done in any operation
        if (nodeOperation == NO_PanView)
        {
            if (!io.MouseDown[2])
            {
                nodeOperation = NO_None;
            }
        }
        else if (nodeOperation != NO_None && !io.MouseDown[0])
        {
            nodeOperation = NO_None;
        }

        // right click
        if (!inMinimap && nodeOperation == NO_None && regionRect.Contains(io.MousePos) &&
                (ImGui::IsMouseClicked(1) /*|| (ImGui::IsWindowFocused() && ImGui::IsKeyPressedMap(ImGuiKey_Tab))*/))
        {
            delegate.RightClick(nodeOver, inputSlotOver, outputSlotOver);
        }

        // Scrolling
        if (ImGui::IsWindowHovered() && !ImGui::IsAnyItemActive() && io.MouseClicked[2] && nodeOperation == NO_None)
        {
            nodeOperation = NO_PanView;
        }
        if (nodeOperation == NO_PanView)
        {
            viewState.mPosition += io.MouseDelta / viewState.mFactor;
        }
    }

    ImGui::PopClipRect();

    ImGui::PopStyleColor(1);
    ImGui::PopStyleVar(2);
    ImGui::EndGroup();
    ImGui::EndChildFrame();

    ImGui::PopStyleVar(3);
    
    // change fit to none
    if (fit)
    {
        *fit = Fit_None;
    }
}

bool EditOptions(Options& options)
{
    bool updated = false;
    if (ImGui::CollapsingHeader("Colors", nullptr))
    {
        ImColor backgroundColor(options.mBackgroundColor);
        ImColor gridColor(options.mGridColor);
        ImColor selectedNodeBorderColor(options.mSelectedNodeBorderColor);
        ImColor nodeBorderColor(options.mNodeBorderColor);
        ImColor quadSelection(options.mQuadSelection);
        ImColor quadSelectionBorder(options.mQuadSelectionBorder);
        ImColor defaultSlotColor(options.mDefaultSlotColor);
        ImColor frameFocus(options.mFrameFocus);

        updated |= ImGui::ColorEdit4("Background", (float*)&backgroundColor);
        updated |= ImGui::ColorEdit4("Grid", (float*)&gridColor);
        updated |= ImGui::ColorEdit4("Selected Node Border", (float*)&selectedNodeBorderColor);
        updated |= ImGui::ColorEdit4("Node Border", (float*)&nodeBorderColor);
        updated |= ImGui::ColorEdit4("Quad Selection", (float*)&quadSelection);
        updated |= ImGui::ColorEdit4("Quad Selection Border", (float*)&quadSelectionBorder);
        updated |= ImGui::ColorEdit4("Default Slot", (float*)&defaultSlotColor);
        updated |= ImGui::ColorEdit4("Frame when has focus", (float*)&frameFocus);

        options.mBackgroundColor = backgroundColor;
        options.mGridColor = gridColor;
        options.mSelectedNodeBorderColor = selectedNodeBorderColor;
        options.mNodeBorderColor = nodeBorderColor;
        options.mQuadSelection = quadSelection;
        options.mQuadSelectionBorder = quadSelectionBorder;
        options.mDefaultSlotColor = defaultSlotColor;
        options.mFrameFocus = frameFocus;
    }

    if (ImGui::CollapsingHeader("Options", nullptr))
    {
        updated |= ImGui::InputFloat4("Minimap", &options.mMinimap.Min.x);
        updated |= ImGui::InputFloat("Line Thickness", &options.mLineThickness);
        updated |= ImGui::InputFloat("Grid Size", &options.mGridSize);
        updated |= ImGui::InputFloat("Rounding", &options.mRounding);
        updated |= ImGui::InputFloat("Zoom Ratio", &options.mZoomRatio);
        updated |= ImGui::InputFloat("Zoom Lerp Factor", &options.mZoomLerpFactor);
        updated |= ImGui::InputFloat("Border Selection Thickness", &options.mBorderSelectionThickness);
        updated |= ImGui::InputFloat("Border Thickness", &options.mBorderThickness);
        updated |= ImGui::InputFloat("Slot Radius", &options.mNodeSlotRadius);
        updated |= ImGui::InputFloat("Slot Hover Factor", &options.mNodeSlotHoverFactor);
        updated |= ImGui::InputFloat2("Zoom min/max", &options.mMinZoom);
        updated |= ImGui::InputFloat("Slot Hover Factor", &options.mSnap);
        
        if (ImGui::RadioButton("Curved Links", options.mDisplayLinksAsCurves))
        {
            options.mDisplayLinksAsCurves = !options.mDisplayLinksAsCurves;
            updated = true;
        }
        if (ImGui::RadioButton("Straight Links", !options.mDisplayLinksAsCurves))
        {
            options.mDisplayLinksAsCurves = !options.mDisplayLinksAsCurves;
            updated = true;
        }

        updated |= ImGui::Checkbox("Allow Quad Selection", &options.mAllowQuadSelection);
        updated |= ImGui::Checkbox("Render Grid", &options.mRenderGrid);
        updated |= ImGui::Checkbox("Draw IO names on hover", &options.mDrawIONameOnHover);
    }

    return updated;
}

} // namespace


================================================
FILE: Source/External/imgui_tools/imguizmo/GraphEditor.h
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#pragma once

#include <vector>
#include <stdint.h>
#include <string>
#include "imgui.h"
#include "imgui_internal.h"

namespace GraphEditor {

typedef size_t NodeIndex;
typedef size_t SlotIndex;
typedef size_t LinkIndex;
typedef size_t TemplateIndex;

// Force the view to be respositionned and zoom to fit nodes with Show function.
// Parameter value will be changed to Fit_None by the function.
enum FitOnScreen
{
    Fit_None,
    Fit_AllNodes,
    Fit_SelectedNodes
};

// Display options and colors
struct Options
{
    ImRect mMinimap{{0.75f, 0.8f, 0.99f, 0.99f}}; // rectangle coordinates of minimap
    ImU32 mBackgroundColor{ IM_COL32(40, 40, 40, 255) }; // full background color
    ImU32 mGridColor{ IM_COL32(0, 0, 0, 60) }; // grid lines color
    ImU32 mGridColor2{ IM_COL32(0, 0, 0, 160) }; // grid lines color every 10th
    ImU32 mSelectedNodeBorderColor{ IM_COL32(255, 130, 30, 255) }; // node border color when it's selected
    ImU32 mNodeBorderColor{ IM_COL32(100, 100, 100, 0) }; // node border color when it's not selected
    ImU32 mQuadSelection{ IM_COL32(255, 32, 32, 64) }; // quad selection inside color
    ImU32 mQuadSelectionBorder{ IM_COL32(255, 32, 32, 255) }; // quad selection border color
    ImU32 mDefaultSlotColor{ IM_COL32(128, 128, 128, 255) }; // when no color is provided in node template, use this value
    ImU32 mFrameFocus{ IM_COL32(64, 128, 255, 255) }; // rectangle border when graph editor has focus
    float mLineThickness{ 5 }; // links width in pixels when zoom value is 1
    float mGridSize{ 64.f }; // background grid size in pixels when zoom value is 1
    float mRounding{ 3.f }; // rounding at node corners
    float mZoomRatio{ 0.1f }; // factor per mouse wheel delta
    float mZoomLerpFactor{ 0.25f }; // the smaller, the smoother
    float mBorderSelectionThickness{ 6.f }; // thickness of selection border around nodes
    float mBorderThickness{ 6.f }; // thickness of selection border around nodes
    float mNodeSlotRadius{ 8.f }; // circle radius for inputs and outputs
    float mNodeSlotHoverFactor{ 1.2f }; // increase size when hovering
    float mMinZoom{ 0.2f }, mMaxZoom { 1.1f };
    float mSnap{ 5.f };
    bool mDisplayLinksAsCurves{ true }; // false is straight and 45deg lines
    bool mAllowQuadSelection{ true }; // multiple selection using drag and drop
    bool mRenderGrid{ true }; // grid or nothing
    bool mDrawIONameOnHover{ true }; // only draw node input/output when hovering
};

// View state: scroll position and zoom factor
struct ViewState
{
    ImVec2 mPosition{0.0f, 0.0f}; // scroll position
    float mFactor{ 1.0f }; // current zoom factor
    float mFactorTarget{ 1.0f }; // targeted zoom factor interpolated using Options.mZoomLerpFactor
};

struct Template
{
    ImU32 mHeaderColor;
    ImU32 mBackgroundColor;
    ImU32 mBackgroundColorOver;
    ImU8 mInputCount;
    const char** mInputNames; // can be nullptr. No text displayed.
    ImU32* mInputColors; // can be nullptr, default slot color will be used.
    ImU8 mOutputCount;
    const char** mOutputNames; // can be nullptr. No text displayed.
    ImU32* mOutputColors; // can be nullptr, default slot color will be used.
};

struct Node
{
    const char* mName;
    TemplateIndex mTemplateIndex;
    ImRect mRect;
    bool mSelected{ false };
};

struct Link
{
    NodeIndex mInputNodeIndex;
    SlotIndex mInputSlotIndex;
    NodeIndex mOutputNodeIndex;
    SlotIndex mOutputSlotIndex;
};

struct Delegate
{
    virtual bool AllowedLink(NodeIndex from, NodeIndex to) = 0;

    virtual void SelectNode(NodeIndex nodeIndex, bool selected) = 0;
    virtual void MoveSelectedNodes(const ImVec2 delta) = 0;
    
    virtual void AddLink(NodeIndex inputNodeIndex, SlotIndex inputSlotIndex, NodeIndex outputNodeIndex, SlotIndex outputSlotIndex) = 0;
    virtual void DelLink(LinkIndex linkIndex) = 0;
    
    // user is responsible for clipping
    virtual void CustomDraw(ImDrawList* drawList, ImRect rectangle, NodeIndex nodeIndex) = 0;
    
    // use mouse position to open context menu
    // if nodeIndex != -1, right click happens on the specified node
    virtual void RightClick(NodeIndex nodeIndex, SlotIndex slotIndexInput, SlotIndex slotIndexOutput) = 0;

    virtual const size_t GetTemplateCount() = 0;
    virtual const Template GetTemplate(TemplateIndex index) = 0;

    virtual const size_t GetNodeCount() = 0;
    virtual const Node GetNode(NodeIndex index) = 0;
    
    virtual const size_t GetLinkCount() = 0;
    virtual const Link GetLink(LinkIndex index) = 0;
};

void Show(Delegate& delegate, const Options& options, ViewState& viewState, bool enabled, FitOnScreen* fit = nullptr);
void GraphEditorClear();

bool EditOptions(Options& options);

} // namespace


================================================
FILE: Source/External/imgui_tools/imguizmo/ImCurveEdit.cpp
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#include "ImCurveEdit.h"
#include "imgui.h"
#include "imgui_internal.h"
#include <stdint.h>
#include <set>
#include <vector>

#if defined(_MSC_VER) || defined(__MINGW32__)
#include <malloc.h>
#endif
#if !defined(_MSC_VER) && !defined(__MINGW64_VERSION_MAJOR)
#define _malloca(x) alloca(x)
#define _freea(x)
#endif

namespace ImCurveEdit
{

#ifndef IMGUI_DEFINE_MATH_OPERATORS
   static ImVec2 operator+(const ImVec2& a, const ImVec2& b) {
      return ImVec2(a.x + b.x, a.y + b.y);
   }

   static ImVec2 operator-(const ImVec2& a, const ImVec2& b) {
      return ImVec2(a.x - b.x, a.y - b.y);
   }

   static ImVec2 operator*(const ImVec2& a, const ImVec2& b) {
      return ImVec2(a.x * b.x, a.y * b.y);
   }

   static ImVec2 operator/(const ImVec2& a, const ImVec2& b) {
      return ImVec2(a.x / b.x, a.y / b.y);
   }

   static ImVec2 operator*(const ImVec2& a, const float b) {
      return ImVec2(a.x * b, a.y * b);
   }
#endif

   static float smoothstep(float edge0, float edge1, float x)
   {
      x = ImClamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
      return x * x * (3 - 2 * x);
   }

   static float distance(float x, float y, float x1, float y1, float x2, float y2)
   {
      float A = x - x1;
      float B = y - y1;
      float C = x2 - x1;
      float D = y2 - y1;

      float dot = A * C + B * D;
      float len_sq = C * C + D * D;
      float param = -1.f;
      if (len_sq > FLT_EPSILON)
         param = dot / len_sq;

      float xx, yy;

      if (param < 0.f) {
         xx = x1;
         yy = y1;
      }
      else if (param > 1.f) {
         xx = x2;
         yy = y2;
      }
      else {
         xx = x1 + param * C;
         yy = y1 + param * D;
      }

      float dx = x - xx;
      float dy = y - yy;
      return sqrtf(dx * dx + dy * dy);
   }

   static int DrawPoint(ImDrawList* draw_list, ImVec2 pos, const ImVec2 size, const ImVec2 offset, bool edited)
   {
      int ret = 0;
      ImGuiIO& io = ImGui::GetIO();

      static const ImVec2 localOffsets[4] = { ImVec2(1,0), ImVec2(0,1), ImVec2(-1,0), ImVec2(0,-1) };
      ImVec2 offsets[4];
      for (int i = 0; i < 4; i++)
      {
         offsets[i] = pos * size + localOffsets[i] * 4.5f + offset;
      }

      const ImVec2 center = pos * size + offset;
      const ImRect anchor(center - ImVec2(5, 5), center + ImVec2(5, 5));
      draw_list->AddConvexPolyFilled(offsets, 4, 0xFF000000);
      if (anchor.Contains(io.MousePos))
      {
         ret = 1;
         if (io.MouseDown[0])
            ret = 2;
      }
      if (edited)
         draw_list->AddPolyline(offsets, 4, 0xFFFFFFFF, true, 3.0f);
      else if (ret)
         draw_list->AddPolyline(offsets, 4, 0xFF80B0FF, true, 2.0f);
      else
         draw_list->AddPolyline(offsets, 4, 0xFF0080FF, true, 2.0f);

      return ret;
   }

   int Edit(Delegate& delegate, const ImVec2& size, unsigned int id, const ImRect* clippingRect, ImVector<EditPoint>* selectedPoints)
   {
      static bool selectingQuad = false;
      static ImVec2 quadSelection;
      static int overCurve = -1;
      static int movingCurve = -1;
      static bool scrollingV = false;
      static std::set<EditPoint> selection;
      static bool overSelectedPoint = false;

      int ret = 0;

      ImGuiIO& io = ImGui::GetIO();
      ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
      ImGui::PushStyleColor(ImGuiCol_Border, 0);
      ImGui::BeginChildFrame(id, size);
      delegate.focused = ImGui::IsWindowFocused();
      ImDrawList* draw_list = ImGui::GetWindowDrawList();
      if (clippingRect)
         draw_list->PushClipRect(clippingRect->Min, clippingRect->Max, true);

      const ImVec2 offset = ImGui::GetCursorScreenPos() + ImVec2(0.f, size.y);
      const ImVec2 ssize(size.x, -size.y);
      const ImRect container(offset + ImVec2(0.f, ssize.y), offset + ImVec2(ssize.x, 0.f));
      ImVec2& min = delegate.GetMin();
      ImVec2& max = delegate.GetMax();

      // handle zoom and VScroll
      if (container.Contains(io.MousePos))
      {
         if (fabsf(io.MouseWheel) > FLT_EPSILON)
         {
            const float r = (io.MousePos.y - offset.y) / ssize.y;
            float ratioY = ImLerp(min.y, max.y, r);
            auto scaleValue = [&](float v) {
               v -= ratioY;
               v *= (1.f - io.MouseWheel * 0.05f);
               v += ratioY;
               return v;
            };
            min.y = scaleValue(min.y);
            max.y = scaleValue(max.y);
         }
         if (!scrollingV && ImGui::IsMouseDown(2))
         {
            scrollingV = true;
         }
      }
      ImVec2 range = max - min + ImVec2(1.f, 0.f);  // +1 because of inclusive last frame

      const ImVec2 viewSize(size.x, -size.y);
      const ImVec2 sizeOfPixel = ImVec2(1.f, 1.f) / viewSize;
      const size_t curveCount = delegate.GetCurveCount();

      if (scrollingV)
      {
         float deltaH = io.MouseDelta.y * range.y * sizeOfPixel.y;
         min.y -= deltaH;
         max.y -= deltaH;
         if (!ImGui::IsMouseDown(2))
            scrollingV = false;
      }

      draw_list->AddRectFilled(offset, offset + ssize, delegate.GetBackgroundColor());

      auto pointToRange = [&](ImVec2 pt) { return (pt - min) / range; };
      auto rangeToPoint = [&](ImVec2 pt) { return (pt * range) + min; };

      draw_list->AddLine(ImVec2(-1.f, -min.y / range.y) * viewSize + offset, ImVec2(1.f, -min.y / range.y) * viewSize + offset, 0xFF000000, 1.5f);
      bool overCurveOrPoint = false;

      int localOverCurve = -1;
      // make sure highlighted curve is rendered last
      int* curvesIndex = (int*)_malloca(sizeof(int) * curveCount);
      for (size_t c = 0; c < curveCount; c++)
         curvesIndex[c] = int(c);
      int highLightedCurveIndex = -1;
      if (overCurve != -1 && curveCount)
      {
         ImSwap(curvesIndex[overCurve], curvesIndex[curveCount - 1]);
         highLightedCurveIndex = overCurve;
      }

      for (size_t cur = 0; cur < curveCount; cur++)
      {
         int c = curvesIndex[cur];
         if (!delegate.IsVisible(c))
            continue;
         const size_t ptCount = delegate.GetPointCount(c);
         if (ptCount < 1)
            continue;
         CurveType curveType = delegate.GetCurveType(c);
         if (curveType == CurveNone)
            continue;
         const ImVec2* pts = delegate.GetPoints(c);
         uint32_t curveColor = delegate.GetCurveColor(c);
         if ((c == highLightedCurveIndex && selection.empty() && !selectingQuad) || movingCurve == c)
            curveColor = 0xFFFFFFFF;

         for (size_t p = 0; p < ptCount - 1; p++)
         {
            const ImVec2 p1 = pointToRange(pts[p]);
            const ImVec2 p2 = pointToRange(pts[p + 1]);

            if (curveType == CurveSmooth || curveType == CurveLinear)
            {
               size_t subStepCount = (curveType == CurveSmooth) ? 20 : 2;
               float step = 1.f / float(subStepCount - 1);
               for (size_t substep = 0; substep < subStepCount - 1; substep++)
               {
                  float t = float(substep) * step;

                  const ImVec2 sp1 = ImLerp(p1, p2, t);
                  const ImVec2 sp2 = ImLerp(p1, p2, t + step);

                  const float rt1 = smoothstep(p1.x, p2.x, sp1.x);
                  const float rt2 = smoothstep(p1.x, p2.x, sp2.x);

                  const ImVec2 pos1 = ImVec2(sp1.x, ImLerp(p1.y, p2.y, rt1)) * viewSize + offset;
                  const ImVec2 pos2 = ImVec2(sp2.x, ImLerp(p1.y, p2.y, rt2)) * viewSize + offset;

                  if (distance(io.MousePos.x, io.MousePos.y, pos1.x, pos1.y, pos2.x, pos2.y) < 8.f && !scrollingV)
                  {
                     localOverCurve = int(c);
                     overCurve = int(c);
                     overCurveOrPoint = true;
                  }

                  draw_list->AddLine(pos1, pos2, curveColor, 1.3f);
               } // substep
            }
            else if (curveType == CurveDiscrete)
            {
               ImVec2 dp1 = p1 * viewSize + offset;
               ImVec2 dp2 = ImVec2(p2.x, p1.y) * viewSize + offset;
               ImVec2 dp3 = p2 * viewSize + offset;
               draw_list->AddLine(dp1, dp2, curveColor, 1.3f);
               draw_list->AddLine(dp2, dp3, curveColor, 1.3f);

               if ((distance(io.MousePos.x, io.MousePos.y, dp1.x, dp1.y, dp3.x, dp1.y) < 8.f ||
                  distance(io.MousePos.x, io.MousePos.y, dp3.x, dp1.y, dp3.x, dp3.y) < 8.f)
                  /*&& localOverCurve == -1*/)
               {
                  localOverCurve = int(c);
                  overCurve = int(c);
                  overCurveOrPoint = true;
               }
            }
         } // point loop

         for (size_t p = 0; p < ptCount; p++)
         {
            const int drawState = DrawPoint(draw_list, pointToRange(pts[p]), viewSize, offset, (selection.find({ int(c), int(p) }) != selection.end() && movingCurve == -1 && !scrollingV));
            if (drawState && movingCurve == -1 && !selectingQuad)
            {
               overCurveOrPoint = true;
               overSelectedPoint = true;
               overCurve = -1;
               if (drawState == 2)
               {
                  if (!io.KeyShift && selection.find({ int(c), int(p) }) == selection.end())
                     selection.clear();
                  selection.insert({ int(c), int(p) });
               }
            }
         }
      } // curves loop

      if (localOverCurve == -1)
         overCurve = -1;

      // move selection
      static bool pointsMoved = false;
      static ImVec2 mousePosOrigin;
      static std::vector<ImVec2> originalPoints;
      if (overSelectedPoint && io.MouseDown[0])
      {
         if ((fabsf(io.MouseDelta.x) > 0.f || fabsf(io.MouseDelta.y) > 0.f) && !selection.empty())
         {
            if (!pointsMoved)
            {
               delegate.BeginEdit(0);
               mousePosOrigin = io.MousePos;
               originalPoints.resize(selection.size());
               int index = 0;
               for (auto& sel : selection)
               {
                  const ImVec2* pts = delegate.GetPoints(sel.curveIndex);
                  originalPoints[index++] = pts[sel.pointIndex];
               }
            }
            pointsMoved = true;
            ret = 1;
            auto prevSelection = selection;
            int originalIndex = 0;
            for (auto& sel : prevSelection)
            {
               const ImVec2 p = rangeToPoint(pointToRange(originalPoints[originalIndex]) + (io.MousePos - mousePosOrigin) * sizeOfPixel);
               const int newIndex = delegate.EditPoint(sel.curveIndex, sel.pointIndex, p);
               if (newIndex != sel.pointIndex)
               {
                  selection.erase(sel);
                  selection.insert({ sel.curveIndex, newIndex });
               }
               originalIndex++;
            }
         }
      }

      if (overSelectedPoint && !io.MouseDown[0])
      {
         overSelectedPoint = false;
         if (pointsMoved)
         {
            pointsMoved = false;
            delegate.EndEdit();
         }
      }

      // add point
      if (overCurve != -1 && io.MouseDoubleClicked[0])
      {
         const ImVec2 np = rangeToPoint((io.MousePos - offset) / viewSize);
         delegate.BeginEdit(overCurve);
         delegate.AddPoint(overCurve, np);
         delegate.EndEdit();
         ret = 1;
      }

      // move curve

      if (movingCurve != -1)
      {
         const size_t ptCount = delegate.GetPointCount(movingCurve);
         const ImVec2* pts = delegate.GetPoints(movingCurve);
         if (!pointsMoved)
         {
            mousePosOrigin = io.MousePos;
            pointsMoved = true;
            originalPoints.resize(ptCount);
            for (size_t index = 0; index < ptCount; index++)
            {
               originalPoints[index] = pts[index];
            }
         }
         if (ptCount >= 1)
         {
            for (size_t p = 0; p < ptCount; p++)
            {
               delegate.EditPoint(movingCurve, int(p), rangeToPoint(pointToRange(originalPoints[p]) + (io.MousePos - mousePosOrigin) * sizeOfPixel));
            }
            ret = 1;
         }
         if (!io.MouseDown[0])
         {
            movingCurve = -1;
            pointsMoved = false;
            delegate.EndEdit();
         }
      }
      if (movingCurve == -1 && overCurve != -1 && ImGui::IsMouseClicked(0) && selection.empty() && !selectingQuad)
      {
         movingCurve = overCurve;
         delegate.BeginEdit(overCurve);
      }

      // quad selection
      if (selectingQuad)
      {
         const ImVec2 bmin = ImMin(quadSelection, io.MousePos);
         const ImVec2 bmax = ImMax(quadSelection, io.MousePos);
         draw_list->AddRectFilled(bmin, bmax, 0x40FF0000, 1.f);
         draw_list->AddRect(bmin, bmax, 0xFFFF0000, 1.f);
         const ImRect selectionQuad(bmin, bmax);
         if (!io.MouseDown[0])
         {
            if (!io.KeyShift)
               selection.clear();
            // select everythnig is quad
            for (size_t c = 0; c < curveCount; c++)
            {
               if (!delegate.IsVisible(c))
                  continue;

               const size_t ptCount = delegate.GetPointCount(c);
               if (ptCount < 1)
                  continue;

               const ImVec2* pts = delegate.GetPoints(c);
               for (size_t p = 0; p < ptCount; p++)
               {
                  const ImVec2 center = pointToRange(pts[p]) * viewSize + offset;
                  if (selectionQuad.Contains(center))
                     selection.insert({ int(c), int(p) });
               }
            }
            // done
            selectingQuad = false;
         }
      }
      if (!overCurveOrPoint && ImGui::IsMouseClicked(0) && !selectingQuad && movingCurve == -1 && !overSelectedPoint && container.Contains(io.MousePos))
      {
         selectingQuad = true;
         quadSelection = io.MousePos;
      }
      if (clippingRect)
         draw_list->PopClipRect();

      ImGui::EndChildFrame();
      ImGui::PopStyleVar();
      ImGui::PopStyleColor(1);

      if (selectedPoints)
      {
         selectedPoints->resize(int(selection.size()));
         int index = 0;
         for (auto& point : selection)
            (*selectedPoints)[index++] = point;
      }
      return ret;
   }
}


================================================
FILE: Source/External/imgui_tools/imguizmo/ImCurveEdit.h
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#pragma once
#include <stdint.h>
#include "imgui.h"

struct ImRect;

namespace ImCurveEdit
{
   enum CurveType
   {
      CurveNone,
      CurveDiscrete,
      CurveLinear,
      CurveSmooth,
      CurveBezier,
   };

   struct EditPoint
   {
      int curveIndex;
      int pointIndex;
      bool operator <(const EditPoint& other) const
      {
         if (curveIndex < other.curveIndex)
            return true;
         if (curveIndex > other.curveIndex)
            return false;

         if (pointIndex < other.pointIndex)
            return true;
         return false;
      }
   };

   struct Delegate
   {
      bool focused = false;
      virtual size_t GetCurveCount() = 0;
      virtual bool IsVisible(size_t /*curveIndex*/) { return true; }
      virtual CurveType GetCurveType(size_t /*curveIndex*/) const { return CurveLinear; }
      virtual ImVec2& GetMin() = 0;
      virtual ImVec2& GetMax() = 0;
      virtual size_t GetPointCount(size_t curveIndex) = 0;
      virtual uint32_t GetCurveColor(size_t curveIndex) = 0;
      virtual ImVec2* GetPoints(size_t curveIndex) = 0;
      virtual int EditPoint(size_t curveIndex, int pointIndex, ImVec2 value) = 0;
      virtual void AddPoint(size_t curveIndex, ImVec2 value) = 0;
      virtual unsigned int GetBackgroundColor() { return 0xFF202020; }
      // handle undo/redo thru this functions
      virtual void BeginEdit(int /*index*/) {}
      virtual void EndEdit() {}
   };

   int Edit(Delegate& delegate, const ImVec2& size, unsigned int id, const ImRect* clippingRect = NULL, ImVector<EditPoint>* selectedPoints = NULL);
}


================================================
FILE: Source/External/imgui_tools/imguizmo/ImGradient.cpp
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#include "ImGradient.h"
#include "imgui.h"
#include "imgui_internal.h"

namespace ImGradient
{
#ifndef IMGUI_DEFINE_MATH_OPERATORS
   static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x * rhs, lhs.y * rhs); }
   static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x / rhs, lhs.y / rhs); }
   static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x + rhs.x, lhs.y + rhs.y); }
   static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x - rhs.x, lhs.y - rhs.y); }
   static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
   static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x / rhs.x, lhs.y / rhs.y); }
#endif

   static int DrawPoint(ImDrawList* draw_list, ImVec4 color, const ImVec2 size, bool editing, ImVec2 pos)
   {
      ImGuiIO& io = ImGui::GetIO();

      ImVec2 p1 = ImLerp(pos, ImVec2(pos + ImVec2(size.x - size.y, 0.f)), color.w) + ImVec2(3, 3);
      ImVec2 p2 = ImLerp(pos + ImVec2(size.y, size.y), ImVec2(pos + size), color.w) - ImVec2(3, 3);
      ImRect rc(p1, p2);

      color.w = 1.f;
      draw_list->AddRectFilled(p1, p2, ImColor(color));
      if (editing)
         draw_list->AddRect(p1, p2, 0xFFFFFFFF, 2.f, 15, 2.5f);
      else
         draw_list->AddRect(p1, p2, 0x80FFFFFF, 2.f, 15, 1.25f);

      if (rc.Contains(io.MousePos))
      {
         if (io.MouseClicked[0])
            return 2;
         return 1;
      }
      return 0;
   }

   bool Edit(Delegate& delegate, const ImVec2& size, int& selection)
   {
      bool ret = false;
      ImGuiIO& io = ImGui::GetIO();
      ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
      ImGui::BeginChildFrame(137, size);

      ImDrawList* draw_list = ImGui::GetWindowDrawList();
      const ImVec2 offset = ImGui::GetCursorScreenPos();

      const ImVec4* pts = delegate.GetPoints();
      static int currentSelection = -1;
      static int movingPt = -1;
      if (currentSelection >= int(delegate.GetPointCount()))
         currentSelection = -1;
      if (movingPt != -1)
      {
         ImVec4 current = pts[movingPt];
         current.w += io.MouseDelta.x / size.x;
         current.w = ImClamp(current.w, 0.f, 1.f);
         delegate.EditPoint(movingPt, current);
         ret = true;
         if (!io.MouseDown[0])
            movingPt = -1;
      }
      for (size_t i = 0; i < delegate.GetPointCount(); i++)
      {
         int ptSel = DrawPoint(draw_list, pts[i], size, i == currentSelection, offset);
         if (ptSel == 2)
         {
            currentSelection = int(i);
            ret = true;
         }
         if (ptSel == 1 && io.MouseDown[0] && movingPt == -1)
         {
            movingPt = int(i);
         }
      }
      ImRect rc(offset, offset + size);
      if (rc.Contains(io.MousePos) && io.MouseDoubleClicked[0])
      {
         float t = (io.MousePos.x - offset.x) / size.x;
         delegate.AddPoint(delegate.GetPoint(t));
         ret = true;
      }
      ImGui::EndChildFrame();
      ImGui::PopStyleVar();

      selection = currentSelection;
      return ret;
   }
}


================================================
FILE: Source/External/imgui_tools/imguizmo/ImGradient.h
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#pragma once
#include <cstddef>

struct ImVec4;
struct ImVec2;

namespace ImGradient
{
   struct Delegate
   {
      virtual size_t GetPointCount() = 0;
      virtual ImVec4* GetPoints() = 0;
      virtual int EditPoint(int pointIndex, ImVec4 value) = 0;
      virtual ImVec4 GetPoint(float t) = 0;
      virtual void AddPoint(ImVec4 value) = 0;
   };

   bool Edit(Delegate& delegate, const ImVec2& size, int& selection);
}


================================================
FILE: Source/External/imgui_tools/imguizmo/ImGuizmo.cpp
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//

#ifndef IMGUI_DEFINE_MATH_OPERATORS
#define IMGUI_DEFINE_MATH_OPERATORS
#endif
#include "imgui.h"
#include "imgui_internal.h"
#include "ImGuizmo.h"

#if defined(_MSC_VER) || defined(__MINGW32__)
#include <malloc.h>
#endif
#if !defined(_MSC_VER) && !defined(__MINGW64_VERSION_MAJOR)
#define _malloca(x) alloca(x)
#define _freea(x)
#endif

// includes patches for multiview from
// https://github.com/CedricGuillemet/ImGuizmo/issues/15

namespace IMGUIZMO_NAMESPACE
{
   static const float ZPI = 3.14159265358979323846f;
   static const float RAD2DEG = (180.f / ZPI);
   static const float DEG2RAD = (ZPI / 180.f);
   const float screenRotateSize = 0.06f;
   // scale a bit so translate axis do not touch when in universal
   const float rotationDisplayFactor = 1.2f;

   static OPERATION operator&(OPERATION lhs, OPERATION rhs)
   {
     return static_cast<OPERATION>(static_cast<int>(lhs) & static_cast<int>(rhs));
   }

   static bool operator!=(OPERATION lhs, int rhs)
   {
     return static_cast<int>(lhs) != rhs;
   }

   static bool Intersects(OPERATION lhs, OPERATION rhs)
   {
     return (lhs & rhs) != 0;
   }

   // True if lhs contains rhs
   static bool Contains(OPERATION lhs, OPERATION rhs)
   {
     return (lhs & rhs) == rhs;
   }

   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   // utility and math

   void FPU_MatrixF_x_MatrixF(const float* a, const float* b, float* r)
   {
      r[0] = a[0] * b[0] + a[1] * b[4] + a[2] * b[8] + a[3] * b[12];
      r[1] = a[0] * b[1] + a[1] * b[5] + a[2] * b[9] + a[3] * b[13];
      r[2] = a[0] * b[2] + a[1] * b[6] + a[2] * b[10] + a[3] * b[14];
      r[3] = a[0] * b[3] + a[1] * b[7] + a[2] * b[11] + a[3] * b[15];

      r[4] = a[4] * b[0] + a[5] * b[4] + a[6] * b[8] + a[7] * b[12];
      r[5] = a[4] * b[1] + a[5] * b[5] + a[6] * b[9] + a[7] * b[13];
      r[6] = a[4] * b[2] + a[5] * b[6] + a[6] * b[10] + a[7] * b[14];
      r[7] = a[4] * b[3] + a[5] * b[7] + a[6] * b[11] + a[7] * b[15];

      r[8] = a[8] * b[0] + a[9] * b[4] + a[10] * b[8] + a[11] * b[12];
      r[9] = a[8] * b[1] + a[9] * b[5] + a[10] * b[9] + a[11] * b[13];
      r[10] = a[8] * b[2] + a[9] * b[6] + a[10] * b[10] + a[11] * b[14];
      r[11] = a[8] * b[3] + a[9] * b[7] + a[10] * b[11] + a[11] * b[15];

      r[12] = a[12] * b[0] + a[13] * b[4] + a[14] * b[8] + a[15] * b[12];
      r[13] = a[12] * b[1] + a[13] * b[5] + a[14] * b[9] + a[15] * b[13];
      r[14] = a[12] * b[2] + a[13] * b[6] + a[14] * b[10] + a[15] * b[14];
      r[15] = a[12] * b[3] + a[13] * b[7] + a[14] * b[11] + a[15] * b[15];
   }

   void Frustum(float left, float right, float bottom, float top, float znear, float zfar, float* m16)
   {
      float temp, temp2, temp3, temp4;
      temp = 2.0f * znear;
      temp2 = right - left;
      temp3 = top - bottom;
      temp4 = zfar - znear;
      m16[0] = temp / temp2;
      m16[1] = 0.0;
      m16[2] = 0.0;
      m16[3] = 0.0;
      m16[4] = 0.0;
      m16[5] = temp / temp3;
      m16[6] = 0.0;
      m16[7] = 0.0;
      m16[8] = (right + left) / temp2;
      m16[9] = (top + bottom) / temp3;
      m16[10] = (-zfar - znear) / temp4;
      m16[11] = -1.0f;
      m16[12] = 0.0;
      m16[13] = 0.0;
      m16[14] = (-temp * zfar) / temp4;
      m16[15] = 0.0;
   }

   void Perspective(float fovyInDegrees, float aspectRatio, float znear, float zfar, float* m16)
   {
      float ymax, xmax;
      ymax = znear * tanf(fovyInDegrees * DEG2RAD);
      xmax = ymax * aspectRatio;
      Frustum(-xmax, xmax, -ymax, ymax, znear, zfar, m16);
   }

   void Cross(const float* a, const float* b, float* r)
   {
      r[0] = a[1] * b[2] - a[2] * b[1];
      r[1] = a[2] * b[0] - a[0] * b[2];
      r[2] = a[0] * b[1] - a[1] * b[0];
   }

   float Dot(const float* a, const float* b)
   {
      return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
   }

   void Normalize(const float* a, float* r)
   {
      float il = 1.f / (sqrtf(Dot(a, a)) + FLT_EPSILON);
      r[0] = a[0] * il;
      r[1] = a[1] * il;
      r[2] = a[2] * il;
   }

   void LookAt(const float* eye, const float* at, const float* up, float* m16)
   {
      float X[3], Y[3], Z[3], tmp[3];

      tmp[0] = eye[0] - at[0];
      tmp[1] = eye[1] - at[1];
      tmp[2] = eye[2] - at[2];
      Normalize(tmp, Z);
      Normalize(up, Y);
      Cross(Y, Z, tmp);
      Normalize(tmp, X);
      Cross(Z, X, tmp);
      Normalize(tmp, Y);

      m16[0] = X[0];
      m16[1] = Y[0];
      m16[2] = Z[0];
      m16[3] = 0.0f;
      m16[4] = X[1];
      m16[5] = Y[1];
      m16[6] = Z[1];
      m16[7] = 0.0f;
      m16[8] = X[2];
      m16[9] = Y[2];
      m16[10] = Z[2];
      m16[11] = 0.0f;
      m16[12] = -Dot(X, eye);
      m16[13] = -Dot(Y, eye);
      m16[14] = -Dot(Z, eye);
      m16[15] = 1.0f;
   }

   template <typename T> T Clamp(T x, T y, T z) { return ((x < y) ? y : ((x > z) ? z : x)); }
   template <typename T> T max(T x, T y) { return (x > y) ? x : y; }
   template <typename T> T min(T x, T y) { return (x < y) ? x : y; }
   template <typename T> bool IsWithin(T x, T y, T z) { return (x >= y) && (x <= z); }

   struct matrix_t;
   struct vec_t
   {
   public:
      float x, y, z, w;

      void Lerp(const vec_t& v, float t)
      {
         x += (v.x - x) * t;
         y += (v.y - y) * t;
         z += (v.z - z) * t;
         w += (v.w - w) * t;
      }

      void Set(float v) { x = y = z = w = v; }
      void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _x; y = _y; z = _z; w = _w; }

      vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; w -= v.w; return *this; }
      vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; w += v.w; return *this; }
      vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; w *= v.w; return *this; }
      vec_t& operator *= (float v) { x *= v;    y *= v;    z *= v;    w *= v;    return *this; }

      vec_t operator * (float f) const;
      vec_t operator - () const;
      vec_t operator - (const vec_t& v) const;
      vec_t operator + (const vec_t& v) const;
      vec_t operator * (const vec_t& v) const;

      const vec_t& operator + () const { return (*this); }
      float Length() const { return sqrtf(x * x + y * y + z * z); };
      float LengthSq() const { return (x * x + y * y + z * z); };
      vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Length() : FLT_EPSILON ) ); return (*this); }
      vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); this->Normalize(); return (*this); }
      vec_t Abs() const;

      void Cross(const vec_t& v)
      {
         vec_t res;
         res.x = y * v.z - z * v.y;
         res.y = z * v.x - x * v.z;
         res.z = x * v.y - y * v.x;

         x = res.x;
         y = res.y;
         z = res.z;
         w = 0.f;
      }

      void Cross(const vec_t& v1, const vec_t& v2)
      {
         x = v1.y * v2.z - v1.z * v2.y;
         y = v1.z * v2.x - v1.x * v2.z;
         z = v1.x * v2.y - v1.y * v2.x;
         w = 0.f;
      }

      float Dot(const vec_t& v) const
      {
         return (x * v.x) + (y * v.y) + (z * v.z) + (w * v.w);
      }

      float Dot3(const vec_t& v) const
      {
         return (x * v.x) + (y * v.y) + (z * v.z);
      }

      void Transform(const matrix_t& matrix);
      void Transform(const vec_t& s, const matrix_t& matrix);

      void TransformVector(const matrix_t& matrix);
      void TransformPoint(const matrix_t& matrix);
      void TransformVector(const vec_t& v, const matrix_t& matrix) { (*this) = v; this->TransformVector(matrix); }
      void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this) = v; this->TransformPoint(matrix); }

      float& operator [] (size_t index) { return ((float*)&x)[index]; }
      const float& operator [] (size_t index) const { return ((float*)&x)[index]; }
      bool operator!=(const vec_t& other) const { return memcmp(this, &other, sizeof(vec_t)) != 0; }
   };

   vec_t makeVect(float _x, float _y, float _z = 0.f, float _w = 0.f) { vec_t res; res.x = _x; res.y = _y; res.z = _z; res.w = _w; return res; }
   vec_t makeVect(ImVec2 v) { vec_t res; res.x = v.x; res.y = v.y; res.z = 0.f; res.w = 0.f; return res; }
   vec_t vec_t::operator * (float f) const { return makeVect(x * f, y * f, z * f, w * f); }
   vec_t vec_t::operator - () const { return makeVect(-x, -y, -z, -w); }
   vec_t vec_t::operator - (const vec_t& v) const { return makeVect(x - v.x, y - v.y, z - v.z, w - v.w); }
   vec_t vec_t::operator + (const vec_t& v) const { return makeVect(x + v.x, y + v.y, z + v.z, w + v.w); }
   vec_t vec_t::operator * (const vec_t& v) const { return makeVect(x * v.x, y * v.y, z * v.z, w * v.w); }
   vec_t vec_t::Abs() const { return makeVect(fabsf(x), fabsf(y), fabsf(z)); }

   vec_t Normalized(const vec_t& v) { vec_t res; res = v; res.Normalize(); return res; }
   vec_t Cross(const vec_t& v1, const vec_t& v2)
   {
      vec_t res;
      res.x = v1.y * v2.z - v1.z * v2.y;
      res.y = v1.z * v2.x - v1.x * v2.z;
      res.z = v1.x * v2.y - v1.y * v2.x;
      res.w = 0.f;
      return res;
   }

   float Dot(const vec_t& v1, const vec_t& v2)
   {
      return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
   }

   vec_t BuildPlan(const vec_t& p_point1, const vec_t& p_normal)
   {
      vec_t normal, res;
      normal.Normalize(p_normal);
      res.w = normal.Dot(p_point1);
      res.x = normal.x;
      res.y = normal.y;
      res.z = normal.z;
      return res;
   }

   struct matrix_t
   {
   public:

      union
      {
         float m[4][4];
         float m16[16];
         struct
         {
            vec_t right, up, dir, position;
         } v;
         vec_t component[4];
      };

      operator float* () { return m16; }
      operator const float* () const { return m16; }
      void Translation(float _x, float _y, float _z) { this->Translation(makeVect(_x, _y, _z)); }

      void Translation(const vec_t& vt)
      {
         v.right.Set(1.f, 0.f, 0.f, 0.f);
         v.up.Set(0.f, 1.f, 0.f, 0.f);
         v.dir.Set(0.f, 0.f, 1.f, 0.f);
         v.position.Set(vt.x, vt.y, vt.z, 1.f);
      }

      void Scale(float _x, float _y, float _z)
      {
         v.right.Set(_x, 0.f, 0.f, 0.f);
         v.up.Set(0.f, _y, 0.f, 0.f);
         v.dir.Set(0.f, 0.f, _z, 0.f);
         v.position.Set(0.f, 0.f, 0.f, 1.f);
      }
      void Scale(const vec_t& s) { Scale(s.x, s.y, s.z); }

      matrix_t& operator *= (const matrix_t& mat)
      {
         matrix_t tmpMat;
         tmpMat = *this;
         tmpMat.Multiply(mat);
         *this = tmpMat;
         return *this;
      }
      matrix_t operator * (const matrix_t& mat) const
      {
         matrix_t matT;
         matT.Multiply(*this, mat);
         return matT;
      }

      void Multiply(const matrix_t& matrix)
      {
         matrix_t tmp;
         tmp = *this;

         FPU_MatrixF_x_MatrixF((float*)&tmp, (float*)&matrix, (float*)this);
      }

      void Multiply(const matrix_t& m1, const matrix_t& m2)
      {
         FPU_MatrixF_x_MatrixF((float*)&m1, (float*)&m2, (float*)this);
      }

      float GetDeterminant() const
      {
         return m[0][0] * m[1][1] * m[2][2] + m[0][1] * m[1][2] * m[2][0] + m[0][2] * m[1][0] * m[2][1] -
            m[0][2] * m[1][1] * m[2][0] - m[0][1] * m[1][0] * m[2][2] - m[0][0] * m[1][2] * m[2][1];
      }

      float Inverse(const matrix_t& srcMatrix, bool affine = false);
      void SetToIdentity()
      {
         v.right.Set(1.f, 0.f, 0.f, 0.f);
         v.up.Set(0.f, 1.f, 0.f, 0.f);
         v.dir.Set(0.f, 0.f, 1.f, 0.f);
         v.position.Set(0.f, 0.f, 0.f, 1.f);
      }
      void Transpose()
      {
         matrix_t tmpm;
         for (int l = 0; l < 4; l++)
         {
            for (int c = 0; c < 4; c++)
            {
               tmpm.m[l][c] = m[c][l];
            }
         }
         (*this) = tmpm;
      }

      void RotationAxis(const vec_t& axis, float angle);

      void OrthoNormalize()
      {
         v.right.Normalize();
         v.up.Normalize();
         v.dir.Normalize();
      }
   };

   void vec_t::Transform(const matrix_t& matrix)
   {
      vec_t out;

      out.x = x * matrix.m[0][0] + y * matrix.m[1][0] + z * matrix.m[2][0] + w * matrix.m[3][0];
      out.y = x * matrix.m[0][1] + y * matrix.m[1][1] + z * matrix.m[2][1] + w * matrix.m[3][1];
      out.z = x * matrix.m[0][2] + y * matrix.m[1][2] + z * matrix.m[2][2] + w * matrix.m[3][2];
      out.w = x * matrix.m[0][3] + y * matrix.m[1][3] + z * matrix.m[2][3] + w * matrix.m[3][3];

      x = out.x;
      y = out.y;
      z = out.z;
      w = out.w;
   }

   void vec_t::Transform(const vec_t& s, const matrix_t& matrix)
   {
      *this = s;
      Transform(matrix);
   }

   void vec_t::TransformPoint(const matrix_t& matrix)
   {
      vec_t out;

      out.x = x * matrix.m[0][0] + y * matrix.m[1][0] + z * matrix.m[2][0] + matrix.m[3][0];
      out.y = x * matrix.m[0][1] + y * matrix.m[1][1] + z * matrix.m[2][1] + matrix.m[3][1];
      out.z = x * matrix.m[0][2] + y * matrix.m[1][2] + z * matrix.m[2][2] + matrix.m[3][2];
      out.w = x * matrix.m[0][3] + y * matrix.m[1][3] + z * matrix.m[2][3] + matrix.m[3][3];

      x = out.x;
      y = out.y;
      z = out.z;
      w = out.w;
   }

   void vec_t::TransformVector(const matrix_t& matrix)
   {
      vec_t out;

      out.x = x * matrix.m[0][0] + y * matrix.m[1][0] + z * matrix.m[2][0];
      out.y = x * matrix.m[0][1] + y * matrix.m[1][1] + z * matrix.m[2][1];
      out.z = x * matrix.m[0][2] + y * matrix.m[1][2] + z * matrix.m[2][2];
      out.w = x * matrix.m[0][3] + y * matrix.m[1][3] + z * matrix.m[2][3];

      x = out.x;
      y = out.y;
      z = out.z;
      w = out.w;
   }

   float matrix_t::Inverse(const matrix_t& srcMatrix, bool affine)
   {
      float det = 0;

      if (affine)
      {
         det = GetDeterminant();
         float s = 1 / det;
         m[0][0] = (srcMatrix.m[1][1] * srcMatrix.m[2][2] - srcMatrix.m[1][2] * srcMatrix.m[2][1]) * s;
         m[0][1] = (srcMatrix.m[2][1] * srcMatrix.m[0][2] - srcMatrix.m[2][2] * srcMatrix.m[0][1]) * s;
         m[0][2] = (srcMatrix.m[0][1] * srcMatrix.m[1][2] - srcMatrix.m[0][2] * srcMatrix.m[1][1]) * s;
         m[1][0] = (srcMatrix.m[1][2] * srcMatrix.m[2][0] - srcMatrix.m[1][0] * srcMatrix.m[2][2]) * s;
         m[1][1] = (srcMatrix.m[2][2] * srcMatrix.m[0][0] - srcMatrix.m[2][0] * srcMatrix.m[0][2]) * s;
         m[1][2] = (srcMatrix.m[0][2] * srcMatrix.m[1][0] - srcMatrix.m[0][0] * srcMatrix.m[1][2]) * s;
         m[2][0] = (srcMatrix.m[1][0] * srcMatrix.m[2][1] - srcMatrix.m[1][1] * srcMatrix.m[2][0]) * s;
         m[2][1] = (srcMatrix.m[2][0] * srcMatrix.m[0][1] - srcMatrix.m[2][1] * srcMatrix.m[0][0]) * s;
         m[2][2] = (srcMatrix.m[0][0] * srcMatrix.m[1][1] - srcMatrix.m[0][1] * srcMatrix.m[1][0]) * s;
         m[3][0] = -(m[0][0] * srcMatrix.m[3][0] + m[1][0] * srcMatrix.m[3][1] + m[2][0] * srcMatrix.m[3][2]);
         m[3][1] = -(m[0][1] * srcMatrix.m[3][0] + m[1][1] * srcMatrix.m[3][1] + m[2][1] * srcMatrix.m[3][2]);
         m[3][2] = -(m[0][2] * srcMatrix.m[3][0] + m[1][2] * srcMatrix.m[3][1] + m[2][2] * srcMatrix.m[3][2]);
      }
      else
      {
         // transpose matrix
         float src[16];
         for (int i = 0; i < 4; ++i)
         {
            src[i] = srcMatrix.m16[i * 4];
            src[i + 4] = srcMatrix.m16[i * 4 + 1];
            src[i + 8] = srcMatrix.m16[i * 4 + 2];
            src[i + 12] = srcMatrix.m16[i * 4 + 3];
         }

         // calculate pairs for first 8 elements (cofactors)
         float tmp[12]; // temp array for pairs
         tmp[0] = src[10] * src[15];
         tmp[1] = src[11] * src[14];
         tmp[2] = src[9] * src[15];
         tmp[3] = src[11] * src[13];
         tmp[4] = src[9] * src[14];
         tmp[5] = src[10] * src[13];
         tmp[6] = src[8] * src[15];
         tmp[7] = src[11] * src[12];
         tmp[8] = src[8] * src[14];
         tmp[9] = src[10] * src[12];
         tmp[10] = src[8] * src[13];
         tmp[11] = src[9] * src[12];

         // calculate first 8 elements (cofactors)
         m16[0] = (tmp[0] * src[5] + tmp[3] * src[6] + tmp[4] * src[7]) - (tmp[1] * src[5] + tmp[2] * src[6] + tmp[5] * src[7]);
         m16[1] = (tmp[1] * src[4] + tmp[6] * src[6] + tmp[9] * src[7]) - (tmp[0] * src[4] + tmp[7] * src[6] + tmp[8] * src[7]);
         m16[2] = (tmp[2] * src[4] + tmp[7] * src[5] + tmp[10] * src[7]) - (tmp[3] * src[4] + tmp[6] * src[5] + tmp[11] * src[7]);
         m16[3] = (tmp[5] * src[4] + tmp[8] * src[5] + tmp[11] * src[6]) - (tmp[4] * src[4] + tmp[9] * src[5] + tmp[10] * src[6]);
         m16[4] = (tmp[1] * src[1] + tmp[2] * src[2] + tmp[5] * src[3]) - (tmp[0] * src[1] + tmp[3] * src[2] + tmp[4] * src[3]);
         m16[5] = (tmp[0] * src[0] + tmp[7] * src[2] + tmp[8] * src[3]) - (tmp[1] * src[0] + tmp[6] * src[2] + tmp[9] * src[3]);
         m16[6] = (tmp[3] * src[0] + tmp[6] * src[1] + tmp[11] * src[3]) - (tmp[2] * src[0] + tmp[7] * src[1] + tmp[10] * src[3]);
         m16[7] = (tmp[4] * src[0] + tmp[9] * src[1] + tmp[10] * src[2]) - (tmp[5] * src[0] + tmp[8] * src[1] + tmp[11] * src[2]);

         // calculate pairs for second 8 elements (cofactors)
         tmp[0] = src[2] * src[7];
         tmp[1] = src[3] * src[6];
         tmp[2] = src[1] * src[7];
         tmp[3] = src[3] * src[5];
         tmp[4] = src[1] * src[6];
         tmp[5] = src[2] * src[5];
         tmp[6] = src[0] * src[7];
         tmp[7] = src[3] * src[4];
         tmp[8] = src[0] * src[6];
         tmp[9] = src[2] * src[4];
         tmp[10] = src[0] * src[5];
         tmp[11] = src[1] * src[4];

         // calculate second 8 elements (cofactors)
         m16[8] = (tmp[0] * src[13] + tmp[3] * src[14] + tmp[4] * src[15]) - (tmp[1] * src[13] + tmp[2] * src[14] + tmp[5] * src[15]);
         m16[9] = (tmp[1] * src[12] + tmp[6] * src[14] + tmp[9] * src[15]) - (tmp[0] * src[12] + tmp[7] * src[14] + tmp[8] * src[15]);
         m16[10] = (tmp[2] * src[12] + tmp[7] * src[13] + tmp[10] * src[15]) - (tmp[3] * src[12] + tmp[6] * src[13] + tmp[11] * src[15]);
         m16[11] = (tmp[5] * src[12] + tmp[8] * src[13] + tmp[11] * src[14]) - (tmp[4] * src[12] + tmp[9] * src[13] + tmp[10] * src[14]);
         m16[12] = (tmp[2] * src[10] + tmp[5] * src[11] + tmp[1] * src[9]) - (tmp[4] * src[11] + tmp[0] * src[9] + tmp[3] * src[10]);
         m16[13] = (tmp[8] * src[11] + tmp[0] * src[8] + tmp[7] * src[10]) - (tmp[6] * src[10] + tmp[9] * src[11] + tmp[1] * src[8]);
         m16[14] = (tmp[6] * src[9] + tmp[11] * src[11] + tmp[3] * src[8]) - (tmp[10] * src[11] + tmp[2] * src[8] + tmp[7] * src[9]);
         m16[15] = (tmp[10] * src[10] + tmp[4] * src[8] + tmp[9] * src[9]) - (tmp[8] * src[9] + tmp[11] * src[10] + tmp[5] * src[8]);

         // calculate determinant
         det = src[0] * m16[0] + src[1] * m16[1] + src[2] * m16[2] + src[3] * m16[3];

         // calculate matrix inverse
         float invdet = 1 / det;
         for (int j = 0; j < 16; ++j)
         {
            m16[j] *= invdet;
         }
      }

      return det;
   }

   void matrix_t::RotationAxis(const vec_t& axis, float angle)
   {
      float length2 = axis.LengthSq();
      if (length2 < FLT_EPSILON)
      {
         SetToIdentity();
         return;
      }

      vec_t n = axis * (1.f / sqrtf(length2));
      float s = sinf(angle);
      float c = cosf(angle);
      float k = 1.f - c;

      float xx = n.x * n.x * k + c;
      float yy = n.y * n.y * k + c;
      float zz = n.z * n.z * k + c;
      float xy = n.x * n.y * k;
      float yz = n.y * n.z * k;
      float zx = n.z * n.x * k;
      float xs = n.x * s;
      float ys = n.y * s;
      float zs = n.z * s;

      m[0][0] = xx;
      m[0][1] = xy + zs;
      m[0][2] = zx - ys;
      m[0][3] = 0.f;
      m[1][0] = xy - zs;
      m[1][1] = yy;
      m[1][2] = yz + xs;
      m[1][3] = 0.f;
      m[2][0] = zx + ys;
      m[2][1] = yz - xs;
      m[2][2] = zz;
      m[2][3] = 0.f;
      m[3][0] = 0.f;
      m[3][1] = 0.f;
      m[3][2] = 0.f;
      m[3][3] = 1.f;
   }

   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   //

   enum MOVETYPE
   {
      MT_NONE,
      MT_MOVE_X,
      MT_MOVE_Y,
      MT_MOVE_Z,
      MT_MOVE_YZ,
      MT_MOVE_ZX,
      MT_MOVE_XY,
      MT_MOVE_SCREEN,
      MT_ROTATE_X,
      MT_ROTATE_Y,
      MT_ROTATE_Z,
      MT_ROTATE_SCREEN,
      MT_SCALE_X,
      MT_SCALE_Y,
      MT_SCALE_Z,
      MT_SCALE_XYZ
   };

   static bool IsTranslateType(int type)
   {
     return type >= MT_MOVE_X && type <= MT_MOVE_SCREEN;
   }

   static bool IsRotateType(int type)
   {
     return type >= MT_ROTATE_X && type <= MT_ROTATE_SCREEN;
   }

   static bool IsScaleType(int type)
   {
     return type >= MT_SCALE_X && type <= MT_SCALE_XYZ;
   }

   // Matches MT_MOVE_AB order
   static const OPERATION TRANSLATE_PLANS[3] = { TRANSLATE_Y | TRANSLATE_Z, TRANSLATE_X | TRANSLATE_Z, TRANSLATE_X | TRANSLATE_Y };

   Style::Style()
   {
      // default values
      TranslationLineThickness   = 3.0f;
      TranslationLineArrowSize   = 6.0f;
      RotationLineThickness      = 2.0f;
      RotationOuterLineThickness = 3.0f;
      ScaleLineThickness         = 3.0f;
      ScaleLineCircleSize        = 6.0f;
      HatchedAxisLineThickness   = 6.0f;
      CenterCircleSize           = 6.0f;

      // initialize default colors
      Colors[DIRECTION_X]           = ImVec4(0.666f, 0.000f, 0.000f, 1.000f);
      Colors[DIRECTION_Y]           = ImVec4(0.000f, 0.666f, 0.000f, 1.000f);
      Colors[DIRECTION_Z]           = ImVec4(0.000f, 0.000f, 0.666f, 1.000f);
      Colors[PLANE_X]               = ImVec4(0.666f, 0.000f, 0.000f, 0.380f);
      Colors[PLANE_Y]               = ImVec4(0.000f, 0.666f, 0.000f, 0.380f);
      Colors[PLANE_Z]               = ImVec4(0.000f, 0.000f, 0.666f, 0.380f);
      Colors[SELECTION]             = ImVec4(1.000f, 0.500f, 0.062f, 0.541f);
      Colors[INACTIVE]              = ImVec4(0.600f, 0.600f, 0.600f, 0.600f);
      Colors[TRANSLATION_LINE]      = ImVec4(0.666f, 0.666f, 0.666f, 0.666f);
      Colors[SCALE_LINE]            = ImVec4(0.250f, 0.250f, 0.250f, 1.000f);
      Colors[ROTATION_USING_BORDER] = ImVec4(1.000f, 0.500f, 0.062f, 1.000f);
      Colors[ROTATION_USING_FILL]   = ImVec4(1.000f, 0.500f, 0.062f, 0.500f);
      Colors[HATCHED_AXIS_LINES]    = ImVec4(0.000f, 0.000f, 0.000f, 0.500f);
      Colors[TEXT]                  = ImVec4(1.000f, 1.000f, 1.000f, 1.000f);
      Colors[TEXT_SHADOW]           = ImVec4(0.000f, 0.000f, 0.000f, 1.000f);
   }

   struct Context
   {
      Context() : mbUsing(false), mbEnable(true), mbUsingBounds(false)
      {
      }

      ImDrawList* mDrawList;
      Style mStyle;

      MODE mMode;
      matrix_t mViewMat;
      matrix_t mProjectionMat;
      matrix_t mModel;
      matrix_t mModelLocal; // orthonormalized model
      matrix_t mModelInverse;
      matrix_t mModelSource;
      matrix_t mModelSourceInverse;
      matrix_t mMVP;
      matrix_t mMVPLocal; // MVP with full model matrix whereas mMVP's model matrix might only be translation in case of World space edition
      matrix_t mViewProjection;

      vec_t mModelScaleOrigin;
      vec_t mCameraEye;
      vec_t mCameraRight;
      vec_t mCameraDir;
      vec_t mCameraUp;
      vec_t mRayOrigin;
      vec_t mRayVector;

      float  mRadiusSquareCenter;
      ImVec2 mScreenSquareCenter;
      ImVec2 mScreenSquareMin;
      ImVec2 mScreenSquareMax;

      float mScreenFactor;
      vec_t mRelativeOrigin;

      bool mbUsing;
      bool mbEnable;
      bool mbMouseOver;
      bool mReversed; // reversed projection matrix

      // translation
      vec_t mTranslationPlan;
      vec_t mTranslationPlanOrigin;
      vec_t mMatrixOrigin;
      vec_t mTranslationLastDelta;

      // rotation
      vec_t mRotationVectorSource;
      float mRotationAngle;
      float mRotationAngleOrigin;
      //vec_t mWorldToLocalAxis;

      // scale
      vec_t mScale;
      vec_t mScaleValueOrigin;
      vec_t mScaleLast;
      float mSaveMousePosx;

      // save axis factor when using gizmo
      bool mBelowAxisLimit[3];
      bool mBelowPlaneLimit[3];
      float mAxisFactor[3];

      // bounds stretching
      vec_t mBoundsPivot;
      vec_t mBoundsAnchor;
      vec_t mBoundsPlan;
      vec_t mBoundsLocalPivot;
      int mBoundsBestAxis;
      int mBoundsAxis[2];
      bool mbUsingBounds;
      matrix_t mBoundsMatrix;

      //
      int mCurrentOperation;

      float mX = 0.f;
      float mY = 0.f;
      float mWidth = 0.f;
      float mHeight = 0.f;
      float mXMax = 0.f;
      float mYMax = 0.f;
      float mDisplayRatio = 1.f;

      bool mIsOrthographic = false;

      int mActualID = -1;
      int mEditingID = -1;
      OPERATION mOperation = OPERATION(-1);

      bool mAllowAxisFlip = true;
      float mGizmoSizeClipSpace = 0.1f;
   };

   static Context gContext;

   static const vec_t directionUnary[3] = { makeVect(1.f, 0.f, 0.f), makeVect(0.f, 1.f, 0.f), makeVect(0.f, 0.f, 1.f) };
   static const char* translationInfoMask[] = { "X : %5.3f", "Y : %5.3f", "Z : %5.3f",
      "Y : %5.3f Z : %5.3f", "X : %5.3f Z : %5.3f", "X : %5.3f Y : %5.3f",
      "X : %5.3f Y : %5.3f Z : %5.3f" };
   static const char* scaleInfoMask[] = { "X : %5.2f", "Y : %5.2f", "Z : %5.2f", "XYZ : %5.2f" };
   static const char* rotationInfoMask[] = { "X : %5.2f deg %5.2f rad", "Y : %5.2f deg %5.2f rad", "Z : %5.2f deg %5.2f rad", "Screen : %5.2f deg %5.2f rad" };
   static const int translationInfoIndex[] = { 0,0,0, 1,0,0, 2,0,0, 1,2,0, 0,2,0, 0,1,0, 0,1,2 };
   static const float quadMin = 0.5f;
   static const float quadMax = 0.8f;
   static const float quadUV[8] = { quadMin, quadMin, quadMin, quadMax, quadMax, quadMax, quadMax, quadMin };
   static const int halfCircleSegmentCount = 64;
   static const float snapTension = 0.5f;

   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   //
   static int GetMoveType(OPERATION op, vec_t* gizmoHitProportion);
   static int GetRotateType(OPERATION op);
   static int GetScaleType(OPERATION op);

   Style& GetStyle()
   {
      return gContext.mStyle;
   }

   static ImU32 GetColorU32(int idx)
   {
      IM_ASSERT(idx < COLOR::COUNT);
      return ImGui::ColorConvertFloat4ToU32(gContext.mStyle.Colors[idx]);
   }

   static ImVec2 worldToPos(const vec_t& worldPos, const matrix_t& mat, ImVec2 position = ImVec2(gContext.mX, gContext.mY), ImVec2 size = ImVec2(gContext.mWidth, gContext.mHeight))
   {
      vec_t trans;
      trans.TransformPoint(worldPos, mat);
      trans *= 0.5f / trans.w;
      trans += makeVect(0.5f, 0.5f);
      trans.y = 1.f - trans.y;
      trans.x *= size.x;
      trans.y *= size.y;
      trans.x += position.x;
      trans.y += position.y;
      return ImVec2(trans.x, trans.y);
   }

   static void ComputeCameraRay(vec_t& rayOrigin, vec_t& rayDir, ImVec2 position = ImVec2(gContext.mX, gContext.mY), ImVec2 size = ImVec2(gContext.mWidth, gContext.mHeight))
   {
      ImGuiIO& io = ImGui::GetIO();

      matrix_t mViewProjInverse;
      mViewProjInverse.Inverse(gContext.mViewMat * gContext.mProjectionMat);

      const float mox = ((io.MousePos.x - position.x) / size.x) * 2.f - 1.f;
      const float moy = (1.f - ((io.MousePos.y - position.y) / size.y)) * 2.f - 1.f;

      const float zNear = gContext.mReversed ? (1.f - FLT_EPSILON) : 0.f;
      const float zFar = gContext.mReversed ? 0.f : (1.f - FLT_EPSILON);

      rayOrigin.Transform(makeVect(mox, moy, zNear, 1.f), mViewProjInverse);
      rayOrigin *= 1.f / rayOrigin.w;
      vec_t rayEnd;
      rayEnd.Transform(makeVect(mox, moy, zFar, 1.f), mViewProjInverse);
      rayEnd *= 1.f / rayEnd.w;
      rayDir = Normalized(rayEnd - rayOrigin);
   }

   static float GetSegmentLengthClipSpace(const vec_t& start, const vec_t& end, const bool localCoordinates = false)
   {
      vec_t startOfSegment = start;
      const matrix_t& mvp = localCoordinates ? gContext.mMVPLocal : gContext.mMVP;
      startOfSegment.TransformPoint(mvp);
      if (fabsf(startOfSegment.w) > FLT_EPSILON) // check for axis aligned with camera direction
      {
         startOfSegment *= 1.f / startOfSegment.w;
      }

      vec_t endOfSegment = end;
      endOfSegment.TransformPoint(mvp);
      if (fabsf(endOfSegment.w) > FLT_EPSILON) // check for axis aligned with camera direction
      {
         endOfSegment *= 1.f / endOfSegment.w;
      }

      vec_t clipSpaceAxis = endOfSegment - startOfSegment;
      clipSpaceAxis.y /= gContext.mDisplayRatio;
      float segmentLengthInClipSpace = sqrtf(clipSpaceAxis.x * clipSpaceAxis.x + clipSpaceAxis.y * clipSpaceAxis.y);
      return segmentLengthInClipSpace;
   }

   static float GetParallelogram(const vec_t& ptO, const vec_t& ptA, const vec_t& ptB)
   {
      vec_t pts[] = { ptO, ptA, ptB };
      for (unsigned int i = 0; i < 3; i++)
      {
         pts[i].TransformPoint(gContext.mMVP);
         if (fabsf(pts[i].w) > FLT_EPSILON) // check for axis aligned with camera direction
         {
            pts[i] *= 1.f / pts[i].w;
         }
      }
      vec_t segA = pts[1] - pts[0];
      vec_t segB = pts[2] - pts[0];
      segA.y /= gContext.mDisplayRatio;
      segB.y /= gContext.mDisplayRatio;
      vec_t segAOrtho = makeVect(-segA.y, segA.x);
      segAOrtho.Normalize();
      float dt = segAOrtho.Dot3(segB);
      float surface = sqrtf(segA.x * segA.x + segA.y * segA.y) * fabsf(dt);
      return surface;
   }

   inline vec_t PointOnSegment(const vec_t& point, const vec_t& vertPos1, const vec_t& vertPos2)
   {
      vec_t c = point - vertPos1;
      vec_t V;

      V.Normalize(vertPos2 - vertPos1);
      float d = (vertPos2 - vertPos1).Length();
      float t = V.Dot3(c);

      if (t < 0.f)
      {
         return vertPos1;
      }

      if (t > d)
      {
         return vertPos2;
      }

      return vertPos1 + V * t;
   }

   static float IntersectRayPlane(const vec_t& rOrigin, const vec_t& rVector, const vec_t& plan)
   {
      const float numer = plan.Dot3(rOrigin) - plan.w;
      const float denom = plan.Dot3(rVector);

      if (fabsf(denom) < FLT_EPSILON)  // normal is orthogonal to vector, cant intersect
      {
         return -1.0f;
      }

      return -(numer / denom);
   }

   static float DistanceToPlane(const vec_t& point, const vec_t& plan)
   {
      return plan.Dot3(point) + plan.w;
   }

   static bool IsInContextRect(ImVec2 p)
   {
      return IsWithin(p.x, gContext.mX, gContext.mXMax) && IsWithin(p.y, gContext.mY, gContext.mYMax);
   }

   static bool IsHoveringWindow()
   {
      ImGuiContext& g = *ImGui::GetCurrentContext();
      ImGuiWindow* window = ImGui::FindWindowByName(gContext.mDrawList->_OwnerName);
      if (g.HoveredWindow == window)   // Mouse hovering drawlist window
         return true;
      if (g.HoveredWindow != NULL)     // Any other window is hovered
         return false;
      if (ImGui::IsMouseHoveringRect(window->InnerRect.Min, window->InnerRect.Max, false))   // Hovering drawlist window rect, while no other window is hovered (for _NoInputs windows)
         return true;
      return false;
   }

   void SetRect(float x, float y, float width, float height)
   {
      gContext.mX = x;
      gContext.mY = y;
      gContext.mWidth = width;
      gContext.mHeight = height;
      gContext.mXMax = gContext.mX + gContext.mWidth;
      gContext.mYMax = gContext.mY + gContext.mXMax;
      gContext.mDisplayRatio = width / height;
   }

   void SetOrthographic(bool isOrthographic)
   {
      gContext.mIsOrthographic = isOrthographic;
   }

   void SetDrawlist(ImDrawList* drawlist)
   {
      gContext.mDrawList = drawlist ? drawlist : ImGui::GetWindowDrawList();
   }

   void SetImGuiContext(ImGuiContext* ctx)
   {
      ImGui::SetCurrentContext(ctx);
   }

   void BeginFrame()
   {
      const ImU32 flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoBringToFrontOnFocus;

#ifdef IMGUI_HAS_VIEWPORT
      ImGui::SetNextWindowSize(ImGui::GetMainViewport()->Size);
      ImGui::SetNextWindowPos(ImGui::GetMainViewport()->Pos);
#else
      ImGuiIO& io = ImGui::GetIO();
      ImGui::SetNextWindowSize(io.DisplaySize);
      ImGui::SetNextWindowPos(ImVec2(0, 0));
#endif

      ImGui::PushStyleColor(ImGuiCol_WindowBg, 0);
      ImGui::PushStyleColor(ImGuiCol_Border, 0);
      ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);

      ImGui::Begin("gizmo", NULL, flags);
      gContext.mDrawList = ImGui::GetWindowDrawList();
      ImGui::End();
      ImGui::PopStyleVar();
      ImGui::PopStyleColor(2);
   }

   bool IsUsing()
   {
      return gContext.mbUsing || gContext.mbUsingBounds;
   }

   bool IsOver()
   {
      return (Intersects(gContext.mOperation, TRANSLATE) && GetMoveType(gContext.mOperation, NULL) != MT_NONE) ||
         (Intersects(gContext.mOperation, ROTATE) && GetRotateType(gContext.mOperation) != MT_NONE) ||
         (Intersects(gContext.mOperation, SCALE) && GetScaleType(gContext.mOperation) != MT_NONE) || IsUsing();
   }

   bool IsOver(OPERATION op)
   {
      if(IsUsing())
      {
         return true;
      }
      if(Intersects(op, SCALE) && GetScaleType(op) != MT_NONE)
      {
         return true;
      }
      if(Intersects(op, ROTATE) && GetRotateType(op) != MT_NONE)
      {
         return true;
      }
      if(Intersects(op, TRANSLATE) && GetMoveType(op, NULL) != MT_NONE)
      {
         return true;
      }
      return false;
   }

   void Enable(bool enable)
   {
      gContext.mbEnable = enable;
      if (!enable)
      {
         gContext.mbUsing = false;
         gContext.mbUsingBounds = false;
      }
   }

   static void ComputeContext(const float* view, const float* projection, float* matrix, MODE mode)
   {
      gContext.mMode = mode;
      gContext.mViewMat = *(matrix_t*)view;
      gContext.mProjectionMat = *(matrix_t*)projection;
      gContext.mbMouseOver = IsHoveringWindow();

      gContext.mModelLocal = *(matrix_t*)matrix;
      gContext.mModelLocal.OrthoNormalize();

      if (mode == LOCAL)
      {
         gContext.mModel = gContext.mModelLocal;
      }
      else
      {
         gContext.mModel.Translation(((matrix_t*)matrix)->v.position);
      }
      gContext.mModelSource = *(matrix_t*)matrix;
      gContext.mModelScaleOrigin.Set(gContext.mModelSource.v.right.Length(), gContext.mModelSource.v.up.Length(), gContext.mModelSource.v.dir.Length());

      gContext.mModelInverse.Inverse(gContext.mModel);
      gContext.mModelSourceInverse.Inverse(gContext.mModelSource);
      gContext.mViewProjection = gContext.mViewMat * gContext.mProjectionMat;
      gContext.mMVP = gContext.mModel * gContext.mViewProjection;
      gContext.mMVPLocal = gContext.mModelLocal * gContext.mViewProjection;

      matrix_t viewInverse;
      viewInverse.Inverse(gContext.mViewMat);
      gContext.mCameraDir = viewInverse.v.dir;
      gContext.mCameraEye = viewInverse.v.position;
      gContext.mCameraRight = viewInverse.v.right;
      gContext.mCameraUp = viewInverse.v.up;

      // projection reverse
       vec_t nearPos, farPos;
       nearPos.Transform(makeVect(0, 0, 1.f, 1.f), gContext.mProjectionMat);
       farPos.Transform(makeVect(0, 0, 2.f, 1.f), gContext.mProjectionMat);

       gContext.mReversed = (nearPos.z/nearPos.w) > (farPos.z / farPos.w);

      // compute scale from the size of camera right vector projected on screen at the matrix position
      vec_t pointRight = viewInverse.v.right;
      pointRight.TransformPoint(gContext.mViewProjection);
      gContext.mScreenFactor = gContext.mGizmoSizeClipSpace / (pointRight.x / pointRight.w - gContext.mMVP.v.position.x / gContext.mMVP.v.position.w);

      vec_t rightViewInverse = viewInverse.v.right;
      rightViewInverse.TransformVector(gContext.mModelInverse);
      float rightLength = GetSegmentLengthClipSpace(makeVect(0.f, 0.f), rightViewInverse);
      gContext.mScreenFactor = gContext.mGizmoSizeClipSpace / rightLength;

      ImVec2 centerSSpace = worldToPos(makeVect(0.f, 0.f), gContext.mMVP);
      gContext.mScreenSquareCenter = centerSSpace;
      gContext.mScreenSquareMin = ImVec2(centerSSpace.x - 10.f, centerSSpace.y - 10.f);
      gContext.mScreenSquareMax = ImVec2(centerSSpace.x + 10.f, centerSSpace.y + 10.f);

      ComputeCameraRay(gContext.mRayOrigin, gContext.mRayVector);
   }

   static void ComputeColors(ImU32* colors, int type, OPERATION operation)
   {
      if (gContext.mbEnable)
      {
         ImU32 selectionColor = GetColorU32(SELECTION);

         switch (operation)
         {
         case TRANSLATE:
            colors[0] = (type == MT_MOVE_SCREEN) ? selectionColor : IM_COL32_WHITE;
            for (int i = 0; i < 3; i++)
            {
               colors[i + 1] = (type == (int)(MT_MOVE_X + i)) ? selectionColor : GetColorU32(DIRECTION_X + i);
               colors[i + 4] = (type == (int)(MT_MOVE_YZ + i)) ? selectionColor : GetColorU32(PLANE_X + i);
               colors[i + 4] = (type == MT_MOVE_SCREEN) ? selectionColor : colors[i + 4];
            }
            break;
         case ROTATE:
            colors[0] = (type == MT_ROTATE_SCREEN) ? selectionColor : IM_COL32_WHITE;
            for (int i = 0; i < 3; i++)
            {
               colors[i + 1] = (type == (int)(MT_ROTATE_X + i)) ? selectionColor : GetColorU32(DIRECTION_X + i);
            }
            break;
         case SCALEU:
         case SCALE:
            colors[0] = (type == MT_SCALE_XYZ) ? selectionColor : IM_COL32_WHITE;
            for (int i = 0; i < 3; i++)
            {
               colors[i + 1] = (type == (int)(MT_SCALE_X + i)) ? selectionColor : GetColorU32(DIRECTION_X + i);
            }
            break;
         // note: this internal function is only called with three possible values for operation
         default:
            break;
         }
      }
      else
      {
         ImU32 inactiveColor = GetColorU32(INACTIVE);
         for (int i = 0; i < 7; i++)
         {
            colors[i] = inactiveColor;
         }
      }
   }

   static void ComputeTripodAxisAndVisibility(const int axisIndex, vec_t& dirAxis, vec_t& dirPlaneX, vec_t& dirPlaneY, bool& belowAxisLimit, bool& belowPlaneLimit, const bool localCoordinates = false)
   {
      dirAxis = directionUnary[axisIndex];
      dirPlaneX = directionUnary[(axisIndex + 1) % 3];
      dirPlaneY = directionUnary[(axisIndex + 2) % 3];

      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID))
      {
         // when using, use stored factors so the gizmo doesn't flip when we translate
         belowAxisLimit = gContext.mBelowAxisLimit[axisIndex];
         belowPlaneLimit = gContext.mBelowPlaneLimit[axisIndex];

         dirAxis *= gContext.mAxisFactor[axisIndex];
         dirPlaneX *= gContext.mAxisFactor[(axisIndex + 1) % 3];
         dirPlaneY *= gContext.mAxisFactor[(axisIndex + 2) % 3];
      }
      else
      {
         // new method
         float lenDir = GetSegmentLengthClipSpace(makeVect(0.f, 0.f, 0.f), dirAxis, localCoordinates);
         float lenDirMinus = GetSegmentLengthClipSpace(makeVect(0.f, 0.f, 0.f), -dirAxis, localCoordinates);

         float lenDirPlaneX = GetSegmentLengthClipSpace(makeVect(0.f, 0.f, 0.f), dirPlaneX, localCoordinates);
         float lenDirMinusPlaneX = GetSegmentLengthClipSpace(makeVect(0.f, 0.f, 0.f), -dirPlaneX, localCoordinates);

         float lenDirPlaneY = GetSegmentLengthClipSpace(makeVect(0.f, 0.f, 0.f), dirPlaneY, localCoordinates);
         float lenDirMinusPlaneY = GetSegmentLengthClipSpace(makeVect(0.f, 0.f, 0.f), -dirPlaneY, localCoordinates);

         // For readability
         bool & allowFlip = gContext.mAllowAxisFlip;
         float mulAxis = (allowFlip && lenDir < lenDirMinus&& fabsf(lenDir - lenDirMinus) > FLT_EPSILON) ? -1.f : 1.f;
         float mulAxisX = (allowFlip && lenDirPlaneX < lenDirMinusPlaneX&& fabsf(lenDirPlaneX - lenDirMinusPlaneX) > FLT_EPSILON) ? -1.f : 1.f;
         float mulAxisY = (allowFlip && lenDirPlaneY < lenDirMinusPlaneY&& fabsf(lenDirPlaneY - lenDirMinusPlaneY) > FLT_EPSILON) ? -1.f : 1.f;
         dirAxis *= mulAxis;
         dirPlaneX *= mulAxisX;
         dirPlaneY *= mulAxisY;

         // for axis
         float axisLengthInClipSpace = GetSegmentLengthClipSpace(makeVect(0.f, 0.f, 0.f), dirAxis * gContext.mScreenFactor, localCoordinates);

         float paraSurf = GetParallelogram(makeVect(0.f, 0.f, 0.f), dirPlaneX * gContext.mScreenFactor, dirPlaneY * gContext.mScreenFactor);
         belowPlaneLimit = (paraSurf > 0.0025f);
         belowAxisLimit = (axisLengthInClipSpace > 0.02f);

         // and store values
         gContext.mAxisFactor[axisIndex] = mulAxis;
         gContext.mAxisFactor[(axisIndex + 1) % 3] = mulAxisX;
         gContext.mAxisFactor[(axisIndex + 2) % 3] = mulAxisY;
         gContext.mBelowAxisLimit[axisIndex] = belowAxisLimit;
         gContext.mBelowPlaneLimit[axisIndex] = belowPlaneLimit;
      }
   }

   static void ComputeSnap(float* value, float snap)
   {
      if (snap <= FLT_EPSILON)
      {
         return;
      }

      float modulo = fmodf(*value, snap);
      float moduloRatio = fabsf(modulo) / snap;
      if (moduloRatio < snapTension)
      {
         *value -= modulo;
      }
      else if (moduloRatio > (1.f - snapTension))
      {
         *value = *value - modulo + snap * ((*value < 0.f) ? -1.f : 1.f);
      }
   }
   static void ComputeSnap(vec_t& value, const float* snap)
   {
      for (int i = 0; i < 3; i++)
      {
         ComputeSnap(&value[i], snap[i]);
      }
   }

   static float ComputeAngleOnPlan()
   {
      const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, gContext.mTranslationPlan);
      vec_t localPos = Normalized(gContext.mRayOrigin + gContext.mRayVector * len - gContext.mModel.v.position);

      vec_t perpendicularVector;
      perpendicularVector.Cross(gContext.mRotationVectorSource, gContext.mTranslationPlan);
      perpendicularVector.Normalize();
      float acosAngle = Clamp(Dot(localPos, gContext.mRotationVectorSource), -1.f, 1.f);
      float angle = acosf(acosAngle);
      angle *= (Dot(localPos, perpendicularVector) < 0.f) ? 1.f : -1.f;
      return angle;
   }

   static void DrawRotationGizmo(OPERATION op, int type)
   {
      if(!Intersects(op, ROTATE))
      {
         return;
      }
      ImDrawList* drawList = gContext.mDrawList;

      // colors
      ImU32 colors[7];
      ComputeColors(colors, type, ROTATE);

      vec_t cameraToModelNormalized;
      if (gContext.mIsOrthographic)
      {
         matrix_t viewInverse;
         viewInverse.Inverse(*(matrix_t*)&gContext.mViewMat);
         cameraToModelNormalized = -viewInverse.v.dir;
      }
      else
      {
         cameraToModelNormalized = Normalized(gContext.mModel.v.position - gContext.mCameraEye);
      }

      cameraToModelNormalized.TransformVector(gContext.mModelInverse);

      gContext.mRadiusSquareCenter = screenRotateSize * gContext.mHeight;

      bool hasRSC = Intersects(op, ROTATE_SCREEN);
      for (int axis = 0; axis < 3; axis++)
      {
         if(!Intersects(op, static_cast<OPERATION>(ROTATE_Z >> axis)))
         {
            continue;
         }
         const bool usingAxis = (gContext.mbUsing && type == MT_ROTATE_Z - axis);
         const int circleMul = (hasRSC && !usingAxis ) ? 1 : 2;

         ImVec2* circlePos = (ImVec2*)alloca(sizeof(ImVec2) * (circleMul * halfCircleSegmentCount + 1));

         float angleStart = atan2f(cameraToModelNormalized[(4 - axis) % 3], cameraToModelNormalized[(3 - axis) % 3]) + ZPI * 0.5f;

         for (int i = 0; i < circleMul * halfCircleSegmentCount + 1; i++)
         {
            float ng = angleStart + (float)circleMul * ZPI * ((float)i / (float)halfCircleSegmentCount);
            vec_t axisPos = makeVect(cosf(ng), sinf(ng), 0.f);
            vec_t pos = makeVect(axisPos[axis], axisPos[(axis + 1) % 3], axisPos[(axis + 2) % 3]) * gContext.mScreenFactor * rotationDisplayFactor;
            circlePos[i] = worldToPos(pos, gContext.mMVP);
         }
         if (!gContext.mbUsing || usingAxis)
         {
            drawList->AddPolyline(circlePos, circleMul* halfCircleSegmentCount + 1, colors[3 - axis], false, gContext.mStyle.RotationLineThickness);
         }

         float radiusAxis = sqrtf((ImLengthSqr(worldToPos(gContext.mModel.v.position, gContext.mViewProjection) - circlePos[0])));
         if (radiusAxis > gContext.mRadiusSquareCenter)
         {
            gContext.mRadiusSquareCenter = radiusAxis;
         }
      }
      if(hasRSC && (!gContext.mbUsing || type == MT_ROTATE_SCREEN))
      {
         drawList->AddCircle(worldToPos(gContext.mModel.v.position, gContext.mViewProjection), gContext.mRadiusSquareCenter, colors[0], 64, gContext.mStyle.RotationOuterLineThickness);
      }

      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID) && IsRotateType(type))
      {
         ImVec2 circlePos[halfCircleSegmentCount + 1];

         circlePos[0] = worldToPos(gContext.mModel.v.position, gContext.mViewProjection);
         for (unsigned int i = 1; i < halfCircleSegmentCount; i++)
         {
            float ng = gContext.mRotationAngle * ((float)(i - 1) / (float)(halfCircleSegmentCount - 1));
            matrix_t rotateVectorMatrix;
            rotateVectorMatrix.RotationAxis(gContext.mTranslationPlan, ng);
            vec_t pos;
            pos.TransformPoint(gContext.mRotationVectorSource, rotateVectorMatrix);
            pos *= gContext.mScreenFactor * rotationDisplayFactor;
            circlePos[i] = worldToPos(pos + gContext.mModel.v.position, gContext.mViewProjection);
         }
         drawList->AddConvexPolyFilled(circlePos, halfCircleSegmentCount, GetColorU32(ROTATION_USING_FILL));
         drawList->AddPolyline(circlePos, halfCircleSegmentCount, GetColorU32(ROTATION_USING_BORDER), true, gContext.mStyle.RotationLineThickness);

         ImVec2 destinationPosOnScreen = circlePos[1];
         char tmps[512];
         ImFormatString(tmps, sizeof(tmps), rotationInfoMask[type - MT_ROTATE_X], (gContext.mRotationAngle / ZPI) * 180.f, gContext.mRotationAngle);
         drawList->AddText(ImVec2(destinationPosOnScreen.x + 15, destinationPosOnScreen.y + 15), GetColorU32(TEXT_SHADOW), tmps);
         drawList->AddText(ImVec2(destinationPosOnScreen.x + 14, destinationPosOnScreen.y + 14), GetColorU32(TEXT), tmps);
      }
   }

   static void DrawHatchedAxis(const vec_t& axis)
   {
      if (gContext.mStyle.HatchedAxisLineThickness <= 0.0f)
      {
         return;
      }

      for (int j = 1; j < 10; j++)
      {
         ImVec2 baseSSpace2 = worldToPos(axis * 0.05f * (float)(j * 2) * gContext.mScreenFactor, gContext.mMVP);
         ImVec2 worldDirSSpace2 = worldToPos(axis * 0.05f * (float)(j * 2 + 1) * gContext.mScreenFactor, gContext.mMVP);
         gContext.mDrawList->AddLine(baseSSpace2, worldDirSSpace2, GetColorU32(HATCHED_AXIS_LINES), gContext.mStyle.HatchedAxisLineThickness);
      }
   }

   static void DrawScaleGizmo(OPERATION op, int type)
   {
      ImDrawList* drawList = gContext.mDrawList;

      if(!Intersects(op, SCALE))
      {
        return;
      }

      // colors
      ImU32 colors[7];
      ComputeColors(colors, type, SCALE);

      // draw
      vec_t scaleDisplay = { 1.f, 1.f, 1.f, 1.f };

      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID))
      {
         scaleDisplay = gContext.mScale;
      }

      for (int i = 0; i < 3; i++)
      {
         if(!Intersects(op, static_cast<OPERATION>(SCALE_X << i)))
         {
            continue;
         }
         const bool usingAxis = (gContext.mbUsing && type == MT_SCALE_X + i);
         if (!gContext.mbUsing || usingAxis)
         {
            vec_t dirPlaneX, dirPlaneY, dirAxis;
            bool belowAxisLimit, belowPlaneLimit;
            ComputeTripodAxisAndVisibility(i, dirAxis, dirPlaneX, dirPlaneY, belowAxisLimit, belowPlaneLimit, true);

            // draw axis
            if (belowAxisLimit)
            {
               bool hasTranslateOnAxis = Contains(op, static_cast<OPERATION>(TRANSLATE_X << i));
               float markerScale = hasTranslateOnAxis ? 1.4f : 1.0f;
               ImVec2 baseSSpace = worldToPos(dirAxis * 0.1f * gContext.mScreenFactor, gContext.mMVP);
               ImVec2 worldDirSSpaceNoScale = worldToPos(dirAxis * markerScale * gContext.mScreenFactor, gContext.mMVP);
               ImVec2 worldDirSSpace = worldToPos((dirAxis * markerScale * scaleDisplay[i]) * gContext.mScreenFactor, gContext.mMVP);

               if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID))
               {
                  ImU32 scaleLineColor = GetColorU32(SCALE_LINE);
                  drawList->AddLine(baseSSpace, worldDirSSpaceNoScale, scaleLineColor, gContext.mStyle.ScaleLineThickness);
                  drawList->AddCircleFilled(worldDirSSpaceNoScale, gContext.mStyle.ScaleLineCircleSize, scaleLineColor);
               }

               if (!hasTranslateOnAxis || gContext.mbUsing)
               {
                  drawList->AddLine(baseSSpace, worldDirSSpace, colors[i + 1], gContext.mStyle.ScaleLineThickness);
               }
               drawList->AddCircleFilled(worldDirSSpace, gContext.mStyle.ScaleLineCircleSize, colors[i + 1]);

               if (gContext.mAxisFactor[i] < 0.f)
               {
                  DrawHatchedAxis(dirAxis * scaleDisplay[i]);
               }
            }
         }
      }

      // draw screen cirle
      drawList->AddCircleFilled(gContext.mScreenSquareCenter, gContext.mStyle.CenterCircleSize, colors[0], 32);

      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID) && IsScaleType(type))
      {
         //ImVec2 sourcePosOnScreen = worldToPos(gContext.mMatrixOrigin, gContext.mViewProjection);
         ImVec2 destinationPosOnScreen = worldToPos(gContext.mModel.v.position, gContext.mViewProjection);
         /*vec_t dif(destinationPosOnScreen.x - sourcePosOnScreen.x, destinationPosOnScreen.y - sourcePosOnScreen.y);
         dif.Normalize();
         dif *= 5.f;
         drawList->AddCircle(sourcePosOnScreen, 6.f, translationLineColor);
         drawList->AddCircle(destinationPosOnScreen, 6.f, translationLineColor);
         drawList->AddLine(ImVec2(sourcePosOnScreen.x + dif.x, sourcePosOnScreen.y + dif.y), ImVec2(destinationPosOnScreen.x - dif.x, destinationPosOnScreen.y - dif.y), translationLineColor, 2.f);
         */
         char tmps[512];
         //vec_t deltaInfo = gContext.mModel.v.position - gContext.mMatrixOrigin;
         int componentInfoIndex = (type - MT_SCALE_X) * 3;
         ImFormatString(tmps, sizeof(tmps), scaleInfoMask[type - MT_SCALE_X], scaleDisplay[translationInfoIndex[componentInfoIndex]]);
         drawList->AddText(ImVec2(destinationPosOnScreen.x + 15, destinationPosOnScreen.y + 15), GetColorU32(TEXT_SHADOW), tmps);
         drawList->AddText(ImVec2(destinationPosOnScreen.x + 14, destinationPosOnScreen.y + 14), GetColorU32(TEXT), tmps);
      }
   }


   static void DrawScaleUniveralGizmo(OPERATION op, int type)
   {
      ImDrawList* drawList = gContext.mDrawList;

      if (!Intersects(op, SCALEU))
      {
         return;
      }

      // colors
      ImU32 colors[7];
      ComputeColors(colors, type, SCALEU);

      // draw
      vec_t scaleDisplay = { 1.f, 1.f, 1.f, 1.f };

      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID))
      {
         scaleDisplay = gContext.mScale;
      }

      for (int i = 0; i < 3; i++)
      {
         if (!Intersects(op, static_cast<OPERATION>(SCALE_XU << i)))
         {
            continue;
         }
         const bool usingAxis = (gContext.mbUsing && type == MT_SCALE_X + i);
         if (!gContext.mbUsing || usingAxis)
         {
            vec_t dirPlaneX, dirPlaneY, dirAxis;
            bool belowAxisLimit, belowPlaneLimit;
            ComputeTripodAxisAndVisibility(i, dirAxis, dirPlaneX, dirPlaneY, belowAxisLimit, belowPlaneLimit, true);

            // draw axis
            if (belowAxisLimit)
            {
               bool hasTranslateOnAxis = Contains(op, static_cast<OPERATION>(TRANSLATE_X << i));
               float markerScale = hasTranslateOnAxis ? 1.4f : 1.0f;
               //ImVec2 baseSSpace = worldToPos(dirAxis * 0.1f * gContext.mScreenFactor, gContext.mMVPLocal);
               //ImVec2 worldDirSSpaceNoScale = worldToPos(dirAxis * markerScale * gContext.mScreenFactor, gContext.mMVP);
               ImVec2 worldDirSSpace = worldToPos((dirAxis * markerScale * scaleDisplay[i]) * gContext.mScreenFactor, gContext.mMVPLocal);

#if 0
               if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID))
               {
                  drawList->AddLine(baseSSpace, worldDirSSpaceNoScale, IM_COL32(0x40, 0x40, 0x40, 0xFF), 3.f);
                  drawList->AddCircleFilled(worldDirSSpaceNoScale, 6.f, IM_COL32(0x40, 0x40, 0x40, 0xFF));
               }
               /*
               if (!hasTranslateOnAxis || gContext.mbUsing)
               {
                  drawList->AddLine(baseSSpace, worldDirSSpace, colors[i + 1], 3.f);
               }
               */
#endif
               drawList->AddCircleFilled(worldDirSSpace, 12.f, colors[i + 1]);
            }
         }
      }

      // draw screen cirle
      drawList->AddCircle(gContext.mScreenSquareCenter, 20.f, colors[0], 32, gContext.mStyle.CenterCircleSize);

      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID) && IsScaleType(type))
      {
         //ImVec2 sourcePosOnScreen = worldToPos(gContext.mMatrixOrigin, gContext.mViewProjection);
         ImVec2 destinationPosOnScreen = worldToPos(gContext.mModel.v.position, gContext.mViewProjection);
         /*vec_t dif(destinationPosOnScreen.x - sourcePosOnScreen.x, destinationPosOnScreen.y - sourcePosOnScreen.y);
         dif.Normalize();
         dif *= 5.f;
         drawList->AddCircle(sourcePosOnScreen, 6.f, translationLineColor);
         drawList->AddCircle(destinationPosOnScreen, 6.f, translationLineColor);
         drawList->AddLine(ImVec2(sourcePosOnScreen.x + dif.x, sourcePosOnScreen.y + dif.y), ImVec2(destinationPosOnScreen.x - dif.x, destinationPosOnScreen.y - dif.y), translationLineColor, 2.f);
         */
         char tmps[512];
         //vec_t deltaInfo = gContext.mModel.v.position - gContext.mMatrixOrigin;
         int componentInfoIndex = (type - MT_SCALE_X) * 3;
         ImFormatString(tmps, sizeof(tmps), scaleInfoMask[type - MT_SCALE_X], scaleDisplay[translationInfoIndex[componentInfoIndex]]);
         drawList->AddText(ImVec2(destinationPosOnScreen.x + 15, destinationPosOnScreen.y + 15), GetColorU32(TEXT_SHADOW), tmps);
         drawList->AddText(ImVec2(destinationPosOnScreen.x + 14, destinationPosOnScreen.y + 14), GetColorU32(TEXT), tmps);
      }
   }

   static void DrawTranslationGizmo(OPERATION op, int type)
   {
      ImDrawList* drawList = gContext.mDrawList;
      if (!drawList)
      {
         return;
      }

      if(!Intersects(op, TRANSLATE))
      {
         return;
      }

      // colors
      ImU32 colors[7];
      ComputeColors(colors, type, TRANSLATE);

      const ImVec2 origin = worldToPos(gContext.mModel.v.position, gContext.mViewProjection);

      // draw
      bool belowAxisLimit = false;
      bool belowPlaneLimit = false;
      for (int i = 0; i < 3; ++i)
      {
         vec_t dirPlaneX, dirPlaneY, dirAxis;
         ComputeTripodAxisAndVisibility(i, dirAxis, dirPlaneX, dirPlaneY, belowAxisLimit, belowPlaneLimit);

         if (!gContext.mbUsing || (gContext.mbUsing && type == MT_MOVE_X + i))
         {
            // draw axis
            if (belowAxisLimit && Intersects(op, static_cast<OPERATION>(TRANSLATE_X << i)))
            {
               ImVec2 baseSSpace = worldToPos(dirAxis * 0.1f * gContext.mScreenFactor, gContext.mMVP);
               ImVec2 worldDirSSpace = worldToPos(dirAxis * gContext.mScreenFactor, gContext.mMVP);

               drawList->AddLine(baseSSpace, worldDirSSpace, colors[i + 1], gContext.mStyle.TranslationLineThickness);

               // Arrow head begin
               ImVec2 dir(origin - worldDirSSpace);

               float d = sqrtf(ImLengthSqr(dir));
               dir /= d; // Normalize
               dir *= gContext.mStyle.TranslationLineArrowSize;

               ImVec2 ortogonalDir(dir.y, -dir.x); // Perpendicular vector
               ImVec2 a(worldDirSSpace + dir);
               drawList->AddTriangleFilled(worldDirSSpace - dir, a + ortogonalDir, a - ortogonalDir, colors[i + 1]);
               // Arrow head end

               if (gContext.mAxisFactor[i] < 0.f)
               {
                  DrawHatchedAxis(dirAxis);
               }
            }
         }
         // draw plane
         if (!gContext.mbUsing || (gContext.mbUsing && type == MT_MOVE_YZ + i))
         {
            if (belowPlaneLimit && Contains(op, TRANSLATE_PLANS[i]))
            {
               ImVec2 screenQuadPts[4];
               for (int j = 0; j < 4; ++j)
               {
                  vec_t cornerWorldPos = (dirPlaneX * quadUV[j * 2] + dirPlaneY * quadUV[j * 2 + 1]) * gContext.mScreenFactor;
                  screenQuadPts[j] = worldToPos(cornerWorldPos, gContext.mMVP);
               }
               drawList->AddPolyline(screenQuadPts, 4, GetColorU32(DIRECTION_X + i), true, 1.0f);
               drawList->AddConvexPolyFilled(screenQuadPts, 4, colors[i + 4]);
            }
         }
      }

      drawList->AddCircleFilled(gContext.mScreenSquareCenter, gContext.mStyle.CenterCircleSize, colors[0], 32);

      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID) && IsTranslateType(type))
      {
         ImU32 translationLineColor = GetColorU32(TRANSLATION_LINE);

         ImVec2 sourcePosOnScreen = worldToPos(gContext.mMatrixOrigin, gContext.mViewProjection);
         ImVec2 destinationPosOnScreen = worldToPos(gContext.mModel.v.position, gContext.mViewProjection);
         vec_t dif = { destinationPosOnScreen.x - sourcePosOnScreen.x, destinationPosOnScreen.y - sourcePosOnScreen.y, 0.f, 0.f };
         dif.Normalize();
         dif *= 5.f;
         drawList->AddCircle(sourcePosOnScreen, 6.f, translationLineColor);
         drawList->AddCircle(destinationPosOnScreen, 6.f, translationLineColor);
         drawList->AddLine(ImVec2(sourcePosOnScreen.x + dif.x, sourcePosOnScreen.y + dif.y), ImVec2(destinationPosOnScreen.x - dif.x, destinationPosOnScreen.y - dif.y), translationLineColor, 2.f);

         char tmps[512];
         vec_t deltaInfo = gContext.mModel.v.position - gContext.mMatrixOrigin;
         int componentInfoIndex = (type - MT_MOVE_X) * 3;
         ImFormatString(tmps, sizeof(tmps), translationInfoMask[type - MT_MOVE_X], deltaInfo[translationInfoIndex[componentInfoIndex]], deltaInfo[translationInfoIndex[componentInfoIndex + 1]], deltaInfo[translationInfoIndex[componentInfoIndex + 2]]);
         drawList->AddText(ImVec2(destinationPosOnScreen.x + 15, destinationPosOnScreen.y + 15), GetColorU32(TEXT_SHADOW), tmps);
         drawList->AddText(ImVec2(destinationPosOnScreen.x + 14, destinationPosOnScreen.y + 14), GetColorU32(TEXT), tmps);
      }
   }

   static bool CanActivate()
   {
      if (ImGui::IsMouseClicked(0) && !ImGui::IsAnyItemHovered() && !ImGui::IsAnyItemActive())
      {
         return true;
      }
      return false;
   }

   static void HandleAndDrawLocalBounds(const float* bounds, matrix_t* matrix, const float* snapValues, OPERATION operation)
   {
      ImGuiIO& io = ImGui::GetIO();
      ImDrawList* drawList = gContext.mDrawList;

      // compute best projection axis
      vec_t axesWorldDirections[3];
      vec_t bestAxisWorldDirection = { 0.0f, 0.0f, 0.0f, 0.0f };
      int axes[3];
      unsigned int numAxes = 1;
      axes[0] = gContext.mBoundsBestAxis;
      int bestAxis = axes[0];
      if (!gContext.mbUsingBounds)
      {
         numAxes = 0;
         float bestDot = 0.f;
         for (int i = 0; i < 3; i++)
         {
            vec_t dirPlaneNormalWorld;
            dirPlaneNormalWorld.TransformVector(directionUnary[i], gContext.mModelSource);
            dirPlaneNormalWorld.Normalize();

            float dt = fabsf(Dot(Normalized(gContext.mCameraEye - gContext.mModelSource.v.position), dirPlaneNormalWorld));
            if (dt >= bestDot)
            {
               bestDot = dt;
               bestAxis = i;
               bestAxisWorldDirection = dirPlaneNormalWorld;
            }

            if (dt >= 0.1f)
            {
               axes[numAxes] = i;
               axesWorldDirections[numAxes] = dirPlaneNormalWorld;
               ++numAxes;
            }
         }
      }

      if (numAxes == 0)
      {
         axes[0] = bestAxis;
         axesWorldDirections[0] = bestAxisWorldDirection;
         numAxes = 1;
      }

      else if (bestAxis != axes[0])
      {
         unsigned int bestIndex = 0;
         for (unsigned int i = 0; i < numAxes; i++)
         {
            if (axes[i] == bestAxis)
            {
               bestIndex = i;
               break;
            }
         }
         int tempAxis = axes[0];
         axes[0] = axes[bestIndex];
         axes[bestIndex] = tempAxis;
         vec_t tempDirection = axesWorldDirections[0];
         axesWorldDirections[0] = axesWorldDirections[bestIndex];
         axesWorldDirections[bestIndex] = tempDirection;
      }

      for (unsigned int axisIndex = 0; axisIndex < numAxes; ++axisIndex)
      {
         bestAxis = axes[axisIndex];
         bestAxisWorldDirection = axesWorldDirections[axisIndex];

         // corners
         vec_t aabb[4];

         int secondAxis = (bestAxis + 1) % 3;
         int thirdAxis = (bestAxis + 2) % 3;

         for (int i = 0; i < 4; i++)
         {
            aabb[i][3] = aabb[i][bestAxis] = 0.f;
            aabb[i][secondAxis] = bounds[secondAxis + 3 * (i >> 1)];
            aabb[i][thirdAxis] = bounds[thirdAxis + 3 * ((i >> 1) ^ (i & 1))];
         }

         // draw bounds
         unsigned int anchorAlpha = gContext.mbEnable ? IM_COL32_BLACK : IM_COL32(0, 0, 0, 0x80);

         matrix_t boundsMVP = gContext.mModelSource * gContext.mViewProjection;
         for (int i = 0; i < 4; i++)
         {
            ImVec2 worldBound1 = worldToPos(aabb[i], boundsMVP);
            ImVec2 worldBound2 = worldToPos(aabb[(i + 1) % 4], boundsMVP);
            if (!IsInContextRect(worldBound1) || !IsInContextRect(worldBound2))
            {
               continue;
            }
            float boundDistance = sqrtf(ImLengthSqr(worldBound1 - worldBound2));
            int stepCount = (int)(boundDistance / 10.f);
            stepCount = min(stepCount, 1000);
            for (int j = 0; j < stepCount; j++)
            {
               float stepLength = 1.f / (float)stepCount;
               float t1 = (float)j * stepLength;
               float t2 = (float)j * stepLength + stepLength * 0.5f;
               ImVec2 worldBoundSS1 = ImLerp(worldBound1, worldBound2, ImVec2(t1, t1));
               ImVec2 worldBoundSS2 = ImLerp(worldBound1, worldBound2, ImVec2(t2, t2));
               //drawList->AddLine(worldBoundSS1, worldBoundSS2, IM_COL32(0, 0, 0, 0) + anchorAlpha, 3.f);
               drawList->AddLine(worldBoundSS1, worldBoundSS2, IM_COL32(0xAA, 0xAA, 0xAA, 0) + anchorAlpha, 2.f);
            }
            vec_t midPoint = (aabb[i] + aabb[(i + 1) % 4]) * 0.5f;
            ImVec2 midBound = worldToPos(midPoint, boundsMVP);
            static const float AnchorBigRadius = 8.f;
            static const float AnchorSmallRadius = 6.f;
            bool overBigAnchor = ImLengthSqr(worldBound1 - io.MousePos) <= (AnchorBigRadius * AnchorBigRadius);
            bool overSmallAnchor = ImLengthSqr(midBound - io.MousePos) <= (AnchorBigRadius * AnchorBigRadius);

            int type = MT_NONE;
            vec_t gizmoHitProportion;

            if(Intersects(operation, TRANSLATE))
            {
               type = GetMoveType(operation, &gizmoHitProportion);
            }
            if(Intersects(operation, ROTATE) && type == MT_NONE)
            {
               type = GetRotateType(operation);
            }
            if(Intersects(operation, SCALE) && type == MT_NONE)
            {
               type = GetScaleType(operation);
            }

            if (type != MT_NONE)
            {
               overBigAnchor = false;
               overSmallAnchor = false;
            }

            ImU32 selectionColor = GetColorU32(SELECTION);

            unsigned int bigAnchorColor = overBigAnchor ? selectionColor : (IM_COL32(0xAA, 0xAA, 0xAA, 0) + anchorAlpha);
            unsigned int smallAnchorColor = overSmallAnchor ? selectionColor : (IM_COL32(0xAA, 0xAA, 0xAA, 0) + anchorAlpha);

            drawList->AddCircleFilled(worldBound1, AnchorBigRadius, IM_COL32_BLACK);
            drawList->AddCircleFilled(worldBound1, AnchorBigRadius - 1.2f, bigAnchorColor);

            drawList->AddCircleFilled(midBound, AnchorSmallRadius, IM_COL32_BLACK);
            drawList->AddCircleFilled(midBound, AnchorSmallRadius - 1.2f, smallAnchorColor);
            int oppositeIndex = (i + 2) % 4;
            // big anchor on corners
            if (!gContext.mbUsingBounds && gContext.mbEnable && overBigAnchor && CanActivate())
            {
               gContext.mBoundsPivot.TransformPoint(aabb[(i + 2) % 4], gContext.mModelSource);
               gContext.mBoundsAnchor.TransformPoint(aabb[i], gContext.mModelSource);
               gContext.mBoundsPlan = BuildPlan(gContext.mBoundsAnchor, bestAxisWorldDirection);
               gContext.mBoundsBestAxis = bestAxis;
               gContext.mBoundsAxis[0] = secondAxis;
               gContext.mBoundsAxis[1] = thirdAxis;

               gContext.mBoundsLocalPivot.Set(0.f);
               gContext.mBoundsLocalPivot[secondAxis] = aabb[oppositeIndex][secondAxis];
               gContext.mBoundsLocalPivot[thirdAxis] = aabb[oppositeIndex][thirdAxis];

               gContext.mbUsingBounds = true;
               gContext.mEditingID = gContext.mActualID;
               gContext.mBoundsMatrix = gContext.mModelSource;
            }
            // small anchor on middle of segment
            if (!gContext.mbUsingBounds && gContext.mbEnable && overSmallAnchor && CanActivate())
            {
               vec_t midPointOpposite = (aabb[(i + 2) % 4] + aabb[(i + 3) % 4]) * 0.5f;
               gContext.mBoundsPivot.TransformPoint(midPointOpposite, gContext.mModelSource);
               gContext.mBoundsAnchor.TransformPoint(midPoint, gContext.mModelSource);
               gContext.mBoundsPlan = BuildPlan(gContext.mBoundsAnchor, bestAxisWorldDirection);
               gContext.mBoundsBestAxis = bestAxis;
               int indices[] = { secondAxis , thirdAxis };
               gContext.mBoundsAxis[0] = indices[i % 2];
               gContext.mBoundsAxis[1] = -1;

               gContext.mBoundsLocalPivot.Set(0.f);
               gContext.mBoundsLocalPivot[gContext.mBoundsAxis[0]] = aabb[oppositeIndex][indices[i % 2]];// bounds[gContext.mBoundsAxis[0]] * (((i + 1) & 2) ? 1.f : -1.f);

               gContext.mbUsingBounds = true;
               gContext.mEditingID = gContext.mActualID;
               gContext.mBoundsMatrix = gContext.mModelSource;
            }
         }

         if (gContext.mbUsingBounds && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID))
         {
            matrix_t scale;
            scale.SetToIdentity();

            // compute projected mouse position on plan
            const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, gContext.mBoundsPlan);
            vec_t newPos = gContext.mRayOrigin + gContext.mRayVector * len;

            // compute a reference and delta vectors base on mouse move
            vec_t deltaVector = (newPos - gContext.mBoundsPivot).Abs();
            vec_t referenceVector = (gContext.mBoundsAnchor - gContext.mBoundsPivot).Abs();

            // for 1 or 2 axes, compute a ratio that's used for scale and snap it based on resulting length
            for (int i = 0; i < 2; i++)
            {
               int axisIndex1 = gContext.mBoundsAxis[i];
               if (axisIndex1 == -1)
               {
                  continue;
               }

               float ratioAxis = 1.f;
               vec_t axisDir = gContext.mBoundsMatrix.component[axisIndex1].Abs();

               float dtAxis = axisDir.Dot(referenceVector);
               float boundSize = bounds[axisIndex1 + 3] - bounds[axisIndex1];
               if (dtAxis > FLT_EPSILON)
               {
                  ratioAxis = axisDir.Dot(deltaVector) / dtAxis;
               }

               if (snapValues)
               {
                  float length = boundSize * ratioAxis;
                  ComputeSnap(&length, snapValues[axisIndex1]);
                  if (boundSize > FLT_EPSILON)
                  {
                     ratioAxis = length / boundSize;
                  }
               }
               scale.component[axisIndex1] *= ratioAxis;
            }

            // transform matrix
            matrix_t preScale, postScale;
            preScale.Translation(-gContext.mBoundsLocalPivot);
            postScale.Translation(gContext.mBoundsLocalPivot);
            matrix_t res = preScale * scale * postScale * gContext.mBoundsMatrix;
            *matrix = res;

            // info text
            char tmps[512];
            ImVec2 destinationPosOnScreen = worldToPos(gContext.mModel.v.position, gContext.mViewProjection);
            ImFormatString(tmps, sizeof(tmps), "X: %.2f Y: %.2f Z: %.2f"
               , (bounds[3] - bounds[0]) * gContext.mBoundsMatrix.component[0].Length() * scale.component[0].Length()
               , (bounds[4] - bounds[1]) * gContext.mBoundsMatrix.component[1].Length() * scale.component[1].Length()
               , (bounds[5] - bounds[2]) * gContext.mBoundsMatrix.component[2].Length() * scale.component[2].Length()
            );
            drawList->AddText(ImVec2(destinationPosOnScreen.x + 15, destinationPosOnScreen.y + 15), GetColorU32(TEXT_SHADOW), tmps);
            drawList->AddText(ImVec2(destinationPosOnScreen.x + 14, destinationPosOnScreen.y + 14), GetColorU32(TEXT), tmps);
         }

         if (!io.MouseDown[0]) {
            gContext.mbUsingBounds = false;
            gContext.mEditingID = -1;
         }
         if (gContext.mbUsingBounds)
         {
            break;
         }
      }
   }

   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   //

   static int GetScaleType(OPERATION op)
   {
      if (gContext.mbUsing)
      {
         return MT_NONE;
      }
      ImGuiIO& io = ImGui::GetIO();
      int type = MT_NONE;

      // screen
      if (io.MousePos.x >= gContext.mScreenSquareMin.x && io.MousePos.x <= gContext.mScreenSquareMax.x &&
         io.MousePos.y >= gContext.mScreenSquareMin.y && io.MousePos.y <= gContext.mScreenSquareMax.y &&
         Contains(op, SCALE))
      {
         type = MT_SCALE_XYZ;
      }

      // compute
      for (int i = 0; i < 3 && type == MT_NONE; i++)
      {
         if(!Intersects(op, static_cast<OPERATION>(SCALE_X << i)))
         {
            continue;
         }
         vec_t dirPlaneX, dirPlaneY, dirAxis;
         bool belowAxisLimit, belowPlaneLimit;
         ComputeTripodAxisAndVisibility(i, dirAxis, dirPlaneX, dirPlaneY, belowAxisLimit, belowPlaneLimit, true);
         dirAxis.TransformVector(gContext.mModelLocal);
         dirPlaneX.TransformVector(gContext.mModelLocal);
         dirPlaneY.TransformVector(gContext.mModelLocal);

         const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, BuildPlan(gContext.mModelLocal.v.position, dirAxis));
         vec_t posOnPlan = gContext.mRayOrigin + gContext.mRayVector * len;

         const float startOffset = Contains(op, static_cast<OPERATION>(TRANSLATE_X << i)) ? 1.0f : 0.1f;
         const float endOffset = Contains(op, static_cast<OPERATION>(TRANSLATE_X << i)) ? 1.4f : 1.0f;
         const ImVec2 posOnPlanScreen = worldToPos(posOnPlan, gContext.mViewProjection);
         const ImVec2 axisStartOnScreen = worldToPos(gContext.mModelLocal.v.position + dirAxis * gContext.mScreenFactor * startOffset, gContext.mViewProjection);
         const ImVec2 axisEndOnScreen = worldToPos(gContext.mModelLocal.v.position + dirAxis * gContext.mScreenFactor * endOffset, gContext.mViewProjection);

         vec_t closestPointOnAxis = PointOnSegment(makeVect(posOnPlanScreen), makeVect(axisStartOnScreen), makeVect(axisEndOnScreen));

         if ((closestPointOnAxis - makeVect(posOnPlanScreen)).Length() < 12.f) // pixel size
         {
            type = MT_SCALE_X + i;
         }
      }

      // universal

      vec_t deltaScreen = { io.MousePos.x - gContext.mScreenSquareCenter.x, io.MousePos.y - gContext.mScreenSquareCenter.y, 0.f, 0.f };
      float dist = deltaScreen.Length();
      if (Contains(op, SCALEU) && dist >= 17.0f && dist < 23.0f)
      {
         type = MT_SCALE_XYZ;
      }

      for (int i = 0; i < 3 && type == MT_NONE; i++)
      {
         if (!Intersects(op, static_cast<OPERATION>(SCALE_XU << i)))
         {
            continue;
         }

         vec_t dirPlaneX, dirPlaneY, dirAxis;
         bool belowAxisLimit, belowPlaneLimit;
         ComputeTripodAxisAndVisibility(i, dirAxis, dirPlaneX, dirPlaneY, belowAxisLimit, belowPlaneLimit, true);

         // draw axis
         if (belowAxisLimit)
         {
            bool hasTranslateOnAxis = Contains(op, static_cast<OPERATION>(TRANSLATE_X << i));
            float markerScale = hasTranslateOnAxis ? 1.4f : 1.0f;
            //ImVec2 baseSSpace = worldToPos(dirAxis * 0.1f * gContext.mScreenFactor, gContext.mMVPLocal);
            //ImVec2 worldDirSSpaceNoScale = worldToPos(dirAxis * markerScale * gContext.mScreenFactor, gContext.mMVP);
            ImVec2 worldDirSSpace = worldToPos((dirAxis * markerScale) * gContext.mScreenFactor, gContext.mMVPLocal);

            float distance = sqrtf(ImLengthSqr(worldDirSSpace - io.MousePos));
            if (distance < 12.f)
            {
               type = MT_SCALE_X + i;
            }
         }
      }
      return type;
   }

   static int GetRotateType(OPERATION op)
   {
      if (gContext.mbUsing)
      {
         return MT_NONE;
      }
      ImGuiIO& io = ImGui::GetIO();
      int type = MT_NONE;

      vec_t deltaScreen = { io.MousePos.x - gContext.mScreenSquareCenter.x, io.MousePos.y - gContext.mScreenSquareCenter.y, 0.f, 0.f };
      float dist = deltaScreen.Length();
      if (Intersects(op, ROTATE_SCREEN) && dist >= (gContext.mRadiusSquareCenter - 4.0f) && dist < (gContext.mRadiusSquareCenter + 4.0f))
      {
         type = MT_ROTATE_SCREEN;
      }

      const vec_t planNormals[] = { gContext.mModel.v.right, gContext.mModel.v.up, gContext.mModel.v.dir };

      vec_t modelViewPos;
      modelViewPos.TransformPoint(gContext.mModel.v.position, gContext.mViewMat);

      for (int i = 0; i < 3 && type == MT_NONE; i++)
      {
         if(!Intersects(op, static_cast<OPERATION>(ROTATE_X << i)))
         {
            continue;
         }
         // pickup plan
         vec_t pickupPlan = BuildPlan(gContext.mModel.v.position, planNormals[i]);

         const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, pickupPlan);
         const vec_t intersectWorldPos = gContext.mRayOrigin + gContext.mRayVector * len;
         vec_t intersectViewPos;
         intersectViewPos.TransformPoint(intersectWorldPos, gContext.mViewMat);

         if (ImAbs(modelViewPos.z) - ImAbs(intersectViewPos.z) < -FLT_EPSILON)
         {
            continue;
         }

         const vec_t localPos = intersectWorldPos - gContext.mModel.v.position;
         vec_t idealPosOnCircle = Normalized(localPos);
         idealPosOnCircle.TransformVector(gContext.mModelInverse);
         const ImVec2 idealPosOnCircleScreen = worldToPos(idealPosOnCircle * rotationDisplayFactor * gContext.mScreenFactor, gContext.mMVP);

         //gContext.mDrawList->AddCircle(idealPosOnCircleScreen, 5.f, IM_COL32_WHITE);
         const ImVec2 distanceOnScreen = idealPosOnCircleScreen - io.MousePos;

         const float distance = makeVect(distanceOnScreen).Length();
         if (distance < 8.f) // pixel size
         {
            type = MT_ROTATE_X + i;
         }
      }

      return type;
   }

   static int GetMoveType(OPERATION op, vec_t* gizmoHitProportion)
   {
      if(!Intersects(op, TRANSLATE) || gContext.mbUsing || !gContext.mbMouseOver)
      {
        return MT_NONE;
      }
      ImGuiIO& io = ImGui::GetIO();
      int type = MT_NONE;

      // screen
      if (io.MousePos.x >= gContext.mScreenSquareMin.x && io.MousePos.x <= gContext.mScreenSquareMax.x &&
         io.MousePos.y >= gContext.mScreenSquareMin.y && io.MousePos.y <= gContext.mScreenSquareMax.y &&
         Contains(op, TRANSLATE))
      {
         type = MT_MOVE_SCREEN;
      }

      const vec_t screenCoord = makeVect(io.MousePos - ImVec2(gContext.mX, gContext.mY));

      // compute
      for (int i = 0; i < 3 && type == MT_NONE; i++)
      {
         vec_t dirPlaneX, dirPlaneY, dirAxis;
         bool belowAxisLimit, belowPlaneLimit;
         ComputeTripodAxisAndVisibility(i, dirAxis, dirPlaneX, dirPlaneY, belowAxisLimit, belowPlaneLimit);
         dirAxis.TransformVector(gContext.mModel);
         dirPlaneX.TransformVector(gContext.mModel);
         dirPlaneY.TransformVector(gContext.mModel);

         const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, BuildPlan(gContext.mModel.v.position, dirAxis));
         vec_t posOnPlan = gContext.mRayOrigin + gContext.mRayVector * len;

         const ImVec2 axisStartOnScreen = worldToPos(gContext.mModel.v.position + dirAxis * gContext.mScreenFactor * 0.1f, gContext.mViewProjection) - ImVec2(gContext.mX, gContext.mY);
         const ImVec2 axisEndOnScreen = worldToPos(gContext.mModel.v.position + dirAxis * gContext.mScreenFactor, gContext.mViewProjection) - ImVec2(gContext.mX, gContext.mY);

         vec_t closestPointOnAxis = PointOnSegment(screenCoord, makeVect(axisStartOnScreen), makeVect(axisEndOnScreen));
         if ((closestPointOnAxis - screenCoord).Length() < 12.f && Intersects(op, static_cast<OPERATION>(TRANSLATE_X << i))) // pixel size
         {
            type = MT_MOVE_X + i;
         }

         const float dx = dirPlaneX.Dot3((posOnPlan - gContext.mModel.v.position) * (1.f / gContext.mScreenFactor));
         const float dy = dirPlaneY.Dot3((posOnPlan - gContext.mModel.v.position) * (1.f / gContext.mScreenFactor));
         if (belowPlaneLimit && dx >= quadUV[0] && dx <= quadUV[4] && dy >= quadUV[1] && dy <= quadUV[3] && Contains(op, TRANSLATE_PLANS[i]))
         {
            type = MT_MOVE_YZ + i;
         }

         if (gizmoHitProportion)
         {
            *gizmoHitProportion = makeVect(dx, dy, 0.f);
         }
      }
      return type;
   }

   static bool HandleTranslation(float* matrix, float* deltaMatrix, OPERATION op, int& type, const float* snap)
   {
      if(!Intersects(op, TRANSLATE) || type != MT_NONE)
      {
        return false;
      }
      const ImGuiIO& io = ImGui::GetIO();
      const bool applyRotationLocaly = gContext.mMode == LOCAL || type == MT_MOVE_SCREEN;
      bool modified = false;

      // move
      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID) && IsTranslateType(gContext.mCurrentOperation))
      {
#if IMGUI_VERSION_NUM >= 18723
         ImGui::SetNextFrameWantCaptureMouse(true);
#else
         ImGui::CaptureMouseFromApp();
#endif
         const float signedLength = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, gContext.mTranslationPlan);
         const float len = fabsf(signedLength); // near plan
         const vec_t newPos = gContext.mRayOrigin + gContext.mRayVector * len;

         // compute delta
         const vec_t newOrigin = newPos - gContext.mRelativeOrigin * gContext.mScreenFactor;
         vec_t delta = newOrigin - gContext.mModel.v.position;

         // 1 axis constraint
         if (gContext.mCurrentOperation >= MT_MOVE_X && gContext.mCurrentOperation <= MT_MOVE_Z)
         {
            const int axisIndex = gContext.mCurrentOperation - MT_MOVE_X;
            const vec_t& axisValue = *(vec_t*)&gContext.mModel.m[axisIndex];
            const float lengthOnAxis = Dot(axisValue, delta);
            delta = axisValue * lengthOnAxis;
         }

         // snap
         if (snap)
         {
            vec_t cumulativeDelta = gContext.mModel.v.position + delta - gContext.mMatrixOrigin;
            if (applyRotationLocaly)
            {
               matrix_t modelSourceNormalized = gContext.mModelSource;
               modelSourceNormalized.OrthoNormalize();
               matrix_t modelSourceNormalizedInverse;
               modelSourceNormalizedInverse.Inverse(modelSourceNormalized);
               cumulativeDelta.TransformVector(modelSourceNormalizedInverse);
               ComputeSnap(cumulativeDelta, snap);
               cumulativeDelta.TransformVector(modelSourceNormalized);
            }
            else
            {
               ComputeSnap(cumulativeDelta, snap);
            }
            delta = gContext.mMatrixOrigin + cumulativeDelta - gContext.mModel.v.position;

         }

         if (delta != gContext.mTranslationLastDelta)
         {
            modified = true;
         }
         gContext.mTranslationLastDelta = delta;

         // compute matrix & delta
         matrix_t deltaMatrixTranslation;
         deltaMatrixTranslation.Translation(delta);
         if (deltaMatrix)
         {
            memcpy(deltaMatrix, deltaMatrixTranslation.m16, sizeof(float) * 16);
         }

         const matrix_t res = gContext.mModelSource * deltaMatrixTranslation;
         *(matrix_t*)matrix = res;

         if (!io.MouseDown[0])
         {
            gContext.mbUsing = false;
         }

         type = gContext.mCurrentOperation;
      }
      else
      {
         // find new possible way to move
         vec_t gizmoHitProportion;
         type = GetMoveType(op, &gizmoHitProportion);
         if (type != MT_NONE)
         {
#if IMGUI_VERSION_NUM >= 18723
            ImGui::SetNextFrameWantCaptureMouse(true);
#else
            ImGui::CaptureMouseFromApp();
#endif
         }
         if (CanActivate() && type != MT_NONE)
         {
            gContext.mbUsing = true;
            gContext.mEditingID = gContext.mActualID;
            gContext.mCurrentOperation = type;
            vec_t movePlanNormal[] = { gContext.mModel.v.right, gContext.mModel.v.up, gContext.mModel.v.dir,
               gContext.mModel.v.right, gContext.mModel.v.up, gContext.mModel.v.dir,
               -gContext.mCameraDir };

            vec_t cameraToModelNormalized = Normalized(gContext.mModel.v.position - gContext.mCameraEye);
            for (unsigned int i = 0; i < 3; i++)
            {
               vec_t orthoVector = Cross(movePlanNormal[i], cameraToModelNormalized);
               movePlanNormal[i].Cross(orthoVector);
               movePlanNormal[i].Normalize();
            }
            // pickup plan
            gContext.mTranslationPlan = BuildPlan(gContext.mModel.v.position, movePlanNormal[type - MT_MOVE_X]);
            const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, gContext.mTranslationPlan);
            gContext.mTranslationPlanOrigin = gContext.mRayOrigin + gContext.mRayVector * len;
            gContext.mMatrixOrigin = gContext.mModel.v.position;

            gContext.mRelativeOrigin = (gContext.mTranslationPlanOrigin - gContext.mModel.v.position) * (1.f / gContext.mScreenFactor);
         }
      }
      return modified;
   }

   static bool HandleScale(float* matrix, float* deltaMatrix, OPERATION op, int& type, const float* snap)
   {
      if((!Intersects(op, SCALE) && !Intersects(op, SCALEU)) || type != MT_NONE || !gContext.mbMouseOver)
      {
         return false;
      }
      ImGuiIO& io = ImGui::GetIO();
      bool modified = false;

      if (!gContext.mbUsing)
      {
         // find new possible way to scale
         type = GetScaleType(op);
         if (type != MT_NONE)
         {
#if IMGUI_VERSION_NUM >= 18723
            ImGui::SetNextFrameWantCaptureMouse(true);
#else
            ImGui::CaptureMouseFromApp();
#endif
         }
         if (CanActivate() && type != MT_NONE)
         {
            gContext.mbUsing = true;
            gContext.mEditingID = gContext.mActualID;
            gContext.mCurrentOperation = type;
            const vec_t movePlanNormal[] = { gContext.mModel.v.up, gContext.mModel.v.dir, gContext.mModel.v.right, gContext.mModel.v.dir, gContext.mModel.v.up, gContext.mModel.v.right, -gContext.mCameraDir };
            // pickup plan

            gContext.mTranslationPlan = BuildPlan(gContext.mModel.v.position, movePlanNormal[type - MT_SCALE_X]);
            const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, gContext.mTranslationPlan);
            gContext.mTranslationPlanOrigin = gContext.mRayOrigin + gContext.mRayVector * len;
            gContext.mMatrixOrigin = gContext.mModel.v.position;
            gContext.mScale.Set(1.f, 1.f, 1.f);
            gContext.mRelativeOrigin = (gContext.mTranslationPlanOrigin - gContext.mModel.v.position) * (1.f / gContext.mScreenFactor);
            gContext.mScaleValueOrigin = makeVect(gContext.mModelSource.v.right.Length(), gContext.mModelSource.v.up.Length(), gContext.mModelSource.v.dir.Length());
            gContext.mSaveMousePosx = io.MousePos.x;
         }
      }
      // scale
      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID) && IsScaleType(gContext.mCurrentOperation))
      {
#if IMGUI_VERSION_NUM >= 18723
         ImGui::SetNextFrameWantCaptureMouse(true);
#else
         ImGui::CaptureMouseFromApp();
#endif
         const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, gContext.mTranslationPlan);
         vec_t newPos = gContext.mRayOrigin + gContext.mRayVector * len;
         vec_t newOrigin = newPos - gContext.mRelativeOrigin * gContext.mScreenFactor;
         vec_t delta = newOrigin - gContext.mModelLocal.v.position;

         // 1 axis constraint
         if (gContext.mCurrentOperation >= MT_SCALE_X && gContext.mCurrentOperation <= MT_SCALE_Z)
         {
            int axisIndex = gContext.mCurrentOperation - MT_SCALE_X;
            const vec_t& axisValue = *(vec_t*)&gContext.mModelLocal.m[axisIndex];
            float lengthOnAxis = Dot(axisValue, delta);
            delta = axisValue * lengthOnAxis;

            vec_t baseVector = gContext.mTranslationPlanOrigin - gContext.mModelLocal.v.position;
            float ratio = Dot(axisValue, baseVector + delta) / Dot(axisValue, baseVector);

            gContext.mScale[axisIndex] = max(ratio, 0.001f);
         }
         else
         {
            float scaleDelta = (io.MousePos.x - gContext.mSaveMousePosx) * 0.01f;
            gContext.mScale.Set(max(1.f + scaleDelta, 0.001f));
         }

         // snap
         if (snap)
         {
            float scaleSnap[] = { snap[0], snap[0], snap[0] };
            ComputeSnap(gContext.mScale, scaleSnap);
         }

         // no 0 allowed
         for (int i = 0; i < 3; i++)
            gContext.mScale[i] = max(gContext.mScale[i], 0.001f);

         if (gContext.mScaleLast != gContext.mScale)
         {
            modified = true;
         }
         gContext.mScaleLast = gContext.mScale;

         // compute matrix & delta
         matrix_t deltaMatrixScale;
         deltaMatrixScale.Scale(gContext.mScale * gContext.mScaleValueOrigin);

         matrix_t res = deltaMatrixScale * gContext.mModelLocal;
         *(matrix_t*)matrix = res;

         if (deltaMatrix)
         {
            vec_t deltaScale = gContext.mScale * gContext.mScaleValueOrigin;

            vec_t originalScaleDivider;
            originalScaleDivider.x = 1 / gContext.mModelScaleOrigin.x;
            originalScaleDivider.y = 1 / gContext.mModelScaleOrigin.y;
            originalScaleDivider.z = 1 / gContext.mModelScaleOrigin.z;

            deltaScale = deltaScale * originalScaleDivider;

            deltaMatrixScale.Scale(deltaScale);
            memcpy(deltaMatrix, deltaMatrixScale.m16, sizeof(float) * 16);
         }

         if (!io.MouseDown[0])
         {
            gContext.mbUsing = false;
            gContext.mScale.Set(1.f, 1.f, 1.f);
         }

         type = gContext.mCurrentOperation;
      }
      return modified;
   }

   static bool HandleRotation(float* matrix, float* deltaMatrix, OPERATION op, int& type, const float* snap)
   {
      if(!Intersects(op, ROTATE) || type != MT_NONE || !gContext.mbMouseOver)
      {
        return false;
      }
      ImGuiIO& io = ImGui::GetIO();
      bool applyRotationLocaly = gContext.mMode == LOCAL;
      bool modified = false;

      if (!gContext.mbUsing)
      {
         type = GetRotateType(op);

         if (type != MT_NONE)
         {
#if IMGUI_VERSION_NUM >= 18723
            ImGui::SetNextFrameWantCaptureMouse(true);
#else
            ImGui::CaptureMouseFromApp();
#endif
         }

         if (type == MT_ROTATE_SCREEN)
         {
            applyRotationLocaly = true;
         }

         if (CanActivate() && type != MT_NONE)
         {
            gContext.mbUsing = true;
            gContext.mEditingID = gContext.mActualID;
            gContext.mCurrentOperation = type;
            const vec_t rotatePlanNormal[] = { gContext.mModel.v.right, gContext.mModel.v.up, gContext.mModel.v.dir, -gContext.mCameraDir };
            // pickup plan
            if (applyRotationLocaly)
            {
               gContext.mTranslationPlan = BuildPlan(gContext.mModel.v.position, rotatePlanNormal[type - MT_ROTATE_X]);
            }
            else
            {
               gContext.mTranslationPlan = BuildPlan(gContext.mModelSource.v.position, directionUnary[type - MT_ROTATE_X]);
            }

            const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, gContext.mTranslationPlan);
            vec_t localPos = gContext.mRayOrigin + gContext.mRayVector * len - gContext.mModel.v.position;
            gContext.mRotationVectorSource = Normalized(localPos);
            gContext.mRotationAngleOrigin = ComputeAngleOnPlan();
         }
      }

      // rotation
      if (gContext.mbUsing && (gContext.mActualID == -1 || gContext.mActualID == gContext.mEditingID) && IsRotateType(gContext.mCurrentOperation))
      {
#if IMGUI_VERSION_NUM >= 18723
         ImGui::SetNextFrameWantCaptureMouse(true);
#else
         ImGui::CaptureMouseFromApp();
#endif
         gContext.mRotationAngle = ComputeAngleOnPlan();
         if (snap)
         {
            float snapInRadian = snap[0] * DEG2RAD;
            ComputeSnap(&gContext.mRotationAngle, snapInRadian);
         }
         vec_t rotationAxisLocalSpace;

         rotationAxisLocalSpace.TransformVector(makeVect(gContext.mTranslationPlan.x, gContext.mTranslationPlan.y, gContext.mTranslationPlan.z, 0.f), gContext.mModelInverse);
         rotationAxisLocalSpace.Normalize();

         matrix_t deltaRotation;
         deltaRotation.RotationAxis(rotationAxisLocalSpace, gContext.mRotationAngle - gContext.mRotationAngleOrigin);
         if (gContext.mRotationAngle != gContext.mRotationAngleOrigin)
         {
            modified = true;
         }
         gContext.mRotationAngleOrigin = gContext.mRotationAngle;

         matrix_t scaleOrigin;
         scaleOrigin.Scale(gContext.mModelScaleOrigin);

         if (applyRotationLocaly)
         {
            *(matrix_t*)matrix = scaleOrigin * deltaRotation * gContext.mModelLocal;
         }
         else
         {
            matrix_t res = gContext.mModelSource;
            res.v.position.Set(0.f);

            *(matrix_t*)matrix = res * deltaRotation;
            ((matrix_t*)matrix)->v.position = gContext.mModelSource.v.position;
         }

         if (deltaMatrix)
         {
            *(matrix_t*)deltaMatrix = gContext.mModelInverse * deltaRotation * gContext.mModel;
         }

         if (!io.MouseDown[0])
         {
            gContext.mbUsing = false;
            gContext.mEditingID = -1;
         }
         type = gContext.mCurrentOperation;
      }
      return modified;
   }

   void DecomposeMatrixToComponents(const float* matrix, float* translation, float* rotation, float* scale)
   {
      matrix_t mat = *(matrix_t*)matrix;

      scale[0] = mat.v.right.Length();
      scale[1] = mat.v.up.Length();
      scale[2] = mat.v.dir.Length();

      mat.OrthoNormalize();

      rotation[0] = RAD2DEG * atan2f(mat.m[1][2], mat.m[2][2]);
      rotation[1] = RAD2DEG * atan2f(-mat.m[0][2], sqrtf(mat.m[1][2] * mat.m[1][2] + mat.m[2][2] * mat.m[2][2]));
      rotation[2] = RAD2DEG * atan2f(mat.m[0][1], mat.m[0][0]);

      translation[0] = mat.v.position.x;
      translation[1] = mat.v.position.y;
      translation[2] = mat.v.position.z;
   }

   void RecomposeMatrixFromComponents(const float* translation, const float* rotation, const float* scale, float* matrix)
   {
      matrix_t& mat = *(matrix_t*)matrix;

      matrix_t rot[3];
      for (int i = 0; i < 3; i++)
      {
         rot[i].RotationAxis(directionUnary[i], rotation[i] * DEG2RAD);
      }

      mat = rot[0] * rot[1] * rot[2];

      float validScale[3];
      for (int i = 0; i < 3; i++)
      {
         if (fabsf(scale[i]) < FLT_EPSILON)
         {
            validScale[i] = 0.001f;
         }
         else
         {
            validScale[i] = scale[i];
         }
      }
      mat.v.right *= validScale[0];
      mat.v.up *= validScale[1];
      mat.v.dir *= validScale[2];
      mat.v.position.Set(translation[0], translation[1], translation[2], 1.f);
   }

   void SetID(int id)
   {
      gContext.mActualID = id;
   }

   void AllowAxisFlip(bool value)
   {
     gContext.mAllowAxisFlip = value;
   }

   bool Manipulate(const float* view, const float* projection, OPERATION operation, MODE mode, float* matrix, float* deltaMatrix, const float* snap, const float* localBounds, const float* boundsSnap)
   {
      // Scale is always local or matrix will be skewed when applying world scale or oriented matrix
      ComputeContext(view, projection, matrix, (operation & SCALE) ? LOCAL : mode);

      // set delta to identity
      if (deltaMatrix)
      {
         ((matrix_t*)deltaMatrix)->SetToIdentity();
      }

      // behind camera
      vec_t camSpacePosition;
      camSpacePosition.TransformPoint(makeVect(0.f, 0.f, 0.f), gContext.mMVP);
      if (!gContext.mIsOrthographic && camSpacePosition.z < 0.001f)
      {
         return false;
      }

      // --
      int type = MT_NONE;
      bool manipulated = false;
      if (gContext.mbEnable)
      {
         if (!gContext.mbUsingBounds)
         {
            manipulated = HandleTranslation(matrix, deltaMatrix, operation, type, snap) ||
                          HandleScale(matrix, deltaMatrix, operation, type, snap) ||
                          HandleRotation(matrix, deltaMatrix, operation, type, snap);
         }
      }

      if (localBounds && !gContext.mbUsing)
      {
         HandleAndDrawLocalBounds(localBounds, (matrix_t*)matrix, boundsSnap, operation);
      }

      gContext.mOperation = operation;
      if (!gContext.mbUsingBounds)
      {
         DrawRotationGizmo(operation, type);
         DrawTranslationGizmo(operation, type);
         DrawScaleGizmo(operation, type);
         DrawScaleUniveralGizmo(operation, type);
      }
      return manipulated;
   }

   void SetGizmoSizeClipSpace(float value)
   {
      gContext.mGizmoSizeClipSpace = value;
   }

   ///////////////////////////////////////////////////////////////////////////////////////////////////
   void ComputeFrustumPlanes(vec_t* frustum, const float* clip)
   {
      frustum[0].x = clip[3] - clip[0];
      frustum[0].y = clip[7] - clip[4];
      frustum[0].z = clip[11] - clip[8];
      frustum[0].w = clip[15] - clip[12];

      frustum[1].x = clip[3] + clip[0];
      frustum[1].y = clip[7] + clip[4];
      frustum[1].z = clip[11] + clip[8];
      frustum[1].w = clip[15] + clip[12];

      frustum[2].x = clip[3] + clip[1];
      frustum[2].y = clip[7] + clip[5];
      frustum[2].z = clip[11] + clip[9];
      frustum[2].w = clip[15] + clip[13];

      frustum[3].x = clip[3] - clip[1];
      frustum[3].y = clip[7] - clip[5];
      frustum[3].z = clip[11] - clip[9];
      frustum[3].w = clip[15] - clip[13];

      frustum[4].x = clip[3] - clip[2];
      frustum[4].y = clip[7] - clip[6];
      frustum[4].z = clip[11] - clip[10];
      frustum[4].w = clip[15] - clip[14];

      frustum[5].x = clip[3] + clip[2];
      frustum[5].y = clip[7] + clip[6];
      frustum[5].z = clip[11] + clip[10];
      frustum[5].w = clip[15] + clip[14];

      for (int i = 0; i < 6; i++)
      {
         frustum[i].Normalize();
      }
   }

   void DrawCubes(const float* view, const float* projection, const float* matrices, int matrixCount)
   {
      matrix_t viewInverse;
      viewInverse.Inverse(*(matrix_t*)view);

      struct CubeFace
      {
         float z;
         ImVec2 faceCoordsScreen[4];
         ImU32 color;
      };
      CubeFace* faces = (CubeFace*)_malloca(sizeof(CubeFace) * matrixCount * 6);

      if (!faces)
      {
         return;
      }

      vec_t frustum[6];
      matrix_t viewProjection = *(matrix_t*)view * *(matrix_t*)projection;
      ComputeFrustumPlanes(frustum, viewProjection.m16);

      int cubeFaceCount = 0;
      for (int cube = 0; cube < matrixCount; cube++)
      {
         const float* matrix = &matrices[cube * 16];

         matrix_t res = *(matrix_t*)matrix * *(matrix_t*)view * *(matrix_t*)projection;

         for (int iFace = 0; iFace < 6; iFace++)
         {
            const int normalIndex = (iFace % 3);
            const int perpXIndex = (normalIndex + 1) % 3;
            const int perpYIndex = (normalIndex + 2) % 3;
            const float invert = (iFace > 2) ? -1.f : 1.f;

            const vec_t faceCoords[4] = { directionUnary[normalIndex] + directionUnary[perpXIndex] + directionUnary[perpYIndex],
               directionUnary[normalIndex] + directionUnary[perpXIndex] - directionUnary[perpYIndex],
               directionUnary[normalIndex] - directionUnary[perpXIndex] - directionUnary[perpYIndex],
               directionUnary[normalIndex] - directionUnary[perpXIndex] + directionUnary[perpYIndex],
            };

            // clipping
            /*
            bool skipFace = false;
            for (unsigned int iCoord = 0; iCoord < 4; iCoord++)
            {
               vec_t camSpacePosition;
               camSpacePosition.TransformPoint(faceCoords[iCoord] * 0.5f * invert, res);
               if (camSpacePosition.z < 0.001f)
               {
                  skipFace = true;
                  break;
               }
            }
            if (skipFace)
            {
               continue;
            }
            */
            vec_t centerPosition, centerPositionVP;
            centerPosition.TransformPoint(directionUnary[normalIndex] * 0.5f * invert, *(matrix_t*)matrix);
            centerPositionVP.TransformPoint(directionUnary[normalIndex] * 0.5f * invert, res);

            bool inFrustum = true;
            for (int iFrustum = 0; iFrustum < 6; iFrustum++)
            {
               float dist = DistanceToPlane(centerPosition, frustum[iFrustum]);
               if (dist < 0.f)
               {
                  inFrustum = false;
                  break;
               }
            }

            if (!inFrustum)
            {
               continue;
            }
            CubeFace& cubeFace = faces[cubeFaceCount];

            // 3D->2D
            //ImVec2 faceCoordsScreen[4];
            for (unsigned int iCoord = 0; iCoord < 4; iCoord++)
            {
               cubeFace.faceCoordsScreen[iCoord] = worldToPos(faceCoords[iCoord] * 0.5f * invert, res);
            }

            ImU32 directionColor = GetColorU32(DIRECTION_X + normalIndex);
            cubeFace.color = directionColor | IM_COL32(0x80, 0x80, 0x80, 0);

            cubeFace.z = centerPositionVP.z / centerPositionVP.w;
            cubeFaceCount++;
         }
      }
      qsort(faces, cubeFaceCount, sizeof(CubeFace), [](void const* _a, void const* _b) {
         CubeFace* a = (CubeFace*)_a;
         CubeFace* b = (CubeFace*)_b;
         if (a->z < b->z)
         {
            return 1;
         }
         return -1;
         });
      // draw face with lighter color
      for (int iFace = 0; iFace < cubeFaceCount; iFace++)
      {
         const CubeFace& cubeFace = faces[iFace];
         gContext.mDrawList->AddConvexPolyFilled(cubeFace.faceCoordsScreen, 4, cubeFace.color);
      }

      _freea(faces);
   }

   void DrawGrid(const float* view, const float* projection, const float* matrix, const float gridSize)
   {
      matrix_t viewProjection = *(matrix_t*)view * *(matrix_t*)projection;
      vec_t frustum[6];
      ComputeFrustumPlanes(frustum, viewProjection.m16);
      matrix_t res = *(matrix_t*)matrix * viewProjection;

      for (float f = -gridSize; f <= gridSize; f += 1.f)
      {
         for (int dir = 0; dir < 2; dir++)
         {
            vec_t ptA = makeVect(dir ? -gridSize : f, 0.f, dir ? f : -gridSize);
            vec_t ptB = makeVect(dir ? gridSize : f, 0.f, dir ? f : gridSize);
            bool visible = true;
            for (int i = 0; i < 6; i++)
            {
               float dA = DistanceToPlane(ptA, frustum[i]);
               float dB = DistanceToPlane(ptB, frustum[i]);
               if (dA < 0.f && dB < 0.f)
               {
                  visible = false;
                  break;
               }
               if (dA > 0.f && dB > 0.f)
               {
                  continue;
               }
               if (dA < 0.f)
               {
                  float len = fabsf(dA - dB);
                  float t = fabsf(dA) / len;
                  ptA.Lerp(ptB, t);
               }
               if (dB < 0.f)
               {
                  float len = fabsf(dB - dA);
                  float t = fabsf(dB) / len;
                  ptB.Lerp(ptA, t);
               }
            }
            if (visible)
            {
               ImU32 col = IM_COL32(0x80, 0x80, 0x80, 0xFF);
               col = (fmodf(fabsf(f), 10.f) < FLT_EPSILON) ? IM_COL32(0x90, 0x90, 0x90, 0xFF) : col;
               col = (fabsf(f) < FLT_EPSILON) ? IM_COL32(0x40, 0x40, 0x40, 0xFF): col;

               float thickness = 1.f;
               thickness = (fmodf(fabsf(f), 10.f) < FLT_EPSILON) ? 1.5f : thickness;
               thickness = (fabsf(f) < FLT_EPSILON) ? 2.3f : thickness;

               gContext.mDrawList->AddLine(worldToPos(ptA, res), worldToPos(ptB, res), col, thickness);
            }
         }
      }
   }

   void ViewManipulate(float* view, const float* projection, OPERATION operation, MODE mode, float* matrix, float length, ImVec2 position, ImVec2 size, ImU32 backgroundColor)
   {
      // Scale is always local or matrix will be skewed when applying world scale or oriented matrix
      ComputeContext(view, projection, matrix, (operation & SCALE) ? LOCAL : mode);
      ViewManipulate(view, length, position, size, backgroundColor);
   }

   void ViewManipulate(float* view, float length, ImVec2 position, ImVec2 size, ImU32 backgroundColor)
   {
      static bool isDraging = false;
      static bool isClicking = false;
      static bool isInside = false;
      static vec_t interpolationUp;
      static vec_t interpolationDir;
      static int interpolationFrames = 0;
      const vec_t referenceUp = makeVect(0.f, 1.f, 0.f);

      matrix_t svgView, svgProjection;
      svgView = gContext.mViewMat;
      svgProjection = gContext.mProjectionMat;

      ImGuiIO& io = ImGui::GetIO();
      gContext.mDrawList->AddRectFilled(position, position + size, backgroundColor);
      matrix_t viewInverse;
      viewInverse.Inverse(*(matrix_t*)view);

      const vec_t camTarget = viewInverse.v.position - viewInverse.v.dir * length;

      // view/projection matrices
      const float distance = 3.f;
      matrix_t cubeProjection, cubeView;
      float fov = acosf(distance / (sqrtf(distance * distance + 3.f))) * RAD2DEG;
      Perspective(fov / sqrtf(2.f), size.x / size.y, 0.01f, 1000.f, cubeProjection.m16);

      vec_t dir = makeVect(viewInverse.m[2][0], viewInverse.m[2][1], viewInverse.m[2][2]);
      vec_t up = makeVect(viewInverse.m[1][0], viewInverse.m[1][1], viewInverse.m[1][2]);
      vec_t eye = dir * distance;
      vec_t zero = makeVect(0.f, 0.f);
      LookAt(&eye.x, &zero.x, &up.x, cubeView.m16);

      // set context
      gContext.mViewMat = cubeView;
      gContext.mProjectionMat = cubeProjection;
      ComputeCameraRay(gContext.mRayOrigin, gContext.mRayVector, position, size);

      const matrix_t res = cubeView * cubeProjection;

      // panels
      static const ImVec2 panelPosition[9] = { ImVec2(0.75f,0.75f), ImVec2(0.25f, 0.75f), ImVec2(0.f, 0.75f),
         ImVec2(0.75f, 0.25f), ImVec2(0.25f, 0.25f), ImVec2(0.f, 0.25f),
         ImVec2(0.75f, 0.f), ImVec2(0.25f, 0.f), ImVec2(0.f, 0.f) };

      static const ImVec2 panelSize[9] = { ImVec2(0.25f,0.25f), ImVec2(0.5f, 0.25f), ImVec2(0.25f, 0.25f),
         ImVec2(0.25f, 0.5f), ImVec2(0.5f, 0.5f), ImVec2(0.25f, 0.5f),
         ImVec2(0.25f, 0.25f), ImVec2(0.5f, 0.25f), ImVec2(0.25f, 0.25f) };

      // tag faces
      bool boxes[27]{};
      static int overBox = -1;
      for (int iPass = 0; iPass < 2; iPass++)
      {
         for (int iFace = 0; iFace < 6; iFace++)
         {
            const int normalIndex = (iFace % 3);
            const int perpXIndex = (normalIndex + 1) % 3;
            const int perpYIndex = (normalIndex + 2) % 3;
            const float invert = (iFace > 2) ? -1.f : 1.f;
            const vec_t indexVectorX = directionUnary[perpXIndex] * invert;
            const vec_t indexVectorY = directionUnary[perpYIndex] * invert;
            const vec_t boxOrigin = directionUnary[normalIndex] * -invert - indexVectorX - indexVectorY;

            // plan local space
            const vec_t n = directionUnary[normalIndex] * invert;
            vec_t viewSpaceNormal = n;
            vec_t viewSpacePoint = n * 0.5f;
            viewSpaceNormal.TransformVector(cubeView);
            viewSpaceNormal.Normalize();
            viewSpacePoint.TransformPoint(cubeView);
            const vec_t viewSpaceFacePlan = BuildPlan(viewSpacePoint, viewSpaceNormal);

            // back face culling
            if (viewSpaceFacePlan.w > 0.f)
            {
               continue;
            }

            const vec_t facePlan = BuildPlan(n * 0.5f, n);

            const float len = IntersectRayPlane(gContext.mRayOrigin, gContext.mRayVector, facePlan);
            vec_t posOnPlan = gContext.mRayOrigin + gContext.mRayVector * len - (n * 0.5f);

            float localx = Dot(directionUnary[perpXIndex], posOnPlan) * invert + 0.5f;
            float localy = Dot(directionUnary[perpYIndex], posOnPlan) * invert + 0.5f;

            // panels
            const vec_t dx = directionUnary[perpXIndex];
            const vec_t dy = directionUnary[perpYIndex];
            const vec_t origin = directionUnary[normalIndex] - dx - dy;
            for (int iPanel = 0; iPanel < 9; iPanel++)
            {
               vec_t boxCoord = boxOrigin + indexVectorX * float(iPanel % 3) + indexVectorY * float(iPanel / 3) + makeVect(1.f, 1.f, 1.f);
               const ImVec2 p = panelPosition[iPanel] * 2.f;
               const ImVec2 s = panelSize[iPanel] * 2.f;
               ImVec2 faceCoordsScreen[4];
               vec_t panelPos[4] = { dx * p.x + dy * p.y,
                                     dx * p.x + dy * (p.y + s.y),
                                     dx * (p.x + s.x) + dy * (p.y + s.y),
                                     dx * (p.x + s.x) + dy * p.y };

               for (unsigned int iCoord = 0; iCoord < 4; iCoord++)
               {
                  faceCoordsScreen[iCoord] = worldToPos((panelPos[iCoord] + origin) * 0.5f * invert, res, position, size);
               }

               const ImVec2 panelCorners[2] = { panelPosition[iPanel], panelPosition[iPanel] + panelSize[iPanel] };
               bool insidePanel = localx > panelCorners[0].x && localx < panelCorners[1].x && localy > panelCorners[0].y && localy < panelCorners[1].y;
               int boxCoordInt = int(boxCoord.x * 9.f + boxCoord.y * 3.f + boxCoord.z);
               IM_ASSERT(boxCoordInt < 27);
               boxes[boxCoordInt] |= insidePanel && (!isDraging) && gContext.mbMouseOver;

               // draw face with lighter color
               if (iPass)
               {
                  ImU32 directionColor = GetColorU32(DIRECTION_X + normalIndex);
                  gContext.mDrawList->AddConvexPolyFilled(faceCoordsScreen, 4, (directionColor | IM_COL32(0x80, 0x80, 0x80, 0x80)) | (isInside ? IM_COL32(0x08, 0x08, 0x08, 0) : 0));
                  if (boxes[boxCoordInt])
                  {
                     gContext.mDrawList->AddConvexPolyFilled(faceCoordsScreen, 4, IM_COL32(0xF0, 0xA0, 0x60, 0x80));

                     if (io.MouseDown[0] && !isClicking && !isDraging) {
                        overBox = boxCoordInt;
                        isClicking = true;
                        isDraging = true;
                     }
                  }
               }
            }
         }
      }
      if (interpolationFrames)
      {
         interpolationFrames--;
         vec_t newDir = viewInverse.v.dir;
         newDir.Lerp(interpolationDir, 0.2f);
         newDir.Normalize();

         vec_t newUp = viewInverse.v.up;
         newUp.Lerp(interpolationUp, 0.3f);
         newUp.Normalize();
         newUp = interpolationUp;
         vec_t newEye = camTarget + newDir * length;
         LookAt(&newEye.x, &camTarget.x, &newUp.x, view);
      }
      isInside = gContext.mbMouseOver && ImRect(position, position + size).Contains(io.MousePos);

      if (io.MouseDown[0] && (fabsf(io.MouseDelta[0]) || fabsf(io.MouseDelta[1])) && isClicking)
      {
         isClicking = false;
      }

      if (!io.MouseDown[0])
      {
         if (isClicking)
         {
            // apply new view direction
            int cx = overBox / 9;
            int cy = (overBox - cx * 9) / 3;
            int cz = overBox % 3;
            interpolationDir = makeVect(1.f - (float)cx, 1.f - (float)cy, 1.f - (float)cz);
            interpolationDir.Normalize();

            if (fabsf(Dot(interpolationDir, referenceUp)) > 1.0f - 0.01f)
            {
               vec_t right = viewInverse.v.right;
               if (fabsf(right.x) > fabsf(right.z))
               {
                  right.z = 0.f;
               }
               else
               {
                  right.x = 0.f;
               }
               right.Normalize();
               interpolationUp = Cross(interpolationDir, right);
               interpolationUp.Normalize();
            }
            else
            {
               interpolationUp = referenceUp;
            }
            interpolationFrames = 40;
            
         }
         isClicking = false;
         isDraging = false;
      }


      if (isDraging)
      {
         matrix_t rx, ry, roll;

         rx.RotationAxis(referenceUp, -io.MouseDelta.x * 0.01f);
         ry.RotationAxis(viewInverse.v.right, -io.MouseDelta.y * 0.01f);

         roll = rx * ry;

         vec_t newDir = viewInverse.v.dir;
         newDir.TransformVector(roll);
         newDir.Normalize();

         // clamp
         vec_t planDir = Cross(viewInverse.v.right, referenceUp);
         planDir.y = 0.f;
         planDir.Normalize();
         float dt = Dot(planDir, newDir);
         if (dt < 0.0f)
         {
            newDir += planDir * dt;
            newDir.Normalize();
         }

         vec_t newEye = camTarget + newDir * length;
         LookAt(&newEye.x, &camTarget.x, &referenceUp.x, view);
      }

      // restore view/projection because it was used to compute ray
      ComputeContext(svgView.m16, svgProjection.m16, gContext.mModelSource.m16, gContext.mMode);
   }
};


================================================
FILE: Source/External/imgui_tools/imguizmo/ImGuizmo.h
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -------------------------------------------------------------------------------------------
// History :
// 2019/11/03 View gizmo
// 2016/09/11 Behind camera culling. Scaling Delta matrix not multiplied by source matrix scales. local/world rotation and translation fixed. Display message is incorrect (X: ... Y:...) in local mode.
// 2016/09/09 Hatched negative axis. Snapping. Documentation update.
// 2016/09/04 Axis switch and translation plan autohiding. Scale transform stability improved
// 2016/09/01 Mogwai changed to Manipulate. Draw debug cube. Fixed inverted scale. Mixing scale and translation/rotation gives bad results.
// 2016/08/31 First version
//
// -------------------------------------------------------------------------------------------
// Future (no order):
//
// - Multi view
// - display rotation/translation/scale infos in local/world space and not only local
// - finish local/world matrix application
// - OPERATION as bitmask
// 
// -------------------------------------------------------------------------------------------
// Example 
#if 0
void EditTransform(const Camera& camera, matrix_t& matrix)
{
   static ImGuizmo::OPERATION mCurrentGizmoOperation(ImGuizmo::ROTATE);
   static ImGuizmo::MODE mCurrentGizmoMode(ImGuizmo::WORLD);
   if (ImGui::IsKeyPressed(90))
      mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
   if (ImGui::IsKeyPressed(69))
      mCurrentGizmoOperation = ImGuizmo::ROTATE;
   if (ImGui::IsKeyPressed(82)) // r Key
      mCurrentGizmoOperation = ImGuizmo::SCALE;
   if (ImGui::RadioButton("Translate", mCurrentGizmoOperation == ImGuizmo::TRANSLATE))
      mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
   ImGui::SameLine();
   if (ImGui::RadioButton("Rotate", mCurrentGizmoOperation == ImGuizmo::ROTATE))
      mCurrentGizmoOperation = ImGuizmo::ROTATE;
   ImGui::SameLine();
   if (ImGui::RadioButton("Scale", mCurrentGizmoOperation == ImGuizmo::SCALE))
      mCurrentGizmoOperation = ImGuizmo::SCALE;
   float matrixTranslation[3], matrixRotation[3], matrixScale[3];
   ImGuizmo::DecomposeMatrixToComponents(matrix.m16, matrixTranslation, matrixRotation, matrixScale);
   ImGui::InputFloat3("Tr", matrixTranslation, 3);
   ImGui::InputFloat3("Rt", matrixRotation, 3);
   ImGui::InputFloat3("Sc", matrixScale, 3);
   ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, matrix.m16);

   if (mCurrentGizmoOperation != ImGuizmo::SCALE)
   {
      if (ImGui::RadioButton("Local", mCurrentGizmoMode == ImGuizmo::LOCAL))
         mCurrentGizmoMode = ImGuizmo::LOCAL;
      ImGui::SameLine();
      if (ImGui::RadioButton("World", mCurrentGizmoMode == ImGuizmo::WORLD))
         mCurrentGizmoMode = ImGuizmo::WORLD;
   }
   static bool useSnap(false);
   if (ImGui::IsKeyPressed(83))
      useSnap = !useSnap;
   ImGui::Checkbox("", &useSnap);
   ImGui::SameLine();
   vec_t snap;
   switch (mCurrentGizmoOperation)
   {
   case ImGuizmo::TRANSLATE:
      snap = config.mSnapTranslation;
      ImGui::InputFloat3("Snap", &snap.x);
      break;
   case ImGuizmo::ROTATE:
      snap = config.mSnapRotation;
      ImGui::InputFloat("Angle Snap", &snap.x);
      break;
   case ImGuizmo::SCALE:
      snap = config.mSnapScale;
      ImGui::InputFloat("Scale Snap", &snap.x);
      break;
   }
   ImGuiIO& io = ImGui::GetIO();
   ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y);
   ImGuizmo::Manipulate(camera.mView.m16, camera.mProjection.m16, mCurrentGizmoOperation, mCurrentGizmoMode, matrix.m16, NULL, useSnap ? &snap.x : NULL);
}
#endif
#pragma once

#ifdef USE_IMGUI_API
#include "imconfig.h"
#endif
#ifndef IMGUI_API
#define IMGUI_API
#endif

#ifndef IMGUIZMO_NAMESPACE
#define IMGUIZMO_NAMESPACE ImGuizmo
#endif

namespace IMGUIZMO_NAMESPACE
{
   // call inside your own window and before Manipulate() in order to draw gizmo to that window.
   // Or pass a specific ImDrawList to draw to (e.g. ImGui::GetForegroundDrawList()).
   IMGUI_API void SetDrawlist(ImDrawList* drawlist = nullptr);

   // call BeginFrame right after ImGui_XXXX_NewFrame();
   IMGUI_API void BeginFrame();

   // this is necessary because when imguizmo is compiled into a dll, and imgui into another
   // globals are not shared between them.
   // More details at https://stackoverflow.com/questions/19373061/what-happens-to-global-and-static-variables-in-a-shared-library-when-it-is-dynam
   // expose method to set imgui context
   IMGUI_API void SetImGuiContext(ImGuiContext* ctx);

   // return true if mouse cursor is over any gizmo control (axis, plan or screen component)
   IMGUI_API bool IsOver();

   // return true if mouse IsOver or if the gizmo is in moving state
   IMGUI_API bool IsUsing();

   // enable/disable the gizmo. Stay in the state until next call to Enable.
   // gizmo is rendered with gray half transparent color when disabled
   IMGUI_API void Enable(bool enable);

   // helper functions for manualy editing translation/rotation/scale with an input float
   // translation, rotation and scale float points to 3 floats each
   // Angles are in degrees (more suitable for human editing)
   // example:
   // float matrixTranslation[3], matrixRotation[3], matrixScale[3];
   // ImGuizmo::DecomposeMatrixToComponents(gizmoMatrix.m16, matrixTranslation, matrixRotation, matrixScale);
   // ImGui::InputFloat3("Tr", matrixTranslation, 3);
   // ImGui::InputFloat3("Rt", matrixRotation, 3);
   // ImGui::InputFloat3("Sc", matrixScale, 3);
   // ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, gizmoMatrix.m16);
   //
   // These functions have some numerical stability issues for now. Use with caution.
   IMGUI_API void DecomposeMatrixToComponents(const float* matrix, float* translation, float* rotation, float* scale);
   IMGUI_API void RecomposeMatrixFromComponents(const float* translation, const float* rotation, const float* scale, float* matrix);

   IMGUI_API void SetRect(float x, float y, float width, float height);
   // default is false
   IMGUI_API void SetOrthographic(bool isOrthographic);

   // Render a cube with face color corresponding to face normal. Usefull for debug/tests
   IMGUI_API void DrawCubes(const float* view, const float* projection, const float* matrices, int matrixCount);
   IMGUI_API void DrawGrid(const float* view, const float* projection, const float* matrix, const float gridSize);

   // call it when you want a gizmo
   // Needs view and projection matrices. 
   // matrix parameter is the source matrix (where will be gizmo be drawn) and might be transformed by the function. Return deltaMatrix is optional
   // translation is applied in world space
   enum OPERATION
   {
      TRANSLATE_X      = (1u << 0),
      TRANSLATE_Y      = (1u << 1),
      TRANSLATE_Z      = (1u << 2),
      ROTATE_X         = (1u << 3),
      ROTATE_Y         = (1u << 4),
      ROTATE_Z         = (1u << 5),
      ROTATE_SCREEN    = (1u << 6),
      SCALE_X          = (1u << 7),
      SCALE_Y          = (1u << 8),
      SCALE_Z          = (1u << 9),
      BOUNDS           = (1u << 10),
      SCALE_XU         = (1u << 11),
      SCALE_YU         = (1u << 12),
      SCALE_ZU         = (1u << 13),

      TRANSLATE = TRANSLATE_X | TRANSLATE_Y | TRANSLATE_Z,
      ROTATE = ROTATE_X | ROTATE_Y | ROTATE_Z | ROTATE_SCREEN,
      SCALE = SCALE_X | SCALE_Y | SCALE_Z,
      SCALEU = SCALE_XU | SCALE_YU | SCALE_ZU, // universal
      UNIVERSAL = TRANSLATE | ROTATE | SCALEU
   };

   inline OPERATION operator|(OPERATION lhs, OPERATION rhs)
   {
     return static_cast<OPERATION>(static_cast<int>(lhs) | static_cast<int>(rhs));
   }

   enum MODE
   {
      LOCAL,
      WORLD
   };

   IMGUI_API bool Manipulate(const float* view, const float* projection, OPERATION operation, MODE mode, float* matrix, float* deltaMatrix = NULL, const float* snap = NULL, const float* localBounds = NULL, const float* boundsSnap = NULL);
   //
   // Please note that this cubeview is patented by Autodesk : https://patents.google.com/patent/US7782319B2/en
   // It seems to be a defensive patent in the US. I don't think it will bring troubles using it as
   // other software are using the same mechanics. But just in case, you are now warned!
   //
   IMGUI_API void ViewManipulate(float* view, float length, ImVec2 position, ImVec2 size, ImU32 backgroundColor);

   // use this version if you did not call Manipulate before and you are just using ViewManipulate
   IMGUI_API void ViewManipulate(float* view, const float* projection, OPERATION operation, MODE mode, float* matrix, float length, ImVec2 position, ImVec2 size, ImU32 backgroundColor);

   IMGUI_API void SetID(int id);

   // return true if the cursor is over the operation's gizmo
   IMGUI_API bool IsOver(OPERATION op);
   IMGUI_API void SetGizmoSizeClipSpace(float value);

   // Allow axis to flip
   // When true (default), the guizmo axis flip for better visibility
   // When false, they always stay along the positive world/local axis
   IMGUI_API void AllowAxisFlip(bool value);

   enum COLOR
   {
      DIRECTION_X,      // directionColor[0]
      DIRECTION_Y,      // directionColor[1]
      DIRECTION_Z,      // directionColor[2]
      PLANE_X,          // planeColor[0]
      PLANE_Y,          // planeColor[1]
      PLANE_Z,          // planeColor[2]
      SELECTION,        // selectionColor
      INACTIVE,         // inactiveColor
      TRANSLATION_LINE, // translationLineColor
      SCALE_LINE,
      ROTATION_USING_BORDER,
      ROTATION_USING_FILL,
      HATCHED_AXIS_LINES,
      TEXT,
      TEXT_SHADOW,
      COUNT
   };

   struct Style
   {
      IMGUI_API Style();

      float TranslationLineThickness;   // Thickness of lines for translation gizmo
      float TranslationLineArrowSize;   // Size of arrow at the end of lines for translation gizmo
      float RotationLineThickness;      // Thickness of lines for rotation gizmo
      float RotationOuterLineThickness; // Thickness of line surrounding the rotation gizmo
      float ScaleLineThickness;         // Thickness of lines for scale gizmo
      float ScaleLineCircleSize;        // Size of circle at the end of lines for scale gizmo
      float HatchedAxisLineThickness;   // Thickness of hatched axis lines
      float CenterCircleSize;           // Size of circle at the center of the translate/scale gizmo

      ImVec4 Colors[COLOR::COUNT];
   };

   IMGUI_API Style& GetStyle();
}


================================================
FILE: Source/External/imgui_tools/imguizmo/ImSequencer.cpp
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#include "ImSequencer.h"
#include "imgui.h"
#include "imgui_internal.h"
#include <cstdlib>

namespace ImSequencer
{
#ifndef IMGUI_DEFINE_MATH_OPERATORS
   static ImVec2 operator+(const ImVec2& a, const ImVec2& b) {
      return ImVec2(a.x + b.x, a.y + b.y);
   }
#endif
   static bool SequencerAddDelButton(ImDrawList* draw_list, ImVec2 pos, bool add = true)
   {
      ImGuiIO& io = ImGui::GetIO();
      ImRect btnRect(pos, ImVec2(pos.x + 16, pos.y + 16));
      bool overBtn = btnRect.Contains(io.MousePos);
      bool containedClick = overBtn && btnRect.Contains(io.MouseClickedPos[0]);
      bool clickedBtn = containedClick && io.MouseReleased[0];
      int btnColor = overBtn ? 0xAAEAFFAA : 0x77A3B2AA;
      if (containedClick && io.MouseDownDuration[0] > 0)
         btnRect.Expand(2.0f);

      float midy = pos.y + 16 / 2 - 0.5f;
      float midx = pos.x + 16 / 2 - 0.5f;
      draw_list->AddRect(btnRect.Min, btnRect.Max, btnColor, 4);
      draw_list->AddLine(ImVec2(btnRect.Min.x + 3, midy), ImVec2(btnRect.Max.x - 3, midy), btnColor, 2);
      if (add)
         draw_list->AddLine(ImVec2(midx, btnRect.Min.y + 3), ImVec2(midx, btnRect.Max.y - 3), btnColor, 2);
      return clickedBtn;
   }

   bool Sequencer(SequenceInterface* sequence, int* currentFrame, bool* expanded, int* selectedEntry, int* firstFrame, int sequenceOptions)
   {
      bool ret = false;
      ImGuiIO& io = ImGui::GetIO();
      int cx = (int)(io.MousePos.x);
      int cy = (int)(io.MousePos.y);
      static float framePixelWidth = 10.f;
      static float framePixelWidthTarget = 10.f;
      int legendWidth = 200;

      static int movingEntry = -1;
      static int movingPos = -1;
      static int movingPart = -1;
      int delEntry = -1;
      int dupEntry = -1;
      int ItemHeight = 20;

      bool popupOpened = false;
      int sequenceCount = sequence->GetItemCount();
      if (!sequenceCount)
         return false;
      ImGui::BeginGroup();

      ImDrawList* draw_list = ImGui::GetWindowDrawList();
      ImVec2 canvas_pos = ImGui::GetCursorScreenPos();            // ImDrawList API uses screen coordinates!
      ImVec2 canvas_size = ImGui::GetContentRegionAvail();        // Resize canvas to what's available
      int firstFrameUsed = firstFrame ? *firstFrame : 0;


      int controlHeight = sequenceCount * ItemHeight;
      for (int i = 0; i < sequenceCount; i++)
         controlHeight += int(sequence->GetCustomHeight(i));
      int frameCount = ImMax(sequence->GetFrameMax() - sequence->GetFrameMin(), 1);

      static bool MovingScrollBar = false;
      static bool MovingCurrentFrame = false;
      struct CustomDraw
      {
         int index;
         ImRect customRect;
         ImRect legendRect;
         ImRect clippingRect;
         ImRect legendClippingRect;
      };
      ImVector<CustomDraw> customDraws;
      ImVector<CustomDraw> compactCustomDraws;
      // zoom in/out
      const int visibleFrameCount = (int)floorf((canvas_size.x - legendWidth) / framePixelWidth);
      const float barWidthRatio = ImMin(visibleFrameCount / (float)frameCount, 1.f);
      const float barWidthInPixels = barWidthRatio * (canvas_size.x - legendWidth);

      ImRect regionRect(canvas_pos, canvas_pos + canvas_size);

      static bool panningView = false;
      static ImVec2 panningViewSource;
      static int panningViewFrame;
      if (ImGui::IsWindowFocused() && io.KeyAlt && io.MouseDown[2])
      {
         if (!panningView)
         {
            panningViewSource = io.MousePos;
            panningView = true;
            panningViewFrame = *firstFrame;
         }
         *firstFrame = panningViewFrame - int((io.MousePos.x - panningViewSource.x) / framePixelWidth);
         *firstFrame = ImClamp(*firstFrame, sequence->GetFrameMin(), sequence->GetFrameMax() - visibleFrameCount);
      }
      if (panningView && !io.MouseDown[2])
      {
         panningView = false;
      }
      framePixelWidthTarget = ImClamp(framePixelWidthTarget, 0.1f, 50.f);

      framePixelWidth = ImLerp(framePixelWidth, framePixelWidthTarget, 0.33f);

      frameCount = sequence->GetFrameMax() - sequence->GetFrameMin();
      if (visibleFrameCount >= frameCount && firstFrame)
         *firstFrame = sequence->GetFrameMin();


      // --
      if (expanded && !*expanded)
      {
         ImGui::InvisibleButton("canvas", ImVec2(canvas_size.x - canvas_pos.x, (float)ItemHeight));
         draw_list->AddRectFilled(canvas_pos, ImVec2(canvas_size.x + canvas_pos.x, canvas_pos.y + ItemHeight), 0xFF3D3837, 0);
         char tmps[512];
         ImFormatString(tmps, IM_ARRAYSIZE(tmps), sequence->GetCollapseFmt(), frameCount, sequenceCount);
         draw_list->AddText(ImVec2(canvas_pos.x + 26, canvas_pos.y + 2), 0xFFFFFFFF, tmps);
      }
      else
      {
         bool hasScrollBar(true);
         /*
         int framesPixelWidth = int(frameCount * framePixelWidth);
         if ((framesPixelWidth + legendWidth) >= canvas_size.x)
         {
             hasScrollBar = true;
         }
         */
         // test scroll area
         ImVec2 headerSize(canvas_size.x, (float)ItemHeight);
         ImVec2 scrollBarSize(canvas_size.x, 14.f);
         ImGui::InvisibleButton("topBar", headerSize);
         draw_list->AddRectFilled(canvas_pos, canvas_pos + headerSize, 0xFFFF0000, 0);
         ImVec2 childFramePos = ImGui::GetCursorScreenPos();
         ImVec2 childFrameSize(canvas_size.x, canvas_size.y - 8.f - headerSize.y - (hasScrollBar ? scrollBarSize.y : 0));
         ImGui::PushStyleColor(ImGuiCol_FrameBg, 0);
         ImGui::BeginChildFrame(889, childFrameSize);
         sequence->focused = ImGui::IsWindowFocused();
         ImGui::InvisibleButton("contentBar", ImVec2(canvas_size.x, float(controlHeight)));
         const ImVec2 contentMin = ImGui::GetItemRectMin();
         const ImVec2 contentMax = ImGui::GetItemRectMax();
         const ImRect contentRect(contentMin, contentMax);
         const float contentHeight = contentMax.y - contentMin.y;

         // full background
         draw_list->AddRectFilled(canvas_pos, canvas_pos + canvas_size, 0xFF242424, 0);

         // current frame top
         ImRect topRect(ImVec2(canvas_pos.x + legendWidth, canvas_pos.y), ImVec2(canvas_pos.x + canvas_size.x, canvas_pos.y + ItemHeight));

         if (!MovingCurrentFrame && !MovingScrollBar && movingEntry == -1 && sequenceOptions & SEQUENCER_CHANGE_FRAME && currentFrame && *currentFrame >= 0 && topRect.Contains(io.MousePos) && io.MouseDown[0])
         {
            MovingCurrentFrame = true;
         }
         if (MovingCurrentFrame)
         {
            if (frameCount)
            {
               *currentFrame = (int)((io.MousePos.x - topRect.Min.x) / framePixelWidth) + firstFrameUsed;
               if (*currentFrame < sequence->GetFrameMin())
                  *currentFrame = sequence->GetFrameMin();
               if (*currentFrame >= sequence->GetFrameMax())
                  *currentFrame = sequence->GetFrameMax();
            }
            if (!io.MouseDown[0])
               MovingCurrentFrame = false;
         }

         //header
         draw_list->AddRectFilled(canvas_pos, ImVec2(canvas_size.x + canvas_pos.x, canvas_pos.y + ItemHeight), 0xFF3D3837, 0);
         if (sequenceOptions & SEQUENCER_ADD)
         {
            if (SequencerAddDelButton(draw_list, ImVec2(canvas_pos.x + legendWidth - ItemHeight, canvas_pos.y + 2), true))
               ImGui::OpenPopup("addEntry");

            if (ImGui::BeginPopup("addEntry"))
            {
               for (int i = 0; i < sequence->GetItemTypeCount(); i++)
                  if (ImGui::Selectable(sequence->GetItemTypeName(i)))
                  {
                     sequence->Add(i);
                     *selectedEntry = sequence->GetItemCount() - 1;
                  }

               ImGui::EndPopup();
               popupOpened = true;
            }
         }

         //header frame number and lines
         int modFrameCount = 10;
         int frameStep = 1;
         while ((modFrameCount * framePixelWidth) < 150)
         {
            modFrameCount *= 2;
            frameStep *= 2;
         };
         int halfModFrameCount = modFrameCount / 2;

         auto drawLine = [&](int i, int regionHeight) {
            bool baseIndex = ((i % modFrameCount) == 0) || (i == sequence->GetFrameMax() || i == sequence->GetFrameMin());
            bool halfIndex = (i % halfModFrameCount) == 0;
            int px = (int)canvas_pos.x + int(i * framePixelWidth) + legendWidth - int(firstFrameUsed * framePixelWidth);
            int tiretStart = baseIndex ? 4 : (halfIndex ? 10 : 14);
            int tiretEnd = baseIndex ? regionHeight : ItemHeight;

            if (px <= (canvas_size.x + canvas_pos.x) && px >= (canvas_pos.x + legendWidth))
            {
               draw_list->AddLine(ImVec2((float)px, canvas_pos.y + (float)tiretStart), ImVec2((float)px, canvas_pos.y + (float)tiretEnd - 1), 0xFF606060, 1);

               draw_list->AddLine(ImVec2((float)px, canvas_pos.y + (float)ItemHeight), ImVec2((float)px, canvas_pos.y + (float)regionHeight - 1), 0x30606060, 1);
            }

            if (baseIndex && px > (canvas_pos.x + legendWidth))
            {
               char tmps[512];
               ImFormatString(tmps, IM_ARRAYSIZE(tmps), "%d", i);
               draw_list->AddText(ImVec2((float)px + 3.f, canvas_pos.y), 0xFFBBBBBB, tmps);
            }

         };

         auto drawLineContent = [&](int i, int /*regionHeight*/) {
            int px = (int)canvas_pos.x + int(i * framePixelWidth) + legendWidth - int(firstFrameUsed * framePixelWidth);
            int tiretStart = int(contentMin.y);
            int tiretEnd = int(contentMax.y);

            if (px <= (canvas_size.x + canvas_pos.x) && px >= (canvas_pos.x + legendWidth))
            {
               //draw_list->AddLine(ImVec2((float)px, canvas_pos.y + (float)tiretStart), ImVec2((float)px, canvas_pos.y + (float)tiretEnd - 1), 0xFF606060, 1);

               draw_list->AddLine(ImVec2(float(px), float(tiretStart)), ImVec2(float(px), float(tiretEnd)), 0x30606060, 1);
            }
         };
         for (int i = sequence->GetFrameMin(); i <= sequence->GetFrameMax(); i += frameStep)
         {
            drawLine(i, ItemHeight);
         }
         drawLine(sequence->GetFrameMin(), ItemHeight);
         drawLine(sequence->GetFrameMax(), ItemHeight);
         /*
                  draw_list->AddLine(canvas_pos, ImVec2(canvas_pos.x, canvas_pos.y + controlHeight), 0xFF000000, 1);
                  draw_list->AddLine(ImVec2(canvas_pos.x, canvas_pos.y + ItemHeight), ImVec2(canvas_size.x, canvas_pos.y + ItemHeight), 0xFF000000, 1);
                  */
                  // clip content

         draw_list->PushClipRect(childFramePos, childFramePos + childFrameSize, true);

         // draw item names in the legend rect on the left
         size_t customHeight = 0;
         for (int i = 0; i < sequenceCount; i++)
         {
            int type;
            sequence->Get(i, NULL, NULL, &type, NULL);
            ImVec2 tpos(contentMin.x + 3, contentMin.y + i * ItemHeight + 2 + customHeight);
            draw_list->AddText(tpos, 0xFFFFFFFF, sequence->GetItemLabel(i));

            if (sequenceOptions & SEQUENCER_DEL)
            {
               if (SequencerAddDelButton(draw_list, ImVec2(contentMin.x + legendWidth - ItemHeight + 2 - 10, tpos.y + 2), false))
                  delEntry = i;

               if (SequencerAddDelButton(draw_list, ImVec2(contentMin.x + legendWidth - ItemHeight - ItemHeight + 2 - 10, tpos.y + 2), true))
                  dupEntry = i;
            }
            customHeight += sequence->GetCustomHeight(i);
         }

         // slots background
         customHeight = 0;
         for (int i = 0; i < sequenceCount; i++)
         {
            unsigned int col = (i & 1) ? 0xFF3A3636 : 0xFF413D3D;

            size_t localCustomHeight = sequence->GetCustomHeight(i);
            ImVec2 pos = ImVec2(contentMin.x + legendWidth, contentMin.y + ItemHeight * i + 1 + customHeight);
            ImVec2 sz = ImVec2(canvas_size.x + canvas_pos.x, pos.y + ItemHeight - 1 + localCustomHeight);
            if (!popupOpened && cy >= pos.y && cy < pos.y + (ItemHeight + localCustomHeight) && movingEntry == -1 && cx>contentMin.x && cx < contentMin.x + canvas_size.x)
            {
               col += 0x80201008;
               pos.x -= legendWidth;
            }
            draw_list->AddRectFilled(pos, sz, col, 0);
            customHeight += localCustomHeight;
         }

         draw_list->PushClipRect(childFramePos + ImVec2(float(legendWidth), 0.f), childFramePos + childFrameSize, true);

         // vertical frame lines in content area
         for (int i = sequence->GetFrameMin(); i <= sequence->GetFrameMax(); i += frameStep)
         {
            drawLineContent(i, int(contentHeight));
         }
         drawLineContent(sequence->GetFrameMin(), int(contentHeight));
         drawLineContent(sequence->GetFrameMax(), int(contentHeight));

         // selection
         bool selected = selectedEntry && (*selectedEntry >= 0);
         if (selected)
         {
            customHeight = 0;
            for (int i = 0; i < *selectedEntry; i++)
               customHeight += sequence->GetCustomHeight(i);
            draw_list->AddRectFilled(ImVec2(contentMin.x, contentMin.y + ItemHeight * *selectedEntry + customHeight), ImVec2(contentMin.x + canvas_size.x, contentMin.y + ItemHeight * (*selectedEntry + 1) + customHeight), 0x801080FF, 1.f);
         }

         // slots
         customHeight = 0;
         for (int i = 0; i < sequenceCount; i++)
         {
            int* start, * end;
            unsigned int color;
            sequence->Get(i, &start, &end, NULL, &color);
            size_t localCustomHeight = sequence->GetCustomHeight(i);

            ImVec2 pos = ImVec2(contentMin.x + legendWidth - firstFrameUsed * framePixelWidth, contentMin.y + ItemHeight * i + 1 + customHeight);
            ImVec2 slotP1(pos.x + *start * framePixelWidth, pos.y + 2);
            ImVec2 slotP2(pos.x + *end * framePixelWidth + framePixelWidth, pos.y + ItemHeight - 2);
            ImVec2 slotP3(pos.x + *end * framePixelWidth + framePixelWidth, pos.y + ItemHeight - 2 + localCustomHeight);
            unsigned int slotColor = color | 0xFF000000;
            unsigned int slotColorHalf = (color & 0xFFFFFF) | 0x40000000;

            if (slotP1.x <= (canvas_size.x + contentMin.x) && slotP2.x >= (contentMin.x + legendWidth))
            {
               draw_list->AddRectFilled(slotP1, slotP3, slotColorHalf, 2);
               draw_list->AddRectFilled(slotP1, slotP2, slotColor, 2);
            }
            if (ImRect(slotP1, slotP2).Contains(io.MousePos) && io.MouseDoubleClicked[0])
            {
               sequence->DoubleClick(i);
            }
            // Ensure grabbable handles
            const float max_handle_width = slotP2.x - slotP1.x / 3.0f;
            const float min_handle_width = ImMin(10.0f, max_handle_width);
            const float handle_width = ImClamp(framePixelWidth / 2.0f, min_handle_width, max_handle_width);
            ImRect rects[3] = { ImRect(slotP1, ImVec2(slotP1.x + handle_width, slotP2.y))
                , ImRect(ImVec2(slotP2.x - handle_width, slotP1.y), slotP2)
                , ImRect(slotP1, slotP2) };

            const unsigned int quadColor[] = { 0xFFFFFFFF, 0xFFFFFFFF, slotColor + (selected ? 0 : 0x202020) };
            if (movingEntry == -1 && (sequenceOptions & SEQUENCER_EDIT_STARTEND))// TODOFOCUS && backgroundRect.Contains(io.MousePos))
            {
               for (int j = 2; j >= 0; j--)
               {
                  ImRect& rc = rects[j];
                  if (!rc.Contains(io.MousePos))
                     continue;
                  draw_list->AddRectFilled(rc.Min, rc.Max, quadColor[j], 2);
               }

               for (int j = 0; j < 3; j++)
               {
                  ImRect& rc = rects[j];
                  if (!rc.Contains(io.MousePos))
                     continue;
                  if (!ImRect(childFramePos, childFramePos + childFrameSize).Contains(io.MousePos))
                     continue;
                  if (ImGui::IsMouseClicked(0) && !MovingScrollBar && !MovingCurrentFrame)
                  {
                     movingEntry = i;
                     movingPos = cx;
                     movingPart = j + 1;
                     sequence->BeginEdit(movingEntry);
                     break;
                  }
               }
            }

            // custom draw
            if (localCustomHeight > 0)
            {
               ImVec2 rp(canvas_pos.x, contentMin.y + ItemHeight * i + 1 + customHeight);
               ImRect customRect(rp + ImVec2(legendWidth - (firstFrameUsed - sequence->GetFrameMin() - 0.5f) * framePixelWidth, float(ItemHeight)),
                  rp + ImVec2(legendWidth + (sequence->GetFrameMax() - firstFrameUsed - 0.5f + 2.f) * framePixelWidth, float(localCustomHeight + ItemHeight)));
               ImRect clippingRect(rp + ImVec2(float(legendWidth), float(ItemHeight)), rp + ImVec2(canvas_size.x, float(localCustomHeight + ItemHeight)));

               ImRect legendRect(rp + ImVec2(0.f, float(ItemHeight)), rp + ImVec2(float(legendWidth), float(localCustomHeight)));
               ImRect legendClippingRect(canvas_pos + ImVec2(0.f, float(ItemHeight)), canvas_pos + ImVec2(float(legendWidth), float(localCustomHeight + ItemHeight)));
               customDraws.push_back({ i, customRect, legendRect, clippingRect, legendClippingRect });
            }
            else
            {
               ImVec2 rp(canvas_pos.x, contentMin.y + ItemHeight * i + customHeight);
               ImRect customRect(rp + ImVec2(legendWidth - (firstFrameUsed - sequence->GetFrameMin() - 0.5f) * framePixelWidth, float(0.f)),
                  rp + ImVec2(legendWidth + (sequence->GetFrameMax() - firstFrameUsed - 0.5f + 2.f) * framePixelWidth, float(ItemHeight)));
               ImRect clippingRect(rp + ImVec2(float(legendWidth), float(0.f)), rp + ImVec2(canvas_size.x, float(ItemHeight)));

               compactCustomDraws.push_back({ i, customRect, ImRect(), clippingRect, ImRect() });
            }
            customHeight += localCustomHeight;
         }


         // moving
         if (/*backgroundRect.Contains(io.MousePos) && */movingEntry >= 0)
         {
#if IMGUI_VERSION_NUM >= 18723
            ImGui::SetNextFrameWantCaptureMouse(true);
#else
            ImGui::CaptureMouseFromApp();
#endif
            int diffFrame = int((cx - movingPos) / framePixelWidth);
            if (std::abs(diffFrame) > 0)
            {
               int* start, * end;
               sequence->Get(movingEntry, &start, &end, NULL, NULL);
               if (selectedEntry)
                  *selectedEntry = movingEntry;
               int& l = *start;
               int& r = *end;
               if (movingPart & 1)
                  l += diffFrame;
               if (movingPart & 2)
                  r += diffFrame;
               if (l < 0)
               {
                  if (movingPart & 2)
                     r -= l;
                  l = 0;
               }
               if (movingPart & 1 && l > r)
                  l = r;
               if (movingPart & 2 && r < l)
                  r = l;
               movingPos += int(diffFrame * framePixelWidth);
            }
            if (!io.MouseDown[0])
            {
               // single select
               if (!diffFrame && movingPart && selectedEntry)
               {
                  *selectedEntry = movingEntry;
                  ret = true;
               }

               movingEntry = -1;
               sequence->EndEdit();
            }
         }

         // cursor
         if (currentFrame && firstFrame && *currentFrame >= *firstFrame && *currentFrame <= sequence->GetFrameMax())
         {
            static const float cursorWidth = 8.f;
            float cursorOffset = contentMin.x + legendWidth + (*currentFrame - firstFrameUsed) * framePixelWidth + framePixelWidth / 2 - cursorWidth * 0.5f;
            draw_list->AddLine(ImVec2(cursorOffset, canvas_pos.y), ImVec2(cursorOffset, contentMax.y), 0xA02A2AFF, cursorWidth);
            char tmps[512];
            ImFormatString(tmps, IM_ARRAYSIZE(tmps), "%d", *currentFrame);
            draw_list->AddText(ImVec2(cursorOffset + 10, canvas_pos.y + 2), 0xFF2A2AFF, tmps);
         }

         draw_list->PopClipRect();
         draw_list->PopClipRect();

         for (auto& customDraw : customDraws)
            sequence->CustomDraw(customDraw.index, draw_list, customDraw.customRect, customDraw.legendRect, customDraw.clippingRect, customDraw.legendClippingRect);
         for (auto& customDraw : compactCustomDraws)
            sequence->CustomDrawCompact(customDraw.index, draw_list, customDraw.customRect, customDraw.clippingRect);

         // copy paste
         if (sequenceOptions & SEQUENCER_COPYPASTE)
         {
            ImRect rectCopy(ImVec2(contentMin.x + 100, canvas_pos.y + 2)
               , ImVec2(contentMin.x + 100 + 30, canvas_pos.y + ItemHeight - 2));
            bool inRectCopy = rectCopy.Contains(io.MousePos);
            unsigned int copyColor = inRectCopy ? 0xFF1080FF : 0xFF000000;
            draw_list->AddText(rectCopy.Min, copyColor, "Copy");

            ImRect rectPaste(ImVec2(contentMin.x + 140, canvas_pos.y + 2)
               , ImVec2(contentMin.x + 140 + 30, canvas_pos.y + ItemHeight - 2));
            bool inRectPaste = rectPaste.Contains(io.MousePos);
            unsigned int pasteColor = inRectPaste ? 0xFF1080FF : 0xFF000000;
            draw_list->AddText(rectPaste.Min, pasteColor, "Paste");

            if (inRectCopy && io.MouseReleased[0])
            {
               sequence->Copy();
            }
            if (inRectPaste && io.MouseReleased[0])
            {
               sequence->Paste();
            }
         }
         //

         ImGui::EndChildFrame();
         ImGui::PopStyleColor();
         if (hasScrollBar)
         {
            ImGui::InvisibleButton("scrollBar", scrollBarSize);
            ImVec2 scrollBarMin = ImGui::GetItemRectMin();
            ImVec2 scrollBarMax = ImGui::GetItemRectMax();

            // ratio = number of frames visible in control / number to total frames

            float startFrameOffset = ((float)(firstFrameUsed - sequence->GetFrameMin()) / (float)frameCount) * (canvas_size.x - legendWidth);
            ImVec2 scrollBarA(scrollBarMin.x + legendWidth, scrollBarMin.y - 2);
            ImVec2 scrollBarB(scrollBarMin.x + canvas_size.x, scrollBarMax.y - 1);
            draw_list->AddRectFilled(scrollBarA, scrollBarB, 0xFF222222, 0);

            ImRect scrollBarRect(scrollBarA, scrollBarB);
            bool inScrollBar = scrollBarRect.Contains(io.MousePos);

            draw_list->AddRectFilled(scrollBarA, scrollBarB, 0xFF101010, 8);


            ImVec2 scrollBarC(scrollBarMin.x + legendWidth + startFrameOffset, scrollBarMin.y);
            ImVec2 scrollBarD(scrollBarMin.x + legendWidth + barWidthInPixels + startFrameOffset, scrollBarMax.y - 2);
            draw_list->AddRectFilled(scrollBarC, scrollBarD, (inScrollBar || MovingScrollBar) ? 0xFF606060 : 0xFF505050, 6);

            ImRect barHandleLeft(scrollBarC, ImVec2(scrollBarC.x + 14, scrollBarD.y));
            ImRect barHandleRight(ImVec2(scrollBarD.x - 14, scrollBarC.y), scrollBarD);

            bool onLeft = barHandleLeft.Contains(io.MousePos);
            bool onRight = barHandleRight.Contains(io.MousePos);

            static bool sizingRBar = false;
            static bool sizingLBar = false;

            draw_list->AddRectFilled(barHandleLeft.Min, barHandleLeft.Max, (onLeft || sizingLBar) ? 0xFFAAAAAA : 0xFF666666, 6);
            draw_list->AddRectFilled(barHandleRight.Min, barHandleRight.Max, (onRight || sizingRBar) ? 0xFFAAAAAA : 0xFF666666, 6);

            ImRect scrollBarThumb(scrollBarC, scrollBarD);
            static const float MinBarWidth = 44.f;
            if (sizingRBar)
            {
               if (!io.MouseDown[0])
               {
                  sizingRBar = false;
               }
               else
               {
                  float barNewWidth = ImMax(barWidthInPixels + io.MouseDelta.x, MinBarWidth);
                  float barRatio = barNewWidth / barWidthInPixels;
                  framePixelWidthTarget = framePixelWidth = framePixelWidth / barRatio;
                  int newVisibleFrameCount = int((canvas_size.x - legendWidth) / framePixelWidthTarget);
                  int lastFrame = *firstFrame + newVisibleFrameCount;
                  if (lastFrame > sequence->GetFrameMax())
                  {
                     framePixelWidthTarget = framePixelWidth = (canvas_size.x - legendWidth) / float(sequence->GetFrameMax() - *firstFrame);
                  }
               }
            }
            else if (sizingLBar)
            {
               if (!io.MouseDown[0])
               {
                  sizingLBar = false;
               }
               else
               {
                  if (fabsf(io.MouseDelta.x) > FLT_EPSILON)
                  {
                     float barNewWidth = ImMax(barWidthInPixels - io.MouseDelta.x, MinBarWidth);
                     float barRatio = barNewWidth / barWidthInPixels;
                     float previousFramePixelWidthTarget = framePixelWidthTarget;
                     framePixelWidthTarget = framePixelWidth = framePixelWidth / barRatio;
                     int newVisibleFrameCount = int(visibleFrameCount / barRatio);
                     int newFirstFrame = *firstFrame + newVisibleFrameCount - visibleFrameCount;
                     newFirstFrame = ImClamp(newFirstFrame, sequence->GetFrameMin(), ImMax(sequence->GetFrameMax() - visibleFrameCount, sequence->GetFrameMin()));
                     if (newFirstFrame == *firstFrame)
                     {
                        framePixelWidth = framePixelWidthTarget = previousFramePixelWidthTarget;
                     }
                     else
                     {
                        *firstFrame = newFirstFrame;
                     }
                  }
               }
            }
            else
            {
               if (MovingScrollBar)
               {
                  if (!io.MouseDown[0])
                  {
                     MovingScrollBar = false;
                  }
                  else
                  {
                     float framesPerPixelInBar = barWidthInPixels / (float)visibleFrameCount;
                     *firstFrame = int((io.MousePos.x - panningViewSource.x) / framesPerPixelInBar) - panningViewFrame;
                     *firstFrame = ImClamp(*firstFrame, sequence->GetFrameMin(), ImMax(sequence->GetFrameMax() - visibleFrameCount, sequence->GetFrameMin()));
                  }
               }
               else
               {
                  if (scrollBarThumb.Contains(io.MousePos) && ImGui::IsMouseClicked(0) && firstFrame && !MovingCurrentFrame && movingEntry == -1)
                  {
                     MovingScrollBar = true;
                     panningViewSource = io.MousePos;
                     panningViewFrame = -*firstFrame;
                  }
                  if (!sizingRBar && onRight && ImGui::IsMouseClicked(0))
                     sizingRBar = true;
                  if (!sizingLBar && onLeft && ImGui::IsMouseClicked(0))
                     sizingLBar = true;

               }
            }
         }
      }

      ImGui::EndGroup();

      if (regionRect.Contains(io.MousePos))
      {
         bool overCustomDraw = false;
         for (auto& custom : customDraws)
         {
            if (custom.customRect.Contains(io.MousePos))
            {
               overCustomDraw = true;
            }
         }
         if (overCustomDraw)
         {
         }
         else
         {
#if 0
            frameOverCursor = *firstFrame + (int)(visibleFrameCount * ((io.MousePos.x - (float)legendWidth - canvas_pos.x) / (canvas_size.x - legendWidth)));
            //frameOverCursor = max(min(*firstFrame - visibleFrameCount / 2, frameCount - visibleFrameCount), 0);

            /**firstFrame -= frameOverCursor;
            *firstFrame *= framePixelWidthTarget / framePixelWidth;
            *firstFrame += frameOverCursor;*/
            if (io.MouseWheel < -FLT_EPSILON)
            {
               *firstFrame -= frameOverCursor;
               *firstFrame = int(*firstFrame * 1.1f);
               framePixelWidthTarget *= 0.9f;
               *firstFrame += frameOverCursor;
            }

            if (io.MouseWheel > FLT_EPSILON)
            {
               *firstFrame -= frameOverCursor;
               *firstFrame = int(*firstFrame * 0.9f);
               framePixelWidthTarget *= 1.1f;
               *firstFrame += frameOverCursor;
            }
#endif
         }
      }

      if (expanded)
      {
         if (SequencerAddDelButton(draw_list, ImVec2(canvas_pos.x + 2, canvas_pos.y + 2), !*expanded))
            *expanded = !*expanded;
      }

      if (delEntry != -1)
      {
         sequence->Del(delEntry);
         if (selectedEntry && (*selectedEntry == delEntry || *selectedEntry >= sequence->GetItemCount()))
            *selectedEntry = -1;
      }

      if (dupEntry != -1)
      {
         sequence->Duplicate(dupEntry);
      }
      return ret;
   }
}


================================================
FILE: Source/External/imgui_tools/imguizmo/ImSequencer.h
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#pragma once

#include <cstddef>

struct ImDrawList;
struct ImRect;
namespace ImSequencer
{
   enum SEQUENCER_OPTIONS
   {
      SEQUENCER_EDIT_NONE = 0,
      SEQUENCER_EDIT_STARTEND = 1 << 1,
      SEQUENCER_CHANGE_FRAME = 1 << 3,
      SEQUENCER_ADD = 1 << 4,
      SEQUENCER_DEL = 1 << 5,
      SEQUENCER_COPYPASTE = 1 << 6,
      SEQUENCER_EDIT_ALL = SEQUENCER_EDIT_STARTEND | SEQUENCER_CHANGE_FRAME
   };

   struct SequenceInterface
   {
      bool focused = false;
      virtual int GetFrameMin() const = 0;
      virtual int GetFrameMax() const = 0;
      virtual int GetItemCount() const = 0;

      virtual void BeginEdit(int /*index*/) {}
      virtual void EndEdit() {}
      virtual int GetItemTypeCount() const { return 0; }
      virtual const char* GetItemTypeName(int /*typeIndex*/) const { return ""; }
      virtual const char* GetItemLabel(int /*index*/) const { return ""; }
      virtual const char* GetCollapseFmt() const { return "%d Frames / %d entries"; }

      virtual void Get(int index, int** start, int** end, int* type, unsigned int* color) = 0;
      virtual void Add(int /*type*/) {}
      virtual void Del(int /*index*/) {}
      virtual void Duplicate(int /*index*/) {}

      virtual void Copy() {}
      virtual void Paste() {}

      virtual size_t GetCustomHeight(int /*index*/) { return 0; }
      virtual void DoubleClick(int /*index*/) {}
      virtual void CustomDraw(int /*index*/, ImDrawList* /*draw_list*/, const ImRect& /*rc*/, const ImRect& /*legendRect*/, const ImRect& /*clippingRect*/, const ImRect& /*legendClippingRect*/) {}
      virtual void CustomDrawCompact(int /*index*/, ImDrawList* /*draw_list*/, const ImRect& /*rc*/, const ImRect& /*clippingRect*/) {}
   };


   // return true if selection is made
   bool Sequencer(SequenceInterface* sequence, int* currentFrame, bool* expanded, int* selectedEntry, int* firstFrame, int sequenceOptions);

}


================================================
FILE: Source/External/imgui_tools/imguizmo/ImZoomSlider.h
================================================
// https://github.com/CedricGuillemet/ImGuizmo
// v 1.89 WIP
//
// The MIT License(MIT)
//
// Copyright(c) 2021 Cedric Guillemet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#pragma once

namespace ImZoomSlider
{
   typedef int ImGuiZoomSliderFlags;
   enum ImGuiPopupFlags_
   {
      ImGuiZoomSliderFlags_None = 0,
      ImGuiZoomSliderFlags_Vertical = 1,
      ImGuiZoomSliderFlags_NoAnchors = 2,
      ImGuiZoomSliderFlags_NoMiddleCarets = 4,
      ImGuiZoomSliderFlags_NoWheel = 8,
   };

   template<typename T> bool ImZoomSlider(const T lower, const T higher, T& viewLower, T& viewHigher, float wheelRatio = 0.01f, ImGuiZoomSliderFlags flags = ImGuiZoomSliderFlags_None)
   {
      bool interacted = false;
      ImGuiIO& io = ImGui::GetIO();
      ImDrawList* draw_list = ImGui::GetWindowDrawList();

      static const float handleSize = 12;
      static const float roundRadius = 3.f;
      static const char* controlName = "ImZoomSlider";

      static bool movingScrollBarSvg = false;
      static bool sizingRBarSvg = false;
      static bool sizingLBarSvg = false;
      static ImGuiID editingId = (ImGuiID)-1;
      static float scrollingSource = 0.f;
      static float saveViewLower;
      static float saveViewHigher;

      const bool isVertical = flags & ImGuiZoomSliderFlags_Vertical;
      const ImVec2 canvasPos = ImGui::GetCursorScreenPos();
      const ImVec2 canvasSize = ImGui::GetContentRegionAvail();
      const float canvasSizeLength = isVertical ? ImGui::GetItemRectSize().y : canvasSize.x;
      const ImVec2 scrollBarSize = isVertical ? ImVec2(14.f, canvasSizeLength) : ImVec2(canvasSizeLength, 14.f);

      ImGui::InvisibleButton(controlName, scrollBarSize);
      const ImGuiID currentId = ImGui::GetID(controlName);

      const bool usingEditingId = currentId == editingId;
      const bool canUseControl = usingEditingId || editingId == -1;
      const bool movingScrollBar = usingEditingId ? movingScrollBarSvg : false;
      const bool sizingRBar = usingEditingId ? sizingRBarSvg : false;
      const bool sizingLBar = usingEditingId ? sizingLBarSvg : false;
      const int componentIndex = isVertical ? 1 : 0;
      const ImVec2 scrollBarMin = ImGui::GetItemRectMin();
      const ImVec2 scrollBarMax = ImGui::GetItemRectMax();
      const ImVec2 scrollBarA = ImVec2(scrollBarMin.x, scrollBarMin.y) - (isVertical ? ImVec2(2,0) : ImVec2(0,2));
      const ImVec2 scrollBarB = isVertical ? ImVec2(scrollBarMax.x - 1.f, scrollBarMin.y + canvasSizeLength) : ImVec2(scrollBarMin.x + canvasSizeLength, scrollBarMax.y - 1.f);
      const float scrollStart = ((viewLower - lower) / (higher - lower)) * canvasSizeLength + scrollBarMin[componentIndex];
      const float scrollEnd = ((viewHigher - lower) / (higher - lower)) * canvasSizeLength + scrollBarMin[componentIndex];
      const float screenSize = scrollEnd - scrollStart;
      const ImVec2 scrollTopLeft = isVertical ? ImVec2(scrollBarMin.x, scrollStart) : ImVec2(scrollStart, scrollBarMin.y);
      const ImVec2 scrollBottomRight = isVertical ? ImVec2(scrollBarMax.x - 2.f, scrollEnd) : ImVec2(scrollEnd, scrollBarMax.y - 2.f);
      const bool inScrollBar = canUseControl && ImRect(scrollTopLeft, scrollBottomRight).Contains(io.MousePos);
      const ImRect scrollBarRect(scrollBarA, scrollBarB);
      const float deltaScreen = io.MousePos[componentIndex] - scrollingSource;
      const float deltaView = ((higher - lower) / canvasSizeLength) * deltaScreen;
      const uint32_t barColor = ImGui::GetColorU32((inScrollBar || movingScrollBar) ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);
      const float middleCoord = (scrollStart + scrollEnd) * 0.5f;
      const bool insideControl = canUseControl && ImRect(scrollBarMin, scrollBarMax).Contains(io.MousePos);
      const bool hasAnchors = !(flags & ImGuiZoomSliderFlags_NoAnchors);
      const float viewMinSize = ((3.f * handleSize) / canvasSizeLength) * (higher - lower);
      const auto ClipView = [lower, higher, &viewLower, &viewHigher]() {
         if (viewLower < lower)
         {
            const float deltaClip = lower - viewLower;
            viewLower += deltaClip;
            viewHigher += deltaClip;
         }
         if (viewHigher > higher)
         {
            const float deltaClip = viewHigher - higher;
            viewLower -= deltaClip;
            viewHigher -= deltaClip;
         }
      };

      bool onLeft = false;
      bool onRight = false;

      draw_list->AddRectFilled(scrollBarA, scrollBarB, 0xFF101010, roundRadius);
      draw_list->AddRectFilled(scrollBarA, scrollBarB, 0xFF222222, 0);
      draw_list->AddRectFilled(scrollTopLeft, scrollBottomRight, barColor, roundRadius);

      if (!(flags & ImGuiZoomSliderFlags_NoMiddleCarets))
      {
         for (float i = 0.5f; i < 3.f; i += 1.f)
         {
            const float coordA = middleCoord - handleSize * 0.5f;
            const float coordB = middleCoord + handleSize * 0.5f;
            ImVec2 base = scrollBarMin;
            base.x += scrollBarSize.x * 0.25f * i;
            base.y += scrollBarSize.y * 0.25f * i;

            if (isVertical)
            {
               draw_list->AddLine(ImVec2(base.x, coordA), ImVec2(base.x, coordB), ImGui::GetColorU32(ImGuiCol_SliderGrab));
            }
            else
            {
               draw_list->AddLine(ImVec2(coordA, base.y), ImVec2(coordB, base.y), ImGui::GetColorU32(ImGuiCol_SliderGrab));
            }
         }
      }

      // Mouse wheel
      if (io.MouseClicked[0] && insideControl && !inScrollBar)
      {
         const float ratio = (io.MousePos[componentIndex] - scrollBarMin[componentIndex]) / (scrollBarMax[componentIndex] - scrollBarMin[componentIndex]);
         const float size = (higher - lower);
         const float halfViewSize = (viewHigher - viewLower) * 0.5f;
         const float middle = ratio * size + lower;
         viewLower = middle - halfViewSize;
         viewHigher = middle + halfViewSize;
         ClipView();
         interacted = true;
      }

      if (!(flags & ImGuiZoomSliderFlags_NoWheel) && inScrollBar && fabsf(io.MouseWheel) > 0.f)
      {
         const float ratio = (io.MousePos[componentIndex] - scrollStart) / (scrollEnd - scrollStart);
         const float amount = io.MouseWheel * wheelRatio * (viewHigher - viewLower);
         
         viewLower -= ratio * amount;
         viewHigher += (1.f - ratio) * amount;
         ClipView();
         interacted = true;
      }

      if (screenSize > handleSize * 2.f && hasAnchors)
      {
         const ImRect barHandleLeft(scrollTopLeft, isVertical ? ImVec2(scrollBottomRight.x, scrollTopLeft.y + handleSize) : ImVec2(scrollTopLeft.x + handleSize, scrollBottomRight.y));
         const ImRect barHandleRight(isVertical ? ImVec2(scrollTopLeft.x, scrollBottomRight.y - handleSize) : ImVec2(scrollBottomRight.x - handleSize, scrollTopLeft.y), scrollBottomRight);

         onLeft = barHandleLeft.Contains(io.MousePos);
         onRight = barHandleRight.Contains(io.MousePos);

         draw_list->AddRectFilled(barHandleLeft.Min, barHandleLeft.Max, ImGui::GetColorU32((onLeft || sizingLBar) ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), roundRadius);
         draw_list->AddRectFilled(barHandleRight.Min, barHandleRight.Max, ImGui::GetColorU32((onRight || sizingRBar) ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), roundRadius);
      }

      if (sizingRBar)
      {
         if (!io.MouseDown[0])
         {
            sizingRBarSvg = false;
            editingId = (ImGuiID)-1;
         }
         else
         {
            viewHigher = ImMin(saveViewHigher + deltaView, higher);
         }
      }
      else if (sizingLBar)
      {
         if (!io.MouseDown[0])
         {
            sizingLBarSvg = false;
            editingId = (ImGuiID)-1;
         }
         else
         {
            viewLower = ImMax(saveViewLower + deltaView, lower);
         }
      }
      else
      {
         if (movingScrollBar)
         {
            if (!io.MouseDown[0])
            {
               movingScrollBarSvg = false;
               editingId = (ImGuiID)-1;
            }
            else
            {
               viewLower = saveViewLower + deltaView;
               viewHigher = saveViewHigher + deltaView;
               ClipView();
            }
         }
         else
         {
            if (inScrollBar && ImGui::IsMouseClicked(0))
            {
               movingScrollBarSvg = true;
               scrollingSource = io.MousePos[componentIndex];
               saveViewLower = viewLower;
               saveViewHigher = viewHigher;
               editingId = currentId;
            }
            if (!sizingRBar && onRight && ImGui::IsMouseClicked(0) && hasAnchors)
            {
               sizingRBarSvg = true;
               editingId = currentId;
            }
            if (!sizingLBar && onLeft && ImGui::IsMouseClicked(0) && hasAnchors)
            {
               sizingLBarSvg = true;
               editingId = currentId;
            }
         }
      }

      // minimal size check
      if ((viewHigher - viewLower) < viewMinSize)
      {
         const float middle = (viewLower + viewHigher) * 0.5f;
         viewLower = middle - viewMinSize * 0.5f;
         viewHigher = middle + viewMinSize * 0.5f;
         ClipView();
      }

      return movingScrollBar || sizingRBar || sizingLBar || interacted;
   }

} // namespace


================================================
FILE: Source/External/imgui_tools/imnodes/imnodes.cpp
================================================
// the structure of this file:
//
// [SECTION] bezier curve helpers
// [SECTION] draw list helper
// [SECTION] ui state logic
// [SECTION] render helpers
// [SECTION] API implementation

#define IMGUI_DEFINE_MATH_OPERATORS
#include "imnodes.h"
#include "imnodes_internal.h"

#include <imgui_internal.h>

// Check minimum ImGui version
#define MINIMUM_COMPATIBLE_IMGUI_VERSION 17400
#if IMGUI_VERSION_NUM < MINIMUM_COMPATIBLE_IMGUI_VERSION
#error "Minimum ImGui version requirement not met -- please use a newer version!"
#endif

#include <limits.h>
#include <math.h>
#include <new>
#include <stdint.h>
#include <stdio.h> // for fwrite, ssprintf, sscanf
#include <stdlib.h>
#include <string.h> // strlen, strncmp

// Use secure CRT function variants to avoid MSVC compiler errors
#ifdef _MSC_VER
#define sscanf sscanf_s
#endif

ImNodesContext* GImNodes = NULL;

namespace IMNODES_NAMESPACE
{
namespace
{
// [SECTION] bezier curve helpers

struct CubicBezier
{
    ImVec2 P0, P1, P2, P3;
    int    NumSegments;
};

inline ImVec2 EvalCubicBezier(
    const float   t,
    const ImVec2& P0,
    const ImVec2& P1,
    const ImVec2& P2,
    const ImVec2& P3)
{
    // B(t) = (1-t)**3 p0 + 3(1 - t)**2 t P1 + 3(1-t)t**2 P2 + t**3 P3

    const float u = 1.0f - t;
    const float b0 = u * u * u;
    const float b1 = 3 * u * u * t;
    const float b2 = 3 * u * t * t;
    const float b3 = t * t * t;
    return ImVec2(
        b0 * P0.x + b1 * P1.x + b2 * P2.x + b3 * P3.x,
        b0 * P0.y + b1 * P1.y + b2 * P2.y + b3 * P3.y);
}

// Calculates the closest point along each bezier curve segment.
ImVec2 GetClosestPointOnCubicBezier(const int num_segments, const ImVec2& p, const CubicBezier& cb)
{
    IM_ASSERT(num_segments > 0);
    ImVec2 p_last = cb.P0;
    ImVec2 p_closest;
    float  p_closest_dist = FLT_MAX;
    float  t_step = 1.0f / (float)num_segments;
    for (int i = 1; i <= num_segments; ++i)
    {
        ImVec2 p_current = EvalCubicBezier(t_step * i, cb.P0, cb.P1, cb.P2, cb.P3);
        ImVec2 p_line = ImLineClosestPoint(p_last, p_current, p);
        float  dist = ImLengthSqr(p - p_line);
        if (dist < p_closest_dist)
        {
            p_closest = p_line;
            p_closest_dist = dist;
        }
        p_last = p_current;
    }
    return p_closest;
}

inline float GetDistanceToCubicBezier(
    const ImVec2&      pos,
    const CubicBezier& cubic_bezier,
    const int          num_segments)
{
    const ImVec2 point_on_curve = GetClosestPointOnCubicBezier(num_segments, pos, cubic_bezier);

    const ImVec2 to_curve = point_on_curve - pos;
    return ImSqrt(ImLengthSqr(to_curve));
}

inline ImRect GetContainingRectForCubicBezier(const CubicBezier& cb)
{
    const ImVec2 min = ImVec2(ImMin(cb.P0.x, cb.P3.x), ImMin(cb.P0.y, cb.P3.y));
    const ImVec2 max = ImVec2(ImMax(cb.P0.x, cb.P3.x), ImMax(cb.P0.y, cb.P3.y));

    const float hover_distance = GImNodes->Style.LinkHoverDistance;

    ImRect rect(min, max);
    rect.Add(cb.P1);
    rect.Add(cb.P2);
    rect.Expand(ImVec2(hover_distance, hover_distance));

    return rect;
}

inline CubicBezier GetCubicBezier(
    ImVec2                     start,
    ImVec2                     end,
    const ImNodesAttributeType start_type,
    const float                line_segments_per_length)
{
    IM_ASSERT(
        (start_type == ImNodesAttributeType_Input) || (start_type == ImNodesAttributeType_Output));
    if (start_type == ImNodesAttributeType_Input)
    {
        ImSwap(start, end);
    }

    const float  link_length = ImSqrt(ImLengthSqr(end - start));
    const ImVec2 offset = ImVec2(0.25f * link_length, 0.f);
    CubicBezier  cubic_bezier;
    cubic_bezier.P0 = start;
    cubic_bezier.P1 = start + offset;
    cubic_bezier.P2 = end - offset;
    cubic_bezier.P3 = end;
    cubic_bezier.NumSegments = ImMax(static_cast<int>(link_length * line_segments_per_length), 1);
    return cubic_bezier;
}

inline float EvalImplicitLineEq(const ImVec2& p1, const ImVec2& p2, const ImVec2& p)
{
    return (p2.y - p1.y) * p.x + (p1.x - p2.x) * p.y + (p2.x * p1.y - p1.x * p2.y);
}

inline int Sign(float val) { return int(val > 0.0f) - int(val < 0.0f); }

inline bool RectangleOverlapsLineSegment(const ImRect& rect, const ImVec2& p1, const ImVec2& p2)
{
    // Trivial case: rectangle contains an endpoint
    if (rect.Contains(p1) || rect.Contains(p2))
    {
        return true;
    }

    // Flip rectangle if necessary
    ImRect flip_rect = rect;

    if (flip_rect.Min.x > flip_rect.Max.x)
    {
        ImSwap(flip_rect.Min.x, flip_rect.Max.x);
    }

    if (flip_rect.Min.y > flip_rect.Max.y)
    {
        ImSwap(flip_rect.Min.y, flip_rect.Max.y);
    }

    // Trivial case: line segment lies to one particular side of rectangle
    if ((p1.x < flip_rect.Min.x && p2.x < flip_rect.Min.x) ||
        (p1.x > flip_rect.Max.x && p2.x > flip_rect.Max.x) ||
        (p1.y < flip_rect.Min.y && p2.y < flip_rect.Min.y) ||
        (p1.y > flip_rect.Max.y && p2.y > flip_rect.Max.y))
    {
        return false;
    }

    const int corner_signs[4] = {
        Sign(EvalImplicitLineEq(p1, p2, flip_rect.Min)),
        Sign(EvalImplicitLineEq(p1, p2, ImVec2(flip_rect.Max.x, flip_rect.Min.y))),
        Sign(EvalImplicitLineEq(p1, p2, ImVec2(flip_rect.Min.x, flip_rect.Max.y))),
        Sign(EvalImplicitLineEq(p1, p2, flip_rect.Max))};

    int sum = 0;
    int sum_abs = 0;

    for (int i = 0; i < 4; ++i)
    {
        sum += corner_signs[i];
        sum_abs += abs(corner_signs[i]);
    }

    // At least one corner of rectangle lies on a different side of line segment
    return abs(sum) != sum_abs;
}

inline bool RectangleOverlapsBezier(const ImRect& rectangle, const CubicBezier& cubic_bezier)
{
    ImVec2 current =
        EvalCubicBezier(0.f, cubic_bezier.P0, cubic_bezier.P1, cubic_bezier.P2, cubic_bezier.P3);
    const float dt = 1.0f / cubic_bezier.NumSegments;
    for (int s = 0; s < cubic_bezier.NumSegments; ++s)
    {
        ImVec2 next = EvalCubicBezier(
            static_cast<float>((s + 1) * dt),
            cubic_bezier.P0,
            cubic_bezier.P1,
            cubic_bezier.P2,
            cubic_bezier.P3);
        if (RectangleOverlapsLineSegment(rectangle, current, next))
        {
            return true;
        }
        current = next;
    }
    return false;
}

inline bool RectangleOverlapsLink(
    const ImRect&              rectangle,
    const ImVec2&              start,
    const ImVec2&              end,
    const ImNodesAttributeType start_type)
{
    // First level: simple rejection test via rectangle overlap:

    ImRect lrect = ImRect(start, end);
    if (lrect.Min.x > lrect.Max.x)
    {
        ImSwap(lrect.Min.x, lrect.Max.x);
    }

    if (lrect.Min.y > lrect.Max.y)
    {
        ImSwap(lrect.Min.y, lrect.Max.y);
    }

    if (rectangle.Overlaps(lrect))
    {
        // First, check if either one or both endpoinds are trivially contained
        // in the rectangle

        if (rectangle.Contains(start) || rectangle.Contains(end))
        {
            return true;
        }

        // Second level of refinement: do a more expensive test against the
        // link

        const CubicBezier cubic_bezier =
            GetCubicBezier(start, end, start_type, GImNodes->Style.LinkLineSegmentsPerLength);
        return RectangleOverlapsBezier(rectangle, cubic_bezier);
    }

    return false;
}

// [SECTION] coordinate space conversion helpers

inline ImVec2 ScreenSpaceToGridSpace(const ImNodesEditorContext& editor, const ImVec2& v)
{
    return v - GImNodes->CanvasOriginScreenSpace - editor.Panning;
}

inline ImRect ScreenSpaceToGridSpace(const ImNodesEditorContext& editor, const ImRect& r)
{
    return ImRect(ScreenSpaceToGridSpace(editor, r.Min), ScreenSpaceToGridSpace(editor, r.Max));
}

inline ImVec2 GridSpaceToScreenSpace(const ImNodesEditorContext& editor, const ImVec2& v)
{
    return v + GImNodes->CanvasOriginScreenSpace + editor.Panning;
}

inline ImVec2 GridSpaceToEditorSpace(const ImNodesEditorContext& editor, const ImVec2& v)
{
    return v + editor.Panning;
}

inline ImVec2 EditorSpaceToGridSpace(const ImNodesEditorContext& editor, const ImVec2& v)
{
    return v - editor.Panning;
}

inline ImVec2 EditorSpaceToScreenSpace(const ImVec2& v)
{
    return GImNodes->CanvasOriginScreenSpace + v;
}

inline ImVec2 MiniMapSpaceToGridSpace(const ImNodesEditorContext& editor, const ImVec2& v)
{
    return (v - editor.MiniMapContentScreenSpace.Min) / editor.MiniMapScaling +
           editor.GridContentBounds.Min;
}

inline ImVec2 ScreenSpaceToMiniMapSpace(const ImNodesEditorContext& editor, const ImVec2& v)
{
    return (ScreenSpaceToGridSpace(editor, v) - editor.GridContentBounds.Min) *
               editor.MiniMapScaling +
           editor.MiniMapContentScreenSpace.Min;
}

inline ImRect ScreenSpaceToMiniMapSpace(const ImNodesEditorContext& editor, const ImRect& r)
{
    return ImRect(
        ScreenSpaceToMiniMapSpace(editor, r.Min), ScreenSpaceToMiniMapSpace(editor, r.Max));
}

// [SECTION] draw list helper

void ImDrawListGrowChannels(ImDrawList* draw_list, const int num_channels)
{
    ImDrawListSplitter& splitter = draw_list->_Splitter;

    if (splitter._Count == 1)
    {
        splitter.Split(draw_list, num_channels + 1);
        return;
    }

    // NOTE: this logic has been lifted from ImDrawListSplitter::Split with slight modifications
    // to allow nested splits. The main modification is that we only create new ImDrawChannel
    // instances after splitter._Count, instead of over the whole splitter._Channels array like
    // the regular ImDrawListSplitter::Split method does.

    const int old_channel_capacity = splitter._Channels.Size;
    // NOTE: _Channels is not resized down, and therefore _Count <= _Channels.size()!
    const int old_channel_count = splitter._Count;
    const int requested_channel_count = old_channel_count + num_channels;
    if (old_channel_capacity < old_channel_count + num_channels)
    {
        splitter._Channels.resize(requested_channel_count);
    }

    splitter._Count = requested_channel_count;

    for (int i = old_channel_count; i < requested_channel_count; ++i)
    {
        ImDrawChannel& channel = splitter._Channels[i];

        // If we're inside the old capacity region of the array, we need to reuse the existing
        // memory of the command and index buffers.
        if (i < old_channel_capacity)
        {
            channel._CmdBuffer.resize(0);
            channel._IdxBuffer.resize(0);
        }
        // Else, we need to construct new draw channels.
        else
        {
            IM_PLACEMENT_NEW(&channel) ImDrawChannel();
        }

        {
            ImDrawCmd draw_cmd;
            draw_cmd.ClipRect = draw_list->_ClipRectStack.back();
            draw_cmd.TextureId = draw_list->_TextureIdStack.back();
            channel._CmdBuffer.push_back(draw_cmd);
        }
    }
}

void ImDrawListSplitterSwapChannels(
    ImDrawListSplitter& splitter,
    const int           lhs_idx,
    const int           rhs_idx)
{
    if (lhs_idx == rhs_idx)
    {
        return;
    }

    IM_ASSERT(lhs_idx >= 0 && lhs_idx < splitter._Count);
    IM_ASSERT(rhs_idx >= 0 && rhs_idx < splitter._Count);

    ImDrawChannel& lhs_channel = splitter._Channels[lhs_idx];
    ImDrawChannel& rhs_channel = splitter._Channels[rhs_idx];
    lhs_channel._CmdBuffer.swap(rhs_channel._CmdBuffer);
    lhs_channel._IdxBuffer.swap(rhs_channel._IdxBuffer);

    const int current_channel = splitter._Current;

    if (current_channel == lhs_idx)
    {
        splitter._Current = rhs_idx;
    }
    else if (current_channel == rhs_idx)
    {
        splitter._Current = lhs_idx;
    }
}

void DrawListSet(ImDrawList* window_draw_list)
{
    GImNodes->CanvasDrawList = window_draw_list;
    GImNodes->NodeIdxToSubmissionIdx.Clear();
    GImNodes->NodeIdxSubmissionOrder.clear();
}

// The draw list channels are structured as follows. First we have our base channel, the canvas grid
// on which we render the grid lines in BeginNodeEditor(). The base channel is the reason
// draw_list_submission_idx_to_background_channel_idx offsets the index by one. Each BeginNode()
// call appends two new draw channels, for the node background and foreground. The node foreground
// is the channel into which the node's ImGui content is rendered. Finally, in EndNodeEditor() we
// append one last draw channel for rendering the selection box and the incomplete link on top of
// everything else.
//
// +----------+----------+----------+----------+----------+----------+
// |          |          |          |          |          |          |
// |canvas    |node      |node      |...       |...       |click     |
// |grid      |background|foreground|          |          |interaction
// |          |          |          |          |          |          |
// +----------+----------+----------+----------+----------+----------+
//            |                     |
//            |   submission idx    |
//            |                     |
//            -----------------------

void DrawListAddNode(const int node_idx)
{
    GImNodes->NodeIdxToSubmissionIdx.SetInt(
        static_cast<ImGuiID>(node_idx), GImNodes->NodeIdxSubmissionOrder.Size);
    GImNodes->NodeIdxSubmissionOrder.push_back(node_idx);
    ImDrawListGrowChannels(GImNodes->CanvasDrawList, 2);
}

void DrawListAppendClickInteractionChannel()
{
    // NOTE: don't use this function outside of EndNodeEditor. Using this before all nodes have been
    // added will screw up the node draw order.
    ImDrawListGrowChannels(GImNodes->CanvasDrawList, 1);
}

int DrawListSubmissionIdxToBackgroundChannelIdx(const int submission_idx)
{
    // NOTE: the first channel is the canvas background, i.e. the grid
    return 1 + 2 * submission_idx;
}

int DrawListSubmissionIdxToForegroundChannelIdx(const int submission_idx)
{
    return DrawListSubmissionIdxToBackgroundChannelIdx(submission_idx) + 1;
}

void DrawListActivateClickInteractionChannel()
{
    GImNodes->CanvasDrawList->_Splitter.SetCurrentChannel(
        GImNodes->CanvasDrawList, GImNodes->CanvasDrawList->_Splitter._Count - 1);
}

void DrawListActivateCurrentNodeForeground()
{
    const int foreground_channel_idx =
        DrawListSubmissionIdxToForegroundChannelIdx(GImNodes->NodeIdxSubmissionOrder.Size - 1);
    GImNodes->CanvasDrawList->_Splitter.SetCurrentChannel(
        GImNodes->CanvasDrawList, foreground_channel_idx);
}

void DrawListActivateNodeBackground(const int node_idx)
{
    const int submission_idx =
        GImNodes->NodeIdxToSubmissionIdx.GetInt(static_cast<ImGuiID>(node_idx), -1);
    // There is a discrepancy in the submitted node count and the rendered node count! Did you call
    // one of the following functions
    // * EditorContextMoveToNode
    // * SetNodeScreenSpacePos
    // * SetNodeGridSpacePos
    // * SetNodeDraggable
    // after the BeginNode/EndNode function calls?
    IM_ASSERT(submission_idx != -1);
    const int background_channel_idx = DrawListSubmissionIdxToBackgroundChannelIdx(submission_idx);
    GImNodes->CanvasDrawList->_Splitter.SetCurrentChannel(
        GImNodes->CanvasDrawList, background_channel_idx);
}

void DrawListSwapSubmissionIndices(const int lhs_idx, const int rhs_idx)
{
    IM_ASSERT(lhs_idx != rhs_idx);

    const int lhs_foreground_channel_idx = DrawListSubmissionIdxToForegroundChannelIdx(lhs_idx);
    const int lhs_background_channel_idx = DrawListSubmissionIdxToBackgroundChannelIdx(lhs_idx);
    const int rhs_foreground_channel_idx = DrawListSubmissionIdxToForegroundChannelIdx(rhs_idx);
    const int rhs_background_channel_idx = DrawListSubmissionIdxToBackgroundChannelIdx(rhs_idx);

    ImDrawListSplitterSwapChannels(
        GImNodes->CanvasDrawList->_Splitter,
        lhs_background_channel_idx,
        rhs_background_channel_idx);
    ImDrawListSplitterSwapChannels(
        GImNodes->CanvasDrawList->_Splitter,
        lhs_foreground_channel_idx,
        rhs_foreground_channel_idx);
}

void DrawListSortChannelsByDepth(const ImVector<int>& node_idx_depth_order)
{
    if (GImNodes->NodeIdxToSubmissionIdx.Data.Size < 2)
    {
        return;
    }

    IM_ASSERT(node_idx_depth_order.Size == GImNodes->NodeIdxSubmissionOrder.Size);

    int start_idx = node_idx_depth_order.Size - 1;

    while (node_idx_depth_order[start_idx] == GImNodes->NodeIdxSubmissionOrder[start_idx])
    {
        if (--start_idx == 0)
        {
            // early out if submission order and depth order are the same
            return;
        }
    }

    // TODO: this is an O(N^2) algorithm. It might be worthwhile revisiting this to see if the time
    // complexity can be reduced.

    for (int depth_idx = start_idx; depth_idx > 0; --depth_idx)
    {
        const int node_idx = node_idx_depth_order[depth_idx];

        // Find the current index of the node_idx in the submission order array
        int submission_idx = -1;
        for (int i = 0; i < GImNodes->NodeIdxSubmissionOrder.Size; ++i)
        {
            if (GImNodes->NodeIdxSubmissionOrder[i] == node_idx)
            {
                submission_idx = i;
                break;
            }
        }
        IM_ASSERT(submission_idx >= 0);

        if (submission_idx == depth_idx)
        {
            continue;
        }

        for (int j = submission_idx; j < depth_idx; ++j)
        {
            DrawListSwapSubmissionIndices(j, j + 1);
            ImSwap(GImNodes->NodeIdxSubmissionOrder[j], GImNodes->NodeIdxSubmissionOrder[j + 1]);
        }
    }
}

// [SECTION] ui state logic

ImVec2 GetScreenSpacePinCoordinates(
    const ImRect&              node_rect,
    const ImRect&              attribute_rect,
    const ImNodesAttributeType type)
{
    IM_ASSERT(type == ImNodesAttributeType_Input || type == ImNodesAttributeType_Output);
    const float x = type == ImNodesAttributeType_Input
                        ? (node_rect.Min.x - GImNodes->Style.PinOffset)
                        : (node_rect.Max.x + GImNodes->Style.PinOffset);
    return ImVec2(x, 0.5f * (attribute_rect.Min.y + attribute_rect.Max.y));
}

ImVec2 GetScreenSpacePinCoordinates(const ImNodesEditorContext& editor, const ImPinData& pin)
{
    const ImRect& parent_node_rect = editor.Nodes.Pool[pin.ParentNodeIdx].Rect;
    return GetScreenSpacePinCoordinates(parent_node_rect, pin.AttributeRect, pin.Type);
}

bool MouseInCanvas()
{
    // This flag should be true either when hovering or clicking something in the canvas.
    const bool is_window_hovered_or_focused = ImGui::IsWindowHovered() || ImGui::IsWindowFocused();

    return is_window_hovered_or_focused &&
           GImNodes->CanvasRectScreenSpace.Contains(ImGui::GetMousePos());
}

void BeginNodeSelection(ImNodesEditorContext& editor, const int node_idx)
{
    // Don't start selecting a node if we are e.g. already creating and dragging
    // a new link! New link creation can happen when the mouse is clicked over
    // a node, but within the hover radius of a pin.
    if (editor.ClickInteraction.Type != ImNodesClickInteractionType_None)
    {
        return;
    }

    editor.ClickInteraction.Type = ImNodesClickInteractionType_Node;
    // If the node is not already contained in the selection, then we want only
    // the interaction node to be selected, effective immediately.
    //
    // If the multiple selection modifier is active, we want to add this node
    // to the current list of selected nodes.
    //
    // Otherwise, we want to allow for the possibility of multiple nodes to be
    // moved at once.
    if (!editor.SelectedNodeIndices.contains(node_idx))
    {
        editor.SelectedLinkIndices.clear();
        if (!GImNodes->MultipleSelectModifier)
        {
            editor.SelectedNodeIndices.clear();
        }
        editor.SelectedNodeIndices.push_back(node_idx);

        // Ensure that individually selected nodes get rendered on top
        ImVector<int>&   depth_stack = editor.NodeDepthOrder;
        const int* const elem = depth_stack.find(node_idx);
        IM_ASSERT(elem != depth_stack.end());
        depth_stack.erase(elem);
        depth_stack.push_back(node_idx);
    }
    // Deselect a previously-selected node
    else if (GImNodes->MultipleSelectModifier)
    {
        const int* const node_ptr = editor.SelectedNodeIndices.find(node_idx);
        editor.SelectedNodeIndices.erase(node_ptr);

        // Don't allow dragging after deselecting
        editor.ClickInteraction.Type = ImNodesClickInteractionType_None;
    }

    // To support snapping of multiple nodes, we need to store the offset of
    // each node in the selection to the origin of the dragged node.
    const ImVec2 ref_origin = editor.Nodes.Pool[node_idx].Origin;
    editor.PrimaryNodeOffset =
        ref_origin + GImNodes->CanvasOriginScreenSpace + editor.Panning - GImNodes->MousePos;

    editor.SelectedNodeOffsets.clear();
    for (int idx = 0; idx < editor.SelectedNodeIndices.Size; idx++)
    {
        const int    node = editor.SelectedNodeIndices[idx];
        const ImVec2 node_origin = editor.Nodes.Pool[node].Origin - ref_origin;
        editor.SelectedNodeOffsets.push_back(node_origin);
    }
}

void BeginLinkSelection(ImNodesEditorContext& editor, const int link_idx)
{
    editor.ClickInteraction.Type = ImNodesClickInteractionType_Link;
    // When a link is selected, clear all other selections, and insert the link
    // as the sole selection.
    editor.SelectedNodeIndices.clear();
    editor.SelectedLinkIndices.clear();
    editor.SelectedLinkIndices.push_back(link_idx);
}

void BeginLinkDetach(ImNodesEditorContext& editor, const int link_idx, const int detach_pin_idx)
{
    const ImLinkData&        link = editor.Links.Pool[link_idx];
    ImClickInteractionState& state = editor.ClickInteraction;
    state.Type = ImNodesClickInteractionType_LinkCreation;
    state.LinkCreation.EndPinIdx.Reset();
    state.LinkCreation.StartPinIdx =
        detach_pin_idx == link.StartPinIdx ? link.EndPinIdx : link.StartPinIdx;
    GImNodes->DeletedLinkIdx = link_idx;
}

void BeginLinkCreation(ImNodesEditorContext& editor, const int hovered_pin_idx)
{
    editor.ClickInteraction.Type = ImNodesClickInteractionType_LinkCreation;
    editor.ClickInteraction.LinkCreation.StartPinIdx = hovered_pin_idx;
    editor.ClickInteraction.LinkCreation.EndPinIdx.Reset();
    editor.ClickInteraction.LinkCreation.Type = ImNodesLinkCreationType_Standard;
    GImNodes->ImNodesUIState |= ImNodesUIState_LinkStarted;
}

void BeginLinkInteraction(
    ImNodesEditorContext& editor,
    const int             link_idx,
    const ImOptionalIndex pin_idx = ImOptionalIndex())
{
    // Check if we are clicking the link with the modifier pressed.
    // This will in a link detach via clicking.

    const bool modifier_pressed = GImNodes->Io.LinkDetachWithModifierClick.Modifier == NULL
                                      ? false
                                      : *GImNodes->Io.LinkDetachWithModifierClick.Modifier;

    if (modifier_pressed)
    {
        const ImLinkData& link = editor.Links.Pool[link_idx];
        const ImPinData&  start_pin = editor.Pins.Pool[link.StartPinIdx];
        const ImPinData&  end_pin = editor.Pins.Pool[link.EndPinIdx];
        const ImVec2&     mouse_pos = GImNodes->MousePos;
        const float       dist_to_start = ImLengthSqr(start_pin.Pos - mouse_pos);
        const float       dist_to_end = ImLengthSqr(end_pin.Pos - mouse_pos);
        const int closest_pin_idx = dist_to_start < dist_to_end ? link.StartPinIdx : link.EndPinIdx;

        editor.ClickInteraction.Type = ImNodesClickInteractionType_LinkCreation;
        BeginLinkDetach(editor, link_idx, closest_pin_idx);
        editor.ClickInteraction.LinkCreation.Type = ImNodesLinkCreationType_FromDetach;
    }
    else
    {
        if (pin_idx.HasValue())
        {
            const int hovered_pin_flags = editor.Pins.Pool[pin_idx.Value()].Flags;

            // Check the 'click and drag to detach' case.
            if (hovered_pin_flags & ImNodesAttributeFlags_EnableLinkDetachWithDragClick)
            {
                BeginLinkDetach(editor, link_idx, pin_idx.Value());
                editor.ClickInteraction.LinkCreation.Type = ImNodesLinkCreationType_FromDetach;
            }
            else
            {
                BeginLinkCreation(editor, pin_idx.Value());
            }
        }
        else
        {
            BeginLinkSelection(editor, link_idx);
        }
    }
}

static inline bool IsMiniMapHovered();

void BeginCanvasInteraction(ImNodesEditorContext& editor)
{
    const bool any_ui_element_hovered =
        GImNodes->HoveredNodeIdx.HasValue() || GImNodes->HoveredLinkIdx.HasValue() ||
        GImNodes->HoveredPinIdx.HasValue() || ImGui::IsAnyItemHovered();

    const bool mouse_not_in_canvas = !MouseInCanvas();

    if (editor.ClickInteraction.Type != ImNodesClickInteractionType_None ||
        any_ui_element_hovered || mouse_not_in_canvas)
    {
        return;
    }

    const bool started_panning = GImNodes->AltMouseClicked;

    if (started_panning)
    {
        editor.ClickInteraction.Type = ImNodesClickInteractionType_Panning;
    }
    else if (GImNodes->LeftMouseClicked)
    {
        editor.ClickInteraction.Type = ImNodesClickInteractionType_BoxSelection;
        editor.ClickInteraction.BoxSelector.Rect.Min =
            ScreenSpaceToGridSpace(editor, GImNodes->MousePos);
    }
}

void BoxSelectorUpdateSelection(ImNodesEditorContext& editor, ImRect box_rect)
{
    // Invert box selector coordinates as needed

    if (box_rect.Min.x > box_rect.Max.x)
    {
        ImSwap(box_rect.Min.x, box_rect.Max.x);
    }

    if (box_rect.Min.y > box_rect.Max.y)
    {
        ImSwap(box_rect.Min.y, box_rect.Max.y);
    }

    // Update node selection

    editor.SelectedNodeIndices.clear();

    // Test for overlap against node rectangles

    for (int node_idx = 0; node_idx < editor.Nodes.Pool.size(); ++node_idx)
    {
        if (editor.Nodes.InUse[node_idx])
        {
            ImNodeData& node = editor.Nodes.Pool[node_idx];
            if (box_rect.Overlaps(node.Rect))
            {
                editor.SelectedNodeIndices.push_back(node_idx);
            }
        }
    }

    // Update link selection

    editor.SelectedLinkIndices.clear();

    // Test for overlap against links

    for (int link_idx = 0; link_idx < editor.Links.Pool.size(); ++link_idx)
    {
        if (editor.Links.InUse[link_idx])
        {
            const ImLinkData& link = editor.Links.Pool[link_idx];

            const ImPinData& pin_start = editor.Pins.Pool[link.StartPinIdx];
            const ImPinData& pin_end = editor.Pins.Pool[link.EndPinIdx];
            const ImRect&    node_start_rect = editor.Nodes.Pool[pin_start.ParentNodeIdx].Rect;
            const ImRect&    node_end_rect = editor.Nodes.Pool[pin_end.ParentNodeIdx].Rect;

            const ImVec2 start = GetScreenSpacePinCoordinates(
                node_start_rect, pin_start.AttributeRect, pin_start.Type);
            const ImVec2 end =
                GetScreenSpacePinCoordinates(node_end_rect, pin_end.AttributeRect, pin_end.Type);

            // Test
            if (RectangleOverlapsLink(box_rect, start, end, pin_start.Type))
            {
                editor.SelectedLinkIndices.push_back(link_idx);
            }
        }
    }
}

ImVec2 SnapOriginToGrid(ImVec2 origin)
{
    if (GImNodes->Style.Flags & ImNodesStyleFlags_GridSnapping)
    {
        const float spacing = GImNodes->Style.GridSpacing;
        const float spacing2 = spacing * 0.5f;

        // Snap the origin to the nearest grid point in any direction
        float modx = fmodf(fabsf(origin.x) + spacing2, spacing) - spacing2;
        float mody = fmodf(fabsf(origin.y) + spacing2, spacing) - spacing2;
        origin.x += (origin.x < 0.f) ? modx : -modx;
        origin.y += (origin.y < 0.f) ? mody : -mody;
    }

    return origin;
}

void TranslateSelectedNodes(ImNodesEditorContext& editor)
{
    if (GImNodes->LeftMouseDragging)
    {
        // If we have grid snap enabled, don't start moving nodes until we've moved the mouse
        // slightly
        const bool shouldTranslate = (GImNodes->Style.Flags & ImNodesStyleFlags_GridSnapping)
                                         ? ImGui::GetIO().MouseDragMaxDistanceSqr[0] > 5.0
                                         : true;

        const ImVec2 origin = SnapOriginToGrid(
            GImNodes->MousePos - GImNodes->CanvasOriginScreenSpace - editor.Panning +
            editor.PrimaryNodeOffset);
        for (int i = 0; i < editor.SelectedNodeIndices.size(); ++i)
        {
            const ImVec2 node_rel = editor.SelectedNodeOffsets[i];
            const int    node_idx = editor.SelectedNodeIndices[i];
            ImNodeData&  node = editor.Nodes.Pool[node_idx];
            if (node.Draggable && shouldTranslate)
            {
                node.Origin = origin + node_rel + editor.AutoPanningDelta;
            }
        }
    }
}

struct LinkPredicate
{
    bool operator()(const ImLinkData& lhs, const ImLinkData& rhs) const
    {
        // Do a unique compare by sorting the pins' addresses.
        // This catches duplicate links, whether they are in the
        // same direction or not.
        // Sorting by pin index should have the uniqueness guarantees as sorting
        // by id -- each unique id will get one slot in the link pool array.

        int lhs_start = lhs.StartPinIdx;
        int lhs_end = lhs.EndPinIdx;
        int rhs_start = rhs.StartPinIdx;
        int rhs_end = rhs.EndPinIdx;

        if (lhs_start > lhs_end)
        {
            ImSwap(lhs_start, lhs_end);
        }

        if (rhs_start > rhs_end)
        {
            ImSwap(rhs_start, rhs_end);
        }

        return lhs_start == rhs_start && lhs_end == rhs_end;
    }
};

ImOptionalIndex FindDuplicateLink(
    const ImNodesEditorContext& editor,
    const int                   start_pin_idx,
    const int                   end_pin_idx)
{
    ImLinkData test_link(0);
    test_link.StartPinIdx = start_pin_idx;
    test_link.EndPinIdx = end_pin_idx;
    for (int link_idx = 0; link_idx < editor.Links.Pool.size(); ++link_idx)
    {
        const ImLinkData& link = editor.Links.Pool[link_idx];
        if (LinkPredicate()(test_link, link) && editor.Links.InUse[link_idx])
        {
            return ImOptionalIndex(link_idx);
        }
    }

    return ImOptionalIndex();
}

bool ShouldLinkSnapToPin(
    const ImNodesEditorContext& editor,
    const ImPinData&            start_pin,
    const int                   hovered_pin_idx,
    const ImOptionalIndex       duplicate_link)
{
    const ImPinData& end_pin = editor.Pins.Pool[hovered_pin_idx];

    // The end pin must be in a different node
    if (start_pin.ParentNodeIdx == end_pin.ParentNodeIdx)
    {
        return false;
    }

    // The end pin must be of a different type
    if (start_pin.Type == end_pin.Type)
    {
        return false;
    }

    // The link to be created must not be a duplicate, unless it is the link which was created on
    // snap. In that case we want to snap, since we want it to appear visually as if the created
    // link remains snapped to the pin.
    if (duplicate_link.HasValue() && !(duplicate_link == GImNodes->SnapLinkIdx))
    {
        return false;
    }

    return true;
}

void ClickInteractionUpdate(ImNodesEditorContext& editor)
{
    switch (editor.ClickInteraction.Type)
    {
    case ImNodesClickInteractionType_BoxSelection:
    {
        editor.ClickInteraction.BoxSelector.Rect.Max =
            ScreenSpaceToGridSpace(editor, GImNodes->MousePos);

        ImRect box_rect = editor.ClickInteraction.BoxSelector.Rect;
        box_rect.Min = GridSpaceToScreenSpace(editor, box_rect.Min);
        box_rect.Max = GridSpaceToScreenSpace(editor, box_rect.Max);

        BoxSelectorUpdateSelection(editor, box_rect);

        const ImU32 box_selector_color = GImNodes->Style.Colors[ImNodesCol_BoxSelector];
        const ImU32 box_selector_outline = GImNodes->Style.Colors[ImNodesCol_BoxSelectorOutline];
        GImNodes->CanvasDrawList->AddRectFilled(box_rect.Min, box_rect.Max, box_selector_color);
        GImNodes->CanvasDrawList->AddRect(box_rect.Min, box_rect.Max, box_selector_outline);

        if (GImNodes->LeftMouseReleased)
        {
            ImVector<int>&       depth_stack = editor.NodeDepthOrder;
            const ImVector<int>& selected_idxs = editor.SelectedNodeIndices;

            // Bump the selected node indices, in order, to the top of the depth stack.
            // NOTE: this algorithm has worst case time complexity of O(N^2), if the node selection
            // is ~ N (due to selected_idxs.contains()).

            if ((selected_idxs.Size > 0) && (selected_idxs.Size < depth_stack.Size))
            {
                int num_moved = 0; // The number of indices moved. Stop after selected_idxs.Size
                for (int i = 0; i < depth_stack.Size - selected_idxs.Size; ++i)
                {
                    for (int node_idx = depth_stack[i]; selected_idxs.contains(node_idx);
                         node_idx = depth_stack[i])
                    {
                        depth_stack.erase(depth_stack.begin() + static_cast<size_t>(i));
                        depth_stack.push_back(node_idx);
                        ++num_moved;
                    }

                    if (num_moved == selected_idxs.Size)
                    {
                        break;
                    }
                }
            }

            editor.ClickInteraction.Type = ImNodesClickInteractionType_None;
        }
    }
    break;
    case ImNodesClickInteractionType_Node:
    {
        TranslateSelectedNodes(editor);

        if (GImNodes->LeftMouseReleased)
        {
            editor.ClickInteraction.Type = ImNodesClickInteractionType_None;
        }
    }
    break;
    case ImNodesClickInteractionType_Link:
    {
        if (GImNodes->LeftMouseReleased)
        {
            editor.ClickInteraction.Type = ImNodesClickInteractionType_None;
        }
    }
    break;
    case ImNodesClickInteractionType_LinkCreation:
    {
        const ImPinData& start_pin =
            editor.Pins.Pool[editor.ClickInteraction.LinkCreation.StartPinIdx];

        const ImOptionalIndex maybe_duplicate_link_idx =
            GImNodes->HoveredPinIdx.HasValue()
                ? FindDuplicateLink(
                      editor,
                      editor.ClickInteraction.LinkCreation.StartPinIdx,
                      GImNodes->HoveredPinIdx.Value())
                : ImOptionalIndex();

        const bool should_snap =
            GImNodes->HoveredPinIdx.HasValue() &&
            ShouldLinkSnapToPin(
                editor, start_pin, GImNodes->HoveredPinIdx.Value(), maybe_duplicate_link_idx);

        // If we created on snap and the hovered pin is empty or changed, then we need signal that
        // the link's state has changed.
        const bool snapping_pin_changed =
            editor.ClickInteraction.LinkCreation.EndPinIdx.HasValue() &&
            !(GImNodes->HoveredPinIdx == editor.ClickInteraction.LinkCreation.EndPinIdx);

        // Detach the link that was created by this link event if it's no longer in snap range
        if (snapping_pin_changed && GImNodes->SnapLinkIdx.HasValue())
        {
            BeginLinkDetach(
                editor,
                GImNodes->SnapLinkIdx.Value(),
                editor.ClickInteraction.LinkCreation.EndPinIdx.Value());
        }

        const ImVec2 start_pos = GetScreenSpacePinCoordinates(editor, start_pin);
        // If we are within the hover radius of a receiving pin, snap the link
        // endpoint to it
        const ImVec2 end_pos = should_snap
                                   ? GetScreenSpacePinCoordinates(
                                         editor, editor.Pins.Pool[GImNodes->HoveredPinIdx.Value()])
                                   : GImNodes->MousePos;

        const CubicBezier cubic_bezier = GetCubicBezier(
            start_pos, end_pos, start_pin.Type, GImNodes->Style.LinkLineSegmentsPerLength);
#if IMGUI_VERSION_NUM < 18000
        GImNodes->CanvasDrawList->AddBezierCurve(
#else
        GImNodes->CanvasDrawList->AddBezierCubic(
#endif
            cubic_bezier.P0,
            cubic_bezier.P1,
            cubic_bezier.P2,
            cubic_bezier.P3,
            GImNodes->Style.Colors[ImNodesCol_Link],
            GImNodes->Style.LinkThickness,
            cubic_bezier.NumSegments);

        const bool link_creation_on_snap =
            GImNodes->HoveredPinIdx.HasValue() &&
            (editor.Pins.Pool[GImNodes->HoveredPinIdx.Value()].Flags &
             ImNodesAttributeFlags_EnableLinkCreationOnSnap);

        if (!should_snap)
        {
            editor.ClickInteraction.LinkCreation.EndPinIdx.Reset();
        }

        const bool create_link =
            should_snap && (GImNodes->LeftMouseReleased || link_creation_on_snap);

        if (create_link && !maybe_duplicate_link_idx.HasValue())
        {
            // Avoid send OnLinkCreated() events every frame if the snap link is not saved
            // (only applies for EnableLinkCreationOnSnap)
            if (!GImNodes->LeftMouseReleased &&
                editor.ClickInteraction.LinkCreation.EndPinIdx == GImNodes->HoveredPinIdx)
            {
                break;
            }

            GImNodes->ImNodesUIState |= ImNodesUIState_LinkCreated;
            editor.ClickInteraction.LinkCreation.EndPinIdx = GImNodes->HoveredPinIdx.Value();
        }

        if (GImNodes->LeftMouseReleased)
        {
            editor.ClickInteraction.Type = ImNodesClickInteractionType_None;
            if (!create_link)
            {
                GImNodes->ImNodesUIState |= ImNodesUIState_LinkDropped;
            }
        }
    }
    break;
    case ImNodesClickInteractionType_Panning:
    {
        const bool dragging = GImNodes->AltMouseDragging;

        if (dragging)
        {
            editor.Panning += ImGui::GetIO().MouseDelta;
        }
        else
        {
            editor.ClickInteraction.Type = ImNodesClickInteractionType_None;
        }
    }
    break;
    case ImNodesClickInteractionType_ImGuiItem:
    {
        if (GImNodes->LeftMouseReleased)
        {
            editor.ClickInteraction.Type = ImNodesClickInteractionType_None;
        }
    }
    case ImNodesClickInteractionType_None:
        break;
    default:
        IM_ASSERT(!"Unreachable code!");
        break;
    }
}

void ResolveOccludedPins(const ImNodesEditorContext& editor, ImVector<int>& occluded_pin_indices)
{
    const ImVector<int>& depth_stack = editor.NodeDepthOrder;

    occluded_pin_indices.resize(0);

    if (depth_stack.Size < 2)
    {
        return;
    }

    // For each node in the depth stack
    for (int depth_idx = 0; depth_idx < (depth_stack.Size - 1); ++depth_idx)
    {
        const ImNodeData& node_below = editor.Nodes.Pool[depth_stack[depth_idx]];

        // Iterate over the rest of the depth stack to find nodes overlapping the pins
        for (int next_depth_idx = depth_idx + 1; next_depth_idx < depth_stack.Size;
             ++next_depth_idx)
        {
            const ImRect& rect_above = editor.Nodes.Pool[depth_stack[next_depth_idx]].Rect;

            // Iterate over each pin
            for (int idx = 0; idx < node_below.PinIndices.Size; ++idx)
            {
                const int     pin_idx = node_below.PinIndices[idx];
                const ImVec2& pin_pos = editor.Pins.Pool[pin_idx].Pos;

                if (rect_above.Contains(pin_pos))
                {
                    occluded_pin_indices.push_back(pin_idx);
                }
            }
        }
    }
}

ImOptionalIndex ResolveHoveredPin(
    const ImObjectPool<ImPinData>& pins,
    const ImVector<int>&           occluded_pin_indices)
{
    float           smallest_distance = FLT_MAX;
    ImOptionalIndex pin_idx_with_smallest_distance;

    const float hover_radius_sqr = GImNodes->Style.PinHoverRadius * GImNodes->Style.PinHoverRadius;

    for (int idx = 0; idx < pins.Pool.Size; ++idx)
    {
        if (!pins.InUse[idx])
        {
            continue;
        }

        if (occluded_pin_indices.contains(idx))
        {
            continue;
        }

        const ImVec2& pin_pos = pins.Pool[idx].Pos;
        const float   distance_sqr = ImLengthSqr(pin_pos - GImNodes->MousePos);

        // TODO: GImNodes->Style.PinHoverRadius needs to be copied into pin data and the pin-local
        // value used here. This is no longer called in BeginAttribute/EndAttribute scope and the
        // detected pin might have a different hover radius than what the user had when calling
        // BeginAttribute/EndAttribute.
        if (distance_sqr < hover_radius_sqr && distance_sqr < smallest_distance)
        {
            smallest_distance = distance_sqr;
            pin_idx_with_smallest_distance = idx;
        }
    }

    return pin_idx_with_smallest_distance;
}

ImOptionalIndex ResolveHoveredNode(const ImVector<int>& depth_stack)
{
    if (GImNodes->NodeIndicesOverlappingWithMouse.size() == 0)
    {
        return ImOptionalIndex();
    }

    if (GImNodes->NodeIndicesOverlappingWithMouse.size() == 1)
    {
        return ImOptionalIndex(GImNodes->NodeIndicesOverlappingWithMouse[0]);
    }

    int largest_depth_idx = -1;
    int node_idx_on_top = -1;

    for (int i = 0; i < GImNodes->NodeIndicesOverlappingWithMouse.size(); ++i)
    {
        const int node_idx = GImNodes->NodeIndicesOverlappingWithMouse[i];
        for (int depth_idx = 0; depth_idx < depth_stack.size(); ++depth_idx)
        {
            if (depth_stack[depth_idx] == node_idx && (depth_idx > largest_depth_idx))
            {
                largest_depth_idx = depth_idx;
                node_idx_on_top = node_idx;
            }
        }
    }

    IM_ASSERT(node_idx_on_top != -1);
    return ImOptionalIndex(node_idx_on_top);
}

ImOptionalIndex ResolveHoveredLink(
    const ImObjectPool<ImLinkData>& links,
    const ImObjectPool<ImPinData>&  pins)
{
    float           smallest_distance = FLT_MAX;
    ImOptionalIndex link_idx_with_smallest_distance;

    // There are two ways a link can be detected as "hovered".
    // 1. The link is within hover distance to the mouse. The closest such link is selected as being
    // hovered over.
    // 2. If the link is connected to the currently hovered pin.
    //
    // The latter is a requirement for link detaching with drag click to work, as both a link and
    // pin are required to be hovered over for the feature to work.

    for (int idx = 0; idx < links.Pool.Size; ++idx)
    {
        if (!links.InUse[idx])
        {
            continue;
        }

        const ImLinkData& link = links.Pool[idx];
        const ImPinData&  start_pin = pins.Pool[link.StartPinIdx];
        const ImPinData&  end_pin = pins.Pool[link.EndPinIdx];

        // If there is a hovered pin links can only be considered hovered if they use that pin
        if (GImNodes->HoveredPinIdx.HasValue())
        {
            if (GImNodes->HoveredPinIdx == link.StartPinIdx ||
                GImNodes->HoveredPinIdx == link.EndPinIdx)
            {
                return idx;
            }
            continue;
        }

        // TODO: the calculated CubicBeziers could be cached since we generate them again when
        // rendering the links

        const CubicBezier cubic_bezier = GetCubicBezier(
            start_pin.Pos, end_pin.Pos, start_pin.Type, GImNodes->Style.LinkLineSegmentsPerLength);

        // The distance test
        {
            const ImRect link_rect = GetContainingRectForCubicBezier(cubic_bezier);

            // First, do a simple bounding box test against the box containing the link
            // to see whether calculating the distance to the link is worth doing.
            if (link_rect.Contains(GImNodes->MousePos))
            {
                const float distance = GetDistanceToCubicBezier(
                    GImNodes->MousePos, cubic_bezier, cubic_bezier.NumSegments);

                // TODO: GImNodes->Style.LinkHoverDistance could be also copied into ImLinkData,
                // since we're not calling this function in the same scope as ImNodes::Link(). The
                // rendered/detected link might have a different hover distance than what the user
                // had specified when calling Link()
                if (distance < GImNodes->Style.LinkHoverDistance && distance < smallest_distance)
                {
                    smallest_distance = distance;
                    link_idx_with_smallest_distance = idx;
                }
            }
        }
    }

    return link_idx_with_smallest_distance;
}

// [SECTION] render helpers

inline ImRect GetItemRect() { return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); }

inline ImVec2 GetNodeTitleBarOrigin(const ImNodeData& node)
{
    return node.Origin + node.LayoutStyle.Padding;
}

inline ImVec2 GetNodeContentOrigin(const ImNodeData& node)
{
    const ImVec2 title_bar_height =
        ImVec2(0.f, node.TitleBarContentRect.GetHeight() + 2.0f * node.LayoutStyle.Padding.y);
    return node.Origin + title_bar_height + node.LayoutStyle.Padding;
}

inline ImRect GetNodeTitleRect(const ImNodeData& node)
{
    ImRect expanded_title_rect = node.TitleBarContentRect;
    expanded_title_rect.Expand(node.LayoutStyle.Padding);

    return ImRect(
        expanded_title_rect.Min,
        expanded_title_rect.Min + ImVec2(node.Rect.GetWidth(), 0.f) +
            ImVec2(0.f, expanded_title_rect.GetHeight()));
}

void DrawGrid(ImNodesEditorContext& editor, const ImVec2& canvas_size)
{
    const ImVec2 offset = editor.Panning;
    ImU32        line_color = GImNodes->Style.Colors[ImNodesCol_GridLine];
    ImU32        line_color_prim = GImNodes->Style.Colors[ImNodesCol_GridLinePrimary];
    bool         draw_primary = GImNodes->Style.Flags & ImNodesStyleFlags_GridLinesPrimary;

    for (float x = fmodf(offset.x, GImNodes->Style.GridSpacing); x < canvas_size.x;
         x += GImNodes->Style.GridSpacing)
    {
        GImNodes->CanvasDrawList->AddLine(
            EditorSpaceToScreenSpace(ImVec2(x, 0.0f)),
            EditorSpaceToScreenSpace(ImVec2(x, canvas_size.y)),
            offset.x - x == 0.f && draw_primary ? line_color_prim : line_color);
    }

    for (float y = fmodf(offset.y, GImNodes->Style.GridSpacing); y < canvas_size.y;
         y += GImNodes->Style.GridSpacing)
    {
        GImNodes->CanvasDrawList->AddLine(
            EditorSpaceToScreenSpace(ImVec2(0.0f, y)),
            EditorSpaceToScreenSpace(ImVec2(canvas_size.x, y)),
            offset.y - y == 0.f && draw_primary ? line_color_prim : line_color);
    }
}

struct QuadOffsets
{
    ImVec2 TopLeft, BottomLeft, BottomRight, TopRight;
};

QuadOffsets CalculateQuadOffsets(const float side_length)
{
    const float half_side = 0.5f * side_length;

    QuadOffsets offset;

    offset.TopLeft = ImVec2(-half_side, half_side);
    offset.BottomLeft = ImVec2(-half_side, -half_side);
    offset.BottomRight = ImVec2(half_side, -half_side);
    offset.TopRight = ImVec2(half_side, half_side);

    return offset;
}

struct TriangleOffsets
{
    ImVec2 TopLeft, BottomLeft, Right;
};

TriangleOffsets CalculateTriangleOffsets(const float side_length)
{
    // Calculates the Vec2 offsets from an equilateral triangle's midpoint to
    // its vertices. Here is how the left_offset and right_offset are
    // calculated.
    //
    // For an equilateral triangle of side length s, the
    // triangle's height, h, is h = s * sqrt(3) / 2.
    //
    // The length from the base to the midpoint is (1 / 3) * h. The length from
    // the midpoint to the triangle vertex is (2 / 3) * h.
    const float sqrt_3 = sqrtf(3.0f);
    const float left_offset = -0.1666666666667f * sqrt_3 * side_length;
    const float right_offset = 0.333333333333f * sqrt_3 * side_length;
    const float vertical_offset = 0.5f * side_length;

    TriangleOffsets offset;
    offset.TopLeft = ImVec2(left_offset, vertical_offset);
    offset.BottomLeft = ImVec2(left_offset, -vertical_offset);
    offset.Right = ImVec2(right_offset, 0.f);

    return offset;
}

void DrawPinShape(const ImVec2& pin_pos, const ImPinData& pin, const ImU32 pin_color)
{
    static const int CIRCLE_NUM_SEGMENTS = 8;

    switch (pin.Shape)
    {
    case ImNodesPinShape_Circle:
    {
        GImNodes->CanvasDrawList->AddCircle(
            pin_pos,
            GImNodes->Style.PinCircleRadius,
            pin_color,
            CIRCLE_NUM_SEGMENTS,
            GImNodes->Style.PinLineThickness);
    }
    break;
    case ImNodesPinShape_CircleFilled:
    {
        GImNodes->CanvasDrawList->AddCircleFilled(
            pin_pos, GImNodes->Style.PinCircleRadius, pin_color, CIRCLE_NUM_SEGMENTS);
    }
    break;
    case ImNodesPinShape_Quad:
    {
        const QuadOffsets offset = CalculateQuadOffsets(GImNodes->Style.PinQuadSideLength);
        GImNodes->CanvasDrawList->AddQuad(
            pin_pos + offset.TopLeft,
            pin_pos + offset.BottomLeft,
            pin_pos + offset.BottomRight,
            pin_pos + offset.TopRight,
            pin_color,
            GImNodes->Style.PinLineThickness);
    }
    break;
    case ImNodesPinShape_QuadFilled:
    {
        const QuadOffsets offset = CalculateQuadOffsets(GImNodes->Style.PinQuadSideLength);
        GImNodes->CanvasDrawList->AddQuadFilled(
            pin_pos + offset.TopLeft,
            pin_pos + offset.BottomLeft,
            pin_pos + offset.BottomRight,
            pin_pos + offset.TopRight,
            pin_color);
    }
    break;
    case ImNodesPinShape_Triangle:
    {
        const TriangleOffsets offset =
            CalculateTriangleOffsets(GImNodes->Style.PinTriangleSideLength);
        GImNodes->CanvasDrawList->AddTriangle(
            pin_pos + offset.TopLeft,
            pin_pos + offset.BottomLeft,
            pin_pos + offset.Right,
            pin_color,
            // NOTE: for some weird reason, the line drawn by AddTriangle is
            // much thinner than the lines drawn by AddCircle or AddQuad.
            // Multiplying the line thickness by two seemed to solve the
            // problem at a few different thickness values.
            2.f * GImNodes->Style.PinLineThickness);
    }
    break;
    case ImNodesPinShape_TriangleFilled:
    {
        const TriangleOffsets offset =
            CalculateTriangleOffsets(GImNodes->Style.PinTriangleSideLength);
        GImNodes->CanvasDrawList->AddTriangleFilled(
            pin_pos + offset.TopLeft,
            pin_pos + offset.BottomLeft,
            pin_pos + offset.Right,
            pin_color);
    }
    break;
    default:
        IM_ASSERT(!"Invalid PinShape value!");
        break;
    }
}

void DrawPin(ImNodesEditorContext& editor, const int pin_idx)
{
    ImPinData&    pin = editor.Pins.Pool[pin_idx];
    const ImRect& parent_node_rect = editor.Nodes.Pool[pin.ParentNodeIdx].Rect;

    pin.Pos = GetScreenSpacePinCoordinates(parent_node_rect, pin.AttributeRect, pin.Type);

    ImU32 pin_color = pin.ColorStyle.Background;

    if (GImNodes->HoveredPinIdx == pin_idx)
    {
        pin_color = pin.ColorStyle.Hovered;
    }

    DrawPinShape(pin.Pos, pin, pin_color);
}

void DrawNode(ImNodesEditorContext& editor, const int node_idx)
{
    const ImNodeData& node = editor.Nodes.Pool[node_idx];
    ImGui::SetCursorPos(node.Origin + editor.Panning);

    const bool node_hovered =
        GImNodes->HoveredNodeIdx == node_idx &&
        editor.ClickInteraction.Type != ImNodesClickInteractionType_BoxSelection;

    ImU32 node_background = node.ColorStyle.Background;
    ImU32 titlebar_background = node.ColorStyle.Titlebar;

    if (editor.SelectedNodeIndices.contains(node_idx))
    {
        node_background = node.ColorStyle.BackgroundSelected;
        titlebar_background = node.ColorStyle.TitlebarSelected;
    }
    else if (node_hovered)
    {
        node_background = node.ColorStyle.BackgroundHovered;
        titlebar_background = node.ColorStyle.TitlebarHovered;
    }

    {
        // node base
        GImNodes->CanvasDrawList->AddRectFilled(
            node.Rect.Min, node.Rect.Max, node_background, node.LayoutStyle.CornerRounding);

        // title bar:
        if (node.TitleBarContentRect.GetHeight() > 0.f)
        {
            ImRect title_bar_rect = GetNodeTitleRect(node);

#if IMGUI_VERSION_NUM < 18200
            GImNodes->CanvasDrawList->AddRectFilled(
                title_bar_rect.Min,
                title_bar_rect.Max,
                titlebar_background,
                node.LayoutStyle.CornerRounding,
                ImDrawCornerFlags_Top);
#else
            GImNodes->CanvasDrawList->AddRectFilled(
                title_bar_rect.Min,
                title_bar_rect.Max,
                titlebar_background,
                node.LayoutStyle.CornerRounding,
                ImDrawFlags_RoundCornersTop);

#endif
        }

        if ((GImNodes->Style.Flags & ImNodesStyleFlags_NodeOutline) != 0)
        {
#if IMGUI_VERSION_NUM < 18200
            GImNodes->CanvasDrawList->AddRect(
                node.Rect.Min,
                node.Rect.Max,
                node.ColorStyle.Outline,
                node.LayoutStyle.CornerRounding,
                ImDrawCornerFlags_All,
                node.LayoutStyle.BorderThickness);
#else
            GImNodes->CanvasDrawList->AddRect(
                node.Rect.Min,
                node.Rect.Max,
                node.ColorStyle.Outline,
                node.LayoutStyle.CornerRounding,
                ImDrawFlags_RoundCornersAll,
                node.LayoutStyle.BorderThickness);
#endif
        }
    }

    for (int i = 0; i < node.PinIndices.size(); ++i)
    {
        DrawPin(editor, node.PinIndices[i]);
    }

    if (node_hovered)
    {
        GImNodes->HoveredNodeIdx = node_idx;
    }
}

void DrawLink(ImNodesEditorContext& editor, const int link_idx)
{
    const ImLinkData& link = editor.Links.Pool[link_idx];
    const ImPinData&  start_pin = editor.Pins.Pool[link.StartPinIdx];
    const ImPinData&  end_pin = editor.Pins.Pool[link.EndPinIdx];

    const CubicBezier cubic_bezier = GetCubicBezier(
        start_pin.Pos, end_pin.Pos, start_pin.Type, GImNodes->Style.LinkLineSegmentsPerLength);

    const bool link_hovered =
        GImNodes->HoveredLinkIdx == link_idx &&
        editor.ClickInteraction.Type != ImNodesClickInteractionType_BoxSelection;

    if (link_hovered)
    {
        GImNodes->HoveredLinkIdx = link_idx;
    }

    // It's possible for a link to be deleted in begin_link_interaction. A user
    // may detach a link, resulting in the link wire snapping to the mouse
    // position.
    //
    // In other words, skip rendering the link if it was deleted.
    if (GImNodes->DeletedLinkIdx == link_idx)
    {
        return;
    }

    ImU32 link_color = link.ColorStyle.Base;
    if (editor.SelectedLinkIndices.contains(link_idx))
    {
        link_color = link.ColorStyle.Selected;
    }
    else if (link_hovered)
    {
        link_color = link.ColorStyle.Hovered;
    }

#if IMGUI_VERSION_NUM < 18000
    GImNodes->CanvasDrawList->AddBezierCurve(
#else
    GImNodes->CanvasDrawList->AddBezierCubic(
#endif
        cubic_bezier.P0,
        cubic_bezier.P1,
        cubic_bezier.P2,
        cubic_bezier.P3,
        link_color,
        GImNodes->Style.LinkThickness,
        cubic_bezier.NumSegments);
}

void BeginPinAttribute(
    const int                  id,
    const ImNodesAttributeType type,
    const ImNodesPinShape      shape,
    const int                  node_idx)
{
    // Make sure to call BeginNode() before calling
    // BeginAttribute()
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Node);
    GImNodes->CurrentScope = ImNodesScope_Attribute;

    ImGui::BeginGroup();
    ImGui::PushID(id);

    ImNodesEditorContext& editor = EditorContextGet();

    GImNodes->CurrentAttributeId = id;

    const int pin_idx = ObjectPoolFindOrCreateIndex(editor.Pins, id);
    GImNodes->CurrentPinIdx = pin_idx;
    ImPinData& pin = editor.Pins.Pool[pin_idx];
    pin.Id = id;
    pin.ParentNodeIdx = node_idx;
    pin.Type = type;
    pin.Shape = shape;
    pin.Flags = GImNodes->CurrentAttributeFlags;
    pin.ColorStyle.Background = GImNodes->Style.Colors[ImNodesCol_Pin];
    pin.ColorStyle.Hovered = GImNodes->Style.Colors[ImNodesCol_PinHovered];
}

void EndPinAttribute()
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Attribute);
    GImNodes->CurrentScope = ImNodesScope_Node;

    ImGui::PopID();
    ImGui::EndGroup();

    if (ImGui::IsItemActive())
    {
        GImNodes->ActiveAttribute = true;
        GImNodes->ActiveAttributeId = GImNodes->CurrentAttributeId;
    }

    ImNodesEditorContext& editor = EditorContextGet();
    ImPinData&            pin = editor.Pins.Pool[GImNodes->CurrentPinIdx];
    ImNodeData&           node = editor.Nodes.Pool[GImNodes->CurrentNodeIdx];
    pin.AttributeRect = GetItemRect();
    node.PinIndices.push_back(GImNodes->CurrentPinIdx);
}

void Initialize(ImNodesContext* context)
{
    context->CanvasOriginScreenSpace = ImVec2(0.0f, 0.0f);
    context->CanvasRectScreenSpace = ImRect(ImVec2(0.f, 0.f), ImVec2(0.f, 0.f));
    context->CurrentScope = ImNodesScope_None;

    context->CurrentPinIdx = INT_MAX;
    context->CurrentNodeIdx = INT_MAX;

    context->DefaultEditorCtx = EditorContextCreate();
    context->EditorCtx = context->DefaultEditorCtx;

    context->CurrentAttributeFlags = ImNodesAttributeFlags_None;
    context->AttributeFlagStack.push_back(GImNodes->CurrentAttributeFlags);

    StyleColorsDark(&context->Style);
}

void Shutdown(ImNodesContext* ctx) { EditorContextFree(ctx->DefaultEditorCtx); }

// [SECTION] minimap

static inline bool IsMiniMapActive()
{
    ImNodesEditorContext& editor = EditorContextGet();
    return editor.MiniMapEnabled && editor.MiniMapSizeFraction > 0.0f;
}

static inline bool IsMiniMapHovered()
{
    ImNodesEditorContext& editor = EditorContextGet();
    return IsMiniMapActive() &&
           ImGui::IsMouseHoveringRect(
               editor.MiniMapRectScreenSpace.Min, editor.MiniMapRectScreenSpace.Max);
}

static inline void CalcMiniMapLayout()
{
    ImNodesEditorContext& editor = EditorContextGet();
    const ImVec2          offset = GImNodes->Style.MiniMapOffset;
    const ImVec2          border = GImNodes->Style.MiniMapPadding;
    const ImRect          editor_rect = GImNodes->CanvasRectScreenSpace;

    // Compute the size of the mini-map area
    ImVec2 mini_map_size;
    float  mini_map_scaling;
    {
        const ImVec2 max_size =
            ImFloor(editor_rect.GetSize() * editor.MiniMapSizeFraction - border * 2.0f);
        const float  max_size_aspect_ratio = max_size.x / max_size.y;
        const ImVec2 grid_content_size = editor.GridContentBounds.IsInverted()
                                             ? max_size
                                             : ImFloor(editor.GridContentBounds.GetSize());
        const float grid_content_aspect_ratio = grid_content_size.x / grid_content_size.y;
        mini_map_size = ImFloor(
            grid_content_aspect_ratio > max_size_aspect_ratio
                ? ImVec2(max_size.x, max_size.x / grid_content_aspect_ratio)
                : ImVec2(max_size.y * grid_content_aspect_ratio, max_size.y));
        mini_map_scaling = mini_map_size.x / grid_content_size.x;
    }

    // Compute location of the mini-map
    ImVec2 mini_map_pos;
    {
        ImVec2 align;

        switch (editor.MiniMapLocation)
        {
        case ImNodesMiniMapLocation_BottomRight:
            align.x = 1.0f;
            align.y = 1.0f;
            break;
        case ImNodesMiniMapLocation_BottomLeft:
            align.x = 0.0f;
            align.y = 1.0f;
            break;
        case ImNodesMiniMapLocation_TopRight:
            align.x = 1.0f;
            align.y = 0.0f;
            break;
        case ImNodesMiniMapLocation_TopLeft: // [[fallthrough]]
        default:
            align.x = 0.0f;
            align.y = 0.0f;
            break;
        }

        const ImVec2 top_left_pos = editor_rect.Min + offset + border;
        const ImVec2 bottom_right_pos = editor_rect.Max - offset - border - mini_map_size;
        mini_map_pos = ImFloor(ImLerp(top_left_pos, bottom_right_pos, align));
    }

    editor.MiniMapRectScreenSpace =
        ImRect(mini_map_pos - border, mini_map_pos + mini_map_size + border);
    editor.MiniMapContentScreenSpace = ImRect(mini_map_pos, mini_map_pos + mini_map_size);
    editor.MiniMapScaling = mini_map_scaling;
}

static void MiniMapDrawNode(ImNodesEditorContext& editor, const int node_idx)
{
    const ImNodeData& node = editor.Nodes.Pool[node_idx];

    const ImRect node_rect = ScreenSpaceToMiniMapSpace(editor, node.Rect);

    // Round to near whole pixel value for corner-rounding to prevent visual glitches
    const float mini_map_node_rounding =
        floorf(node.LayoutStyle.CornerRounding * editor.MiniMapScaling);

    ImU32 mini_map_node_background;

    if (editor.ClickInteraction.Type == ImNodesClickInteractionType_None &&
        ImGui::IsMouseHoveringRect(node_rect.Min, node_rect.Max))
    {
        mini_map_node_background = GImNodes->Style.Colors[ImNodesCol_MiniMapNodeBackgroundHovered];

        // Run user callback when hovering a mini-map node
        if (editor.MiniMapNodeHoveringCallback)
        {
            editor.MiniMapNodeHoveringCallback(node.Id, editor.MiniMapNodeHoveringCallbackUserData);
        }
    }
    else if (editor.SelectedNodeIndices.contains(node_idx))
    {
        mini_map_node_background = GImNodes->Style.Colors[ImNodesCol_MiniMapNodeBackgroundSelected];
    }
    else
    {
        mini_map_node_background = GImNodes->Style.Colors[ImNodesCol_MiniMapNodeBackground];
    }

    const ImU32 mini_map_node_outline = GImNodes->Style.Colors[ImNodesCol_MiniMapNodeOutline];

    GImNodes->CanvasDrawList->AddRectFilled(
        node_rect.Min, node_rect.Max, mini_map_node_background, mini_map_node_rounding);

    GImNodes->CanvasDrawList->AddRect(
        node_rect.Min, node_rect.Max, mini_map_node_outline, mini_map_node_rounding);
}

static void MiniMapDrawLink(ImNodesEditorContext& editor, const int link_idx)
{
    const ImLinkData& link = editor.Links.Pool[link_idx];
    const ImPinData&  start_pin = editor.Pins.Pool[link.StartPinIdx];
    const ImPinData&  end_pin = editor.Pins.Pool[link.EndPinIdx];

    const CubicBezier cubic_bezier = GetCubicBezier(
        ScreenSpaceToMiniMapSpace(editor, start_pin.Pos),
        ScreenSpaceToMiniMapSpace(editor, end_pin.Pos),
        start_pin.Type,
        GImNodes->Style.LinkLineSegmentsPerLength / editor.MiniMapScaling);

    // It's possible for a link to be deleted in begin_link_interaction. A user
    // may detach a link, resulting in the link wire snapping to the mouse
    // position.
    //
    // In other words, skip rendering the link if it was deleted.
    if (GImNodes->DeletedLinkIdx == link_idx)
    {
        return;
    }

    const ImU32 link_color =
        GImNodes->Style.Colors
            [editor.SelectedLinkIndices.contains(link_idx) ? ImNodesCol_MiniMapLinkSelected
                                                           : ImNodesCol_MiniMapLink];

#if IMGUI_VERSION_NUM < 18000
    GImNodes->CanvasDrawList->AddBezierCurve(
#else
    GImNodes->CanvasDrawList->AddBezierCubic(
#endif
        cubic_bezier.P0,
        cubic_bezier.P1,
        cubic_bezier.P2,
        cubic_bezier.P3,
        link_color,
        GImNodes->Style.LinkThickness * editor.MiniMapScaling,
        cubic_bezier.NumSegments);
}

static void MiniMapUpdate()
{
    ImNodesEditorContext& editor = EditorContextGet();

    ImU32 mini_map_background;

    if (IsMiniMapHovered())
    {
        mini_map_background = GImNodes->Style.Colors[ImNodesCol_MiniMapBackgroundHovered];
    }
    else
    {
        mini_map_background = GImNodes->Style.Colors[ImNodesCol_MiniMapBackground];
    }

    // Create a child window bellow mini-map, so it blocks all mouse interaction on canvas.
    int flags = ImGuiWindowFlags_NoBackground;
    ImGui::SetCursorScreenPos(editor.MiniMapRectScreenSpace.Min);
    ImGui::BeginChild("minimap", editor.MiniMapRectScreenSpace.GetSize(), false, flags);

    const ImRect& mini_map_rect = editor.MiniMapRectScreenSpace;

    // Draw minimap background and border
    GImNodes->CanvasDrawList->AddRectFilled(
        mini_map_rect.Min, mini_map_rect.Max, mini_map_background);

    GImNodes->CanvasDrawList->AddRect(
        mini_map_rect.Min, mini_map_rect.Max, GImNodes->Style.Colors[ImNodesCol_MiniMapOutline]);

    // Clip draw list items to mini-map rect (after drawing background/outline)
    GImNodes->CanvasDrawList->PushClipRect(
        mini_map_rect.Min, mini_map_rect.Max, true /* intersect with editor clip-rect */);

    // Draw links first so they appear under nodes, and we can use the same draw channel
    for (int link_idx = 0; link_idx < editor.Links.Pool.size(); ++link_idx)
    {
        if (editor.Links.InUse[link_idx])
        {
            MiniMapDrawLink(editor, link_idx);
        }
    }

    for (int node_idx = 0; node_idx < editor.Nodes.Pool.size(); ++node_idx)
    {
        if (editor.Nodes.InUse[node_idx])
        {
            MiniMapDrawNode(editor, node_idx);
        }
    }

    // Draw editor canvas rect inside mini-map
    {
        const ImU32  canvas_color = GImNodes->Style.Colors[ImNodesCol_MiniMapCanvas];
        const ImU32  outline_color = GImNodes->Style.Colors[ImNodesCol_MiniMapCanvasOutline];
        const ImRect rect = ScreenSpaceToMiniMapSpace(editor, GImNodes->CanvasRectScreenSpace);

        GImNodes->CanvasDrawList->AddRectFilled(rect.Min, rect.Max, canvas_color);
        GImNodes->CanvasDrawList->AddRect(rect.Min, rect.Max, outline_color);
    }

    // Have to pop mini-map clip rect
    GImNodes->CanvasDrawList->PopClipRect();

    bool mini_map_is_hovered = ImGui::IsWindowHovered();

    ImGui::EndChild();

    bool center_on_click = mini_map_is_hovered && ImGui::IsMouseDown(ImGuiMouseButton_Left) &&
                           editor.ClickInteraction.Type == ImNodesClickInteractionType_None &&
                           !GImNodes->NodeIdxSubmissionOrder.empty();
    if (center_on_click)
    {
        ImVec2 target = MiniMapSpaceToGridSpace(editor, ImGui::GetMousePos());
        ImVec2 center = GImNodes->CanvasRectScreenSpace.GetSize() * 0.5f;
        editor.Panning = ImFloor(center - target);
    }

    // Reset callback info after use
    editor.MiniMapNodeHoveringCallback = NULL;
    editor.MiniMapNodeHoveringCallbackUserData = NULL;
}

// [SECTION] selection helpers

template<typename T>
void SelectObject(const ImObjectPool<T>& objects, ImVector<int>& selected_indices, const int id)
{
    const int idx = ObjectPoolFind(objects, id);
    IM_ASSERT(idx >= 0);
    IM_ASSERT(selected_indices.find(idx) == selected_indices.end());
    selected_indices.push_back(idx);
}

template<typename T>
void ClearObjectSelection(
    const ImObjectPool<T>& objects,
    ImVector<int>&         selected_indices,
    const int              id)
{
    const int idx = ObjectPoolFind(objects, id);
    IM_ASSERT(idx >= 0);
    IM_ASSERT(selected_indices.find(idx) != selected_indices.end());
    selected_indices.find_erase_unsorted(idx);
}

template<typename T>
bool IsObjectSelected(const ImObjectPool<T>& objects, ImVector<int>& selected_indices, const int id)
{
    const int idx = ObjectPoolFind(objects, id);
    return selected_indices.find(idx) != selected_indices.end();
}

} // namespace
} // namespace IMNODES_NAMESPACE

// [SECTION] API implementation

ImNodesIO::EmulateThreeButtonMouse::EmulateThreeButtonMouse() : Modifier(NULL) {}

ImNodesIO::LinkDetachWithModifierClick::LinkDetachWithModifierClick() : Modifier(NULL) {}

ImNodesIO::MultipleSelectModifier::MultipleSelectModifier() : Modifier(NULL) {}

ImNodesIO::ImNodesIO()
    : EmulateThreeButtonMouse(), LinkDetachWithModifierClick(),
      AltMouseButton(ImGuiMouseButton_Middle), AutoPanningSpeed(1000.0f)
{
}

ImNodesStyle::ImNodesStyle()
    : GridSpacing(24.f), NodeCornerRounding(4.f), NodePadding(8.f, 8.f), NodeBorderThickness(1.f),
      LinkThickness(3.f), LinkLineSegmentsPerLength(0.1f), LinkHoverDistance(10.f),
      PinCircleRadius(4.f), PinQuadSideLength(7.f), PinTriangleSideLength(9.5),
      PinLineThickness(1.f), PinHoverRadius(10.f), PinOffset(0.f), MiniMapPadding(8.0f, 8.0f),
      MiniMapOffset(4.0f, 4.0f), Flags(ImNodesStyleFlags_NodeOutline | ImNodesStyleFlags_GridLines),
      Colors()
{
}

namespace IMNODES_NAMESPACE
{
ImNodesContext* CreateContext()
{
    ImNodesContext* ctx = IM_NEW(ImNodesContext)();
    if (GImNodes == NULL)
        SetCurrentContext(ctx);
    Initialize(ctx);
    return ctx;
}

void DestroyContext(ImNodesContext* ctx)
{
    if (ctx == NULL)
        ctx = GImNodes;
    Shutdown(ctx);
    if (GImNodes == ctx)
        SetCurrentContext(NULL);
    IM_DELETE(ctx);
}

ImNodesContext* GetCurrentContext() { return GImNodes; }

void SetCurrentContext(ImNodesContext* ctx) { GImNodes = ctx; }

ImNodesEditorContext* EditorContextCreate()
{
    void* mem = ImGui::MemAlloc(sizeof(ImNodesEditorContext));
    new (mem) ImNodesEditorContext();
    return (ImNodesEditorContext*)mem;
}

void EditorContextFree(ImNodesEditorContext* ctx)
{
    ctx->~ImNodesEditorContext();
    ImGui::MemFree(ctx);
}

void EditorContextSet(ImNodesEditorContext* ctx) { GImNodes->EditorCtx = ctx; }

ImVec2 EditorContextGetPanning()
{
    const ImNodesEditorContext& editor = EditorContextGet();
    return editor.Panning;
}

void EditorContextResetPanning(const ImVec2& pos)
{
    ImNodesEditorContext& editor = EditorContextGet();
    editor.Panning = pos;
}

void EditorContextMoveToNode(const int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    ImNodeData&           node = ObjectPoolFindOrCreateObject(editor.Nodes, node_id);

    editor.Panning.x = -node.Origin.x;
    editor.Panning.y = -node.Origin.y;
}

void SetImGuiContext(ImGuiContext* ctx) { ImGui::SetCurrentContext(ctx); }

ImNodesIO& GetIO() { return GImNodes->Io; }

ImNodesStyle& GetStyle() { return GImNodes->Style; }

void StyleColorsDark(ImNodesStyle* dest)
{
    if (dest == nullptr)
    {
        dest = &GImNodes->Style;
    }

    dest->Colors[ImNodesCol_NodeBackground] = IM_COL32(50, 50, 50, 255);
    dest->Colors[ImNodesCol_NodeBackgroundHovered] = IM_COL32(75, 75, 75, 255);
    dest->Colors[ImNodesCol_NodeBackgroundSelected] = IM_COL32(75, 75, 75, 255);
    dest->Colors[ImNodesCol_NodeOutline] = IM_COL32(100, 100, 100, 255);
    // title bar colors match ImGui's titlebg colors
    dest->Colors[ImNodesCol_TitleBar] = IM_COL32(41, 74, 122, 255);
    dest->Colors[ImNodesCol_TitleBarHovered] = IM_COL32(66, 150, 250, 255);
    dest->Colors[ImNodesCol_TitleBarSelected] = IM_COL32(66, 150, 250, 255);
    // link colors match ImGui's slider grab colors
    dest->Colors[ImNodesCol_Link] = IM_COL32(61, 133, 224, 200);
    dest->Colors[ImNodesCol_LinkHovered] = IM_COL32(66, 150, 250, 255);
    dest->Colors[ImNodesCol_LinkSelected] = IM_COL32(66, 150, 250, 255);
    // pin colors match ImGui's button colors
    dest->Colors[ImNodesCol_Pin] = IM_COL32(53, 150, 250, 180);
    dest->Colors[ImNodesCol_PinHovered] = IM_COL32(53, 150, 250, 255);

    dest->Colors[ImNodesCol_BoxSelector] = IM_COL32(61, 133, 224, 30);
    dest->Colors[ImNodesCol_BoxSelectorOutline] = IM_COL32(61, 133, 224, 150);

    dest->Colors[ImNodesCol_GridBackground] = IM_COL32(40, 40, 50, 200);
    dest->Colors[ImNodesCol_GridLine] = IM_COL32(200, 200, 200, 40);
    dest->Colors[ImNodesCol_GridLinePrimary] = IM_COL32(240, 240, 240, 60);

    // minimap colors
    dest->Colors[ImNodesCol_MiniMapBackground] = IM_COL32(25, 25, 25, 150);
    dest->Colors[ImNodesCol_MiniMapBackgroundHovered] = IM_COL32(25, 25, 25, 200);
    dest->Colors[ImNodesCol_MiniMapOutline] = IM_COL32(150, 150, 150, 100);
    dest->Colors[ImNodesCol_MiniMapOutlineHovered] = IM_COL32(150, 150, 150, 200);
    dest->Colors[ImNodesCol_MiniMapNodeBackground] = IM_COL32(200, 200, 200, 100);
    dest->Colors[ImNodesCol_MiniMapNodeBackgroundHovered] = IM_COL32(200, 200, 200, 255);
    dest->Colors[ImNodesCol_MiniMapNodeBackgroundSelected] =
        dest->Colors[ImNodesCol_MiniMapNodeBackgroundHovered];
    dest->Colors[ImNodesCol_MiniMapNodeOutline] = IM_COL32(200, 200, 200, 100);
    dest->Colors[ImNodesCol_MiniMapLink] = dest->Colors[ImNodesCol_Link];
    dest->Colors[ImNodesCol_MiniMapLinkSelected] = dest->Colors[ImNodesCol_LinkSelected];
    dest->Colors[ImNodesCol_MiniMapCanvas] = IM_COL32(200, 200, 200, 25);
    dest->Colors[ImNodesCol_MiniMapCanvasOutline] = IM_COL32(200, 200, 200, 200);
}

void StyleColorsClassic(ImNodesStyle* dest)
{
    if (dest == nullptr)
    {
        dest = &GImNodes->Style;
    }

    dest->Colors[ImNodesCol_NodeBackground] = IM_COL32(50, 50, 50, 255);
    dest->Colors[ImNodesCol_NodeBackgroundHovered] = IM_COL32(75, 75, 75, 255);
    dest->Colors[ImNodesCol_NodeBackgroundSelected] = IM_COL32(75, 75, 75, 255);
    dest->Colors[ImNodesCol_NodeOutline] = IM_COL32(100, 100, 100, 255);
    dest->Colors[ImNodesCol_TitleBar] = IM_COL32(69, 69, 138, 255);
    dest->Colors[ImNodesCol_TitleBarHovered] = IM_COL32(82, 82, 161, 255);
    dest->Colors[ImNodesCol_TitleBarSelected] = IM_COL32(82, 82, 161, 255);
    dest->Colors[ImNodesCol_Link] = IM_COL32(255, 255, 255, 100);
    dest->Colors[ImNodesCol_LinkHovered] = IM_COL32(105, 99, 204, 153);
    dest->Colors[ImNodesCol_LinkSelected] = IM_COL32(105, 99, 204, 153);
    dest->Colors[ImNodesCol_Pin] = IM_COL32(89, 102, 156, 170);
    dest->Colors[ImNodesCol_PinHovered] = IM_COL32(102, 122, 179, 200);
    dest->Colors[ImNodesCol_BoxSelector] = IM_COL32(82, 82, 161, 100);
    dest->Colors[ImNodesCol_BoxSelectorOutline] = IM_COL32(82, 82, 161, 255);
    dest->Colors[ImNodesCol_GridBackground] = IM_COL32(40, 40, 50, 200);
    dest->Colors[ImNodesCol_GridLine] = IM_COL32(200, 200, 200, 40);
    dest->Colors[ImNodesCol_GridLinePrimary] = IM_COL32(240, 240, 240, 60);

    // minimap colors
    dest->Colors[ImNodesCol_MiniMapBackground] = IM_COL32(25, 25, 25, 100);
    dest->Colors[ImNodesCol_MiniMapBackgroundHovered] = IM_COL32(25, 25, 25, 200);
    dest->Colors[ImNodesCol_MiniMapOutline] = IM_COL32(150, 150, 150, 100);
    dest->Colors[ImNodesCol_MiniMapOutlineHovered] = IM_COL32(150, 150, 150, 200);
    dest->Colors[ImNodesCol_MiniMapNodeBackground] = IM_COL32(200, 200, 200, 100);
    dest->Colors[ImNodesCol_MiniMapNodeBackgroundSelected] =
        dest->Colors[ImNodesCol_MiniMapNodeBackgroundHovered];
    dest->Colors[ImNodesCol_MiniMapNodeBackgroundSelected] = IM_COL32(200, 200, 240, 255);
    dest->Colors[ImNodesCol_MiniMapNodeOutline] = IM_COL32(200, 200, 200, 100);
    dest->Colors[ImNodesCol_MiniMapLink] = dest->Colors[ImNodesCol_Link];
    dest->Colors[ImNodesCol_MiniMapLinkSelected] = dest->Colors[ImNodesCol_LinkSelected];
    dest->Colors[ImNodesCol_MiniMapCanvas] = IM_COL32(200, 200, 200, 25);
    dest->Colors[ImNodesCol_MiniMapCanvasOutline] = IM_COL32(200, 200, 200, 200);
}

void StyleColorsLight(ImNodesStyle* dest)
{
    if (dest == nullptr)
    {
        dest = &GImNodes->Style;
    }

    dest->Colors[ImNodesCol_NodeBackground] = IM_COL32(240, 240, 240, 255);
    dest->Colors[ImNodesCol_NodeBackgroundHovered] = IM_COL32(240, 240, 240, 255);
    dest->Colors[ImNodesCol_NodeBackgroundSelected] = IM_COL32(240, 240, 240, 255);
    dest->Colors[ImNodesCol_NodeOutline] = IM_COL32(100, 100, 100, 255);
    dest->Colors[ImNodesCol_TitleBar] = IM_COL32(248, 248, 248, 255);
    dest->Colors[ImNodesCol_TitleBarHovered] = IM_COL32(209, 209, 209, 255);
    dest->Colors[ImNodesCol_TitleBarSelected] = IM_COL32(209, 209, 209, 255);
    // original imgui values: 66, 150, 250
    dest->Colors[ImNodesCol_Link] = IM_COL32(66, 150, 250, 100);
    // original imgui values: 117, 138, 204
    dest->Colors[ImNodesCol_LinkHovered] = IM_COL32(66, 150, 250, 242);
    dest->Colors[ImNodesCol_LinkSelected] = IM_COL32(66, 150, 250, 242);
    // original imgui values: 66, 150, 250
    dest->Colors[ImNodesCol_Pin] = IM_COL32(66, 150, 250, 160);
    dest->Colors[ImNodesCol_PinHovered] = IM_COL32(66, 150, 250, 255);
    dest->Colors[ImNodesCol_BoxSelector] = IM_COL32(90, 170, 250, 30);
    dest->Colors[ImNodesCol_BoxSelectorOutline] = IM_COL32(90, 170, 250, 150);
    dest->Colors[ImNodesCol_GridBackground] = IM_COL32(225, 225, 225, 255);
    dest->Colors[ImNodesCol_GridLine] = IM_COL32(180, 180, 180, 100);
    dest->Colors[ImNodesCol_GridLinePrimary] = IM_COL32(120, 120, 120, 100);

    // minimap colors
    dest->Colors[ImNodesCol_MiniMapBackground] = IM_COL32(25, 25, 25, 100);
    dest->Colors[ImNodesCol_MiniMapBackgroundHovered] = IM_COL32(25, 25, 25, 200);
    dest->Colors[ImNodesCol_MiniMapOutline] = IM_COL32(150, 150, 150, 100);
    dest->Colors[ImNodesCol_MiniMapOutlineHovered] = IM_COL32(150, 150, 150, 200);
    dest->Colors[ImNodesCol_MiniMapNodeBackground] = IM_COL32(200, 200, 200, 100);
    dest->Colors[ImNodesCol_MiniMapNodeBackgroundSelected] =
        dest->Colors[ImNodesCol_MiniMapNodeBackgroundHovered];
    dest->Colors[ImNodesCol_MiniMapNodeBackgroundSelected] = IM_COL32(200, 200, 240, 255);
    dest->Colors[ImNodesCol_MiniMapNodeOutline] = IM_COL32(200, 200, 200, 100);
    dest->Colors[ImNodesCol_MiniMapLink] = dest->Colors[ImNodesCol_Link];
    dest->Colors[ImNodesCol_MiniMapLinkSelected] = dest->Colors[ImNodesCol_LinkSelected];
    dest->Colors[ImNodesCol_MiniMapCanvas] = IM_COL32(200, 200, 200, 25);
    dest->Colors[ImNodesCol_MiniMapCanvasOutline] = IM_COL32(200, 200, 200, 200);
}

void BeginNodeEditor()
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    GImNodes->CurrentScope = ImNodesScope_Editor;

    // Reset state from previous pass

    ImNodesEditorContext& editor = EditorContextGet();
    editor.AutoPanningDelta = ImVec2(0, 0);
    editor.GridContentBounds = ImRect(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX);
    editor.MiniMapEnabled = false;
    ObjectPoolReset(editor.Nodes);
    ObjectPoolReset(editor.Pins);
    ObjectPoolReset(editor.Links);

    GImNodes->HoveredNodeIdx.Reset();
    GImNodes->HoveredLinkIdx.Reset();
    GImNodes->HoveredPinIdx.Reset();
    GImNodes->DeletedLinkIdx.Reset();
    GImNodes->SnapLinkIdx.Reset();

    GImNodes->NodeIndicesOverlappingWithMouse.clear();

    GImNodes->ImNodesUIState = ImNodesUIState_None;

    GImNodes->MousePos = ImGui::GetIO().MousePos;
    GImNodes->LeftMouseClicked = ImGui::IsMouseClicked(0);
    GImNodes->LeftMouseReleased = ImGui::IsMouseReleased(0);
    GImNodes->LeftMouseDragging = ImGui::IsMouseDragging(0, 0.0f);
    GImNodes->AltMouseClicked =
        (GImNodes->Io.EmulateThreeButtonMouse.Modifier != NULL &&
         *GImNodes->Io.EmulateThreeButtonMouse.Modifier && GImNodes->LeftMouseClicked) ||
        ImGui::IsMouseClicked(GImNodes->Io.AltMouseButton);
    GImNodes->AltMouseDragging =
        (GImNodes->Io.EmulateThreeButtonMouse.Modifier != NULL && GImNodes->LeftMouseDragging &&
         (*GImNodes->Io.EmulateThreeButtonMouse.Modifier)) ||
        ImGui::IsMouseDragging(GImNodes->Io.AltMouseButton, 0.0f);
    GImNodes->AltMouseScrollDelta = ImGui::GetIO().MouseWheel;
    GImNodes->MultipleSelectModifier =
        (GImNodes->Io.MultipleSelectModifier.Modifier != NULL
             ? *GImNodes->Io.MultipleSelectModifier.Modifier
             : ImGui::GetIO().KeyCtrl);

    GImNodes->ActiveAttribute = false;

    ImGui::BeginGroup();
    {
        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(1.f, 1.f));
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.f, 0.f));
        ImGui::PushStyleColor(ImGuiCol_ChildBg, GImNodes->Style.Colors[ImNodesCol_GridBackground]);
        ImGui::BeginChild(
            "scrolling_region",
            ImVec2(0.f, 0.f),
            true,
            ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoMove |
                ImGuiWindowFlags_NoScrollWithMouse);
        GImNodes->CanvasOriginScreenSpace = ImGui::GetCursorScreenPos();

        // NOTE: we have to fetch the canvas draw list *after* we call
        // BeginChild(), otherwise the ImGui UI elements are going to be
        // rendered into the parent window draw list.
        DrawListSet(ImGui::GetWindowDrawList());

        {
            const ImVec2 canvas_size = ImGui::GetWindowSize();
            GImNodes->CanvasRectScreenSpace = ImRect(
                EditorSpaceToScreenSpace(ImVec2(0.f, 0.f)), EditorSpaceToScreenSpace(canvas_size));

            if (GImNodes->Style.Flags & ImNodesStyleFlags_GridLines)
            {
                DrawGrid(editor, canvas_size);
            }
        }
    }
}

void EndNodeEditor()
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Editor);
    GImNodes->CurrentScope = ImNodesScope_None;

    ImNodesEditorContext& editor = EditorContextGet();

    bool no_grid_content = editor.GridContentBounds.IsInverted();
    if (no_grid_content)
    {
        editor.GridContentBounds = ScreenSpaceToGridSpace(editor, GImNodes->CanvasRectScreenSpace);
    }

    // Detect ImGui interaction first, because it blocks interaction with the rest of the UI

    if (GImNodes->LeftMouseClicked && ImGui::IsAnyItemActive())
    {
        editor.ClickInteraction.Type = ImNodesClickInteractionType_ImGuiItem;
    }

    // Detect which UI element is being hovered over. Detection is done in a hierarchical fashion,
    // because a UI element being hovered excludes any other as being hovered over.

    // Don't do hovering detection for nodes/links/pins when interacting with the mini-map, since
    // its an *overlay* with its own interaction behavior and must have precedence during mouse
    // interaction.

    if ((editor.ClickInteraction.Type == ImNodesClickInteractionType_None ||
         editor.ClickInteraction.Type == ImNodesClickInteractionType_LinkCreation) &&
        MouseInCanvas() && !IsMiniMapHovered())
    {
        // Pins needs some special care. We need to check the depth stack to see which pins are
        // being occluded by other nodes.
        ResolveOccludedPins(editor, GImNodes->OccludedPinIndices);

        GImNodes->HoveredPinIdx = ResolveHoveredPin(editor.Pins, GImNodes->OccludedPinIndices);

        if (!GImNodes->HoveredPinIdx.HasValue())
        {
            // Resolve which node is actually on top and being hovered using the depth stack.
            GImNodes->HoveredNodeIdx = ResolveHoveredNode(editor.NodeDepthOrder);
        }

        // We don't check for hovered pins here, because if we want to detach a link by clicking and
        // dragging, we need to have both a link and pin hovered.
        if (!GImNodes->HoveredNodeIdx.HasValue())
        {
            GImNodes->HoveredLinkIdx = ResolveHoveredLink(editor.Links, editor.Pins);
        }
    }

    for (int node_idx = 0; node_idx < editor.Nodes.Pool.size(); ++node_idx)
    {
        if (editor.Nodes.InUse[node_idx])
        {
            DrawListActivateNodeBackground(node_idx);
            DrawNode(editor, node_idx);
        }
    }

    // In order to render the links underneath the nodes, we want to first select the bottom draw
    // channel.
    GImNodes->CanvasDrawList->ChannelsSetCurrent(0);

    for (int link_idx = 0; link_idx < editor.Links.Pool.size(); ++link_idx)
    {
        if (editor.Links.InUse[link_idx])
        {
            DrawLink(editor, link_idx);
        }
    }

    // Render the click interaction UI elements (partial links, box selector) on top of everything
    // else.

    DrawListAppendClickInteractionChannel();
    DrawListActivateClickInteractionChannel();

    if (IsMiniMapActive())
    {
        CalcMiniMapLayout();
        MiniMapUpdate();
    }

    // Handle node graph interaction

    if (!IsMiniMapHovered())
    {
        if (GImNodes->LeftMouseClicked && GImNodes->HoveredLinkIdx.HasValue())
        {
            BeginLinkInteraction(editor, GImNodes->HoveredLinkIdx.Value(), GImNodes->HoveredPinIdx);
        }

        else if (GImNodes->LeftMouseClicked && GImNodes->HoveredPinIdx.HasValue())
        {
            BeginLinkCreation(editor, GImNodes->HoveredPinIdx.Value());
        }

        else if (GImNodes->LeftMouseClicked && GImNodes->HoveredNodeIdx.HasValue())
        {
            BeginNodeSelection(editor, GImNodes->HoveredNodeIdx.Value());
        }

        else if (
            GImNodes->LeftMouseClicked || GImNodes->LeftMouseReleased ||
            GImNodes->AltMouseClicked || GImNodes->AltMouseScrollDelta != 0.f)
        {
            BeginCanvasInteraction(editor);
        }

        bool should_auto_pan =
            editor.ClickInteraction.Type == ImNodesClickInteractionType_BoxSelection ||
            editor.ClickInteraction.Type == ImNodesClickInteractionType_LinkCreation ||
            editor.ClickInteraction.Type == ImNodesClickInteractionType_Node;
        if (should_auto_pan && !MouseInCanvas())
        {
            ImVec2 mouse = ImGui::GetMousePos();
            ImVec2 center = GImNodes->CanvasRectScreenSpace.GetCenter();
            ImVec2 direction = (center - mouse);
            direction = direction * ImInvLength(direction, 0.0);

            editor.AutoPanningDelta =
                direction * ImGui::GetIO().DeltaTime * GImNodes->Io.AutoPanningSpeed;
            editor.Panning += editor.AutoPanningDelta;
        }
    }
    ClickInteractionUpdate(editor);

    // At this point, draw commands have been issued for all nodes (and pins). Update the node pool
    // to detect unused node slots and remove those indices from the depth stack before sorting the
    // node draw commands by depth.
    ObjectPoolUpdate(editor.Nodes);
    ObjectPoolUpdate(editor.Pins);

    DrawListSortChannelsByDepth(editor.NodeDepthOrder);

    // After the links have been rendered, the link pool can be updated as well.
    ObjectPoolUpdate(editor.Links);

    // Finally, merge the draw channels
    GImNodes->CanvasDrawList->ChannelsMerge();

    // pop style
    ImGui::EndChild();      // end scrolling region
    ImGui::PopStyleColor(); // pop child window background color
    ImGui::PopStyleVar();   // pop window padding
    ImGui::PopStyleVar();   // pop frame padding
    ImGui::EndGroup();
}

void MiniMap(
    const float                                      minimap_size_fraction,
    const ImNodesMiniMapLocation                     location,
    const ImNodesMiniMapNodeHoveringCallback         node_hovering_callback,
    const ImNodesMiniMapNodeHoveringCallbackUserData node_hovering_callback_data)
{
    // Check that editor size fraction is sane; must be in the range (0, 1]
    IM_ASSERT(minimap_size_fraction > 0.f && minimap_size_fraction <= 1.f);

    // Remember to call before EndNodeEditor
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Editor);

    ImNodesEditorContext& editor = EditorContextGet();

    editor.MiniMapEnabled = true;
    editor.MiniMapSizeFraction = minimap_size_fraction;
    editor.MiniMapLocation = location;

    // Set node hovering callback information
    editor.MiniMapNodeHoveringCallback = node_hovering_callback;
    editor.MiniMapNodeHoveringCallbackUserData = node_hovering_callback_data;

    // Actual drawing/updating of the MiniMap is done in EndNodeEditor so that
    // mini map is draw over everything and all pin/link positions are updated
    // correctly relative to their respective nodes. Hence, we must store some of
    // of the state for the mini map in GImNodes for the actual drawing/updating
}

void BeginNode(const int node_id)
{
    // Remember to call BeginNodeEditor before calling BeginNode
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Editor);
    GImNodes->CurrentScope = ImNodesScope_Node;

    ImNodesEditorContext& editor = EditorContextGet();

    const int node_idx = ObjectPoolFindOrCreateIndex(editor.Nodes, node_id);
    GImNodes->CurrentNodeIdx = node_idx;

    ImNodeData& node = editor.Nodes.Pool[node_idx];
    node.ColorStyle.Background = GImNodes->Style.Colors[ImNodesCol_NodeBackground];
    node.ColorStyle.BackgroundHovered = GImNodes->Style.Colors[ImNodesCol_NodeBackgroundHovered];
    node.ColorStyle.BackgroundSelected = GImNodes->Style.Colors[ImNodesCol_NodeBackgroundSelected];
    node.ColorStyle.Outline = GImNodes->Style.Colors[ImNodesCol_NodeOutline];
    node.ColorStyle.Titlebar = GImNodes->Style.Colors[ImNodesCol_TitleBar];
    node.ColorStyle.TitlebarHovered = GImNodes->Style.Colors[ImNodesCol_TitleBarHovered];
    node.ColorStyle.TitlebarSelected = GImNodes->Style.Colors[ImNodesCol_TitleBarSelected];
    node.LayoutStyle.CornerRounding = GImNodes->Style.NodeCornerRounding;
    node.LayoutStyle.Padding = GImNodes->Style.NodePadding;
    node.LayoutStyle.BorderThickness = GImNodes->Style.NodeBorderThickness;

    // ImGui::SetCursorPos sets the cursor position, local to the current widget
    // (in this case, the child object started in BeginNodeEditor). Use
    // ImGui::SetCursorScreenPos to set the screen space coordinates directly.
    ImGui::SetCursorPos(GridSpaceToEditorSpace(editor, GetNodeTitleBarOrigin(node)));

    DrawListAddNode(node_idx);
    DrawListActivateCurrentNodeForeground();

    ImGui::PushID(node.Id);
    ImGui::BeginGroup();
}

void EndNode()
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Node);
    GImNodes->CurrentScope = ImNodesScope_Editor;

    ImNodesEditorContext& editor = EditorContextGet();

    // The node's rectangle depends on the ImGui UI group size.
    ImGui::EndGroup();
    ImGui::PopID();

    ImNodeData& node = editor.Nodes.Pool[GImNodes->CurrentNodeIdx];
    node.Rect = GetItemRect();
    node.Rect.Expand(node.LayoutStyle.Padding);

    editor.GridContentBounds.Add(node.Origin);
    editor.GridContentBounds.Add(node.Origin + node.Rect.GetSize());

    if (node.Rect.Contains(GImNodes->MousePos))
    {
        GImNodes->NodeIndicesOverlappingWithMouse.push_back(GImNodes->CurrentNodeIdx);
    }
}

ImVec2 GetNodeDimensions(int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    const int             node_idx = ObjectPoolFind(editor.Nodes, node_id);
    IM_ASSERT(node_idx != -1); // invalid node_id
    const ImNodeData& node = editor.Nodes.Pool[node_idx];
    return node.Rect.GetSize();
}

void BeginNodeTitleBar()
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Node);
    ImGui::BeginGroup();
}

void EndNodeTitleBar()
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Node);
    ImGui::EndGroup();

    ImNodesEditorContext& editor = EditorContextGet();
    ImNodeData&           node = editor.Nodes.Pool[GImNodes->CurrentNodeIdx];
    node.TitleBarContentRect = GetItemRect();

    ImGui::ItemAdd(GetNodeTitleRect(node), ImGui::GetID("title_bar"));

    ImGui::SetCursorPos(GridSpaceToEditorSpace(editor, GetNodeContentOrigin(node)));
}

void BeginInputAttribute(const int id, const ImNodesPinShape shape)
{
    BeginPinAttribute(id, ImNodesAttributeType_Input, shape, GImNodes->CurrentNodeIdx);
}

void EndInputAttribute() { EndPinAttribute(); }

void BeginOutputAttribute(const int id, const ImNodesPinShape shape)
{
    BeginPinAttribute(id, ImNodesAttributeType_Output, shape, GImNodes->CurrentNodeIdx);
}

void EndOutputAttribute() { EndPinAttribute(); }

void BeginStaticAttribute(const int id)
{
    // Make sure to call BeginNode() before calling BeginAttribute()
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Node);
    GImNodes->CurrentScope = ImNodesScope_Attribute;

    GImNodes->CurrentAttributeId = id;

    ImGui::BeginGroup();
    ImGui::PushID(id);
}

void EndStaticAttribute()
{
    // Make sure to call BeginNode() before calling BeginAttribute()
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Attribute);
    GImNodes->CurrentScope = ImNodesScope_Node;

    ImGui::PopID();
    ImGui::EndGroup();

    if (ImGui::IsItemActive())
    {
        GImNodes->ActiveAttribute = true;
        GImNodes->ActiveAttributeId = GImNodes->CurrentAttributeId;
    }
}

void PushAttributeFlag(const ImNodesAttributeFlags flag)
{
    GImNodes->CurrentAttributeFlags |= flag;
    GImNodes->AttributeFlagStack.push_back(GImNodes->CurrentAttributeFlags);
}

void PopAttributeFlag()
{
    // PopAttributeFlag called without a matching PushAttributeFlag!
    // The bottom value is always the default value, pushed in Initialize().
    IM_ASSERT(GImNodes->AttributeFlagStack.size() > 1);

    GImNodes->AttributeFlagStack.pop_back();
    GImNodes->CurrentAttributeFlags = GImNodes->AttributeFlagStack.back();
}

void Link(const int id, const int start_attr_id, const int end_attr_id)
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_Editor);

    ImNodesEditorContext& editor = EditorContextGet();
    ImLinkData&           link = ObjectPoolFindOrCreateObject(editor.Links, id);
    link.Id = id;
    link.StartPinIdx = ObjectPoolFindOrCreateIndex(editor.Pins, start_attr_id);
    link.EndPinIdx = ObjectPoolFindOrCreateIndex(editor.Pins, end_attr_id);
    link.ColorStyle.Base = GImNodes->Style.Colors[ImNodesCol_Link];
    link.ColorStyle.Hovered = GImNodes->Style.Colors[ImNodesCol_LinkHovered];
    link.ColorStyle.Selected = GImNodes->Style.Colors[ImNodesCol_LinkSelected];

    // Check if this link was created by the current link event
    if ((editor.ClickInteraction.Type == ImNodesClickInteractionType_LinkCreation &&
         editor.Pins.Pool[link.EndPinIdx].Flags & ImNodesAttributeFlags_EnableLinkCreationOnSnap &&
         editor.ClickInteraction.LinkCreation.StartPinIdx == link.StartPinIdx &&
         editor.ClickInteraction.LinkCreation.EndPinIdx == link.EndPinIdx) ||
        (editor.ClickInteraction.LinkCreation.StartPinIdx == link.EndPinIdx &&
         editor.ClickInteraction.LinkCreation.EndPinIdx == link.StartPinIdx))
    {
        GImNodes->SnapLinkIdx = ObjectPoolFindOrCreateIndex(editor.Links, id);
    }
}

void PushColorStyle(const ImNodesCol item, unsigned int color)
{
    GImNodes->ColorModifierStack.push_back(ImNodesColElement(GImNodes->Style.Colors[item], item));
    GImNodes->Style.Colors[item] = color;
}

void PopColorStyle()
{
    IM_ASSERT(GImNodes->ColorModifierStack.size() > 0);
    const ImNodesColElement elem = GImNodes->ColorModifierStack.back();
    GImNodes->Style.Colors[elem.Item] = elem.Color;
    GImNodes->ColorModifierStack.pop_back();
}

struct ImNodesStyleVarInfo
{
    ImGuiDataType Type;
    ImU32         Count;
    ImU32         Offset;
    void* GetVarPtr(ImNodesStyle* style) const { return (void*)((unsigned char*)style + Offset); }
};

static const ImNodesStyleVarInfo GStyleVarInfo[] = {
    // ImNodesStyleVar_GridSpacing
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, GridSpacing)},
    // ImNodesStyleVar_NodeCornerRounding
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, NodeCornerRounding)},
    // ImNodesStyleVar_NodePadding
    {ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImNodesStyle, NodePadding)},
    // ImNodesStyleVar_NodeBorderThickness
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, NodeBorderThickness)},
    // ImNodesStyleVar_LinkThickness
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, LinkThickness)},
    // ImNodesStyleVar_LinkLineSegmentsPerLength
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, LinkLineSegmentsPerLength)},
    // ImNodesStyleVar_LinkHoverDistance
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, LinkHoverDistance)},
    // ImNodesStyleVar_PinCircleRadius
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, PinCircleRadius)},
    // ImNodesStyleVar_PinQuadSideLength
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, PinQuadSideLength)},
    // ImNodesStyleVar_PinTriangleSideLength
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, PinTriangleSideLength)},
    // ImNodesStyleVar_PinLineThickness
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, PinLineThickness)},
    // ImNodesStyleVar_PinHoverRadius
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, PinHoverRadius)},
    // ImNodesStyleVar_PinOffset
    {ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImNodesStyle, PinOffset)},
    // ImNodesStyleVar_MiniMapPadding
    {ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImNodesStyle, MiniMapPadding)},
    // ImNodesStyleVar_MiniMapOffset
    {ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImNodesStyle, MiniMapOffset)},
};

static const ImNodesStyleVarInfo* GetStyleVarInfo(ImNodesStyleVar idx)
{
    IM_ASSERT(idx >= 0 && idx < ImNodesStyleVar_COUNT);
    IM_ASSERT(IM_ARRAYSIZE(GStyleVarInfo) == ImNodesStyleVar_COUNT);
    return &GStyleVarInfo[idx];
}

void PushStyleVar(const ImNodesStyleVar item, const float value)
{
    const ImNodesStyleVarInfo* var_info = GetStyleVarInfo(item);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1)
    {
        float& style_var = *(float*)var_info->GetVarPtr(&GImNodes->Style);
        GImNodes->StyleModifierStack.push_back(ImNodesStyleVarElement(item, style_var));
        style_var = value;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() float variant but variable is not a float!");
}

void PushStyleVar(const ImNodesStyleVar item, const ImVec2& value)
{
    const ImNodesStyleVarInfo* var_info = GetStyleVarInfo(item);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
    {
        ImVec2& style_var = *(ImVec2*)var_info->GetVarPtr(&GImNodes->Style);
        GImNodes->StyleModifierStack.push_back(ImNodesStyleVarElement(item, style_var));
        style_var = value;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() ImVec2 variant but variable is not a ImVec2!");
}

void PopStyleVar(int count)
{
    while (count > 0)
    {
        IM_ASSERT(GImNodes->StyleModifierStack.size() > 0);
        const ImNodesStyleVarElement style_backup = GImNodes->StyleModifierStack.back();
        GImNodes->StyleModifierStack.pop_back();
        const ImNodesStyleVarInfo* var_info = GetStyleVarInfo(style_backup.Item);
        void*                      style_var = var_info->GetVarPtr(&GImNodes->Style);
        if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1)
        {
            ((float*)style_var)[0] = style_backup.FloatValue[0];
        }
        else if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
        {
            ((float*)style_var)[0] = style_backup.FloatValue[0];
            ((float*)style_var)[1] = style_backup.FloatValue[1];
        }
        count--;
    }
}

void SetNodeScreenSpacePos(const int node_id, const ImVec2& screen_space_pos)
{
    ImNodesEditorContext& editor = EditorContextGet();
    ImNodeData&           node = ObjectPoolFindOrCreateObject(editor.Nodes, node_id);
    node.Origin = ScreenSpaceToGridSpace(editor, screen_space_pos);
}

void SetNodeEditorSpacePos(const int node_id, const ImVec2& editor_space_pos)
{
    ImNodesEditorContext& editor = EditorContextGet();
    ImNodeData&           node = ObjectPoolFindOrCreateObject(editor.Nodes, node_id);
    node.Origin = EditorSpaceToGridSpace(editor, editor_space_pos);
}

void SetNodeGridSpacePos(const int node_id, const ImVec2& grid_pos)
{
    ImNodesEditorContext& editor = EditorContextGet();
    ImNodeData&           node = ObjectPoolFindOrCreateObject(editor.Nodes, node_id);
    node.Origin = grid_pos;
}

void SetNodeDraggable(const int node_id, const bool draggable)
{
    ImNodesEditorContext& editor = EditorContextGet();
    ImNodeData&           node = ObjectPoolFindOrCreateObject(editor.Nodes, node_id);
    node.Draggable = draggable;
}

ImVec2 GetNodeScreenSpacePos(const int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    const int             node_idx = ObjectPoolFind(editor.Nodes, node_id);
    IM_ASSERT(node_idx != -1);
    ImNodeData& node = editor.Nodes.Pool[node_idx];
    return GridSpaceToScreenSpace(editor, node.Origin);
}

ImVec2 GetNodeEditorSpacePos(const int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    const int             node_idx = ObjectPoolFind(editor.Nodes, node_id);
    IM_ASSERT(node_idx != -1);
    ImNodeData& node = editor.Nodes.Pool[node_idx];
    return GridSpaceToEditorSpace(editor, node.Origin);
}

ImVec2 GetNodeGridSpacePos(const int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    const int             node_idx = ObjectPoolFind(editor.Nodes, node_id);
    IM_ASSERT(node_idx != -1);
    ImNodeData& node = editor.Nodes.Pool[node_idx];
    return node.Origin;
}

void SnapNodeToGrid(int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    ImNodeData&           node = ObjectPoolFindOrCreateObject(editor.Nodes, node_id);
    node.Origin = SnapOriginToGrid(node.Origin);
}

bool IsEditorHovered() { return MouseInCanvas(); }

bool IsNodeHovered(int* const node_id)
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    IM_ASSERT(node_id != NULL);

    const bool is_hovered = GImNodes->HoveredNodeIdx.HasValue();
    if (is_hovered)
    {
        const ImNodesEditorContext& editor = EditorContextGet();
        *node_id = editor.Nodes.Pool[GImNodes->HoveredNodeIdx.Value()].Id;
    }
    return is_hovered;
}

bool IsLinkHovered(int* const link_id)
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    IM_ASSERT(link_id != NULL);

    const bool is_hovered = GImNodes->HoveredLinkIdx.HasValue();
    if (is_hovered)
    {
        const ImNodesEditorContext& editor = EditorContextGet();
        *link_id = editor.Links.Pool[GImNodes->HoveredLinkIdx.Value()].Id;
    }
    return is_hovered;
}

bool IsPinHovered(int* const attr)
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    IM_ASSERT(attr != NULL);

    const bool is_hovered = GImNodes->HoveredPinIdx.HasValue();
    if (is_hovered)
    {
        const ImNodesEditorContext& editor = EditorContextGet();
        *attr = editor.Pins.Pool[GImNodes->HoveredPinIdx.Value()].Id;
    }
    return is_hovered;
}

int NumSelectedNodes()
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    const ImNodesEditorContext& editor = EditorContextGet();
    return editor.SelectedNodeIndices.size();
}

int NumSelectedLinks()
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    const ImNodesEditorContext& editor = EditorContextGet();
    return editor.SelectedLinkIndices.size();
}

void GetSelectedNodes(int* node_ids)
{
    IM_ASSERT(node_ids != NULL);

    const ImNodesEditorContext& editor = EditorContextGet();
    for (int i = 0; i < editor.SelectedNodeIndices.size(); ++i)
    {
        const int node_idx = editor.SelectedNodeIndices[i];
        node_ids[i] = editor.Nodes.Pool[node_idx].Id;
    }
}

void GetSelectedLinks(int* link_ids)
{
    IM_ASSERT(link_ids != NULL);

    const ImNodesEditorContext& editor = EditorContextGet();
    for (int i = 0; i < editor.SelectedLinkIndices.size(); ++i)
    {
        const int link_idx = editor.SelectedLinkIndices[i];
        link_ids[i] = editor.Links.Pool[link_idx].Id;
    }
}

void ClearNodeSelection()
{
    ImNodesEditorContext& editor = EditorContextGet();
    editor.SelectedNodeIndices.clear();
}

void ClearNodeSelection(int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    ClearObjectSelection(editor.Nodes, editor.SelectedNodeIndices, node_id);
}

void ClearLinkSelection()
{
    ImNodesEditorContext& editor = EditorContextGet();
    editor.SelectedLinkIndices.clear();
}

void ClearLinkSelection(int link_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    ClearObjectSelection(editor.Links, editor.SelectedLinkIndices, link_id);
}

void SelectNode(int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    SelectObject(editor.Nodes, editor.SelectedNodeIndices, node_id);
}

void SelectLink(int link_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    SelectObject(editor.Links, editor.SelectedLinkIndices, link_id);
}

bool IsNodeSelected(int node_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    return IsObjectSelected(editor.Nodes, editor.SelectedNodeIndices, node_id);
}

bool IsLinkSelected(int link_id)
{
    ImNodesEditorContext& editor = EditorContextGet();
    return IsObjectSelected(editor.Links, editor.SelectedLinkIndices, link_id);
}

bool IsAttributeActive()
{
    IM_ASSERT((GImNodes->CurrentScope & ImNodesScope_Node) != 0);

    if (!GImNodes->ActiveAttribute)
    {
        return false;
    }

    return GImNodes->ActiveAttributeId == GImNodes->CurrentAttributeId;
}

bool IsAnyAttributeActive(int* const attribute_id)
{
    IM_ASSERT((GImNodes->CurrentScope & (ImNodesScope_Node | ImNodesScope_Attribute)) == 0);

    if (!GImNodes->ActiveAttribute)
    {
        return false;
    }

    if (attribute_id != NULL)
    {
        *attribute_id = GImNodes->ActiveAttributeId;
    }

    return true;
}

bool IsLinkStarted(int* const started_at_id)
{
    // Call this function after EndNodeEditor()!
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    IM_ASSERT(started_at_id != NULL);

    const bool is_started = (GImNodes->ImNodesUIState & ImNodesUIState_LinkStarted) != 0;
    if (is_started)
    {
        const ImNodesEditorContext& editor = EditorContextGet();
        const int                   pin_idx = editor.ClickInteraction.LinkCreation.StartPinIdx;
        *started_at_id = editor.Pins.Pool[pin_idx].Id;
    }

    return is_started;
}

bool IsLinkDropped(int* const started_at_id, const bool including_detached_links)
{
    // Call this function after EndNodeEditor()!
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);

    const ImNodesEditorContext& editor = EditorContextGet();

    const bool link_dropped =
        (GImNodes->ImNodesUIState & ImNodesUIState_LinkDropped) != 0 &&
        (including_detached_links ||
         editor.ClickInteraction.LinkCreation.Type != ImNodesLinkCreationType_FromDetach);

    if (link_dropped && started_at_id)
    {
        const int pin_idx = editor.ClickInteraction.LinkCreation.StartPinIdx;
        *started_at_id = editor.Pins.Pool[pin_idx].Id;
    }

    return link_dropped;
}

bool IsLinkCreated(
    int* const  started_at_pin_id,
    int* const  ended_at_pin_id,
    bool* const created_from_snap)
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    IM_ASSERT(started_at_pin_id != NULL);
    IM_ASSERT(ended_at_pin_id != NULL);

    const bool is_created = (GImNodes->ImNodesUIState & ImNodesUIState_LinkCreated) != 0;

    if (is_created)
    {
        const ImNodesEditorContext& editor = EditorContextGet();
        const int                   start_idx = editor.ClickInteraction.LinkCreation.StartPinIdx;
        const int        end_idx = editor.ClickInteraction.LinkCreation.EndPinIdx.Value();
        const ImPinData& start_pin = editor.Pins.Pool[start_idx];
        const ImPinData& end_pin = editor.Pins.Pool[end_idx];

        if (start_pin.Type == ImNodesAttributeType_Output)
        {
            *started_at_pin_id = start_pin.Id;
            *ended_at_pin_id = end_pin.Id;
        }
        else
        {
            *started_at_pin_id = end_pin.Id;
            *ended_at_pin_id = start_pin.Id;
        }

        if (created_from_snap)
        {
            *created_from_snap =
                editor.ClickInteraction.Type == ImNodesClickInteractionType_LinkCreation;
        }
    }

    return is_created;
}

bool IsLinkCreated(
    int*  started_at_node_id,
    int*  started_at_pin_id,
    int*  ended_at_node_id,
    int*  ended_at_pin_id,
    bool* created_from_snap)
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);
    IM_ASSERT(started_at_node_id != NULL);
    IM_ASSERT(started_at_pin_id != NULL);
    IM_ASSERT(ended_at_node_id != NULL);
    IM_ASSERT(ended_at_pin_id != NULL);

    const bool is_created = (GImNodes->ImNodesUIState & ImNodesUIState_LinkCreated) != 0;

    if (is_created)
    {
        const ImNodesEditorContext& editor = EditorContextGet();
        const int                   start_idx = editor.ClickInteraction.LinkCreation.StartPinIdx;
        const int         end_idx = editor.ClickInteraction.LinkCreation.EndPinIdx.Value();
        const ImPinData&  start_pin = editor.Pins.Pool[start_idx];
        const ImNodeData& start_node = editor.Nodes.Pool[start_pin.ParentNodeIdx];
        const ImPinData&  end_pin = editor.Pins.Pool[end_idx];
        const ImNodeData& end_node = editor.Nodes.Pool[end_pin.ParentNodeIdx];

        if (start_pin.Type == ImNodesAttributeType_Output)
        {
            *started_at_pin_id = start_pin.Id;
            *started_at_node_id = start_node.Id;
            *ended_at_pin_id = end_pin.Id;
            *ended_at_node_id = end_node.Id;
        }
        else
        {
            *started_at_pin_id = end_pin.Id;
            *started_at_node_id = end_node.Id;
            *ended_at_pin_id = start_pin.Id;
            *ended_at_node_id = start_node.Id;
        }

        if (created_from_snap)
        {
            *created_from_snap =
                editor.ClickInteraction.Type == ImNodesClickInteractionType_LinkCreation;
        }
    }

    return is_created;
}

bool IsLinkDestroyed(int* const link_id)
{
    IM_ASSERT(GImNodes->CurrentScope == ImNodesScope_None);

    const bool link_destroyed = GImNodes->DeletedLinkIdx.HasValue();
    if (link_destroyed)
    {
        const ImNodesEditorContext& editor = EditorContextGet();
        const int                   link_idx = GImNodes->DeletedLinkIdx.Value();
        *link_id = editor.Links.Pool[link_idx].Id;
    }

    return link_destroyed;
}

namespace
{
void NodeLineHandler(ImNodesEditorContext& editor, const char* const line)
{
    int id;
    int x, y;
    if (sscanf(line, "[node.%i", &id) == 1)
    {
        const int node_idx = ObjectPoolFindOrCreateIndex(editor.Nodes, id);
        GImNodes->CurrentNodeIdx = node_idx;
        ImNodeData& node = editor.Nodes.Pool[node_idx];
        node.Id = id;
    }
    else if (sscanf(line, "origin=%i,%i", &x, &y) == 2)
    {
        ImNodeData& node = editor.Nodes.Pool[GImNodes->CurrentNodeIdx];
        node.Origin = SnapOriginToGrid(ImVec2((float)x, (float)y));
    }
}

void EditorLineHandler(ImNodesEditorContext& editor, const char* const line)
{
    (void)sscanf(line, "panning=%f,%f", &editor.Panning.x, &editor.Panning.y);
}
} // namespace

const char* SaveCurrentEditorStateToIniString(size_t* const data_size)
{
    return SaveEditorStateToIniString(&EditorContextGet(), data_size);
}

const char* SaveEditorStateToIniString(
    const ImNodesEditorContext* const editor_ptr,
    size_t* const                     data_size)
{
    IM_ASSERT(editor_ptr != NULL);
    const ImNodesEditorContext& editor = *editor_ptr;

    GImNodes->TextBuffer.clear();
    // TODO: check to make sure that the estimate is the upper bound of element
    GImNodes->TextBuffer.reserve(64 * editor.Nodes.Pool.size());

    GImNodes->TextBuffer.appendf(
        "[editor]\npanning=%i,%i\n", (int)editor.Panning.x, (int)editor.Panning.y);

    for (int i = 0; i < editor.Nodes.Pool.size(); i++)
    {
        if (editor.Nodes.InUse[i])
        {
            const ImNodeData& node = editor.Nodes.Pool[i];
            GImNodes->TextBuffer.appendf("\n[node.%d]\n", node.Id);
            GImNodes->TextBuffer.appendf("origin=%i,%i\n", (int)node.Origin.x, (int)node.Origin.y);
        }
    }

    if (data_size != NULL)
    {
        *data_size = GImNodes->TextBuffer.size();
    }

    return GImNodes->TextBuffer.c_str();
}

void LoadCurrentEditorStateFromIniString(const char* const data, const size_t data_size)
{
    LoadEditorStateFromIniString(&EditorContextGet(), data, data_size);
}

void LoadEditorStateFromIniString(
    ImNodesEditorContext* const editor_ptr,
    const char* const           data,
    const size_t                data_size)
{
    if (data_size == 0u)
    {
        return;
    }

    ImNodesEditorContext& editor = editor_ptr == NULL ? EditorContextGet() : *editor_ptr;

    char*       buf = (char*)ImGui::MemAlloc(data_size + 1);
    const char* buf_end = buf + data_size;
    memcpy(buf, data, data_size);
    buf[data_size] = 0;

    void (*line_handler)(ImNodesEditorContext&, const char*);
    line_handler = NULL;
    char* line_end = NULL;
    for (char* line = buf; line < buf_end; line = line_end + 1)
    {
        while (*line == '\n' || *line == '\r')
        {
            line++;
        }
        line_end = line;
        while (line_end < buf_end && *line_end != '\n' && *line_end != '\r')
        {
            line_end++;
        }
        line_end[0] = 0;

        if (*line == ';' || *line == '\0')
        {
            continue;
        }

        if (line[0] == '[' && line_end[-1] == ']')
        {
            line_end[-1] = 0;
            if (strncmp(line + 1, "node", 4) == 0)
            {
                line_handler = NodeLineHandler;
            }
            else if (strcmp(line + 1, "editor") == 0)
            {
                line_handler = EditorLineHandler;
            }
        }

        if (line_handler != NULL)
        {
            line_handler(editor, line);
        }
    }
    ImGui::MemFree(buf);
}

void SaveCurrentEditorStateToIniFile(const char* const file_name)
{
    SaveEditorStateToIniFile(&EditorContextGet(), file_name);
}

void SaveEditorStateToIniFile(const ImNodesEditorContext* const editor, const char* const file_name)
{
    size_t      data_size = 0u;
    const char* data = SaveEditorStateToIniString(editor, &data_size);
    FILE*       file = ImFileOpen(file_name, "wt");
    if (!file)
    {
        return;
    }

    fwrite(data, sizeof(char), data_size, file);
    fclose(file);
}

void LoadCurrentEditorStateFromIniFile(const char* const file_name)
{
    LoadEditorStateFromIniFile(&EditorContextGet(), file_name);
}

void LoadEditorStateFromIniFile(ImNodesEditorContext* const editor, const char* const file_name)
{
    size_t data_size = 0u;
    char*  file_data = (char*)ImFileLoadToMemory(file_name, "rb", &data_size);

    if (!file_data)
    {
        return;
    }

    LoadEditorStateFromIniString(editor, file_data, data_size);
    ImGui::MemFree(file_data);
}
} // namespace IMNODES_NAMESPACE


================================================
FILE: Source/External/imgui_tools/imnodes/imnodes.h
================================================
#pragma once

#include <stddef.h>
#include <imgui.h>

#ifdef IMNODES_USER_CONFIG
#include IMNODES_USER_CONFIG
#endif

#ifndef IMNODES_NAMESPACE
#define IMNODES_NAMESPACE ImNodes
#endif

typedef int ImNodesCol;             // -> enum ImNodesCol_
typedef int ImNodesStyleVar;        // -> enum ImNodesStyleVar_
typedef int ImNodesStyleFlags;      // -> enum ImNodesStyleFlags_
typedef int ImNodesPinShape;        // -> enum ImNodesPinShape_
typedef int ImNodesAttributeFlags;  // -> enum ImNodesAttributeFlags_
typedef int ImNodesMiniMapLocation; // -> enum ImNodesMiniMapLocation_

enum ImNodesCol_
{
    ImNodesCol_NodeBackground = 0,
    ImNodesCol_NodeBackgroundHovered,
    ImNodesCol_NodeBackgroundSelected,
    ImNodesCol_NodeOutline,
    ImNodesCol_TitleBar,
    ImNodesCol_TitleBarHovered,
    ImNodesCol_TitleBarSelected,
    ImNodesCol_Link,
    ImNodesCol_LinkHovered,
    ImNodesCol_LinkSelected,
    ImNodesCol_Pin,
    ImNodesCol_PinHovered,
    ImNodesCol_BoxSelector,
    ImNodesCol_BoxSelectorOutline,
    ImNodesCol_GridBackground,
    ImNodesCol_GridLine,
    ImNodesCol_GridLinePrimary,
    ImNodesCol_MiniMapBackground,
    ImNodesCol_MiniMapBackgroundHovered,
    ImNodesCol_MiniMapOutline,
    ImNodesCol_MiniMapOutlineHovered,
    ImNodesCol_MiniMapNodeBackground,
    ImNodesCol_MiniMapNodeBackgroundHovered,
    ImNodesCol_MiniMapNodeBackgroundSelected,
    ImNodesCol_MiniMapNodeOutline,
    ImNodesCol_MiniMapLink,
    ImNodesCol_MiniMapLinkSelected,
    ImNodesCol_MiniMapCanvas,
    ImNodesCol_MiniMapCanvasOutline,
    ImNodesCol_COUNT
};

enum ImNodesStyleVar_
{
    ImNodesStyleVar_GridSpacing = 0,
    ImNodesStyleVar_NodeCornerRounding,
    ImNodesStyleVar_NodePadding,
    ImNodesStyleVar_NodeBorderThickness,
    ImNodesStyleVar_LinkThickness,
    ImNodesStyleVar_LinkLineSegmentsPerLength,
    ImNodesStyleVar_LinkHoverDistance,
    ImNodesStyleVar_PinCircleRadius,
    ImNodesStyleVar_PinQuadSideLength,
    ImNodesStyleVar_PinTriangleSideLength,
    ImNodesStyleVar_PinLineThickness,
    ImNodesStyleVar_PinHoverRadius,
    ImNodesStyleVar_PinOffset,
    ImNodesStyleVar_MiniMapPadding,
    ImNodesStyleVar_MiniMapOffset,
    ImNodesStyleVar_COUNT
};

enum ImNodesStyleFlags_
{
    ImNodesStyleFlags_None = 0,
    ImNodesStyleFlags_NodeOutline = 1 << 0,
    ImNodesStyleFlags_GridLines = 1 << 2,
    ImNodesStyleFlags_GridLinesPrimary = 1 << 3,
    ImNodesStyleFlags_GridSnapping = 1 << 4
};

enum ImNodesPinShape_
{
    ImNodesPinShape_Circle,
    ImNodesPinShape_CircleFilled,
    ImNodesPinShape_Triangle,
    ImNodesPinShape_TriangleFilled,
    ImNodesPinShape_Quad,
    ImNodesPinShape_QuadFilled
};

// This enum controls the way the attribute pins behave.
enum ImNodesAttributeFlags_
{
    ImNodesAttributeFlags_None = 0,
    // Allow detaching a link by left-clicking and dragging the link at a pin it is connected to.
    // NOTE: the user has to actually delete the link for this to work. A deleted link can be
    // detected by calling IsLinkDestroyed() after EndNodeEditor().
    ImNodesAttributeFlags_EnableLinkDetachWithDragClick = 1 << 0,
    // Visual snapping of an in progress link will trigger IsLink Created/Destroyed events. Allows
    // for previewing the creation of a link while dragging it across attributes. See here for demo:
    // https://github.com/Nelarius/imnodes/issues/41#issuecomment-647132113 NOTE: the user has to
    // actually delete the link for this to work. A deleted link can be detected by calling
    // IsLinkDestroyed() after EndNodeEditor().
    ImNodesAttributeFlags_EnableLinkCreationOnSnap = 1 << 1
};

struct ImNodesIO
{
    struct EmulateThreeButtonMouse
    {
        EmulateThreeButtonMouse();

        // The keyboard modifier to use in combination with mouse left click to pan the editor view.
        // Set to NULL by default. To enable this feature, set the modifier to point to a boolean
        // indicating the state of a modifier. For example,
        //
        // ImNodes::GetIO().EmulateThreeButtonMouse.Modifier = &ImGui::GetIO().KeyAlt;
        const bool* Modifier;
    } EmulateThreeButtonMouse;

    struct LinkDetachWithModifierClick
    {
        LinkDetachWithModifierClick();

        // Pointer to a boolean value indicating when the desired modifier is pressed. Set to NULL
        // by default. To enable the feature, set the modifier to point to a boolean indicating the
        // state of a modifier. For example,
        //
        // ImNodes::GetIO().LinkDetachWithModifierClick.Modifier = &ImGui::GetIO().KeyCtrl;
        //
        // Left-clicking a link with this modifier pressed will detach that link. NOTE: the user has
        // to actually delete the link for this to work. A deleted link can be detected by calling
        // IsLinkDestroyed() after EndNodeEditor().
        const bool* Modifier;
    } LinkDetachWithModifierClick;

    struct MultipleSelectModifier
    {
        MultipleSelectModifier();

        // Pointer to a boolean value indicating when the desired modifier is pressed. Set to NULL
        // by default. To enable the feature, set the modifier to point to a boolean indicating the
        // state of a modifier. For example,
        //
        // ImNodes::GetIO().MultipleSelectModifier.Modifier = &ImGui::GetIO().KeyCtrl;
        //
        // Left-clicking a node with this modifier pressed will add the node to the list of
        // currently selected nodes. If this value is NULL, the Ctrl key will be used.
        const bool* Modifier;
    } MultipleSelectModifier;

    // Holding alt mouse button pans the node area, by default middle mouse button will be used
    // Set based on ImGuiMouseButton values
    int AltMouseButton;

    // Panning speed when dragging an element and mouse is outside the main editor view.
    float AutoPanningSpeed;

    ImNodesIO();
};

struct ImNodesStyle
{
    float GridSpacing;

    float  NodeCornerRounding;
    ImVec2 NodePadding;
    float  NodeBorderThickness;

    float LinkThickness;
    float LinkLineSegmentsPerLength;
    float LinkHoverDistance;

    // The following variables control the look and behavior of the pins. The default size of each
    // pin shape is balanced to occupy approximately the same surface area on the screen.

    // The circle radius used when the pin shape is either ImNodesPinShape_Circle or
    // ImNodesPinShape_CircleFilled.
    float PinCircleRadius;
    // The quad side length used when the shape is either ImNodesPinShape_Quad or
    // ImNodesPinShape_QuadFilled.
    float PinQuadSideLength;
    // The equilateral triangle side length used when the pin shape is either
    // ImNodesPinShape_Triangle or ImNodesPinShape_TriangleFilled.
    float PinTriangleSideLength;
    // The thickness of the line used when the pin shape is not filled.
    float PinLineThickness;
    // The radius from the pin's center position inside of which it is detected as being hovered
    // over.
    float PinHoverRadius;
    // Offsets the pins' positions from the edge of the node to the outside of the node.
    float PinOffset;

    // Mini-map padding size between mini-map edge and mini-map content.
    ImVec2 MiniMapPadding;
    // Mini-map offset from the screen side.
    ImVec2 MiniMapOffset;

    // By default, ImNodesStyleFlags_NodeOutline and ImNodesStyleFlags_Gridlines are enabled.
    ImNodesStyleFlags Flags;
    // Set these mid-frame using Push/PopColorStyle. You can index this color array with with a
    // ImNodesCol value.
    unsigned int Colors[ImNodesCol_COUNT];

    ImNodesStyle();
};

enum ImNodesMiniMapLocation_
{
    ImNodesMiniMapLocation_BottomLeft,
    ImNodesMiniMapLocation_BottomRight,
    ImNodesMiniMapLocation_TopLeft,
    ImNodesMiniMapLocation_TopRight,
};

struct ImGuiContext;
struct ImVec2;

struct ImNodesContext;

// An editor context corresponds to a set of nodes in a single workspace (created with a single
// Begin/EndNodeEditor pair)
//
// By default, the library creates an editor context behind the scenes, so using any of the imnodes
// functions doesn't require you to explicitly create a context.
struct ImNodesEditorContext;

// Callback type used to specify special behavior when hovering a node in the minimap
#ifndef ImNodesMiniMapNodeHoveringCallback
typedef void (*ImNodesMiniMapNodeHoveringCallback)(int, void*);
#endif

#ifndef ImNodesMiniMapNodeHoveringCallbackUserData
typedef void* ImNodesMiniMapNodeHoveringCallbackUserData;
#endif

namespace IMNODES_NAMESPACE
{
// Call this function if you are compiling imnodes in to a dll, separate from ImGui. Calling this
// function sets the GImGui global variable, which is not shared across dll boundaries.
void SetImGuiContext(ImGuiContext* ctx);

ImNodesContext* CreateContext();
void            DestroyContext(ImNodesContext* ctx = NULL); // NULL = destroy current context
ImNodesContext* GetCurrentContext();
void            SetCurrentContext(ImNodesContext* ctx);

ImNodesEditorContext* EditorContextCreate();
void                  EditorContextFree(ImNodesEditorContext*);
void                  EditorContextSet(ImNodesEditorContext*);
ImVec2                EditorContextGetPanning();
void                  EditorContextResetPanning(const ImVec2& pos);
void                  EditorContextMoveToNode(const int node_id);

ImNodesIO& GetIO();

// Returns the global style struct. See the struct declaration for default values.
ImNodesStyle& GetStyle();
// Style presets matching the dear imgui styles of the same name. If dest is NULL, the active
// context's ImNodesStyle instance will be used as the destination.
void StyleColorsDark(ImNodesStyle* dest = NULL); // on by default
void StyleColorsClassic(ImNodesStyle* dest = NULL);
void StyleColorsLight(ImNodesStyle* dest = NULL);

// The top-level function call. Call this before calling BeginNode/EndNode. Calling this function
// will result the node editor grid workspace being rendered.
void BeginNodeEditor();
void EndNodeEditor();

// Add a navigable minimap to the editor; call before EndNodeEditor after all
// nodes and links have been specified
void MiniMap(
    const float                                      minimap_size_fraction = 0.2f,
    const ImNodesMiniMapLocation                     location = ImNodesMiniMapLocation_TopLeft,
    const ImNodesMiniMapNodeHoveringCallback         node_hovering_callback = NULL,
    const ImNodesMiniMapNodeHoveringCallbackUserData node_hovering_callback_data = NULL);

// Use PushColorStyle and PopColorStyle to modify ImNodesStyle::Colors mid-frame.
void PushColorStyle(ImNodesCol item, unsigned int color);
void PopColorStyle();
void PushStyleVar(ImNodesStyleVar style_item, float value);
void PushStyleVar(ImNodesStyleVar style_item, const ImVec2& value);
void PopStyleVar(int count = 1);

// id can be any positive or negative integer, but INT_MIN is currently reserved for internal use.
void BeginNode(int id);
void EndNode();

ImVec2 GetNodeDimensions(int id);

// Place your node title bar content (such as the node title, using ImGui::Text) between the
// following function calls. These functions have to be called before adding any attributes, or the
// layout of the node will be incorrect.
void BeginNodeTitleBar();
void EndNodeTitleBar();

// Attributes are ImGui UI elements embedded within the node. Attributes can have pin shapes
// rendered next to them. Links are created between pins.
//
// The activity status of an attribute can be checked via the IsAttributeActive() and
// IsAnyAttributeActive() function calls. This is one easy way of checking for any changes made to
// an attribute's drag float UI, for instance.
//
// Each attribute id must be unique.

// Create an input attribute block. The pin is rendered on left side.
void BeginInputAttribute(int id, ImNodesPinShape shape = ImNodesPinShape_CircleFilled);
void EndInputAttribute();
// Create an output attribute block. The pin is rendered on the right side.
void BeginOutputAttribute(int id, ImNodesPinShape shape = ImNodesPinShape_CircleFilled);
void EndOutputAttribute();
// Create a static attribute block. A static attribute has no pin, and therefore can't be linked to
// anything. However, you can still use IsAttributeActive() and IsAnyAttributeActive() to check for
// attribute activity.
void BeginStaticAttribute(int id);
void EndStaticAttribute();

// Push a single AttributeFlags value. By default, only AttributeFlags_None is set.
void PushAttributeFlag(ImNodesAttributeFlags flag);
void PopAttributeFlag();

// Render a link between attributes.
// The attributes ids used here must match the ids used in Begin(Input|Output)Attribute function
// calls. The order of start_attr and end_attr doesn't make a difference for rendering the link.
void Link(int id, int start_attribute_id, int end_attribute_id);

// Enable or disable the ability to click and drag a specific node.
void SetNodeDraggable(int node_id, const bool draggable);

// The node's position can be expressed in three coordinate systems:
// * screen space coordinates, -- the origin is the upper left corner of the window.
// * editor space coordinates -- the origin is the upper left corner of the node editor window
// * grid space coordinates, -- the origin is the upper left corner of the node editor window,
// translated by the current editor panning vector (see EditorContextGetPanning() and
// EditorContextResetPanning())

// Use the following functions to get and set the node's coordinates in these coordinate systems.

void SetNodeScreenSpacePos(int node_id, const ImVec2& screen_space_pos);
void SetNodeEditorSpacePos(int node_id, const ImVec2& editor_space_pos);
void SetNodeGridSpacePos(int node_id, const ImVec2& grid_pos);

ImVec2 GetNodeScreenSpacePos(const int node_id);
ImVec2 GetNodeEditorSpacePos(const int node_id);
ImVec2 GetNodeGridSpacePos(const int node_id);

// If ImNodesStyleFlags_GridSnapping is enabled, snap the specified node's origin to the grid.
void SnapNodeToGrid(int node_id);

// Returns true if the current node editor canvas is being hovered over by the mouse, and is not
// blocked by any other windows.
bool IsEditorHovered();
// The following functions return true if a UI element is being hovered over by the mouse cursor.
// Assigns the id of the UI element being hovered over to the function argument. Use these functions
// after EndNodeEditor() has been called.
bool IsNodeHovered(int* node_id);
bool IsLinkHovered(int* link_id);
bool IsPinHovered(int* attribute_id);

// Use The following two functions to query the number of selected nodes or links in the current
// editor. Use after calling EndNodeEditor().
int NumSelectedNodes();
int NumSelectedLinks();
// Get the selected node/link ids. The pointer argument should point to an integer array with at
// least as many elements as the respective NumSelectedNodes/NumSelectedLinks function call
// returned.
void GetSelectedNodes(int* node_ids);
void GetSelectedLinks(int* link_ids);
// Clears the list of selected nodes/links. Useful if you want to delete a selected node or link.
void ClearNodeSelection();
void ClearLinkSelection();
// Use the following functions to add or remove individual nodes or links from the current editors
// selection. Note that all functions require the id to be an existing valid id for this editor.
// Select-functions has the precondition that the object is currently considered unselected.
// Clear-functions has the precondition that the object is currently considered selected.
// Preconditions listed above can be checked via IsNodeSelected/IsLinkSelected if not already
// known.
void SelectNode(int node_id);
void ClearNodeSelection(int node_id);
bool IsNodeSelected(int node_id);
void SelectLink(int link_id);
void ClearLinkSelection(int link_id);
bool IsLinkSelected(int link_id);

// Was the previous attribute active? This will continuously return true while the left mouse button
// is being pressed over the UI content of the attribute.
bool IsAttributeActive();
// Was any attribute active? If so, sets the active attribute id to the output function argument.
bool IsAnyAttributeActive(int* attribute_id = NULL);

// Use the following functions to query a change of state for an existing link, or new link. Call
// these after EndNodeEditor().

// Did the user start dragging a new link from a pin?
bool IsLinkStarted(int* started_at_attribute_id);
// Did the user drop the dragged link before attaching it to a pin?
// There are two different kinds of situations to consider when handling this event:
// 1) a link which is created at a pin and then dropped
// 2) an existing link which is detached from a pin and then dropped
// Use the including_detached_links flag to control whether this function triggers when the user
// detaches a link and drops it.
bool IsLinkDropped(int* started_at_attribute_id = NULL, bool including_detached_links = true);
// Did the user finish creating a new link?
bool IsLinkCreated(
    int*  started_at_attribute_id,
    int*  ended_at_attribute_id,
    bool* created_from_snap = NULL);
bool IsLinkCreated(
    int*  started_at_node_id,
    int*  started_at_attribute_id,
    int*  ended_at_node_id,
    int*  ended_at_attribute_id,
    bool* created_from_snap = NULL);

// Was an existing link detached from a pin by the user? The detached link's id is assigned to the
// output argument link_id.
bool IsLinkDestroyed(int* link_id);

// Use the following functions to write the editor context's state to a string, or directly to a
// file. The editor context is serialized in the INI file format.

const char* SaveCurrentEditorStateToIniString(size_t* data_size = NULL);
const char* SaveEditorStateToIniString(
    const ImNodesEditorContext* editor,
    size_t*                     data_size = NULL);

void LoadCurrentEditorStateFromIniString(const char* data, size_t data_size);
void LoadEditorStateFromIniString(ImNodesEditorContext* editor, const char* data, size_t data_size);

void SaveCurrentEditorStateToIniFile(const char* file_name);
void SaveEditorStateToIniFile(const ImNodesEditorContext* editor, const char* file_name);

void LoadCurrentEditorStateFromIniFile(const char* file_name);
void LoadEditorStateFromIniFile(ImNodesEditorContext* editor, const char* file_name);
} // namespace IMNODES_NAMESPACE


================================================
FILE: Source/External/imgui_tools/imnodes/imnodes_internal.h
================================================
#pragma once

#define IMGUI_DEFINE_MATH_OPERATORS
#include "imnodes.h"

#include <imgui.h>
#include <imgui_internal.h>

#include <limits.h>

// the structure of this file:
//
// [SECTION] internal enums
// [SECTION] internal data structures
// [SECTION] global and editor context structs
// [SECTION] object pool implementation

struct ImNodesContext;

extern ImNodesContext* GImNodes;

// [SECTION] internal enums

typedef int ImNodesScope;
typedef int ImNodesAttributeType;
typedef int ImNodesUIState;
typedef int ImNodesClickInteractionType;
typedef int ImNodesLinkCreationType;

enum ImNodesScope_
{
    ImNodesScope_None = 1,
    ImNodesScope_Editor = 1 << 1,
    ImNodesScope_Node = 1 << 2,
    ImNodesScope_Attribute = 1 << 3
};

enum ImNodesAttributeType_
{
    ImNodesAttributeType_None,
    ImNodesAttributeType_Input,
    ImNodesAttributeType_Output
};

enum ImNodesUIState_
{
    ImNodesUIState_None = 0,
    ImNodesUIState_LinkStarted = 1 << 0,
    ImNodesUIState_LinkDropped = 1 << 1,
    ImNodesUIState_LinkCreated = 1 << 2
};

enum ImNodesClickInteractionType_
{
    ImNodesClickInteractionType_Node,
    ImNodesClickInteractionType_Link,
    ImNodesClickInteractionType_LinkCreation,
    ImNodesClickInteractionType_Panning,
    ImNodesClickInteractionType_BoxSelection,
    ImNodesClickInteractionType_ImGuiItem,
    ImNodesClickInteractionType_None
};

enum ImNodesLinkCreationType_
{
    ImNodesLinkCreationType_Standard,
    ImNodesLinkCreationType_FromDetach
};

// [SECTION] internal data structures

// The object T must have the following interface:
//
// struct T
// {
//     T();
//
//     int id;
// };
template<typename T>
struct ImObjectPool
{
    ImVector<T>    Pool;
    ImVector<bool> InUse;
    ImVector<int>  FreeList;
    ImGuiStorage   IdMap;

    ImObjectPool() : Pool(), InUse(), FreeList(), IdMap() {}
};

// Emulates std::optional<int> using the sentinel value `INVALID_INDEX`.
struct ImOptionalIndex
{
    ImOptionalIndex() : _Index(INVALID_INDEX) {}
    ImOptionalIndex(const int value) : _Index(value) {}

    // Observers

    inline bool HasValue() const { return _Index != INVALID_INDEX; }

    inline int Value() const
    {
        IM_ASSERT(HasValue());
        return _Index;
    }

    // Modifiers

    inline ImOptionalIndex& operator=(const int value)
    {
        _Index = value;
        return *this;
    }

    inline void Reset() { _Index = INVALID_INDEX; }

    inline bool operator==(const ImOptionalIndex& rhs) const { return _Index == rhs._Index; }

    inline bool operator==(const int rhs) const { return _Index == rhs; }

    inline bool operator!=(const ImOptionalIndex& rhs) const { return _Index != rhs._Index; }

    inline bool operator!=(const int rhs) const { return _Index != rhs; }

    static const int INVALID_INDEX = -1;

private:
    int _Index;
};

struct ImNodeData
{
    int    Id;
    ImVec2 Origin; // The node origin is in editor space
    ImRect TitleBarContentRect;
    ImRect Rect;

    struct
    {
        ImU32 Background, BackgroundHovered, BackgroundSelected, Outline, Titlebar, TitlebarHovered,
            TitlebarSelected;
    } ColorStyle;

    struct
    {
        float  CornerRounding;
        ImVec2 Padding;
        float  BorderThickness;
    } LayoutStyle;

    ImVector<int> PinIndices;
    bool          Draggable;

    ImNodeData(const int node_id)
        : Id(node_id), Origin(0.0f, 0.0f), TitleBarContentRect(),
          Rect(ImVec2(0.0f, 0.0f), ImVec2(0.0f, 0.0f)), ColorStyle(), LayoutStyle(), PinIndices(),
          Draggable(true)
    {
    }

    ~ImNodeData() { Id = INT_MIN; }
};

struct ImPinData
{
    int                  Id;
    int                  ParentNodeIdx;
    ImRect               AttributeRect;
    ImNodesAttributeType Type;
    ImNodesPinShape      Shape;
    ImVec2               Pos; // screen-space coordinates
    int                  Flags;

    struct
    {
        ImU32 Background, Hovered;
    } ColorStyle;

    ImPinData(const int pin_id)
        : Id(pin_id), ParentNodeIdx(), AttributeRect(), Type(ImNodesAttributeType_None),
          Shape(ImNodesPinShape_CircleFilled), Pos(), Flags(ImNodesAttributeFlags_None),
          ColorStyle()
    {
    }
};

struct ImLinkData
{
    int Id;
    int StartPinIdx, EndPinIdx;

    struct
    {
        ImU32 Base, Hovered, Selected;
    } ColorStyle;

    ImLinkData(const int link_id) : Id(link_id), StartPinIdx(), EndPinIdx(), ColorStyle() {}
};

struct ImClickInteractionState
{
    ImNodesClickInteractionType Type;

    struct
    {
        int                     StartPinIdx;
        ImOptionalIndex         EndPinIdx;
        ImNodesLinkCreationType Type;
    } LinkCreation;

    struct
    {
        ImRect Rect; // Coordinates in grid space
    } BoxSelector;

    ImClickInteractionState() : Type(ImNodesClickInteractionType_None) {}
};

struct ImNodesColElement
{
    ImU32      Color;
    ImNodesCol Item;

    ImNodesColElement(const ImU32 c, const ImNodesCol s) : Color(c), Item(s) {}
};

struct ImNodesStyleVarElement
{
    ImNodesStyleVar Item;
    float           FloatValue[2];

    ImNodesStyleVarElement(const ImNodesStyleVar variable, const float value) : Item(variable)
    {
        FloatValue[0] = value;
    }

    ImNodesStyleVarElement(const ImNodesStyleVar variable, const ImVec2 value) : Item(variable)
    {
        FloatValue[0] = value.x;
        FloatValue[1] = value.y;
    }
};

// [SECTION] global and editor context structs

struct ImNodesEditorContext
{
    ImObjectPool<ImNodeData> Nodes;
    ImObjectPool<ImPinData>  Pins;
    ImObjectPool<ImLinkData> Links;

    ImVector<int> NodeDepthOrder;

    // ui related fields
    ImVec2 Panning;
    ImVec2 AutoPanningDelta;
    // Minimum and maximum extents of all content in grid space. Valid after final
    // ImNodes::EndNode() call.
    ImRect GridContentBounds;

    ImVector<int> SelectedNodeIndices;
    ImVector<int> SelectedLinkIndices;

    // Relative origins of selected nodes for snapping of dragged nodes
    ImVector<ImVec2> SelectedNodeOffsets;
    // Offset of the primary node origin relative to the mouse cursor.
    ImVec2           PrimaryNodeOffset;

    ImClickInteractionState ClickInteraction;

    // Mini-map state set by MiniMap()

    bool                                       MiniMapEnabled;
    ImNodesMiniMapLocation                     MiniMapLocation;
    float                                      MiniMapSizeFraction;
    ImNodesMiniMapNodeHoveringCallback         MiniMapNodeHoveringCallback;
    ImNodesMiniMapNodeHoveringCallbackUserData MiniMapNodeHoveringCallbackUserData;

    // Mini-map state set during EndNodeEditor() call

    ImRect MiniMapRectScreenSpace;
    ImRect MiniMapContentScreenSpace;
    float  MiniMapScaling;

    ImNodesEditorContext()
        : Nodes(), Pins(), Links(), Panning(0.f, 0.f), SelectedNodeIndices(), SelectedLinkIndices(),
          SelectedNodeOffsets(), PrimaryNodeOffset(0.f, 0.f), ClickInteraction(),
          MiniMapEnabled(false), MiniMapSizeFraction(0.0f),
          MiniMapNodeHoveringCallback(NULL), MiniMapNodeHoveringCallbackUserData(NULL),
          MiniMapScaling(0.0f)
    {
    }
};

struct ImNodesContext
{
    ImNodesEditorContext* DefaultEditorCtx;
    ImNodesEditorContext* EditorCtx;

    // Canvas draw list and helper state
    ImDrawList*   CanvasDrawList;
    ImGuiStorage  NodeIdxToSubmissionIdx;
    ImVector<int> NodeIdxSubmissionOrder;
    ImVector<int> NodeIndicesOverlappingWithMouse;
    ImVector<int> OccludedPinIndices;

    // Canvas extents
    ImVec2 CanvasOriginScreenSpace;
    ImRect CanvasRectScreenSpace;

    // Debug helpers
    ImNodesScope CurrentScope;

    // Configuration state
    ImNodesIO                        Io;
    ImNodesStyle                     Style;
    ImVector<ImNodesColElement>      ColorModifierStack;
    ImVector<ImNodesStyleVarElement> StyleModifierStack;
    ImGuiTextBuffer                  TextBuffer;

    int           CurrentAttributeFlags;
    ImVector<int> AttributeFlagStack;

    // UI element state
    int CurrentNodeIdx;
    int CurrentPinIdx;
    int CurrentAttributeId;

    ImOptionalIndex HoveredNodeIdx;
    ImOptionalIndex HoveredLinkIdx;
    ImOptionalIndex HoveredPinIdx;

    ImOptionalIndex DeletedLinkIdx;
    ImOptionalIndex SnapLinkIdx;

    // Event helper state
    // TODO: this should be a part of a state machine, and not a member of the global struct.
    // Unclear what parts of the code this relates to.
    int ImNodesUIState;

    int  ActiveAttributeId;
    bool ActiveAttribute;

    // ImGui::IO cache

    ImVec2 MousePos;

    bool  LeftMouseClicked;
    bool  LeftMouseReleased;
    bool  AltMouseClicked;
    bool  LeftMouseDragging;
    bool  AltMouseDragging;
    float AltMouseScrollDelta;
    bool  MultipleSelectModifier;
};

namespace IMNODES_NAMESPACE
{
static inline ImNodesEditorContext& EditorContextGet()
{
    // No editor context was set! Did you forget to call ImNodes::CreateContext()?
    IM_ASSERT(GImNodes->EditorCtx != NULL);
    return *GImNodes->EditorCtx;
}

// [SECTION] ObjectPool implementation

template<typename T>
static inline int ObjectPoolFind(const ImObjectPool<T>& objects, const int id)
{
    const int index = objects.IdMap.GetInt(static_cast<ImGuiID>(id), -1);
    return index;
}

template<typename T>
static inline void ObjectPoolUpdate(ImObjectPool<T>& objects)
{
    for (int i = 0; i < objects.InUse.size(); ++i)
    {
        const int id = objects.Pool[i].Id;

        if (!objects.InUse[i] && objects.IdMap.GetInt(id, -1) == i)
        {
            objects.IdMap.SetInt(id, -1);
            objects.FreeList.push_back(i);
            (objects.Pool.Data + i)->~T();
        }
    }
}

template<>
inline void ObjectPoolUpdate(ImObjectPool<ImNodeData>& nodes)
{
    for (int i = 0; i < nodes.InUse.size(); ++i)
    {
        if (nodes.InUse[i])
        {
            nodes.Pool[i].PinIndices.clear();
        }
        else
        {
            const int id = nodes.Pool[i].Id;

            if (nodes.IdMap.GetInt(id, -1) == i)
            {
                // Remove node idx form depth stack the first time we detect that this idx slot is
                // unused
                ImVector<int>&   depth_stack = EditorContextGet().NodeDepthOrder;
                const int* const elem = depth_stack.find(i);
                IM_ASSERT(elem != depth_stack.end());
                depth_stack.erase(elem);

                nodes.IdMap.SetInt(id, -1);
                nodes.FreeList.push_back(i);
                (nodes.Pool.Data + i)->~ImNodeData();
            }
        }
    }
}

template<typename T>
static inline void ObjectPoolReset(ImObjectPool<T>& objects)
{
    if (!objects.InUse.empty())
    {
        memset(objects.InUse.Data, 0, objects.InUse.size_in_bytes());
    }
}

template<typename T>
static inline int ObjectPoolFindOrCreateIndex(ImObjectPool<T>& objects, const int id)
{
    int index = objects.IdMap.GetInt(static_cast<ImGuiID>(id), -1);

    // Construct new object
    if (index == -1)
    {
        if (objects.FreeList.empty())
        {
            index = objects.Pool.size();
            IM_ASSERT(objects.Pool.size() == objects.InUse.size());
            const int new_size = objects.Pool.size() + 1;
            objects.Pool.resize(new_size);
            objects.InUse.resize(new_size);
        }
        else
        {
            index = objects.FreeList.back();
            objects.FreeList.pop_back();
        }
        IM_PLACEMENT_NEW(objects.Pool.Data + index) T(id);
        objects.IdMap.SetInt(static_cast<ImGuiID>(id), index);
    }

    // Flag it as used
    objects.InUse[index] = true;

    return index;
}

template<>
inline int ObjectPoolFindOrCreateIndex(ImObjectPool<ImNodeData>& nodes, const int node_id)
{
    int node_idx = nodes.IdMap.GetInt(static_cast<ImGuiID>(node_id), -1);

    // Construct new node
    if (node_idx == -1)
    {
        if (nodes.FreeList.empty())
        {
            node_idx = nodes.Pool.size();
            IM_ASSERT(nodes.Pool.size() == nodes.InUse.size());
            const int new_size = nodes.Pool.size() + 1;
            nodes.Pool.resize(new_size);
            nodes.InUse.resize(new_size);
        }
        else
        {
            node_idx = nodes.FreeList.back();
            nodes.FreeList.pop_back();
        }
        IM_PLACEMENT_NEW(nodes.Pool.Data + node_idx) ImNodeData(node_id);
        nodes.IdMap.SetInt(static_cast<ImGuiID>(node_id), node_idx);

        ImNodesEditorContext& editor = EditorContextGet();
        editor.NodeDepthOrder.push_back(node_idx);
    }

    // Flag node as used
    nodes.InUse[node_idx] = true;

    return node_idx;
}

template<typename T>
static inline T& ObjectPoolFindOrCreateObject(ImObjectPool<T>& objects, const int id)
{
    const int index = ObjectPoolFindOrCreateIndex(objects, id);
    return objects.Pool[index];
}
} // namespace IMNODES_NAMESPACE


================================================
FILE: Source/External/imgui_tools/implot/implot.cpp
================================================
// MIT License

// Copyright (c) 2022 Evan Pezent

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// ImPlot v0.14

/*

API BREAKING CHANGES
====================
Occasionally introducing changes that are breaking the API. We try to make the breakage minor and easy to fix.
Below is a change-log of API breaking changes only. If you are using one of the functions listed, expect to have to fix some code.
When you are not sure about a old symbol or function name, try using the Search/Find function of your IDE to look for comments or references in all implot files.
You can read releases logs https://github.com/epezent/implot/releases for more details.

- 2022/06/19 (0.14) - The signature of ColormapScale has changed to accommodate a new ImPlotColormapScaleFlags parameter
- 2022/06/17 (0.14) - **IMPORTANT** All PlotX functions now take an ImPlotX_Flags `flags` parameter. Where applicable, it is located before the existing `offset` and `stride` parameters.
                      If you were providing offset and stride values, you will need to update your function call to include a `flags` value. If you fail to do this, you will likely see
                      unexpected results or crashes without a compiler warning since these three are all default args. We apologize for the inconvenience, but this was a necessary evil.
                    - PlotBarsH has been removed; use PlotBars + ImPlotBarsFlags_Horizontal instead
                    - PlotErrorBarsH has been removed; use PlotErrorBars + ImPlotErrorBarsFlags_Horizontal
                    - PlotHistogram/PlotHistogram2D signatures changed; `cumulative`, `density`, and `outliers` options now specified via ImPlotHistogramFlags
                    - PlotPieChart signature changed; `normalize` option now specified via ImPlotPieChartFlags
                    - PlotText signature changes; `vertical` option now specified via `ImPlotTextFlags_Vertical`
                    - `PlotVLines` and `PlotHLines` replaced with `PlotInfLines` (+ ImPlotInfLinesFlags_Horizontal )
                    - arguments of ImPlotGetter have been reversed to be consistent with other API callbacks
                    - SetupAxisScale + ImPlotScale have replaced ImPlotAxisFlags_LogScale and ImPlotAxisFlags_Time flags
                    - ImPlotFormatters should now return an int indicating the size written
                    - the signature of ImPlotGetter has been reversed so that void* user_data is the last argument and consistent with other callbacks
- 2021/10/19 (0.13) - MAJOR API OVERHAUL! See #168 and #272
                    - TRIVIAL RENAME:
                      - ImPlotLimits                              -> ImPlotRect
                      - ImPlotYAxis_                              -> ImAxis_
                      - SetPlotYAxis                              -> SetAxis
                      - BeginDragDropTarget                       -> BeginDragDropTargetPlot
                      - BeginDragDropSource                       -> BeginDragDropSourcePlot
                      - ImPlotFlags_NoMousePos                    -> ImPlotFlags_NoMouseText
                      - SetNextPlotLimits                         -> SetNextAxesLimits
                      - SetMouseTextLocation                      -> SetupMouseText
                    - SIGNATURE MODIFIED:
                      - PixelsToPlot/PlotToPixels                 -> added optional X-Axis arg
                      - GetPlotMousePos                           -> added optional X-Axis arg
                      - GetPlotLimits                             -> added optional X-Axis arg
                      - GetPlotSelection                          -> added optional X-Axis arg
                      - DragLineX/Y/DragPoint                     -> now takes int id; removed labels (render with Annotation/Tag instead)
                    - REPLACED:
                      - IsPlotXAxisHovered/IsPlotXYAxisHovered    -> IsAxisHovered(ImAxis)
                      - BeginDragDropTargetX/BeginDragDropTargetY -> BeginDragDropTargetAxis(ImAxis)
                      - BeginDragDropSourceX/BeginDragDropSourceY -> BeginDragDropSourceAxis(ImAxis)
                      - ImPlotCol_XAxis, ImPlotCol_YAxis1, etc.   -> ImPlotCol_AxisText (push/pop this around SetupAxis to style individual axes)
                      - ImPlotCol_XAxisGrid, ImPlotCol_Y1AxisGrid -> ImPlotCol_AxisGrid (push/pop this around SetupAxis to style individual axes)
                      - SetNextPlotLimitsX/Y                      -> SetNextAxisLimits(ImAxis)
                      - LinkNextPlotLimits                        -> SetNextAxisLinks(ImAxis)
                      - FitNextPlotAxes                           -> SetNextAxisToFit(ImAxis)/SetNextAxesToFit
                      - SetLegendLocation                         -> SetupLegend
                      - ImPlotFlags_NoHighlight                   -> ImPlotLegendFlags_NoHighlight
                      - ImPlotOrientation                         -> ImPlotLegendFlags_Horizontal
                      - Annotate                                  -> Annotation
                    - REMOVED:
                      - GetPlotQuery, SetPlotQuery, IsPlotQueried -> use DragRect
                      - SetNextPlotTicksX, SetNextPlotTicksY      -> use SetupAxisTicks
                      - SetNextPlotFormatX, SetNextPlotFormatY    -> use SetupAxisFormat
                      - AnnotateClamped                           -> use Annotation(bool clamp = true)
                    - OBSOLETED:
                      - BeginPlot (original signature)            -> use simplified signature + Setup API
- 2021/07/30 (0.12) - The offset argument of `PlotXG` functions was been removed. Implement offsetting in your getter callback instead.
- 2021/03/08 (0.9)  - SetColormap and PushColormap(ImVec4*) were removed. Use AddColormap for custom colormap support. LerpColormap was changed to SampleColormap.
                      ShowColormapScale was changed to ColormapScale and requires additional arguments.
- 2021/03/07 (0.9)  - The signature of ShowColormapScale was modified to accept a ImVec2 size.
- 2021/02/28 (0.9)  - BeginLegendDragDropSource was changed to BeginDragDropSourceItem with a number of other drag and drop improvements.
- 2021/01/18 (0.9)  - The default behavior for opening context menus was change from double right-click to single right-click. ImPlotInputMap and related functions were moved
                      to implot_internal.h due to its immaturity.
- 2020/10/16 (0.8)  - ImPlotStyleVar_InfoPadding was changed to ImPlotStyleVar_MousePosPadding
- 2020/09/10 (0.8)  - The single array versions of PlotLine, PlotScatter, PlotStems, and PlotShaded were given additional arguments for x-scale and x0.
- 2020/09/07 (0.8)  - Plotting functions which accept a custom getter function pointer have been post-fixed with a G (e.g. PlotLineG)
- 2020/09/06 (0.7)  - Several flags under ImPlotFlags and ImPlotAxisFlags were inverted (e.g. ImPlotFlags_Legend -> ImPlotFlags_NoLegend) so that the default flagset
                      is simply 0. This more closely matches ImGui's style and makes it easier to enable non-default but commonly used flags (e.g. ImPlotAxisFlags_Time).
- 2020/08/28 (0.5)  - ImPlotMarker_ can no longer be combined with bitwise OR, |. This features caused unecessary slow-down, and almost no one used it.
- 2020/08/25 (0.5)  - ImPlotAxisFlags_Scientific was removed. Logarithmic axes automatically uses scientific notation.
- 2020/08/17 (0.5)  - PlotText was changed so that text is centered horizontally and vertically about the desired point.
- 2020/08/16 (0.5)  - An ImPlotContext must be explicitly created and destroyed now with `CreateContext` and `DestroyContext`. Previously, the context was statically initialized in this source file.
- 2020/06/13 (0.4)  - The flags `ImPlotAxisFlag_Adaptive` and `ImPlotFlags_Cull` were removed. Both are now done internally by default.
- 2020/06/03 (0.3)  - The signature and behavior of PlotPieChart was changed so that data with sum less than 1 can optionally be normalized. The label format can now be specified as well.
- 2020/06/01 (0.3)  - SetPalette was changed to `SetColormap` for consistency with other plotting libraries. `RestorePalette` was removed. Use `SetColormap(ImPlotColormap_Default)`.
- 2020/05/31 (0.3)  - Plot functions taking custom ImVec2* getters were removed. Use the ImPlotPoint* getter versions instead.
- 2020/05/29 (0.3)  - The signature of ImPlotLimits::Contains was changed to take two doubles instead of ImVec2
- 2020/05/16 (0.2)  - All plotting functions were reverted to being prefixed with "Plot" to maintain a consistent VerbNoun style. `Plot` was split into `PlotLine`
                      and `PlotScatter` (however, `PlotLine` can still be used to plot scatter points as `Plot` did before.). `Bar` is not `PlotBars`, to indicate
                      that multiple bars will be plotted.
- 2020/05/13 (0.2)  - `ImMarker` was change to `ImPlotMarker` and `ImAxisFlags` was changed to `ImPlotAxisFlags`.
- 2020/05/11 (0.2)  - `ImPlotFlags_Selection` was changed to `ImPlotFlags_BoxSelect`
- 2020/05/11 (0.2)  - The namespace ImGui:: was replaced with ImPlot::. As a result, the following additional changes were made:
                      - Functions that were prefixed or decorated with the word "Plot" have been truncated. E.g., `ImGui::PlotBars` is now just `ImPlot::Bar`.
                        It should be fairly obvious what was what.
                      - Some functions have been given names that would have otherwise collided with the ImGui namespace. This has been done to maintain a consistent
                        style with ImGui. E.g., 'ImGui::PushPlotStyleVar` is now 'ImPlot::PushStyleVar'.
- 2020/05/10 (0.2)  - The following function/struct names were changes:
                     - ImPlotRange       -> ImPlotLimits
                     - GetPlotRange()    -> GetPlotLimits()
                     - SetNextPlotRange  -> SetNextPlotLimits
                     - SetNextPlotRangeX -> SetNextPlotLimitsX
                     - SetNextPlotRangeY -> SetNextPlotLimitsY
- 2020/05/10 (0.2)  - Plot queries are pixel based by default. Query rects that maintain relative plot position have been removed. This was done to support multi-y-axis.

*/

#define IMGUI_DEFINE_MATH_OPERATORS
#include "implot.h"
#include "implot_internal.h"

#include <stdlib.h>

// Support for pre-1.82 versions. Users on 1.82+ can use 0 (default) flags to mean "all corners" but in order to support older versions we are more explicit.
#if (IMGUI_VERSION_NUM < 18102) && !defined(ImDrawFlags_RoundCornersAll)
#define ImDrawFlags_RoundCornersAll ImDrawCornerFlags_All
#endif

// Support for pre-1.89.7 versions.
#if (IMGUI_VERSION_NUM < 18966)
#define ImGuiButtonFlags_AllowOverlap ImGuiButtonFlags_AllowItemOverlap
#endif

// Visual Studio warnings
#ifdef _MSC_VER
#pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen
#endif

// Clang/GCC warnings with -Weverything
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wformat-nonliteral"  // warning: format string is not a string literal
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wformat-nonliteral"    // warning: format not a string literal, format string not checked
#endif

// Global plot context
#ifndef GImPlot
ImPlotContext* GImPlot = nullptr;
#endif

//-----------------------------------------------------------------------------
// Struct Implementations
//-----------------------------------------------------------------------------

ImPlotInputMap::ImPlotInputMap() {
    ImPlot::MapInputDefault(this);
}

ImPlotStyle::ImPlotStyle() {

    LineWeight         = 1;
    Marker             = ImPlotMarker_None;
    MarkerSize         = 4;
    MarkerWeight       = 1;
    FillAlpha          = 1;
    ErrorBarSize       = 5;
    ErrorBarWeight     = 1.5f;
    DigitalBitHeight   = 8;
    DigitalBitGap      = 4;

    PlotBorderSize     = 1;
    MinorAlpha         = 0.25f;
    MajorTickLen       = ImVec2(10,10);
    MinorTickLen       = ImVec2(5,5);
    MajorTickSize      = ImVec2(1,1);
    MinorTickSize      = ImVec2(1,1);
    MajorGridSize      = ImVec2(1,1);
    MinorGridSize      = ImVec2(1,1);
    PlotPadding        = ImVec2(10,10);
    LabelPadding       = ImVec2(5,5);
    LegendPadding      = ImVec2(10,10);
    LegendInnerPadding = ImVec2(5,5);
    LegendSpacing      = ImVec2(5,0);
    MousePosPadding    = ImVec2(10,10);
    AnnotationPadding  = ImVec2(2,2);
    FitPadding         = ImVec2(0,0);
    PlotDefaultSize    = ImVec2(400,300);
    PlotMinSize        = ImVec2(200,150);

    ImPlot::StyleColorsAuto(this);

    Colormap = ImPlotColormap_Deep;

    UseLocalTime     = false;
    Use24HourClock   = false;
    UseISO8601       = false;
}

//-----------------------------------------------------------------------------
// Style
//-----------------------------------------------------------------------------

namespace ImPlot {

const char* GetStyleColorName(ImPlotCol col) {
    static const char* col_names[ImPlotCol_COUNT] = {
        "Line",
        "Fill",
        "MarkerOutline",
        "MarkerFill",
        "ErrorBar",
        "FrameBg",
        "PlotBg",
        "PlotBorder",
        "LegendBg",
        "LegendBorder",
        "LegendText",
        "TitleText",
        "InlayText",
        "AxisText",
        "AxisGrid",
        "AxisTick",
        "AxisBg",
        "AxisBgHovered",
        "AxisBgActive",
        "Selection",
        "Crosshairs"
    };
    return col_names[col];
}

const char* GetMarkerName(ImPlotMarker marker) {
    switch (marker) {
        case ImPlotMarker_None:     return "None";
        case ImPlotMarker_Circle:   return "Circle";
        case ImPlotMarker_Square:   return "Square";
        case ImPlotMarker_Diamond:  return "Diamond";
        case ImPlotMarker_Up:       return "Up";
        case ImPlotMarker_Down:     return "Down";
        case ImPlotMarker_Left:     return "Left";
        case ImPlotMarker_Right:    return "Right";
        case ImPlotMarker_Cross:    return "Cross";
        case ImPlotMarker_Plus:     return "Plus";
        case ImPlotMarker_Asterisk: return "Asterisk";
        default:                    return "";
    }
}

ImVec4 GetAutoColor(ImPlotCol idx) {
    ImVec4 col(0,0,0,1);
    switch(idx) {
        case ImPlotCol_Line:          return col; // these are plot dependent!
        case ImPlotCol_Fill:          return col; // these are plot dependent!
        case ImPlotCol_MarkerOutline: return col; // these are plot dependent!
        case ImPlotCol_MarkerFill:    return col; // these are plot dependent!
        case ImPlotCol_ErrorBar:      return ImGui::GetStyleColorVec4(ImGuiCol_Text);
        case ImPlotCol_FrameBg:       return ImGui::GetStyleColorVec4(ImGuiCol_FrameBg);
        case ImPlotCol_PlotBg:        return ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
        case ImPlotCol_PlotBorder:    return ImGui::GetStyleColorVec4(ImGuiCol_Border);
        case ImPlotCol_LegendBg:      return ImGui::GetStyleColorVec4(ImGuiCol_PopupBg);
        case ImPlotCol_LegendBorder:  return GetStyleColorVec4(ImPlotCol_PlotBorder);
        case ImPlotCol_LegendText:    return GetStyleColorVec4(ImPlotCol_InlayText);
        case ImPlotCol_TitleText:     return ImGui::GetStyleColorVec4(ImGuiCol_Text);
        case ImPlotCol_InlayText:     return ImGui::GetStyleColorVec4(ImGuiCol_Text);
        case ImPlotCol_AxisText:      return ImGui::GetStyleColorVec4(ImGuiCol_Text);
        case ImPlotCol_AxisGrid:      return GetStyleColorVec4(ImPlotCol_AxisText) * ImVec4(1,1,1,0.25f);
        case ImPlotCol_AxisTick:      return GetStyleColorVec4(ImPlotCol_AxisGrid);
        case ImPlotCol_AxisBg:        return ImVec4(0,0,0,0);
        case ImPlotCol_AxisBgHovered: return ImGui::GetStyleColorVec4(ImGuiCol_ButtonHovered);
        case ImPlotCol_AxisBgActive:  return ImGui::GetStyleColorVec4(ImGuiCol_ButtonActive);
        case ImPlotCol_Selection:     return ImVec4(1,1,0,1);
        case ImPlotCol_Crosshairs:    return GetStyleColorVec4(ImPlotCol_PlotBorder);
        default: return col;
    }
}

struct ImPlotStyleVarInfo {
    ImGuiDataType   Type;
    ImU32           Count;
    ImU32           Offset;
    void*           GetVarPtr(ImPlotStyle* style) const { return (void*)((unsigned char*)style + Offset); }
};

static const ImPlotStyleVarInfo GPlotStyleVarInfo[] =
{
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, LineWeight)         }, // ImPlotStyleVar_LineWeight
    { ImGuiDataType_S32,   1, (ImU32)IM_OFFSETOF(ImPlotStyle, Marker)             }, // ImPlotStyleVar_Marker
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, MarkerSize)         }, // ImPlotStyleVar_MarkerSize
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, MarkerWeight)       }, // ImPlotStyleVar_MarkerWeight
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, FillAlpha)          }, // ImPlotStyleVar_FillAlpha
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, ErrorBarSize)       }, // ImPlotStyleVar_ErrorBarSize
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, ErrorBarWeight)     }, // ImPlotStyleVar_ErrorBarWeight
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, DigitalBitHeight)   }, // ImPlotStyleVar_DigitalBitHeight
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, DigitalBitGap)      }, // ImPlotStyleVar_DigitalBitGap

    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, PlotBorderSize)     }, // ImPlotStyleVar_PlotBorderSize
    { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, MinorAlpha)         }, // ImPlotStyleVar_MinorAlpha
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MajorTickLen)       }, // ImPlotStyleVar_MajorTickLen
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MinorTickLen)       }, // ImPlotStyleVar_MinorTickLen
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MajorTickSize)      }, // ImPlotStyleVar_MajorTickSize
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MinorTickSize)      }, // ImPlotStyleVar_MinorTickSize
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MajorGridSize)      }, // ImPlotStyleVar_MajorGridSize
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MinorGridSize)      }, // ImPlotStyleVar_MinorGridSize
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, PlotPadding)        }, // ImPlotStyleVar_PlotPadding
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, LabelPadding)       }, // ImPlotStyleVar_LabelPaddine
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, LegendPadding)      }, // ImPlotStyleVar_LegendPadding
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, LegendInnerPadding) }, // ImPlotStyleVar_LegendInnerPadding
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, LegendSpacing)      }, // ImPlotStyleVar_LegendSpacing

    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MousePosPadding)    }, // ImPlotStyleVar_MousePosPadding
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, AnnotationPadding)  }, // ImPlotStyleVar_AnnotationPadding
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, FitPadding)         }, // ImPlotStyleVar_FitPadding
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, PlotDefaultSize)    }, // ImPlotStyleVar_PlotDefaultSize
    { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, PlotMinSize)        }  // ImPlotStyleVar_PlotMinSize
};

static const ImPlotStyleVarInfo* GetPlotStyleVarInfo(ImPlotStyleVar idx) {
    IM_ASSERT(idx >= 0 && idx < ImPlotStyleVar_COUNT);
    IM_ASSERT(IM_ARRAYSIZE(GPlotStyleVarInfo) == ImPlotStyleVar_COUNT);
    return &GPlotStyleVarInfo[idx];
}

//-----------------------------------------------------------------------------
// Generic Helpers
//-----------------------------------------------------------------------------

void AddTextVertical(ImDrawList *DrawList, ImVec2 pos, ImU32 col, const char *text_begin, const char* text_end) {
    // the code below is based loosely on ImFont::RenderText
    if (!text_end)
        text_end = text_begin + strlen(text_begin);
    ImGuiContext& g = *GImGui;
    ImFont* font = g.Font;
    // Align to be pixel perfect
    pos.x = IM_FLOOR(pos.x);
    pos.y = IM_FLOOR(pos.y);
    const float scale = g.FontSize / font->FontSize;
    const char* s = text_begin;
    int chars_exp = (int)(text_end - s);
    int chars_rnd = 0;
    const int vtx_count_max = chars_exp * 4;
    const int idx_count_max = chars_exp * 6;
    DrawList->PrimReserve(idx_count_max, vtx_count_max);
    while (s < text_end) {
        unsigned int c = (unsigned int)*s;
        if (c < 0x80) {
            s += 1;
        }
        else {
            s += ImTextCharFromUtf8(&c, s, text_end);
            if (c == 0) // Malformed UTF-8?
                break;
        }
        const ImFontGlyph * glyph = font->FindGlyph((ImWchar)c);
        if (glyph == nullptr) {
            continue;
        }
        DrawList->PrimQuadUV(pos + ImVec2(glyph->Y0, -glyph->X0) * scale, pos + ImVec2(glyph->Y0, -glyph->X1) * scale,
                             pos + ImVec2(glyph->Y1, -glyph->X1) * scale, pos + ImVec2(glyph->Y1, -glyph->X0) * scale,
                             ImVec2(glyph->U0, glyph->V0), ImVec2(glyph->U1, glyph->V0),
                             ImVec2(glyph->U1, glyph->V1), ImVec2(glyph->U0, glyph->V1),
                             col);
        pos.y -= glyph->AdvanceX * scale;
        chars_rnd++;
    }
    // Give back unused vertices
    int chars_skp = chars_exp-chars_rnd;
    DrawList->PrimUnreserve(chars_skp*6, chars_skp*4);
}

void AddTextCentered(ImDrawList* DrawList, ImVec2 top_center, ImU32 col, const char* text_begin, const char* text_end) {
    float txt_ht = ImGui::GetTextLineHeight();
    const char* title_end = ImGui::FindRenderedTextEnd(text_begin, text_end);
    ImVec2 text_size;
    float  y = 0;
    while (const char* tmp = (const char*)memchr(text_begin, '\n', title_end-text_begin)) {
        text_size = ImGui::CalcTextSize(text_begin,tmp,true);
        DrawList->AddText(ImVec2(top_center.x - text_size.x * 0.5f, top_center.y+y),col,text_begin,tmp);
        text_begin = tmp + 1;
        y += txt_ht;
    }
    text_size = ImGui::CalcTextSize(text_begin,title_end,true);
    DrawList->AddText(ImVec2(top_center.x - text_size.x * 0.5f, top_center.y+y),col,text_begin,title_end);
}

double NiceNum(double x, bool round) {
    double f;
    double nf;
    int expv = (int)floor(ImLog10(x));
    f = x / ImPow(10.0, (double)expv);
    if (round)
        if (f < 1.5)
            nf = 1;
        else if (f < 3)
            nf = 2;
        else if (f < 7)
            nf = 5;
        else
            nf = 10;
    else if (f <= 1)
        nf = 1;
    else if (f <= 2)
        nf = 2;
    else if (f <= 5)
        nf = 5;
    else
        nf = 10;
    return nf * ImPow(10.0, expv);
}

//-----------------------------------------------------------------------------
// Context Utils
//-----------------------------------------------------------------------------

void SetImGuiContext(ImGuiContext* ctx) {
    ImGui::SetCurrentContext(ctx);
}

ImPlotContext* CreateContext() {
    ImPlotContext* ctx = IM_NEW(ImPlotContext)();
    Initialize(ctx);
    if (GImPlot == nullptr)
        SetCurrentContext(ctx);
    return ctx;
}

void DestroyContext(ImPlotContext* ctx) {
    if (ctx == nullptr)
        ctx = GImPlot;
    if (GImPlot == ctx)
        SetCurrentContext(nullptr);
    IM_DELETE(ctx);
}

ImPlotContext* GetCurrentContext() {
    return GImPlot;
}

void SetCurrentContext(ImPlotContext* ctx) {
    GImPlot = ctx;
}

#define IMPLOT_APPEND_CMAP(name, qual) ctx->ColormapData.Append(#name, name, sizeof(name)/sizeof(ImU32), qual)
#define IM_RGB(r,g,b) IM_COL32(r,g,b,255)

void Initialize(ImPlotContext* ctx) {
    ResetCtxForNextPlot(ctx);
    ResetCtxForNextAlignedPlots(ctx);
    ResetCtxForNextSubplot(ctx);

    const ImU32 Deep[]     = {4289753676, 4283598045, 4285048917, 4283584196, 4289950337, 4284512403, 4291005402, 4287401100, 4285839820, 4291671396                        };
    const ImU32 Dark[]     = {4280031972, 4290281015, 4283084621, 4288892568, 4278222847, 4281597951, 4280833702, 4290740727, 4288256409                                    };
    const ImU32 Pastel[]   = {4289639675, 4293119411, 4291161036, 4293184478, 4289124862, 4291624959, 4290631909, 4293712637, 4294111986                                    };
    const ImU32 Paired[]   = {4293119554, 4290017311, 4287291314, 4281114675, 4288256763, 4280031971, 4285513725, 4278222847, 4292260554, 4288298346, 4288282623, 4280834481};
    const ImU32 Viridis[]  = {4283695428, 4285867080, 4287054913, 4287455029, 4287526954, 4287402273, 4286883874, 4285579076, 4283552122, 4280737725, 4280674301            };
    const ImU32 Plasma[]   = {4287039501, 4288480321, 4289200234, 4288941455, 4287638193, 4286072780, 4284638433, 4283139314, 4281771772, 4280667900, 4280416752            };
    const ImU32 Hot[]      = {4278190144, 4278190208, 4278190271, 4278190335, 4278206719, 4278223103, 4278239231, 4278255615, 4283826175, 4289396735, 4294967295            };
    const ImU32 Cool[]     = {4294967040, 4294960666, 4294954035, 4294947661, 4294941030, 4294934656, 4294928025, 4294921651, 4294915020, 4294908646, 4294902015            };
    const ImU32 Pink[]     = {4278190154, 4282532475, 4284308894, 4285690554, 4286879686, 4287870160, 4288794330, 4289651940, 4291685869, 4293392118, 4294967295            };
    const ImU32 Jet[]      = {4289331200, 4294901760, 4294923520, 4294945280, 4294967040, 4289396565, 4283826090, 4278255615, 4278233855, 4278212095, 4278190335            };
    const ImU32 Twilight[] = {IM_RGB(226,217,226),IM_RGB(166,191,202),IM_RGB(109,144,192),IM_RGB(95,88,176),IM_RGB(83,30,124),IM_RGB(47,20,54),IM_RGB(100,25,75),IM_RGB(159,60,80),IM_RGB(192,117,94),IM_RGB(208,179,158),IM_RGB(226,217,226)};
    const ImU32 RdBu[]     = {IM_RGB(103,0,31),IM_RGB(178,24,43),IM_RGB(214,96,77),IM_RGB(244,165,130),IM_RGB(253,219,199),IM_RGB(247,247,247),IM_RGB(209,229,240),IM_RGB(146,197,222),IM_RGB(67,147,195),IM_RGB(33,102,172),IM_RGB(5,48,97)};
    const ImU32 BrBG[]     = {IM_RGB(84,48,5),IM_RGB(140,81,10),IM_RGB(191,129,45),IM_RGB(223,194,125),IM_RGB(246,232,195),IM_RGB(245,245,245),IM_RGB(199,234,229),IM_RGB(128,205,193),IM_RGB(53,151,143),IM_RGB(1,102,94),IM_RGB(0,60,48)};
    const ImU32 PiYG[]     = {IM_RGB(142,1,82),IM_RGB(197,27,125),IM_RGB(222,119,174),IM_RGB(241,182,218),IM_RGB(253,224,239),IM_RGB(247,247,247),IM_RGB(230,245,208),IM_RGB(184,225,134),IM_RGB(127,188,65),IM_RGB(77,146,33),IM_RGB(39,100,25)};
    const ImU32 Spectral[] = {IM_RGB(158,1,66),IM_RGB(213,62,79),IM_RGB(244,109,67),IM_RGB(253,174,97),IM_RGB(254,224,139),IM_RGB(255,255,191),IM_RGB(230,245,152),IM_RGB(171,221,164),IM_RGB(102,194,165),IM_RGB(50,136,189),IM_RGB(94,79,162)};
    const ImU32 Greys[]    = {IM_COL32_WHITE, IM_COL32_BLACK                                                                                                                };

    IMPLOT_APPEND_CMAP(Deep, true);
    IMPLOT_APPEND_CMAP(Dark, true);
    IMPLOT_APPEND_CMAP(Pastel, true);
    IMPLOT_APPEND_CMAP(Paired, true);
    IMPLOT_APPEND_CMAP(Viridis, false);
    IMPLOT_APPEND_CMAP(Plasma, false);
    IMPLOT_APPEND_CMAP(Hot, false);
    IMPLOT_APPEND_CMAP(Cool, false);
    IMPLOT_APPEND_CMAP(Pink, false);
    IMPLOT_APPEND_CMAP(Jet, false);
    IMPLOT_APPEND_CMAP(Twilight, false);
    IMPLOT_APPEND_CMAP(RdBu, false);
    IMPLOT_APPEND_CMAP(BrBG, false);
    IMPLOT_APPEND_CMAP(PiYG, false);
    IMPLOT_APPEND_CMAP(Spectral, false);
    IMPLOT_APPEND_CMAP(Greys, false);
}

void ResetCtxForNextPlot(ImPlotContext* ctx) {
    // end child window if it was made
    if (ctx->ChildWindowMade)
        ImGui::EndChild();
    ctx->ChildWindowMade = false;
    // reset the next plot/item data
    ctx->NextPlotData.Reset();
    ctx->NextItemData.Reset();
    // reset labels
    ctx->Annotations.Reset();
    ctx->Tags.Reset();
    // reset extents/fit
    ctx->OpenContextThisFrame = false;
    // reset digital plot items count
    ctx->DigitalPlotItemCnt = 0;
    ctx->DigitalPlotOffset = 0;
    // nullify plot
    ctx->CurrentPlot  = nullptr;
    ctx->CurrentItem  = nullptr;
    ctx->PreviousItem = nullptr;
}

void ResetCtxForNextAlignedPlots(ImPlotContext* ctx) {
    ctx->CurrentAlignmentH = nullptr;
    ctx->CurrentAlignmentV = nullptr;
}

void ResetCtxForNextSubplot(ImPlotContext* ctx) {
    ctx->CurrentSubplot      = nullptr;
    ctx->CurrentAlignmentH   = nullptr;
    ctx->CurrentAlignmentV   = nullptr;
}

//-----------------------------------------------------------------------------
// Plot Utils
//-----------------------------------------------------------------------------

ImPlotPlot* GetPlot(const char* title) {
    ImGuiWindow*   Window = GImGui->CurrentWindow;
    const ImGuiID  ID     = Window->GetID(title);
    return GImPlot->Plots.GetByKey(ID);
}

ImPlotPlot* GetCurrentPlot() {
    return GImPlot->CurrentPlot;
}

void BustPlotCache() {
    ImPlotContext& gp = *GImPlot;
    gp.Plots.Clear();
    gp.Subplots.Clear();
}

//-----------------------------------------------------------------------------
// Legend Utils
//-----------------------------------------------------------------------------

ImVec2 GetLocationPos(const ImRect& outer_rect, const ImVec2& inner_size, ImPlotLocation loc, const ImVec2& pad) {
    ImVec2 pos;
    if (ImHasFlag(loc, ImPlotLocation_West) && !ImHasFlag(loc, ImPlotLocation_East))
        pos.x = outer_rect.Min.x + pad.x;
    else if (!ImHasFlag(loc, ImPlotLocation_West) && ImHasFlag(loc, ImPlotLocation_East))
        pos.x = outer_rect.Max.x - pad.x - inner_size.x;
    else
        pos.x = outer_rect.GetCenter().x - inner_size.x * 0.5f;
    // legend reference point y
    if (ImHasFlag(loc, ImPlotLocation_North) && !ImHasFlag(loc, ImPlotLocation_South))
        pos.y = outer_rect.Min.y + pad.y;
    else if (!ImHasFlag(loc, ImPlotLocation_North) && ImHasFlag(loc, ImPlotLocation_South))
        pos.y = outer_rect.Max.y - pad.y - inner_size.y;
    else
        pos.y = outer_rect.GetCenter().y - inner_size.y * 0.5f;
    pos.x = IM_ROUND(pos.x);
    pos.y = IM_ROUND(pos.y);
    return pos;
}

ImVec2 CalcLegendSize(ImPlotItemGroup& items, const ImVec2& pad, const ImVec2& spacing, bool vertical) {
    // vars
    const int   nItems      = items.GetLegendCount();
    const float txt_ht      = ImGui::GetTextLineHeight();
    const float icon_size   = txt_ht;
    // get label max width
    float max_label_width = 0;
    float sum_label_width = 0;
    for (int i = 0; i < nItems; ++i) {
        const char* label       = items.GetLegendLabel(i);
        const float label_width = ImGui::CalcTextSize(label, nullptr, true).x;
        max_label_width         = label_width > max_label_width ? label_width : max_label_width;
        sum_label_width        += label_width;
    }
    // calc legend size
    const ImVec2 legend_size = vertical ?
                               ImVec2(pad.x * 2 + icon_size + max_label_width, pad.y * 2 + nItems * txt_ht + (nItems - 1) * spacing.y) :
                               ImVec2(pad.x * 2 + icon_size * nItems + sum_label_width + (nItems - 1) * spacing.x, pad.y * 2 + txt_ht);
    return legend_size;
}

int LegendSortingComp(const void* _a, const void* _b) {
    ImPlotItemGroup* items = GImPlot->SortItems;
    const int a = *(const int*)_a;
    const int b = *(const int*)_b;
    const char* label_a = items->GetLegendLabel(a);
    const char* label_b = items->GetLegendLabel(b);
    return strcmp(label_a,label_b);
}

bool ShowLegendEntries(ImPlotItemGroup& items, const ImRect& legend_bb, bool hovered, const ImVec2& pad, const ImVec2& spacing, bool vertical, ImDrawList& DrawList) {
    // vars
    const float txt_ht      = ImGui::GetTextLineHeight();
    const float icon_size   = txt_ht;
    const float icon_shrink = 2;
    ImU32 col_txt           = GetStyleColorU32(ImPlotCol_LegendText);
    ImU32 col_txt_dis       = ImAlphaU32(col_txt, 0.25f);
    // render each legend item
    float sum_label_width = 0;
    bool any_item_hovered = false;

    const int num_items = items.GetLegendCount();
    if (num_items < 1)
        return hovered;
    // build render order
    ImPlotContext& gp = *GImPlot;
    ImVector<int>& indices = gp.TempInt1;
    indices.resize(num_items);
    for (int i = 0; i < num_items; ++i)
        indices[i] = i;
    if (ImHasFlag(items.Legend.Flags, ImPlotLegendFlags_Sort) && num_items > 1) {
        gp.SortItems = &items;
        qsort(indices.Data, num_items, sizeof(int), LegendSortingComp);
    }
    // render
    for (int i = 0; i < num_items; ++i) {
        const int idx           = indices[i];
        ImPlotItem* item        = items.GetLegendItem(idx);
        const char* label       = items.GetLegendLabel(idx);
        const float label_width = ImGui::CalcTextSize(label, nullptr, true).x;
        const ImVec2 top_left   = vertical ?
                                  legend_bb.Min + pad + ImVec2(0, i * (txt_ht + spacing.y)) :
                                  legend_bb.Min + pad + ImVec2(i * (icon_size + spacing.x) + sum_label_width, 0);
        sum_label_width        += label_width;
        ImRect icon_bb;
        icon_bb.Min = top_left + ImVec2(icon_shrink,icon_shrink);
        icon_bb.Max = top_left + ImVec2(icon_size - icon_shrink, icon_size - icon_shrink);
        ImRect label_bb;
        label_bb.Min = top_left;
        label_bb.Max = top_left + ImVec2(label_width + icon_size, icon_size);
        ImU32 col_txt_hl;
        ImU32 col_item = ImAlphaU32(item->Color,1);

        ImRect button_bb(icon_bb.Min, label_bb.Max);

        ImGui::KeepAliveID(item->ID);

        bool item_hov = false;
        bool item_hld = false;
        bool item_clk = ImHasFlag(items.Legend.Flags, ImPlotLegendFlags_NoButtons)
                      ? false
                      : ImGui::ButtonBehavior(button_bb, item->ID, &item_hov, &item_hld);

        if (item_clk)
            item->Show = !item->Show;


        const bool can_hover = (item_hov)
                             && (!ImHasFlag(items.Legend.Flags, ImPlotLegendFlags_NoHighlightItem)
                             || !ImHasFlag(items.Legend.Flags, ImPlotLegendFlags_NoHighlightAxis));

        if (can_hover) {
            item->LegendHoverRect.Min = icon_bb.Min;
            item->LegendHoverRect.Max = label_bb.Max;
            item->LegendHovered = true;
            col_txt_hl = ImMixU32(col_txt, col_item, 64);
            any_item_hovered = true;
        }
        else {
            col_txt_hl = ImGui::GetColorU32(col_txt);
        }
        ImU32 col_icon;
        if (item_hld)
            col_icon = item->Show ? ImAlphaU32(col_item,0.5f) : ImGui::GetColorU32(ImGuiCol_TextDisabled, 0.5f);
        else if (item_hov)
            col_icon = item->Show ? ImAlphaU32(col_item,0.75f) : ImGui::GetColorU32(ImGuiCol_TextDisabled, 0.75f);
        else
            col_icon = item->Show ? col_item : col_txt_dis;

        DrawList.AddRectFilled(icon_bb.Min, icon_bb.Max, col_icon);
        const char* text_display_end = ImGui::FindRenderedTextEnd(label, nullptr);
        if (label != text_display_end)
            DrawList.AddText(top_left + ImVec2(icon_size, 0), item->Show ? col_txt_hl  : col_txt_dis, label, text_display_end);
    }
    return hovered && !any_item_hovered;
}

//-----------------------------------------------------------------------------
// Locators
//-----------------------------------------------------------------------------

static const float TICK_FILL_X = 0.8f;
static const float TICK_FILL_Y = 1.0f;

void Locator_Default(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data) {
    if (range.Min == range.Max)
        return;
    const int nMinor        = 10;
    const int nMajor        = ImMax(2, (int)IM_ROUND(pixels / (vertical ? 300.0f : 400.0f)));
    const double nice_range = NiceNum(range.Size() * 0.99, false);
    const double interval   = NiceNum(nice_range / (nMajor - 1), true);
    const double graphmin   = floor(range.Min / interval) * interval;
    const double graphmax   = ceil(range.Max / interval) * interval;
    bool first_major_set    = false;
    int  first_major_idx    = 0;
    const int idx0 = ticker.TickCount(); // ticker may have user custom ticks
    ImVec2 total_size(0,0);
    for (double major = graphmin; major < graphmax + 0.5 * interval; major += interval) {
        // is this zero? combat zero formatting issues
        if (major-interval < 0 && major+interval > 0)
            major = 0;
        if (range.Contains(major)) {
            if (!first_major_set) {
                first_major_idx = ticker.TickCount();
                first_major_set = true;
            }
            total_size += ticker.AddTick(major, true, 0, true, formatter, formatter_data).LabelSize;
        }
        for (int i = 1; i < nMinor; ++i) {
            double minor = major + i * interval / nMinor;
            if (range.Contains(minor)) {
                total_size += ticker.AddTick(minor, false, 0, true, formatter, formatter_data).LabelSize;
            }
        }
    }
    // prune if necessary
    if ((!vertical && total_size.x > pixels*TICK_FILL_X) || (vertical && total_size.y > pixels*TICK_FILL_Y)) {
        for (int i = first_major_idx-1; i >= idx0; i -= 2)
            ticker.Ticks[i].ShowLabel = false;
        for (int i = first_major_idx+1; i < ticker.TickCount(); i += 2)
            ticker.Ticks[i].ShowLabel = false;
    }
}

bool CalcLogarithmicExponents(const ImPlotRange& range, float pix, bool vertical, int& exp_min, int& exp_max, int& exp_step) {
    if (range.Min * range.Max > 0) {
        const int nMajor = vertical ? ImMax(2, (int)IM_ROUND(pix * 0.02f)) : ImMax(2, (int)IM_ROUND(pix * 0.01f)); // TODO: magic numbers
        double log_min = ImLog10(ImAbs(range.Min));
        double log_max = ImLog10(ImAbs(range.Max));
        double log_a = ImMin(log_min,log_max);
        double log_b = ImMax(log_min,log_max);
        exp_step  = ImMax(1,(int)(log_b - log_a) / nMajor);
        exp_min   = (int)log_a;
        exp_max   = (int)log_b;
        if (exp_step != 1) {
            while(exp_step % 3 != 0)       exp_step++; // make step size multiple of three
            while(exp_min % exp_step != 0) exp_min--;  // decrease exp_min until exp_min + N * exp_step will be 0
        }
        return true;
    }
    return false;
}

void AddTicksLogarithmic(const ImPlotRange& range, int exp_min, int exp_max, int exp_step, ImPlotTicker& ticker, ImPlotFormatter formatter, void* data) {
    const double sign = ImSign(range.Max);
    for (int e = exp_min - exp_step; e < (exp_max + exp_step); e += exp_step) {
        double major1 = sign*ImPow(10, (double)(e));
        double major2 = sign*ImPow(10, (double)(e + 1));
        double interval = (major2 - major1) / 9;
        if (major1 >= (range.Min - DBL_EPSILON) && major1 <= (range.Max + DBL_EPSILON))
            ticker.AddTick(major1, true, 0, true, formatter, data);
        for (int j = 0; j < exp_step; ++j) {
            major1 = sign*ImPow(10, (double)(e+j));
            major2 = sign*ImPow(10, (double)(e+j+1));
            interval = (major2 - major1) / 9;
            for (int i = 1; i < (9 + (int)(j < (exp_step - 1))); ++i) {
                double minor = major1 + i * interval;
                if (minor >= (range.Min - DBL_EPSILON) && minor <= (range.Max + DBL_EPSILON))
                    ticker.AddTick(minor, false, 0, false, formatter, data);
            }
        }
    }
}

void Locator_Log10(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data) {
    int exp_min, exp_max, exp_step;
    if (CalcLogarithmicExponents(range, pixels, vertical, exp_min, exp_max, exp_step))
        AddTicksLogarithmic(range, exp_min, exp_max, exp_step, ticker, formatter, formatter_data);
}

float CalcSymLogPixel(double plt, const ImPlotRange& range, float pixels) {
    double scaleToPixels = pixels / range.Size();
    double scaleMin      = TransformForward_SymLog(range.Min,nullptr);
    double scaleMax      = TransformForward_SymLog(range.Max,nullptr);
    double s             = TransformForward_SymLog(plt, nullptr);
    double t             = (s - scaleMin) / (scaleMax - scaleMin);
    plt                  = range.Min + range.Size() * t;

    return (float)(0 + scaleToPixels * (plt - range.Min));
}

void Locator_SymLog(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data) {
    if (range.Min >= -1 && range.Max <= 1) {
        Locator_Default(ticker, range, pixels, vertical, formatter, formatter_data);
    }
    else if (range.Min * range.Max < 0) { // cross zero
        const float pix_min = 0;
        const float pix_max = pixels;
        const float pix_p1  = CalcSymLogPixel(1, range, pixels);
        const float pix_n1  = CalcSymLogPixel(-1, range, pixels);
        int exp_min_p, exp_max_p, exp_step_p;
        int exp_min_n, exp_max_n, exp_step_n;
        CalcLogarithmicExponents(ImPlotRange(1,range.Max), ImAbs(pix_max-pix_p1),vertical,exp_min_p,exp_max_p,exp_step_p);
        CalcLogarithmicExponents(ImPlotRange(range.Min,-1),ImAbs(pix_n1-pix_min),vertical,exp_min_n,exp_max_n,exp_step_n);
        int exp_step = ImMax(exp_step_n, exp_step_p);
        ticker.AddTick(0,true,0,true,formatter,formatter_data);
        AddTicksLogarithmic(ImPlotRange(1,range.Max), exp_min_p,exp_max_p,exp_step,ticker,formatter,formatter_data);
        AddTicksLogarithmic(ImPlotRange(range.Min,-1),exp_min_n,exp_max_n,exp_step,ticker,formatter,formatter_data);
    }
    else {
        Locator_Log10(ticker, range, pixels, vertical, formatter, formatter_data);
    }
}

void AddTicksCustom(const double* values, const char* const labels[], int n, ImPlotTicker& ticker, ImPlotFormatter formatter, void* data) {
    for (int i = 0; i < n; ++i) {
        if (labels != nullptr)
            ticker.AddTick(values[i], false, 0, true, labels[i]);
        else
            ticker.AddTick(values[i], false, 0, true, formatter, data);
    }
}

//-----------------------------------------------------------------------------
// Time Ticks and Utils
//-----------------------------------------------------------------------------

// this may not be thread safe?
static const double TimeUnitSpans[ImPlotTimeUnit_COUNT] = {
    0.000001,
    0.001,
    1,
    60,
    3600,
    86400,
    2629800,
    31557600
};

inline ImPlotTimeUnit GetUnitForRange(double range) {
    static double cutoffs[ImPlotTimeUnit_COUNT] = {0.001, 1, 60, 3600, 86400, 2629800, 31557600, IMPLOT_MAX_TIME};
    for (int i = 0; i < ImPlotTimeUnit_COUNT; ++i) {
        if (range <= cutoffs[i])
            return (ImPlotTimeUnit)i;
    }
    return ImPlotTimeUnit_Yr;
}

inline int LowerBoundStep(int max_divs, const int* divs, const int* step, int size) {
    if (max_divs < divs[0])
        return 0;
    for (int i = 1; i < size; ++i) {
        if (max_divs < divs[i])
            return step[i-1];
    }
    return step[size-1];
}

inline int GetTimeStep(int max_divs, ImPlotTimeUnit unit) {
    if (unit == ImPlotTimeUnit_Ms || unit == ImPlotTimeUnit_Us) {
        static const int step[] = {500,250,200,100,50,25,20,10,5,2,1};
        static const int divs[] = {2,4,5,10,20,40,50,100,200,500,1000};
        return LowerBoundStep(max_divs, divs, step, 11);
    }
    if (unit == ImPlotTimeUnit_S || unit == ImPlotTimeUnit_Min) {
        static const int step[] = {30,15,10,5,1};
        static const int divs[] = {2,4,6,12,60};
        return LowerBoundStep(max_divs, divs, step, 5);
    }
    else if (unit == ImPlotTimeUnit_Hr) {
        static const int step[] = {12,6,3,2,1};
        static const int divs[] = {2,4,8,12,24};
        return LowerBoundStep(max_divs, divs, step, 5);
    }
    else if (unit == ImPlotTimeUnit_Day) {
        static const int step[] = {14,7,2,1};
        static const int divs[] = {2,4,14,28};
        return LowerBoundStep(max_divs, divs, step, 4);
    }
    else if (unit == ImPlotTimeUnit_Mo) {
        static const int step[] = {6,3,2,1};
        static const int divs[] = {2,4,6,12};
        return LowerBoundStep(max_divs, divs, step, 4);
    }
    return 0;
}

ImPlotTime MkGmtTime(struct tm *ptm) {
    ImPlotTime t;
#ifdef _WIN32
    t.S = _mkgmtime(ptm);
#else
    t.S = timegm(ptm);
#endif
    if (t.S < 0)
        t.S = 0;
    return t;
}

tm* GetGmtTime(const ImPlotTime& t, tm* ptm)
{
#ifdef _WIN32
  if (gmtime_s(ptm, &t.S) == 0)
    return ptm;
  else
    return nullptr;
#else
  return gmtime_r(&t.S, ptm);
#endif
}

ImPlotTime MkLocTime(struct tm *ptm) {
    ImPlotTime t;
    t.S = mktime(ptm);
    if (t.S < 0)
        t.S = 0;
    return t;
}

tm* GetLocTime(const ImPlotTime& t, tm* ptm) {
#ifdef _WIN32
  if (localtime_s(ptm, &t.S) == 0)
    return ptm;
  else
    return nullptr;
#else
    return localtime_r(&t.S, ptm);
#endif
}

inline ImPlotTime MkTime(struct tm *ptm) {
    if (GetStyle().UseLocalTime)
        return MkLocTime(ptm);
    else
        return MkGmtTime(ptm);
}

inline tm* GetTime(const ImPlotTime& t, tm* ptm) {
    if (GetStyle().UseLocalTime)
        return GetLocTime(t,ptm);
    else
        return GetGmtTime(t,ptm);
}

ImPlotTime MakeTime(int year, int month, int day, int hour, int min, int sec, int us) {
    tm& Tm = GImPlot->Tm;

    int yr = year - 1900;
    if (yr < 0)
        yr = 0;

    sec  = sec + us / 1000000;
    us   = us % 1000000;

    Tm.tm_sec  = sec;
    Tm.tm_min  = min;
    Tm.tm_hour = hour;
    Tm.tm_mday = day;
    Tm.tm_mon  = month;
    Tm.tm_year = yr;

    ImPlotTime t = MkTime(&Tm);

    t.Us = us;
    return t;
}

int GetYear(const ImPlotTime& t) {
    tm& Tm = GImPlot->Tm;
    GetTime(t, &Tm);
    return Tm.tm_year + 1900;
}

ImPlotTime AddTime(const ImPlotTime& t, ImPlotTimeUnit unit, int count) {
    tm& Tm = GImPlot->Tm;
    ImPlotTime t_out = t;
    switch(unit) {
        case ImPlotTimeUnit_Us:  t_out.Us += count;         break;
        case ImPlotTimeUnit_Ms:  t_out.Us += count * 1000;  break;
        case ImPlotTimeUnit_S:   t_out.S  += count;         break;
        case ImPlotTimeUnit_Min: t_out.S  += count * 60;    break;
        case ImPlotTimeUnit_Hr:  t_out.S  += count * 3600;  break;
        case ImPlotTimeUnit_Day: t_out.S  += count * 86400; break;
        case ImPlotTimeUnit_Mo:  for (int i = 0; i < abs(count); ++i) {
                                     GetTime(t_out, &Tm);
                                     if (count > 0)
                                        t_out.S += 86400 * GetDaysInMonth(Tm.tm_year + 1900, Tm.tm_mon);
                                     else if (count < 0)
                                        t_out.S -= 86400 * GetDaysInMonth(Tm.tm_year + 1900 - (Tm.tm_mon == 0 ? 1 : 0), Tm.tm_mon == 0 ? 11 : Tm.tm_mon - 1); // NOT WORKING
                                 }
                                 break;
        case ImPlotTimeUnit_Yr:  for (int i = 0; i < abs(count); ++i) {
                                    if (count > 0)
                                        t_out.S += 86400 * (365 + (int)IsLeapYear(GetYear(t_out)));
                                    else if (count < 0)
                                        t_out.S -= 86400 * (365 + (int)IsLeapYear(GetYear(t_out) - 1));
                                    // this is incorrect if leap year and we are past Feb 28
                                 }
                                 break;
        default:                 break;
    }
    t_out.RollOver();
    return t_out;
}

ImPlotTime FloorTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
    ImPlotContext& gp = *GImPlot;
    GetTime(t, &gp.Tm);
    switch (unit) {
        case ImPlotTimeUnit_S:   return ImPlotTime(t.S, 0);
        case ImPlotTimeUnit_Ms:  return ImPlotTime(t.S, (t.Us / 1000) * 1000);
        case ImPlotTimeUnit_Us:  return t;
        case ImPlotTimeUnit_Yr:  gp.Tm.tm_mon  = 0; // fall-through
        case ImPlotTimeUnit_Mo:  gp.Tm.tm_mday = 1; // fall-through
        case ImPlotTimeUnit_Day: gp.Tm.tm_hour = 0; // fall-through
        case ImPlotTimeUnit_Hr:  gp.Tm.tm_min  = 0; // fall-through
        case ImPlotTimeUnit_Min: gp.Tm.tm_sec  = 0; break;
        default:                 return t;
    }
    return MkTime(&gp.Tm);
}

ImPlotTime CeilTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
    return AddTime(FloorTime(t, unit), unit, 1);
}

ImPlotTime RoundTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
    ImPlotTime t1 = FloorTime(t, unit);
    ImPlotTime t2 = AddTime(t1,unit,1);
    if (t1.S == t2.S)
        return t.Us - t1.Us < t2.Us - t.Us ? t1 : t2;
    return t.S - t1.S < t2.S - t.S ? t1 : t2;
}

ImPlotTime CombineDateTime(const ImPlotTime& date_part, const ImPlotTime& tod_part) {
    ImPlotContext& gp = *GImPlot;
    tm& Tm = gp.Tm;
    GetTime(date_part, &gp.Tm);
    int y = Tm.tm_year;
    int m = Tm.tm_mon;
    int d = Tm.tm_mday;
    GetTime(tod_part, &gp.Tm);
    Tm.tm_year = y;
    Tm.tm_mon  = m;
    Tm.tm_mday = d;
    ImPlotTime t = MkTime(&Tm);
    t.Us = tod_part.Us;
    return t;
}

// TODO: allow users to define these
static const char* MONTH_NAMES[]  = {"January","February","March","April","May","June","July","August","September","October","November","December"};
static const char* WD_ABRVS[]     = {"Su","Mo","Tu","We","Th","Fr","Sa"};
static const char* MONTH_ABRVS[]  = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

int FormatTime(const ImPlotTime& t, char* buffer, int size, ImPlotTimeFmt fmt, bool use_24_hr_clk) {
    tm& Tm = GImPlot->Tm;
    GetTime(t, &Tm);
    const int us   = t.Us % 1000;
    const int ms   = t.Us / 1000;
    const int sec  = Tm.tm_sec;
    const int min  = Tm.tm_min;
    if (use_24_hr_clk) {
        const int hr   = Tm.tm_hour;
        switch(fmt) {
            case ImPlotTimeFmt_Us:        return ImFormatString(buffer, size, ".%03d %03d", ms, us);
            case ImPlotTimeFmt_SUs:       return ImFormatString(buffer, size, ":%02d.%03d %03d", sec, ms, us);
            case ImPlotTimeFmt_SMs:       return ImFormatString(buffer, size, ":%02d.%03d", sec, ms);
            case ImPlotTimeFmt_S:         return ImFormatString(buffer, size, ":%02d", sec);
            case ImPlotTimeFmt_MinSMs:    return ImFormatString(buffer, size, ":%02d:%02d.%03d", min, sec, ms);
            case ImPlotTimeFmt_HrMinSMs:  return ImFormatString(buffer, size, "%02d:%02d:%02d.%03d", hr, min, sec, ms);
            case ImPlotTimeFmt_HrMinS:    return ImFormatString(buffer, size, "%02d:%02d:%02d", hr, min, sec);
            case ImPlotTimeFmt_HrMin:     return ImFormatString(buffer, size, "%02d:%02d", hr, min);
            case ImPlotTimeFmt_Hr:        return ImFormatString(buffer, size, "%02d:00", hr);
            default:                      return 0;
        }
    }
    else {
        const char* ap = Tm.tm_hour < 12 ? "am" : "pm";
        const int hr   = (Tm.tm_hour == 0 || Tm.tm_hour == 12) ? 12 : Tm.tm_hour % 12;
        switch(fmt) {
            case ImPlotTimeFmt_Us:        return ImFormatString(buffer, size, ".%03d %03d", ms, us);
            case ImPlotTimeFmt_SUs:       return ImFormatString(buffer, size, ":%02d.%03d %03d", sec, ms, us);
            case ImPlotTimeFmt_SMs:       return ImFormatString(buffer, size, ":%02d.%03d", sec, ms);
            case ImPlotTimeFmt_S:         return ImFormatString(buffer, size, ":%02d", sec);
            case ImPlotTimeFmt_MinSMs:    return ImFormatString(buffer, size, ":%02d:%02d.%03d", min, sec, ms);
            case ImPlotTimeFmt_HrMinSMs:  return ImFormatString(buffer, size, "%d:%02d:%02d.%03d%s", hr, min, sec, ms, ap);
            case ImPlotTimeFmt_HrMinS:    return ImFormatString(buffer, size, "%d:%02d:%02d%s", hr, min, sec, ap);
            case ImPlotTimeFmt_HrMin:     return ImFormatString(buffer, size, "%d:%02d%s", hr, min, ap);
            case ImPlotTimeFmt_Hr:        return ImFormatString(buffer, size, "%d%s", hr, ap);
            default:                      return 0;
        }
    }
}

int FormatDate(const ImPlotTime& t, char* buffer, int size, ImPlotDateFmt fmt, bool use_iso_8601) {
    tm& Tm = GImPlot->Tm;
    GetTime(t, &Tm);
    const int day  = Tm.tm_mday;
    const int mon  = Tm.tm_mon + 1;
    const int year = Tm.tm_year + 1900;
    const int yr   = year % 100;
    if (use_iso_8601) {
        switch (fmt) {
            case ImPlotDateFmt_DayMo:   return ImFormatString(buffer, size, "--%02d-%02d", mon, day);
            case ImPlotDateFmt_DayMoYr: return ImFormatString(buffer, size, "%d-%02d-%02d", year, mon, day);
            case ImPlotDateFmt_MoYr:    return ImFormatString(buffer, size, "%d-%02d", year, mon);
            case ImPlotDateFmt_Mo:      return ImFormatString(buffer, size, "--%02d", mon);
            case ImPlotDateFmt_Yr:      return ImFormatString(buffer, size, "%d", year);
            default:                    return 0;
        }
    }
    else {
        switch (fmt) {
            case ImPlotDateFmt_DayMo:   return ImFormatString(buffer, size, "%d/%d", mon, day);
            case ImPlotDateFmt_DayMoYr: return ImFormatString(buffer, size, "%d/%d/%02d", mon, day, yr);
            case ImPlotDateFmt_MoYr:    return ImFormatString(buffer, size, "%s %d", MONTH_ABRVS[Tm.tm_mon], year);
            case ImPlotDateFmt_Mo:      return ImFormatString(buffer, size, "%s", MONTH_ABRVS[Tm.tm_mon]);
            case ImPlotDateFmt_Yr:      return ImFormatString(buffer, size, "%d", year);
            default:                    return 0;
        }
    }
 }

int FormatDateTime(const ImPlotTime& t, char* buffer, int size, ImPlotDateTimeSpec fmt) {
    int written = 0;
    if (fmt.Date != ImPlotDateFmt_None)
        written += FormatDate(t, buffer, size, fmt.Date, fmt.UseISO8601);
    if (fmt.Time != ImPlotTimeFmt_None) {
        if (fmt.Date != ImPlotDateFmt_None)
            buffer[written++] = ' ';
        written += FormatTime(t, &buffer[written], size - written, fmt.Time, fmt.Use24HourClock);
    }
    return written;
}

inline float GetDateTimeWidth(ImPlotDateTimeSpec fmt) {
    static const ImPlotTime t_max_width = MakeTime(2888, 12, 22, 12, 58, 58, 888888); // best guess at time that maximizes pixel width
    char buffer[32];
    FormatDateTime(t_max_width, buffer, 32, fmt);
    return ImGui::CalcTextSize(buffer).x;
}

inline bool TimeLabelSame(const char* l1, const char* l2) {
    size_t len1 = strlen(l1);
    size_t len2 = strlen(l2);
    size_t n  = len1 < len2 ? len1 : len2;
    return strcmp(l1 + len1 - n, l2 + len2 - n) == 0;
}

static const ImPlotDateTimeSpec TimeFormatLevel0[ImPlotTimeUnit_COUNT] = {
    ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_Us),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_SMs),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_S),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_HrMin),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_Hr),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMo, ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_Mo,    ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_Yr,    ImPlotTimeFmt_None)
};

static const ImPlotDateTimeSpec TimeFormatLevel1[ImPlotTimeUnit_COUNT] = {
    ImPlotDateTimeSpec(ImPlotDateFmt_None,    ImPlotTimeFmt_HrMin),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,    ImPlotTimeFmt_HrMinS),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,    ImPlotTimeFmt_HrMin),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,    ImPlotTimeFmt_HrMin),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_Yr,      ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_Yr,      ImPlotTimeFmt_None)
};

static const ImPlotDateTimeSpec TimeFormatLevel1First[ImPlotTimeUnit_COUNT] = {
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMinS),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMinS),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMin),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMin),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_Yr,      ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_Yr,      ImPlotTimeFmt_None)
};

static const ImPlotDateTimeSpec TimeFormatMouseCursor[ImPlotTimeUnit_COUNT] = {
    ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_Us),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_SUs),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_SMs),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_HrMinS),
    ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_HrMin),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMo,    ImPlotTimeFmt_Hr),
    ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr,  ImPlotTimeFmt_None),
    ImPlotDateTimeSpec(ImPlotDateFmt_MoYr,     ImPlotTimeFmt_None)
};

inline ImPlotDateTimeSpec GetDateTimeFmt(const ImPlotDateTimeSpec* ctx, ImPlotTimeUnit idx) {
    ImPlotStyle& style     = GetStyle();
    ImPlotDateTimeSpec fmt  = ctx[idx];
    fmt.UseISO8601         = style.UseISO8601;
    fmt.Use24HourClock     = style.Use24HourClock;
    return fmt;
}

void Locator_Time(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data) {
    IM_ASSERT_USER_ERROR(vertical == false, "Cannot locate Time ticks on vertical axis!");
    (void)vertical;
    // get units for level 0 and level 1 labels
    const ImPlotTimeUnit unit0 = GetUnitForRange(range.Size() / (pixels / 100)); // level = 0 (top)
    const ImPlotTimeUnit unit1 = ImClamp(unit0 + 1, 0, ImPlotTimeUnit_COUNT-1);  // level = 1 (bottom)
    // get time format specs
    const ImPlotDateTimeSpec fmt0 = GetDateTimeFmt(TimeFormatLevel0, unit0);
    const ImPlotDateTimeSpec fmt1 = GetDateTimeFmt(TimeFormatLevel1, unit1);
    const ImPlotDateTimeSpec fmtf = GetDateTimeFmt(TimeFormatLevel1First, unit1);
    // min max times
    const ImPlotTime t_min = ImPlotTime::FromDouble(range.Min);
    const ImPlotTime t_max = ImPlotTime::FromDouble(range.Max);
    // maximum allowable density of labels
    const float max_density = 0.5f;
    // book keeping
    int last_major_offset = -1;
    // formatter data
    Formatter_Time_Data ftd;
    ftd.UserFormatter = formatter;
    ftd.UserFormatterData = formatter_data;
    if (unit0 != ImPlotTimeUnit_Yr) {
        // pixels per major (level 1) division
        const float pix_per_major_div = pixels / (float)(range.Size() / TimeUnitSpans[unit1]);
        // nominal pixels taken up by labels
        const float fmt0_width = GetDateTimeWidth(fmt0);
        const float fmt1_width = GetDateTimeWidth(fmt1);
        const float fmtf_width = GetDateTimeWidth(fmtf);
        // the maximum number of minor (level 0) labels that can fit between major (level 1) divisions
        const int   minor_per_major   = (int)(max_density * pix_per_major_div / fmt0_width);
        // the minor step size (level 0)
        const int step = GetTimeStep(minor_per_major, unit0);
        // generate ticks
        ImPlotTime t1 = FloorTime(ImPlotTime::FromDouble(range.Min), unit1);
        while (t1 < t_max) {
            // get next major
            const ImPlotTime t2 = AddTime(t1, unit1, 1);
            // add major tick
            if (t1 >= t_min && t1 <= t_max) {
                // minor level 0 tick
                ftd.Time = t1; ftd.Spec = fmt0;
                ticker.AddTick(t1.ToDouble(), true, 0, true, Formatter_Time, &ftd);
                // major level 1 tick
                ftd.Time = t1; ftd.Spec = last_major_offset < 0 ? fmtf : fmt1;
                ImPlotTick& tick_maj = ticker.AddTick(t1.ToDouble(), true, 1, true, Formatter_Time, &ftd);
                const char* this_major = ticker.GetText(tick_maj);
                if (last_major_offset >= 0 && TimeLabelSame(ticker.TextBuffer.Buf.Data + last_major_offset, this_major))
                    tick_maj.ShowLabel = false;
                last_major_offset = tick_maj.TextOffset;
            }
            // add minor ticks up until next major
            if (minor_per_major > 1 && (t_min <= t2 && t1 <= t_max)) {
                ImPlotTime t12 = AddTime(t1, unit0, step);
                while (t12 < t2) {
                    float px_to_t2 = (float)((t2 - t12).ToDouble()/range.Size()) * pixels;
                    if (t12 >= t_min && t12 <= t_max) {
                        ftd.Time = t12; ftd.Spec = fmt0;
                        ticker.AddTick(t12.ToDouble(), false, 0, px_to_t2 >= fmt0_width, Formatter_Time, &ftd);
                        if (last_major_offset < 0 && px_to_t2 >= fmt0_width && px_to_t2 >= (fmt1_width + fmtf_width) / 2) {
                            ftd.Time = t12; ftd.Spec = fmtf;
                            ImPlotTick& tick_maj = ticker.AddTick(t12.ToDouble(), true, 1, true, Formatter_Time, &ftd);
                            last_major_offset = tick_maj.TextOffset;
                        }
                    }
                    t12 = AddTime(t12, unit0, step);
                }
            }
            t1 = t2;
        }
    }
    else {
        const ImPlotDateTimeSpec fmty = GetDateTimeFmt(TimeFormatLevel0, ImPlotTimeUnit_Yr);
        const float label_width = GetDateTimeWidth(fmty);
        const int   max_labels  = (int)(max_density * pixels / label_width);
        const int year_min      = GetYear(t_min);
        const int year_max      = GetYear(CeilTime(t_max, ImPlotTimeUnit_Yr));
        const double nice_range = NiceNum((year_max - year_min)*0.99,false);
        const double interval   = NiceNum(nice_range / (max_labels - 1), true);
        const int graphmin      = (int)(floor(year_min / interval) * interval);
        const int graphmax      = (int)(ceil(year_max  / interval) * interval);
        const int step          = (int)interval <= 0 ? 1 : (int)interval;

        for (int y = graphmin; y < graphmax; y += step) {
            ImPlotTime t = MakeTime(y);
            if (t >= t_min && t <= t_max) {
                ftd.Time = t; ftd.Spec = fmty;
                ticker.AddTick(t.ToDouble(), true, 0, true, Formatter_Time, &ftd);
            }
        }
    }
}

//-----------------------------------------------------------------------------
// Context Menu
//-----------------------------------------------------------------------------

template <typename F>
bool DragFloat(const char*, F*, float, F, F) {
    return false;
}

template <>
bool DragFloat<double>(const char* label, double* v, float v_speed, double v_min, double v_max) {
    return ImGui::DragScalar(label, ImGuiDataType_Double, v, v_speed, &v_min, &v_max, "%.3f", 1);
}

template <>
bool DragFloat<float>(const char* label, float* v, float v_speed, float v_min, float v_max) {
    return ImGui::DragScalar(label, ImGuiDataType_Float, v, v_speed, &v_min, &v_max, "%.3f", 1);
}

inline void BeginDisabledControls(bool cond) {
    if (cond) {
        ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
        ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.25f);
    }
}

inline void EndDisabledControls(bool cond) {
    if (cond) {
        ImGui::PopItemFlag();
        ImGui::PopStyleVar();
    }
}

void ShowAxisContextMenu(ImPlotAxis& axis, ImPlotAxis* equal_axis, bool /*time_allowed*/) {

    ImGui::PushItemWidth(75);
    bool always_locked   = axis.IsRangeLocked() || axis.IsAutoFitting();
    bool label           = axis.HasLabel();
    bool grid            = axis.HasGridLines();
    bool ticks           = axis.HasTickMarks();
    bool labels          = axis.HasTickLabels();
    double drag_speed    = (axis.Range.Size() <= DBL_EPSILON) ? DBL_EPSILON * 1.0e+13 : 0.01 * axis.Range.Size(); // recover from almost equal axis limits.

    if (axis.Scale == ImPlotScale_Time) {
        ImPlotTime tmin = ImPlotTime::FromDouble(axis.Range.Min);
        ImPlotTime tmax = ImPlotTime::FromDouble(axis.Range.Max);

        BeginDisabledControls(always_locked);
        ImGui::CheckboxFlags("##LockMin", (unsigned int*)&axis.Flags, ImPlotAxisFlags_LockMin);
        EndDisabledControls(always_locked);
        ImGui::SameLine();
        BeginDisabledControls(axis.IsLockedMin() || always_locked);
        if (ImGui::BeginMenu("Min Time")) {
            if (ShowTimePicker("mintime", &tmin)) {
                if (tmin >= tmax)
                    tmax = AddTime(tmin, ImPlotTimeUnit_S, 1);
                axis.SetRange(tmin.ToDouble(),tmax.ToDouble());
            }
            ImGui::Separator();
            if (ShowDatePicker("mindate",&axis.PickerLevel,&axis.PickerTimeMin,&tmin,&tmax)) {
                tmin = CombineDateTime(axis.PickerTimeMin, tmin);
                if (tmin >= tmax)
                    tmax = AddTime(tmin, ImPlotTimeUnit_S, 1);
                axis.SetRange(tmin.ToDouble(), tmax.ToDouble());
            }
            ImGui::EndMenu();
        }
        EndDisabledControls(axis.IsLockedMin() || always_locked);

        BeginDisabledControls(always_locked);
        ImGui::CheckboxFlags("##LockMax", (unsigned int*)&axis.Flags, ImPlotAxisFlags_LockMax);
        EndDisabledControls(always_locked);
        ImGui::SameLine();
        BeginDisabledControls(axis.IsLockedMax() || always_locked);
        if (ImGui::BeginMenu("Max Time")) {
            if (ShowTimePicker("maxtime", &tmax)) {
                if (tmax <= tmin)
                    tmin = AddTime(tmax, ImPlotTimeUnit_S, -1);
                axis.SetRange(tmin.ToDouble(),tmax.ToDouble());
            }
            ImGui::Separator();
            if (ShowDatePicker("maxdate",&axis.PickerLevel,&axis.PickerTimeMax,&tmin,&tmax)) {
                tmax = CombineDateTime(axis.PickerTimeMax, tmax);
                if (tmax <= tmin)
                    tmin = AddTime(tmax, ImPlotTimeUnit_S, -1);
                axis.SetRange(tmin.ToDouble(), tmax.ToDouble());
            }
            ImGui::EndMenu();
        }
        EndDisabledControls(axis.IsLockedMax() || always_locked);
    }
    else {
        BeginDisabledControls(always_locked);
        ImGui::CheckboxFlags("##LockMin", (unsigned int*)&axis.Flags, ImPlotAxisFlags_LockMin);
        EndDisabledControls(always_locked);
        ImGui::SameLine();
        BeginDisabledControls(axis.IsLockedMin() || always_locked);
        double temp_min = axis.Range.Min;
        if (DragFloat("Min", &temp_min, (float)drag_speed, -HUGE_VAL, axis.Range.Max - DBL_EPSILON)) {
            axis.SetMin(temp_min,true);
            if (equal_axis != nullptr)
                equal_axis->SetAspect(axis.GetAspect());
        }
        EndDisabledControls(axis.IsLockedMin() || always_locked);

        BeginDisabledControls(always_locked);
        ImGui::CheckboxFlags("##LockMax", (unsigned int*)&axis.Flags, ImPlotAxisFlags_LockMax);
        EndDisabledControls(always_locked);
        ImGui::SameLine();
        BeginDisabledControls(axis.IsLockedMax() || always_locked);
        double temp_max = axis.Range.Max;
        if (DragFloat("Max", &temp_max, (float)drag_speed, axis.Range.Min + DBL_EPSILON, HUGE_VAL)) {
            axis.SetMax(temp_max,true);
            if (equal_axis != nullptr)
                equal_axis->SetAspect(axis.GetAspect());
        }
        EndDisabledControls(axis.IsLockedMax() || always_locked);
    }

    ImGui::Separator();

    ImGui::CheckboxFlags("Auto-Fit",(unsigned int*)&axis.Flags, ImPlotAxisFlags_AutoFit);
    // TODO
    // BeginDisabledControls(axis.IsTime() && time_allowed);
    // ImGui::CheckboxFlags("Log Scale",(unsigned int*)&axis.Flags, ImPlotAxisFlags_LogScale);
    // EndDisabledControls(axis.IsTime() && time_allowed);
    // if (time_allowed) {
    //     BeginDisabledControls(axis.IsLog() || axis.IsSymLog());
    //     ImGui::CheckboxFlags("Time",(unsigned int*)&axis.Flags, ImPlotAxisFlags_Time);
    //     EndDisabledControls(axis.IsLog() || axis.IsSymLog());
    // }
    ImGui::Separator();
    ImGui::CheckboxFlags("Invert",(unsigned int*)&axis.Flags, ImPlotAxisFlags_Invert);
    ImGui::CheckboxFlags("Opposite",(unsigned int*)&axis.Flags, ImPlotAxisFlags_Opposite);
    ImGui::Separator();
    BeginDisabledControls(axis.LabelOffset == -1);
    if (ImGui::Checkbox("Label", &label))
        ImFlipFlag(axis.Flags, ImPlotAxisFlags_NoLabel);
    EndDisabledControls(axis.LabelOffset == -1);
    if (ImGui::Checkbox("Grid Lines", &grid))
        ImFlipFlag(axis.Flags, ImPlotAxisFlags_NoGridLines);
    if (ImGui::Checkbox("Tick Marks", &ticks))
        ImFlipFlag(axis.Flags, ImPlotAxisFlags_NoTickMarks);
    if (ImGui::Checkbox("Tick Labels", &labels))
        ImFlipFlag(axis.Flags, ImPlotAxisFlags_NoTickLabels);

}

bool ShowLegendContextMenu(ImPlotLegend& legend, bool visible) {
    const float s = ImGui::GetFrameHeight();
    bool ret = false;
    if (ImGui::Checkbox("Show",&visible))
        ret = true;
    if (legend.CanGoInside)
        ImGui::CheckboxFlags("Outside",(unsigned int*)&legend.Flags, ImPlotLegendFlags_Outside);
    if (ImGui::RadioButton("H", ImHasFlag(legend.Flags, ImPlotLegendFlags_Horizontal)))
        legend.Flags |= ImPlotLegendFlags_Horizontal;
    ImGui::SameLine();
    if (ImGui::RadioButton("V", !ImHasFlag(legend.Flags, ImPlotLegendFlags_Horizontal)))
        legend.Flags &= ~ImPlotLegendFlags_Horizontal;
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(2,2));
    if (ImGui::Button("NW",ImVec2(1.5f*s,s))) { legend.Location = ImPlotLocation_NorthWest; } ImGui::SameLine();
    if (ImGui::Button("N", ImVec2(1.5f*s,s))) { legend.Location = ImPlotLocation_North;     } ImGui::SameLine();
    if (ImGui::Button("NE",ImVec2(1.5f*s,s))) { legend.Location = ImPlotLocation_NorthEast; }
    if (ImGui::Button("W", ImVec2(1.5f*s,s))) { legend.Location = ImPlotLocation_West;      } ImGui::SameLine();
    if (ImGui::InvisibleButton("C", ImVec2(1.5f*s,s))) {     } ImGui::SameLine();
    if (ImGui::Button("E", ImVec2(1.5f*s,s))) { legend.Location = ImPlotLocation_East;      }
    if (ImGui::Button("SW",ImVec2(1.5f*s,s))) { legend.Location = ImPlotLocation_SouthWest; } ImGui::SameLine();
    if (ImGui::Button("S", ImVec2(1.5f*s,s))) { legend.Location = ImPlotLocation_South;     } ImGui::SameLine();
    if (ImGui::Button("SE",ImVec2(1.5f*s,s))) { legend.Location = ImPlotLocation_SouthEast; }
    ImGui::PopStyleVar();
    return ret;
}

void ShowSubplotsContextMenu(ImPlotSubplot& subplot) {
    if ((ImGui::BeginMenu("Linking"))) {
        if (ImGui::MenuItem("Link Rows",nullptr,ImHasFlag(subplot.Flags, ImPlotSubplotFlags_LinkRows)))
            ImFlipFlag(subplot.Flags, ImPlotSubplotFlags_LinkRows);
        if (ImGui::MenuItem("Link Cols",nullptr,ImHasFlag(subplot.Flags, ImPlotSubplotFlags_LinkCols)))
            ImFlipFlag(subplot.Flags, ImPlotSubplotFlags_LinkCols);
        if (ImGui::MenuItem("Link All X",nullptr,ImHasFlag(subplot.Flags, ImPlotSubplotFlags_LinkAllX)))
            ImFlipFlag(subplot.Flags, ImPlotSubplotFlags_LinkAllX);
        if (ImGui::MenuItem("Link All Y",nullptr,ImHasFlag(subplot.Flags, ImPlotSubplotFlags_LinkAllY)))
            ImFlipFlag(subplot.Flags, ImPlotSubplotFlags_LinkAllY);
        ImGui::EndMenu();
    }
    if ((ImGui::BeginMenu("Settings"))) {
        BeginDisabledControls(!subplot.HasTitle);
        if (ImGui::MenuItem("Title",nullptr,subplot.HasTitle && !ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoTitle)))
            ImFlipFlag(subplot.Flags, ImPlotSubplotFlags_NoTitle);
        EndDisabledControls(!subplot.HasTitle);
        if (ImGui::MenuItem("Resizable",nullptr,!ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoResize)))
            ImFlipFlag(subplot.Flags, ImPlotSubplotFlags_NoResize);
        if (ImGui::MenuItem("Align",nullptr,!ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoAlign)))
            ImFlipFlag(subplot.Flags, ImPlotSubplotFlags_NoAlign);
        if (ImGui::MenuItem("Share Items",nullptr,ImHasFlag(subplot.Flags, ImPlotSubplotFlags_ShareItems)))
            ImFlipFlag(subplot.Flags, ImPlotSubplotFlags_ShareItems);
        ImGui::EndMenu();
    }
}

void ShowPlotContextMenu(ImPlotPlot& plot) {
    ImPlotContext& gp = *GImPlot;
    const bool owns_legend = gp.CurrentItems == &plot.Items;
    const bool equal = ImHasFlag(plot.Flags, ImPlotFlags_Equal);

    char buf[16] = {};

    for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
        ImPlotAxis& x_axis = plot.XAxis(i);
        if (!x_axis.Enabled || !x_axis.HasMenus())
            continue;
        ImGui::PushID(i);
        ImFormatString(buf, sizeof(buf) - 1, i == 0 ? "X-Axis" : "X-Axis %d", i + 1);
        if (ImGui::BeginMenu(x_axis.HasLabel() ? plot.GetAxisLabel(x_axis) : buf)) {
            ShowAxisContextMenu(x_axis, equal ? x_axis.OrthoAxis : nullptr, false);
            ImGui::EndMenu();
        }
        ImGui::PopID();
    }

    for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
        ImPlotAxis& y_axis = plot.YAxis(i);
        if (!y_axis.Enabled || !y_axis.HasMenus())
            continue;
        ImGui::PushID(i);
        ImFormatString(buf, sizeof(buf) - 1, i == 0 ? "Y-Axis" : "Y-Axis %d", i + 1);
        if (ImGui::BeginMenu(y_axis.HasLabel() ? plot.GetAxisLabel(y_axis) : buf)) {
            ShowAxisContextMenu(y_axis, equal ? y_axis.OrthoAxis : nullptr, false);
            ImGui::EndMenu();
        }
        ImGui::PopID();
    }

    ImGui::Separator();
    if (!ImHasFlag(gp.CurrentItems->Legend.Flags, ImPlotLegendFlags_NoMenus)) {
        if ((ImGui::BeginMenu("Legend"))) {
            if (owns_legend) {
                if (ShowLegendContextMenu(plot.Items.Legend, !ImHasFlag(plot.Flags, ImPlotFlags_NoLegend)))
                    ImFlipFlag(plot.Flags, ImPlotFlags_NoLegend);
            }
            else if (gp.CurrentSubplot != nullptr) {
                if (ShowLegendContextMenu(gp.CurrentSubplot->Items.Legend, !ImHasFlag(gp.CurrentSubplot->Flags, ImPlotSubplotFlags_NoLegend)))
                    ImFlipFlag(gp.CurrentSubplot->Flags, ImPlotSubplotFlags_NoLegend);
            }
            ImGui::EndMenu();
        }
    }
    if ((ImGui::BeginMenu("Settings"))) {
        if (ImGui::MenuItem("Equal", nullptr, ImHasFlag(plot.Flags, ImPlotFlags_Equal)))
            ImFlipFlag(plot.Flags, ImPlotFlags_Equal);
        if (ImGui::MenuItem("Box Select",nullptr,!ImHasFlag(plot.Flags, ImPlotFlags_NoBoxSelect)))
            ImFlipFlag(plot.Flags, ImPlotFlags_NoBoxSelect);
        BeginDisabledControls(plot.TitleOffset == -1);
        if (ImGui::MenuItem("Title",nullptr,plot.HasTitle()))
            ImFlipFlag(plot.Flags, ImPlotFlags_NoTitle);
        EndDisabledControls(plot.TitleOffset == -1);
        if (ImGui::MenuItem("Mouse Position",nullptr,!ImHasFlag(plot.Flags, ImPlotFlags_NoMouseText)))
            ImFlipFlag(plot.Flags, ImPlotFlags_NoMouseText);
        if (ImGui::MenuItem("Crosshairs",nullptr,ImHasFlag(plot.Flags, ImPlotFlags_Crosshairs)))
            ImFlipFlag(plot.Flags, ImPlotFlags_Crosshairs);
        ImGui::EndMenu();
    }
    if (gp.CurrentSubplot != nullptr && !ImHasFlag(gp.CurrentPlot->Flags, ImPlotSubplotFlags_NoMenus)) {
        ImGui::Separator();
        if ((ImGui::BeginMenu("Subplots"))) {
            ShowSubplotsContextMenu(*gp.CurrentSubplot);
            ImGui::EndMenu();
        }
    }
}

//-----------------------------------------------------------------------------
// Axis Utils
//-----------------------------------------------------------------------------

static inline int AxisPrecision(const ImPlotAxis& axis) {
    const double range = axis.Ticker.TickCount() > 1 ? (axis.Ticker.Ticks[1].PlotPos - axis.Ticker.Ticks[0].PlotPos) : axis.Range.Size();
    return Precision(range);
}

static inline double RoundAxisValue(const ImPlotAxis& axis, double value) {
    return RoundTo(value, AxisPrecision(axis));
}

void LabelAxisValue(const ImPlotAxis& axis, double value, char* buff, int size, bool round) {
    ImPlotContext& gp = *GImPlot;
    // TODO: We shouldn't explicitly check that the axis is Time here. Ideally,
    // Formatter_Time would handle the formatting for us, but the code below
    // needs additional arguments which are not currently available in ImPlotFormatter
    if (axis.Locator == Locator_Time) {
        ImPlotTimeUnit unit = axis.Vertical
                            ? GetUnitForRange(axis.Range.Size() / (gp.CurrentPlot->PlotRect.GetHeight() / 100)) // TODO: magic value!
                            : GetUnitForRange(axis.Range.Size() / (gp.CurrentPlot->PlotRect.GetWidth() / 100)); // TODO: magic value!
        FormatDateTime(ImPlotTime::FromDouble(value), buff, size, GetDateTimeFmt(TimeFormatMouseCursor, unit));
    }
    else {
        if (round)
            value = RoundAxisValue(axis, value);
        axis.Formatter(value, buff, size, axis.FormatterData);
    }
}

void UpdateAxisColors(ImPlotAxis& axis) {
    const ImVec4 col_grid = GetStyleColorVec4(ImPlotCol_AxisGrid);
    axis.ColorMaj         = ImGui::GetColorU32(col_grid);
    axis.ColorMin         = ImGui::GetColorU32(col_grid*ImVec4(1,1,1,GImPlot->Style.MinorAlpha));
    axis.ColorTick        = GetStyleColorU32(ImPlotCol_AxisTick);
    axis.ColorTxt         = GetStyleColorU32(ImPlotCol_AxisText);
    axis.ColorBg          = GetStyleColorU32(ImPlotCol_AxisBg);
    axis.ColorHov         = GetStyleColorU32(ImPlotCol_AxisBgHovered);
    axis.ColorAct         = GetStyleColorU32(ImPlotCol_AxisBgActive);
    // axis.ColorHiLi     = IM_COL32_BLACK_TRANS;
}

void PadAndDatumAxesX(ImPlotPlot& plot, float& pad_T, float& pad_B, ImPlotAlignmentData* align) {

    ImPlotContext& gp = *GImPlot;

    const float T = ImGui::GetTextLineHeight();
    const float P = gp.Style.LabelPadding.y;
    const float K = gp.Style.MinorTickLen.x;

    int   count_T = 0;
    int   count_B = 0;
    float last_T  = plot.AxesRect.Min.y;
    float last_B  = plot.AxesRect.Max.y;

    for (int i = IMPLOT_NUM_X_AXES; i-- > 0;) { // FYI: can iterate forward
        ImPlotAxis& axis = plot.XAxis(i);
        if (!axis.Enabled)
            continue;
        const bool label = axis.HasLabel();
        const bool ticks = axis.HasTickLabels();
        const bool opp   = axis.IsOpposite();
        const bool time  = axis.Scale == ImPlotScale_Time;
        if (opp) {
            if (count_T++ > 0)
                pad_T += K + P;
            if (label)
                pad_T += T + P;
            if (ticks)
                pad_T += ImMax(T, axis.Ticker.MaxSize.y) + P + (time ? T + P : 0);
            axis.Datum1 = plot.CanvasRect.Min.y + pad_T;
            axis.Datum2 = last_T;
            last_T = axis.Datum1;
        }
        else {
            if (count_B++ > 0)
                pad_B += K + P;
            if (label)
                pad_B += T + P;
            if (ticks)
                pad_B += ImMax(T, axis.Ticker.MaxSize.y) + P + (time ? T + P : 0);
            axis.Datum1 = plot.CanvasRect.Max.y - pad_B;
            axis.Datum2 = last_B;
            last_B = axis.Datum1;
        }
    }

    if (align) {
        count_T = count_B = 0;
        float delta_T, delta_B;
        align->Update(pad_T,pad_B,delta_T,delta_B);
        for (int i = IMPLOT_NUM_X_AXES; i-- > 0;) {
            ImPlotAxis& axis = plot.XAxis(i);
            if (!axis.Enabled)
                continue;
            if (axis.IsOpposite()) {
                axis.Datum1 += delta_T;
                axis.Datum2 += count_T++ > 1 ? delta_T : 0;
            }
            else {
                axis.Datum1 -= delta_B;
                axis.Datum2 -= count_B++ > 1 ? delta_B : 0;
            }
        }
    }
}

void PadAndDatumAxesY(ImPlotPlot& plot, float& pad_L, float& pad_R, ImPlotAlignmentData* align) {

    //   [   pad_L   ]                 [   pad_R   ]
    //   .................CanvasRect................
    //   :TPWPK.PTPWP _____PlotRect____ PWPTP.KPWPT:
    //   :A # |- A # |-               -| # A -| # A:
    //   :X   |  X   |                 |   X  |   x:
    //   :I # |- I # |-               -| # I -| # I:
    //   :S   |  S   |                 |   S  |   S:
    //   :3 # |- 0 # |-_______________-| # 1 -| # 2:
    //   :.........................................:
    //
    //   T = text height
    //   P = label padding
    //   K = minor tick length
    //   W = label width

    ImPlotContext& gp = *GImPlot;

    const float T = ImGui::GetTextLineHeight();
    const float P = gp.Style.LabelPadding.x;
    const float K = gp.Style.MinorTickLen.y;

    int   count_L = 0;
    int   count_R = 0;
    float last_L  = plot.AxesRect.Min.x;
    float last_R  = plot.AxesRect.Max.x;

    for (int i = IMPLOT_NUM_Y_AXES; i-- > 0;) { // FYI: can iterate forward
        ImPlotAxis& axis = plot.YAxis(i);
        if (!axis.Enabled)
            continue;
        const bool label = axis.HasLabel();
        const bool ticks = axis.HasTickLabels();
        const bool opp   = axis.IsOpposite();
        if (opp) {
            if (count_R++ > 0)
                pad_R += K + P;
            if (label)
                pad_R += T + P;
            if (ticks)
                pad_R += axis.Ticker.MaxSize.x + P;
            axis.Datum1 = plot.CanvasRect.Max.x - pad_R;
            axis.Datum2 = last_R;
            last_R = axis.Datum1;
        }
        else {
            if (count_L++ > 0)
                pad_L += K + P;
            if (label)
                pad_L += T + P;
            if (ticks)
                pad_L += axis.Ticker.MaxSize.x + P;
            axis.Datum1 = plot.CanvasRect.Min.x + pad_L;
            axis.Datum2 = last_L;
            last_L = axis.Datum1;
        }
    }

    plot.PlotRect.Min.x = plot.CanvasRect.Min.x + pad_L;
    plot.PlotRect.Max.x = plot.CanvasRect.Max.x - pad_R;

    if (align) {
        count_L = count_R = 0;
        float delta_L, delta_R;
        align->Update(pad_L,pad_R,delta_L,delta_R);
        for (int i = IMPLOT_NUM_Y_AXES; i-- > 0;) {
            ImPlotAxis& axis = plot.YAxis(i);
            if (!axis.Enabled)
                continue;
            if (axis.IsOpposite()) {
                axis.Datum1 -= delta_R;
                axis.Datum2 -= count_R++ > 1 ? delta_R : 0;
            }
            else {
                axis.Datum1 += delta_L;
                axis.Datum2 += count_L++ > 1 ? delta_L : 0;
            }
        }
    }
}

//-----------------------------------------------------------------------------
// RENDERING
//-----------------------------------------------------------------------------

static inline void RenderGridLinesX(ImDrawList& DrawList, const ImPlotTicker& ticker, const ImRect& rect, ImU32 col_maj, ImU32 col_min, float size_maj, float size_min) {
    const float density   = ticker.TickCount() / rect.GetWidth();
    ImVec4 col_min4  = ImGui::ColorConvertU32ToFloat4(col_min);
    col_min4.w      *= ImClamp(ImRemap(density, 0.1f, 0.2f, 1.0f, 0.0f), 0.0f, 1.0f);
    col_min = ImGui::ColorConvertFloat4ToU32(col_min4);
    for (int t = 0; t < ticker.TickCount(); t++) {
        const ImPlotTick& xt = ticker.Ticks[t];
        if (xt.PixelPos < rect.Min.x || xt.PixelPos > rect.Max.x)
            continue;
        if (xt.Level == 0) {
            if (xt.Major)
                DrawList.AddLine(ImVec2(xt.PixelPos, rect.Min.y), ImVec2(xt.PixelPos, rect.Max.y), col_maj, size_maj);
            else if (density < 0.2f)
                DrawList.AddLine(ImVec2(xt.PixelPos, rect.Min.y), ImVec2(xt.PixelPos, rect.Max.y), col_min, size_min);
        }
    }
}

static inline void RenderGridLinesY(ImDrawList& DrawList, const ImPlotTicker& ticker, const ImRect& rect, ImU32 col_maj, ImU32 col_min, float size_maj, float size_min) {
    const float density   = ticker.TickCount() / rect.GetHeight();
    ImVec4 col_min4  = ImGui::ColorConvertU32ToFloat4(col_min);
    col_min4.w      *= ImClamp(ImRemap(density, 0.1f, 0.2f, 1.0f, 0.0f), 0.0f, 1.0f);
    col_min = ImGui::ColorConvertFloat4ToU32(col_min4);
    for (int t = 0; t < ticker.TickCount(); t++) {
        const ImPlotTick& yt = ticker.Ticks[t];
        if (yt.PixelPos < rect.Min.y || yt.PixelPos > rect.Max.y)
            continue;
        if (yt.Major)
            DrawList.AddLine(ImVec2(rect.Min.x, yt.PixelPos), ImVec2(rect.Max.x, yt.PixelPos), col_maj, size_maj);
        else if (density < 0.2f)
            DrawList.AddLine(ImVec2(rect.Min.x, yt.PixelPos), ImVec2(rect.Max.x, yt.PixelPos), col_min, size_min);
    }
}

static inline void RenderSelectionRect(ImDrawList& DrawList, const ImVec2& p_min, const ImVec2& p_max, const ImVec4& col) {
    const ImU32 col_bg = ImGui::GetColorU32(col * ImVec4(1,1,1,0.25f));
    const ImU32 col_bd = ImGui::GetColorU32(col);
    DrawList.AddRectFilled(p_min, p_max, col_bg);
    DrawList.AddRect(p_min, p_max, col_bd);
}

//-----------------------------------------------------------------------------
// Input Handling
//-----------------------------------------------------------------------------

static const float MOUSE_CURSOR_DRAG_THRESHOLD = 5.0f;
static const float BOX_SELECT_DRAG_THRESHOLD   = 4.0f;

bool UpdateInput(ImPlotPlot& plot) {

    bool changed = false;

    ImPlotContext& gp = *GImPlot;
    ImGuiIO& IO = ImGui::GetIO();

    // BUTTON STATE -----------------------------------------------------------

    const ImGuiButtonFlags plot_button_flags = ImGuiButtonFlags_AllowOverlap
                                             | ImGuiButtonFlags_PressedOnClick
                                             | ImGuiButtonFlags_PressedOnDoubleClick
                                             | ImGuiButtonFlags_MouseButtonLeft
                                             | ImGuiButtonFlags_MouseButtonRight
                                             | ImGuiButtonFlags_MouseButtonMiddle;
    const ImGuiButtonFlags axis_button_flags = ImGuiButtonFlags_FlattenChildren
                                             | plot_button_flags;

    const bool plot_clicked = ImGui::ButtonBehavior(plot.PlotRect,plot.ID,&plot.Hovered,&plot.Held,plot_button_flags);
#if (IMGUI_VERSION_NUM < 18966)
    ImGui::SetItemAllowOverlap(); // Handled by ButtonBehavior()
#endif

    if (plot_clicked) {
        if (!ImHasFlag(plot.Flags, ImPlotFlags_NoBoxSelect) && IO.MouseClicked[gp.InputMap.Select] && ImHasFlag(IO.KeyMods, gp.InputMap.SelectMod)) {
            plot.Selecting   = true;
            plot.SelectStart = IO.MousePos;
            plot.SelectRect  = ImRect(0,0,0,0);
        }
        if (IO.MouseDoubleClicked[gp.InputMap.Fit]) {
            plot.FitThisFrame = true;
            for (int i = 0; i < ImAxis_COUNT; ++i)
                plot.Axes[i].FitThisFrame = true;
        }
    }

    const bool can_pan = IO.MouseDown[gp.InputMap.Pan] && ImHasFlag(IO.KeyMods, gp.InputMap.PanMod);

    plot.Held = plot.Held && can_pan;

    bool x_click[IMPLOT_NUM_X_AXES] = {false};
    bool x_held[IMPLOT_NUM_X_AXES]  = {false};
    bool x_hov[IMPLOT_NUM_X_AXES]   = {false};

    bool y_click[IMPLOT_NUM_Y_AXES] = {false};
    bool y_held[IMPLOT_NUM_Y_AXES]  = {false};
    bool y_hov[IMPLOT_NUM_Y_AXES]   = {false};

    for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i) {
        ImPlotAxis& xax = plot.XAxis(i);
        if (xax.Enabled) {
            ImGui::KeepAliveID(xax.ID);
            x_click[i]  = ImGui::ButtonBehavior(xax.HoverRect,xax.ID,&xax.Hovered,&xax.Held,axis_button_flags);
            if (x_click[i] && IO.MouseDoubleClicked[gp.InputMap.Fit])
                plot.FitThisFrame = xax.FitThisFrame = true;
            xax.Held  = xax.Held && can_pan;
            x_hov[i]  = xax.Hovered || plot.Hovered;
            x_held[i] = xax.Held    || plot.Held;
        }
    }

    for (int i = 0; i < IMPLOT_NUM_Y_AXES; ++i) {
        ImPlotAxis& yax = plot.YAxis(i);
        if (yax.Enabled) {
            ImGui::KeepAliveID(yax.ID);
            y_click[i]  = ImGui::ButtonBehavior(yax.HoverRect,yax.ID,&yax.Hovered,&yax.Held,axis_button_flags);
            if (y_click[i] && IO.MouseDoubleClicked[gp.InputMap.Fit])
                plot.FitThisFrame = yax.FitThisFrame = true;
            yax.Held  = yax.Held && can_pan;
            y_hov[i]  = yax.Hovered || plot.Hovered;
            y_held[i] = yax.Held    || plot.Held;
        }
    }

    // cancel due to DND activity
    if (GImGui->DragDropActive || (IO.KeyMods == gp.InputMap.OverrideMod && gp.InputMap.OverrideMod != 0))
        return false;

    // STATE -------------------------------------------------------------------

    const bool axis_equal      = ImHasFlag(plot.Flags, ImPlotFlags_Equal);

    const bool any_x_hov       = plot.Hovered || AnyAxesHovered(&plot.Axes[ImAxis_X1], IMPLOT_NUM_X_AXES);
    const bool any_x_held      = plot.Held    || AnyAxesHeld(&plot.Axes[ImAxis_X1], IMPLOT_NUM_X_AXES);
    const bool any_y_hov       = plot.Hovered || AnyAxesHovered(&plot.Axes[ImAxis_Y1], IMPLOT_NUM_Y_AXES);
    const bool any_y_held      = plot.Held    || AnyAxesHeld(&plot.Axes[ImAxis_Y1], IMPLOT_NUM_Y_AXES);
    const bool any_hov         = any_x_hov    || any_y_hov;
    const bool any_held        = any_x_held   || any_y_held;

    const ImVec2 select_drag   = ImGui::GetMouseDragDelta(gp.InputMap.Select);
    const ImVec2 pan_drag      = ImGui::GetMouseDragDelta(gp.InputMap.Pan);
    const float select_drag_sq = ImLengthSqr(select_drag);
    const float pan_drag_sq    = ImLengthSqr(pan_drag);
    const bool selecting       = plot.Selecting && select_drag_sq > MOUSE_CURSOR_DRAG_THRESHOLD;
    const bool panning         = any_held       && pan_drag_sq    > MOUSE_CURSOR_DRAG_THRESHOLD;

    // CONTEXT MENU -----------------------------------------------------------

    if (IO.MouseReleased[gp.InputMap.Menu] && !plot.ContextLocked)
        gp.OpenContextThisFrame = true;

    if (selecting || panning)
        plot.ContextLocked = true;
    else if (!(IO.MouseDown[gp.InputMap.Menu] || IO.MouseReleased[gp.InputMap.Menu]))
        plot.ContextLocked = false;

    // DRAG INPUT -------------------------------------------------------------

    if (any_held && !plot.Selecting) {
        int drag_direction = 0;
        for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
            ImPlotAxis& x_axis = plot.XAxis(i);
            if (x_held[i] && !x_axis.IsInputLocked()) {
                drag_direction |= (1 << 1);
                bool increasing = x_axis.IsInverted() ? IO.MouseDelta.x > 0 : IO.MouseDelta.x < 0;
                if (IO.MouseDelta.x != 0 && !x_axis.IsPanLocked(increasing)) {
                    const double plot_l = x_axis.PixelsToPlot(plot.PlotRect.Min.x - IO.MouseDelta.x);
                    const double plot_r = x_axis.PixelsToPlot(plot.PlotRect.Max.x - IO.MouseDelta.x);
                    x_axis.SetMin(x_axis.IsInverted() ? plot_r : plot_l);
                    x_axis.SetMax(x_axis.IsInverted() ? plot_l : plot_r);
                    if (axis_equal && x_axis.OrthoAxis != nullptr)
                        x_axis.OrthoAxis->SetAspect(x_axis.GetAspect());
                    changed = true;
                }
            }
        }
        for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
            ImPlotAxis& y_axis = plot.YAxis(i);
            if (y_held[i] && !y_axis.IsInputLocked()) {
                drag_direction |= (1 << 2);
                bool increasing = y_axis.IsInverted() ? IO.MouseDelta.y < 0 : IO.MouseDelta.y > 0;
                if (IO.MouseDelta.y != 0 && !y_axis.IsPanLocked(increasing)) {
                    const double plot_t = y_axis.PixelsToPlot(plot.PlotRect.Min.y - IO.MouseDelta.y);
                    const double plot_b = y_axis.PixelsToPlot(plot.PlotRect.Max.y - IO.MouseDelta.y);
                    y_axis.SetMin(y_axis.IsInverted() ? plot_t : plot_b);
                    y_axis.SetMax(y_axis.IsInverted() ? plot_b : plot_t);
                    if (axis_equal && y_axis.OrthoAxis != nullptr)
                        y_axis.OrthoAxis->SetAspect(y_axis.GetAspect());
                    changed = true;
                }
            }
        }
        if (IO.MouseDragMaxDistanceSqr[gp.InputMap.Pan] > MOUSE_CURSOR_DRAG_THRESHOLD) {
            switch (drag_direction) {
                case 0        : ImGui::SetMouseCursor(ImGuiMouseCursor_NotAllowed); break;
                case (1 << 1) : ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);   break;
                case (1 << 2) : ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNS);   break;
                default       : ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeAll);  break;
            }
        }
    }

    // SCROLL INPUT -----------------------------------------------------------

    if (any_hov && IO.MouseWheel != 0 && ImHasFlag(IO.KeyMods, gp.InputMap.ZoomMod)) {

        float zoom_rate = gp.InputMap.ZoomRate;
        if (IO.MouseWheel > 0)
            zoom_rate = (-zoom_rate) / (1.0f + (2.0f * zoom_rate));
        ImVec2 rect_size = plot.PlotRect.GetSize();
        float tx = ImRemap(IO.MousePos.x, plot.PlotRect.Min.x, plot.PlotRect.Max.x, 0.0f, 1.0f);
        float ty = ImRemap(IO.MousePos.y, plot.PlotRect.Min.y, plot.PlotRect.Max.y, 0.0f, 1.0f);

        for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
            ImPlotAxis& x_axis = plot.XAxis(i);
            const bool equal_zoom   = axis_equal && x_axis.OrthoAxis != nullptr;
            const bool equal_locked = (equal_zoom != false) && x_axis.OrthoAxis->IsInputLocked();
            if (x_hov[i] && !x_axis.IsInputLocked() && !equal_locked) {
                float correction = (plot.Hovered && equal_zoom) ? 0.5f : 1.0f;
                const double plot_l = x_axis.PixelsToPlot(plot.PlotRect.Min.x - rect_size.x * tx * zoom_rate * correction);
                const double plot_r = x_axis.PixelsToPlot(plot.PlotRect.Max.x + rect_size.x * (1 - tx) * zoom_rate * correction);
                x_axis.SetMin(x_axis.IsInverted() ? plot_r : plot_l);
                x_axis.SetMax(x_axis.IsInverted() ? plot_l : plot_r);
                if (axis_equal && x_axis.OrthoAxis != nullptr)
                    x_axis.OrthoAxis->SetAspect(x_axis.GetAspect());
                changed = true;
            }
        }
        for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
            ImPlotAxis& y_axis = plot.YAxis(i);
            const bool equal_zoom   = axis_equal && y_axis.OrthoAxis != nullptr;
            const bool equal_locked = equal_zoom && y_axis.OrthoAxis->IsInputLocked();
            if (y_hov[i] && !y_axis.IsInputLocked() && !equal_locked) {
                float correction = (plot.Hovered && equal_zoom) ? 0.5f : 1.0f;
                const double plot_t = y_axis.PixelsToPlot(plot.PlotRect.Min.y - rect_size.y * ty * zoom_rate * correction);
                const double plot_b = y_axis.PixelsToPlot(plot.PlotRect.Max.y + rect_size.y * (1 - ty) * zoom_rate * correction);
                y_axis.SetMin(y_axis.IsInverted() ? plot_t : plot_b);
                y_axis.SetMax(y_axis.IsInverted() ? plot_b : plot_t);
                if (axis_equal && y_axis.OrthoAxis != nullptr)
                    y_axis.OrthoAxis->SetAspect(y_axis.GetAspect());
                changed = true;
            }
        }
    }

    // BOX-SELECTION ----------------------------------------------------------

    if (plot.Selecting) {
        const ImVec2 d = plot.SelectStart - IO.MousePos;
        const bool x_can_change = !ImHasFlag(IO.KeyMods,gp.InputMap.SelectHorzMod) && ImFabs(d.x) > 2;
        const bool y_can_change = !ImHasFlag(IO.KeyMods,gp.InputMap.SelectVertMod) && ImFabs(d.y) > 2;
        // confirm
        if (IO.MouseReleased[gp.InputMap.Select]) {
            for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
                ImPlotAxis& x_axis = plot.XAxis(i);
                if (!x_axis.IsInputLocked() && x_can_change) {
                    const double p1 = x_axis.PixelsToPlot(plot.SelectStart.x);
                    const double p2 = x_axis.PixelsToPlot(IO.MousePos.x);
                    x_axis.SetMin(ImMin(p1, p2));
                    x_axis.SetMax(ImMax(p1, p2));
                    changed = true;
                }
            }
            for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
                ImPlotAxis& y_axis = plot.YAxis(i);
                if (!y_axis.IsInputLocked() && y_can_change) {
                    const double p1 = y_axis.PixelsToPlot(plot.SelectStart.y);
                    const double p2 = y_axis.PixelsToPlot(IO.MousePos.y);
                    y_axis.SetMin(ImMin(p1, p2));
                    y_axis.SetMax(ImMax(p1, p2));
                    changed = true;
                }
            }
            if (x_can_change || y_can_change || (ImHasFlag(IO.KeyMods,gp.InputMap.SelectHorzMod) && ImHasFlag(IO.KeyMods,gp.InputMap.SelectVertMod)))
                gp.OpenContextThisFrame = false;
            plot.Selected = plot.Selecting = false;
        }
        // cancel
        else if (IO.MouseReleased[gp.InputMap.SelectCancel]) {
            plot.Selected = plot.Selecting = false;
            gp.OpenContextThisFrame = false;
        }
        else if (ImLengthSqr(d) > BOX_SELECT_DRAG_THRESHOLD) {
            // bad selection
            if (plot.IsInputLocked()) {
                ImGui::SetMouseCursor(ImGuiMouseCursor_NotAllowed);
                gp.OpenContextThisFrame = false;
                plot.Selected      = false;
            }
            else {
                // TODO: Handle only min or max locked cases
                const bool full_width  = ImHasFlag(IO.KeyMods, gp.InputMap.SelectHorzMod) || AllAxesInputLocked(&plot.Axes[ImAxis_X1], IMPLOT_NUM_X_AXES);
                const bool full_height = ImHasFlag(IO.KeyMods, gp.InputMap.SelectVertMod) || AllAxesInputLocked(&plot.Axes[ImAxis_Y1], IMPLOT_NUM_Y_AXES);
                plot.SelectRect.Min.x = full_width  ? plot.PlotRect.Min.x : ImMin(plot.SelectStart.x, IO.MousePos.x);
                plot.SelectRect.Max.x = full_width  ? plot.PlotRect.Max.x : ImMax(plot.SelectStart.x, IO.MousePos.x);
                plot.SelectRect.Min.y = full_height ? plot.PlotRect.Min.y : ImMin(plot.SelectStart.y, IO.MousePos.y);
                plot.SelectRect.Max.y = full_height ? plot.PlotRect.Max.y : ImMax(plot.SelectStart.y, IO.MousePos.y);
                plot.SelectRect.Min  -= plot.PlotRect.Min;
                plot.SelectRect.Max  -= plot.PlotRect.Min;
                plot.Selected = true;
            }
        }
        else {
            plot.Selected = false;
        }
    }
    return changed;
}

//-----------------------------------------------------------------------------
// Next Plot Data (Legacy)
//-----------------------------------------------------------------------------

void ApplyNextPlotData(ImAxis idx) {
    ImPlotContext& gp = *GImPlot;
    ImPlotPlot& plot  = *gp.CurrentPlot;
    ImPlotAxis& axis  = plot.Axes[idx];
    if (!axis.Enabled)
        return;
    double*     npd_lmin = gp.NextPlotData.LinkedMin[idx];
    double*     npd_lmax = gp.NextPlotData.LinkedMax[idx];
    bool        npd_rngh = gp.NextPlotData.HasRange[idx];
    ImPlotCond  npd_rngc = gp.NextPlotData.RangeCond[idx];
    ImPlotRange     npd_rngv = gp.NextPlotData.Range[idx];
    axis.LinkedMin = npd_lmin;
    axis.LinkedMax = npd_lmax;
    axis.PullLinks();
    if (npd_rngh) {
        if (!plot.Initialized || npd_rngc == ImPlotCond_Always)
            axis.SetRange(npd_rngv);
    }
    axis.HasRange         = npd_rngh;
    axis.RangeCond        = npd_rngc;
}

//-----------------------------------------------------------------------------
// Setup
//-----------------------------------------------------------------------------

void SetupAxis(ImAxis idx, const char* label, ImPlotAxisFlags flags) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                         "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    // get plot and axis
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    // set ID
    axis.ID = plot.ID + idx + 1;
    // check and set flags
    if (plot.JustCreated || flags != axis.PreviousFlags)
        axis.Flags = flags;
    axis.PreviousFlags = flags;
    // enable axis
    axis.Enabled = true;
    // set label
    plot.SetAxisLabel(axis,label);
    // cache colors
    UpdateAxisColors(axis);
}

void SetupAxisLimits(ImAxis idx, double min_lim, double max_lim, ImPlotCond cond) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                         "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");    // get plot and axis
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    if (!plot.Initialized || cond == ImPlotCond_Always)
        axis.SetRange(min_lim, max_lim);
    axis.HasRange  = true;
    axis.RangeCond = cond;
}

void SetupAxisFormat(ImAxis idx, const char* fmt) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                         "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    axis.HasFormatSpec = fmt != nullptr;
    if (fmt != nullptr)
        ImStrncpy(axis.FormatSpec,fmt,sizeof(axis.FormatSpec));
}

void SetupAxisLinks(ImAxis idx, double* min_lnk, double* max_lnk) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                         "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    axis.LinkedMin = min_lnk;
    axis.LinkedMax = max_lnk;
    axis.PullLinks();
}

void SetupAxisFormat(ImAxis idx, ImPlotFormatter formatter, void* data) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                         "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    axis.Formatter = formatter;
    axis.FormatterData = data;
}

void SetupAxisTicks(ImAxis idx, const double* values, int n_ticks, const char* const labels[], bool show_default) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                        "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    axis.ShowDefaultTicks = show_default;
    AddTicksCustom(values,
                  labels,
                  n_ticks,
                  axis.Ticker,
                  axis.Formatter ? axis.Formatter : Formatter_Default,
                  (axis.Formatter && axis.FormatterData) ? axis.FormatterData : axis.HasFormatSpec ? axis.FormatSpec : (void*)IMPLOT_LABEL_FORMAT);
}

void SetupAxisTicks(ImAxis idx, double v_min, double v_max, int n_ticks, const char* const labels[], bool show_default) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                         "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    n_ticks = n_ticks < 2 ? 2 : n_ticks;
    FillRange(gp.TempDouble1, n_ticks, v_min, v_max);
    SetupAxisTicks(idx, gp.TempDouble1.Data, n_ticks, labels, show_default);
}

void SetupAxisScale(ImAxis idx, ImPlotScale scale) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                        "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    axis.Scale = scale;
    switch (scale)
    {
    case ImPlotScale_Time:
        axis.TransformForward = nullptr;
        axis.TransformInverse = nullptr;
        axis.TransformData    = nullptr;
        axis.Locator          = Locator_Time;
        axis.ConstraintRange  = ImPlotRange(IMPLOT_MIN_TIME, IMPLOT_MAX_TIME);
        axis.Ticker.Levels    = 2;
        break;
    case ImPlotScale_Log10:
        axis.TransformForward = TransformForward_Log10;
        axis.TransformInverse = TransformInverse_Log10;
        axis.TransformData    = nullptr;
        axis.Locator          = Locator_Log10;
        axis.ConstraintRange  = ImPlotRange(DBL_MIN, INFINITY);
        break;
    case ImPlotScale_SymLog:
        axis.TransformForward = TransformForward_SymLog;
        axis.TransformInverse = TransformInverse_SymLog;
        axis.TransformData    = nullptr;
        axis.Locator          = Locator_SymLog;
        axis.ConstraintRange  = ImPlotRange(-INFINITY, INFINITY);
        break;
    default:
        axis.TransformForward = nullptr;
        axis.TransformInverse = nullptr;
        axis.TransformData    = nullptr;
        axis.Locator          = nullptr;
        axis.ConstraintRange  = ImPlotRange(-INFINITY, INFINITY);
        break;
    }
}

void SetupAxisScale(ImAxis idx, ImPlotTransform fwd, ImPlotTransform inv, void* data) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                        "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    axis.Scale = IMPLOT_AUTO;
    axis.TransformForward = fwd;
    axis.TransformInverse = inv;
    axis.TransformData = data;
}

void SetupAxisLimitsConstraints(ImAxis idx, double v_min, double v_max) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                        "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    axis.ConstraintRange.Min = v_min;
    axis.ConstraintRange.Max = v_max;
}

void SetupAxisZoomConstraints(ImAxis idx, double z_min, double z_max) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                        "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& axis = plot.Axes[idx];
    IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    axis.ConstraintZoom.Min = z_min;
    axis.ConstraintZoom.Max = z_max;
}

void SetupAxes(const char* x_label, const char* y_label, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags) {
    SetupAxis(ImAxis_X1, x_label, x_flags);
    SetupAxis(ImAxis_Y1, y_label, y_flags);
}

void SetupAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond) {
    SetupAxisLimits(ImAxis_X1, x_min, x_max, cond);
    SetupAxisLimits(ImAxis_Y1, y_min, y_max, cond);
}

void SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                         "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    IM_ASSERT_USER_ERROR(gp.CurrentItems != nullptr,
                         "SetupLegend() needs to be called within an itemized context!");
    ImPlotLegend& legend = gp.CurrentItems->Legend;
    // check and set location
    if (location != legend.PreviousLocation)
        legend.Location = location;
    legend.PreviousLocation = location;
    // check and set flags
    if (flags != legend.PreviousFlags)
        legend.Flags = flags;
    legend.PreviousFlags = flags;
}

void SetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
                         "Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
    gp.CurrentPlot->MouseTextLocation = location;
    gp.CurrentPlot->MouseTextFlags = flags;
}

//-----------------------------------------------------------------------------
// SetNext
//-----------------------------------------------------------------------------

void SetNextAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot == nullptr, "SetNextAxisLimits() needs to be called before BeginPlot()!");
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    gp.NextPlotData.HasRange[axis]  = true;
    gp.NextPlotData.RangeCond[axis] = cond;
    gp.NextPlotData.Range[axis].Min = v_min;
    gp.NextPlotData.Range[axis].Max = v_max;
}

void SetNextAxisLinks(ImAxis axis, double* link_min, double* link_max) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot == nullptr, "SetNextAxisLinks() needs to be called before BeginPlot()!");
    gp.NextPlotData.LinkedMin[axis] = link_min;
    gp.NextPlotData.LinkedMax[axis] = link_max;
}

void SetNextAxisToFit(ImAxis axis) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot == nullptr, "SetNextAxisToFit() needs to be called before BeginPlot()!");
    gp.NextPlotData.Fit[axis] = true;
}

void SetNextAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond) {
    SetNextAxisLimits(ImAxis_X1, x_min, x_max, cond);
    SetNextAxisLimits(ImAxis_Y1, y_min, y_max, cond);
}

void SetNextAxesToFit() {
    for (int i = 0; i < ImAxis_COUNT; ++i)
        SetNextAxisToFit(i);
}

//-----------------------------------------------------------------------------
// BeginPlot
//-----------------------------------------------------------------------------

bool BeginPlot(const char* title_id, const ImVec2& size, ImPlotFlags flags) {
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot == nullptr, "Mismatched BeginPlot()/EndPlot()!");

    // FRONT MATTER -----------------------------------------------------------

    if (gp.CurrentSubplot != nullptr)
        ImGui::PushID(gp.CurrentSubplot->CurrentIdx);

    // get globals
    ImGuiContext &G          = *GImGui;
    ImGuiWindow* Window      = G.CurrentWindow;

    // skip if needed
    if (Window->SkipItems && !gp.CurrentSubplot) {
        ResetCtxForNextPlot(GImPlot);
        return false;
    }

    // ID and age (TODO: keep track of plot age in frames)
    const ImGuiID ID         = Window->GetID(title_id);
    const bool just_created  = gp.Plots.GetByKey(ID) == nullptr;
    gp.CurrentPlot           = gp.Plots.GetOrAddByKey(ID);

    ImPlotPlot &plot         = *gp.CurrentPlot;
    plot.ID                  = ID;
    plot.Items.ID            = ID - 1;
    plot.JustCreated         = just_created;
    plot.SetupLocked         = false;

    // check flags
    if (plot.JustCreated)
        plot.Flags = flags;
    else if (flags != plot.PreviousFlags)
        plot.Flags = flags;
    plot.PreviousFlags = flags;

    // setup default axes
    if (plot.JustCreated) {
        SetupAxis(ImAxis_X1);
        SetupAxis(ImAxis_Y1);
    }

    // reset axes
    for (int i = 0; i < ImAxis_COUNT; ++i) {
        plot.Axes[i].Reset();
        UpdateAxisColors(plot.Axes[i]);
    }
    // ensure first axes enabled
    plot.Axes[ImAxis_X1].Enabled = true;
    plot.Axes[ImAxis_Y1].Enabled = true;
    // set initial axes
    plot.CurrentX = ImAxis_X1;
    plot.CurrentY = ImAxis_Y1;

    // process next plot data (legacy)
    for (int i = 0; i < ImAxis_COUNT; ++i)
        ApplyNextPlotData(i);

    // capture scroll with a child region
    if (!ImHasFlag(plot.Flags, ImPlotFlags_NoChild)) {
        ImVec2 child_size;
        if (gp.CurrentSubplot != nullptr)
            child_size = gp.CurrentSubplot->CellSize;
        else
            child_size = ImVec2(size.x == 0 ? gp.Style.PlotDefaultSize.x : size.x, size.y == 0 ? gp.Style.PlotDefaultSize.y : size.y);
        ImGui::BeginChild(title_id, child_size, false, ImGuiWindowFlags_NoScrollbar);
        Window = ImGui::GetCurrentWindow();
        Window->ScrollMax.y = 1.0f;
        gp.ChildWindowMade = true;
    }
    else {
        gp.ChildWindowMade = false;
    }

    // clear text buffers
    plot.ClearTextBuffer();
    plot.SetTitle(title_id);

    // set frame size
    ImVec2 frame_size;
    if (gp.CurrentSubplot != nullptr)
        frame_size = gp.CurrentSubplot->CellSize;
    else
        frame_size = ImGui::CalcItemSize(size, gp.Style.PlotDefaultSize.x, gp.Style.PlotDefaultSize.y);

    if (frame_size.x < gp.Style.PlotMinSize.x && (size.x < 0.0f || gp.CurrentSubplot != nullptr))
        frame_size.x = gp.Style.PlotMinSize.x;
    if (frame_size.y < gp.Style.PlotMinSize.y && (size.y < 0.0f || gp.CurrentSubplot != nullptr))
        frame_size.y = gp.Style.PlotMinSize.y;

    plot.FrameRect = ImRect(Window->DC.CursorPos, Window->DC.CursorPos + frame_size);
    ImGui::ItemSize(plot.FrameRect);
    if (!ImGui::ItemAdd(plot.FrameRect, plot.ID, &plot.FrameRect) && !gp.CurrentSubplot) {
        ResetCtxForNextPlot(GImPlot);
        return false;
    }

    // setup items (or dont)
    if (gp.CurrentItems == nullptr)
        gp.CurrentItems = &plot.Items;

    return true;
}

//-----------------------------------------------------------------------------
// SetupFinish
//-----------------------------------------------------------------------------

void SetupFinish() {
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "SetupFinish needs to be called after BeginPlot!");

    ImGuiContext& G         = *GImGui;
    ImDrawList& DrawList    = *G.CurrentWindow->DrawList;
    const ImGuiStyle& Style = G.Style;

    ImPlotPlot &plot  = *gp.CurrentPlot;

    // lock setup
    plot.SetupLocked = true;

    // finalize axes and set default formatter/locator
    for (int i = 0; i < ImAxis_COUNT; ++i) {
        ImPlotAxis& axis = plot.Axes[i];
        if (axis.Enabled) {
            axis.Constrain();
            if (!plot.Initialized && axis.CanInitFit())
                plot.FitThisFrame = axis.FitThisFrame = true;
        }
        if (axis.Formatter == nullptr) {
            axis.Formatter = Formatter_Default;
            if (axis.HasFormatSpec)
                axis.FormatterData = axis.FormatSpec;
            else
                axis.FormatterData = (void*)IMPLOT_LABEL_FORMAT;
        }
        if (axis.Locator == nullptr) {
            axis.Locator = Locator_Default;
        }
    }

    // setup nullptr orthogonal axes
    const bool axis_equal = ImHasFlag(plot.Flags, ImPlotFlags_Equal);
    for (int ix = ImAxis_X1, iy = ImAxis_Y1; ix < ImAxis_Y1 || iy < ImAxis_COUNT; ++ix, ++iy) {
        ImPlotAxis& x_axis = plot.Axes[ix];
        ImPlotAxis& y_axis = plot.Axes[iy];
        if (x_axis.Enabled && y_axis.Enabled) {
            if (x_axis.OrthoAxis == nullptr)
                x_axis.OrthoAxis = &y_axis;
            if (y_axis.OrthoAxis == nullptr)
                y_axis.OrthoAxis = &x_axis;
        }
        else if (x_axis.Enabled)
        {
            if (x_axis.OrthoAxis == nullptr && !axis_equal)
                x_axis.OrthoAxis = &plot.Axes[ImAxis_Y1];
        }
        else if (y_axis.Enabled) {
            if (y_axis.OrthoAxis == nullptr && !axis_equal)
                y_axis.OrthoAxis = &plot.Axes[ImAxis_X1];
        }
    }

    // canvas/axes bb
    plot.CanvasRect = ImRect(plot.FrameRect.Min + gp.Style.PlotPadding, plot.FrameRect.Max - gp.Style.PlotPadding);
    plot.AxesRect   = plot.FrameRect;

    // outside legend adjustments
    if (!ImHasFlag(plot.Flags, ImPlotFlags_NoLegend) && plot.Items.GetLegendCount() > 0 && ImHasFlag(plot.Items.Legend.Flags, ImPlotLegendFlags_Outside)) {
        ImPlotLegend& legend = plot.Items.Legend;
        const bool horz = ImHasFlag(legend.Flags, ImPlotLegendFlags_Horizontal);
        const ImVec2 legend_size = CalcLegendSize(plot.Items, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, !horz);
        const bool west = ImHasFlag(legend.Location, ImPlotLocation_West) && !ImHasFlag(legend.Location, ImPlotLocation_East);
        const bool east = ImHasFlag(legend.Location, ImPlotLocation_East) && !ImHasFlag(legend.Location, ImPlotLocation_West);
        const bool north = ImHasFlag(legend.Location, ImPlotLocation_North) && !ImHasFlag(legend.Location, ImPlotLocation_South);
        const bool south = ImHasFlag(legend.Location, ImPlotLocation_South) && !ImHasFlag(legend.Location, ImPlotLocation_North);
        if ((west && !horz) || (west && horz && !north && !south)) {
            plot.CanvasRect.Min.x += (legend_size.x + gp.Style.LegendPadding.x);
            plot.AxesRect.Min.x   += (legend_size.x + gp.Style.PlotPadding.x);
        }
        if ((east && !horz) || (east && horz && !north && !south)) {
            plot.CanvasRect.Max.x -= (legend_size.x + gp.Style.LegendPadding.x);
            plot.AxesRect.Max.x   -= (legend_size.x + gp.Style.PlotPadding.x);
        }
        if ((north && horz) || (north && !horz && !west && !east)) {
            plot.CanvasRect.Min.y += (legend_size.y + gp.Style.LegendPadding.y);
            plot.AxesRect.Min.y   += (legend_size.y + gp.Style.PlotPadding.y);
        }
        if ((south && horz) || (south && !horz && !west && !east)) {
            plot.CanvasRect.Max.y -= (legend_size.y + gp.Style.LegendPadding.y);
            plot.AxesRect.Max.y   -= (legend_size.y + gp.Style.PlotPadding.y);
        }
    }

    // plot bb
    float pad_top = 0, pad_bot = 0, pad_left = 0, pad_right = 0;

    // (0) calc top padding form title
    ImVec2 title_size(0.0f, 0.0f);
    if (plot.HasTitle())
         title_size = ImGui::CalcTextSize(plot.GetTitle(), nullptr, true);
    if (title_size.x > 0) {
        pad_top += title_size.y + gp.Style.LabelPadding.y;
        plot.AxesRect.Min.y += gp.Style.PlotPadding.y + pad_top;
    }

    // (1) calc addition top padding and bot padding
    PadAndDatumAxesX(plot,pad_top,pad_bot,gp.CurrentAlignmentH);

    const float plot_height = plot.CanvasRect.GetHeight() - pad_top - pad_bot;

    // (2) get y tick labels (needed for left/right pad)
    for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
        ImPlotAxis& axis = plot.YAxis(i);
        if (axis.WillRender() && axis.ShowDefaultTicks) {
            axis.Locator(axis.Ticker, axis.Range, plot_height, true, axis.Formatter, axis.FormatterData);
        }
    }

    // (3) calc left/right pad
    PadAndDatumAxesY(plot,pad_left,pad_right,gp.CurrentAlignmentV);

    const float plot_width = plot.CanvasRect.GetWidth() - pad_left - pad_right;

    // (4) get x ticks
    for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
        ImPlotAxis& axis = plot.XAxis(i);
        if (axis.WillRender() && axis.ShowDefaultTicks) {
            axis.Locator(axis.Ticker, axis.Range, plot_width, false, axis.Formatter, axis.FormatterData);
        }
    }

    // (5) calc plot bb
    plot.PlotRect = ImRect(plot.CanvasRect.Min + ImVec2(pad_left, pad_top), plot.CanvasRect.Max - ImVec2(pad_right, pad_bot));

    // HOVER------------------------------------------------------------

    // axes hover rect, pixel ranges
    for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i) {
        ImPlotAxis& xax = plot.XAxis(i);
        xax.HoverRect   = ImRect(ImVec2(plot.PlotRect.Min.x, ImMin(xax.Datum1,xax.Datum2)),
                                 ImVec2(plot.PlotRect.Max.x, ImMax(xax.Datum1,xax.Datum2)));
        xax.PixelMin    = xax.IsInverted() ? plot.PlotRect.Max.x : plot.PlotRect.Min.x;
        xax.PixelMax    = xax.IsInverted() ? plot.PlotRect.Min.x : plot.PlotRect.Max.x;
        xax.UpdateTransformCache();
    }

    for (int i = 0; i < IMPLOT_NUM_Y_AXES; ++i) {
        ImPlotAxis& yax = plot.YAxis(i);
        yax.HoverRect   = ImRect(ImVec2(ImMin(yax.Datum1,yax.Datum2),plot.PlotRect.Min.y),
                                 ImVec2(ImMax(yax.Datum1,yax.Datum2),plot.PlotRect.Max.y));
        yax.PixelMin    = yax.IsInverted() ? plot.PlotRect.Min.y : plot.PlotRect.Max.y;
        yax.PixelMax    = yax.IsInverted() ? plot.PlotRect.Max.y : plot.PlotRect.Min.y;
        yax.UpdateTransformCache();
    }
    // Equal axis constraint. Must happen after we set Pixels
    // constrain equal axes for primary x and y if not approximately equal
    // constrains x to y since x pixel size depends on y labels width, and causes feedback loops in opposite case
    if (axis_equal) {
        for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i) {
            ImPlotAxis& x_axis = plot.XAxis(i);
            if (x_axis.OrthoAxis == nullptr)
                continue;
            double xar = x_axis.GetAspect();
            double yar = x_axis.OrthoAxis->GetAspect();
            // edge case: user has set x range this frame, so fit y to x so that we honor their request for x range
            // NB: because of feedback across several frames, the user's x request may not be perfectly honored
            if (x_axis.HasRange)
                x_axis.OrthoAxis->SetAspect(xar);
            else if (!ImAlmostEqual(xar,yar) && !x_axis.OrthoAxis->IsInputLocked())
                 x_axis.SetAspect(yar);
        }
    }

    // INPUT ------------------------------------------------------------------
    if (!ImHasFlag(plot.Flags, ImPlotFlags_NoInputs))
        UpdateInput(plot);

    // fit from FitNextPlotAxes or auto fit
    for (int i = 0; i < ImAxis_COUNT; ++i) {
        if (gp.NextPlotData.Fit[i] || plot.Axes[i].IsAutoFitting()) {
            plot.FitThisFrame = true;
            plot.Axes[i].FitThisFrame = true;
        }
    }

    // RENDER -----------------------------------------------------------------

    const float txt_height = ImGui::GetTextLineHeight();

    // render frame
    if (!ImHasFlag(plot.Flags, ImPlotFlags_NoFrame))
        ImGui::RenderFrame(plot.FrameRect.Min, plot.FrameRect.Max, GetStyleColorU32(ImPlotCol_FrameBg), true, Style.FrameRounding);

    // grid bg
    DrawList.AddRectFilled(plot.PlotRect.Min, plot.PlotRect.Max, GetStyleColorU32(ImPlotCol_PlotBg));

    // transform ticks
    for (int i = 0; i < ImAxis_COUNT; i++) {
        ImPlotAxis& axis = plot.Axes[i];
        if (axis.WillRender()) {
            for (int t = 0; t < axis.Ticker.TickCount(); t++) {
                ImPlotTick& tk = axis.Ticker.Ticks[t];
                tk.PixelPos = IM_ROUND(axis.PlotToPixels(tk.PlotPos));
            }
        }
    }

    // render grid (background)
    for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
        ImPlotAxis& x_axis = plot.XAxis(i);
        if (x_axis.Enabled && x_axis.HasGridLines() && !x_axis.IsForeground())
            RenderGridLinesX(DrawList, x_axis.Ticker, plot.PlotRect, x_axis.ColorMaj, x_axis.ColorMin, gp.Style.MajorGridSize.x, gp.Style.MinorGridSize.x);
    }
    for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
        ImPlotAxis& y_axis = plot.YAxis(i);
        if (y_axis.Enabled && y_axis.HasGridLines() && !y_axis.IsForeground())
            RenderGridLinesY(DrawList, y_axis.Ticker, plot.PlotRect,  y_axis.ColorMaj, y_axis.ColorMin, gp.Style.MajorGridSize.y, gp.Style.MinorGridSize.y);
    }

    // render x axis button, label, tick labels
    for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
        ImPlotAxis& ax = plot.XAxis(i);
        if (!ax.Enabled)
            continue;
        if ((ax.Hovered || ax.Held) && !plot.Held && !ImHasFlag(ax.Flags, ImPlotAxisFlags_NoHighlight))
            DrawList.AddRectFilled(ax.HoverRect.Min, ax.HoverRect.Max, ax.Held ? ax.ColorAct : ax.ColorHov);
        else if (ax.ColorHiLi != IM_COL32_BLACK_TRANS) {
            DrawList.AddRectFilled(ax.HoverRect.Min, ax.HoverRect.Max, ax.ColorHiLi);
            ax.ColorHiLi = IM_COL32_BLACK_TRANS;
        }
        else if (ax.ColorBg != IM_COL32_BLACK_TRANS) {
            DrawList.AddRectFilled(ax.HoverRect.Min, ax.HoverRect.Max, ax.ColorBg);
        }
        const ImPlotTicker& tkr = ax.Ticker;
        const bool opp = ax.IsOpposite();
        if (ax.HasLabel()) {
            const char* label        = plot.GetAxisLabel(ax);
            const ImVec2 label_size  = ImGui::CalcTextSize(label);
            const float label_offset = (ax.HasTickLabels() ? tkr.MaxSize.y + gp.Style.LabelPadding.y : 0.0f)
                                     + (tkr.Levels - 1) * (txt_height + gp.Style.LabelPadding.y)
                                     + gp.Style.LabelPadding.y;
            const ImVec2 label_pos(plot.PlotRect.GetCenter().x - label_size.x * 0.5f,
                                   opp ? ax.Datum1 - label_offset - label_size.y : ax.Datum1 + label_offset);
            DrawList.AddText(label_pos, ax.ColorTxt, label);
        }
        if (ax.HasTickLabels()) {
            for (int j = 0; j < tkr.TickCount(); ++j) {
                const ImPlotTick& tk = tkr.Ticks[j];
                const float datum = ax.Datum1 + (opp ? (-gp.Style.LabelPadding.y -txt_height -tk.Level * (txt_height + gp.Style.LabelPadding.y))
                                                     : gp.Style.LabelPadding.y + tk.Level * (txt_height + gp.Style.LabelPadding.y));
                if (tk.ShowLabel && tk.PixelPos >= plot.PlotRect.Min.x - 1 && tk.PixelPos <= plot.PlotRect.Max.x + 1) {
                    ImVec2 start(tk.PixelPos - 0.5f * tk.LabelSize.x, datum);
                    DrawList.AddText(start, ax.ColorTxt, tkr.GetText(j));
                }
            }
        }
    }

    // render y axis button, label, tick labels
    for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
        ImPlotAxis& ax = plot.YAxis(i);
        if (!ax.Enabled)
            continue;
        if ((ax.Hovered || ax.Held) && !plot.Held && !ImHasFlag(ax.Flags, ImPlotAxisFlags_NoHighlight))
            DrawList.AddRectFilled(ax.HoverRect.Min, ax.HoverRect.Max, ax.Held ? ax.ColorAct : ax.ColorHov);
        else if (ax.ColorHiLi != IM_COL32_BLACK_TRANS) {
            DrawList.AddRectFilled(ax.HoverRect.Min, ax.HoverRect.Max, ax.ColorHiLi);
            ax.ColorHiLi = IM_COL32_BLACK_TRANS;
        }
        else if (ax.ColorBg != IM_COL32_BLACK_TRANS) {
            DrawList.AddRectFilled(ax.HoverRect.Min, ax.HoverRect.Max, ax.ColorBg);
        }
        const ImPlotTicker& tkr = ax.Ticker;
        const bool opp = ax.IsOpposite();
        if (ax.HasLabel()) {
            const char* label        = plot.GetAxisLabel(ax);
            const ImVec2 label_size  = CalcTextSizeVertical(label);
            const float label_offset = (ax.HasTickLabels() ? tkr.MaxSize.x + gp.Style.LabelPadding.x : 0.0f)
                                     + gp.Style.LabelPadding.x;
            const ImVec2 label_pos(opp ? ax.Datum1 + label_offset : ax.Datum1 - label_offset - label_size.x,
                                   plot.PlotRect.GetCenter().y + label_size.y * 0.5f);
            AddTextVertical(&DrawList, label_pos, ax.ColorTxt, label);
        }
        if (ax.HasTickLabels()) {
            for (int j = 0; j < tkr.TickCount(); ++j) {
                const ImPlotTick& tk = tkr.Ticks[j];
                const float datum = ax.Datum1 + (opp ? gp.Style.LabelPadding.x : (-gp.Style.LabelPadding.x - tk.LabelSize.x));
                if (tk.ShowLabel && tk.PixelPos >= plot.PlotRect.Min.y - 1 && tk.PixelPos <= plot.PlotRect.Max.y + 1) {
                    ImVec2 start(datum, tk.PixelPos - 0.5f * tk.LabelSize.y);
                    DrawList.AddText(start, ax.ColorTxt, tkr.GetText(j));
                }
            }
        }
    }


    // clear legend (TODO: put elsewhere)
    plot.Items.Legend.Reset();
    // push ID to set item hashes (NB: !!!THIS PROBABLY NEEDS TO BE IN BEGIN PLOT!!!!)
    ImGui::PushOverrideID(gp.CurrentItems->ID);
}

//-----------------------------------------------------------------------------
// EndPlot()
//-----------------------------------------------------------------------------

void EndPlot() {
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "Mismatched BeginPlot()/EndPlot()!");

    SetupLock();

    ImGuiContext &G       = *GImGui;
    ImPlotPlot &plot      = *gp.CurrentPlot;
    ImGuiWindow * Window  = G.CurrentWindow;
    ImDrawList & DrawList = *Window->DrawList;
    const ImGuiIO &   IO  = ImGui::GetIO();

    // FINAL RENDER -----------------------------------------------------------

    const bool render_border  = gp.Style.PlotBorderSize > 0 && gp.Style.Colors[ImPlotCol_PlotBorder].w > 0;
    const bool any_x_held = plot.Held    || AnyAxesHeld(&plot.Axes[ImAxis_X1], IMPLOT_NUM_X_AXES);
    const bool any_y_held = plot.Held    || AnyAxesHeld(&plot.Axes[ImAxis_Y1], IMPLOT_NUM_Y_AXES);

    ImGui::PushClipRect(plot.FrameRect.Min, plot.FrameRect.Max, true);

    // render grid (foreground)
    for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
        ImPlotAxis& x_axis = plot.XAxis(i);
        if (x_axis.Enabled && x_axis.HasGridLines() && x_axis.IsForeground())
            RenderGridLinesX(DrawList, x_axis.Ticker, plot.PlotRect, x_axis.ColorMaj, x_axis.ColorMin, gp.Style.MajorGridSize.x, gp.Style.MinorGridSize.x);
    }
    for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
        ImPlotAxis& y_axis = plot.YAxis(i);
        if (y_axis.Enabled && y_axis.HasGridLines() && y_axis.IsForeground())
            RenderGridLinesY(DrawList, y_axis.Ticker, plot.PlotRect,  y_axis.ColorMaj, y_axis.ColorMin, gp.Style.MajorGridSize.y, gp.Style.MinorGridSize.y);
    }


    // render title
    if (plot.HasTitle()) {
        ImU32 col = GetStyleColorU32(ImPlotCol_TitleText);
        AddTextCentered(&DrawList,ImVec2(plot.PlotRect.GetCenter().x, plot.CanvasRect.Min.y),col,plot.GetTitle());
    }

    // render x ticks
    int count_B = 0, count_T = 0;
    for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
        const ImPlotAxis& ax = plot.XAxis(i);
        if (!ax.Enabled)
            continue;
        const ImPlotTicker& tkr = ax.Ticker;
        const bool opp = ax.IsOpposite();
        const bool aux = ((opp && count_T > 0)||(!opp && count_B > 0));
        if (ax.HasTickMarks()) {
            const float direction = opp ? 1.0f : -1.0f;
            for (int j = 0; j < tkr.TickCount(); ++j) {
                const ImPlotTick& tk = tkr.Ticks[j];
                if (tk.Level != 0 || tk.PixelPos < plot.PlotRect.Min.x || tk.PixelPos > plot.PlotRect.Max.x)
                    continue;
                const ImVec2 start(tk.PixelPos, ax.Datum1);
                const float len = (!aux && tk.Major) ? gp.Style.MajorTickLen.x  : gp.Style.MinorTickLen.x;
                const float thk = (!aux && tk.Major) ? gp.Style.MajorTickSize.x : gp.Style.MinorTickSize.x;
                DrawList.AddLine(start, start + ImVec2(0,direction*len), ax.ColorTick, thk);
            }
            if (aux || !render_border)
                DrawList.AddLine(ImVec2(plot.PlotRect.Min.x,ax.Datum1), ImVec2(plot.PlotRect.Max.x,ax.Datum1), ax.ColorTick, gp.Style.MinorTickSize.x);
        }
        count_B += !opp;
        count_T +=  opp;
    }

    // render y ticks
    int count_L = 0, count_R = 0;
    for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
        const ImPlotAxis& ax = plot.YAxis(i);
        if (!ax.Enabled)
            continue;
        const ImPlotTicker& tkr = ax.Ticker;
        const bool opp = ax.IsOpposite();
        const bool aux = ((opp && count_R > 0)||(!opp && count_L > 0));
        if (ax.HasTickMarks()) {
            const float direction = opp ? -1.0f : 1.0f;
            for (int j = 0; j < tkr.TickCount(); ++j) {
                const ImPlotTick& tk = tkr.Ticks[j];
                if (tk.Level != 0 || tk.PixelPos < plot.PlotRect.Min.y || tk.PixelPos > plot.PlotRect.Max.y)
                    continue;
                const ImVec2 start(ax.Datum1, tk.PixelPos);
                const float len = (!aux && tk.Major) ? gp.Style.MajorTickLen.y  : gp.Style.MinorTickLen.y;
                const float thk = (!aux && tk.Major) ? gp.Style.MajorTickSize.y : gp.Style.MinorTickSize.y;
                DrawList.AddLine(start, start + ImVec2(direction*len,0), ax.ColorTick, thk);
            }
            if (aux || !render_border)
                DrawList.AddLine(ImVec2(ax.Datum1, plot.PlotRect.Min.y), ImVec2(ax.Datum1, plot.PlotRect.Max.y), ax.ColorTick, gp.Style.MinorTickSize.y);
        }
        count_L += !opp;
        count_R +=  opp;
    }
    ImGui::PopClipRect();

    // render annotations
    PushPlotClipRect();
    for (int i = 0; i < gp.Annotations.Size; ++i) {
        const char* txt       = gp.Annotations.GetText(i);
        ImPlotAnnotation& an  = gp.Annotations.Annotations[i];
        const ImVec2 txt_size = ImGui::CalcTextSize(txt);
        const ImVec2 size     = txt_size + gp.Style.AnnotationPadding * 2;
        ImVec2 pos            = an.Pos;
        if (an.Offset.x == 0)
            pos.x -= size.x / 2;
        else if (an.Offset.x > 0)
            pos.x += an.Offset.x;
        else
            pos.x -= size.x - an.Offset.x;
        if (an.Offset.y == 0)
            pos.y -= size.y / 2;
        else if (an.Offset.y > 0)
            pos.y += an.Offset.y;
        else
            pos.y -= size.y - an.Offset.y;
        if (an.Clamp)
            pos = ClampLabelPos(pos, size, plot.PlotRect.Min, plot.PlotRect.Max);
        ImRect rect(pos,pos+size);
        if (an.Offset.x != 0 || an.Offset.y != 0) {
            ImVec2 corners[4] = {rect.GetTL(), rect.GetTR(), rect.GetBR(), rect.GetBL()};
            int min_corner = 0;
            float min_len = FLT_MAX;
            for (int c = 0; c < 4; ++c) {
                float len = ImLengthSqr(an.Pos - corners[c]);
                if (len < min_len) {
                    min_corner = c;
                    min_len = len;
                }
            }
            DrawList.AddLine(an.Pos, corners[min_corner], an.ColorBg);
        }
        DrawList.AddRectFilled(rect.Min, rect.Max, an.ColorBg);
        DrawList.AddText(pos + gp.Style.AnnotationPadding, an.ColorFg, txt);
    }

    // render selection
    if (plot.Selected)
        RenderSelectionRect(DrawList, plot.SelectRect.Min + plot.PlotRect.Min, plot.SelectRect.Max + plot.PlotRect.Min, GetStyleColorVec4(ImPlotCol_Selection));

    // render crosshairs
    if (ImHasFlag(plot.Flags, ImPlotFlags_Crosshairs) && plot.Hovered && !(any_x_held || any_y_held) && !plot.Selecting && !plot.Items.Legend.Hovered) {
        ImGui::SetMouseCursor(ImGuiMouseCursor_None);
        ImVec2 xy = IO.MousePos;
        ImVec2 h1(plot.PlotRect.Min.x, xy.y);
        ImVec2 h2(xy.x - 5, xy.y);
        ImVec2 h3(xy.x + 5, xy.y);
        ImVec2 h4(plot.PlotRect.Max.x, xy.y);
        ImVec2 v1(xy.x, plot.PlotRect.Min.y);
        ImVec2 v2(xy.x, xy.y - 5);
        ImVec2 v3(xy.x, xy.y + 5);
        ImVec2 v4(xy.x, plot.PlotRect.Max.y);
        ImU32 col = GetStyleColorU32(ImPlotCol_Crosshairs);
        DrawList.AddLine(h1, h2, col);
        DrawList.AddLine(h3, h4, col);
        DrawList.AddLine(v1, v2, col);
        DrawList.AddLine(v3, v4, col);
    }

    // render mouse pos
    if (!ImHasFlag(plot.Flags, ImPlotFlags_NoMouseText) && (plot.Hovered || ImHasFlag(plot.MouseTextFlags, ImPlotMouseTextFlags_ShowAlways))) {

        const bool no_aux = ImHasFlag(plot.MouseTextFlags, ImPlotMouseTextFlags_NoAuxAxes);
        const bool no_fmt = ImHasFlag(plot.MouseTextFlags, ImPlotMouseTextFlags_NoFormat);

        ImGuiTextBuffer& builder = gp.MousePosStringBuilder;
        builder.Buf.shrink(0);
        char buff[IMPLOT_LABEL_MAX_SIZE];

        const int num_x = no_aux ? 1 : IMPLOT_NUM_X_AXES;
        for (int i = 0; i < num_x; ++i) {
            ImPlotAxis& x_axis = plot.XAxis(i);
            if (!x_axis.Enabled)
                continue;
            if (i > 0)
                builder.append(", (");
            double v = x_axis.PixelsToPlot(IO.MousePos.x);
            if (no_fmt)
                Formatter_Default(v,buff,IMPLOT_LABEL_MAX_SIZE,(void*)IMPLOT_LABEL_FORMAT);
            else
                LabelAxisValue(x_axis,v,buff,IMPLOT_LABEL_MAX_SIZE,true);
            builder.append(buff);
            if (i > 0)
                builder.append(")");
        }
        builder.append(", ");
        const int num_y = no_aux ? 1 : IMPLOT_NUM_Y_AXES;
        for (int i = 0; i < num_y; ++i) {
            ImPlotAxis& y_axis = plot.YAxis(i);
            if (!y_axis.Enabled)
                continue;
            if (i > 0)
                builder.append(", (");
            double v = y_axis.PixelsToPlot(IO.MousePos.y);
            if (no_fmt)
                Formatter_Default(v,buff,IMPLOT_LABEL_MAX_SIZE,(void*)IMPLOT_LABEL_FORMAT);
            else
                LabelAxisValue(y_axis,v,buff,IMPLOT_LABEL_MAX_SIZE,true);
            builder.append(buff);
            if (i > 0)
                builder.append(")");
        }

        if (!builder.empty()) {
            const ImVec2 size = ImGui::CalcTextSize(builder.c_str());
            const ImVec2 pos = GetLocationPos(plot.PlotRect, size, plot.MouseTextLocation, gp.Style.MousePosPadding);
            DrawList.AddText(pos, GetStyleColorU32(ImPlotCol_InlayText), builder.c_str());
        }
    }
    PopPlotClipRect();

    // axis side switch
    if (!plot.Held) {
        ImVec2 mouse_pos = ImGui::GetIO().MousePos;
        ImRect trigger_rect = plot.PlotRect;
        trigger_rect.Expand(-10);
        for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i) {
            ImPlotAxis& x_axis = plot.XAxis(i);
            if (ImHasFlag(x_axis.Flags, ImPlotAxisFlags_NoSideSwitch))
                continue;
            if (x_axis.Held && plot.PlotRect.Contains(mouse_pos)) {
                const bool opp = ImHasFlag(x_axis.Flags, ImPlotAxisFlags_Opposite);
                if (!opp) {
                    ImRect rect(plot.PlotRect.Min.x - 5, plot.PlotRect.Min.y - 5,
                                plot.PlotRect.Max.x + 5, plot.PlotRect.Min.y + 5);
                    if (mouse_pos.y < plot.PlotRect.Max.y - 10)
                        DrawList.AddRectFilled(rect.Min, rect.Max, x_axis.ColorHov);
                    if (rect.Contains(mouse_pos))
                        x_axis.Flags |= ImPlotAxisFlags_Opposite;
                }
                else {
                    ImRect rect(plot.PlotRect.Min.x - 5, plot.PlotRect.Max.y - 5,
                                plot.PlotRect.Max.x + 5, plot.PlotRect.Max.y + 5);
                    if (mouse_pos.y > plot.PlotRect.Min.y + 10)
                        DrawList.AddRectFilled(rect.Min, rect.Max, x_axis.ColorHov);
                    if (rect.Contains(mouse_pos))
                        x_axis.Flags &= ~ImPlotAxisFlags_Opposite;
                }
            }
        }
        for (int i = 0; i < IMPLOT_NUM_Y_AXES; ++i) {
            ImPlotAxis& y_axis = plot.YAxis(i);
            if (ImHasFlag(y_axis.Flags, ImPlotAxisFlags_NoSideSwitch))
                continue;
            if (y_axis.Held && plot.PlotRect.Contains(mouse_pos)) {
                const bool opp = ImHasFlag(y_axis.Flags, ImPlotAxisFlags_Opposite);
                if (!opp) {
                    ImRect rect(plot.PlotRect.Max.x - 5, plot.PlotRect.Min.y - 5,
                                plot.PlotRect.Max.x + 5, plot.PlotRect.Max.y + 5);
                    if (mouse_pos.x > plot.PlotRect.Min.x + 10)
                        DrawList.AddRectFilled(rect.Min, rect.Max, y_axis.ColorHov);
                    if (rect.Contains(mouse_pos))
                        y_axis.Flags |= ImPlotAxisFlags_Opposite;
                }
                else {
                    ImRect rect(plot.PlotRect.Min.x - 5, plot.PlotRect.Min.y - 5,
                                plot.PlotRect.Min.x + 5, plot.PlotRect.Max.y + 5);
                    if (mouse_pos.x < plot.PlotRect.Max.x - 10)
                        DrawList.AddRectFilled(rect.Min, rect.Max, y_axis.ColorHov);
                    if (rect.Contains(mouse_pos))
                        y_axis.Flags &= ~ImPlotAxisFlags_Opposite;
                }
            }
        }
    }

    // reset legend hovers
    plot.Items.Legend.Hovered = false;
    for (int i = 0; i < plot.Items.GetItemCount(); ++i)
        plot.Items.GetItemByIndex(i)->LegendHovered = false;
    // render legend
    if (!ImHasFlag(plot.Flags, ImPlotFlags_NoLegend) && plot.Items.GetLegendCount() > 0) {
        ImPlotLegend& legend = plot.Items.Legend;
        const bool   legend_out  = ImHasFlag(legend.Flags, ImPlotLegendFlags_Outside);
        const bool   legend_horz = ImHasFlag(legend.Flags, ImPlotLegendFlags_Horizontal);
        const ImVec2 legend_size = CalcLegendSize(plot.Items, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, !legend_horz);
        const ImVec2 legend_pos  = GetLocationPos(legend_out ? plot.FrameRect : plot.PlotRect,
                                                  legend_size,
                                                  legend.Location,
                                                  legend_out ? gp.Style.PlotPadding : gp.Style.LegendPadding);
        legend.Rect = ImRect(legend_pos, legend_pos + legend_size);
        // test hover
        legend.Hovered = ImGui::IsWindowHovered() && legend.Rect.Contains(IO.MousePos);

        if (legend_out)
            ImGui::PushClipRect(plot.FrameRect.Min, plot.FrameRect.Max, true);
        else
            PushPlotClipRect();
        ImU32  col_bg      = GetStyleColorU32(ImPlotCol_LegendBg);
        ImU32  col_bd      = GetStyleColorU32(ImPlotCol_LegendBorder);
        DrawList.AddRectFilled(legend.Rect.Min, legend.Rect.Max, col_bg);
        DrawList.AddRect(legend.Rect.Min, legend.Rect.Max, col_bd);
        bool legend_contextable = ShowLegendEntries(plot.Items, legend.Rect, legend.Hovered, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, !legend_horz, DrawList)
                                && !ImHasFlag(legend.Flags, ImPlotLegendFlags_NoMenus);

        // main ctx menu
        if (gp.OpenContextThisFrame && legend_contextable && !ImHasFlag(plot.Flags, ImPlotFlags_NoMenus))
            ImGui::OpenPopup("##LegendContext");
        ImGui::PopClipRect();
        if (ImGui::BeginPopup("##LegendContext")) {
            ImGui::Text("Legend"); ImGui::Separator();
            if (ShowLegendContextMenu(legend, !ImHasFlag(plot.Flags, ImPlotFlags_NoLegend)))
                ImFlipFlag(plot.Flags, ImPlotFlags_NoLegend);
            ImGui::EndPopup();
        }
    }
    else {
        plot.Items.Legend.Rect = ImRect();
    }

    // render border
    if (render_border)
        DrawList.AddRect(plot.PlotRect.Min, plot.PlotRect.Max, GetStyleColorU32(ImPlotCol_PlotBorder), 0, ImDrawFlags_RoundCornersAll, gp.Style.PlotBorderSize);

    // render tags
    for (int i = 0; i < gp.Tags.Size; ++i) {
        ImPlotTag& tag  = gp.Tags.Tags[i];
        ImPlotAxis& axis = plot.Axes[tag.Axis];
        if (!axis.Enabled || !axis.Range.Contains(tag.Value))
            continue;
        const char* txt = gp.Tags.GetText(i);
        ImVec2 text_size = ImGui::CalcTextSize(txt);
        ImVec2 size = text_size + gp.Style.AnnotationPadding * 2;
        ImVec2 pos;
        axis.Ticker.OverrideSizeLate(size);
        float pix = IM_ROUND(axis.PlotToPixels(tag.Value));
        if (axis.Vertical) {
            if (axis.IsOpposite()) {
                pos = ImVec2(axis.Datum1 + gp.Style.LabelPadding.x, pix - size.y * 0.5f);
                DrawList.AddTriangleFilled(ImVec2(axis.Datum1,pix), pos, pos + ImVec2(0,size.y), tag.ColorBg);
            }
            else {
                pos = ImVec2(axis.Datum1 - size.x - gp.Style.LabelPadding.x, pix - size.y * 0.5f);
                DrawList.AddTriangleFilled(pos + ImVec2(size.x,0), ImVec2(axis.Datum1,pix), pos+size, tag.ColorBg);
            }
        }
        else {
            if (axis.IsOpposite()) {
                pos = ImVec2(pix - size.x * 0.5f, axis.Datum1 - size.y - gp.Style.LabelPadding.y );
                DrawList.AddTriangleFilled(pos + ImVec2(0,size.y), pos + size, ImVec2(pix,axis.Datum1), tag.ColorBg);
            }
            else {
                pos = ImVec2(pix - size.x * 0.5f, axis.Datum1 + gp.Style.LabelPadding.y);
                DrawList.AddTriangleFilled(pos, ImVec2(pix,axis.Datum1), pos + ImVec2(size.x, 0), tag.ColorBg);
            }
        }
        DrawList.AddRectFilled(pos,pos+size,tag.ColorBg);
        DrawList.AddText(pos+gp.Style.AnnotationPadding,tag.ColorFg,txt);
    }

    // FIT DATA --------------------------------------------------------------
    const bool axis_equal = ImHasFlag(plot.Flags, ImPlotFlags_Equal);
    if (plot.FitThisFrame) {
        for (int i = 0; i < IMPLOT_NUM_X_AXES; i++) {
            ImPlotAxis& x_axis = plot.XAxis(i);
            if (x_axis.FitThisFrame) {
                x_axis.ApplyFit(gp.Style.FitPadding.x);
                if (axis_equal && x_axis.OrthoAxis != nullptr) {
                    double aspect = x_axis.GetAspect();
                    ImPlotAxis& y_axis = *x_axis.OrthoAxis;
                    if (y_axis.FitThisFrame) {
                        y_axis.ApplyFit(gp.Style.FitPadding.y);
                        y_axis.FitThisFrame = false;
                        aspect = ImMax(aspect, y_axis.GetAspect());
                    }
                    x_axis.SetAspect(aspect);
                    y_axis.SetAspect(aspect);
                }
            }
        }
        for (int i = 0; i < IMPLOT_NUM_Y_AXES; i++) {
            ImPlotAxis& y_axis = plot.YAxis(i);
            if (y_axis.FitThisFrame) {
                y_axis.ApplyFit(gp.Style.FitPadding.y);
                if (axis_equal && y_axis.OrthoAxis != nullptr) {
                    double aspect = y_axis.GetAspect();
                    ImPlotAxis& x_axis = *y_axis.OrthoAxis;
                    if (x_axis.FitThisFrame) {
                        x_axis.ApplyFit(gp.Style.FitPadding.x);
                        x_axis.FitThisFrame = false;
                        aspect = ImMax(x_axis.GetAspect(), aspect);
                    }
                    x_axis.SetAspect(aspect);
                    y_axis.SetAspect(aspect);
                }
            }
        }
        plot.FitThisFrame = false;
    }

    // CONTEXT MENUS -----------------------------------------------------------

    ImGui::PushOverrideID(plot.ID);

    const bool can_ctx = gp.OpenContextThisFrame &&
                         !ImHasFlag(plot.Flags, ImPlotFlags_NoMenus) &&
                         !plot.Items.Legend.Hovered;



    // main ctx menu
    if (can_ctx && plot.Hovered)
        ImGui::OpenPopup("##PlotContext");
    if (ImGui::BeginPopup("##PlotContext")) {
        ShowPlotContextMenu(plot);
        ImGui::EndPopup();
    }

    // axes ctx menus
    for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i) {
        ImGui::PushID(i);
        ImPlotAxis& x_axis = plot.XAxis(i);
        if (can_ctx && x_axis.Hovered && x_axis.HasMenus())
            ImGui::OpenPopup("##XContext");
        if (ImGui::BeginPopup("##XContext")) {
            ImGui::Text(x_axis.HasLabel() ? plot.GetAxisLabel(x_axis) :  i == 0 ? "X-Axis" : "X-Axis %d", i + 1);
            ImGui::Separator();
            ShowAxisContextMenu(x_axis, axis_equal ? x_axis.OrthoAxis : nullptr, true);
            ImGui::EndPopup();
        }
        ImGui::PopID();
    }
    for (int i = 0; i < IMPLOT_NUM_Y_AXES; ++i) {
        ImGui::PushID(i);
        ImPlotAxis& y_axis = plot.YAxis(i);
        if (can_ctx && y_axis.Hovered && y_axis.HasMenus())
            ImGui::OpenPopup("##YContext");
        if (ImGui::BeginPopup("##YContext")) {
            ImGui::Text(y_axis.HasLabel() ? plot.GetAxisLabel(y_axis) : i == 0 ? "Y-Axis" : "Y-Axis %d", i + 1);
            ImGui::Separator();
            ShowAxisContextMenu(y_axis, axis_equal ? y_axis.OrthoAxis : nullptr, false);
            ImGui::EndPopup();
        }
        ImGui::PopID();
    }
    ImGui::PopID();

    // LINKED AXES ------------------------------------------------------------

    for (int i = 0; i < ImAxis_COUNT; ++i)
        plot.Axes[i].PushLinks();


    // CLEANUP ----------------------------------------------------------------

    // remove items
    if (gp.CurrentItems == &plot.Items)
        gp.CurrentItems = nullptr;
    // reset the plot items for the next frame
    for (int i = 0; i < plot.Items.GetItemCount(); ++i) {
        plot.Items.GetItemByIndex(i)->SeenThisFrame = false;
    }

    // mark the plot as initialized, i.e. having made it through one frame completely
    plot.Initialized = true;
    // Pop ImGui::PushID at the end of BeginPlot
    ImGui::PopID();
    // Reset context for next plot
    ResetCtxForNextPlot(GImPlot);

    // setup next subplot
    if (gp.CurrentSubplot != nullptr) {
        ImGui::PopID();
        SubplotNextCell();
    }
}

//-----------------------------------------------------------------------------
// BEGIN/END SUBPLOT
//-----------------------------------------------------------------------------

static const float SUBPLOT_BORDER_SIZE             = 1.0f;
static const float SUBPLOT_SPLITTER_HALF_THICKNESS = 4.0f;
static const float SUBPLOT_SPLITTER_FEEDBACK_TIMER = 0.06f;

void SubplotSetCell(int row, int col) {
    ImPlotContext& gp      = *GImPlot;
    ImPlotSubplot& subplot = *gp.CurrentSubplot;
    if (row >= subplot.Rows || col >= subplot.Cols)
        return;
    float xoff = 0;
    float yoff = 0;
    for (int c = 0; c < col; ++c)
        xoff += subplot.ColRatios[c];
    for (int r = 0; r < row; ++r)
        yoff += subplot.RowRatios[r];
    const ImVec2 grid_size = subplot.GridRect.GetSize();
    ImVec2 cpos            = subplot.GridRect.Min + ImVec2(xoff*grid_size.x,yoff*grid_size.y);
    cpos.x = IM_ROUND(cpos.x);
    cpos.y = IM_ROUND(cpos.y);
    ImGui::GetCurrentWindow()->DC.CursorPos =  cpos;
    // set cell size
    subplot.CellSize.x = IM_ROUND(subplot.GridRect.GetWidth()  * subplot.ColRatios[col]);
    subplot.CellSize.y = IM_ROUND(subplot.GridRect.GetHeight() * subplot.RowRatios[row]);
    // setup links
    const bool lx = ImHasFlag(subplot.Flags, ImPlotSubplotFlags_LinkAllX);
    const bool ly = ImHasFlag(subplot.Flags, ImPlotSubplotFlags_LinkAllY);
    const bool lr = ImHasFlag(subplot.Flags, ImPlotSubplotFlags_LinkRows);
    const bool lc = ImHasFlag(subplot.Flags, ImPlotSubplotFlags_LinkCols);

    SetNextAxisLinks(ImAxis_X1, lx ? &subplot.ColLinkData[0].Min : lc ? &subplot.ColLinkData[col].Min : nullptr,
                                lx ? &subplot.ColLinkData[0].Max : lc ? &subplot.ColLinkData[col].Max : nullptr);
    SetNextAxisLinks(ImAxis_Y1, ly ? &subplot.RowLinkData[0].Min : lr ? &subplot.RowLinkData[row].Min : nullptr,
                                ly ? &subplot.RowLinkData[0].Max : lr ? &subplot.RowLinkData[row].Max : nullptr);
    // setup alignment
    if (!ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoAlign)) {
        gp.CurrentAlignmentH = &subplot.RowAlignmentData[row];
        gp.CurrentAlignmentV = &subplot.ColAlignmentData[col];
    }
    // set idx
    if (ImHasFlag(subplot.Flags, ImPlotSubplotFlags_ColMajor))
        subplot.CurrentIdx = col * subplot.Rows + row;
    else
        subplot.CurrentIdx = row * subplot.Cols + col;
}

void SubplotSetCell(int idx) {
    ImPlotContext& gp      = *GImPlot;
    ImPlotSubplot& subplot = *gp.CurrentSubplot;
    if (idx >= subplot.Rows * subplot.Cols)
        return;
    int row = 0, col = 0;
    if (ImHasFlag(subplot.Flags, ImPlotSubplotFlags_ColMajor)) {
        row = idx % subplot.Rows;
        col = idx / subplot.Rows;
    }
    else {
        row = idx / subplot.Cols;
        col = idx % subplot.Cols;
    }
    return SubplotSetCell(row, col);
}

void SubplotNextCell() {
    ImPlotContext& gp      = *GImPlot;
    ImPlotSubplot& subplot = *gp.CurrentSubplot;
    SubplotSetCell(++subplot.CurrentIdx);
}

bool BeginSubplots(const char* title, int rows, int cols, const ImVec2& size, ImPlotSubplotFlags flags, float* row_sizes, float* col_sizes) {
    IM_ASSERT_USER_ERROR(rows > 0 && cols > 0, "Invalid sizing arguments!");
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentSubplot == nullptr, "Mismatched BeginSubplots()/EndSubplots()!");
    ImGuiContext &G = *GImGui;
    ImGuiWindow * Window = G.CurrentWindow;
    if (Window->SkipItems)
        return false;
    const ImGuiID ID = Window->GetID(title);
    bool just_created = gp.Subplots.GetByKey(ID) == nullptr;
    gp.CurrentSubplot = gp.Subplots.GetOrAddByKey(ID);
    ImPlotSubplot& subplot = *gp.CurrentSubplot;
    subplot.ID       = ID;
    subplot.Items.ID = ID - 1;
    subplot.HasTitle = ImGui::FindRenderedTextEnd(title, nullptr) != title;
    // push ID
    ImGui::PushID(ID);

    if (just_created)
        subplot.Flags = flags;
    else if (flags != subplot.PreviousFlags)
        subplot.Flags = flags;
    subplot.PreviousFlags = flags;

    // check for change in rows and cols
    if (subplot.Rows != rows || subplot.Cols != cols) {
        subplot.RowAlignmentData.resize(rows);
        subplot.RowLinkData.resize(rows);
        subplot.RowRatios.resize(rows);
        for (int r = 0; r < rows; ++r) {
            subplot.RowAlignmentData[r].Reset();
            subplot.RowLinkData[r] = ImPlotRange(0,1);
            subplot.RowRatios[r] = 1.0f / rows;
        }
        subplot.ColAlignmentData.resize(cols);
        subplot.ColLinkData.resize(cols);
        subplot.ColRatios.resize(cols);
        for (int c = 0; c < cols; ++c) {
            subplot.ColAlignmentData[c].Reset();
            subplot.ColLinkData[c] = ImPlotRange(0,1);
            subplot.ColRatios[c] = 1.0f / cols;
        }
    }
    // check incoming size requests
    float row_sum = 0, col_sum = 0;
    if (row_sizes != nullptr) {
        row_sum = ImSum(row_sizes, rows);
        for (int r = 0; r < rows; ++r)
            subplot.RowRatios[r] = row_sizes[r] / row_sum;
    }
    if (col_sizes != nullptr) {
        col_sum = ImSum(col_sizes, cols);
        for (int c = 0; c < cols; ++c)
            subplot.ColRatios[c] = col_sizes[c] / col_sum;
    }
    subplot.Rows = rows;
    subplot.Cols = cols;

    // calc plot frame sizes
    ImVec2 title_size(0.0f, 0.0f);
    if (!ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoTitle))
         title_size = ImGui::CalcTextSize(title, nullptr, true);
    const float pad_top = title_size.x > 0.0f ? title_size.y + gp.Style.LabelPadding.y : 0;
    const ImVec2 half_pad = gp.Style.PlotPadding/2;
    const ImVec2 frame_size = ImGui::CalcItemSize(size, gp.Style.PlotDefaultSize.x, gp.Style.PlotDefaultSize.y);
    subplot.FrameRect = ImRect(Window->DC.CursorPos, Window->DC.CursorPos + frame_size);
    subplot.GridRect.Min = subplot.FrameRect.Min + half_pad + ImVec2(0,pad_top);
    subplot.GridRect.Max = subplot.FrameRect.Max - half_pad;
    subplot.FrameHovered = subplot.FrameRect.Contains(ImGui::GetMousePos()) && ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows);

    // outside legend adjustments (TODO: make function)
    const bool share_items = ImHasFlag(subplot.Flags, ImPlotSubplotFlags_ShareItems);
    if (share_items)
        gp.CurrentItems = &subplot.Items;
    if (share_items && !ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoLegend) && subplot.Items.GetLegendCount() > 0) {
        ImPlotLegend& legend = subplot.Items.Legend;
        const bool horz = ImHasFlag(legend.Flags, ImPlotLegendFlags_Horizontal);
        const ImVec2 legend_size = CalcLegendSize(subplot.Items, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, !horz);
        const bool west = ImHasFlag(legend.Location, ImPlotLocation_West) && !ImHasFlag(legend.Location, ImPlotLocation_East);
        const bool east = ImHasFlag(legend.Location, ImPlotLocation_East) && !ImHasFlag(legend.Location, ImPlotLocation_West);
        const bool north = ImHasFlag(legend.Location, ImPlotLocation_North) && !ImHasFlag(legend.Location, ImPlotLocation_South);
        const bool south = ImHasFlag(legend.Location, ImPlotLocation_South) && !ImHasFlag(legend.Location, ImPlotLocation_North);
        if ((west && !horz) || (west && horz && !north && !south))
            subplot.GridRect.Min.x += (legend_size.x + gp.Style.LegendPadding.x);
        if ((east && !horz) || (east && horz && !north && !south))
            subplot.GridRect.Max.x -= (legend_size.x + gp.Style.LegendPadding.x);
        if ((north && horz) || (north && !horz && !west && !east))
            subplot.GridRect.Min.y += (legend_size.y + gp.Style.LegendPadding.y);
        if ((south && horz) || (south && !horz && !west && !east))
            subplot.GridRect.Max.y -= (legend_size.y + gp.Style.LegendPadding.y);
    }

    // render single background frame
    ImGui::RenderFrame(subplot.FrameRect.Min, subplot.FrameRect.Max, GetStyleColorU32(ImPlotCol_FrameBg), true, ImGui::GetStyle().FrameRounding);
    // render title
    if (title_size.x > 0.0f && !ImHasFlag(subplot.Flags, ImPlotFlags_NoTitle)) {
        const ImU32 col = GetStyleColorU32(ImPlotCol_TitleText);
        AddTextCentered(ImGui::GetWindowDrawList(),ImVec2(subplot.GridRect.GetCenter().x, subplot.GridRect.Min.y - pad_top + half_pad.y),col,title);
    }

    // render splitters
    if (!ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoResize)) {
        ImDrawList& DrawList = *ImGui::GetWindowDrawList();
        const ImU32 hov_col = ImGui::ColorConvertFloat4ToU32(GImGui->Style.Colors[ImGuiCol_SeparatorHovered]);
        const ImU32 act_col = ImGui::ColorConvertFloat4ToU32(GImGui->Style.Colors[ImGuiCol_SeparatorActive]);
        float xpos = subplot.GridRect.Min.x;
        float ypos = subplot.GridRect.Min.y;
        int separator = 1;
        // bool pass = false;
        for (int r = 0; r < subplot.Rows-1; ++r) {
            ypos += subplot.RowRatios[r] * subplot.GridRect.GetHeight();
            const ImGuiID sep_id = subplot.ID + separator;
            ImGui::KeepAliveID(sep_id);
            const ImRect sep_bb = ImRect(subplot.GridRect.Min.x, ypos-SUBPLOT_SPLITTER_HALF_THICKNESS, subplot.GridRect.Max.x, ypos+SUBPLOT_SPLITTER_HALF_THICKNESS);
            bool sep_hov = false, sep_hld = false;
            const bool sep_clk = ImGui::ButtonBehavior(sep_bb, sep_id, &sep_hov, &sep_hld, ImGuiButtonFlags_FlattenChildren | ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnDoubleClick);
            if ((sep_hov && G.HoveredIdTimer > SUBPLOT_SPLITTER_FEEDBACK_TIMER) || sep_hld) {
                if (sep_clk && ImGui::IsMouseDoubleClicked(0)) {
                    float p = (subplot.RowRatios[r] + subplot.RowRatios[r+1])/2;
                    subplot.RowRatios[r] = subplot.RowRatios[r+1] = p;
                }
                if (sep_clk) {
                    subplot.TempSizes[0] = subplot.RowRatios[r];
                    subplot.TempSizes[1] = subplot.RowRatios[r+1];
                }
                if (sep_hld) {
                    float dp = ImGui::GetMouseDragDelta(0).y  / subplot.GridRect.GetHeight();
                    if (subplot.TempSizes[0] + dp > 0.1f && subplot.TempSizes[1] - dp > 0.1f) {
                        subplot.RowRatios[r]   = subplot.TempSizes[0] + dp;
                        subplot.RowRatios[r+1] = subplot.TempSizes[1] - dp;
                    }
                }
                DrawList.AddLine(ImVec2(IM_ROUND(subplot.GridRect.Min.x),IM_ROUND(ypos)),
                                 ImVec2(IM_ROUND(subplot.GridRect.Max.x),IM_ROUND(ypos)),
                                 sep_hld ? act_col : hov_col, SUBPLOT_BORDER_SIZE);
                ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNS);
            }
            separator++;
        }
        for (int c = 0; c < subplot.Cols-1; ++c) {
            xpos += subplot.ColRatios[c] * subplot.GridRect.GetWidth();
            const ImGuiID sep_id = subplot.ID + separator;
            ImGui::KeepAliveID(sep_id);
            const ImRect sep_bb = ImRect(xpos-SUBPLOT_SPLITTER_HALF_THICKNESS, subplot.GridRect.Min.y, xpos+SUBPLOT_SPLITTER_HALF_THICKNESS, subplot.GridRect.Max.y);
            bool sep_hov = false, sep_hld = false;
            const bool sep_clk = ImGui::ButtonBehavior(sep_bb, sep_id, &sep_hov, &sep_hld, ImGuiButtonFlags_FlattenChildren | ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnDoubleClick);
            if ((sep_hov && G.HoveredIdTimer > SUBPLOT_SPLITTER_FEEDBACK_TIMER) || sep_hld) {
                if (sep_clk && ImGui::IsMouseDoubleClicked(0)) {
                    float p = (subplot.ColRatios[c] + subplot.ColRatios[c+1])/2;
                    subplot.ColRatios[c] = subplot.ColRatios[c+1] = p;
                }
                if (sep_clk) {
                    subplot.TempSizes[0] = subplot.ColRatios[c];
                    subplot.TempSizes[1] = subplot.ColRatios[c+1];
                }
                if (sep_hld) {
                    float dp = ImGui::GetMouseDragDelta(0).x / subplot.GridRect.GetWidth();
                    if (subplot.TempSizes[0] + dp > 0.1f && subplot.TempSizes[1] - dp > 0.1f) {
                        subplot.ColRatios[c]   = subplot.TempSizes[0] + dp;
                        subplot.ColRatios[c+1] = subplot.TempSizes[1] - dp;
                    }
                }
                DrawList.AddLine(ImVec2(IM_ROUND(xpos),IM_ROUND(subplot.GridRect.Min.y)),
                                 ImVec2(IM_ROUND(xpos),IM_ROUND(subplot.GridRect.Max.y)),
                                 sep_hld ? act_col : hov_col, SUBPLOT_BORDER_SIZE);
                ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
            }
            separator++;
        }
    }

    // set outgoing sizes
    if (row_sizes != nullptr) {
        for (int r = 0; r < rows; ++r)
            row_sizes[r] = subplot.RowRatios[r] * row_sum;
    }
    if (col_sizes != nullptr) {
        for (int c = 0; c < cols; ++c)
            col_sizes[c] = subplot.ColRatios[c] * col_sum;
    }

    // push styling
    PushStyleColor(ImPlotCol_FrameBg, IM_COL32_BLACK_TRANS);
    PushStyleVar(ImPlotStyleVar_PlotPadding, half_pad);
    PushStyleVar(ImPlotStyleVar_PlotMinSize, ImVec2(0,0));
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize,0);

    // set initial cursor pos
    Window->DC.CursorPos = subplot.GridRect.Min;
    // begin alignments
    for (int r = 0; r < subplot.Rows; ++r)
        subplot.RowAlignmentData[r].Begin();
    for (int c = 0; c < subplot.Cols; ++c)
        subplot.ColAlignmentData[c].Begin();
    // clear legend data
    subplot.Items.Legend.Reset();
    // Setup first subplot
    SubplotSetCell(0,0);
    return true;
}

void EndSubplots() {
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentSubplot != nullptr, "Mismatched BeginSubplots()/EndSubplots()!");
    ImPlotSubplot& subplot = *gp.CurrentSubplot;
    // set alignments
    for (int r = 0; r < subplot.Rows; ++r)
        subplot.RowAlignmentData[r].End();
    for (int c = 0; c < subplot.Cols; ++c)
        subplot.ColAlignmentData[c].End();
    // pop styling
    PopStyleColor();
    PopStyleVar();
    PopStyleVar();
    ImGui::PopStyleVar();
    // legend
    subplot.Items.Legend.Hovered = false;
    for (int i = 0; i < subplot.Items.GetItemCount(); ++i)
        subplot.Items.GetItemByIndex(i)->LegendHovered = false;
    // render legend
    const bool share_items = ImHasFlag(subplot.Flags, ImPlotSubplotFlags_ShareItems);
    ImDrawList& DrawList = *ImGui::GetWindowDrawList();
    if (share_items && !ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoLegend) && subplot.Items.GetLegendCount() > 0) {
        const bool   legend_horz = ImHasFlag(subplot.Items.Legend.Flags, ImPlotLegendFlags_Horizontal);
        const ImVec2 legend_size = CalcLegendSize(subplot.Items, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, !legend_horz);
        const ImVec2 legend_pos  = GetLocationPos(subplot.FrameRect, legend_size, subplot.Items.Legend.Location, gp.Style.PlotPadding);
        subplot.Items.Legend.Rect = ImRect(legend_pos, legend_pos + legend_size);
        subplot.Items.Legend.Hovered = subplot.FrameHovered && subplot.Items.Legend.Rect.Contains(ImGui::GetIO().MousePos);
        ImGui::PushClipRect(subplot.FrameRect.Min, subplot.FrameRect.Max, true);
        ImU32  col_bg      = GetStyleColorU32(ImPlotCol_LegendBg);
        ImU32  col_bd      = GetStyleColorU32(ImPlotCol_LegendBorder);
        DrawList.AddRectFilled(subplot.Items.Legend.Rect.Min, subplot.Items.Legend.Rect.Max, col_bg);
        DrawList.AddRect(subplot.Items.Legend.Rect.Min, subplot.Items.Legend.Rect.Max, col_bd);
        bool legend_contextable = ShowLegendEntries(subplot.Items, subplot.Items.Legend.Rect, subplot.Items.Legend.Hovered, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, !legend_horz, DrawList)
                                && !ImHasFlag(subplot.Items.Legend.Flags, ImPlotLegendFlags_NoMenus);
        if (legend_contextable && !ImHasFlag(subplot.Flags, ImPlotSubplotFlags_NoMenus) && ImGui::GetIO().MouseReleased[gp.InputMap.Menu])
            ImGui::OpenPopup("##LegendContext");
        ImGui::PopClipRect();
        if (ImGui::BeginPopup("##LegendContext")) {
            ImGui::Text("Legend"); ImGui::Separator();
            if (ShowLegendContextMenu(subplot.Items.Legend, !ImHasFlag(subplot.Flags, ImPlotFlags_NoLegend)))
                ImFlipFlag(subplot.Flags, ImPlotFlags_NoLegend);
            ImGui::EndPopup();
        }
    }
    else {
        subplot.Items.Legend.Rect = ImRect();
    }
    // remove items
    if (gp.CurrentItems == &subplot.Items)
        gp.CurrentItems = nullptr;
    // reset the plot items for the next frame (TODO: put this elswhere)
    for (int i = 0; i < subplot.Items.GetItemCount(); ++i) {
        subplot.Items.GetItemByIndex(i)->SeenThisFrame = false;
    }
    // pop id
    ImGui::PopID();
    // set DC back correctly
    GImGui->CurrentWindow->DC.CursorPos = subplot.FrameRect.Min;
    ImGui::Dummy(subplot.FrameRect.GetSize());
    ResetCtxForNextSubplot(GImPlot);

}

//-----------------------------------------------------------------------------
// [SECTION] Plot Utils
//-----------------------------------------------------------------------------

void SetAxis(ImAxis axis) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "SetAxis() needs to be called between BeginPlot() and EndPlot()!");
    IM_ASSERT_USER_ERROR(axis >= ImAxis_X1 && axis < ImAxis_COUNT, "Axis index out of bounds!");
    IM_ASSERT_USER_ERROR(gp.CurrentPlot->Axes[axis].Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    SetupLock();
    if (axis < ImAxis_Y1)
        gp.CurrentPlot->CurrentX = axis;
    else
        gp.CurrentPlot->CurrentY = axis;
}

void SetAxes(ImAxis x_idx, ImAxis y_idx) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "SetAxes() needs to be called between BeginPlot() and EndPlot()!");
    IM_ASSERT_USER_ERROR(x_idx >= ImAxis_X1 && x_idx < ImAxis_Y1, "X-Axis index out of bounds!");
    IM_ASSERT_USER_ERROR(y_idx >= ImAxis_Y1 && y_idx < ImAxis_COUNT, "Y-Axis index out of bounds!");
    IM_ASSERT_USER_ERROR(gp.CurrentPlot->Axes[x_idx].Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    IM_ASSERT_USER_ERROR(gp.CurrentPlot->Axes[y_idx].Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
    SetupLock();
    gp.CurrentPlot->CurrentX = x_idx;
    gp.CurrentPlot->CurrentY = y_idx;
}

ImPlotPoint PixelsToPlot(float x, float y, ImAxis x_idx, ImAxis y_idx) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "PixelsToPlot() needs to be called between BeginPlot() and EndPlot()!");
    IM_ASSERT_USER_ERROR(x_idx == IMPLOT_AUTO || (x_idx >= ImAxis_X1 && x_idx < ImAxis_Y1),    "X-Axis index out of bounds!");
    IM_ASSERT_USER_ERROR(y_idx == IMPLOT_AUTO || (y_idx >= ImAxis_Y1 && y_idx < ImAxis_COUNT), "Y-Axis index out of bounds!");
    SetupLock();
    ImPlotPlot& plot   = *gp.CurrentPlot;
    ImPlotAxis& x_axis = x_idx == IMPLOT_AUTO ? plot.Axes[plot.CurrentX] : plot.Axes[x_idx];
    ImPlotAxis& y_axis = y_idx == IMPLOT_AUTO ? plot.Axes[plot.CurrentY] : plot.Axes[y_idx];
    return ImPlotPoint( x_axis.PixelsToPlot(x), y_axis.PixelsToPlot(y) );
}

ImPlotPoint PixelsToPlot(const ImVec2& pix, ImAxis x_idx, ImAxis y_idx) {
    return PixelsToPlot(pix.x, pix.y, x_idx, y_idx);
}

ImVec2 PlotToPixels(double x, double y, ImAxis x_idx, ImAxis y_idx) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "PlotToPixels() needs to be called between BeginPlot() and EndPlot()!");
    IM_ASSERT_USER_ERROR(x_idx == IMPLOT_AUTO || (x_idx >= ImAxis_X1 && x_idx < ImAxis_Y1),    "X-Axis index out of bounds!");
    IM_ASSERT_USER_ERROR(y_idx == IMPLOT_AUTO || (y_idx >= ImAxis_Y1 && y_idx < ImAxis_COUNT), "Y-Axis index out of bounds!");
    SetupLock();
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& x_axis = x_idx == IMPLOT_AUTO ? plot.Axes[plot.CurrentX] : plot.Axes[x_idx];
    ImPlotAxis& y_axis = y_idx == IMPLOT_AUTO ? plot.Axes[plot.CurrentY] : plot.Axes[y_idx];
    return ImVec2( x_axis.PlotToPixels(x), y_axis.PlotToPixels(y) );
}

ImVec2 PlotToPixels(const ImPlotPoint& plt, ImAxis x_idx, ImAxis y_idx) {
    return PlotToPixels(plt.x, plt.y, x_idx, y_idx);
}

ImVec2 GetPlotPos() {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "GetPlotPos() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    return gp.CurrentPlot->PlotRect.Min;
}

ImVec2 GetPlotSize() {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "GetPlotSize() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    return gp.CurrentPlot->PlotRect.GetSize();
}

ImPlotPoint GetPlotMousePos(ImAxis x_idx, ImAxis y_idx) {
    IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != nullptr, "GetPlotMousePos() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    return PixelsToPlot(ImGui::GetMousePos(), x_idx, y_idx);
}

ImPlotRect GetPlotLimits(ImAxis x_idx, ImAxis y_idx) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "GetPlotLimits() needs to be called between BeginPlot() and EndPlot()!");
    IM_ASSERT_USER_ERROR(x_idx == IMPLOT_AUTO || (x_idx >= ImAxis_X1 && x_idx < ImAxis_Y1),    "X-Axis index out of bounds!");
    IM_ASSERT_USER_ERROR(y_idx == IMPLOT_AUTO || (y_idx >= ImAxis_Y1 && y_idx < ImAxis_COUNT), "Y-Axis index out of bounds!");
    SetupLock();
    ImPlotPlot& plot = *gp.CurrentPlot;
    ImPlotAxis& x_axis = x_idx == IMPLOT_AUTO ? plot.Axes[plot.CurrentX] : plot.Axes[x_idx];
    ImPlotAxis& y_axis = y_idx == IMPLOT_AUTO ? plot.Axes[plot.CurrentY] : plot.Axes[y_idx];
    ImPlotRect limits;
    limits.X = x_axis.Range;
    limits.Y = y_axis.Range;
    return limits;
}

bool IsPlotHovered() {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "IsPlotHovered() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    return gp.CurrentPlot->Hovered;
}

bool IsAxisHovered(ImAxis axis) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "IsPlotXAxisHovered() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    return gp.CurrentPlot->Axes[axis].Hovered;
}

bool IsSubplotsHovered() {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentSubplot != nullptr, "IsSubplotsHovered() needs to be called between BeginSubplots() and EndSubplots()!");
    return gp.CurrentSubplot->FrameHovered;
}

bool IsPlotSelected() {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "IsPlotSelected() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    return gp.CurrentPlot->Selected;
}

ImPlotRect GetPlotSelection(ImAxis x_idx, ImAxis y_idx) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "GetPlotSelection() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    ImPlotPlot& plot = *gp.CurrentPlot;
    if (!plot.Selected)
        return ImPlotRect(0,0,0,0);
    ImPlotPoint p1 = PixelsToPlot(plot.SelectRect.Min + plot.PlotRect.Min, x_idx, y_idx);
    ImPlotPoint p2 = PixelsToPlot(plot.SelectRect.Max + plot.PlotRect.Min, x_idx, y_idx);
    ImPlotRect result;
    result.X.Min = ImMin(p1.x, p2.x);
    result.X.Max = ImMax(p1.x, p2.x);
    result.Y.Min = ImMin(p1.y, p2.y);
    result.Y.Max = ImMax(p1.y, p2.y);
    return result;
}

void CancelPlotSelection() {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "CancelPlotSelection() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    ImPlotPlot& plot = *gp.CurrentPlot;
    if (plot.Selected)
        plot.Selected = plot.Selecting = false;
}

void HideNextItem(bool hidden, ImPlotCond cond) {
    ImPlotContext& gp = *GImPlot;
    gp.NextItemData.HasHidden  = true;
    gp.NextItemData.Hidden     = hidden;
    gp.NextItemData.HiddenCond = cond;
}

//-----------------------------------------------------------------------------
// [SECTION] Plot Tools
//-----------------------------------------------------------------------------

void Annotation(double x, double y, const ImVec4& col, const ImVec2& offset, bool clamp, bool round) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "Annotation() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    char x_buff[IMPLOT_LABEL_MAX_SIZE];
    char y_buff[IMPLOT_LABEL_MAX_SIZE];
    ImPlotAxis& x_axis = gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentX];
    ImPlotAxis& y_axis = gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentY];
    LabelAxisValue(x_axis, x, x_buff, sizeof(x_buff), round);
    LabelAxisValue(y_axis, y, y_buff, sizeof(y_buff), round);
    Annotation(x,y,col,offset,clamp,"%s, %s",x_buff,y_buff);
}

void AnnotationV(double x, double y, const ImVec4& col, const ImVec2& offset, bool clamp, const char* fmt, va_list args) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "Annotation() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    ImVec2 pos = PlotToPixels(x,y,IMPLOT_AUTO,IMPLOT_AUTO);
    ImU32  bg  = ImGui::GetColorU32(col);
    ImU32  fg  = col.w == 0 ? GetStyleColorU32(ImPlotCol_InlayText) : CalcTextColor(col);
    gp.Annotations.AppendV(pos, offset, bg, fg, clamp, fmt, args);
}

void Annotation(double x, double y, const ImVec4& col, const ImVec2& offset, bool clamp, const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    AnnotationV(x,y,col,offset,clamp,fmt,args);
    va_end(args);
}

void TagV(ImAxis axis, double v, const ImVec4& col, const char* fmt, va_list args) {
    ImPlotContext& gp = *GImPlot;
    SetupLock();
    ImU32 bg = ImGui::GetColorU32(col);
    ImU32 fg = col.w == 0 ? GetStyleColorU32(ImPlotCol_AxisText) : CalcTextColor(col);
    gp.Tags.AppendV(axis,v,bg,fg,fmt,args);
}

void Tag(ImAxis axis, double v, const ImVec4& col, const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    TagV(axis,v,col,fmt,args);
    va_end(args);
}

void Tag(ImAxis axis, double v, const ImVec4& color, bool round) {
    ImPlotContext& gp = *GImPlot;
    SetupLock();
    char buff[IMPLOT_LABEL_MAX_SIZE];
    ImPlotAxis& ax = gp.CurrentPlot->Axes[axis];
    LabelAxisValue(ax, v, buff, sizeof(buff), round);
    Tag(axis,v,color,"%s",buff);
}

IMPLOT_API void TagX(double x, const ImVec4& color, bool round) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "TagX() needs to be called between BeginPlot() and EndPlot()!");
    Tag(gp.CurrentPlot->CurrentX, x, color, round);
}

IMPLOT_API void TagX(double x, const ImVec4& color, const char* fmt, ...) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "TagX() needs to be called between BeginPlot() and EndPlot()!");
    va_list args;
    va_start(args, fmt);
    TagV(gp.CurrentPlot->CurrentX,x,color,fmt,args);
    va_end(args);
}

IMPLOT_API void TagXV(double x, const ImVec4& color, const char* fmt, va_list args) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "TagX() needs to be called between BeginPlot() and EndPlot()!");
    TagV(gp.CurrentPlot->CurrentX, x, color, fmt, args);
}

IMPLOT_API void TagY(double y, const ImVec4& color, bool round) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "TagY() needs to be called between BeginPlot() and EndPlot()!");
    Tag(gp.CurrentPlot->CurrentY, y, color, round);
}

IMPLOT_API void TagY(double y, const ImVec4& color, const char* fmt, ...) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "TagY() needs to be called between BeginPlot() and EndPlot()!");
    va_list args;
    va_start(args, fmt);
    TagV(gp.CurrentPlot->CurrentY,y,color,fmt,args);
    va_end(args);
}

IMPLOT_API void TagYV(double y, const ImVec4& color, const char* fmt, va_list args) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "TagY() needs to be called between BeginPlot() and EndPlot()!");
    TagV(gp.CurrentPlot->CurrentY, y, color, fmt, args);
}

static const float DRAG_GRAB_HALF_SIZE = 4.0f;

bool DragPoint(int n_id, double* x, double* y, const ImVec4& col, float radius, ImPlotDragToolFlags flags) {
    ImGui::PushID("#IMPLOT_DRAG_POINT");
    IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != nullptr, "DragPoint() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();

    if (!ImHasFlag(flags,ImPlotDragToolFlags_NoFit) && FitThisFrame()) {
        FitPoint(ImPlotPoint(*x,*y));
    }

    const bool input = !ImHasFlag(flags, ImPlotDragToolFlags_NoInputs);
    const bool show_curs = !ImHasFlag(flags, ImPlotDragToolFlags_NoCursors);
    const bool no_delay = !ImHasFlag(flags, ImPlotDragToolFlags_Delayed);
    const float grab_half_size = ImMax(DRAG_GRAB_HALF_SIZE, radius);
    const ImVec4 color = IsColorAuto(col) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : col;
    const ImU32 col32 = ImGui::ColorConvertFloat4ToU32(color);

    ImVec2 pos = PlotToPixels(*x,*y,IMPLOT_AUTO,IMPLOT_AUTO);
    const ImGuiID id = ImGui::GetCurrentWindow()->GetID(n_id);
    ImRect rect(pos.x-grab_half_size,pos.y-grab_half_size,pos.x+grab_half_size,pos.y+grab_half_size);
    bool hovered = false, held = false;

    ImGui::KeepAliveID(id);
    if (input)
        ImGui::ButtonBehavior(rect,id,&hovered,&held);

    bool dragging = false;
    if (held && ImGui::IsMouseDragging(0)) {
        *x = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).x;
        *y = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).y;
        dragging = true;
    }

    PushPlotClipRect();
    ImDrawList& DrawList = *GetPlotDrawList();
    if ((hovered || held) && show_curs)
        ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
    if (dragging && no_delay)
        pos = PlotToPixels(*x,*y,IMPLOT_AUTO,IMPLOT_AUTO);
    DrawList.AddCircleFilled(pos, radius, col32);
    PopPlotClipRect();

    ImGui::PopID();
    return dragging;
}

bool DragLineX(int n_id, double* value, const ImVec4& col, float thickness, ImPlotDragToolFlags flags) {
    // ImGui::PushID("#IMPLOT_DRAG_LINE_X");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "DragLineX() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();

    if (!ImHasFlag(flags,ImPlotDragToolFlags_NoFit) && FitThisFrame()) {
        FitPointX(*value);
    }

    const bool input = !ImHasFlag(flags, ImPlotDragToolFlags_NoInputs);
    const bool show_curs = !ImHasFlag(flags, ImPlotDragToolFlags_NoCursors);
    const bool no_delay = !ImHasFlag(flags, ImPlotDragToolFlags_Delayed);
    const float grab_half_size = ImMax(DRAG_GRAB_HALF_SIZE, thickness/2);
    float yt = gp.CurrentPlot->PlotRect.Min.y;
    float yb = gp.CurrentPlot->PlotRect.Max.y;
    float x  = IM_ROUND(PlotToPixels(*value,0,IMPLOT_AUTO,IMPLOT_AUTO).x);
    const ImGuiID id = ImGui::GetCurrentWindow()->GetID(n_id);
    ImRect rect(x-grab_half_size,yt,x+grab_half_size,yb);
    bool hovered = false, held = false;

    ImGui::KeepAliveID(id);
    if (input)
        ImGui::ButtonBehavior(rect,id,&hovered,&held);

    if ((hovered || held) && show_curs)
        ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);

    float len = gp.Style.MajorTickLen.x;
    ImVec4 color = IsColorAuto(col) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : col;
    ImU32 col32 = ImGui::ColorConvertFloat4ToU32(color);

    bool dragging = false;
    if (held && ImGui::IsMouseDragging(0)) {
        *value = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).x;
        dragging = true;
    }

    PushPlotClipRect();
    ImDrawList& DrawList = *GetPlotDrawList();
    if (dragging && no_delay)
        x  = IM_ROUND(PlotToPixels(*value,0,IMPLOT_AUTO,IMPLOT_AUTO).x);
    DrawList.AddLine(ImVec2(x,yt), ImVec2(x,yb),     col32,   thickness);
    DrawList.AddLine(ImVec2(x,yt), ImVec2(x,yt+len), col32, 3*thickness);
    DrawList.AddLine(ImVec2(x,yb), ImVec2(x,yb-len), col32, 3*thickness);
    PopPlotClipRect();

    // ImGui::PopID();
    return dragging;
}

bool DragLineY(int n_id, double* value, const ImVec4& col, float thickness, ImPlotDragToolFlags flags) {
    ImGui::PushID("#IMPLOT_DRAG_LINE_Y");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "DragLineY() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();

    if (!ImHasFlag(flags,ImPlotDragToolFlags_NoFit) && FitThisFrame()) {
        FitPointY(*value);
    }

    const bool input = !ImHasFlag(flags, ImPlotDragToolFlags_NoInputs);
    const bool show_curs = !ImHasFlag(flags, ImPlotDragToolFlags_NoCursors);
    const bool no_delay = !ImHasFlag(flags, ImPlotDragToolFlags_Delayed);
    const float grab_half_size = ImMax(DRAG_GRAB_HALF_SIZE, thickness/2);
    float xl = gp.CurrentPlot->PlotRect.Min.x;
    float xr = gp.CurrentPlot->PlotRect.Max.x;
    float y  = IM_ROUND(PlotToPixels(0, *value,IMPLOT_AUTO,IMPLOT_AUTO).y);

    const ImGuiID id = ImGui::GetCurrentWindow()->GetID(n_id);
    ImRect rect(xl,y-grab_half_size,xr,y+grab_half_size);
    bool hovered = false, held = false;

    ImGui::KeepAliveID(id);
    if (input)
        ImGui::ButtonBehavior(rect,id,&hovered,&held);

    if ((hovered || held) && show_curs)
        ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNS);

    float len = gp.Style.MajorTickLen.y;
    ImVec4 color = IsColorAuto(col) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : col;
    ImU32 col32 = ImGui::ColorConvertFloat4ToU32(color);

    bool dragging = false;
    if (held && ImGui::IsMouseDragging(0)) {
        *value = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).y;
        dragging = true;
    }

    PushPlotClipRect();
    ImDrawList& DrawList = *GetPlotDrawList();
    if (dragging && no_delay)
        y  = IM_ROUND(PlotToPixels(0, *value,IMPLOT_AUTO,IMPLOT_AUTO).y);
    DrawList.AddLine(ImVec2(xl,y), ImVec2(xr,y),     col32,   thickness);
    DrawList.AddLine(ImVec2(xl,y), ImVec2(xl+len,y), col32, 3*thickness);
    DrawList.AddLine(ImVec2(xr,y), ImVec2(xr-len,y), col32, 3*thickness);
    PopPlotClipRect();

    ImGui::PopID();
    return dragging;
}

bool DragRect(int n_id, double* x_min, double* y_min, double* x_max, double* y_max, const ImVec4& col, ImPlotDragToolFlags flags) {
    ImGui::PushID("#IMPLOT_DRAG_RECT");
    IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != nullptr, "DragRect() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();

    if (!ImHasFlag(flags,ImPlotDragToolFlags_NoFit) && FitThisFrame()) {
        FitPoint(ImPlotPoint(*x_min,*y_min));
        FitPoint(ImPlotPoint(*x_max,*y_max));
    }

    const bool input = !ImHasFlag(flags, ImPlotDragToolFlags_NoInputs);
    const bool show_curs = !ImHasFlag(flags, ImPlotDragToolFlags_NoCursors);
    const bool no_delay = !ImHasFlag(flags, ImPlotDragToolFlags_Delayed);
    bool    h[] = {true,false,true,false};
    double* x[] = {x_min,x_max,x_max,x_min};
    double* y[] = {y_min,y_min,y_max,y_max};
    ImVec2 p[4];
    for (int i = 0; i < 4; ++i)
        p[i] = PlotToPixels(*x[i],*y[i],IMPLOT_AUTO,IMPLOT_AUTO);
    ImVec2 pc = PlotToPixels((*x_min+*x_max)/2,(*y_min+*y_max)/2,IMPLOT_AUTO,IMPLOT_AUTO);
    ImRect rect(ImMin(p[0],p[2]),ImMax(p[0],p[2]));
    ImRect rect_grab = rect; rect_grab.Expand(DRAG_GRAB_HALF_SIZE);

    ImGuiMouseCursor cur[4];
    if (show_curs) {
        cur[0] = (rect.Min.x == p[0].x && rect.Min.y == p[0].y) || (rect.Max.x == p[0].x && rect.Max.y == p[0].y) ? ImGuiMouseCursor_ResizeNWSE : ImGuiMouseCursor_ResizeNESW;
        cur[1] = cur[0] == ImGuiMouseCursor_ResizeNWSE ? ImGuiMouseCursor_ResizeNESW : ImGuiMouseCursor_ResizeNWSE;
        cur[2] = cur[1] == ImGuiMouseCursor_ResizeNWSE ? ImGuiMouseCursor_ResizeNESW : ImGuiMouseCursor_ResizeNWSE;
        cur[3] = cur[2] == ImGuiMouseCursor_ResizeNWSE ? ImGuiMouseCursor_ResizeNESW : ImGuiMouseCursor_ResizeNWSE;
    }

    ImVec4 color = IsColorAuto(col) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : col;
    ImU32 col32 = ImGui::ColorConvertFloat4ToU32(color);
    color.w *= 0.25f;
    ImU32 col32_a = ImGui::ColorConvertFloat4ToU32(color);
    const ImGuiID id = ImGui::GetCurrentWindow()->GetID(n_id);

    bool dragging = false;
    bool hovered = false, held = false;
    ImRect b_rect(pc.x-DRAG_GRAB_HALF_SIZE,pc.y-DRAG_GRAB_HALF_SIZE,pc.x+DRAG_GRAB_HALF_SIZE,pc.y+DRAG_GRAB_HALF_SIZE);

    ImGui::KeepAliveID(id);
    if (input)
        ImGui::ButtonBehavior(b_rect,id,&hovered,&held);

    if ((hovered || held) && show_curs)
        ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeAll);
    if (held && ImGui::IsMouseDragging(0)) {
        for (int i = 0; i < 4; ++i) {
            ImPlotPoint pp = PixelsToPlot(p[i] + ImGui::GetIO().MouseDelta,IMPLOT_AUTO,IMPLOT_AUTO);
            *y[i] = pp.y;
            *x[i] = pp.x;
        }
        dragging = true;
    }

    for (int i = 0; i < 4; ++i) {
        // points
        b_rect = ImRect(p[i].x-DRAG_GRAB_HALF_SIZE,p[i].y-DRAG_GRAB_HALF_SIZE,p[i].x+DRAG_GRAB_HALF_SIZE,p[i].y+DRAG_GRAB_HALF_SIZE);
        ImGuiID p_id = id + i + 1;
        ImGui::KeepAliveID(p_id);
        if (input)
            ImGui::ButtonBehavior(b_rect,p_id,&hovered,&held);
        if ((hovered || held) && show_curs)
            ImGui::SetMouseCursor(cur[i]);

        if (held && ImGui::IsMouseDragging(0)) {
            *x[i] = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).x;
            *y[i] = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).y;
            dragging = true;
        }

        // edges
        ImVec2 e_min = ImMin(p[i],p[(i+1)%4]);
        ImVec2 e_max = ImMax(p[i],p[(i+1)%4]);
        b_rect = h[i] ? ImRect(e_min.x + DRAG_GRAB_HALF_SIZE, e_min.y - DRAG_GRAB_HALF_SIZE, e_max.x - DRAG_GRAB_HALF_SIZE, e_max.y + DRAG_GRAB_HALF_SIZE)
                    : ImRect(e_min.x - DRAG_GRAB_HALF_SIZE, e_min.y + DRAG_GRAB_HALF_SIZE, e_max.x + DRAG_GRAB_HALF_SIZE, e_max.y - DRAG_GRAB_HALF_SIZE);
        ImGuiID e_id = id + i + 5;
        ImGui::KeepAliveID(e_id);
        if (input)
            ImGui::ButtonBehavior(b_rect,e_id,&hovered,&held);
        if ((hovered || held) && show_curs)
            h[i] ? ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNS) : ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
        if (held && ImGui::IsMouseDragging(0)) {
            if (h[i])
                *y[i] = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).y;
            else
                *x[i] = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).x;
            dragging = true;
        }
        if (hovered && ImGui::IsMouseDoubleClicked(0))
        {
            ImPlotRect b = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO);
            if (h[i])
                *y[i] = ((y[i] == y_min && *y_min < *y_max) || (y[i] == y_max && *y_max < *y_min)) ? b.Y.Min : b.Y.Max;
            else
                *x[i] = ((x[i] == x_min && *x_min < *x_max) || (x[i] == x_max && *x_max < *x_min)) ? b.X.Min : b.X.Max;
            dragging = true;
        }
    }


    PushPlotClipRect();
    ImDrawList& DrawList = *GetPlotDrawList();
    if (dragging && no_delay) {
        for (int i = 0; i < 4; ++i)
            p[i] = PlotToPixels(*x[i],*y[i],IMPLOT_AUTO,IMPLOT_AUTO);
        pc = PlotToPixels((*x_min+*x_max)/2,(*y_min+*y_max)/2,IMPLOT_AUTO,IMPLOT_AUTO);
        rect = ImRect(ImMin(p[0],p[2]),ImMax(p[0],p[2]));
    }
    DrawList.AddRectFilled(rect.Min, rect.Max, col32_a);
    DrawList.AddRect(rect.Min, rect.Max, col32);
    if (input && (dragging || rect_grab.Contains(ImGui::GetMousePos()))) {
        DrawList.AddCircleFilled(pc,DRAG_GRAB_HALF_SIZE,col32);
        for (int i = 0; i < 4; ++i)
            DrawList.AddCircleFilled(p[i],DRAG_GRAB_HALF_SIZE,col32);
    }
    PopPlotClipRect();
    ImGui::PopID();
    return dragging;
}

bool DragRect(int id, ImPlotRect* bounds, const ImVec4& col, ImPlotDragToolFlags flags) {
    return DragRect(id, &bounds->X.Min, &bounds->Y.Min,&bounds->X.Max, &bounds->Y.Max, col, flags);
}

//-----------------------------------------------------------------------------
// [SECTION] Legend Utils and Tools
//-----------------------------------------------------------------------------

bool IsLegendEntryHovered(const char* label_id) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentItems != nullptr, "IsPlotItemHighlight() needs to be called within an itemized context!");
    SetupLock();
    ImGuiID id = ImGui::GetIDWithSeed(label_id, nullptr, gp.CurrentItems->ID);
    ImPlotItem* item = gp.CurrentItems->GetItem(id);
    return item && item->LegendHovered;
}

bool BeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_button) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentItems != nullptr, "BeginLegendPopup() needs to be called within an itemized context!");
    SetupLock();
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (window->SkipItems)
        return false;
    ImGuiID id = ImGui::GetIDWithSeed(label_id, nullptr, gp.CurrentItems->ID);
    if (ImGui::IsMouseReleased(mouse_button)) {
        ImPlotItem* item = gp.CurrentItems->GetItem(id);
        if (item && item->LegendHovered)
            ImGui::OpenPopupEx(id);
    }
    return ImGui::BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

void EndLegendPopup() {
    SetupLock();
    ImGui::EndPopup();
}

void ShowAltLegend(const char* title_id, bool vertical, const ImVec2 size, bool interactable) {
    ImPlotContext& gp    = *GImPlot;
    ImGuiContext &G      = *GImGui;
    ImGuiWindow * Window = G.CurrentWindow;
    if (Window->SkipItems)
        return;
    ImDrawList &DrawList = *Window->DrawList;
    ImPlotPlot* plot = GetPlot(title_id);
    ImVec2 legend_size;
    ImVec2 default_size = gp.Style.LegendPadding * 2;
    if (plot != nullptr) {
        legend_size  = CalcLegendSize(plot->Items, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, vertical);
        default_size = legend_size + gp.Style.LegendPadding * 2;
    }
    ImVec2 frame_size = ImGui::CalcItemSize(size, default_size.x, default_size.y);
    ImRect bb_frame = ImRect(Window->DC.CursorPos, Window->DC.CursorPos + frame_size);
    ImGui::ItemSize(bb_frame);
    if (!ImGui::ItemAdd(bb_frame, 0, &bb_frame))
        return;
    ImGui::RenderFrame(bb_frame.Min, bb_frame.Max, GetStyleColorU32(ImPlotCol_FrameBg), true, G.Style.FrameRounding);
    DrawList.PushClipRect(bb_frame.Min, bb_frame.Max, true);
    if (plot != nullptr) {
        const ImVec2 legend_pos  = GetLocationPos(bb_frame, legend_size, 0, gp.Style.LegendPadding);
        const ImRect legend_bb(legend_pos, legend_pos + legend_size);
        interactable = interactable && bb_frame.Contains(ImGui::GetIO().MousePos);
        // render legend box
        ImU32  col_bg      = GetStyleColorU32(ImPlotCol_LegendBg);
        ImU32  col_bd      = GetStyleColorU32(ImPlotCol_LegendBorder);
        DrawList.AddRectFilled(legend_bb.Min, legend_bb.Max, col_bg);
        DrawList.AddRect(legend_bb.Min, legend_bb.Max, col_bd);
        // render entries
        ShowLegendEntries(plot->Items, legend_bb, interactable, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, vertical, DrawList);
    }
    DrawList.PopClipRect();
}

//-----------------------------------------------------------------------------
// [SECTION] Drag and Drop Utils
//-----------------------------------------------------------------------------

bool BeginDragDropTargetPlot() {
    SetupLock();
    ImPlotContext& gp = *GImPlot;
    ImRect rect = gp.CurrentPlot->PlotRect;
    return ImGui::BeginDragDropTargetCustom(rect, gp.CurrentPlot->ID);
}

bool BeginDragDropTargetAxis(ImAxis axis) {
    SetupLock();
    ImPlotPlot& plot = *GImPlot->CurrentPlot;
    ImPlotAxis& ax = plot.Axes[axis];
    ImRect rect = ax.HoverRect;
    rect.Expand(-3.5f);
    return ImGui::BeginDragDropTargetCustom(rect, ax.ID);
}

bool BeginDragDropTargetLegend() {
    SetupLock();
    ImPlotItemGroup& items = *GImPlot->CurrentItems;
    ImRect rect = items.Legend.Rect;
    return ImGui::BeginDragDropTargetCustom(rect, items.ID);
}

void EndDragDropTarget() {
    SetupLock();
	ImGui::EndDragDropTarget();
}

bool BeginDragDropSourcePlot(ImGuiDragDropFlags flags) {
    SetupLock();
    ImPlotContext& gp = *GImPlot;
    ImPlotPlot* plot = gp.CurrentPlot;
    if (GImGui->IO.KeyMods == gp.InputMap.OverrideMod || GImGui->DragDropPayload.SourceId == plot->ID)
        return ImGui::ItemAdd(plot->PlotRect, plot->ID) && ImGui::BeginDragDropSource(flags);
    return false;
}

bool BeginDragDropSourceAxis(ImAxis idx, ImGuiDragDropFlags flags) {
    SetupLock();
    ImPlotContext& gp = *GImPlot;
    ImPlotAxis& axis = gp.CurrentPlot->Axes[idx];
    if (GImGui->IO.KeyMods == gp.InputMap.OverrideMod || GImGui->DragDropPayload.SourceId == axis.ID)
        return ImGui::ItemAdd(axis.HoverRect, axis.ID) && ImGui::BeginDragDropSource(flags);
    return false;
}

bool BeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags) {
    SetupLock();
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentItems != nullptr, "BeginDragDropSourceItem() needs to be called within an itemized context!");
    ImGuiID item_id = ImGui::GetIDWithSeed(label_id, nullptr, gp.CurrentItems->ID);
    ImPlotItem* item = gp.CurrentItems->GetItem(item_id);
    if (item != nullptr) {
        return ImGui::ItemAdd(item->LegendHoverRect, item->ID) && ImGui::BeginDragDropSource(flags);
    }
    return false;
}

void EndDragDropSource() {
    SetupLock();
    ImGui::EndDragDropSource();
}

//-----------------------------------------------------------------------------
// [SECTION] Aligned Plots
//-----------------------------------------------------------------------------

bool BeginAlignedPlots(const char* group_id, bool vertical) {
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentAlignmentH == nullptr && gp.CurrentAlignmentV == nullptr, "Mismatched BeginAlignedPlots()/EndAlignedPlots()!");
    ImGuiContext &G = *GImGui;
    ImGuiWindow * Window = G.CurrentWindow;
    if (Window->SkipItems)
        return false;
    const ImGuiID ID = Window->GetID(group_id);
    ImPlotAlignmentData* alignment = gp.AlignmentData.GetOrAddByKey(ID);
    if (vertical)
        gp.CurrentAlignmentV = alignment;
    else
        gp.CurrentAlignmentH = alignment;
    if (alignment->Vertical != vertical)
        alignment->Reset();
    alignment->Vertical = vertical;
    alignment->Begin();
    return true;
}

void EndAlignedPlots() {
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentAlignmentH != nullptr || gp.CurrentAlignmentV != nullptr, "Mismatched BeginAlignedPlots()/EndAlignedPlots()!");
    ImPlotAlignmentData* alignment = gp.CurrentAlignmentH != nullptr ? gp.CurrentAlignmentH : (gp.CurrentAlignmentV != nullptr ? gp.CurrentAlignmentV : nullptr);
    if (alignment)
        alignment->End();
    ResetCtxForNextAlignedPlots(GImPlot);
}

//-----------------------------------------------------------------------------
// [SECTION] Plot and Item Styling
//-----------------------------------------------------------------------------

ImPlotStyle& GetStyle() {
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    return gp.Style;
}

void PushStyleColor(ImPlotCol idx, ImU32 col) {
    ImPlotContext& gp = *GImPlot;
    ImGuiColorMod backup;
    backup.Col = (ImGuiCol)idx;
    backup.BackupValue = gp.Style.Colors[idx];
    gp.ColorModifiers.push_back(backup);
    gp.Style.Colors[idx] = ImGui::ColorConvertU32ToFloat4(col);
}

void PushStyleColor(ImPlotCol idx, const ImVec4& col) {
    ImPlotContext& gp = *GImPlot;
    ImGuiColorMod backup;
    backup.Col = (ImGuiCol)idx;
    backup.BackupValue = gp.Style.Colors[idx];
    gp.ColorModifiers.push_back(backup);
    gp.Style.Colors[idx] = col;
}

void PopStyleColor(int count) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(count <= gp.ColorModifiers.Size, "You can't pop more modifiers than have been pushed!");
    while (count > 0)
    {
        ImGuiColorMod& backup = gp.ColorModifiers.back();
        gp.Style.Colors[backup.Col] = backup.BackupValue;
        gp.ColorModifiers.pop_back();
        count--;
    }
}

void PushStyleVar(ImPlotStyleVar idx, float val) {
    ImPlotContext& gp = *GImPlot;
    const ImPlotStyleVarInfo* var_info = GetPlotStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1) {
        float* pvar = (float*)var_info->GetVarPtr(&gp.Style);
        gp.StyleModifiers.push_back(ImGuiStyleMod((ImGuiStyleVar)idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() float variant but variable is not a float!");
}

void PushStyleVar(ImPlotStyleVar idx, int val) {
    ImPlotContext& gp = *GImPlot;
    const ImPlotStyleVarInfo* var_info = GetPlotStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_S32 && var_info->Count == 1) {
        int* pvar = (int*)var_info->GetVarPtr(&gp.Style);
        gp.StyleModifiers.push_back(ImGuiStyleMod((ImGuiStyleVar)idx, *pvar));
        *pvar = val;
        return;
    }
    else if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1) {
        float* pvar = (float*)var_info->GetVarPtr(&gp.Style);
        gp.StyleModifiers.push_back(ImGuiStyleMod((ImGuiStyleVar)idx, *pvar));
        *pvar = (float)val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() int variant but variable is not a int!");
}

void PushStyleVar(ImPlotStyleVar idx, const ImVec2& val)
{
    ImPlotContext& gp = *GImPlot;
    const ImPlotStyleVarInfo* var_info = GetPlotStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
    {
        ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&gp.Style);
        gp.StyleModifiers.push_back(ImGuiStyleMod((ImGuiStyleVar)idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() ImVec2 variant but variable is not a ImVec2!");
}

void PopStyleVar(int count) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(count <= gp.StyleModifiers.Size, "You can't pop more modifiers than have been pushed!");
    while (count > 0) {
        ImGuiStyleMod& backup = gp.StyleModifiers.back();
        const ImPlotStyleVarInfo* info = GetPlotStyleVarInfo(backup.VarIdx);
        void* data = info->GetVarPtr(&gp.Style);
        if (info->Type == ImGuiDataType_Float && info->Count == 1) {
            ((float*)data)[0] = backup.BackupFloat[0];
        }
        else if (info->Type == ImGuiDataType_Float && info->Count == 2) {
             ((float*)data)[0] = backup.BackupFloat[0];
             ((float*)data)[1] = backup.BackupFloat[1];
        }
        else if (info->Type == ImGuiDataType_S32 && info->Count == 1) {
            ((int*)data)[0] = backup.BackupInt[0];
        }
        gp.StyleModifiers.pop_back();
        count--;
    }
}

//------------------------------------------------------------------------------
// [Section] Colormaps
//------------------------------------------------------------------------------

ImPlotColormap AddColormap(const char* name, const ImVec4* colormap, int size, bool qual) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(size > 1, "The colormap size must be greater than 1!");
    IM_ASSERT_USER_ERROR(gp.ColormapData.GetIndex(name) == -1, "The colormap name has already been used!");
    ImVector<ImU32> buffer;
    buffer.resize(size);
    for (int i = 0; i < size; ++i)
        buffer[i] = ImGui::ColorConvertFloat4ToU32(colormap[i]);
    return gp.ColormapData.Append(name, buffer.Data, size, qual);
}

ImPlotColormap AddColormap(const char* name, const ImU32*  colormap, int size, bool qual) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(size > 1, "The colormap size must be greater than 1!");
    IM_ASSERT_USER_ERROR(gp.ColormapData.GetIndex(name) == -1, "The colormap name has already be used!");
    return gp.ColormapData.Append(name, colormap, size, qual);
}

int GetColormapCount() {
    ImPlotContext& gp = *GImPlot;
    return gp.ColormapData.Count;
}

const char* GetColormapName(ImPlotColormap colormap) {
    ImPlotContext& gp = *GImPlot;
    return gp.ColormapData.GetName(colormap);
}

ImPlotColormap GetColormapIndex(const char* name) {
    ImPlotContext& gp = *GImPlot;
    return gp.ColormapData.GetIndex(name);
}

void PushColormap(ImPlotColormap colormap) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(colormap >= 0 && colormap < gp.ColormapData.Count, "The colormap index is invalid!");
    gp.ColormapModifiers.push_back(gp.Style.Colormap);
    gp.Style.Colormap = colormap;
}

void PushColormap(const char* name) {
    ImPlotContext& gp = *GImPlot;
    ImPlotColormap idx = gp.ColormapData.GetIndex(name);
    IM_ASSERT_USER_ERROR(idx != -1, "The colormap name is invalid!");
    PushColormap(idx);
}

void PopColormap(int count) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(count <= gp.ColormapModifiers.Size, "You can't pop more modifiers than have been pushed!");
    while (count > 0) {
        const ImPlotColormap& backup = gp.ColormapModifiers.back();
        gp.Style.Colormap     = backup;
        gp.ColormapModifiers.pop_back();
        count--;
    }
}

ImU32 NextColormapColorU32() {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentItems != nullptr, "NextColormapColor() needs to be called between BeginPlot() and EndPlot()!");
    int idx = gp.CurrentItems->ColormapIdx % gp.ColormapData.GetKeyCount(gp.Style.Colormap);
    ImU32 col  = gp.ColormapData.GetKeyColor(gp.Style.Colormap, idx);
    gp.CurrentItems->ColormapIdx++;
    return col;
}

ImVec4 NextColormapColor() {
    return ImGui::ColorConvertU32ToFloat4(NextColormapColorU32());
}

int GetColormapSize(ImPlotColormap cmap) {
    ImPlotContext& gp = *GImPlot;
    cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
    IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
    return gp.ColormapData.GetKeyCount(cmap);
}

ImU32 GetColormapColorU32(int idx, ImPlotColormap cmap) {
    ImPlotContext& gp = *GImPlot;
    cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
    IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
    idx = idx % gp.ColormapData.GetKeyCount(cmap);
    return gp.ColormapData.GetKeyColor(cmap, idx);
}

ImVec4 GetColormapColor(int idx, ImPlotColormap cmap) {
    return ImGui::ColorConvertU32ToFloat4(GetColormapColorU32(idx,cmap));
}

ImU32  SampleColormapU32(float t, ImPlotColormap cmap) {
    ImPlotContext& gp = *GImPlot;
    cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
    IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
    return gp.ColormapData.LerpTable(cmap, t);
}

ImVec4 SampleColormap(float t, ImPlotColormap cmap) {
    return ImGui::ColorConvertU32ToFloat4(SampleColormapU32(t,cmap));
}

void RenderColorBar(const ImU32* colors, int size, ImDrawList& DrawList, const ImRect& bounds, bool vert, bool reversed, bool continuous) {
    const int n = continuous ? size - 1 : size;
    ImU32 col1, col2;
    if (vert) {
        const float step = bounds.GetHeight() / n;
        ImRect rect(bounds.Min.x, bounds.Min.y, bounds.Max.x, bounds.Min.y + step);
        for (int i = 0; i < n; ++i) {
            if (reversed) {
                col1 = colors[size-i-1];
                col2 = continuous ? colors[size-i-2] : col1;
            }
            else {
                col1 = colors[i];
                col2 = continuous ? colors[i+1] : col1;
            }
            DrawList.AddRectFilledMultiColor(rect.Min, rect.Max, col1, col1, col2, col2);
            rect.TranslateY(step);
        }
    }
    else {
        const float step = bounds.GetWidth() / n;
        ImRect rect(bounds.Min.x, bounds.Min.y, bounds.Min.x + step, bounds.Max.y);
        for (int i = 0; i < n; ++i) {
            if (reversed) {
                col1 = colors[size-i-1];
                col2 = continuous ? colors[size-i-2] : col1;
            }
            else {
                col1 = colors[i];
                col2 = continuous ? colors[i+1] : col1;
            }
            DrawList.AddRectFilledMultiColor(rect.Min, rect.Max, col1, col2, col2, col1);
            rect.TranslateX(step);
        }
    }
}

void ColormapScale(const char* label, double scale_min, double scale_max, const ImVec2& size, const char* format, ImPlotColormapScaleFlags flags, ImPlotColormap cmap) {
    ImGuiContext &G      = *GImGui;
    ImGuiWindow * Window = G.CurrentWindow;
    if (Window->SkipItems)
        return;

    const ImGuiID ID = Window->GetID(label);
    ImVec2 label_size(0,0);
    if (!ImHasFlag(flags, ImPlotColormapScaleFlags_NoLabel)) {
        label_size = ImGui::CalcTextSize(label,nullptr,true);
    }

    ImPlotContext& gp = *GImPlot;
    cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
    IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");

    ImVec2 frame_size  = ImGui::CalcItemSize(size, 0, gp.Style.PlotDefaultSize.y);
    if (frame_size.y < gp.Style.PlotMinSize.y && size.y < 0.0f)
        frame_size.y = gp.Style.PlotMinSize.y;

    ImPlotRange range(ImMin(scale_min,scale_max), ImMax(scale_min,scale_max));
    gp.CTicker.Reset();
    Locator_Default(gp.CTicker, range, frame_size.y, true, Formatter_Default, (void*)format);

    const bool rend_label = label_size.x > 0;
    const float txt_off   = gp.Style.LabelPadding.x;
    const float pad       = txt_off + gp.CTicker.MaxSize.x + (rend_label ? txt_off + label_size.y : 0);
    float bar_w           = 20;
    if (frame_size.x == 0)
        frame_size.x = bar_w + pad + 2 * gp.Style.PlotPadding.x;
    else {
        bar_w = frame_size.x - (pad + 2 * gp.Style.PlotPadding.x);
        if (bar_w < gp.Style.MajorTickLen.y)
            bar_w = gp.Style.MajorTickLen.y;
    }

    ImDrawList &DrawList = *Window->DrawList;
    ImRect bb_frame = ImRect(Window->DC.CursorPos, Window->DC.CursorPos + frame_size);
    ImGui::ItemSize(bb_frame);
    if (!ImGui::ItemAdd(bb_frame, ID, &bb_frame))
        return;

    ImGui::RenderFrame(bb_frame.Min, bb_frame.Max, GetStyleColorU32(ImPlotCol_FrameBg), true, G.Style.FrameRounding);

    const bool opposite = ImHasFlag(flags, ImPlotColormapScaleFlags_Opposite);
    const bool inverted = ImHasFlag(flags, ImPlotColormapScaleFlags_Invert);
    const bool reversed = scale_min > scale_max;

    float bb_grad_shift = opposite ? pad : 0;
    ImRect bb_grad(bb_frame.Min + gp.Style.PlotPadding + ImVec2(bb_grad_shift, 0),
                   bb_frame.Min + ImVec2(bar_w + gp.Style.PlotPadding.x + bb_grad_shift,
                                         frame_size.y - gp.Style.PlotPadding.y));

    ImGui::PushClipRect(bb_frame.Min, bb_frame.Max, true);
    const ImU32 col_text = ImGui::GetColorU32(ImGuiCol_Text);

    const bool invert_scale = inverted ? (reversed ? false : true) : (reversed ? true : false);
    const float y_min = invert_scale ? bb_grad.Max.y : bb_grad.Min.y;
    const float y_max = invert_scale ? bb_grad.Min.y : bb_grad.Max.y;

    RenderColorBar(gp.ColormapData.GetKeys(cmap), gp.ColormapData.GetKeyCount(cmap), DrawList, bb_grad, true, !inverted, !gp.ColormapData.IsQual(cmap));
    for (int i = 0; i < gp.CTicker.TickCount(); ++i) {
        const double y_pos_plt = gp.CTicker.Ticks[i].PlotPos;
        const float y_pos = ImRemap((float)y_pos_plt, (float)range.Max, (float)range.Min, y_min, y_max);
        const float tick_width = gp.CTicker.Ticks[i].Major ? gp.Style.MajorTickLen.y : gp.Style.MinorTickLen.y;
        const float tick_thick = gp.CTicker.Ticks[i].Major ? gp.Style.MajorTickSize.y : gp.Style.MinorTickSize.y;
        const float tick_t     = (float)((y_pos_plt - scale_min) / (scale_max - scale_min));
        const ImU32 tick_col = CalcTextColor(gp.ColormapData.LerpTable(cmap,tick_t));
        if (y_pos < bb_grad.Max.y - 2 && y_pos > bb_grad.Min.y + 2) {
            DrawList.AddLine(opposite ? ImVec2(bb_grad.Min.x+1, y_pos) : ImVec2(bb_grad.Max.x-1, y_pos),
                             opposite ? ImVec2(bb_grad.Min.x + tick_width, y_pos) : ImVec2(bb_grad.Max.x - tick_width, y_pos),
                             tick_col,
                             tick_thick);
        }
        const float txt_x = opposite ? bb_grad.Min.x - txt_off - gp.CTicker.Ticks[i].LabelSize.x : bb_grad.Max.x + txt_off;
        const float txt_y = y_pos - gp.CTicker.Ticks[i].LabelSize.y * 0.5f;
        DrawList.AddText(ImVec2(txt_x, txt_y), col_text, gp.CTicker.GetText(i));
    }

    if (rend_label) {
        const float pos_x = opposite ? bb_frame.Min.x + gp.Style.PlotPadding.x : bb_grad.Max.x + 2 * txt_off + gp.CTicker.MaxSize.x;
        const float pos_y = bb_grad.GetCenter().y + label_size.x * 0.5f;
        const char* label_end = ImGui::FindRenderedTextEnd(label);
        AddTextVertical(&DrawList,ImVec2(pos_x,pos_y),col_text,label,label_end);
    }
    DrawList.AddRect(bb_grad.Min, bb_grad.Max, GetStyleColorU32(ImPlotCol_PlotBorder));
    ImGui::PopClipRect();
}

bool ColormapSlider(const char* label, float* t, ImVec4* out, const char* format, ImPlotColormap cmap) {
    *t = ImClamp(*t,0.0f,1.0f);
    ImGuiContext &G      = *GImGui;
    ImGuiWindow * Window = G.CurrentWindow;
    if (Window->SkipItems)
        return false;
    ImPlotContext& gp = *GImPlot;
    cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
    IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
    const ImU32* keys  = gp.ColormapData.GetKeys(cmap);
    const int    count = gp.ColormapData.GetKeyCount(cmap);
    const bool   qual  = gp.ColormapData.IsQual(cmap);
    const ImVec2 pos  = ImGui::GetCurrentWindow()->DC.CursorPos;
    const float w     = ImGui::CalcItemWidth();
    const float h     = ImGui::GetFrameHeight();
    const ImRect rect = ImRect(pos.x,pos.y,pos.x+w,pos.y+h);
    RenderColorBar(keys,count,*ImGui::GetWindowDrawList(),rect,false,false,!qual);
    const ImU32 grab = CalcTextColor(gp.ColormapData.LerpTable(cmap,*t));
    // const ImU32 text = CalcTextColor(gp.ColormapData.LerpTable(cmap,0.5f));
    ImGui::PushStyleColor(ImGuiCol_FrameBg,IM_COL32_BLACK_TRANS);
    ImGui::PushStyleColor(ImGuiCol_FrameBgActive,IM_COL32_BLACK_TRANS);
    ImGui::PushStyleColor(ImGuiCol_FrameBgHovered,ImVec4(1,1,1,0.1f));
    ImGui::PushStyleColor(ImGuiCol_SliderGrab,grab);
    ImGui::PushStyleColor(ImGuiCol_SliderGrabActive, grab);
    ImGui::PushStyleVar(ImGuiStyleVar_GrabMinSize,2);
    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding,0);
    const bool changed = ImGui::SliderFloat(label,t,0,1,format);
    ImGui::PopStyleColor(5);
    ImGui::PopStyleVar(2);
    if (out != nullptr)
        *out = ImGui::ColorConvertU32ToFloat4(gp.ColormapData.LerpTable(cmap,*t));
    return changed;
}

bool ColormapButton(const char* label, const ImVec2& size_arg, ImPlotColormap cmap) {
    ImGuiContext &G      = *GImGui;
    const ImGuiStyle& style = G.Style;
    ImGuiWindow * Window = G.CurrentWindow;
    if (Window->SkipItems)
        return false;
    ImPlotContext& gp = *GImPlot;
    cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
    IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
    const ImU32* keys  = gp.ColormapData.GetKeys(cmap);
    const int    count = gp.ColormapData.GetKeyCount(cmap);
    const bool   qual  = gp.ColormapData.IsQual(cmap);
    const ImVec2 pos  = ImGui::GetCurrentWindow()->DC.CursorPos;
    const ImVec2 label_size = ImGui::CalcTextSize(label, nullptr, true);
    ImVec2 size = ImGui::CalcItemSize(size_arg, label_size.x + style.FramePadding.x * 2.0f, label_size.y + style.FramePadding.y * 2.0f);
    const ImRect rect = ImRect(pos.x,pos.y,pos.x+size.x,pos.y+size.y);
    RenderColorBar(keys,count,*ImGui::GetWindowDrawList(),rect,false,false,!qual);
    const ImU32 text = CalcTextColor(gp.ColormapData.LerpTable(cmap,G.Style.ButtonTextAlign.x));
    ImGui::PushStyleColor(ImGuiCol_Button,IM_COL32_BLACK_TRANS);
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered,ImVec4(1,1,1,0.1f));
    ImGui::PushStyleColor(ImGuiCol_ButtonActive,ImVec4(1,1,1,0.2f));
    ImGui::PushStyleColor(ImGuiCol_Text,text);
    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding,0);
    const bool pressed = ImGui::Button(label,size);
    ImGui::PopStyleColor(4);
    ImGui::PopStyleVar(1);
    return pressed;
}

//-----------------------------------------------------------------------------
// [Section] Miscellaneous
//-----------------------------------------------------------------------------

ImPlotInputMap& GetInputMap() {
    IM_ASSERT_USER_ERROR(GImPlot != nullptr, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
    ImPlotContext& gp = *GImPlot;
    return gp.InputMap;
}

void MapInputDefault(ImPlotInputMap* dst) {
    ImPlotInputMap& map = dst ? *dst : GetInputMap();
    map.Pan             = ImGuiMouseButton_Left;
    map.PanMod          = ImGuiMod_None;
    map.Fit             = ImGuiMouseButton_Left;
    map.Menu            = ImGuiMouseButton_Right;
    map.Select          = ImGuiMouseButton_Right;
    map.SelectMod       = ImGuiMod_None;
    map.SelectCancel    = ImGuiMouseButton_Left;
    map.SelectHorzMod   = ImGuiMod_Alt;
    map.SelectVertMod   = ImGuiMod_Shift;
    map.OverrideMod     = ImGuiMod_Ctrl;
    map.ZoomMod         = ImGuiMod_None;
    map.ZoomRate        = 0.1f;
}

void MapInputReverse(ImPlotInputMap* dst) {
    ImPlotInputMap& map = dst ? *dst : GetInputMap();
    map.Pan             = ImGuiMouseButton_Right;
    map.PanMod          = ImGuiMod_None;
    map.Fit             = ImGuiMouseButton_Left;
    map.Menu            = ImGuiMouseButton_Right;
    map.Select          = ImGuiMouseButton_Left;
    map.SelectMod       = ImGuiMod_None;
    map.SelectCancel    = ImGuiMouseButton_Right;
    map.SelectHorzMod   = ImGuiMod_Alt;
    map.SelectVertMod   = ImGuiMod_Shift;
    map.OverrideMod     = ImGuiMod_Ctrl;
    map.ZoomMod         = ImGuiMod_None;
    map.ZoomRate        = 0.1f;
}

//-----------------------------------------------------------------------------
// [Section] Miscellaneous
//-----------------------------------------------------------------------------

void ItemIcon(const ImVec4& col) {
    ItemIcon(ImGui::ColorConvertFloat4ToU32(col));
}

void ItemIcon(ImU32 col) {
    const float txt_size = ImGui::GetTextLineHeight();
    ImVec2 size(txt_size-4,txt_size);
    ImGuiWindow* window = ImGui::GetCurrentWindow();
    ImVec2 pos = window->DC.CursorPos;
    ImGui::GetWindowDrawList()->AddRectFilled(pos + ImVec2(0,2), pos + size - ImVec2(0,2), col);
    ImGui::Dummy(size);
}

void ColormapIcon(ImPlotColormap cmap) {
    ImPlotContext& gp = *GImPlot;
    const float txt_size = ImGui::GetTextLineHeight();
    ImVec2 size(txt_size-4,txt_size);
    ImGuiWindow* window = ImGui::GetCurrentWindow();
    ImVec2 pos = window->DC.CursorPos;
    ImRect rect(pos+ImVec2(0,2),pos+size-ImVec2(0,2));
    ImDrawList& DrawList = *ImGui::GetWindowDrawList();
    RenderColorBar(gp.ColormapData.GetKeys(cmap),gp.ColormapData.GetKeyCount(cmap),DrawList,rect,false,false,!gp.ColormapData.IsQual(cmap));
    ImGui::Dummy(size);
}

ImDrawList* GetPlotDrawList() {
    return ImGui::GetWindowDrawList();
}

void PushPlotClipRect(float expand) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "PushPlotClipRect() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    ImRect rect = gp.CurrentPlot->PlotRect;
    rect.Expand(expand);
    ImGui::PushClipRect(rect.Min, rect.Max, true);
}

void PopPlotClipRect() {
    SetupLock();
    ImGui::PopClipRect();
}

static void HelpMarker(const char* desc) {
    ImGui::TextDisabled("(?)");
    if (ImGui::IsItemHovered()) {
        ImGui::BeginTooltip();
        ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
        ImGui::TextUnformatted(desc);
        ImGui::PopTextWrapPos();
        ImGui::EndTooltip();
    }
}

bool ShowStyleSelector(const char* label)
{
    static int style_idx = -1;
    if (ImGui::Combo(label, &style_idx, "Auto\0Classic\0Dark\0Light\0"))
    {
        switch (style_idx)
        {
        case 0: StyleColorsAuto(); break;
        case 1: StyleColorsClassic(); break;
        case 2: StyleColorsDark(); break;
        case 3: StyleColorsLight(); break;
        }
        return true;
    }
    return false;
}

bool ShowColormapSelector(const char* label) {
    ImPlotContext& gp = *GImPlot;
    bool set = false;
    if (ImGui::BeginCombo(label, gp.ColormapData.GetName(gp.Style.Colormap))) {
        for (int i = 0; i < gp.ColormapData.Count; ++i) {
            const char* name = gp.ColormapData.GetName(i);
            if (ImGui::Selectable(name, gp.Style.Colormap == i)) {
                gp.Style.Colormap = i;
                ImPlot::BustItemCache();
                set = true;
            }
        }
        ImGui::EndCombo();
    }
    return set;
}

bool ShowInputMapSelector(const char* label) {
    static int map_idx = -1;
    if (ImGui::Combo(label, &map_idx, "Default\0Reversed\0"))
    {
        switch (map_idx)
        {
        case 0: MapInputDefault(); break;
        case 1: MapInputReverse(); break;
        }
        return true;
    }
    return false;
}


void ShowStyleEditor(ImPlotStyle* ref) {
    ImPlotContext& gp = *GImPlot;
    ImPlotStyle& style = GetStyle();
    static ImPlotStyle ref_saved_style;
    // Default to using internal storage as reference
    static bool init = true;
    if (init && ref == nullptr)
        ref_saved_style = style;
    init = false;
    if (ref == nullptr)
        ref = &ref_saved_style;

    if (ImPlot::ShowStyleSelector("Colors##Selector"))
        ref_saved_style = style;

    // Save/Revert button
    if (ImGui::Button("Save Ref"))
        *ref = ref_saved_style = style;
    ImGui::SameLine();
    if (ImGui::Button("Revert Ref"))
        style = *ref;
    ImGui::SameLine();
    HelpMarker("Save/Revert in local non-persistent storage. Default Colors definition are not affected. "
               "Use \"Export\" below to save them somewhere.");
    if (ImGui::BeginTabBar("##StyleEditor")) {
        if (ImGui::BeginTabItem("Variables")) {
            ImGui::Text("Item Styling");
            ImGui::SliderFloat("LineWeight", &style.LineWeight, 0.0f, 5.0f, "%.1f");
            ImGui::SliderFloat("MarkerSize", &style.MarkerSize, 2.0f, 10.0f, "%.1f");
            ImGui::SliderFloat("MarkerWeight", &style.MarkerWeight, 0.0f, 5.0f, "%.1f");
            ImGui::SliderFloat("FillAlpha", &style.FillAlpha, 0.0f, 1.0f, "%.2f");
            ImGui::SliderFloat("ErrorBarSize", &style.ErrorBarSize, 0.0f, 10.0f, "%.1f");
            ImGui::SliderFloat("ErrorBarWeight", &style.ErrorBarWeight, 0.0f, 5.0f, "%.1f");
            ImGui::SliderFloat("DigitalBitHeight", &style.DigitalBitHeight, 0.0f, 20.0f, "%.1f");
            ImGui::SliderFloat("DigitalBitGap", &style.DigitalBitGap, 0.0f, 20.0f, "%.1f");
            ImGui::Text("Plot Styling");
            ImGui::SliderFloat("PlotBorderSize", &style.PlotBorderSize, 0.0f, 2.0f, "%.0f");
            ImGui::SliderFloat("MinorAlpha", &style.MinorAlpha, 0.0f, 1.0f, "%.2f");
            ImGui::SliderFloat2("MajorTickLen", (float*)&style.MajorTickLen, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("MinorTickLen", (float*)&style.MinorTickLen, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("MajorTickSize",  (float*)&style.MajorTickSize, 0.0f, 2.0f, "%.1f");
            ImGui::SliderFloat2("MinorTickSize", (float*)&style.MinorTickSize, 0.0f, 2.0f, "%.1f");
            ImGui::SliderFloat2("MajorGridSize", (float*)&style.MajorGridSize, 0.0f, 2.0f, "%.1f");
            ImGui::SliderFloat2("MinorGridSize", (float*)&style.MinorGridSize, 0.0f, 2.0f, "%.1f");
            ImGui::SliderFloat2("PlotDefaultSize", (float*)&style.PlotDefaultSize, 0.0f, 1000, "%.0f");
            ImGui::SliderFloat2("PlotMinSize", (float*)&style.PlotMinSize, 0.0f, 300, "%.0f");
            ImGui::Text("Plot Padding");
            ImGui::SliderFloat2("PlotPadding", (float*)&style.PlotPadding, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("LabelPadding", (float*)&style.LabelPadding, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("LegendPadding", (float*)&style.LegendPadding, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("LegendInnerPadding", (float*)&style.LegendInnerPadding, 0.0f, 10.0f, "%.0f");
            ImGui::SliderFloat2("LegendSpacing", (float*)&style.LegendSpacing, 0.0f, 5.0f, "%.0f");
            ImGui::SliderFloat2("MousePosPadding", (float*)&style.MousePosPadding, 0.0f, 20.0f, "%.0f");
            ImGui::SliderFloat2("AnnotationPadding", (float*)&style.AnnotationPadding, 0.0f, 5.0f, "%.0f");
            ImGui::SliderFloat2("FitPadding", (float*)&style.FitPadding, 0, 0.2f, "%.2f");

            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Colors")) {
            static int output_dest = 0;
            static bool output_only_modified = false;

            if (ImGui::Button("Export", ImVec2(75,0))) {
                if (output_dest == 0)
                    ImGui::LogToClipboard();
                else
                    ImGui::LogToTTY();
                ImGui::LogText("ImVec4* colors = ImPlot::GetStyle().Colors;\n");
                for (int i = 0; i < ImPlotCol_COUNT; i++) {
                    const ImVec4& col = style.Colors[i];
                    const char* name = ImPlot::GetStyleColorName(i);
                    if (!output_only_modified || memcmp(&col, &ref->Colors[i], sizeof(ImVec4)) != 0) {
                        if (IsColorAuto(i))
                            ImGui::LogText("colors[ImPlotCol_%s]%*s= IMPLOT_AUTO_COL;\n",name,14 - (int)strlen(name), "");
                        else
                            ImGui::LogText("colors[ImPlotCol_%s]%*s= ImVec4(%.2ff, %.2ff, %.2ff, %.2ff);\n",
                                        name, 14 - (int)strlen(name), "", col.x, col.y, col.z, col.w);
                    }
                }
                ImGui::LogFinish();
            }
            ImGui::SameLine(); ImGui::SetNextItemWidth(120); ImGui::Combo("##output_type", &output_dest, "To Clipboard\0To TTY\0");
            ImGui::SameLine(); ImGui::Checkbox("Only Modified Colors", &output_only_modified);

            static ImGuiTextFilter filter;
            filter.Draw("Filter colors", ImGui::GetFontSize() * 16);

            static ImGuiColorEditFlags alpha_flags = ImGuiColorEditFlags_AlphaPreviewHalf;
            if (ImGui::RadioButton("Opaque", alpha_flags == ImGuiColorEditFlags_None))             { alpha_flags = ImGuiColorEditFlags_None; } ImGui::SameLine();
            if (ImGui::RadioButton("Alpha",  alpha_flags == ImGuiColorEditFlags_AlphaPreview))     { alpha_flags = ImGuiColorEditFlags_AlphaPreview; } ImGui::SameLine();
            if (ImGui::RadioButton("Both",   alpha_flags == ImGuiColorEditFlags_AlphaPreviewHalf)) { alpha_flags = ImGuiColorEditFlags_AlphaPreviewHalf; } ImGui::SameLine();
            HelpMarker(
                "In the color list:\n"
                "Left-click on colored square to open color picker,\n"
                "Right-click to open edit options menu.");
            ImGui::Separator();
            ImGui::PushItemWidth(-160);
            for (int i = 0; i < ImPlotCol_COUNT; i++) {
                const char* name = ImPlot::GetStyleColorName(i);
                if (!filter.PassFilter(name))
                    continue;
                ImGui::PushID(i);
                ImVec4 temp = GetStyleColorVec4(i);
                const bool is_auto = IsColorAuto(i);
                if (!is_auto)
                    ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.25f);
                if (ImGui::Button("Auto")) {
                    if (is_auto)
                        style.Colors[i] = temp;
                    else
                        style.Colors[i] = IMPLOT_AUTO_COL;
                    BustItemCache();
                }
                if (!is_auto)
                    ImGui::PopStyleVar();
                ImGui::SameLine();
                if (ImGui::ColorEdit4(name, &temp.x, ImGuiColorEditFlags_NoInputs | alpha_flags)) {
                    style.Colors[i] = temp;
                    BustItemCache();
                }
                if (memcmp(&style.Colors[i], &ref->Colors[i], sizeof(ImVec4)) != 0) {
                    ImGui::SameLine(175); if (ImGui::Button("Save")) { ref->Colors[i] = style.Colors[i]; }
                    ImGui::SameLine(); if (ImGui::Button("Revert")) {
                        style.Colors[i] = ref->Colors[i];
                        BustItemCache();
                    }
                }
                ImGui::PopID();
            }
            ImGui::PopItemWidth();
            ImGui::Separator();
            ImGui::Text("Colors that are set to Auto (i.e. IMPLOT_AUTO_COL) will\n"
                        "be automatically deduced from your ImGui style or the\n"
                        "current ImPlot Colormap. If you want to style individual\n"
                        "plot items, use Push/PopStyleColor around its function.");
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Colormaps")) {
            static int output_dest = 0;
            if (ImGui::Button("Export", ImVec2(75,0))) {
                if (output_dest == 0)
                    ImGui::LogToClipboard();
                else
                    ImGui::LogToTTY();
                int size = GetColormapSize();
                const char* name = GetColormapName(gp.Style.Colormap);
                ImGui::LogText("static const ImU32 %s_Data[%d] = {\n", name, size);
                for (int i = 0; i < size; ++i) {
                    ImU32 col = GetColormapColorU32(i,gp.Style.Colormap);
                    ImGui::LogText("    %u%s\n", col, i == size - 1 ? "" : ",");
                }
                ImGui::LogText("};\nImPlotColormap %s = ImPlot::AddColormap(\"%s\", %s_Data, %d);", name, name, name, size);
                ImGui::LogFinish();
            }
            ImGui::SameLine(); ImGui::SetNextItemWidth(120); ImGui::Combo("##output_type", &output_dest, "To Clipboard\0To TTY\0");
            ImGui::SameLine();
            static bool edit = false;
            ImGui::Checkbox("Edit Mode",&edit);

            // built-in/added
            ImGui::Separator();
            for (int i = 0; i < gp.ColormapData.Count; ++i) {
                ImGui::PushID(i);
                int size = gp.ColormapData.GetKeyCount(i);
                bool selected = i == gp.Style.Colormap;

                const char* name = GetColormapName(i);
                if (!selected)
                    ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.25f);
                if (ImGui::Button(name, ImVec2(100,0))) {
                    gp.Style.Colormap = i;
                    BustItemCache();
                }
                if (!selected)
                    ImGui::PopStyleVar();
                ImGui::SameLine();
                ImGui::BeginGroup();
                if (edit) {
                    for (int c = 0; c < size; ++c) {
                        ImGui::PushID(c);
                        ImVec4 col4 = ImGui::ColorConvertU32ToFloat4(gp.ColormapData.GetKeyColor(i,c));
                        if (ImGui::ColorEdit4("",&col4.x,ImGuiColorEditFlags_NoInputs)) {
                            ImU32 col32 = ImGui::ColorConvertFloat4ToU32(col4);
                            gp.ColormapData.SetKeyColor(i,c,col32);
                            BustItemCache();
                        }
                        if ((c + 1) % 12 != 0 && c != size -1)
                            ImGui::SameLine();
                        ImGui::PopID();
                    }
                }
                else {
                    if (ImPlot::ColormapButton("##",ImVec2(-1,0),i))
                        edit = true;
                }
                ImGui::EndGroup();
                ImGui::PopID();
            }


            static ImVector<ImVec4> custom;
            if (custom.Size == 0) {
                custom.push_back(ImVec4(1,0,0,1));
                custom.push_back(ImVec4(0,1,0,1));
                custom.push_back(ImVec4(0,0,1,1));
            }
            ImGui::Separator();
            ImGui::BeginGroup();
            static char name[16] = "MyColormap";


            if (ImGui::Button("+", ImVec2((100 - ImGui::GetStyle().ItemSpacing.x)/2,0)))
                custom.push_back(ImVec4(0,0,0,1));
            ImGui::SameLine();
            if (ImGui::Button("-", ImVec2((100 - ImGui::GetStyle().ItemSpacing.x)/2,0)) && custom.Size > 2)
                custom.pop_back();
            ImGui::SetNextItemWidth(100);
            ImGui::InputText("##Name",name,16,ImGuiInputTextFlags_CharsNoBlank);
            static bool qual = true;
            ImGui::Checkbox("Qualitative",&qual);
            if (ImGui::Button("Add", ImVec2(100, 0)) && gp.ColormapData.GetIndex(name)==-1)
                AddColormap(name,custom.Data,custom.Size,qual);

            ImGui::EndGroup();
            ImGui::SameLine();
            ImGui::BeginGroup();
            for (int c = 0; c < custom.Size; ++c) {
                ImGui::PushID(c);
                if (ImGui::ColorEdit4("##Col1", &custom[c].x, ImGuiColorEditFlags_NoInputs)) {

                }
                if ((c + 1) % 12 != 0)
                    ImGui::SameLine();
                ImGui::PopID();
            }
            ImGui::EndGroup();


            ImGui::EndTabItem();
        }
        ImGui::EndTabBar();
    }
}

void ShowUserGuide() {
        ImGui::BulletText("Left-click drag within the plot area to pan X and Y axes.");
    ImGui::Indent();
        ImGui::BulletText("Left-click drag on axis labels to pan an individual axis.");
    ImGui::Unindent();
    ImGui::BulletText("Scroll in the plot area to zoom both X any Y axes.");
    ImGui::Indent();
        ImGui::BulletText("Scroll on axis labels to zoom an individual axis.");
    ImGui::Unindent();
    ImGui::BulletText("Right-click drag to box select data.");
    ImGui::Indent();
        ImGui::BulletText("Hold Alt to expand box selection horizontally.");
        ImGui::BulletText("Hold Shift to expand box selection vertically.");
        ImGui::BulletText("Left-click while box selecting to cancel the selection.");
    ImGui::Unindent();
    ImGui::BulletText("Double left-click to fit all visible data.");
    ImGui::Indent();
        ImGui::BulletText("Double left-click axis labels to fit the individual axis.");
    ImGui::Unindent();
    ImGui::BulletText("Right-click open the full plot context menu.");
    ImGui::Indent();
        ImGui::BulletText("Right-click axis labels to open an individual axis context menu.");
    ImGui::Unindent();
    ImGui::BulletText("Click legend label icons to show/hide plot items.");
}

void ShowTicksMetrics(const ImPlotTicker& ticker) {
    ImGui::BulletText("Size: %d", ticker.TickCount());
    ImGui::BulletText("MaxSize: [%f,%f]", ticker.MaxSize.x, ticker.MaxSize.y);
}

void ShowAxisMetrics(const ImPlotPlot& plot, const ImPlotAxis& axis) {
    ImGui::BulletText("Label: %s", axis.LabelOffset == -1 ? "[none]" : plot.GetAxisLabel(axis));
    ImGui::BulletText("Flags: 0x%08X", axis.Flags);
    ImGui::BulletText("Range: [%f,%f]",axis.Range.Min, axis.Range.Max);
    ImGui::BulletText("Pixels: %f", axis.PixelSize());
    ImGui::BulletText("Aspect: %f", axis.GetAspect());
    ImGui::BulletText(axis.OrthoAxis == nullptr ? "OrtherAxis: NULL" : "OrthoAxis: 0x%08X", axis.OrthoAxis->ID);
    ImGui::BulletText("LinkedMin: %p", (void*)axis.LinkedMin);
    ImGui::BulletText("LinkedMax: %p", (void*)axis.LinkedMax);
    ImGui::BulletText("HasRange: %s", axis.HasRange ? "true" : "false");
    ImGui::BulletText("Hovered: %s", axis.Hovered ? "true" : "false");
    ImGui::BulletText("Held: %s", axis.Held ? "true" : "false");

    if (ImGui::TreeNode("Transform")) {
        ImGui::BulletText("PixelMin: %f", axis.PixelMin);
        ImGui::BulletText("PixelMax: %f", axis.PixelMax);
        ImGui::BulletText("ScaleToPixel: %f", axis.ScaleToPixel);
        ImGui::BulletText("ScaleMax: %f", axis.ScaleMax);
        ImGui::TreePop();
    }

    if (ImGui::TreeNode("Ticks")) {
        ShowTicksMetrics(axis.Ticker);
        ImGui::TreePop();
    }
}

void ShowMetricsWindow(bool* p_popen) {

    static bool show_plot_rects = false;
    static bool show_axes_rects = false;
    static bool show_axis_rects = false;
    static bool show_canvas_rects = false;
    static bool show_frame_rects = false;
    static bool show_subplot_frame_rects = false;
    static bool show_subplot_grid_rects = false;

    ImDrawList& fg = *ImGui::GetForegroundDrawList();

    ImPlotContext& gp = *GImPlot;
    // ImGuiContext& g = *GImGui;
    ImGuiIO& io = ImGui::GetIO();
    ImGui::Begin("ImPlot Metrics", p_popen);
    ImGui::Text("ImPlot " IMPLOT_VERSION);
    ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
    ImGui::Text("Mouse Position: [%.0f,%.0f]", io.MousePos.x, io.MousePos.y);
    ImGui::Separator();
    if (ImGui::TreeNode("Tools")) {
        if (ImGui::Button("Bust Plot Cache"))
            BustPlotCache();
        ImGui::SameLine();
        if (ImGui::Button("Bust Item Cache"))
            BustItemCache();
        ImGui::Checkbox("Show Frame Rects", &show_frame_rects);
        ImGui::Checkbox("Show Canvas Rects",&show_canvas_rects);
        ImGui::Checkbox("Show Plot Rects",  &show_plot_rects);
        ImGui::Checkbox("Show Axes Rects",  &show_axes_rects);
        ImGui::Checkbox("Show Axis Rects",  &show_axis_rects);
        ImGui::Checkbox("Show Subplot Frame Rects",  &show_subplot_frame_rects);
        ImGui::Checkbox("Show Subplot Grid Rects",  &show_subplot_grid_rects);
        ImGui::TreePop();
    }
    const int n_plots = gp.Plots.GetBufSize();
    const int n_subplots = gp.Subplots.GetBufSize();
    // render rects
    for (int p = 0; p < n_plots; ++p) {
        ImPlotPlot* plot = gp.Plots.GetByIndex(p);
        if (show_frame_rects)
            fg.AddRect(plot->FrameRect.Min, plot->FrameRect.Max, IM_COL32(255,0,255,255));
        if (show_canvas_rects)
            fg.AddRect(plot->CanvasRect.Min, plot->CanvasRect.Max, IM_COL32(0,255,255,255));
        if (show_plot_rects)
            fg.AddRect(plot->PlotRect.Min, plot->PlotRect.Max, IM_COL32(255,255,0,255));
        if (show_axes_rects)
            fg.AddRect(plot->AxesRect.Min, plot->AxesRect.Max, IM_COL32(0,255,128,255));
        if (show_axis_rects) {
            for (int i = 0; i < ImAxis_COUNT; ++i) {
                if (plot->Axes[i].Enabled)
                    fg.AddRect(plot->Axes[i].HoverRect.Min, plot->Axes[i].HoverRect.Max, IM_COL32(0,255,0,255));
            }
        }
    }
    for (int p = 0; p < n_subplots; ++p) {
        ImPlotSubplot* subplot = gp.Subplots.GetByIndex(p);
        if (show_subplot_frame_rects)
            fg.AddRect(subplot->FrameRect.Min, subplot->FrameRect.Max, IM_COL32(255,0,0,255));
        if (show_subplot_grid_rects)
            fg.AddRect(subplot->GridRect.Min, subplot->GridRect.Max, IM_COL32(0,0,255,255));
    }
    if (ImGui::TreeNode("Plots","Plots (%d)", n_plots)) {
        for (int p = 0; p < n_plots; ++p) {
            // plot
            ImPlotPlot& plot = *gp.Plots.GetByIndex(p);
            ImGui::PushID(p);
            if (ImGui::TreeNode("Plot", "Plot [0x%08X]", plot.ID)) {
                int n_items = plot.Items.GetItemCount();
                if (ImGui::TreeNode("Items", "Items (%d)", n_items)) {
                    for (int i = 0; i < n_items; ++i) {
                        ImPlotItem* item = plot.Items.GetItemByIndex(i);
                        ImGui::PushID(i);
                        if (ImGui::TreeNode("Item", "Item [0x%08X]", item->ID)) {
                            ImGui::Bullet(); ImGui::Checkbox("Show", &item->Show);
                            ImGui::Bullet();
                            ImVec4 temp = ImGui::ColorConvertU32ToFloat4(item->Color);
                            if (ImGui::ColorEdit4("Color",&temp.x, ImGuiColorEditFlags_NoInputs))
                                item->Color = ImGui::ColorConvertFloat4ToU32(temp);

                            ImGui::BulletText("NameOffset: %d",item->NameOffset);
                            ImGui::BulletText("Name: %s", item->NameOffset != -1 ? plot.Items.Legend.Labels.Buf.Data + item->NameOffset : "N/A");
                            ImGui::BulletText("Hovered: %s",item->LegendHovered ? "true" : "false");
                            ImGui::TreePop();
                        }
                        ImGui::PopID();
                    }
                    ImGui::TreePop();
                }
                char buff[16];
                for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i) {
                    ImFormatString(buff,16,"X-Axis %d", i+1);
                    if (plot.XAxis(i).Enabled && ImGui::TreeNode(buff, "X-Axis %d [0x%08X]", i+1, plot.XAxis(i).ID)) {
                        ShowAxisMetrics(plot, plot.XAxis(i));
                        ImGui::TreePop();
                    }
                }
                for (int i = 0; i < IMPLOT_NUM_Y_AXES; ++i) {
                    ImFormatString(buff,16,"Y-Axis %d", i+1);
                    if (plot.YAxis(i).Enabled && ImGui::TreeNode(buff, "Y-Axis %d [0x%08X]", i+1, plot.YAxis(i).ID)) {
                        ShowAxisMetrics(plot, plot.YAxis(i));
                        ImGui::TreePop();
                    }
                }
                ImGui::BulletText("Title: %s", plot.HasTitle() ? plot.GetTitle() : "none");
                ImGui::BulletText("Flags: 0x%08X", plot.Flags);
                ImGui::BulletText("Initialized: %s", plot.Initialized ? "true" : "false");
                ImGui::BulletText("Selecting: %s", plot.Selecting ? "true" : "false");
                ImGui::BulletText("Selected: %s", plot.Selected ? "true" : "false");
                ImGui::BulletText("Hovered: %s", plot.Hovered ? "true" : "false");
                ImGui::BulletText("Held: %s", plot.Held ? "true" : "false");
                ImGui::BulletText("LegendHovered: %s", plot.Items.Legend.Hovered ? "true" : "false");
                ImGui::BulletText("ContextLocked: %s", plot.ContextLocked ? "true" : "false");
                ImGui::TreePop();
            }
            ImGui::PopID();
        }
        ImGui::TreePop();
    }

    if (ImGui::TreeNode("Subplots","Subplots (%d)", n_subplots)) {
        for (int p = 0; p < n_subplots; ++p) {
            // plot
            ImPlotSubplot& plot = *gp.Subplots.GetByIndex(p);
            ImGui::PushID(p);
            if (ImGui::TreeNode("Subplot", "Subplot [0x%08X]", plot.ID)) {
                int n_items = plot.Items.GetItemCount();
                if (ImGui::TreeNode("Items", "Items (%d)", n_items)) {
                    for (int i = 0; i < n_items; ++i) {
                        ImPlotItem* item = plot.Items.GetItemByIndex(i);
                        ImGui::PushID(i);
                        if (ImGui::TreeNode("Item", "Item [0x%08X]", item->ID)) {
                            ImGui::Bullet(); ImGui::Checkbox("Show", &item->Show);
                            ImGui::Bullet();
                            ImVec4 temp = ImGui::ColorConvertU32ToFloat4(item->Color);
                            if (ImGui::ColorEdit4("Color",&temp.x, ImGuiColorEditFlags_NoInputs))
                                item->Color = ImGui::ColorConvertFloat4ToU32(temp);

                            ImGui::BulletText("NameOffset: %d",item->NameOffset);
                            ImGui::BulletText("Name: %s", item->NameOffset != -1 ? plot.Items.Legend.Labels.Buf.Data + item->NameOffset : "N/A");
                            ImGui::BulletText("Hovered: %s",item->LegendHovered ? "true" : "false");
                            ImGui::TreePop();
                        }
                        ImGui::PopID();
                    }
                    ImGui::TreePop();
                }
                ImGui::BulletText("Flags: 0x%08X", plot.Flags);
                ImGui::BulletText("FrameHovered: %s", plot.FrameHovered ? "true" : "false");
                ImGui::BulletText("LegendHovered: %s", plot.Items.Legend.Hovered ? "true" : "false");
                ImGui::TreePop();
            }
            ImGui::PopID();
        }
        ImGui::TreePop();
    }
    if (ImGui::TreeNode("Colormaps")) {
        ImGui::BulletText("Colormaps:  %d", gp.ColormapData.Count);
        ImGui::BulletText("Memory: %d bytes", gp.ColormapData.Tables.Size * 4);
        if (ImGui::TreeNode("Data")) {
            for (int m = 0; m < gp.ColormapData.Count; ++m) {
                if (ImGui::TreeNode(gp.ColormapData.GetName(m))) {
                    int count = gp.ColormapData.GetKeyCount(m);
                    int size = gp.ColormapData.GetTableSize(m);
                    bool qual = gp.ColormapData.IsQual(m);
                    ImGui::BulletText("Qualitative: %s", qual ? "true" : "false");
                    ImGui::BulletText("Key Count: %d", count);
                    ImGui::BulletText("Table Size: %d", size);
                    ImGui::Indent();

                    static float t = 0.5;
                    ImVec4 samp;
                    float wid = 32 * 10 - ImGui::GetFrameHeight() - ImGui::GetStyle().ItemSpacing.x;
                    ImGui::SetNextItemWidth(wid);
                    ImPlot::ColormapSlider("##Sample",&t,&samp,"%.3f",m);
                    ImGui::SameLine();
                    ImGui::ColorButton("Sampler",samp);
                    ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0,0,0,0));
                    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0,0));
                    for (int c = 0; c < size; ++c) {
                        ImVec4 col = ImGui::ColorConvertU32ToFloat4(gp.ColormapData.GetTableColor(m,c));
                        ImGui::PushID(m*1000+c);
                        ImGui::ColorButton("",col,0,ImVec2(10,10));
                        ImGui::PopID();
                        if ((c + 1) % 32 != 0 && c != size - 1)
                            ImGui::SameLine();
                    }
                    ImGui::PopStyleVar();
                    ImGui::PopStyleColor();
                    ImGui::Unindent();
                    ImGui::TreePop();
                }
            }
            ImGui::TreePop();
        }
        ImGui::TreePop();
    }
    ImGui::End();
}

bool ShowDatePicker(const char* id, int* level, ImPlotTime* t, const ImPlotTime* t1, const ImPlotTime* t2) {

    ImGui::PushID(id);
    ImGui::BeginGroup();

    ImGuiStyle& style = ImGui::GetStyle();
    ImVec4 col_txt    = style.Colors[ImGuiCol_Text];
    ImVec4 col_dis    = style.Colors[ImGuiCol_TextDisabled];
    ImVec4 col_btn    = style.Colors[ImGuiCol_Button];
    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0,0,0,0));
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0,0));

    const float ht    = ImGui::GetFrameHeight();
    ImVec2 cell_size(ht*1.25f,ht);
    char buff[32];
    bool clk = false;
    tm& Tm = GImPlot->Tm;

    const int min_yr = 1970;
    const int max_yr = 2999;

    // t1 parts
    int t1_mo = 0; int t1_md = 0; int t1_yr = 0;
    if (t1 != nullptr) {
        GetTime(*t1,&Tm);
        t1_mo = Tm.tm_mon;
        t1_md = Tm.tm_mday;
        t1_yr = Tm.tm_year + 1900;
    }

     // t2 parts
    int t2_mo = 0; int t2_md = 0; int t2_yr = 0;
    if (t2 != nullptr) {
        GetTime(*t2,&Tm);
        t2_mo = Tm.tm_mon;
        t2_md = Tm.tm_mday;
        t2_yr = Tm.tm_year + 1900;
    }

    // day widget
    if (*level == 0) {
        *t = FloorTime(*t, ImPlotTimeUnit_Day);
        GetTime(*t, &Tm);
        const int this_year = Tm.tm_year + 1900;
        const int last_year = this_year - 1;
        const int next_year = this_year + 1;
        const int this_mon  = Tm.tm_mon;
        const int last_mon  = this_mon == 0 ? 11 : this_mon - 1;
        const int next_mon  = this_mon == 11 ? 0 : this_mon + 1;
        const int days_this_mo = GetDaysInMonth(this_year, this_mon);
        const int days_last_mo = GetDaysInMonth(this_mon == 0 ? last_year : this_year, last_mon);
        ImPlotTime t_first_mo = FloorTime(*t,ImPlotTimeUnit_Mo);
        GetTime(t_first_mo,&Tm);
        const int first_wd = Tm.tm_wday;
        // month year
        ImFormatString(buff, 32, "%s %d", MONTH_NAMES[this_mon], this_year);
        if (ImGui::Button(buff))
            *level = 1;
        ImGui::SameLine(5*cell_size.x);
        BeginDisabledControls(this_year <= min_yr && this_mon == 0);
        if (ImGui::ArrowButtonEx("##Up",ImGuiDir_Up,cell_size))
            *t = AddTime(*t, ImPlotTimeUnit_Mo, -1);
        EndDisabledControls(this_year <= min_yr && this_mon == 0);
        ImGui::SameLine();
        BeginDisabledControls(this_year >= max_yr && this_mon == 11);
        if (ImGui::ArrowButtonEx("##Down",ImGuiDir_Down,cell_size))
            *t = AddTime(*t, ImPlotTimeUnit_Mo, 1);
        EndDisabledControls(this_year >= max_yr && this_mon == 11);
        // render weekday abbreviations
        ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
        for (int i = 0; i < 7; ++i) {
            ImGui::Button(WD_ABRVS[i],cell_size);
            if (i != 6) { ImGui::SameLine(); }
        }
        ImGui::PopItemFlag();
        // 0 = last mo, 1 = this mo, 2 = next mo
        int mo = first_wd > 0 ? 0 : 1;
        int day = mo == 1 ? 1 : days_last_mo - first_wd + 1;
        for (int i = 0; i < 6; ++i) {
            for (int j = 0; j < 7; ++j) {
                if (mo == 0 && day > days_last_mo) {
                    mo = 1;
                    day = 1;
                }
                else if (mo == 1 && day > days_this_mo) {
                    mo = 2;
                    day = 1;
                }
                const int now_yr = (mo == 0 && this_mon == 0) ? last_year : ((mo == 2 && this_mon == 11) ? next_year : this_year);
                const int now_mo = mo == 0 ? last_mon : (mo == 1 ? this_mon : next_mon);
                const int now_md = day;

                const bool off_mo   = mo == 0 || mo == 2;
                const bool t1_or_t2 = (t1 != nullptr && t1_mo == now_mo && t1_yr == now_yr && t1_md == now_md) ||
                                      (t2 != nullptr && t2_mo == now_mo && t2_yr == now_yr && t2_md == now_md);

                if (off_mo)
                    ImGui::PushStyleColor(ImGuiCol_Text, col_dis);
                if (t1_or_t2) {
                    ImGui::PushStyleColor(ImGuiCol_Button, col_btn);
                    ImGui::PushStyleColor(ImGuiCol_Text, col_txt);
                }
                ImGui::PushID(i*7+j);
                ImFormatString(buff,32,"%d",day);
                if (now_yr == min_yr-1 || now_yr == max_yr+1) {
                    ImGui::Dummy(cell_size);
                }
                else if (ImGui::Button(buff,cell_size) && !clk) {
                    *t = MakeTime(now_yr, now_mo, now_md);
                    clk = true;
                }
                ImGui::PopID();
                if (t1_or_t2)
                    ImGui::PopStyleColor(2);
                if (off_mo)
                    ImGui::PopStyleColor();
                if (j != 6)
                    ImGui::SameLine();
                day++;
            }
        }
    }
    // month widget
    else if (*level == 1) {
        *t = FloorTime(*t, ImPlotTimeUnit_Mo);
        GetTime(*t, &Tm);
        int this_yr  = Tm.tm_year + 1900;
        ImFormatString(buff, 32, "%d", this_yr);
        if (ImGui::Button(buff))
            *level = 2;
        BeginDisabledControls(this_yr <= min_yr);
        ImGui::SameLine(5*cell_size.x);
        if (ImGui::ArrowButtonEx("##Up",ImGuiDir_Up,cell_size))
            *t = AddTime(*t, ImPlotTimeUnit_Yr, -1);
        EndDisabledControls(this_yr <= min_yr);
        ImGui::SameLine();
        BeginDisabledControls(this_yr >= max_yr);
        if (ImGui::ArrowButtonEx("##Down",ImGuiDir_Down,cell_size))
            *t = AddTime(*t, ImPlotTimeUnit_Yr, 1);
        EndDisabledControls(this_yr >= max_yr);
        // ImGui::Dummy(cell_size);
        cell_size.x *= 7.0f/4.0f;
        cell_size.y *= 7.0f/3.0f;
        int mo = 0;
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 4; ++j) {
                const bool t1_or_t2 = (t1 != nullptr && t1_yr == this_yr && t1_mo == mo) ||
                                      (t2 != nullptr && t2_yr == this_yr && t2_mo == mo);
                if (t1_or_t2)
                    ImGui::PushStyleColor(ImGuiCol_Button, col_btn);
                if (ImGui::Button(MONTH_ABRVS[mo],cell_size) && !clk) {
                    *t = MakeTime(this_yr, mo);
                    *level = 0;
                }
                if (t1_or_t2)
                    ImGui::PopStyleColor();
                if (j != 3)
                    ImGui::SameLine();
                mo++;
            }
        }
    }
    else if (*level == 2) {
        *t = FloorTime(*t, ImPlotTimeUnit_Yr);
        int this_yr = GetYear(*t);
        int yr = this_yr  - this_yr % 20;
        ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
        ImFormatString(buff,32,"%d-%d",yr,yr+19);
        ImGui::Button(buff);
        ImGui::PopItemFlag();
        ImGui::SameLine(5*cell_size.x);
        BeginDisabledControls(yr <= min_yr);
        if (ImGui::ArrowButtonEx("##Up",ImGuiDir_Up,cell_size))
            *t = MakeTime(yr-20);
        EndDisabledControls(yr <= min_yr);
        ImGui::SameLine();
        BeginDisabledControls(yr + 20 >= max_yr);
        if (ImGui::ArrowButtonEx("##Down",ImGuiDir_Down,cell_size))
            *t = MakeTime(yr+20);
        EndDisabledControls(yr+ 20 >= max_yr);
        // ImGui::Dummy(cell_size);
        cell_size.x *= 7.0f/4.0f;
        cell_size.y *= 7.0f/5.0f;
        for (int i = 0; i < 5; ++i) {
            for (int j = 0; j < 4; ++j) {
                const bool t1_or_t2 = (t1 != nullptr && t1_yr == yr) || (t2 != nullptr && t2_yr == yr);
                if (t1_or_t2)
                    ImGui::PushStyleColor(ImGuiCol_Button, col_btn);
                ImFormatString(buff,32,"%d",yr);
                if (yr<1970||yr>3000) {
                    ImGui::Dummy(cell_size);
                }
                else if (ImGui::Button(buff,cell_size)) {
                    *t = MakeTime(yr);
                    *level = 1;
                }
                if (t1_or_t2)
                    ImGui::PopStyleColor();
                if (j != 3)
                    ImGui::SameLine();
                yr++;
            }
        }
    }
    ImGui::PopStyleVar();
    ImGui::PopStyleColor();
    ImGui::EndGroup();
    ImGui::PopID();
    return clk;
}

bool ShowTimePicker(const char* id, ImPlotTime* t) {
    ImPlotContext& gp = *GImPlot;
    ImGui::PushID(id);
    tm& Tm = gp.Tm;
    GetTime(*t,&Tm);

    static const char* nums[] = { "00","01","02","03","04","05","06","07","08","09",
                                  "10","11","12","13","14","15","16","17","18","19",
                                  "20","21","22","23","24","25","26","27","28","29",
                                  "30","31","32","33","34","35","36","37","38","39",
                                  "40","41","42","43","44","45","46","47","48","49",
                                  "50","51","52","53","54","55","56","57","58","59"};

    static const char* am_pm[] = {"am","pm"};

    bool hour24 = gp.Style.Use24HourClock;

    int hr  = hour24 ? Tm.tm_hour : ((Tm.tm_hour == 0 || Tm.tm_hour == 12) ? 12 : Tm.tm_hour % 12);
    int min = Tm.tm_min;
    int sec = Tm.tm_sec;
    int ap  = Tm.tm_hour < 12 ? 0 : 1;

    bool changed = false;

    ImVec2 spacing = ImGui::GetStyle().ItemSpacing;
    spacing.x = 0;
    float width    = ImGui::CalcTextSize("888").x;
    float height   = ImGui::GetFrameHeight();

    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, spacing);
    ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize,2.0f);
    ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0,0,0,0));
    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0,0,0,0));
    ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImGui::GetStyleColorVec4(ImGuiCol_ButtonHovered));

    ImGui::SetNextItemWidth(width);
    if (ImGui::BeginCombo("##hr",nums[hr],ImGuiComboFlags_NoArrowButton)) {
        const int ia = hour24 ? 0 : 1;
        const int ib = hour24 ? 24 : 13;
        for (int i = ia; i < ib; ++i) {
            if (ImGui::Selectable(nums[i],i==hr)) {
                hr = i;
                changed = true;
            }
        }
        ImGui::EndCombo();
    }
    ImGui::SameLine();
    ImGui::Text(":");
    ImGui::SameLine();
    ImGui::SetNextItemWidth(width);
    if (ImGui::BeginCombo("##min",nums[min],ImGuiComboFlags_NoArrowButton)) {
        for (int i = 0; i < 60; ++i) {
            if (ImGui::Selectable(nums[i],i==min)) {
                min = i;
                changed = true;
            }
        }
        ImGui::EndCombo();
    }
    ImGui::SameLine();
    ImGui::Text(":");
    ImGui::SameLine();
    ImGui::SetNextItemWidth(width);
    if (ImGui::BeginCombo("##sec",nums[sec],ImGuiComboFlags_NoArrowButton)) {
        for (int i = 0; i < 60; ++i) {
            if (ImGui::Selectable(nums[i],i==sec)) {
                sec = i;
                changed = true;
            }
        }
        ImGui::EndCombo();
    }
    if (!hour24) {
        ImGui::SameLine();
        if (ImGui::Button(am_pm[ap],ImVec2(0,height))) {
            ap = 1 - ap;
            changed = true;
        }
    }

    ImGui::PopStyleColor(3);
    ImGui::PopStyleVar(2);
    ImGui::PopID();

    if (changed) {
        if (!hour24)
            hr = hr % 12 + ap * 12;
        Tm.tm_hour = hr;
        Tm.tm_min  = min;
        Tm.tm_sec  = sec;
        *t = MkTime(&Tm);
    }

    return changed;
}

void StyleColorsAuto(ImPlotStyle* dst) {
    ImPlotStyle* style              = dst ? dst : &ImPlot::GetStyle();
    ImVec4* colors                  = style->Colors;

    style->MinorAlpha               = 0.25f;

    colors[ImPlotCol_Line]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_Fill]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerFill]    = IMPLOT_AUTO_COL;
    colors[ImPlotCol_ErrorBar]      = IMPLOT_AUTO_COL;
    colors[ImPlotCol_FrameBg]       = IMPLOT_AUTO_COL;
    colors[ImPlotCol_PlotBg]        = IMPLOT_AUTO_COL;
    colors[ImPlotCol_PlotBorder]    = IMPLOT_AUTO_COL;
    colors[ImPlotCol_LegendBg]      = IMPLOT_AUTO_COL;
    colors[ImPlotCol_LegendBorder]  = IMPLOT_AUTO_COL;
    colors[ImPlotCol_LegendText]    = IMPLOT_AUTO_COL;
    colors[ImPlotCol_TitleText]     = IMPLOT_AUTO_COL;
    colors[ImPlotCol_InlayText]     = IMPLOT_AUTO_COL;
    colors[ImPlotCol_PlotBorder]    = IMPLOT_AUTO_COL;
    colors[ImPlotCol_AxisText]      = IMPLOT_AUTO_COL;
    colors[ImPlotCol_AxisGrid]      = IMPLOT_AUTO_COL;
    colors[ImPlotCol_AxisTick]      = IMPLOT_AUTO_COL;
    colors[ImPlotCol_AxisBg]        = IMPLOT_AUTO_COL;
    colors[ImPlotCol_AxisBgHovered] = IMPLOT_AUTO_COL;
    colors[ImPlotCol_AxisBgActive]  = IMPLOT_AUTO_COL;
    colors[ImPlotCol_Selection]     = IMPLOT_AUTO_COL;
    colors[ImPlotCol_Crosshairs]    = IMPLOT_AUTO_COL;
}

void StyleColorsClassic(ImPlotStyle* dst) {
    ImPlotStyle* style              = dst ? dst : &ImPlot::GetStyle();
    ImVec4* colors                  = style->Colors;

    style->MinorAlpha               = 0.5f;

    colors[ImPlotCol_Line]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_Fill]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerFill]    = IMPLOT_AUTO_COL;
    colors[ImPlotCol_ErrorBar]      = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
    colors[ImPlotCol_FrameBg]       = ImVec4(0.43f, 0.43f, 0.43f, 0.39f);
    colors[ImPlotCol_PlotBg]        = ImVec4(0.00f, 0.00f, 0.00f, 0.35f);
    colors[ImPlotCol_PlotBorder]    = ImVec4(0.50f, 0.50f, 0.50f, 0.50f);
    colors[ImPlotCol_LegendBg]      = ImVec4(0.11f, 0.11f, 0.14f, 0.92f);
    colors[ImPlotCol_LegendBorder]  = ImVec4(0.50f, 0.50f, 0.50f, 0.50f);
    colors[ImPlotCol_LegendText]    = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
    colors[ImPlotCol_TitleText]     = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
    colors[ImPlotCol_InlayText]     = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
    colors[ImPlotCol_AxisText]      = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
    colors[ImPlotCol_AxisGrid]      = ImVec4(0.90f, 0.90f, 0.90f, 0.25f);
    colors[ImPlotCol_AxisTick]      = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_AxisBg]        = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_AxisBgHovered] = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_AxisBgActive]  = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_Selection]     = ImVec4(0.97f, 0.97f, 0.39f, 1.00f);
    colors[ImPlotCol_Crosshairs]    = ImVec4(0.50f, 0.50f, 0.50f, 0.75f);
}

void StyleColorsDark(ImPlotStyle* dst) {
    ImPlotStyle* style              = dst ? dst : &ImPlot::GetStyle();
    ImVec4* colors                  = style->Colors;

    style->MinorAlpha               = 0.25f;

    colors[ImPlotCol_Line]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_Fill]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerFill]    = IMPLOT_AUTO_COL;
    colors[ImPlotCol_ErrorBar]      = IMPLOT_AUTO_COL;
    colors[ImPlotCol_FrameBg]       = ImVec4(1.00f, 1.00f, 1.00f, 0.07f);
    colors[ImPlotCol_PlotBg]        = ImVec4(0.00f, 0.00f, 0.00f, 0.50f);
    colors[ImPlotCol_PlotBorder]    = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
    colors[ImPlotCol_LegendBg]      = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
    colors[ImPlotCol_LegendBorder]  = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
    colors[ImPlotCol_LegendText]    = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImPlotCol_TitleText]     = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImPlotCol_InlayText]     = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImPlotCol_AxisText]      = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImPlotCol_AxisGrid]      = ImVec4(1.00f, 1.00f, 1.00f, 0.25f);
    colors[ImPlotCol_AxisTick]      = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_AxisBg]        = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_AxisBgHovered] = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_AxisBgActive]  = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_Selection]     = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
    colors[ImPlotCol_Crosshairs]    = ImVec4(1.00f, 1.00f, 1.00f, 0.50f);
}

void StyleColorsLight(ImPlotStyle* dst) {
    ImPlotStyle* style              = dst ? dst : &ImPlot::GetStyle();
    ImVec4* colors                  = style->Colors;

    style->MinorAlpha               = 1.0f;

    colors[ImPlotCol_Line]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_Fill]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerFill]    = IMPLOT_AUTO_COL;
    colors[ImPlotCol_ErrorBar]      = IMPLOT_AUTO_COL;
    colors[ImPlotCol_FrameBg]       = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImPlotCol_PlotBg]        = ImVec4(0.42f, 0.57f, 1.00f, 0.13f);
    colors[ImPlotCol_PlotBorder]    = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImPlotCol_LegendBg]      = ImVec4(1.00f, 1.00f, 1.00f, 0.98f);
    colors[ImPlotCol_LegendBorder]  = ImVec4(0.82f, 0.82f, 0.82f, 0.80f);
    colors[ImPlotCol_LegendText]    = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_TitleText]     = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_InlayText]     = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_AxisText]      = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_AxisGrid]      = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImPlotCol_AxisTick]      = ImVec4(0.00f, 0.00f, 0.00f, 0.25f);
    colors[ImPlotCol_AxisBg]        = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_AxisBgHovered] = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_AxisBgActive]  = IMPLOT_AUTO_COL; // TODO
    colors[ImPlotCol_Selection]     = ImVec4(0.82f, 0.64f, 0.03f, 1.00f);
    colors[ImPlotCol_Crosshairs]    = ImVec4(0.00f, 0.00f, 0.00f, 0.50f);
}

//-----------------------------------------------------------------------------
// [SECTION] Obsolete Functions/Types
//-----------------------------------------------------------------------------

#ifndef IMPLOT_DISABLE_OBSOLETE_FUNCTIONS

bool BeginPlot(const char* title, const char* x_label, const char* y1_label, const ImVec2& size,
               ImPlotFlags flags, ImPlotAxisFlags x_flags, ImPlotAxisFlags y1_flags, ImPlotAxisFlags y2_flags, ImPlotAxisFlags y3_flags,
               const char* y2_label, const char* y3_label)
{
    if (!BeginPlot(title, size, flags))
        return false;
    SetupAxis(ImAxis_X1, x_label, x_flags);
    SetupAxis(ImAxis_Y1, y1_label, y1_flags);
    if (ImHasFlag(flags, ImPlotFlags_YAxis2))
        SetupAxis(ImAxis_Y2, y2_label, y2_flags);
    if (ImHasFlag(flags, ImPlotFlags_YAxis3))
        SetupAxis(ImAxis_Y3, y3_label, y3_flags);
    return true;
}

#endif

}  // namespace ImPlot


================================================
FILE: Source/External/imgui_tools/implot/implot.h
================================================
// MIT License

// Copyright (c) 2022 Evan Pezent

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// ImPlot v0.14

// Table of Contents:
//
// [SECTION] Macros and Defines
// [SECTION] Enums and Types
// [SECTION] Callbacks
// [SECTION] Contexts
// [SECTION] Begin/End Plot
// [SECTION] Begin/End Subplot
// [SECTION] Setup
// [SECTION] SetNext
// [SECTION] Plot Items
// [SECTION] Plot Tools
// [SECTION] Plot Utils
// [SECTION] Legend Utils
// [SECTION] Drag and Drop
// [SECTION] Styling
// [SECTION] Colormaps
// [SECTION] Input Mapping
// [SECTION] Miscellaneous
// [SECTION] Demo
// [SECTION] Obsolete API

#pragma once
#include "imgui.h"

//-----------------------------------------------------------------------------
// [SECTION] Macros and Defines
//-----------------------------------------------------------------------------

// Define attributes of all API symbols declarations (e.g. for DLL under Windows)
// Using ImPlot via a shared library is not recommended, because we don't guarantee
// backward nor forward ABI compatibility and also function call overhead. If you
// do use ImPlot as a DLL, be sure to call SetImGuiContext (see Miscellanous section).
#ifndef IMPLOT_API
#define IMPLOT_API
#endif

// ImPlot version string.
#define IMPLOT_VERSION "0.14"
// Indicates variable should deduced automatically.
#define IMPLOT_AUTO -1
// Special color used to indicate that a color should be deduced automatically.
#define IMPLOT_AUTO_COL ImVec4(0,0,0,-1)
// Macro for templated plotting functions; keeps header clean.
#define IMPLOT_TMP template <typename T> IMPLOT_API

//-----------------------------------------------------------------------------
// [SECTION] Enums and Types
//-----------------------------------------------------------------------------

// Forward declarations
struct ImPlotContext;             // ImPlot context (opaque struct, see implot_internal.h)

// Enums/Flags
typedef int ImAxis;                   // -> enum ImAxis_
typedef int ImPlotFlags;              // -> enum ImPlotFlags_
typedef int ImPlotAxisFlags;          // -> enum ImPlotAxisFlags_
typedef int ImPlotSubplotFlags;       // -> enum ImPlotSubplotFlags_
typedef int ImPlotLegendFlags;        // -> enum ImPlotLegendFlags_
typedef int ImPlotMouseTextFlags;     // -> enum ImPlotMouseTextFlags_
typedef int ImPlotDragToolFlags;      // -> ImPlotDragToolFlags_
typedef int ImPlotColormapScaleFlags; // -> ImPlotColormapScaleFlags_

typedef int ImPlotItemFlags;          // -> ImPlotItemFlags_
typedef int ImPlotLineFlags;          // -> ImPlotLineFlags_
typedef int ImPlotScatterFlags;       // -> ImPlotScatterFlags
typedef int ImPlotStairsFlags;        // -> ImPlotStairsFlags_
typedef int ImPlotShadedFlags;        // -> ImPlotShadedFlags_
typedef int ImPlotBarsFlags;          // -> ImPlotBarsFlags_
typedef int ImPlotBarGroupsFlags;     // -> ImPlotBarGroupsFlags_
typedef int ImPlotErrorBarsFlags;     // -> ImPlotErrorBarsFlags_
typedef int ImPlotStemsFlags;         // -> ImPlotStemsFlags_
typedef int ImPlotInfLinesFlags;      // -> ImPlotInfLinesFlags_
typedef int ImPlotPieChartFlags;      // -> ImPlotPieChartFlags_
typedef int ImPlotHeatmapFlags;       // -> ImPlotHeatmapFlags_
typedef int ImPlotHistogramFlags;     // -> ImPlotHistogramFlags_
typedef int ImPlotDigitalFlags;       // -> ImPlotDigitalFlags_
typedef int ImPlotImageFlags;         // -> ImPlotImageFlags_
typedef int ImPlotTextFlags;          // -> ImPlotTextFlags_
typedef int ImPlotDummyFlags;         // -> ImPlotDummyFlags_

typedef int ImPlotCond;               // -> enum ImPlotCond_
typedef int ImPlotCol;                // -> enum ImPlotCol_
typedef int ImPlotStyleVar;           // -> enum ImPlotStyleVar_
typedef int ImPlotScale;              // -> enum ImPlotScale_
typedef int ImPlotMarker;             // -> enum ImPlotMarker_
typedef int ImPlotColormap;           // -> enum ImPlotColormap_
typedef int ImPlotLocation;           // -> enum ImPlotLocation_
typedef int ImPlotBin;                // -> enum ImPlotBin_

// Axis indices. The values assigned may change; NEVER hardcode these.
enum ImAxis_ {
    // horizontal axes
    ImAxis_X1 = 0, // enabled by default
    ImAxis_X2,     // disabled by default
    ImAxis_X3,     // disabled by default
    // vertical axes
    ImAxis_Y1,     // enabled by default
    ImAxis_Y2,     // disabled by default
    ImAxis_Y3,     // disabled by default
    // bookeeping
    ImAxis_COUNT
};

// Options for plots (see BeginPlot).
enum ImPlotFlags_ {
    ImPlotFlags_None          = 0,       // default
    ImPlotFlags_NoTitle       = 1 << 0,  // the plot title will not be displayed (titles are also hidden if preceeded by double hashes, e.g. "##MyPlot")
    ImPlotFlags_NoLegend      = 1 << 1,  // the legend will not be displayed
    ImPlotFlags_NoMouseText   = 1 << 2,  // the mouse position, in plot coordinates, will not be displayed inside of the plot
    ImPlotFlags_NoInputs      = 1 << 3,  // the user will not be able to interact with the plot
    ImPlotFlags_NoMenus       = 1 << 4,  // the user will not be able to open context menus
    ImPlotFlags_NoBoxSelect   = 1 << 5,  // the user will not be able to box-select
    ImPlotFlags_NoChild       = 1 << 6,  // a child window region will not be used to capture mouse scroll (can boost performance for single ImGui window applications)
    ImPlotFlags_NoFrame       = 1 << 7,  // the ImGui frame will not be rendered
    ImPlotFlags_Equal         = 1 << 8,  // x and y axes pairs will be constrained to have the same units/pixel
    ImPlotFlags_Crosshairs    = 1 << 9,  // the default mouse cursor will be replaced with a crosshair when hovered
    ImPlotFlags_CanvasOnly    = ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMouseText
};

// Options for plot axes (see SetupAxis).
enum ImPlotAxisFlags_ {
    ImPlotAxisFlags_None          = 0,       // default
    ImPlotAxisFlags_NoLabel       = 1 << 0,  // the axis label will not be displayed (axis labels are also hidden if the supplied string name is nullptr)
    ImPlotAxisFlags_NoGridLines   = 1 << 1,  // no grid lines will be displayed
    ImPlotAxisFlags_NoTickMarks   = 1 << 2,  // no tick marks will be displayed
    ImPlotAxisFlags_NoTickLabels  = 1 << 3,  // no text labels will be displayed
    ImPlotAxisFlags_NoInitialFit  = 1 << 4,  // axis will not be initially fit to data extents on the first rendered frame
    ImPlotAxisFlags_NoMenus       = 1 << 5,  // the user will not be able to open context menus with right-click
    ImPlotAxisFlags_NoSideSwitch  = 1 << 6,  // the user will not be able to switch the axis side by dragging it
    ImPlotAxisFlags_NoHighlight   = 1 << 7,  // the axis will not have its background highlighted when hovered or held
    ImPlotAxisFlags_Opposite      = 1 << 8,  // axis ticks and labels will be rendered on the conventionally opposite side (i.e, right or top)
    ImPlotAxisFlags_Foreground    = 1 << 9,  // grid lines will be displayed in the foreground (i.e. on top of data) instead of the background
    ImPlotAxisFlags_Invert        = 1 << 10, // the axis will be inverted
    ImPlotAxisFlags_AutoFit       = 1 << 11, // axis will be auto-fitting to data extents
    ImPlotAxisFlags_RangeFit      = 1 << 12, // axis will only fit points if the point is in the visible range of the **orthogonal** axis
    ImPlotAxisFlags_PanStretch    = 1 << 13, // panning in a locked or constrained state will cause the axis to stretch if possible
    ImPlotAxisFlags_LockMin       = 1 << 14, // the axis minimum value will be locked when panning/zooming
    ImPlotAxisFlags_LockMax       = 1 << 15, // the axis maximum value will be locked when panning/zooming
    ImPlotAxisFlags_Lock          = ImPlotAxisFlags_LockMin | ImPlotAxisFlags_LockMax,
    ImPlotAxisFlags_NoDecorations = ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks | ImPlotAxisFlags_NoTickLabels,
    ImPlotAxisFlags_AuxDefault    = ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_Opposite
};

// Options for subplots (see BeginSubplot)
enum ImPlotSubplotFlags_ {
    ImPlotSubplotFlags_None        = 0,       // default
    ImPlotSubplotFlags_NoTitle     = 1 << 0,  // the subplot title will not be displayed (titles are also hidden if preceeded by double hashes, e.g. "##MySubplot")
    ImPlotSubplotFlags_NoLegend    = 1 << 1,  // the legend will not be displayed (only applicable if ImPlotSubplotFlags_ShareItems is enabled)
    ImPlotSubplotFlags_NoMenus     = 1 << 2,  // the user will not be able to open context menus with right-click
    ImPlotSubplotFlags_NoResize    = 1 << 3,  // resize splitters between subplot cells will be not be provided
    ImPlotSubplotFlags_NoAlign     = 1 << 4,  // subplot edges will not be aligned vertically or horizontally
    ImPlotSubplotFlags_ShareItems  = 1 << 5,  // items across all subplots will be shared and rendered into a single legend entry
    ImPlotSubplotFlags_LinkRows    = 1 << 6,  // link the y-axis limits of all plots in each row (does not apply to auxiliary axes)
    ImPlotSubplotFlags_LinkCols    = 1 << 7,  // link the x-axis limits of all plots in each column (does not apply to auxiliary axes)
    ImPlotSubplotFlags_LinkAllX    = 1 << 8,  // link the x-axis limits in every plot in the subplot (does not apply to auxiliary axes)
    ImPlotSubplotFlags_LinkAllY    = 1 << 9,  // link the y-axis limits in every plot in the subplot (does not apply to auxiliary axes)
    ImPlotSubplotFlags_ColMajor    = 1 << 10  // subplots are added in column major order instead of the default row major order
};

// Options for legends (see SetupLegend)
enum ImPlotLegendFlags_ {
    ImPlotLegendFlags_None            = 0,      // default
    ImPlotLegendFlags_NoButtons       = 1 << 0, // legend icons will not function as hide/show buttons
    ImPlotLegendFlags_NoHighlightItem = 1 << 1, // plot items will not be highlighted when their legend entry is hovered
    ImPlotLegendFlags_NoHighlightAxis = 1 << 2, // axes will not be highlighted when legend entries are hovered (only relevant if x/y-axis count > 1)
    ImPlotLegendFlags_NoMenus         = 1 << 3, // the user will not be able to open context menus with right-click
    ImPlotLegendFlags_Outside         = 1 << 4, // legend will be rendered outside of the plot area
    ImPlotLegendFlags_Horizontal      = 1 << 5, // legend entries will be displayed horizontally
    ImPlotLegendFlags_Sort            = 1 << 6, // legend entries will be displayed in alphabetical order
};

// Options for mouse hover text (see SetupMouseText)
enum ImPlotMouseTextFlags_ {
    ImPlotMouseTextFlags_None        = 0,      // default
    ImPlotMouseTextFlags_NoAuxAxes   = 1 << 0, // only show the mouse position for primary axes
    ImPlotMouseTextFlags_NoFormat    = 1 << 1, // axes label formatters won't be used to render text
    ImPlotMouseTextFlags_ShowAlways  = 1 << 2, // always display mouse position even if plot not hovered
};

// Options for DragPoint, DragLine, DragRect
enum ImPlotDragToolFlags_ {
    ImPlotDragToolFlags_None      = 0,      // default
    ImPlotDragToolFlags_NoCursors = 1 << 0, // drag tools won't change cursor icons when hovered or held
    ImPlotDragToolFlags_NoFit     = 1 << 1, // the drag tool won't be considered for plot fits
    ImPlotDragToolFlags_NoInputs  = 1 << 2, // lock the tool from user inputs
    ImPlotDragToolFlags_Delayed   = 1 << 3, // tool rendering will be delayed one frame; useful when applying position-constraints
};

// Flags for ColormapScale
enum ImPlotColormapScaleFlags_ {
    ImPlotColormapScaleFlags_None     = 0,      // default
    ImPlotColormapScaleFlags_NoLabel  = 1 << 0, // the colormap axis label will not be displayed
    ImPlotColormapScaleFlags_Opposite = 1 << 1, // render the colormap label and tick labels on the opposite side
    ImPlotColormapScaleFlags_Invert   = 1 << 2, // invert the colormap bar and axis scale (this only affects rendering; if you only want to reverse the scale mapping, make scale_min > scale_max)
};

// Flags for ANY PlotX function
enum ImPlotItemFlags_ {
    ImPlotItemFlags_None     = 0,
    ImPlotItemFlags_NoLegend = 1 << 0, // the item won't have a legend entry displayed
    ImPlotItemFlags_NoFit    = 1 << 1, // the item won't be considered for plot fits
};

// Flags for PlotLine
enum ImPlotLineFlags_ {
    ImPlotLineFlags_None        = 0,       // default
    ImPlotLineFlags_Segments    = 1 << 10, // a line segment will be rendered from every two consecutive points
    ImPlotLineFlags_Loop        = 1 << 11, // the last and first point will be connected to form a closed loop
    ImPlotLineFlags_SkipNaN     = 1 << 12, // NaNs values will be skipped instead of rendered as missing data
    ImPlotLineFlags_NoClip      = 1 << 13, // markers (if displayed) on the edge of a plot will not be clipped
    ImPlotLineFlags_Shaded      = 1 << 14, // a filled region between the line and horizontal origin will be rendered; use PlotShaded for more advanced cases
};

// Flags for PlotScatter
enum ImPlotScatterFlags_ {
    ImPlotScatterFlags_None   = 0,       // default
    ImPlotScatterFlags_NoClip = 1 << 10, // markers on the edge of a plot will not be clipped
};

// Flags for PlotStairs
enum ImPlotStairsFlags_ {
    ImPlotStairsFlags_None     = 0,       // default
    ImPlotStairsFlags_PreStep  = 1 << 10, // the y value is continued constantly to the left from every x position, i.e. the interval (x[i-1], x[i]] has the value y[i]
    ImPlotStairsFlags_Shaded   = 1 << 11  // a filled region between the stairs and horizontal origin will be rendered; use PlotShaded for more advanced cases
};

// Flags for PlotShaded (placeholder)
enum ImPlotShadedFlags_ {
    ImPlotShadedFlags_None  = 0 // default
};

// Flags for PlotBars
enum ImPlotBarsFlags_ {
    ImPlotBarsFlags_None         = 0,       // default
    ImPlotBarsFlags_Horizontal   = 1 << 10, // bars will be rendered horizontally on the current y-axis
};

// Flags for PlotBarGroups
enum ImPlotBarGroupsFlags_ {
    ImPlotBarGroupsFlags_None        = 0,       // default
    ImPlotBarGroupsFlags_Horizontal  = 1 << 10, // bar groups will be rendered horizontally on the current y-axis
    ImPlotBarGroupsFlags_Stacked     = 1 << 11, // items in a group will be stacked on top of each other
};

// Flags for PlotErrorBars
enum ImPlotErrorBarsFlags_ {
    ImPlotErrorBarsFlags_None       = 0,       // default
    ImPlotErrorBarsFlags_Horizontal = 1 << 10, // error bars will be rendered horizontally on the current y-axis
};

// Flags for PlotStems
enum ImPlotStemsFlags_ {
    ImPlotStemsFlags_None       = 0,       // default
    ImPlotStemsFlags_Horizontal = 1 << 10, // stems will be rendered horizontally on the current y-axis
};

// Flags for PlotInfLines
enum ImPlotInfLinesFlags_ {
    ImPlotInfLinesFlags_None       = 0,      // default
    ImPlotInfLinesFlags_Horizontal = 1 << 10 // lines will be rendered horizontally on the current y-axis
};

// Flags for PlotPieChart
enum ImPlotPieChartFlags_ {
    ImPlotPieChartFlags_None      = 0,      // default
    ImPlotPieChartFlags_Normalize = 1 << 10 // force normalization of pie chart values (i.e. always make a full circle if sum < 0)
};

// Flags for PlotHeatmap
enum ImPlotHeatmapFlags_ {
    ImPlotHeatmapFlags_None     = 0,       // default
    ImPlotHeatmapFlags_ColMajor = 1 << 10, // data will be read in column major order
};

// Flags for PlotHistogram and PlotHistogram2D
enum ImPlotHistogramFlags_ {
    ImPlotHistogramFlags_None       = 0,       // default
    ImPlotHistogramFlags_Horizontal = 1 << 10, // histogram bars will be rendered horizontally (not supported by PlotHistogram2D)
    ImPlotHistogramFlags_Cumulative = 1 << 11, // each bin will contain its count plus the counts of all previous bins (not supported by PlotHistogram2D)
    ImPlotHistogramFlags_Density    = 1 << 12, // counts will be normalized, i.e. the PDF will be visualized, or the CDF will be visualized if Cumulative is also set
    ImPlotHistogramFlags_NoOutliers = 1 << 13, // exclude values outside the specifed histogram range from the count toward normalizing and cumulative counts
    ImPlotHistogramFlags_ColMajor   = 1 << 14  // data will be read in column major order (not supported by PlotHistogram)
};

// Flags for PlotDigital (placeholder)
enum ImPlotDigitalFlags_ {
    ImPlotDigitalFlags_None = 0 // default
};

// Flags for PlotImage (placeholder)
enum ImPlotImageFlags_ {
    ImPlotImageFlags_None = 0 // default
};

// Flags for PlotText
enum ImPlotTextFlags_ {
    ImPlotTextFlags_None     = 0,       // default
    ImPlotTextFlags_Vertical = 1 << 10  // text will be rendered vertically
};

// Flags for PlotDummy (placeholder)
enum ImPlotDummyFlags_ {
    ImPlotDummyFlags_None = 0 // default
};

// Represents a condition for SetupAxisLimits etc. (same as ImGuiCond, but we only support a subset of those enums)
enum ImPlotCond_
{
    ImPlotCond_None   = ImGuiCond_None,    // No condition (always set the variable), same as _Always
    ImPlotCond_Always = ImGuiCond_Always,  // No condition (always set the variable)
    ImPlotCond_Once   = ImGuiCond_Once,    // Set the variable once per runtime session (only the first call will succeed)
};

// Plot styling colors.
enum ImPlotCol_ {
    // item styling colors
    ImPlotCol_Line,          // plot line/outline color (defaults to next unused color in current colormap)
    ImPlotCol_Fill,          // plot fill color for bars (defaults to the current line color)
    ImPlotCol_MarkerOutline, // marker outline color (defaults to the current line color)
    ImPlotCol_MarkerFill,    // marker fill color (defaults to the current line color)
    ImPlotCol_ErrorBar,      // error bar color (defaults to ImGuiCol_Text)
    // plot styling colors
    ImPlotCol_FrameBg,       // plot frame background color (defaults to ImGuiCol_FrameBg)
    ImPlotCol_PlotBg,        // plot area background color (defaults to ImGuiCol_WindowBg)
    ImPlotCol_PlotBorder,    // plot area border color (defaults to ImGuiCol_Border)
    ImPlotCol_LegendBg,      // legend background color (defaults to ImGuiCol_PopupBg)
    ImPlotCol_LegendBorder,  // legend border color (defaults to ImPlotCol_PlotBorder)
    ImPlotCol_LegendText,    // legend text color (defaults to ImPlotCol_InlayText)
    ImPlotCol_TitleText,     // plot title text color (defaults to ImGuiCol_Text)
    ImPlotCol_InlayText,     // color of text appearing inside of plots (defaults to ImGuiCol_Text)
    ImPlotCol_AxisText,      // axis label and tick lables color (defaults to ImGuiCol_Text)
    ImPlotCol_AxisGrid,      // axis grid color (defaults to 25% ImPlotCol_AxisText)
    ImPlotCol_AxisTick,      // axis tick color (defaults to AxisGrid)
    ImPlotCol_AxisBg,        // background color of axis hover region (defaults to transparent)
    ImPlotCol_AxisBgHovered, // axis hover color (defaults to ImGuiCol_ButtonHovered)
    ImPlotCol_AxisBgActive,  // axis active color (defaults to ImGuiCol_ButtonActive)
    ImPlotCol_Selection,     // box-selection color (defaults to yellow)
    ImPlotCol_Crosshairs,    // crosshairs color (defaults to ImPlotCol_PlotBorder)
    ImPlotCol_COUNT
};

// Plot styling variables.
enum ImPlotStyleVar_ {
    // item styling variables
    ImPlotStyleVar_LineWeight,         // float,  plot item line weight in pixels
    ImPlotStyleVar_Marker,             // int,    marker specification
    ImPlotStyleVar_MarkerSize,         // float,  marker size in pixels (roughly the marker's "radius")
    ImPlotStyleVar_MarkerWeight,       // float,  plot outline weight of markers in pixels
    ImPlotStyleVar_FillAlpha,          // float,  alpha modifier applied to all plot item fills
    ImPlotStyleVar_ErrorBarSize,       // float,  error bar whisker width in pixels
    ImPlotStyleVar_ErrorBarWeight,     // float,  error bar whisker weight in pixels
    ImPlotStyleVar_DigitalBitHeight,   // float,  digital channels bit height (at 1) in pixels
    ImPlotStyleVar_DigitalBitGap,      // float,  digital channels bit padding gap in pixels
    // plot styling variables
    ImPlotStyleVar_PlotBorderSize,     // float,  thickness of border around plot area
    ImPlotStyleVar_MinorAlpha,         // float,  alpha multiplier applied to minor axis grid lines
    ImPlotStyleVar_MajorTickLen,       // ImVec2, major tick lengths for X and Y axes
    ImPlotStyleVar_MinorTickLen,       // ImVec2, minor tick lengths for X and Y axes
    ImPlotStyleVar_MajorTickSize,      // ImVec2, line thickness of major ticks
    ImPlotStyleVar_MinorTickSize,      // ImVec2, line thickness of minor ticks
    ImPlotStyleVar_MajorGridSize,      // ImVec2, line thickness of major grid lines
    ImPlotStyleVar_MinorGridSize,      // ImVec2, line thickness of minor grid lines
    ImPlotStyleVar_PlotPadding,        // ImVec2, padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
    ImPlotStyleVar_LabelPadding,       // ImVec2, padding between axes labels, tick labels, and plot edge
    ImPlotStyleVar_LegendPadding,      // ImVec2, legend padding from plot edges
    ImPlotStyleVar_LegendInnerPadding, // ImVec2, legend inner padding from legend edges
    ImPlotStyleVar_LegendSpacing,      // ImVec2, spacing between legend entries
    ImPlotStyleVar_MousePosPadding,    // ImVec2, padding between plot edge and interior info text
    ImPlotStyleVar_AnnotationPadding,  // ImVec2, text padding around annotation labels
    ImPlotStyleVar_FitPadding,         // ImVec2, additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
    ImPlotStyleVar_PlotDefaultSize,    // ImVec2, default size used when ImVec2(0,0) is passed to BeginPlot
    ImPlotStyleVar_PlotMinSize,        // ImVec2, minimum size plot frame can be when shrunk
    ImPlotStyleVar_COUNT
};

// Axis scale
enum ImPlotScale_ {
    ImPlotScale_Linear = 0, // default linear scale
    ImPlotScale_Time,       // date/time scale
    ImPlotScale_Log10,      // base 10 logartithmic scale
    ImPlotScale_SymLog,     // symmetric log scale
};

// Marker specifications.
enum ImPlotMarker_ {
    ImPlotMarker_None = -1, // no marker
    ImPlotMarker_Circle,    // a circle marker (default)
    ImPlotMarker_Square,    // a square maker
    ImPlotMarker_Diamond,   // a diamond marker
    ImPlotMarker_Up,        // an upward-pointing triangle marker
    ImPlotMarker_Down,      // an downward-pointing triangle marker
    ImPlotMarker_Left,      // an leftward-pointing triangle marker
    ImPlotMarker_Right,     // an rightward-pointing triangle marker
    ImPlotMarker_Cross,     // a cross marker (not fillable)
    ImPlotMarker_Plus,      // a plus marker (not fillable)
    ImPlotMarker_Asterisk,  // a asterisk marker (not fillable)
    ImPlotMarker_COUNT
};

// Built-in colormaps
enum ImPlotColormap_ {
    ImPlotColormap_Deep     = 0,   // a.k.a. seaborn deep             (qual=true,  n=10) (default)
    ImPlotColormap_Dark     = 1,   // a.k.a. matplotlib "Set1"        (qual=true,  n=9 )
    ImPlotColormap_Pastel   = 2,   // a.k.a. matplotlib "Pastel1"     (qual=true,  n=9 )
    ImPlotColormap_Paired   = 3,   // a.k.a. matplotlib "Paired"      (qual=true,  n=12)
    ImPlotColormap_Viridis  = 4,   // a.k.a. matplotlib "viridis"     (qual=false, n=11)
    ImPlotColormap_Plasma   = 5,   // a.k.a. matplotlib "plasma"      (qual=false, n=11)
    ImPlotColormap_Hot      = 6,   // a.k.a. matplotlib/MATLAB "hot"  (qual=false, n=11)
    ImPlotColormap_Cool     = 7,   // a.k.a. matplotlib/MATLAB "cool" (qual=false, n=11)
    ImPlotColormap_Pink     = 8,   // a.k.a. matplotlib/MATLAB "pink" (qual=false, n=11)
    ImPlotColormap_Jet      = 9,   // a.k.a. MATLAB "jet"             (qual=false, n=11)
    ImPlotColormap_Twilight = 10,  // a.k.a. matplotlib "twilight"    (qual=false, n=11)
    ImPlotColormap_RdBu     = 11,  // red/blue, Color Brewer          (qual=false, n=11)
    ImPlotColormap_BrBG     = 12,  // brown/blue-green, Color Brewer  (qual=false, n=11)
    ImPlotColormap_PiYG     = 13,  // pink/yellow-green, Color Brewer (qual=false, n=11)
    ImPlotColormap_Spectral = 14,  // color spectrum, Color Brewer    (qual=false, n=11)
    ImPlotColormap_Greys    = 15,  // white/black                     (qual=false, n=2 )
};

// Used to position items on a plot (e.g. legends, labels, etc.)
enum ImPlotLocation_ {
    ImPlotLocation_Center    = 0,                                          // center-center
    ImPlotLocation_North     = 1 << 0,                                     // top-center
    ImPlotLocation_South     = 1 << 1,                                     // bottom-center
    ImPlotLocation_West      = 1 << 2,                                     // center-left
    ImPlotLocation_East      = 1 << 3,                                     // center-right
    ImPlotLocation_NorthWest = ImPlotLocation_North | ImPlotLocation_West, // top-left
    ImPlotLocation_NorthEast = ImPlotLocation_North | ImPlotLocation_East, // top-right
    ImPlotLocation_SouthWest = ImPlotLocation_South | ImPlotLocation_West, // bottom-left
    ImPlotLocation_SouthEast = ImPlotLocation_South | ImPlotLocation_East  // bottom-right
};

// Enums for different automatic histogram binning methods (k = bin count or w = bin width)
enum ImPlotBin_ {
    ImPlotBin_Sqrt    = -1, // k = sqrt(n)
    ImPlotBin_Sturges = -2, // k = 1 + log2(n)
    ImPlotBin_Rice    = -3, // k = 2 * cbrt(n)
    ImPlotBin_Scott   = -4, // w = 3.49 * sigma / cbrt(n)
};

// Double precision version of ImVec2 used by ImPlot. Extensible by end users.
struct ImPlotPoint {
    double x, y;
    ImPlotPoint()                         { x = y = 0.0;      }
    ImPlotPoint(double _x, double _y)     { x = _x; y = _y;   }
    ImPlotPoint(const ImVec2& p)          { x = p.x; y = p.y; }
    double  operator[] (size_t idx) const { return (&x)[idx]; }
    double& operator[] (size_t idx)       { return (&x)[idx]; }
#ifdef IMPLOT_POINT_CLASS_EXTRA
    IMPLOT_POINT_CLASS_EXTRA     // Define additional constructors and implicit cast operators in imconfig.h
                                 // to convert back and forth between your math types and ImPlotPoint.
#endif
};

// Range defined by a min/max value.
struct ImPlotRange {
    double Min, Max;
    ImPlotRange()                         { Min = 0; Max = 0;                                         }
    ImPlotRange(double _min, double _max) { Min = _min; Max = _max;                                   }
    bool Contains(double value) const     { return value >= Min && value <= Max;                      }
    double Size() const                   { return Max - Min;                                         }
    double Clamp(double value) const      { return (value < Min) ? Min : (value > Max) ? Max : value; }
};

// Combination of two range limits for X and Y axes. Also an AABB defined by Min()/Max().
struct ImPlotRect {
    ImPlotRange X, Y;
    ImPlotRect()                                                       {                                                               }
    ImPlotRect(double x_min, double x_max, double y_min, double y_max) { X.Min = x_min; X.Max = x_max; Y.Min = y_min; Y.Max = y_max;   }
    bool Contains(const ImPlotPoint& p) const                          { return Contains(p.x, p.y);                                    }
    bool Contains(double x, double y) const                            { return X.Contains(x) && Y.Contains(y);                        }
    ImPlotPoint Size() const                                           { return ImPlotPoint(X.Size(), Y.Size());                       }
    ImPlotPoint Clamp(const ImPlotPoint& p)                            { return Clamp(p.x, p.y);                                       }
    ImPlotPoint Clamp(double x, double y)                              { return ImPlotPoint(X.Clamp(x),Y.Clamp(y));                    }
    ImPlotPoint Min() const                                            { return ImPlotPoint(X.Min, Y.Min);                             }
    ImPlotPoint Max() const                                            { return ImPlotPoint(X.Max, Y.Max);                             }
};

// Plot style structure
struct ImPlotStyle {
    // item styling variables
    float   LineWeight;              // = 1,      item line weight in pixels
    int     Marker;                  // = ImPlotMarker_None, marker specification
    float   MarkerSize;              // = 4,      marker size in pixels (roughly the marker's "radius")
    float   MarkerWeight;            // = 1,      outline weight of markers in pixels
    float   FillAlpha;               // = 1,      alpha modifier applied to plot fills
    float   ErrorBarSize;            // = 5,      error bar whisker width in pixels
    float   ErrorBarWeight;          // = 1.5,    error bar whisker weight in pixels
    float   DigitalBitHeight;        // = 8,      digital channels bit height (at y = 1.0f) in pixels
    float   DigitalBitGap;           // = 4,      digital channels bit padding gap in pixels
    // plot styling variables
    float   PlotBorderSize;          // = 1,      line thickness of border around plot area
    float   MinorAlpha;              // = 0.25    alpha multiplier applied to minor axis grid lines
    ImVec2  MajorTickLen;            // = 10,10   major tick lengths for X and Y axes
    ImVec2  MinorTickLen;            // = 5,5     minor tick lengths for X and Y axes
    ImVec2  MajorTickSize;           // = 1,1     line thickness of major ticks
    ImVec2  MinorTickSize;           // = 1,1     line thickness of minor ticks
    ImVec2  MajorGridSize;           // = 1,1     line thickness of major grid lines
    ImVec2  MinorGridSize;           // = 1,1     line thickness of minor grid lines
    ImVec2  PlotPadding;             // = 10,10   padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
    ImVec2  LabelPadding;            // = 5,5     padding between axes labels, tick labels, and plot edge
    ImVec2  LegendPadding;           // = 10,10   legend padding from plot edges
    ImVec2  LegendInnerPadding;      // = 5,5     legend inner padding from legend edges
    ImVec2  LegendSpacing;           // = 5,0     spacing between legend entries
    ImVec2  MousePosPadding;         // = 10,10   padding between plot edge and interior mouse location text
    ImVec2  AnnotationPadding;       // = 2,2     text padding around annotation labels
    ImVec2  FitPadding;              // = 0,0     additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
    ImVec2  PlotDefaultSize;         // = 400,300 default size used when ImVec2(0,0) is passed to BeginPlot
    ImVec2  PlotMinSize;             // = 200,150 minimum size plot frame can be when shrunk
    // style colors
    ImVec4  Colors[ImPlotCol_COUNT]; // Array of styling colors. Indexable with ImPlotCol_ enums.
    // colormap
    ImPlotColormap Colormap;         // The current colormap. Set this to either an ImPlotColormap_ enum or an index returned by AddColormap.
    // settings/flags
    bool    UseLocalTime;            // = false,  axis labels will be formatted for your timezone when ImPlotAxisFlag_Time is enabled
    bool    UseISO8601;              // = false,  dates will be formatted according to ISO 8601 where applicable (e.g. YYYY-MM-DD, YYYY-MM, --MM-DD, etc.)
    bool    Use24HourClock;          // = false,  times will be formatted using a 24 hour clock
    IMPLOT_API ImPlotStyle();
};

// Support for legacy versions
#if (IMGUI_VERSION_NUM < 18716) // Renamed in 1.88
#define ImGuiMod_None       0
#define ImGuiMod_Ctrl       ImGuiKeyModFlags_Ctrl
#define ImGuiMod_Shift      ImGuiKeyModFlags_Shift
#define ImGuiMod_Alt        ImGuiKeyModFlags_Alt
#define ImGuiMod_Super      ImGuiKeyModFlags_Super
#elif (IMGUI_VERSION_NUM < 18823) // Renamed in 1.89, sorry
#define ImGuiMod_None       0
#define ImGuiMod_Ctrl       ImGuiModFlags_Ctrl
#define ImGuiMod_Shift      ImGuiModFlags_Shift
#define ImGuiMod_Alt        ImGuiModFlags_Alt
#define ImGuiMod_Super      ImGuiModFlags_Super
#endif

// Input mapping structure. Default values listed. See also MapInputDefault, MapInputReverse.
struct ImPlotInputMap {
    ImGuiMouseButton Pan;           // LMB    enables panning when held,
    int              PanMod;        // none   optional modifier that must be held for panning/fitting
    ImGuiMouseButton Fit;           // LMB    initiates fit when double clicked
    ImGuiMouseButton Select;        // RMB    begins box selection when pressed and confirms selection when released
    ImGuiMouseButton SelectCancel;  // LMB    cancels active box selection when pressed; cannot be same as Select
    int              SelectMod;     // none   optional modifier that must be held for box selection
    int              SelectHorzMod; // Alt    expands active box selection horizontally to plot edge when held
    int              SelectVertMod; // Shift  expands active box selection vertically to plot edge when held
    ImGuiMouseButton Menu;          // RMB    opens context menus (if enabled) when clicked
    int              OverrideMod;   // Ctrl   when held, all input is ignored; used to enable axis/plots as DND sources
    int              ZoomMod;       // none   optional modifier that must be held for scroll wheel zooming
    float            ZoomRate;      // 0.1f   zoom rate for scroll (e.g. 0.1f = 10% plot range every scroll click); make negative to invert
    IMPLOT_API ImPlotInputMap();
};

//-----------------------------------------------------------------------------
// [SECTION] Callbacks
//-----------------------------------------------------------------------------

// Callback signature for axis tick label formatter.
typedef int (*ImPlotFormatter)(double value, char* buff, int size, void* user_data);

// Callback signature for data getter.
typedef ImPlotPoint (*ImPlotGetter)(int idx, void* user_data);

// Callback signature for axis transform.
typedef double (*ImPlotTransform)(double value, void* user_data);

namespace ImPlot {

//-----------------------------------------------------------------------------
// [SECTION] Contexts
//-----------------------------------------------------------------------------

// Creates a new ImPlot context. Call this after ImGui::CreateContext.
IMPLOT_API ImPlotContext* CreateContext();
// Destroys an ImPlot context. Call this before ImGui::DestroyContext. nullptr = destroy current context.
IMPLOT_API void DestroyContext(ImPlotContext* ctx = nullptr);
// Returns the current ImPlot context. nullptr if no context has ben set.
IMPLOT_API ImPlotContext* GetCurrentContext();
// Sets the current ImPlot context.
IMPLOT_API void SetCurrentContext(ImPlotContext* ctx);

// Sets the current **ImGui** context. This is ONLY necessary if you are compiling
// ImPlot as a DLL (not recommended) separate from your ImGui compilation. It
// sets the global variable GImGui, which is not shared across DLL boundaries.
// See GImGui documentation in imgui.cpp for more details.
IMPLOT_API void SetImGuiContext(ImGuiContext* ctx);

//-----------------------------------------------------------------------------
// [SECTION] Begin/End Plot
//-----------------------------------------------------------------------------

// Starts a 2D plotting context. If this function returns true, EndPlot() MUST
// be called! You are encouraged to use the following convention:
//
// if (BeginPlot(...)) {
//     PlotLine(...);
//     ...
//     EndPlot();
// }
//
// Important notes:
//
// - #title_id must be unique to the current ImGui ID scope. If you need to avoid ID
//   collisions or don't want to display a title in the plot, use double hashes
//   (e.g. "MyPlot##HiddenIdText" or "##NoTitle").
// - #size is the **frame** size of the plot widget, not the plot area. The default
//   size of plots (i.e. when ImVec2(0,0)) can be modified in your ImPlotStyle.
IMPLOT_API bool BeginPlot(const char* title_id, const ImVec2& size=ImVec2(-1,0), ImPlotFlags flags=0);

// Only call EndPlot() if BeginPlot() returns true! Typically called at the end
// of an if statement conditioned on BeginPlot(). See example above.
IMPLOT_API void EndPlot();

//-----------------------------------------------------------------------------
// [SECTION] Begin/End Subplots
//-----------------------------------------------------------------------------

// Starts a subdivided plotting context. If the function returns true,
// EndSubplots() MUST be called! Call BeginPlot/EndPlot AT MOST [rows*cols]
// times in  between the begining and end of the subplot context. Plots are
// added in row major order.
//
// Example:
//
// if (BeginSubplots("My Subplot",2,3,ImVec2(800,400)) {
//     for (int i = 0; i < 6; ++i) {
//         if (BeginPlot(...)) {
//             ImPlot::PlotLine(...);
//             ...
//             EndPlot();
//         }
//     }
//     EndSubplots();
// }
//
// Produces:
//
// [0] | [1] | [2]
// ----|-----|----
// [3] | [4] | [5]
//
// Important notes:
//
// - #title_id must be unique to the current ImGui ID scope. If you need to avoid ID
//   collisions or don't want to display a title in the plot, use double hashes
//   (e.g. "MySubplot##HiddenIdText" or "##NoTitle").
// - #rows and #cols must be greater than 0.
// - #size is the size of the entire grid of subplots, not the individual plots
// - #row_ratios and #col_ratios must have AT LEAST #rows and #cols elements,
//   respectively. These are the sizes of the rows and columns expressed in ratios.
//   If the user adjusts the dimensions, the arrays are updated with new ratios.
//
// Important notes regarding BeginPlot from inside of BeginSubplots:
//
// - The #title_id parameter of _BeginPlot_ (see above) does NOT have to be
//   unique when called inside of a subplot context. Subplot IDs are hashed
//   for your convenience so you don't have call PushID or generate unique title
//   strings. Simply pass an empty string to BeginPlot unless you want to title
//   each subplot.
// - The #size parameter of _BeginPlot_ (see above) is ignored when inside of a
//   subplot context. The actual size of the subplot will be based on the
//   #size value you pass to _BeginSubplots_ and #row/#col_ratios if provided.

IMPLOT_API bool BeginSubplots(const char* title_id,
                             int rows,
                             int cols,
                             const ImVec2& size,
                             ImPlotSubplotFlags flags = 0,
                             float* row_ratios        = nullptr,
                             float* col_ratios        = nullptr);

// Only call EndSubplots() if BeginSubplots() returns true! Typically called at the end
// of an if statement conditioned on BeginSublots(). See example above.
IMPLOT_API void EndSubplots();

//-----------------------------------------------------------------------------
// [SECTION] Setup
//-----------------------------------------------------------------------------

// The following API allows you to setup and customize various aspects of the
// current plot. The functions should be called immediately after BeginPlot
// and before any other API calls. Typical usage is as follows:

// if (BeginPlot(...)) {                     1) begin a new plot
//     SetupAxis(ImAxis_X1, "My X-Axis");    2) make Setup calls
//     SetupAxis(ImAxis_Y1, "My Y-Axis");
//     SetupLegend(ImPlotLocation_North);
//     ...
//     SetupFinish();                        3) [optional] explicitly finish setup
//     PlotLine(...);                        4) plot items
//     ...
//     EndPlot();                            5) end the plot
// }
//
// Important notes:
//
// - Always call Setup code at the top of your BeginPlot conditional statement.
// - Setup is locked once you start plotting or explicitly call SetupFinish.
//   Do NOT call Setup code after you begin plotting or after you make
//   any non-Setup API calls (e.g. utils like PlotToPixels also lock Setup)
// - Calling SetupFinish is OPTIONAL, but probably good practice. If you do not
//   call it yourself, then the first subsequent plotting or utility function will
//   call it for you.

// Enables an axis or sets the label and/or flags for an existing axis. Leave #label = nullptr for no label.
IMPLOT_API void SetupAxis(ImAxis axis, const char* label=nullptr, ImPlotAxisFlags flags=0);
// Sets an axis range limits. If ImPlotCond_Always is used, the axes limits will be locked.
IMPLOT_API void SetupAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond = ImPlotCond_Once);
// Links an axis range limits to external values. Set to nullptr for no linkage. The pointer data must remain valid until EndPlot.
IMPLOT_API void SetupAxisLinks(ImAxis axis, double* link_min, double* link_max);
// Sets the format of numeric axis labels via formater specifier (default="%g"). Formated values will be double (i.e. use %f).
IMPLOT_API void SetupAxisFormat(ImAxis axis, const char* fmt);
// Sets the format of numeric axis labels via formatter callback. Given #value, write a label into #buff. Optionally pass user data.
IMPLOT_API void SetupAxisFormat(ImAxis axis, ImPlotFormatter formatter, void* data=nullptr);
// Sets an axis' ticks and optionally the labels. To keep the default ticks, set #keep_default=true.
IMPLOT_API void SetupAxisTicks(ImAxis axis, const double* values, int n_ticks, const char* const labels[]=nullptr, bool keep_default=false);
// Sets an axis' ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
IMPLOT_API void SetupAxisTicks(ImAxis axis, double v_min, double v_max, int n_ticks, const char* const labels[]=nullptr, bool keep_default=false);
// Sets an axis' scale using built-in options.
IMPLOT_API void SetupAxisScale(ImAxis axis, ImPlotScale scale);
// Sets an axis' scale using user supplied forward and inverse transfroms.
IMPLOT_API void SetupAxisScale(ImAxis axis, ImPlotTransform forward, ImPlotTransform inverse, void* data=nullptr);
// Sets an axis' limits constraints.
IMPLOT_API void SetupAxisLimitsConstraints(ImAxis axis, double v_min, double v_max);
// Sets an axis' zoom constraints.
IMPLOT_API void SetupAxisZoomConstraints(ImAxis axis, double z_min, double z_max);

// Sets the label and/or flags for primary X and Y axes (shorthand for two calls to SetupAxis).
IMPLOT_API void SetupAxes(const char* x_label, const char* y_label, ImPlotAxisFlags x_flags=0, ImPlotAxisFlags y_flags=0);
// Sets the primary X and Y axes range limits. If ImPlotCond_Always is used, the axes limits will be locked (shorthand for two calls to SetupAxisLimits).
IMPLOT_API void SetupAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond = ImPlotCond_Once);

// Sets up the plot legend.
IMPLOT_API void SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags=0);
// Set the location of the current plot's mouse position text (default = South|East).
IMPLOT_API void SetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags=0);

// Explicitly finalize plot setup. Once you call this, you cannot make anymore Setup calls for the current plot!
// Note that calling this function is OPTIONAL; it will be called by the first subsequent setup-locking API call.
IMPLOT_API void SetupFinish();

//-----------------------------------------------------------------------------
// [SECTION] SetNext
//-----------------------------------------------------------------------------

// Though you should default to the `Setup` API above, there are some scenarios
// where (re)configuring a plot or axis before `BeginPlot` is needed (e.g. if
// using a preceding button or slider widget to change the plot limits). In
// this case, you can use the `SetNext` API below. While this is not as feature
// rich as the Setup API, most common needs are provided. These functions can be
// called anwhere except for inside of `Begin/EndPlot`. For example:

// if (ImGui::Button("Center Plot"))
//     ImPlot::SetNextPlotLimits(-1,1,-1,1);
// if (ImPlot::BeginPlot(...)) {
//     ...
//     ImPlot::EndPlot();
// }
//
// Important notes:
//
// - You must still enable non-default axes with SetupAxis for these functions
//   to work properly.

// Sets an upcoming axis range limits. If ImPlotCond_Always is used, the axes limits will be locked.
IMPLOT_API void SetNextAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond = ImPlotCond_Once);
// Links an upcoming axis range limits to external values. Set to nullptr for no linkage. The pointer data must remain valid until EndPlot!
IMPLOT_API void SetNextAxisLinks(ImAxis axis, double* link_min, double* link_max);
// Set an upcoming axis to auto fit to its data.
IMPLOT_API void SetNextAxisToFit(ImAxis axis);

// Sets the upcoming primary X and Y axes range limits. If ImPlotCond_Always is used, the axes limits will be locked (shorthand for two calls to SetupAxisLimits).
IMPLOT_API void SetNextAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond = ImPlotCond_Once);
// Sets all upcoming axes to auto fit to their data.
IMPLOT_API void SetNextAxesToFit();

//-----------------------------------------------------------------------------
// [SECTION] Plot Items
//-----------------------------------------------------------------------------

// The main plotting API is provied below. Call these functions between
// Begin/EndPlot and after any Setup API calls. Each plots data on the current
// x and y axes, which can be changed with `SetAxis/Axes`.
//
// The templated functions are explicitly instantiated in implot_items.cpp.
// They are not intended to be used generically with custom types. You will get
// a linker error if you try! All functions support the following scalar types:
//
// float, double, ImS8, ImU8, ImS16, ImU16, ImS32, ImU32, ImS64, ImU64
//
//
// If you need to plot custom or non-homogenous data you have a few options:
//
// 1. If your data is a simple struct/class (e.g. Vector2f), you can use striding.
//    This is the most performant option if applicable.
//
//    struct Vector2f { float X, Y; };
//    ...
//    Vector2f data[42];
//    ImPlot::PlotLine("line", &data[0].x, &data[0].y, 42, 0, 0, sizeof(Vector2f));
//
// 2. Write a custom getter C function or C++ lambda and pass it and optionally your data to
//    an ImPlot function post-fixed with a G (e.g. PlotScatterG). This has a slight performance
//    cost, but probably not enough to worry about unless your data is very large. Examples:
//
//    ImPlotPoint MyDataGetter(void* data, int idx) {
//        MyData* my_data = (MyData*)data;
//        ImPlotPoint p;
//        p.x = my_data->GetTime(idx);
//        p.y = my_data->GetValue(idx);
//        return p
//    }
//    ...
//    auto my_lambda = [](int idx, void*) {
//        double t = idx / 999.0;
//        return ImPlotPoint(t, 0.5+0.5*std::sin(2*PI*10*t));
//    };
//    ...
//    if (ImPlot::BeginPlot("MyPlot")) {
//        MyData my_data;
//        ImPlot::PlotScatterG("scatter", MyDataGetter, &my_data, my_data.Size());
//        ImPlot::PlotLineG("line", my_lambda, nullptr, 1000);
//        ImPlot::EndPlot();
//    }
//
// NB: All types are converted to double before plotting. You may lose information
// if you try plotting extremely large 64-bit integral types. Proceed with caution!

// Plots a standard 2D line plot.
IMPLOT_TMP void PlotLine(const char* label_id, const T* values, int count, double xscale=1, double xstart=0, ImPlotLineFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_TMP void PlotLine(const char* label_id, const T* xs, const T* ys, int count, ImPlotLineFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_API void PlotLineG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotLineFlags flags=0);

// Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
IMPLOT_TMP void PlotScatter(const char* label_id, const T* values, int count, double xscale=1, double xstart=0, ImPlotScatterFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_TMP void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, ImPlotScatterFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_API void PlotScatterG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotScatterFlags flags=0);

// Plots a a stairstep graph. The y value is continued constantly to the right from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i]
IMPLOT_TMP void PlotStairs(const char* label_id, const T* values, int count, double xscale=1, double xstart=0, ImPlotStairsFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_TMP void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, ImPlotStairsFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_API void PlotStairsG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotStairsFlags flags=0);

// Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set yref to +/-INFINITY for infinite fill extents.
IMPLOT_TMP void PlotShaded(const char* label_id, const T* values, int count, double yref=0, double xscale=1, double xstart=0, ImPlotShadedFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_TMP void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double yref=0, ImPlotShadedFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_TMP void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, ImPlotShadedFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_API void PlotShadedG(const char* label_id, ImPlotGetter getter1, void* data1, ImPlotGetter getter2, void* data2, int count, ImPlotShadedFlags flags=0);

// Plots a bar graph. Vertical by default. #bar_size and #shift are in plot units.
IMPLOT_TMP void PlotBars(const char* label_id, const T* values, int count, double bar_size=0.67, double shift=0, ImPlotBarsFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_TMP void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double bar_size, ImPlotBarsFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_API void PlotBarsG(const char* label_id, ImPlotGetter getter, void* data, int count, double bar_size, ImPlotBarsFlags flags=0);

// Plots a group of bars. #values is a row-major matrix with #item_count rows and #group_count cols. #label_ids should have #item_count elements.
IMPLOT_TMP void PlotBarGroups(const char* const label_ids[], const T* values, int item_count, int group_count, double group_size=0.67, double shift=0, ImPlotBarGroupsFlags flags=0);

// Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
IMPLOT_TMP void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, ImPlotErrorBarsFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_TMP void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, ImPlotErrorBarsFlags flags=0, int offset=0, int stride=sizeof(T));

// Plots stems. Vertical by default.
IMPLOT_TMP void PlotStems(const char* label_id, const T* values, int count, double ref=0, double scale=1, double start=0, ImPlotStemsFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_TMP void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double ref=0, ImPlotStemsFlags flags=0, int offset=0, int stride=sizeof(T));

// Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
IMPLOT_TMP void PlotInfLines(const char* label_id, const T* values, int count, ImPlotInfLinesFlags flags=0, int offset=0, int stride=sizeof(T));

// Plots a pie chart. Center and radius are in plot units. #label_fmt can be set to nullptr for no labels.
IMPLOT_TMP void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, const char* label_fmt="%.1f", double angle0=90, ImPlotPieChartFlags flags=0);

// Plots a 2D heatmap chart. Values are expected to be in row-major order by default. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to nullptr for no labels.
IMPLOT_TMP void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min=0, double scale_max=0, const char* label_fmt="%.1f", const ImPlotPoint& bounds_min=ImPlotPoint(0,0), const ImPlotPoint& bounds_max=ImPlotPoint(1,1), ImPlotHeatmapFlags flags=0);

// Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #range is left unspecified, the min/max of #values will be used as the range.
// Otherwise, outlier values outside of the range are not binned. The largest bin count or density is returned.
IMPLOT_TMP double PlotHistogram(const char* label_id, const T* values, int count, int bins=ImPlotBin_Sturges, double bar_scale=1.0, ImPlotRange range=ImPlotRange(), ImPlotHistogramFlags flags=0);

// Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #range is left unspecified, the min/max of
// #xs an #ys will be used as the ranges. Otherwise, outlier values outside of range are not binned. The largest bin count or density is returned.
IMPLOT_TMP double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins=ImPlotBin_Sturges, int y_bins=ImPlotBin_Sturges, ImPlotRect range=ImPlotRect(), ImPlotHistogramFlags flags=0);

// Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
IMPLOT_TMP void PlotDigital(const char* label_id, const T* xs, const T* ys, int count, ImPlotDigitalFlags flags=0, int offset=0, int stride=sizeof(T));
IMPLOT_API void PlotDigitalG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotDigitalFlags flags=0);

// Plots an axis-aligned image. #bounds_min/bounds_max are in plot coordinates (y-up) and #uv0/uv1 are in texture coordinates (y-down).
IMPLOT_API void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, const ImVec2& uv0=ImVec2(0,0), const ImVec2& uv1=ImVec2(1,1), const ImVec4& tint_col=ImVec4(1,1,1,1), ImPlotImageFlags flags=0);

// Plots a centered text label at point x,y with an optional pixel offset. Text color can be changed with ImPlot::PushStyleColor(ImPlotCol_InlayText, ...).
IMPLOT_API void PlotText(const char* text, double x, double y, const ImVec2& pix_offset=ImVec2(0,0), ImPlotTextFlags flags=0);

// Plots a dummy item (i.e. adds a legend entry colored by ImPlotCol_Line)
IMPLOT_API void PlotDummy(const char* label_id, ImPlotDummyFlags flags=0);

//-----------------------------------------------------------------------------
// [SECTION] Plot Tools
//-----------------------------------------------------------------------------

// The following can be used to render interactive elements and/or annotations.
// Like the item plotting functions above, they apply to the current x and y
// axes, which can be changed with `SetAxis/SetAxes`.

// Shows a draggable point at x,y. #col defaults to ImGuiCol_Text.
IMPLOT_API bool DragPoint(int id, double* x, double* y, const ImVec4& col, float size = 4, ImPlotDragToolFlags flags=0);
// Shows a draggable vertical guide line at an x-value. #col defaults to ImGuiCol_Text.
IMPLOT_API bool DragLineX(int id, double* x, const ImVec4& col, float thickness = 1, ImPlotDragToolFlags flags=0);
// Shows a draggable horizontal guide line at a y-value. #col defaults to ImGuiCol_Text.
IMPLOT_API bool DragLineY(int id, double* y, const ImVec4& col, float thickness = 1, ImPlotDragToolFlags flags=0);
// Shows a draggable and resizeable rectangle.
IMPLOT_API bool DragRect(int id, double* x1, double* y1, double* x2, double* y2, const ImVec4& col, ImPlotDragToolFlags flags=0);

// Shows an annotation callout at a chosen point. Clamping keeps annotations in the plot area. Annotations are always rendered on top.
IMPLOT_API void Annotation(double x, double y, const ImVec4& col, const ImVec2& pix_offset, bool clamp, bool round = false);
IMPLOT_API void Annotation(double x, double y, const ImVec4& col, const ImVec2& pix_offset, bool clamp, const char* fmt, ...)           IM_FMTARGS(6);
IMPLOT_API void AnnotationV(double x, double y, const ImVec4& col, const ImVec2& pix_offset, bool clamp, const char* fmt, va_list args) IM_FMTLIST(6);

// Shows a x-axis tag at the specified coordinate value.
IMPLOT_API void TagX(double x, const ImVec4& col, bool round = false);
IMPLOT_API void TagX(double x, const ImVec4& col, const char* fmt, ...)           IM_FMTARGS(3);
IMPLOT_API void TagXV(double x, const ImVec4& col, const char* fmt, va_list args) IM_FMTLIST(3);

// Shows a y-axis tag at the specified coordinate value.
IMPLOT_API void TagY(double y, const ImVec4& col, bool round = false);
IMPLOT_API void TagY(double y, const ImVec4& col, const char* fmt, ...)           IM_FMTARGS(3);
IMPLOT_API void TagYV(double y, const ImVec4& col, const char* fmt, va_list args) IM_FMTLIST(3);

//-----------------------------------------------------------------------------
// [SECTION] Plot Utils
//-----------------------------------------------------------------------------

// Select which axis/axes will be used for subsequent plot elements.
IMPLOT_API void SetAxis(ImAxis axis);
IMPLOT_API void SetAxes(ImAxis x_axis, ImAxis y_axis);

// Convert pixels to a position in the current plot's coordinate system. Passing IMPLOT_AUTO uses the current axes.
IMPLOT_API ImPlotPoint PixelsToPlot(const ImVec2& pix, ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
IMPLOT_API ImPlotPoint PixelsToPlot(float x, float y, ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);

// Convert a position in the current plot's coordinate system to pixels. Passing IMPLOT_AUTO uses the current axes.
IMPLOT_API ImVec2 PlotToPixels(const ImPlotPoint& plt, ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
IMPLOT_API ImVec2 PlotToPixels(double x, double y, ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);

// Get the current Plot position (top-left) in pixels.
IMPLOT_API ImVec2 GetPlotPos();
// Get the curent Plot size in pixels.
IMPLOT_API ImVec2 GetPlotSize();

// Returns the mouse position in x,y coordinates of the current plot. Passing IMPLOT_AUTO uses the current axes.
IMPLOT_API ImPlotPoint GetPlotMousePos(ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
// Returns the current plot axis range.
IMPLOT_API ImPlotRect GetPlotLimits(ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);

// Returns true if the plot area in the current plot is hovered.
IMPLOT_API bool IsPlotHovered();
// Returns true if the axis label area in the current plot is hovered.
IMPLOT_API bool IsAxisHovered(ImAxis axis);
// Returns true if the bounding frame of a subplot is hovered.
IMPLOT_API bool IsSubplotsHovered();

// Returns true if the current plot is being box selected.
IMPLOT_API bool IsPlotSelected();
// Returns the current plot box selection bounds. Passing IMPLOT_AUTO uses the current axes.
IMPLOT_API ImPlotRect GetPlotSelection(ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
// Cancels a the current plot box selection.
IMPLOT_API void CancelPlotSelection();

// Hides or shows the next plot item (i.e. as if it were toggled from the legend).
// Use ImPlotCond_Always if you need to forcefully set this every frame.
IMPLOT_API void HideNextItem(bool hidden = true, ImPlotCond cond = ImPlotCond_Once);

// Use the following around calls to Begin/EndPlot to align l/r/t/b padding.
// Consider using Begin/EndSubplots first. They are more feature rich and
// accomplish the same behaviour by default. The functions below offer lower
// level control of plot alignment.

// Align axis padding over multiple plots in a single row or column. #group_id must
// be unique. If this function returns true, EndAlignedPlots() must be called.
IMPLOT_API bool BeginAlignedPlots(const char* group_id, bool vertical = true);
// Only call EndAlignedPlots() if BeginAlignedPlots() returns true!
IMPLOT_API void EndAlignedPlots();

//-----------------------------------------------------------------------------
// [SECTION] Legend Utils
//-----------------------------------------------------------------------------

// Begin a popup for a legend entry.
IMPLOT_API bool BeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_button=1);
// End a popup for a legend entry.
IMPLOT_API void EndLegendPopup();
// Returns true if a plot item legend entry is hovered.
IMPLOT_API bool IsLegendEntryHovered(const char* label_id);

//-----------------------------------------------------------------------------
// [SECTION] Drag and Drop
//-----------------------------------------------------------------------------

// Turns the current plot's plotting area into a drag and drop target. Don't forget to call EndDragDropTarget!
IMPLOT_API bool BeginDragDropTargetPlot();
// Turns the current plot's X-axis into a drag and drop target. Don't forget to call EndDragDropTarget!
IMPLOT_API bool BeginDragDropTargetAxis(ImAxis axis);
// Turns the current plot's legend into a drag and drop target. Don't forget to call EndDragDropTarget!
IMPLOT_API bool BeginDragDropTargetLegend();
// Ends a drag and drop target (currently just an alias for ImGui::EndDragDropTarget).
IMPLOT_API void EndDragDropTarget();

// NB: By default, plot and axes drag and drop *sources* require holding the Ctrl modifier to initiate the drag.
// You can change the modifier if desired. If ImGuiMod_None is provided, the axes will be locked from panning.

// Turns the current plot's plotting area into a drag and drop source. You must hold Ctrl. Don't forget to call EndDragDropSource!
IMPLOT_API bool BeginDragDropSourcePlot(ImGuiDragDropFlags flags=0);
// Turns the current plot's X-axis into a drag and drop source. You must hold Ctrl. Don't forget to call EndDragDropSource!
IMPLOT_API bool BeginDragDropSourceAxis(ImAxis axis, ImGuiDragDropFlags flags=0);
// Turns an item in the current plot's legend into drag and drop source. Don't forget to call EndDragDropSource!
IMPLOT_API bool BeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags=0);
// Ends a drag and drop source (currently just an alias for ImGui::EndDragDropSource).
IMPLOT_API void EndDragDropSource();

//-----------------------------------------------------------------------------
// [SECTION] Styling
//-----------------------------------------------------------------------------

// Styling colors in ImPlot works similarly to styling colors in ImGui, but
// with one important difference. Like ImGui, all style colors are stored in an
// indexable array in ImPlotStyle. You can permanently modify these values through
// GetStyle().Colors, or temporarily modify them with Push/Pop functions below.
// However, by default all style colors in ImPlot default to a special color
// IMPLOT_AUTO_COL. The behavior of this color depends upon the style color to
// which it as applied:
//
//     1) For style colors associated with plot items (e.g. ImPlotCol_Line),
//        IMPLOT_AUTO_COL tells ImPlot to color the item with the next unused
//        color in the current colormap. Thus, every item will have a different
//        color up to the number of colors in the colormap, at which point the
//        colormap will roll over. For most use cases, you should not need to
//        set these style colors to anything but IMPLOT_COL_AUTO; you are
//        probably better off changing the current colormap. However, if you
//        need to explicitly color a particular item you may either Push/Pop
//        the style color around the item in question, or use the SetNextXXXStyle
//        API below. If you permanently set one of these style colors to a specific
//        color, or forget to call Pop, then all subsequent items will be styled
//        with the color you set.
//
//     2) For style colors associated with plot styling (e.g. ImPlotCol_PlotBg),
//        IMPLOT_AUTO_COL tells ImPlot to set that color from color data in your
//        **ImGuiStyle**. The ImGuiCol_ that these style colors default to are
//        detailed above, and in general have been mapped to produce plots visually
//        consistent with your current ImGui style. Of course, you are free to
//        manually set these colors to whatever you like, and further can Push/Pop
//        them around individual plots for plot-specific styling (e.g. coloring axes).

// Provides access to plot style structure for permanant modifications to colors, sizes, etc.
IMPLOT_API ImPlotStyle& GetStyle();

// Style plot colors for current ImGui style (default).
IMPLOT_API void StyleColorsAuto(ImPlotStyle* dst = nullptr);
// Style plot colors for ImGui "Classic".
IMPLOT_API void StyleColorsClassic(ImPlotStyle* dst = nullptr);
// Style plot colors for ImGui "Dark".
IMPLOT_API void StyleColorsDark(ImPlotStyle* dst = nullptr);
// Style plot colors for ImGui "Light".
IMPLOT_API void StyleColorsLight(ImPlotStyle* dst = nullptr);

// Use PushStyleX to temporarily modify your ImPlotStyle. The modification
// will last until the matching call to PopStyleX. You MUST call a pop for
// every push, otherwise you will leak memory! This behaves just like ImGui.

// Temporarily modify a style color. Don't forget to call PopStyleColor!
IMPLOT_API void PushStyleColor(ImPlotCol idx, ImU32 col);
IMPLOT_API void PushStyleColor(ImPlotCol idx, const ImVec4& col);
// Undo temporary style color modification(s). Undo multiple pushes at once by increasing count.
IMPLOT_API void PopStyleColor(int count = 1);

// Temporarily modify a style variable of float type. Don't forget to call PopStyleVar!
IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, float val);
// Temporarily modify a style variable of int type. Don't forget to call PopStyleVar!
IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, int val);
// Temporarily modify a style variable of ImVec2 type. Don't forget to call PopStyleVar!
IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, const ImVec2& val);
// Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count.
IMPLOT_API void PopStyleVar(int count = 1);

// The following can be used to modify the style of the next plot item ONLY. They do
// NOT require calls to PopStyleX. Leave style attributes you don't want modified to
// IMPLOT_AUTO or IMPLOT_AUTO_COL. Automatic styles will be deduced from the current
// values in your ImPlotStyle or from Colormap data.

// Set the line color and weight for the next item only.
IMPLOT_API void SetNextLineStyle(const ImVec4& col = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO);
// Set the fill color for the next item only.
IMPLOT_API void SetNextFillStyle(const ImVec4& col = IMPLOT_AUTO_COL, float alpha_mod = IMPLOT_AUTO);
// Set the marker style for the next item only.
IMPLOT_API void SetNextMarkerStyle(ImPlotMarker marker = IMPLOT_AUTO, float size = IMPLOT_AUTO, const ImVec4& fill = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO, const ImVec4& outline = IMPLOT_AUTO_COL);
// Set the error bar style for the next item only.
IMPLOT_API void SetNextErrorBarStyle(const ImVec4& col = IMPLOT_AUTO_COL, float size = IMPLOT_AUTO, float weight = IMPLOT_AUTO);

// Gets the last item primary color (i.e. its legend icon color)
IMPLOT_API ImVec4 GetLastItemColor();

// Returns the null terminated string name for an ImPlotCol.
IMPLOT_API const char* GetStyleColorName(ImPlotCol idx);
// Returns the null terminated string name for an ImPlotMarker.
IMPLOT_API const char* GetMarkerName(ImPlotMarker idx);

//-----------------------------------------------------------------------------
// [SECTION] Colormaps
//-----------------------------------------------------------------------------

// Item styling is based on colormaps when the relevant ImPlotCol_XXX is set to
// IMPLOT_AUTO_COL (default). Several built-in colormaps are available. You can
// add and then push/pop your own colormaps as well. To permanently set a colormap,
// modify the Colormap index member of your ImPlotStyle.

// Colormap data will be ignored and a custom color will be used if you have done one of the following:
//     1) Modified an item style color in your ImPlotStyle to anything other than IMPLOT_AUTO_COL.
//     2) Pushed an item style color using PushStyleColor().
//     3) Set the next item style with a SetNextXXXStyle function.

// Add a new colormap. The color data will be copied. The colormap can be used by pushing either the returned index or the
// string name with PushColormap. The colormap name must be unique and the size must be greater than 1. You will receive
// an assert otherwise! By default colormaps are considered to be qualitative (i.e. discrete). If you want to create a
// continuous colormap, set #qual=false. This will treat the colors you provide as keys, and ImPlot will build a linearly
// interpolated lookup table. The memory footprint of this table will be exactly ((size-1)*255+1)*4 bytes.
IMPLOT_API ImPlotColormap AddColormap(const char* name, const ImVec4* cols, int size, bool qual=true);
IMPLOT_API ImPlotColormap AddColormap(const char* name, const ImU32*  cols, int size, bool qual=true);

// Returns the number of available colormaps (i.e. the built-in + user-added count).
IMPLOT_API int GetColormapCount();
// Returns a null terminated string name for a colormap given an index. Returns nullptr if index is invalid.
IMPLOT_API const char* GetColormapName(ImPlotColormap cmap);
// Returns an index number for a colormap given a valid string name. Returns -1 if name is invalid.
IMPLOT_API ImPlotColormap GetColormapIndex(const char* name);

// Temporarily switch to one of the built-in (i.e. ImPlotColormap_XXX) or user-added colormaps (i.e. a return value of AddColormap). Don't forget to call PopColormap!
IMPLOT_API void PushColormap(ImPlotColormap cmap);
// Push a colormap by string name. Use built-in names such as "Default", "Deep", "Jet", etc. or a string you provided to AddColormap. Don't forget to call PopColormap!
IMPLOT_API void PushColormap(const char* name);
// Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count.
IMPLOT_API void PopColormap(int count = 1);

// Returns the next color from the current colormap and advances the colormap for the current plot.
// Can also be used with no return value to skip colors if desired. You need to call this between Begin/EndPlot!
IMPLOT_API ImVec4 NextColormapColor();

// Colormap utils. If cmap = IMPLOT_AUTO (default), the current colormap is assumed.
// Pass an explicit colormap index (built-in or user-added) to specify otherwise.

// Returns the size of a colormap.
IMPLOT_API int GetColormapSize(ImPlotColormap cmap = IMPLOT_AUTO);
// Returns a color from a colormap given an index >= 0 (modulo will be performed).
IMPLOT_API ImVec4 GetColormapColor(int idx, ImPlotColormap cmap = IMPLOT_AUTO);
// Sample a color from the current colormap given t between 0 and 1.
IMPLOT_API ImVec4 SampleColormap(float t, ImPlotColormap cmap = IMPLOT_AUTO);

// Shows a vertical color scale with linear spaced ticks using the specified color map. Use double hashes to hide label (e.g. "##NoLabel"). If scale_min > scale_max, the scale to color mapping will be reversed.
IMPLOT_API void ColormapScale(const char* label, double scale_min, double scale_max, const ImVec2& size = ImVec2(0,0), const char* format = "%g", ImPlotColormapScaleFlags flags = 0, ImPlotColormap cmap = IMPLOT_AUTO);
// Shows a horizontal slider with a colormap gradient background. Optionally returns the color sampled at t in [0 1].
IMPLOT_API bool ColormapSlider(const char* label, float* t, ImVec4* out = nullptr, const char* format = "", ImPlotColormap cmap = IMPLOT_AUTO);
// Shows a button with a colormap gradient brackground.
IMPLOT_API bool ColormapButton(const char* label, const ImVec2& size = ImVec2(0,0), ImPlotColormap cmap = IMPLOT_AUTO);

// When items in a plot sample their color from a colormap, the color is cached and does not change
// unless explicitly overriden. Therefore, if you change the colormap after the item has already been plotted,
// item colors will NOT update. If you need item colors to resample the new colormap, then use this
// function to bust the cached colors. If #plot_title_id is nullptr, then every item in EVERY existing plot
// will be cache busted. Otherwise only the plot specified by #plot_title_id will be busted. For the
// latter, this function must be called in the same ImGui ID scope that the plot is in. You should rarely if ever
// need this function, but it is available for applications that require runtime colormap swaps (e.g. Heatmaps demo).
IMPLOT_API void BustColorCache(const char* plot_title_id = nullptr);

//-----------------------------------------------------------------------------
// [SECTION] Input Mapping
//-----------------------------------------------------------------------------

// Provides access to input mapping structure for permanant modifications to controls for pan, select, etc.
IMPLOT_API ImPlotInputMap& GetInputMap();

// Default input mapping: pan = LMB drag, box select = RMB drag, fit = LMB double click, context menu = RMB click, zoom = scroll.
IMPLOT_API void MapInputDefault(ImPlotInputMap* dst = nullptr);
// Reverse input mapping: pan = RMB drag, box select = LMB drag, fit = LMB double click, context menu = RMB click, zoom = scroll.
IMPLOT_API void MapInputReverse(ImPlotInputMap* dst = nullptr);

//-----------------------------------------------------------------------------
// [SECTION] Miscellaneous
//-----------------------------------------------------------------------------

// Render icons similar to those that appear in legends (nifty for data lists).
IMPLOT_API void ItemIcon(const ImVec4& col);
IMPLOT_API void ItemIcon(ImU32 col);
IMPLOT_API void ColormapIcon(ImPlotColormap cmap);

// Get the plot draw list for custom rendering to the current plot area. Call between Begin/EndPlot.
IMPLOT_API ImDrawList* GetPlotDrawList();
// Push clip rect for rendering to current plot area. The rect can be expanded or contracted by #expand pixels. Call between Begin/EndPlot.
IMPLOT_API void PushPlotClipRect(float expand=0);
// Pop plot clip rect. Call between Begin/EndPlot.
IMPLOT_API void PopPlotClipRect();

// Shows ImPlot style selector dropdown menu.
IMPLOT_API bool ShowStyleSelector(const char* label);
// Shows ImPlot colormap selector dropdown menu.
IMPLOT_API bool ShowColormapSelector(const char* label);
// Shows ImPlot input map selector dropdown menu.
IMPLOT_API bool ShowInputMapSelector(const char* label);
// Shows ImPlot style editor block (not a window).
IMPLOT_API void ShowStyleEditor(ImPlotStyle* ref = nullptr);
// Add basic help/info block for end users (not a window).
IMPLOT_API void ShowUserGuide();
// Shows ImPlot metrics/debug information window.
IMPLOT_API void ShowMetricsWindow(bool* p_popen = nullptr);

//-----------------------------------------------------------------------------
// [SECTION] Demo
//-----------------------------------------------------------------------------

// Shows the ImPlot demo window (add implot_demo.cpp to your sources!)
IMPLOT_API void ShowDemoWindow(bool* p_open = nullptr);

}  // namespace ImPlot

//-----------------------------------------------------------------------------
// [SECTION] Obsolete API
//-----------------------------------------------------------------------------

// The following functions will be removed! Keep your copy of implot up to date!
// Occasionally set '#define IMPLOT_DISABLE_OBSOLETE_FUNCTIONS' to stay ahead.
// If you absolutely must use these functions and do not want to receive compiler
// warnings, set '#define IMPLOT_DISABLE_OBSOLETE_WARNINGS'.

#ifndef IMPLOT_DISABLE_OBSOLETE_FUNCTIONS

#ifndef IMPLOT_DISABLE_DEPRECATED_WARNINGS
#if __cplusplus > 201402L
#define IMPLOT_DEPRECATED(method) [[deprecated]] method
#elif defined( __GNUC__ ) && !defined( __INTEL_COMPILER ) && ( __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 1 ) )
#define IMPLOT_DEPRECATED(method) method __attribute__( ( deprecated ) )
#elif defined( _MSC_VER )
#define IMPLOT_DEPRECATED(method) __declspec(deprecated) method
#else
#define IMPLOT_DEPRECATED(method) method
#endif
#else
#define IMPLOT_DEPRECATED(method) method
#endif

enum ImPlotFlagsObsolete_ {
    ImPlotFlags_YAxis2 = 1 << 20,
    ImPlotFlags_YAxis3 = 1 << 21,
};

namespace ImPlot {

// OBSOLETED in v0.13 -> PLANNED REMOVAL in v1.0
IMPLOT_DEPRECATED( IMPLOT_API bool BeginPlot(const char* title_id,
                                             const char* x_label,  // = nullptr,
                                             const char* y_label,  // = nullptr,
                                             const ImVec2& size       = ImVec2(-1,0),
                                             ImPlotFlags flags        = ImPlotFlags_None,
                                             ImPlotAxisFlags x_flags  = 0,
                                             ImPlotAxisFlags y_flags  = 0,
                                             ImPlotAxisFlags y2_flags = ImPlotAxisFlags_AuxDefault,
                                             ImPlotAxisFlags y3_flags = ImPlotAxisFlags_AuxDefault,
                                             const char* y2_label     = nullptr,
                                             const char* y3_label     = nullptr) );

} // namespace ImPlot

#endif


================================================
FILE: Source/External/imgui_tools/implot/implot_demo.cpp
================================================
// MIT License

// Copyright (c) 2022 Evan Pezent

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// ImPlot v0.14

// We define this so that the demo does not accidentally use deprecated API
#ifndef IMPLOT_DISABLE_OBSOLETE_FUNCTIONS
#define IMPLOT_DISABLE_OBSOLETE_FUNCTIONS
#endif

#include "implot.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#ifdef _MSC_VER
#define sprintf sprintf_s
#endif

#ifndef PI
#define PI 3.14159265358979323846
#endif

#define CHECKBOX_FLAG(flags, flag) ImGui::CheckboxFlags(#flag, (unsigned int*)&flags, flag)

// Encapsulates examples for customizing ImPlot.
namespace MyImPlot {

// Example for Custom Data and Getters section.
struct Vector2f {
    Vector2f(float _x, float _y) { x = _x; y = _y; }
    float x, y;
};

// Example for Custom Data and Getters section.
struct WaveData {
    double X, Amp, Freq, Offset;
    WaveData(double x, double amp, double freq, double offset) { X = x; Amp = amp; Freq = freq; Offset = offset; }
};
ImPlotPoint SineWave(int idx, void* wave_data);
ImPlotPoint SawWave(int idx, void* wave_data);
ImPlotPoint Spiral(int idx, void* wave_data);

// Example for Tables section.
void Sparkline(const char* id, const float* values, int count, float min_v, float max_v, int offset, const ImVec4& col, const ImVec2& size);

// Example for Custom Plotters and Tooltips section.
void PlotCandlestick(const char* label_id, const double* xs, const double* opens, const double* closes, const double* lows, const double* highs, int count, bool tooltip = true, float width_percent = 0.25f, ImVec4 bullCol = ImVec4(0,1,0,1), ImVec4 bearCol = ImVec4(1,0,0,1));

// Example for Custom Styles section.
void StyleSeaborn();

} // namespace MyImPlot

namespace ImPlot {

template <typename T>
inline T RandomRange(T min, T max) {
    T scale = rand() / (T) RAND_MAX;
    return min + scale * ( max - min );
}

ImVec4 RandomColor() {
    ImVec4 col;
    col.x = RandomRange(0.0f,1.0f);
    col.y = RandomRange(0.0f,1.0f);
    col.z = RandomRange(0.0f,1.0f);
    col.w = 1.0f;
    return col;
}

double RandomGauss() {
	static double V1, V2, S;
	static int phase = 0;
	double X;
	if(phase == 0) {
		do {
			double U1 = (double)rand() / RAND_MAX;
			double U2 = (double)rand() / RAND_MAX;
			V1 = 2 * U1 - 1;
			V2 = 2 * U2 - 1;
			S = V1 * V1 + V2 * V2;
			} while(S >= 1 || S == 0);

		X = V1 * sqrt(-2 * log(S) / S);
	} else
		X = V2 * sqrt(-2 * log(S) / S);
	phase = 1 - phase;
	return X;
}

template <int N>
struct NormalDistribution {
    NormalDistribution(double mean, double sd) {
        for (int i = 0; i < N; ++i)
            Data[i] = RandomGauss()*sd + mean;
    }
    double Data[N];
};

// utility structure for realtime plot
struct ScrollingBuffer {
    int MaxSize;
    int Offset;
    ImVector<ImVec2> Data;
    ScrollingBuffer(int max_size = 2000) {
        MaxSize = max_size;
        Offset  = 0;
        Data.reserve(MaxSize);
    }
    void AddPoint(float x, float y) {
        if (Data.size() < MaxSize)
            Data.push_back(ImVec2(x,y));
        else {
            Data[Offset] = ImVec2(x,y);
            Offset =  (Offset + 1) % MaxSize;
        }
    }
    void Erase() {
        if (Data.size() > 0) {
            Data.shrink(0);
            Offset  = 0;
        }
    }
};

// utility structure for realtime plot
struct RollingBuffer {
    float Span;
    ImVector<ImVec2> Data;
    RollingBuffer() {
        Span = 10.0f;
        Data.reserve(2000);
    }
    void AddPoint(float x, float y) {
        float xmod = fmodf(x, Span);
        if (!Data.empty() && xmod < Data.back().x)
            Data.shrink(0);
        Data.push_back(ImVec2(xmod, y));
    }
};

// Huge data used by Time Formatting example (~500 MB allocation!)
struct HugeTimeData {
    HugeTimeData(double min) {
        Ts = new double[Size];
        Ys = new double[Size];
        for (int i = 0; i < Size; ++i) {
            Ts[i] = min + i;
            Ys[i] = GetY(Ts[i]);
        }
    }
    ~HugeTimeData() { delete[] Ts;  delete[] Ys; }
    static double GetY(double t) {
        return 0.5 + 0.25 * sin(t/86400/12) +  0.005 * sin(t/3600);
    }
    double* Ts;
    double* Ys;
    static const int Size = 60*60*24*366;
};

//-----------------------------------------------------------------------------
// [SECTION] Demo Functions
//-----------------------------------------------------------------------------

void Demo_Help() {
    ImGui::Text("ABOUT THIS DEMO:");
    ImGui::BulletText("Sections below are demonstrating many aspects of the library.");
    ImGui::BulletText("The \"Tools\" menu above gives access to: Style Editors (ImPlot/ImGui)\n"
                        "and Metrics (general purpose Dear ImGui debugging tool).");
    ImGui::Separator();
    ImGui::Text("PROGRAMMER GUIDE:");
    ImGui::BulletText("See the ShowDemoWindow() code in implot_demo.cpp. <- you are here!");
    ImGui::BulletText("If you see visual artifacts, do one of the following:");
    ImGui::Indent();
    ImGui::BulletText("Handle ImGuiBackendFlags_RendererHasVtxOffset for 16-bit indices in your backend.");
    ImGui::BulletText("Or, enable 32-bit indices in imconfig.h.");
    ImGui::BulletText("Your current configuration is:");
    ImGui::Indent();
    ImGui::BulletText("ImDrawIdx: %d-bit", (int)(sizeof(ImDrawIdx) * 8));
    ImGui::BulletText("ImGuiBackendFlags_RendererHasVtxOffset: %s", (ImGui::GetIO().BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset) ? "True" : "False");
    ImGui::Unindent();
    ImGui::Unindent();
    ImGui::Separator();
    ImGui::Text("USER GUIDE:");
    ShowUserGuide();
}

//-----------------------------------------------------------------------------

void ButtonSelector(const char* label, ImGuiMouseButton* b) {
    ImGui::PushID(label);
    if (ImGui::RadioButton("LMB",*b == ImGuiMouseButton_Left))
        *b = ImGuiMouseButton_Left;
    ImGui::SameLine();
    if (ImGui::RadioButton("RMB",*b == ImGuiMouseButton_Right))
        *b = ImGuiMouseButton_Right;
    ImGui::SameLine();
    if (ImGui::RadioButton("MMB",*b == ImGuiMouseButton_Middle))
        *b = ImGuiMouseButton_Middle;
    ImGui::PopID();
}

void ModSelector(const char* label, int* k) {
    ImGui::PushID(label);
    ImGui::CheckboxFlags("Ctrl", (unsigned int*)k, ImGuiMod_Ctrl); ImGui::SameLine();
    ImGui::CheckboxFlags("Shift", (unsigned int*)k, ImGuiMod_Shift); ImGui::SameLine();
    ImGui::CheckboxFlags("Alt", (unsigned int*)k, ImGuiMod_Alt); ImGui::SameLine();
    ImGui::CheckboxFlags("Super", (unsigned int*)k, ImGuiMod_Super);
    ImGui::PopID();
}

void InputMapping(const char* label, ImGuiMouseButton* b, int* k) {
    ImGui::LabelText("##","%s",label);
    if (b != nullptr) {
        ImGui::SameLine(100);
        ButtonSelector(label,b);
    }
    if (k != nullptr) {
        ImGui::SameLine(300);
        ModSelector(label,k);
    }
}

void ShowInputMapping() {
    ImPlotInputMap& map = ImPlot::GetInputMap();
    InputMapping("Pan",&map.Pan,&map.PanMod);
    InputMapping("Fit",&map.Fit,nullptr);
    InputMapping("Select",&map.Select,&map.SelectMod);
    InputMapping("SelectHorzMod",nullptr,&map.SelectHorzMod);
    InputMapping("SelectVertMod",nullptr,&map.SelectVertMod);
    InputMapping("SelectCancel",&map.SelectCancel,nullptr);
    InputMapping("Menu",&map.Menu,nullptr);
    InputMapping("OverrideMod",nullptr,&map.OverrideMod);
    InputMapping("ZoomMod",nullptr,&map.ZoomMod);
    ImGui::SliderFloat("ZoomRate",&map.ZoomRate,-1,1);
}

void Demo_Config() {
    ImGui::ShowFontSelector("Font");
    ImGui::ShowStyleSelector("ImGui Style");
    ImPlot::ShowStyleSelector("ImPlot Style");
    ImPlot::ShowColormapSelector("ImPlot Colormap");
    ImPlot::ShowInputMapSelector("Input Map");
    ImGui::Separator();
    ImGui::Checkbox("Use Local Time", &ImPlot::GetStyle().UseLocalTime);
    ImGui::Checkbox("Use ISO 8601", &ImPlot::GetStyle().UseISO8601);
    ImGui::Checkbox("Use 24 Hour Clock", &ImPlot::GetStyle().Use24HourClock);
    ImGui::Separator();
    if (ImPlot::BeginPlot("Preview")) {
        static double now = (double)time(nullptr);
        ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_Time);
        ImPlot::SetupAxisLimits(ImAxis_X1, now, now + 24*3600);
        for (int i = 0; i < 10; ++i) {
            double x[2] = {now, now + 24*3600};
            double y[2] = {0,i/9.0};
            ImGui::PushID(i);
            ImPlot::PlotLine("##Line",x,y,2);
            ImGui::PopID();
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_LinePlots() {
    static float xs1[1001], ys1[1001];
    for (int i = 0; i < 1001; ++i) {
        xs1[i] = i * 0.001f;
        ys1[i] = 0.5f + 0.5f * sinf(50 * (xs1[i] + (float)ImGui::GetTime() / 10));
    }
    static double xs2[20], ys2[20];
    for (int i = 0; i < 20; ++i) {
        xs2[i] = i * 1/19.0f;
        ys2[i] = xs2[i] * xs2[i];
    }
    if (ImPlot::BeginPlot("Line Plots")) {
        ImPlot::SetupAxes("x","y");
        ImPlot::PlotLine("f(x)", xs1, ys1, 1001);
        ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
        ImPlot::PlotLine("g(x)", xs2, ys2, 20,ImPlotLineFlags_Segments);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_FilledLinePlots() {
    static double xs1[101], ys1[101], ys2[101], ys3[101];
    srand(0);
    for (int i = 0; i < 101; ++i) {
        xs1[i] = (float)i;
        ys1[i] = RandomRange(400.0,450.0);
        ys2[i] = RandomRange(275.0,350.0);
        ys3[i] = RandomRange(150.0,225.0);
    }
    static bool show_lines = true;
    static bool show_fills = true;
    static float fill_ref = 0;
    static int shade_mode = 0;
    static ImPlotShadedFlags flags = 0;
    ImGui::Checkbox("Lines",&show_lines); ImGui::SameLine();
    ImGui::Checkbox("Fills",&show_fills);
    if (show_fills) {
        ImGui::SameLine();
        if (ImGui::RadioButton("To -INF",shade_mode == 0))
            shade_mode = 0;
        ImGui::SameLine();
        if (ImGui::RadioButton("To +INF",shade_mode == 1))
            shade_mode = 1;
        ImGui::SameLine();
        if (ImGui::RadioButton("To Ref",shade_mode == 2))
            shade_mode = 2;
        if (shade_mode == 2) {
            ImGui::SameLine();
            ImGui::SetNextItemWidth(100);
            ImGui::DragFloat("##Ref",&fill_ref, 1, -100, 500);
        }
    }

    if (ImPlot::BeginPlot("Stock Prices")) {
        ImPlot::SetupAxes("Days","Price");
        ImPlot::SetupAxesLimits(0,100,0,500);
        if (show_fills) {
            ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, 0.25f);
            ImPlot::PlotShaded("Stock 1", xs1, ys1, 101, shade_mode == 0 ? -INFINITY : shade_mode == 1 ? INFINITY : fill_ref, flags);
            ImPlot::PlotShaded("Stock 2", xs1, ys2, 101, shade_mode == 0 ? -INFINITY : shade_mode == 1 ? INFINITY : fill_ref, flags);
            ImPlot::PlotShaded("Stock 3", xs1, ys3, 101, shade_mode == 0 ? -INFINITY : shade_mode == 1 ? INFINITY : fill_ref, flags);
            ImPlot::PopStyleVar();
        }
        if (show_lines) {
            ImPlot::PlotLine("Stock 1", xs1, ys1, 101);
            ImPlot::PlotLine("Stock 2", xs1, ys2, 101);
            ImPlot::PlotLine("Stock 3", xs1, ys3, 101);
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_ShadedPlots() {
    static float xs[1001], ys[1001], ys1[1001], ys2[1001], ys3[1001], ys4[1001];
    srand(0);
    for (int i = 0; i < 1001; ++i) {
        xs[i]  = i * 0.001f;
        ys[i]  = 0.25f + 0.25f * sinf(25 * xs[i]) * sinf(5 * xs[i]) + RandomRange(-0.01f, 0.01f);
        ys1[i] = ys[i] + RandomRange(0.1f, 0.12f);
        ys2[i] = ys[i] - RandomRange(0.1f, 0.12f);
        ys3[i] = 0.75f + 0.2f * sinf(25 * xs[i]);
        ys4[i] = 0.75f + 0.1f * cosf(25 * xs[i]);
    }
    static float alpha = 0.25f;
    ImGui::DragFloat("Alpha",&alpha,0.01f,0,1);

    if (ImPlot::BeginPlot("Shaded Plots")) {
        ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, alpha);
        ImPlot::PlotShaded("Uncertain Data",xs,ys1,ys2,1001);
        ImPlot::PlotLine("Uncertain Data", xs, ys, 1001);
        ImPlot::PlotShaded("Overlapping",xs,ys3,ys4,1001);
        ImPlot::PlotLine("Overlapping",xs,ys3,1001);
        ImPlot::PlotLine("Overlapping",xs,ys4,1001);
        ImPlot::PopStyleVar();
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_ScatterPlots() {
    srand(0);
    static float xs1[100], ys1[100];
    for (int i = 0; i < 100; ++i) {
        xs1[i] = i * 0.01f;
        ys1[i] = xs1[i] + 0.1f * ((float)rand() / (float)RAND_MAX);
    }
    static float xs2[50], ys2[50];
    for (int i = 0; i < 50; i++) {
        xs2[i] = 0.25f + 0.2f * ((float)rand() / (float)RAND_MAX);
        ys2[i] = 0.75f + 0.2f * ((float)rand() / (float)RAND_MAX);
    }

    if (ImPlot::BeginPlot("Scatter Plot")) {
        ImPlot::PlotScatter("Data 1", xs1, ys1, 100);
        ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, 0.25f);
        ImPlot::SetNextMarkerStyle(ImPlotMarker_Square, 6, ImPlot::GetColormapColor(1), IMPLOT_AUTO, ImPlot::GetColormapColor(1));
        ImPlot::PlotScatter("Data 2", xs2, ys2, 50);
        ImPlot::PopStyleVar();
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_StairstepPlots() {
    static float ys1[21], ys2[21];
    for (int i = 0; i < 21; ++i) {
        ys1[i] = 0.75f + 0.2f * sinf(10 * i * 0.05f);
        ys2[i] = 0.25f + 0.2f * sinf(10 * i * 0.05f);
    }
    static ImPlotStairsFlags flags = 0;
    CHECKBOX_FLAG(flags, ImPlotStairsFlags_Shaded);
    if (ImPlot::BeginPlot("Stairstep Plot")) {
        ImPlot::SetupAxes("x","f(x)");
        ImPlot::SetupAxesLimits(0,1,0,1);

        ImPlot::PushStyleColor(ImPlotCol_Line, ImVec4(0.5f,0.5f,0.5f,1.0f));
        ImPlot::PlotLine("##1",ys1,21,0.05f);
        ImPlot::PlotLine("##2",ys2,21,0.05f);
        ImPlot::PopStyleColor();

        ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
        ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL, 0.25f);
        ImPlot::PlotStairs("Post Step (default)", ys1, 21, 0.05f, 0, flags);
        ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
        ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL, 0.25f);
        ImPlot::PlotStairs("Pre Step", ys2, 21, 0.05f, 0, flags|ImPlotStairsFlags_PreStep);

        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_BarPlots() {
    static ImS8  data[10] = {1,2,3,4,5,6,7,8,9,10};
    if (ImPlot::BeginPlot("Bar Plot")) {
        ImPlot::PlotBars("Vertical",data,10,0.7,1);
        ImPlot::PlotBars("Horizontal",data,10,0.4,1,ImPlotBarsFlags_Horizontal);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_BarGroups() {
    static ImS8  data[30] = {83, 67, 23, 89, 83, 78, 91, 82, 85, 90,  // midterm
                             80, 62, 56, 99, 55, 78, 88, 78, 90, 100, // final
                             80, 69, 52, 92, 72, 78, 75, 76, 89, 95}; // course

    static const char*  ilabels[]   = {"Midterm Exam","Final Exam","Course Grade"};
    static const char*  glabels[]   = {"S1","S2","S3","S4","S5","S6","S7","S8","S9","S10"};
    static const double positions[] = {0,1,2,3,4,5,6,7,8,9};

    static int items  = 3;
    static int groups = 10;
    static float size = 0.67f;

    static ImPlotBarGroupsFlags flags = 0;
    static bool horz = false;

    ImGui::CheckboxFlags("Stacked", (unsigned int*)&flags, ImPlotBarGroupsFlags_Stacked);
    ImGui::SameLine();
    ImGui::Checkbox("Horizontal",&horz);

    ImGui::SliderInt("Items",&items,1,3);
    ImGui::SliderFloat("Size",&size,0,1);

    if (ImPlot::BeginPlot("Bar Group")) {
        ImPlot::SetupLegend(ImPlotLocation_East, ImPlotLegendFlags_Outside);
        if (horz) {
            ImPlot::SetupAxes("Score","Student",ImPlotAxisFlags_AutoFit,ImPlotAxisFlags_AutoFit);
            ImPlot::SetupAxisTicks(ImAxis_Y1,positions, groups, glabels);
            ImPlot::PlotBarGroups(ilabels,data,items,groups,size,0,flags|ImPlotBarGroupsFlags_Horizontal);
        }
        else {
            ImPlot::SetupAxes("Student","Score",ImPlotAxisFlags_AutoFit,ImPlotAxisFlags_AutoFit);
            ImPlot::SetupAxisTicks(ImAxis_X1,positions, groups, glabels);
            ImPlot::PlotBarGroups(ilabels,data,items,groups,size,0,flags);
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_BarStacks() {

    static ImPlotColormap Liars = -1;
    if (Liars == -1) {
        static const ImU32 Liars_Data[6] = { 4282515870, 4282609140, 4287357182, 4294630301, 4294945280, 4294921472 };
        Liars = ImPlot::AddColormap("Liars", Liars_Data, 6);
    }

    static bool diverging = true;
    ImGui::Checkbox("Diverging",&diverging);

    static const char* politicians[] = {"Trump","Bachman","Cruz","Gingrich","Palin","Santorum","Walker","Perry","Ryan","McCain","Rubio","Romney","Rand Paul","Christie","Biden","Kasich","Sanders","J Bush","H Clinton","Obama"};
    static int data_reg[] = {18,26,7,14,10,8,6,11,4,4,3,8,6,8,6,5,0,3,1,2,                // Pants on Fire
                             43,36,30,21,30,27,25,17,11,22,15,16,16,17,12,12,14,6,13,12,  // False
                             16,13,28,22,15,21,15,18,30,17,24,18,13,10,14,15,17,22,14,12, // Mostly False
                             17,10,13,25,12,22,19,26,23,17,22,27,20,26,29,17,18,22,21,27, // Half True
                             5,7,16,10,10,12,23,13,17,20,22,16,23,19,20,26,36,29,27,26,   // Mostly True
                             1,8,6,8,23,10,12,15,15,20,14,15,22,20,19,25,15,18,24,21};    // True
    static const char* labels_reg[] = {"Pants on Fire","False","Mostly False","Half True","Mostly True","True"};


    static int data_div[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,                                         // Pants on Fire (dummy, to order legend logically)
                             0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,                                         // False         (dummy, to order legend logically)
                             0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,                                         // Mostly False  (dummy, to order legend logically)
                             -16,-13,-28,-22,-15,-21,-15,-18,-30,-17,-24,-18,-13,-10,-14,-15,-17,-22,-14,-12, // Mostly False
                             -43,-36,-30,-21,-30,-27,-25,-17,-11,-22,-15,-16,-16,-17,-12,-12,-14,-6,-13,-12,  // False
                             -18,-26,-7,-14,-10,-8,-6,-11,-4,-4,-3,-8,-6,-8,-6,-5,0,-3,-1,-2,                 // Pants on Fire
                             17,10,13,25,12,22,19,26,23,17,22,27,20,26,29,17,18,22,21,27,                     // Half True
                             5,7,16,10,10,12,23,13,17,20,22,16,23,19,20,26,36,29,27,26,                       // Mostly True
                             1,8,6,8,23,10,12,15,15,20,14,15,22,20,19,25,15,18,24,21};                        // True
    static const char* labels_div[] = {"Pants on Fire","False","Mostly False","Mostly False","False","Pants on Fire","Half True","Mostly True","True"};

    ImPlot::PushColormap(Liars);
    if (ImPlot::BeginPlot("PolitiFact: Who Lies More?",ImVec2(-1,400),ImPlotFlags_NoMouseText)) {
        ImPlot::SetupLegend(ImPlotLocation_South, ImPlotLegendFlags_Outside|ImPlotLegendFlags_Horizontal);
        ImPlot::SetupAxes(nullptr,nullptr,ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_Invert);
        ImPlot::SetupAxisTicks(ImAxis_Y1,0,19,20,politicians,false);
        if (diverging)
            ImPlot::PlotBarGroups(labels_div,data_div,9,20,0.75,0,ImPlotBarGroupsFlags_Stacked|ImPlotBarGroupsFlags_Horizontal);
        else
            ImPlot::PlotBarGroups(labels_reg,data_reg,6,20,0.75,0,ImPlotBarGroupsFlags_Stacked|ImPlotBarGroupsFlags_Horizontal);
        ImPlot::EndPlot();
    }
    ImPlot::PopColormap();
}

//-----------------------------------------------------------------------------

void Demo_ErrorBars() {
    static float xs[5]    = {1,2,3,4,5};
    static float bar[5]   = {1,2,5,3,4};
    static float lin1[5]  = {8,8,9,7,8};
    static float lin2[5]  = {6,7,6,9,6};
    static float err1[5]  = {0.2f, 0.4f, 0.2f, 0.6f, 0.4f};
    static float err2[5]  = {0.4f, 0.2f, 0.4f, 0.8f, 0.6f};
    static float err3[5]  = {0.09f, 0.14f, 0.09f, 0.12f, 0.16f};
    static float err4[5]  = {0.02f, 0.08f, 0.15f, 0.05f, 0.2f};


    if (ImPlot::BeginPlot("##ErrorBars")) {
        ImPlot::SetupAxesLimits(0, 6, 0, 10);
        ImPlot::PlotBars("Bar", xs, bar, 5, 0.5f);
        ImPlot::PlotErrorBars("Bar", xs, bar, err1, 5);
        ImPlot::SetNextErrorBarStyle(ImPlot::GetColormapColor(1), 0);
        ImPlot::PlotErrorBars("Line", xs, lin1, err1, err2, 5);
        ImPlot::SetNextMarkerStyle(ImPlotMarker_Square);
        ImPlot::PlotLine("Line", xs, lin1, 5);
        ImPlot::PushStyleColor(ImPlotCol_ErrorBar, ImPlot::GetColormapColor(2));
        ImPlot::PlotErrorBars("Scatter", xs, lin2, err2, 5);
        ImPlot::PlotErrorBars("Scatter", xs, lin2,  err3, err4, 5, ImPlotErrorBarsFlags_Horizontal);
        ImPlot::PopStyleColor();
        ImPlot::PlotScatter("Scatter", xs, lin2, 5);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_StemPlots() {
    static double xs[51], ys1[51], ys2[51];
    for (int i = 0; i < 51; ++i) {
        xs[i] = i * 0.02;
        ys1[i] = 1.0 + 0.5 * sin(25*xs[i])*cos(2*xs[i]);
        ys2[i] = 0.5 + 0.25  * sin(10*xs[i]) * sin(xs[i]);
    }
    if (ImPlot::BeginPlot("Stem Plots")) {
        ImPlot::SetupAxisLimits(ImAxis_X1,0,1.0);
        ImPlot::SetupAxisLimits(ImAxis_Y1,0,1.6);
        ImPlot::PlotStems("Stems 1",xs,ys1,51);
        ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
        ImPlot::PlotStems("Stems 2", xs, ys2,51);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_InfiniteLines() {
    static double vals[] = {0.25, 0.5, 0.75};
    if (ImPlot::BeginPlot("##Infinite")) {
        ImPlot::SetupAxes(nullptr,nullptr,ImPlotAxisFlags_NoInitialFit,ImPlotAxisFlags_NoInitialFit);
        ImPlot::PlotInfLines("Vertical",vals,3);
        ImPlot::PlotInfLines("Horizontal",vals,3,ImPlotInfLinesFlags_Horizontal);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_PieCharts() {
    static const char* labels1[]    = {"Frogs","Hogs","Dogs","Logs"};
    static float data1[]            = {0.15f,  0.30f,  0.2f, 0.05f};
    static ImPlotPieChartFlags flags = 0;
    ImGui::SetNextItemWidth(250);
    ImGui::DragFloat4("Values", data1, 0.01f, 0, 1);
    if ((data1[0] + data1[1] + data1[2] + data1[3]) < 1) {
        ImGui::SameLine();
        CHECKBOX_FLAG(flags,ImPlotPieChartFlags_Normalize);
    }

    if (ImPlot::BeginPlot("##Pie1", ImVec2(250,250), ImPlotFlags_Equal | ImPlotFlags_NoMouseText)) {
        ImPlot::SetupAxes(nullptr, nullptr, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations);
        ImPlot::SetupAxesLimits(0, 1, 0, 1);
        ImPlot::PlotPieChart(labels1, data1, 4, 0.5, 0.5, 0.4, "%.2f", 90, flags);
        ImPlot::EndPlot();
    }

    ImGui::SameLine();

    static const char* labels2[]   = {"A","B","C","D","E"};
    static int data2[]             = {1,1,2,3,5};

    ImPlot::PushColormap(ImPlotColormap_Pastel);
    if (ImPlot::BeginPlot("##Pie2", ImVec2(250,250), ImPlotFlags_Equal | ImPlotFlags_NoMouseText)) {
        ImPlot::SetupAxes(nullptr, nullptr, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations);
        ImPlot::SetupAxesLimits(0, 1, 0, 1);
        ImPlot::PlotPieChart(labels2, data2, 5, 0.5, 0.5, 0.4, "%.0f", 180, flags);
        ImPlot::EndPlot();
    }
    ImPlot::PopColormap();
}

//-----------------------------------------------------------------------------

void Demo_Heatmaps() {
    static float values1[7][7]  = {{0.8f, 2.4f, 2.5f, 3.9f, 0.0f, 4.0f, 0.0f},
                                    {2.4f, 0.0f, 4.0f, 1.0f, 2.7f, 0.0f, 0.0f},
                                    {1.1f, 2.4f, 0.8f, 4.3f, 1.9f, 4.4f, 0.0f},
                                    {0.6f, 0.0f, 0.3f, 0.0f, 3.1f, 0.0f, 0.0f},
                                    {0.7f, 1.7f, 0.6f, 2.6f, 2.2f, 6.2f, 0.0f},
                                    {1.3f, 1.2f, 0.0f, 0.0f, 0.0f, 3.2f, 5.1f},
                                    {0.1f, 2.0f, 0.0f, 1.4f, 0.0f, 1.9f, 6.3f}};
    static float scale_min       = 0;
    static float scale_max       = 6.3f;
    static const char* xlabels[] = {"C1","C2","C3","C4","C5","C6","C7"};
    static const char* ylabels[] = {"R1","R2","R3","R4","R5","R6","R7"};

    static ImPlotColormap map = ImPlotColormap_Viridis;
    if (ImPlot::ColormapButton(ImPlot::GetColormapName(map),ImVec2(225,0),map)) {
        map = (map + 1) % ImPlot::GetColormapCount();
        // We bust the color cache of our plots so that item colors will
        // resample the new colormap in the event that they have already
        // been created. See documentation in implot.h.
        BustColorCache("##Heatmap1");
        BustColorCache("##Heatmap2");
    }

    ImGui::SameLine();
    ImGui::LabelText("##Colormap Index", "%s", "Change Colormap");
    ImGui::SetNextItemWidth(225);
    ImGui::DragFloatRange2("Min / Max",&scale_min, &scale_max, 0.01f, -20, 20);

    static ImPlotHeatmapFlags hm_flags = 0;

    ImGui::CheckboxFlags("Column Major", (unsigned int*)&hm_flags, ImPlotHeatmapFlags_ColMajor);

    static ImPlotAxisFlags axes_flags = ImPlotAxisFlags_Lock | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks;

    ImPlot::PushColormap(map);

    if (ImPlot::BeginPlot("##Heatmap1",ImVec2(225,225),ImPlotFlags_NoLegend|ImPlotFlags_NoMouseText)) {
        ImPlot::SetupAxes(nullptr, nullptr, axes_flags, axes_flags);
        ImPlot::SetupAxisTicks(ImAxis_X1,0 + 1.0/14.0, 1 - 1.0/14.0, 7, xlabels);
        ImPlot::SetupAxisTicks(ImAxis_Y1,1 - 1.0/14.0, 0 + 1.0/14.0, 7, ylabels);
        ImPlot::PlotHeatmap("heat",values1[0],7,7,scale_min,scale_max,"%g",ImPlotPoint(0,0),ImPlotPoint(1,1),hm_flags);
        ImPlot::EndPlot();
    }
    ImGui::SameLine();
    ImPlot::ColormapScale("##HeatScale",scale_min, scale_max, ImVec2(60,225));

    ImGui::SameLine();

    const int size = 80;
    static double values2[size*size];
    srand((unsigned int)(ImGui::GetTime()*1000000));
    for (int i = 0; i < size*size; ++i)
        values2[i] = RandomRange(0.0,1.0);

    if (ImPlot::BeginPlot("##Heatmap2",ImVec2(225,225))) {
        ImPlot::SetupAxes(nullptr, nullptr, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations);
        ImPlot::SetupAxesLimits(-1,1,-1,1);
        ImPlot::PlotHeatmap("heat1",values2,size,size,0,1,nullptr);
        ImPlot::PlotHeatmap("heat2",values2,size,size,0,1,nullptr, ImPlotPoint(-1,-1), ImPlotPoint(0,0));
        ImPlot::EndPlot();
    }
    ImPlot::PopColormap();

}

//-----------------------------------------------------------------------------

void Demo_Histogram() {
    static ImPlotHistogramFlags hist_flags = ImPlotHistogramFlags_Density;
    static int  bins       = 50;
    static double mu       = 5;
    static double sigma    = 2;
    ImGui::SetNextItemWidth(200);
    if (ImGui::RadioButton("Sqrt",bins==ImPlotBin_Sqrt))       { bins = ImPlotBin_Sqrt;    } ImGui::SameLine();
    if (ImGui::RadioButton("Sturges",bins==ImPlotBin_Sturges)) { bins = ImPlotBin_Sturges; } ImGui::SameLine();
    if (ImGui::RadioButton("Rice",bins==ImPlotBin_Rice))       { bins = ImPlotBin_Rice;    } ImGui::SameLine();
    if (ImGui::RadioButton("Scott",bins==ImPlotBin_Scott))     { bins = ImPlotBin_Scott;   } ImGui::SameLine();
    if (ImGui::RadioButton("N Bins",bins>=0))                  { bins = 50;                }
    if (bins>=0) {
        ImGui::SameLine();
        ImGui::SetNextItemWidth(200);
        ImGui::SliderInt("##Bins", &bins, 1, 100);
    }
    ImGui::CheckboxFlags("Horizontal", (unsigned int*)&hist_flags, ImPlotHistogramFlags_Horizontal);
    ImGui::SameLine();
    ImGui::CheckboxFlags("Density", (unsigned int*)&hist_flags, ImPlotHistogramFlags_Density);
    ImGui::SameLine();
    ImGui::CheckboxFlags("Cumulative", (unsigned int*)&hist_flags, ImPlotHistogramFlags_Cumulative);

    static bool range = false;
    ImGui::Checkbox("Range", &range);
    static float rmin = -3;
    static float rmax = 13;
    if (range) {
        ImGui::SameLine();
        ImGui::SetNextItemWidth(200);
        ImGui::DragFloat2("##Range",&rmin,0.1f,-3,13);
        ImGui::SameLine();
        ImGui::CheckboxFlags("Exclude Outliers", (unsigned int*)&hist_flags, ImPlotHistogramFlags_NoOutliers);
    }
    static NormalDistribution<10000> dist(mu, sigma);
    static double x[100];
    static double y[100];
    if (hist_flags & ImPlotHistogramFlags_Density) {
        for (int i = 0; i < 100; ++i) {
            x[i] = -3 + 16 * (double)i/99.0;
            y[i] = exp( - (x[i]-mu)*(x[i]-mu) / (2*sigma*sigma)) / (sigma * sqrt(2*3.141592653589793238));
        }
        if (hist_flags & ImPlotHistogramFlags_Cumulative) {
            for (int i = 1; i < 100; ++i)
                y[i] += y[i-1];
            for (int i = 0; i < 100; ++i)
                y[i] /= y[99];
        }
    }

    if (ImPlot::BeginPlot("##Histograms")) {
        ImPlot::SetupAxes(nullptr,nullptr,ImPlotAxisFlags_AutoFit,ImPlotAxisFlags_AutoFit);
        ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL,0.5f);
        ImPlot::PlotHistogram("Empirical", dist.Data, 10000, bins, 1.0, range ? ImPlotRange(rmin,rmax) : ImPlotRange(), hist_flags);
        if ((hist_flags & ImPlotHistogramFlags_Density) && !(hist_flags & ImPlotHistogramFlags_NoOutliers)) {
            if (hist_flags & ImPlotHistogramFlags_Horizontal)
                ImPlot::PlotLine("Theoretical",y,x,100);
            else
                ImPlot::PlotLine("Theoretical",x,y,100);
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_Histogram2D() {
    static int count     = 50000;
    static int xybins[2] = {100,100};

    static ImPlotHistogramFlags hist_flags = 0;

    ImGui::SliderInt("Count",&count,100,100000);
    ImGui::SliderInt2("Bins",xybins,1,500);
    ImGui::SameLine();
    ImGui::CheckboxFlags("Density", (unsigned int*)&hist_flags, ImPlotHistogramFlags_Density);

    static NormalDistribution<100000> dist1(1, 2);
    static NormalDistribution<100000> dist2(1, 1);
    double max_count = 0;
    ImPlotAxisFlags flags = ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_Foreground;
    ImPlot::PushColormap("Hot");
    if (ImPlot::BeginPlot("##Hist2D",ImVec2(ImGui::GetContentRegionAvail().x-100-ImGui::GetStyle().ItemSpacing.x,0))) {
        ImPlot::SetupAxes(nullptr, nullptr, flags, flags);
        ImPlot::SetupAxesLimits(-6,6,-6,6);
        max_count = ImPlot::PlotHistogram2D("Hist2D",dist1.Data,dist2.Data,count,xybins[0],xybins[1],ImPlotRect(-6,6,-6,6), hist_flags);
        ImPlot::EndPlot();
    }
    ImGui::SameLine();
    ImPlot::ColormapScale(hist_flags & ImPlotHistogramFlags_Density ? "Density" : "Count",0,max_count,ImVec2(100,0));
    ImPlot::PopColormap();
}

//-----------------------------------------------------------------------------

void Demo_DigitalPlots() {
    ImGui::BulletText("Digital plots do not respond to Y drag and zoom, so that");
    ImGui::Indent();
    ImGui::Text("you can drag analog plots over the rising/falling digital edge.");
    ImGui::Unindent();

    static bool paused = false;
    static ScrollingBuffer dataDigital[2];
    static ScrollingBuffer dataAnalog[2];
    static bool showDigital[2] = {true, false};
    static bool showAnalog[2] = {true, false};

    char label[32];
    ImGui::Checkbox("digital_0", &showDigital[0]); ImGui::SameLine();
    ImGui::Checkbox("digital_1", &showDigital[1]); ImGui::SameLine();
    ImGui::Checkbox("analog_0",  &showAnalog[0]);  ImGui::SameLine();
    ImGui::Checkbox("analog_1",  &showAnalog[1]);

    static float t = 0;
    if (!paused) {
        t += ImGui::GetIO().DeltaTime;
        //digital signal values
        if (showDigital[0])
            dataDigital[0].AddPoint(t, sinf(2*t) > 0.45);
        if (showDigital[1])
            dataDigital[1].AddPoint(t, sinf(2*t) < 0.45);
        //Analog signal values
        if (showAnalog[0])
            dataAnalog[0].AddPoint(t, sinf(2*t));
        if (showAnalog[1])
            dataAnalog[1].AddPoint(t, cosf(2*t));
    }
    if (ImPlot::BeginPlot("##Digital")) {
        ImPlot::SetupAxisLimits(ImAxis_X1, t - 10.0, t, paused ? ImGuiCond_Once : ImGuiCond_Always);
        ImPlot::SetupAxisLimits(ImAxis_Y1, -1, 1);
        for (int i = 0; i < 2; ++i) {
            if (showDigital[i] && dataDigital[i].Data.size() > 0) {
                snprintf(label, sizeof(label), "digital_%d", i);
                ImPlot::PlotDigital(label, &dataDigital[i].Data[0].x, &dataDigital[i].Data[0].y, dataDigital[i].Data.size(), 0, dataDigital[i].Offset, 2 * sizeof(float));
            }
        }
        for (int i = 0; i < 2; ++i) {
            if (showAnalog[i]) {
                snprintf(label, sizeof(label), "analog_%d", i);
                if (dataAnalog[i].Data.size() > 0)
                    ImPlot::PlotLine(label, &dataAnalog[i].Data[0].x, &dataAnalog[i].Data[0].y, dataAnalog[i].Data.size(), 0, dataAnalog[i].Offset, 2 * sizeof(float));
            }
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_Images() {
    ImGui::BulletText("Below we are displaying the font texture, which is the only texture we have\naccess to in this demo.");
    ImGui::BulletText("Use the 'ImTextureID' type as storage to pass pointers or identifiers to your\nown texture data.");
    ImGui::BulletText("See ImGui Wiki page 'Image Loading and Displaying Examples'.");
    static ImVec2 bmin(0,0);
    static ImVec2 bmax(1,1);
    static ImVec2 uv0(0,0);
    static ImVec2 uv1(1,1);
    static ImVec4 tint(1,1,1,1);
    ImGui::SliderFloat2("Min", &bmin.x, -2, 2, "%.1f");
    ImGui::SliderFloat2("Max", &bmax.x, -2, 2, "%.1f");
    ImGui::SliderFloat2("UV0", &uv0.x, -2, 2, "%.1f");
    ImGui::SliderFloat2("UV1", &uv1.x, -2, 2, "%.1f");
    ImGui::ColorEdit4("Tint",&tint.x);
    if (ImPlot::BeginPlot("##image")) {
        ImPlot::PlotImage("my image",ImGui::GetIO().Fonts->TexID, bmin, bmax, uv0, uv1, tint);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_RealtimePlots() {
    ImGui::BulletText("Move your mouse to change the data!");
    ImGui::BulletText("This example assumes 60 FPS. Higher FPS requires larger buffer size.");
    static ScrollingBuffer sdata1, sdata2;
    static RollingBuffer   rdata1, rdata2;
    ImVec2 mouse = ImGui::GetMousePos();
    static float t = 0;
    t += ImGui::GetIO().DeltaTime;
    sdata1.AddPoint(t, mouse.x * 0.0005f);
    rdata1.AddPoint(t, mouse.x * 0.0005f);
    sdata2.AddPoint(t, mouse.y * 0.0005f);
    rdata2.AddPoint(t, mouse.y * 0.0005f);

    static float history = 10.0f;
    ImGui::SliderFloat("History",&history,1,30,"%.1f s");
    rdata1.Span = history;
    rdata2.Span = history;

    static ImPlotAxisFlags flags = ImPlotAxisFlags_NoTickLabels;

    if (ImPlot::BeginPlot("##Scrolling", ImVec2(-1,150))) {
        ImPlot::SetupAxes(nullptr, nullptr, flags, flags);
        ImPlot::SetupAxisLimits(ImAxis_X1,t - history, t, ImGuiCond_Always);
        ImPlot::SetupAxisLimits(ImAxis_Y1,0,1);
        ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL,0.5f);
        ImPlot::PlotShaded("Mouse X", &sdata1.Data[0].x, &sdata1.Data[0].y, sdata1.Data.size(), -INFINITY, 0, sdata1.Offset, 2 * sizeof(float));
        ImPlot::PlotLine("Mouse Y", &sdata2.Data[0].x, &sdata2.Data[0].y, sdata2.Data.size(), 0, sdata2.Offset, 2*sizeof(float));
        ImPlot::EndPlot();
    }
    if (ImPlot::BeginPlot("##Rolling", ImVec2(-1,150))) {
        ImPlot::SetupAxes(nullptr, nullptr, flags, flags);
        ImPlot::SetupAxisLimits(ImAxis_X1,0,history, ImGuiCond_Always);
        ImPlot::SetupAxisLimits(ImAxis_Y1,0,1);
        ImPlot::PlotLine("Mouse X", &rdata1.Data[0].x, &rdata1.Data[0].y, rdata1.Data.size(), 0, 0, 2 * sizeof(float));
        ImPlot::PlotLine("Mouse Y", &rdata2.Data[0].x, &rdata2.Data[0].y, rdata2.Data.size(), 0, 0, 2 * sizeof(float));
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_MarkersAndText() {
    static float mk_size = ImPlot::GetStyle().MarkerSize;
    static float mk_weight = ImPlot::GetStyle().MarkerWeight;
    ImGui::DragFloat("Marker Size",&mk_size,0.1f,2.0f,10.0f,"%.2f px");
    ImGui::DragFloat("Marker Weight", &mk_weight,0.05f,0.5f,3.0f,"%.2f px");

    if (ImPlot::BeginPlot("##MarkerStyles", ImVec2(-1,0), ImPlotFlags_CanvasOnly)) {

        ImPlot::SetupAxes(nullptr, nullptr, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations);
        ImPlot::SetupAxesLimits(0, 10, 0, 12);

        ImS8 xs[2] = {1,4};
        ImS8 ys[2] = {10,11};

        // filled markers
        for (int m = 0; m < ImPlotMarker_COUNT; ++m) {
            ImGui::PushID(m);
            ImPlot::SetNextMarkerStyle(m, mk_size, IMPLOT_AUTO_COL, mk_weight);
            ImPlot::PlotLine("##Filled", xs, ys, 2);
            ImGui::PopID();
            ys[0]--; ys[1]--;
        }
        xs[0] = 6; xs[1] = 9; ys[0] = 10; ys[1] = 11;
        // open markers
        for (int m = 0; m < ImPlotMarker_COUNT; ++m) {
            ImGui::PushID(m);
            ImPlot::SetNextMarkerStyle(m, mk_size, ImVec4(0,0,0,0), mk_weight);
            ImPlot::PlotLine("##Open", xs, ys, 2);
            ImGui::PopID();
            ys[0]--; ys[1]--;
        }

        ImPlot::PlotText("Filled Markers", 2.5f, 6.0f);
        ImPlot::PlotText("Open Markers",   7.5f, 6.0f);

        ImPlot::PushStyleColor(ImPlotCol_InlayText, ImVec4(1,0,1,1));
        ImPlot::PlotText("Vertical Text", 5.0f, 6.0f, ImVec2(0,0), ImPlotTextFlags_Vertical);
        ImPlot::PopStyleColor();

        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_NaNValues() {

    static bool include_nan = true;
    static ImPlotLineFlags flags = 0;

    float data1[5] = {0.0f,0.25f,0.5f,0.75f,1.0f};
    float data2[5] = {0.0f,0.25f,0.5f,0.75f,1.0f};

    if (include_nan)
        data1[2] = NAN;

    ImGui::Checkbox("Include NaN",&include_nan);
    ImGui::SameLine();
    ImGui::CheckboxFlags("Skip NaN", (unsigned int*)&flags, ImPlotLineFlags_SkipNaN);

    if (ImPlot::BeginPlot("##NaNValues")) {
        ImPlot::SetNextMarkerStyle(ImPlotMarker_Square);
        ImPlot::PlotLine("line", data1, data2, 5, flags);
        ImPlot::PlotBars("bars", data1, 5);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_LogScale() {
    static double xs[1001], ys1[1001], ys2[1001], ys3[1001];
    for (int i = 0; i < 1001; ++i) {
        xs[i]  = i*0.1f;
        ys1[i] = sin(xs[i]) + 1;
        ys2[i] = log(xs[i]);
        ys3[i] = pow(10.0, xs[i]);
    }
    if (ImPlot::BeginPlot("Log Plot", ImVec2(-1,0))) {
        ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_Log10);
        ImPlot::SetupAxesLimits(0.1, 100, 0, 10);
        ImPlot::PlotLine("f(x) = x",        xs, xs,  1001);
        ImPlot::PlotLine("f(x) = sin(x)+1", xs, ys1, 1001);
        ImPlot::PlotLine("f(x) = log(x)",   xs, ys2, 1001);
        ImPlot::PlotLine("f(x) = 10^x",     xs, ys3, 21);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_SymmetricLogScale() {
    static double xs[1001], ys1[1001], ys2[1001];
    for (int i = 0; i < 1001; ++i) {
        xs[i]  = i*0.1f-50;
        ys1[i] = sin(xs[i]);
        ys2[i] = i*0.002 - 1;
    }
    if (ImPlot::BeginPlot("SymLog Plot", ImVec2(-1,0))) {
        ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_SymLog);
        ImPlot::PlotLine("f(x) = a*x+b",xs,ys2,1001);
        ImPlot::PlotLine("f(x) = sin(x)",xs,ys1,1001);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_TimeScale() {

    static double t_min = 1609459200; // 01/01/2021 @ 12:00:00am (UTC)
    static double t_max = 1640995200; // 01/01/2022 @ 12:00:00am (UTC)

    ImGui::BulletText("When ImPlotAxisFlags_Time is enabled on the X-Axis, values are interpreted as\n"
                        "UNIX timestamps in seconds and axis labels are formated as date/time.");
    ImGui::BulletText("By default, labels are in UTC time but can be set to use local time instead.");

    ImGui::Checkbox("Local Time",&ImPlot::GetStyle().UseLocalTime);
    ImGui::SameLine();
    ImGui::Checkbox("ISO 8601",&ImPlot::GetStyle().UseISO8601);
    ImGui::SameLine();
    ImGui::Checkbox("24 Hour Clock",&ImPlot::GetStyle().Use24HourClock);

    static HugeTimeData* data = nullptr;
    if (data == nullptr) {
        ImGui::SameLine();
        if (ImGui::Button("Generate Huge Data (~500MB!)")) {
            static HugeTimeData sdata(t_min);
            data = &sdata;
        }
    }

    if (ImPlot::BeginPlot("##Time", ImVec2(-1,0))) {
        ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_Time);
        ImPlot::SetupAxesLimits(t_min,t_max,0,1);
        if (data != nullptr) {
            // downsample our data
            int downsample = (int)ImPlot::GetPlotLimits().X.Size() / 1000 + 1;
            int start = (int)(ImPlot::GetPlotLimits().X.Min - t_min);
            start = start < 0 ? 0 : start > HugeTimeData::Size - 1 ? HugeTimeData::Size - 1 : start;
            int end = (int)(ImPlot::GetPlotLimits().X.Max - t_min) + 1000;
            end = end < 0 ? 0 : end > HugeTimeData::Size - 1 ? HugeTimeData::Size - 1 : end;
            int size = (end - start)/downsample;
            // plot it
            ImPlot::PlotLine("Time Series", &data->Ts[start], &data->Ys[start], size, 0, 0, sizeof(double)*downsample);
        }
        // plot time now
        double t_now = (double)time(nullptr);
        double y_now = HugeTimeData::GetY(t_now);
        ImPlot::PlotScatter("Now",&t_now,&y_now,1);
        ImPlot::Annotation(t_now,y_now,ImPlot::GetLastItemColor(),ImVec2(10,10),false,"Now");
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

static inline double TransformForward_Sqrt(double v, void*) {
    return sqrt(v);
}

static inline double TransformInverse_Sqrt(double v, void*) {
    return v*v;
}

void Demo_CustomScale() {
    static float v[100];
    for (int i = 0; i < 100; ++i) {
        v[i] = i*0.01f;
    }
    if (ImPlot::BeginPlot("Sqrt")) {
        ImPlot::SetupAxis(ImAxis_X1, "Linear");
        ImPlot::SetupAxis(ImAxis_Y1, "Sqrt");
        ImPlot::SetupAxisScale(ImAxis_Y1, TransformForward_Sqrt, TransformInverse_Sqrt);
        ImPlot::SetupAxisLimitsConstraints(ImAxis_Y1, 0, INFINITY);
        ImPlot::PlotLine("##data",v,v,100);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_MultipleAxes() {
    static float xs[1001], xs2[1001], ys1[1001], ys2[1001], ys3[1001];
    for (int i = 0; i < 1001; ++i) {
        xs[i]  = (i*0.1f);
        xs2[i] = xs[i] + 10.0f;
        ys1[i] = sinf(xs[i]) * 3 + 1;
        ys2[i] = cosf(xs[i]) * 0.2f + 0.5f;
        ys3[i] = sinf(xs[i]+0.5f) * 100 + 200;
    }

    static bool x2_axis = true;
    static bool y2_axis = true;
    static bool y3_axis = true;

    ImGui::Checkbox("X-Axis 2", &x2_axis);
    ImGui::SameLine();
    ImGui::Checkbox("Y-Axis 2", &y2_axis);
    ImGui::SameLine();
    ImGui::Checkbox("Y-Axis 3", &y3_axis);

    ImGui::BulletText("You can drag axes to the opposite side of the plot.");
    ImGui::BulletText("Hover over legend items to see which axis they are plotted on.");

    if (ImPlot::BeginPlot("Multi-Axis Plot", ImVec2(-1,0))) {
        ImPlot::SetupAxes("X-Axis 1", "Y-Axis 1");
        ImPlot::SetupAxesLimits(0, 100, 0, 10);
        if (x2_axis) {
            ImPlot::SetupAxis(ImAxis_X2, "X-Axis 2",ImPlotAxisFlags_AuxDefault);
            ImPlot::SetupAxisLimits(ImAxis_X2, 0, 100);
        }
        if (y2_axis) {
            ImPlot::SetupAxis(ImAxis_Y2, "Y-Axis 2",ImPlotAxisFlags_AuxDefault);
            ImPlot::SetupAxisLimits(ImAxis_Y2, 0, 1);
        }
        if (y3_axis) {
            ImPlot::SetupAxis(ImAxis_Y3, "Y-Axis 3",ImPlotAxisFlags_AuxDefault);
            ImPlot::SetupAxisLimits(ImAxis_Y3, 0, 300);
        }

        ImPlot::PlotLine("f(x) = x", xs, xs, 1001);
        if (x2_axis) {
            ImPlot::SetAxes(ImAxis_X2, ImAxis_Y1);
            ImPlot::PlotLine("f(x) = sin(x)*3+1", xs2, ys1, 1001);
        }
        if (y2_axis) {
            ImPlot::SetAxes(ImAxis_X1, ImAxis_Y2);
            ImPlot::PlotLine("f(x) = cos(x)*.2+.5", xs, ys2, 1001);
        }
        if (y3_axis) {
            ImPlot::SetAxes(ImAxis_X2, ImAxis_Y3);
            ImPlot::PlotLine("f(x) = sin(x+.5)*100+200 ", xs2, ys3, 1001);
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_LinkedAxes() {
    static ImPlotRect lims(0,1,0,1);
    static bool linkx = true, linky = true;
    int data[2] = {0,1};
    ImGui::Checkbox("Link X", &linkx);
    ImGui::SameLine();
    ImGui::Checkbox("Link Y", &linky);

    ImGui::DragScalarN("Limits",ImGuiDataType_Double,&lims.X.Min,4,0.01f);

    if (BeginAlignedPlots("AlignedGroup")) {
        if (ImPlot::BeginPlot("Plot A")) {
            ImPlot::SetupAxisLinks(ImAxis_X1, linkx ? &lims.X.Min : nullptr, linkx ? &lims.X.Max : nullptr);
            ImPlot::SetupAxisLinks(ImAxis_Y1, linky ? &lims.Y.Min : nullptr, linky ? &lims.Y.Max : nullptr);
            ImPlot::PlotLine("Line",data,2);
            ImPlot::EndPlot();
        }
        if (ImPlot::BeginPlot("Plot B")) {
            ImPlot::SetupAxisLinks(ImAxis_X1, linkx ? &lims.X.Min : nullptr, linkx ? &lims.X.Max : nullptr);
            ImPlot::SetupAxisLinks(ImAxis_Y1, linky ? &lims.Y.Min : nullptr, linky ? &lims.Y.Max : nullptr);
            ImPlot::PlotLine("Line",data,2);
            ImPlot::EndPlot();
        }
        ImPlot::EndAlignedPlots();
    }
}

//-----------------------------------------------------------------------------

void Demo_AxisConstraints() {
    static float constraints[4] = {-10,10,1,20};
    static ImPlotAxisFlags flags;
    ImGui::DragFloat2("Limits Constraints", &constraints[0], 0.01f);
    ImGui::DragFloat2("Zoom Constraints", &constraints[2], 0.01f);
    CHECKBOX_FLAG(flags, ImPlotAxisFlags_PanStretch);
    if (ImPlot::BeginPlot("##AxisConstraints",ImVec2(-1,0))) {
        ImPlot::SetupAxes("X","Y",flags,flags);
        ImPlot::SetupAxesLimits(-1,1,-1,1);
        ImPlot::SetupAxisLimitsConstraints(ImAxis_X1,constraints[0], constraints[1]);
        ImPlot::SetupAxisZoomConstraints(ImAxis_X1,constraints[2], constraints[3]);
        ImPlot::SetupAxisLimitsConstraints(ImAxis_Y1,constraints[0], constraints[1]);
        ImPlot::SetupAxisZoomConstraints(ImAxis_Y1,constraints[2], constraints[3]);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_EqualAxes() {
    ImGui::BulletText("Equal constraint applies to axis pairs (e.g ImAxis_X1/Y1, ImAxis_X2/Y2)");
    static double xs1[360], ys1[360];
    for (int i = 0; i < 360; ++i) {
        double angle = i * 2 * PI / 359.0;
        xs1[i] = cos(angle); ys1[i] = sin(angle);
    }
    float xs2[] = {-1,0,1,0,-1};
    float ys2[] = {0,1,0,-1,0};
    if (ImPlot::BeginPlot("##EqualAxes",ImVec2(-1,0),ImPlotFlags_Equal)) {
        ImPlot::SetupAxis(ImAxis_X2, nullptr, ImPlotAxisFlags_AuxDefault);
        ImPlot::SetupAxis(ImAxis_Y2, nullptr, ImPlotAxisFlags_AuxDefault);
        ImPlot::PlotLine("Circle",xs1,ys1,360);
        ImPlot::SetAxes(ImAxis_X2, ImAxis_Y2);
        ImPlot::PlotLine("Diamond",xs2,ys2,5);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_AutoFittingData() {
    ImGui::BulletText("The Y-axis has been configured to auto-fit to only the data visible in X-axis range.");
    ImGui::BulletText("Zoom and pan the X-axis. Disable Stems to see a difference in fit.");
    ImGui::BulletText("If ImPlotAxisFlags_RangeFit is disabled, the axis will fit ALL data.");

    static ImPlotAxisFlags xflags = ImPlotAxisFlags_None;
    static ImPlotAxisFlags yflags = ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_RangeFit;

    ImGui::TextUnformatted("X: "); ImGui::SameLine();
    ImGui::CheckboxFlags("ImPlotAxisFlags_AutoFit##X", (unsigned int*)&xflags, ImPlotAxisFlags_AutoFit); ImGui::SameLine();
    ImGui::CheckboxFlags("ImPlotAxisFlags_RangeFit##X", (unsigned int*)&xflags, ImPlotAxisFlags_RangeFit);

    ImGui::TextUnformatted("Y: "); ImGui::SameLine();
    ImGui::CheckboxFlags("ImPlotAxisFlags_AutoFit##Y", (unsigned int*)&yflags, ImPlotAxisFlags_AutoFit); ImGui::SameLine();
    ImGui::CheckboxFlags("ImPlotAxisFlags_RangeFit##Y", (unsigned int*)&yflags, ImPlotAxisFlags_RangeFit);

    static double data[101];
    srand(0);
    for (int i = 0; i < 101; ++i)
        data[i] = 1 + sin(i/10.0f);

    if (ImPlot::BeginPlot("##DataFitting")) {
        ImPlot::SetupAxes("X","Y",xflags,yflags);
        ImPlot::PlotLine("Line",data,101);
        ImPlot::PlotStems("Stems",data,101);
        ImPlot::EndPlot();
    };
}

//-----------------------------------------------------------------------------

ImPlotPoint SinewaveGetter(int i, void* data) {
    float f = *(float*)data;
    return ImPlotPoint(i,sinf(f*i));
}

void Demo_SubplotsSizing() {

    static ImPlotSubplotFlags flags = ImPlotSubplotFlags_None;
    ImGui::CheckboxFlags("ImPlotSubplotFlags_NoResize", (unsigned int*)&flags, ImPlotSubplotFlags_NoResize);
    ImGui::CheckboxFlags("ImPlotSubplotFlags_NoTitle", (unsigned int*)&flags, ImPlotSubplotFlags_NoTitle);

    static int rows = 3;
    static int cols = 3;
    ImGui::SliderInt("Rows",&rows,1,5);
    ImGui::SliderInt("Cols",&cols,1,5);
    static float rratios[] = {5,1,1,1,1,1};
    static float cratios[] = {5,1,1,1,1,1};
    ImGui::DragScalarN("Row Ratios",ImGuiDataType_Float,rratios,rows,0.01f,nullptr);
    ImGui::DragScalarN("Col Ratios",ImGuiDataType_Float,cratios,cols,0.01f,nullptr);
    if (ImPlot::BeginSubplots("My Subplots", rows, cols, ImVec2(-1,400), flags, rratios, cratios)) {
        for (int i = 0; i < rows*cols; ++i) {
            if (ImPlot::BeginPlot("",ImVec2(),ImPlotFlags_NoLegend)) {
                ImPlot::SetupAxes(nullptr,nullptr,ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_NoDecorations);
                float fi = 0.01f * (i+1);
                ImPlot::SetNextLineStyle(SampleColormap((float)i/(float)(rows*cols-1),ImPlotColormap_Jet));
                ImPlot::PlotLineG("data",SinewaveGetter,&fi,1000);
                ImPlot::EndPlot();
            }
        }
        ImPlot::EndSubplots();
    }
}

//-----------------------------------------------------------------------------

void Demo_SubplotItemSharing() {
    static ImPlotSubplotFlags flags = ImPlotSubplotFlags_ShareItems;
    ImGui::CheckboxFlags("ImPlotSubplotFlags_ShareItems", (unsigned int*)&flags, ImPlotSubplotFlags_ShareItems);
    ImGui::CheckboxFlags("ImPlotSubplotFlags_ColMajor", (unsigned int*)&flags, ImPlotSubplotFlags_ColMajor);
    ImGui::BulletText("Drag and drop items from the legend onto plots (except for 'common')");
    static int rows = 2;
    static int cols = 3;
    static int id[] = {0,1,2,3,4,5};
    static int curj = -1;
    if (ImPlot::BeginSubplots("##ItemSharing", rows, cols, ImVec2(-1,400), flags)) {
        for (int i = 0; i < rows*cols; ++i) {
            if (ImPlot::BeginPlot("")) {
                float fc = 0.01f;
                ImPlot::PlotLineG("common",SinewaveGetter,&fc,1000);
                for (int j = 0; j < 6; ++j) {
                    if (id[j] == i) {
                        char label[8];
                        float fj = 0.01f * (j+2);
                        snprintf(label, sizeof(label), "data%d", j);
                        ImPlot::PlotLineG(label,SinewaveGetter,&fj,1000);
                        if (ImPlot::BeginDragDropSourceItem(label)) {
                            curj = j;
                            ImGui::SetDragDropPayload("MY_DND",nullptr,0);
                            ImPlot::ItemIcon(GetLastItemColor()); ImGui::SameLine();
                            ImGui::TextUnformatted(label);
                            ImPlot::EndDragDropSource();
                        }
                    }
                }
                if (ImPlot::BeginDragDropTargetPlot()) {
                    if (ImGui::AcceptDragDropPayload("MY_DND"))
                        id[curj] = i;
                    ImPlot::EndDragDropTarget();
                }
                ImPlot::EndPlot();
            }
        }
        ImPlot::EndSubplots();
    }
}

//-----------------------------------------------------------------------------

void Demo_SubplotAxisLinking() {
    static ImPlotSubplotFlags flags = ImPlotSubplotFlags_LinkRows | ImPlotSubplotFlags_LinkCols;
    ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkRows", (unsigned int*)&flags, ImPlotSubplotFlags_LinkRows);
    ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkCols", (unsigned int*)&flags, ImPlotSubplotFlags_LinkCols);
    ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkAllX", (unsigned int*)&flags, ImPlotSubplotFlags_LinkAllX);
    ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkAllY", (unsigned int*)&flags, ImPlotSubplotFlags_LinkAllY);

    static int rows = 2;
    static int cols = 2;
    if (ImPlot::BeginSubplots("##AxisLinking", rows, cols, ImVec2(-1,400), flags)) {
        for (int i = 0; i < rows*cols; ++i) {
            if (ImPlot::BeginPlot("")) {
                ImPlot::SetupAxesLimits(0,1000,-1,1);
                float fc = 0.01f;
                ImPlot::PlotLineG("common",SinewaveGetter,&fc,1000);
                ImPlot::EndPlot();
            }
        }
        ImPlot::EndSubplots();
    }
}

//-----------------------------------------------------------------------------

void Demo_LegendOptions() {
    static ImPlotLocation loc = ImPlotLocation_East;
    ImGui::CheckboxFlags("North", (unsigned int*)&loc, ImPlotLocation_North); ImGui::SameLine();
    ImGui::CheckboxFlags("South", (unsigned int*)&loc, ImPlotLocation_South); ImGui::SameLine();
    ImGui::CheckboxFlags("West",  (unsigned int*)&loc, ImPlotLocation_West);  ImGui::SameLine();
    ImGui::CheckboxFlags("East",  (unsigned int*)&loc, ImPlotLocation_East);

    static ImPlotLegendFlags flags = 0;

    CHECKBOX_FLAG(flags, ImPlotLegendFlags_Horizontal);
    CHECKBOX_FLAG(flags, ImPlotLegendFlags_Outside);
    CHECKBOX_FLAG(flags, ImPlotLegendFlags_Sort);

    ImGui::SliderFloat2("LegendPadding", (float*)&GetStyle().LegendPadding, 0.0f, 20.0f, "%.0f");
    ImGui::SliderFloat2("LegendInnerPadding", (float*)&GetStyle().LegendInnerPadding, 0.0f, 10.0f, "%.0f");
    ImGui::SliderFloat2("LegendSpacing", (float*)&GetStyle().LegendSpacing, 0.0f, 5.0f, "%.0f");

    if (ImPlot::BeginPlot("##Legend",ImVec2(-1,0))) {
        ImPlot::SetupLegend(loc, flags);
        static MyImPlot::WaveData data1(0.001, 0.2, 4, 0.2);
        static MyImPlot::WaveData data2(0.001, 0.2, 4, 0.4);
        static MyImPlot::WaveData data3(0.001, 0.2, 4, 0.6);
        static MyImPlot::WaveData data4(0.001, 0.2, 4, 0.8);
        static MyImPlot::WaveData data5(0.001, 0.2, 4, 1.0);

        ImPlot::PlotLineG("Item B", MyImPlot::SawWave, &data1, 1000);         // "Item B" added to legend
        ImPlot::PlotLineG("Item A##IDText", MyImPlot::SawWave, &data2, 1000);  // "Item A" added to legend, text after ## used for ID only
        ImPlot::PlotLineG("##NotListed", MyImPlot::SawWave, &data3, 1000);     // plotted, but not added to legend
        ImPlot::PlotLineG("Item C", MyImPlot::SawWave, &data4, 1000);         // "Item C" added to legend
        ImPlot::PlotLineG("Item C", MyImPlot::SawWave,  &data5, 1000);         // combined with previous "Item C"

        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_DragPoints() {
    ImGui::BulletText("Click and drag each point.");
    static ImPlotDragToolFlags flags = ImPlotDragToolFlags_None;
    ImGui::CheckboxFlags("NoCursors", (unsigned int*)&flags, ImPlotDragToolFlags_NoCursors); ImGui::SameLine();
    ImGui::CheckboxFlags("NoFit", (unsigned int*)&flags, ImPlotDragToolFlags_NoFit); ImGui::SameLine();
    ImGui::CheckboxFlags("NoInput", (unsigned int*)&flags, ImPlotDragToolFlags_NoInputs);
    ImPlotAxisFlags ax_flags = ImPlotAxisFlags_NoTickLabels | ImPlotAxisFlags_NoTickMarks;
    if (ImPlot::BeginPlot("##Bezier",ImVec2(-1,0),ImPlotFlags_CanvasOnly)) {
        ImPlot::SetupAxes(nullptr,nullptr,ax_flags,ax_flags);
        ImPlot::SetupAxesLimits(0,1,0,1);
        static ImPlotPoint P[] = {ImPlotPoint(.05f,.05f), ImPlotPoint(0.2,0.4),  ImPlotPoint(0.8,0.6),  ImPlotPoint(.95f,.95f)};

        ImPlot::DragPoint(0,&P[0].x,&P[0].y, ImVec4(0,0.9f,0,1),4,flags);
        ImPlot::DragPoint(1,&P[1].x,&P[1].y, ImVec4(1,0.5f,1,1),4,flags);
        ImPlot::DragPoint(2,&P[2].x,&P[2].y, ImVec4(0,0.5f,1,1),4,flags);
        ImPlot::DragPoint(3,&P[3].x,&P[3].y, ImVec4(0,0.9f,0,1),4,flags);

        static ImPlotPoint B[100];
        for (int i = 0; i < 100; ++i) {
            double t  = i / 99.0;
            double u  = 1 - t;
            double w1 = u*u*u;
            double w2 = 3*u*u*t;
            double w3 = 3*u*t*t;
            double w4 = t*t*t;
            B[i] = ImPlotPoint(w1*P[0].x + w2*P[1].x + w3*P[2].x + w4*P[3].x, w1*P[0].y + w2*P[1].y + w3*P[2].y + w4*P[3].y);
        }


        ImPlot::SetNextLineStyle(ImVec4(1,0.5f,1,1));
        ImPlot::PlotLine("##h1",&P[0].x, &P[0].y, 2, 0, 0, sizeof(ImPlotPoint));
        ImPlot::SetNextLineStyle(ImVec4(0,0.5f,1,1));
        ImPlot::PlotLine("##h2",&P[2].x, &P[2].y, 2, 0, 0, sizeof(ImPlotPoint));
        ImPlot::SetNextLineStyle(ImVec4(0,0.9f,0,1), 2);
        ImPlot::PlotLine("##bez",&B[0].x, &B[0].y, 100, 0, 0, sizeof(ImPlotPoint));

        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_DragLines() {
    ImGui::BulletText("Click and drag the horizontal and vertical lines.");
    static double x1 = 0.2;
    static double x2 = 0.8;
    static double y1 = 0.25;
    static double y2 = 0.75;
    static double f = 0.1;
    static ImPlotDragToolFlags flags = ImPlotDragToolFlags_None;
    ImGui::CheckboxFlags("NoCursors", (unsigned int*)&flags, ImPlotDragToolFlags_NoCursors); ImGui::SameLine();
    ImGui::CheckboxFlags("NoFit", (unsigned int*)&flags, ImPlotDragToolFlags_NoFit); ImGui::SameLine();
    ImGui::CheckboxFlags("NoInput", (unsigned int*)&flags, ImPlotDragToolFlags_NoInputs);
    if (ImPlot::BeginPlot("##lines",ImVec2(-1,0))) {
        ImPlot::SetupAxesLimits(0,1,0,1);
        ImPlot::DragLineX(0,&x1,ImVec4(1,1,1,1),1,flags);
        ImPlot::DragLineX(1,&x2,ImVec4(1,1,1,1),1,flags);
        ImPlot::DragLineY(2,&y1,ImVec4(1,1,1,1),1,flags);
        ImPlot::DragLineY(3,&y2,ImVec4(1,1,1,1),1,flags);
        double xs[1000], ys[1000];
        for (int i = 0; i < 1000; ++i) {
            xs[i] = (x2+x1)/2+fabs(x2-x1)*(i/1000.0f - 0.5f);
            ys[i] = (y1+y2)/2+fabs(y2-y1)/2*sin(f*i/10);
        }
        ImPlot::PlotLine("Interactive Data", xs, ys, 1000);
        ImPlot::DragLineY(120482,&f,ImVec4(1,0.5f,1,1),1,flags);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_DragRects() {

    static float x_data[512];
    static float y_data1[512];
    static float y_data2[512];
    static float y_data3[512];
    static float sampling_freq = 44100;
    static float freq = 500;
    for (size_t i = 0; i < 512; ++i) {
        const float t = i / sampling_freq;
        x_data[i] = t;
        const float arg = 2 * 3.14f * freq * t;
        y_data1[i] = sinf(arg);
        y_data2[i] = y_data1[i] * -0.6f + sinf(2 * arg) * 0.4f;
        y_data3[i] = y_data2[i] * -0.6f + sinf(3 * arg) * 0.4f;
    }
    ImGui::BulletText("Click and drag the edges, corners, and center of the rect.");
    static ImPlotRect rect(0.0025,0.0045,0,0.5);
    static ImPlotDragToolFlags flags = ImPlotDragToolFlags_None;
    ImGui::CheckboxFlags("NoCursors", (unsigned int*)&flags, ImPlotDragToolFlags_NoCursors); ImGui::SameLine();
    ImGui::CheckboxFlags("NoFit", (unsigned int*)&flags, ImPlotDragToolFlags_NoFit); ImGui::SameLine();
    ImGui::CheckboxFlags("NoInput", (unsigned int*)&flags, ImPlotDragToolFlags_NoInputs);

    if (ImPlot::BeginPlot("##Main",ImVec2(-1,150))) {
        ImPlot::SetupAxes(nullptr,nullptr,ImPlotAxisFlags_NoTickLabels,ImPlotAxisFlags_NoTickLabels);
        ImPlot::SetupAxesLimits(0,0.01,-1,1);
        ImPlot::PlotLine("Signal 1", x_data, y_data1, 512);
        ImPlot::PlotLine("Signal 2", x_data, y_data2, 512);
        ImPlot::PlotLine("Signal 3", x_data, y_data3, 512);
        ImPlot::DragRect(0,&rect.X.Min,&rect.Y.Min,&rect.X.Max,&rect.Y.Max,ImVec4(1,0,1,1),flags);
        ImPlot::EndPlot();
    }
    if (ImPlot::BeginPlot("##rect",ImVec2(-1,150), ImPlotFlags_CanvasOnly)) {
        ImPlot::SetupAxes(nullptr,nullptr,ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_NoDecorations);
        ImPlot::SetupAxesLimits(rect.X.Min, rect.X.Max, rect.Y.Min, rect.Y.Max, ImGuiCond_Always);
        ImPlot::PlotLine("Signal 1", x_data, y_data1, 512);
        ImPlot::PlotLine("Signal 2", x_data, y_data2, 512);
        ImPlot::PlotLine("Signal 3", x_data, y_data3, 512);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

ImPlotPoint FindCentroid(const ImVector<ImPlotPoint>& data, const ImPlotRect& bounds, int& cnt) {
    cnt = 0;
    ImPlotPoint avg;
    ImPlotRect bounds_fixed;
    bounds_fixed.X.Min = bounds.X.Min < bounds.X.Max ? bounds.X.Min : bounds.X.Max;
    bounds_fixed.X.Max = bounds.X.Min < bounds.X.Max ? bounds.X.Max : bounds.X.Min;
    bounds_fixed.Y.Min = bounds.Y.Min < bounds.Y.Max ? bounds.Y.Min : bounds.Y.Max;
    bounds_fixed.Y.Max = bounds.Y.Min < bounds.Y.Max ? bounds.Y.Max : bounds.Y.Min;
    for (int i = 0; i < data.size(); ++i) {
        if (bounds_fixed.Contains(data[i].x, data[i].y)) {
            avg.x += data[i].x;
            avg.y += data[i].y;
            cnt++;
        }
    }
    if (cnt > 0) {
        avg.x = avg.x / cnt;
        avg.y = avg.y / cnt;
    }
    return avg;
}

//-----------------------------------------------------------------------------

void Demo_Querying() {
    static ImVector<ImPlotPoint> data;
    static ImVector<ImPlotRect> rects;
    static ImPlotRect limits, select;
    static bool init = true;
    if (init) {
        for (int i = 0; i < 50; ++i)
        {
            double x = RandomRange(0.1, 0.9);
            double y = RandomRange(0.1, 0.9);
            data.push_back(ImPlotPoint(x,y));
        }
        init = false;
    }

    ImGui::BulletText("Box select and left click mouse to create a new query rect.");
    ImGui::BulletText("Ctrl + click in the plot area to draw points.");

    if (ImGui::Button("Clear Queries"))
        rects.shrink(0);

    if (ImPlot::BeginPlot("##Centroid")) {
        ImPlot::SetupAxesLimits(0,1,0,1);
        if (ImPlot::IsPlotHovered() && ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyCtrl) {
            ImPlotPoint pt = ImPlot::GetPlotMousePos();
            data.push_back(pt);
        }
        ImPlot::PlotScatter("Points", &data[0].x, &data[0].y, data.size(), 0, 0, 2 * sizeof(double));
        if (ImPlot::IsPlotSelected()) {
            select = ImPlot::GetPlotSelection();
            int cnt;
            ImPlotPoint centroid = FindCentroid(data,select,cnt);
            if (cnt > 0) {
                ImPlot::SetNextMarkerStyle(ImPlotMarker_Square,6);
                ImPlot::PlotScatter("Centroid", &centroid.x, &centroid.y, 1);
            }
            if (ImGui::IsMouseClicked(ImPlot::GetInputMap().SelectCancel)) {
                CancelPlotSelection();
                rects.push_back(select);
            }
        }
        for (int i = 0; i < rects.size(); ++i) {
            int cnt;
            ImPlotPoint centroid = FindCentroid(data,rects[i],cnt);
            if (cnt > 0) {
                ImPlot::SetNextMarkerStyle(ImPlotMarker_Square,6);
                ImPlot::PlotScatter("Centroid", &centroid.x, &centroid.y, 1);
            }
            ImPlot::DragRect(i,&rects[i].X.Min,&rects[i].Y.Min,&rects[i].X.Max,&rects[i].Y.Max,ImVec4(1,0,1,1));
        }
        limits  = ImPlot::GetPlotLimits();
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_Annotations() {
    static bool clamp = false;
    ImGui::Checkbox("Clamp",&clamp);
    if (ImPlot::BeginPlot("##Annotations")) {
        ImPlot::SetupAxesLimits(0,2,0,1);
        static float p[] = {0.25f, 0.25f, 0.75f, 0.75f, 0.25f};
        ImPlot::PlotScatter("##Points",&p[0],&p[1],4);
        ImVec4 col = GetLastItemColor();
        ImPlot::Annotation(0.25,0.25,col,ImVec2(-15,15),clamp,"BL");
        ImPlot::Annotation(0.75,0.25,col,ImVec2(15,15),clamp,"BR");
        ImPlot::Annotation(0.75,0.75,col,ImVec2(15,-15),clamp,"TR");
        ImPlot::Annotation(0.25,0.75,col,ImVec2(-15,-15),clamp,"TL");
        ImPlot::Annotation(0.5,0.5,col,ImVec2(0,0),clamp,"Center");

        ImPlot::Annotation(1.25,0.75,ImVec4(0,1,0,1),ImVec2(0,0),clamp);

        float bx[] = {1.2f,1.5f,1.8f};
        float by[] = {0.25f, 0.5f, 0.75f};
        ImPlot::PlotBars("##Bars",bx,by,3,0.2);
        for (int i = 0; i < 3; ++i)
            ImPlot::Annotation(bx[i],by[i],ImVec4(0,0,0,0),ImVec2(0,-5),clamp,"B[%d]=%.2f",i,by[i]);
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_Tags() {
    static bool show = true;
    ImGui::Checkbox("Show Tags",&show);
    if (ImPlot::BeginPlot("##Tags")) {
        ImPlot::SetupAxis(ImAxis_X2);
        ImPlot::SetupAxis(ImAxis_Y2);
        if (show) {
            ImPlot::TagX(0.25, ImVec4(1,1,0,1));
            ImPlot::TagY(0.75, ImVec4(1,1,0,1));
            static double drag_tag = 0.25;
            ImPlot::DragLineY(0,&drag_tag,ImVec4(1,0,0,1),1,ImPlotDragToolFlags_NoFit);
            ImPlot::TagY(drag_tag, ImVec4(1,0,0,1), "Drag");
            SetAxes(ImAxis_X2, ImAxis_Y2);
            ImPlot::TagX(0.5, ImVec4(0,1,1,1), "%s", "MyTag");
            ImPlot::TagY(0.5, ImVec4(0,1,1,1), "Tag: %d", 42);
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_DragAndDrop() {
    ImGui::BulletText("Drag/drop items from the left column.");
    ImGui::BulletText("Drag/drop items between plots.");
    ImGui::Indent();
    ImGui::BulletText("Plot 1 Targets: Plot, Y-Axes, Legend");
    ImGui::BulletText("Plot 1 Sources: Legend Item Labels");
    ImGui::BulletText("Plot 2 Targets: Plot, X-Axis, Y-Axis");
    ImGui::BulletText("Plot 2 Sources: Plot, X-Axis, Y-Axis (hold Ctrl)");
    ImGui::Unindent();

    // convenience struct to manage DND items; do this however you like
    struct MyDndItem {
        int              Idx;
        int              Plt;
        ImAxis           Yax;
        char             Label[16];
        ImVector<ImVec2> Data;
        ImVec4           Color;
        MyDndItem()        {
            static int i = 0;
            Idx = i++;
            Plt = 0;
            Yax = ImAxis_Y1;
            snprintf(Label, sizeof(Label), "%02d Hz", Idx+1);
            Color = RandomColor();
            Data.reserve(1001);
            for (int k = 0; k < 1001; ++k) {
                float t = k * 1.0f / 999;
                Data.push_back(ImVec2(t, 0.5f + 0.5f * sinf(2*3.14f*t*(Idx+1))));
            }
        }
        void Reset() { Plt = 0; Yax = ImAxis_Y1; }
    };

    const int         k_dnd = 20;
    static MyDndItem  dnd[k_dnd];
    static MyDndItem* dndx = nullptr; // for plot 2
    static MyDndItem* dndy = nullptr; // for plot 2

    // child window to serve as initial source for our DND items
    ImGui::BeginChild("DND_LEFT",ImVec2(100,400));
    if (ImGui::Button("Reset Data")) {
        for (int k = 0; k < k_dnd; ++k)
            dnd[k].Reset();
        dndx = dndy = nullptr;
    }
    for (int k = 0; k < k_dnd; ++k) {
        if (dnd[k].Plt > 0)
            continue;
        ImPlot::ItemIcon(dnd[k].Color); ImGui::SameLine();
        ImGui::Selectable(dnd[k].Label, false, 0, ImVec2(100, 0));
        if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_None)) {
            ImGui::SetDragDropPayload("MY_DND", &k, sizeof(int));
            ImPlot::ItemIcon(dnd[k].Color); ImGui::SameLine();
            ImGui::TextUnformatted(dnd[k].Label);
            ImGui::EndDragDropSource();
        }
    }
    ImGui::EndChild();
    if (ImGui::BeginDragDropTarget()) {
        if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
            int i = *(int*)payload->Data; dnd[i].Reset();
        }
        ImGui::EndDragDropTarget();
    }

    ImGui::SameLine();
    ImGui::BeginChild("DND_RIGHT",ImVec2(-1,400));
    // plot 1 (time series)
    ImPlotAxisFlags flags = ImPlotAxisFlags_NoTickLabels | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoHighlight;
    if (ImPlot::BeginPlot("##DND1", ImVec2(-1,195))) {
        ImPlot::SetupAxis(ImAxis_X1, nullptr, flags|ImPlotAxisFlags_Lock);
        ImPlot::SetupAxis(ImAxis_Y1, "[drop here]", flags);
        ImPlot::SetupAxis(ImAxis_Y2, "[drop here]", flags|ImPlotAxisFlags_Opposite);
        ImPlot::SetupAxis(ImAxis_Y3, "[drop here]", flags|ImPlotAxisFlags_Opposite);

        for (int k = 0; k < k_dnd; ++k) {
            if (dnd[k].Plt == 1 && dnd[k].Data.size() > 0) {
                ImPlot::SetAxis(dnd[k].Yax);
                ImPlot::SetNextLineStyle(dnd[k].Color);
                ImPlot::PlotLine(dnd[k].Label, &dnd[k].Data[0].x, &dnd[k].Data[0].y, dnd[k].Data.size(), 0, 0, 2 * sizeof(float));
                // allow legend item labels to be DND sources
                if (ImPlot::BeginDragDropSourceItem(dnd[k].Label)) {
                    ImGui::SetDragDropPayload("MY_DND", &k, sizeof(int));
                    ImPlot::ItemIcon(dnd[k].Color); ImGui::SameLine();
                    ImGui::TextUnformatted(dnd[k].Label);
                    ImPlot::EndDragDropSource();
                }
            }
        }
        // allow the main plot area to be a DND target
        if (ImPlot::BeginDragDropTargetPlot()) {
            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
                int i = *(int*)payload->Data; dnd[i].Plt = 1; dnd[i].Yax = ImAxis_Y1;
            }
            ImPlot::EndDragDropTarget();
        }
        // allow each y-axis to be a DND target
        for (int y = ImAxis_Y1; y <= ImAxis_Y3; ++y) {
            if (ImPlot::BeginDragDropTargetAxis(y)) {
                if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
                    int i = *(int*)payload->Data; dnd[i].Plt = 1; dnd[i].Yax = y;
                }
                ImPlot::EndDragDropTarget();
            }
        }
        // allow the legend to be a DND target
        if (ImPlot::BeginDragDropTargetLegend()) {
            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
                int i = *(int*)payload->Data; dnd[i].Plt = 1; dnd[i].Yax = ImAxis_Y1;
            }
            ImPlot::EndDragDropTarget();
        }
        ImPlot::EndPlot();
    }
    // plot 2 (Lissajous)
    if (ImPlot::BeginPlot("##DND2", ImVec2(-1,195))) {
        ImPlot::PushStyleColor(ImPlotCol_AxisBg, dndx != nullptr ? dndx->Color : ImPlot::GetStyle().Colors[ImPlotCol_AxisBg]);
        ImPlot::SetupAxis(ImAxis_X1, dndx == nullptr ? "[drop here]" : dndx->Label, flags);
        ImPlot::PushStyleColor(ImPlotCol_AxisBg, dndy != nullptr ? dndy->Color : ImPlot::GetStyle().Colors[ImPlotCol_AxisBg]);
        ImPlot::SetupAxis(ImAxis_Y1, dndy == nullptr ? "[drop here]" : dndy->Label, flags);
        ImPlot::PopStyleColor(2);
        if (dndx != nullptr && dndy != nullptr) {
            ImVec4 mixed((dndx->Color.x + dndy->Color.x)/2,(dndx->Color.y + dndy->Color.y)/2,(dndx->Color.z + dndy->Color.z)/2,(dndx->Color.w + dndy->Color.w)/2);
            ImPlot::SetNextLineStyle(mixed);
            ImPlot::PlotLine("##dndxy", &dndx->Data[0].y, &dndy->Data[0].y, dndx->Data.size(), 0, 0, 2 * sizeof(float));
        }
        // allow the x-axis to be a DND target
        if (ImPlot::BeginDragDropTargetAxis(ImAxis_X1)) {
            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
                int i = *(int*)payload->Data; dndx = &dnd[i];
            }
            ImPlot::EndDragDropTarget();
        }
        // allow the x-axis to be a DND source
        if (dndx != nullptr && ImPlot::BeginDragDropSourceAxis(ImAxis_X1)) {
            ImGui::SetDragDropPayload("MY_DND", &dndx->Idx, sizeof(int));
            ImPlot::ItemIcon(dndx->Color); ImGui::SameLine();
            ImGui::TextUnformatted(dndx->Label);
            ImPlot::EndDragDropSource();
        }
        // allow the y-axis to be a DND target
        if (ImPlot::BeginDragDropTargetAxis(ImAxis_Y1)) {
            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
                int i = *(int*)payload->Data; dndy = &dnd[i];
            }
            ImPlot::EndDragDropTarget();
        }
        // allow the y-axis to be a DND source
        if (dndy != nullptr && ImPlot::BeginDragDropSourceAxis(ImAxis_Y1)) {
            ImGui::SetDragDropPayload("MY_DND", &dndy->Idx, sizeof(int));
            ImPlot::ItemIcon(dndy->Color); ImGui::SameLine();
            ImGui::TextUnformatted(dndy->Label);
            ImPlot::EndDragDropSource();
        }
        // allow the plot area to be a DND target
        if (ImPlot::BeginDragDropTargetPlot()) {
            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
                int i = *(int*)payload->Data; dndx = dndy = &dnd[i];
            }
        }
        // allow the plot area to be a DND source
        if (ImPlot::BeginDragDropSourcePlot()) {
            ImGui::TextUnformatted("Yes, you can\ndrag this!");
            ImPlot::EndDragDropSource();
        }
        ImPlot::EndPlot();
    }
    ImGui::EndChild();
}

//-----------------------------------------------------------------------------

void Demo_Tables() {
#ifdef IMGUI_HAS_TABLE
    static ImGuiTableFlags flags = ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV |
                                   ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable;
    static bool anim = true;
    static int offset = 0;
    ImGui::BulletText("Plots can be used inside of ImGui tables as another means of creating subplots.");
    ImGui::Checkbox("Animate",&anim);
    if (anim)
        offset = (offset + 1) % 100;
    if (ImGui::BeginTable("##table", 3, flags, ImVec2(-1,0))) {
        ImGui::TableSetupColumn("Electrode", ImGuiTableColumnFlags_WidthFixed, 75.0f);
        ImGui::TableSetupColumn("Voltage", ImGuiTableColumnFlags_WidthFixed, 75.0f);
        ImGui::TableSetupColumn("EMG Signal");
        ImGui::TableHeadersRow();
        ImPlot::PushColormap(ImPlotColormap_Cool);
        for (int row = 0; row < 10; row++) {
            ImGui::TableNextRow();
            static float data[100];
            srand(row);
            for (int i = 0; i < 100; ++i)
                data[i] = RandomRange(0.0f,10.0f);
            ImGui::TableSetColumnIndex(0);
            ImGui::Text("EMG %d", row);
            ImGui::TableSetColumnIndex(1);
            ImGui::Text("%.3f V", data[offset]);
            ImGui::TableSetColumnIndex(2);
            ImGui::PushID(row);
            MyImPlot::Sparkline("##spark",data,100,0,11.0f,offset,ImPlot::GetColormapColor(row),ImVec2(-1, 35));
            ImGui::PopID();
        }
        ImPlot::PopColormap();
        ImGui::EndTable();
    }
#else
    ImGui::BulletText("You need to merge the ImGui 'tables' branch for this section.");
#endif
}

//-----------------------------------------------------------------------------

void Demo_OffsetAndStride() {
    static const int k_circles    = 11;
    static const int k_points_per = 50;
    static const int k_size       = 2 * k_points_per * k_circles;
    static double interleaved_data[k_size];
    for (int p = 0; p < k_points_per; ++p) {
        for (int c = 0; c < k_circles; ++c) {
            double r = (double)c / (k_circles - 1) * 0.2 + 0.2;
            interleaved_data[p*2*k_circles + 2*c + 0] = 0.5 + r * cos((double)p/k_points_per * 6.28);
            interleaved_data[p*2*k_circles + 2*c + 1] = 0.5 + r * sin((double)p/k_points_per * 6.28);
        }
    }
    static int offset = 0;
    ImGui::BulletText("Offsetting is useful for realtime plots (see above) and circular buffers.");
    ImGui::BulletText("Striding is useful for interleaved data (e.g. audio) or plotting structs.");
    ImGui::BulletText("Here, all circle data is stored in a single interleaved buffer:");
    ImGui::BulletText("[c0.x0 c0.y0 ... cn.x0 cn.y0 c0.x1 c0.y1 ... cn.x1 cn.y1 ... cn.xm cn.ym]");
    ImGui::BulletText("The offset value indicates which circle point index is considered the first.");
    ImGui::BulletText("Offsets can be negative and/or larger than the actual data count.");
    ImGui::SliderInt("Offset", &offset, -2*k_points_per, 2*k_points_per);
    if (ImPlot::BeginPlot("##strideoffset",ImVec2(-1,0),ImPlotFlags_Equal)) {
        ImPlot::PushColormap(ImPlotColormap_Jet);
        char buff[32];
        for (int c = 0; c < k_circles; ++c) {
            snprintf(buff, sizeof(buff), "Circle %d", c);
            ImPlot::PlotLine(buff, &interleaved_data[c*2 + 0], &interleaved_data[c*2 + 1], k_points_per, 0, offset, 2*k_circles*sizeof(double));
        }
        ImPlot::EndPlot();
        ImPlot::PopColormap();
    }
    // offset++; uncomment for animation!
}

//-----------------------------------------------------------------------------

void Demo_CustomDataAndGetters() {
    ImGui::BulletText("You can plot custom structs using the stride feature.");
    ImGui::BulletText("Most plotters can also be passed a function pointer for getting data.");
    ImGui::Indent();
        ImGui::BulletText("You can optionally pass user data to be given to your getter function.");
        ImGui::BulletText("C++ lambdas can be passed as function pointers as well!");
    ImGui::Unindent();

    MyImPlot::Vector2f vec2_data[2] = { MyImPlot::Vector2f(0,0), MyImPlot::Vector2f(1,1) };

    if (ImPlot::BeginPlot("##Custom Data")) {

        // custom structs using stride example:
        ImPlot::PlotLine("Vector2f", &vec2_data[0].x, &vec2_data[0].y, 2, 0, 0, sizeof(MyImPlot::Vector2f) /* or sizeof(float) * 2 */);

        // custom getter example 1:
        ImPlot::PlotLineG("Spiral", MyImPlot::Spiral, nullptr, 1000);

        // custom getter example 2:
        static MyImPlot::WaveData data1(0.001, 0.2, 2, 0.75);
        static MyImPlot::WaveData data2(0.001, 0.2, 4, 0.25);
        ImPlot::PlotLineG("Waves", MyImPlot::SineWave, &data1, 1000);
        ImPlot::PlotLineG("Waves", MyImPlot::SawWave, &data2, 1000);
        ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, 0.25f);
        ImPlot::PlotShadedG("Waves", MyImPlot::SineWave, &data1, MyImPlot::SawWave, &data2, 1000);
        ImPlot::PopStyleVar();

        // you can also pass C++ lambdas:
        // auto lamda = [](void* data, int idx) { ... return ImPlotPoint(x,y); };
        // ImPlot::PlotLine("My Lambda", lambda, data, 1000);

        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

int MetricFormatter(double value, char* buff, int size, void* data) {
    const char* unit = (const char*)data;
    static double v[]      = {1000000000,1000000,1000,1,0.001,0.000001,0.000000001};
    static const char* p[] = {"G","M","k","","m","u","n"};
    if (value == 0) {
        return snprintf(buff,size,"0 %s", unit);
    }
    for (int i = 0; i < 7; ++i) {
        if (fabs(value) >= v[i]) {
            return snprintf(buff,size,"%g %s%s",value/v[i],p[i],unit);
        }
    }
    return snprintf(buff,size,"%g %s%s",value/v[6],p[6],unit);
}

void Demo_TickLabels()  {
    static bool custom_fmt    = true;
    static bool custom_ticks  = false;
    static bool custom_labels = true;
    ImGui::Checkbox("Show Custom Format", &custom_fmt);
    ImGui::SameLine();
    ImGui::Checkbox("Show Custom Ticks", &custom_ticks);
    if (custom_ticks) {
        ImGui::SameLine();
        ImGui::Checkbox("Show Custom Labels", &custom_labels);
    }
    const double pi = 3.14;
    const char* pi_str[] = {"PI"};
    static double yticks[] = {100,300,700,900};
    static const char*  ylabels[] = {"One","Three","Seven","Nine"};
    static double yticks_aux[] = {0.2,0.4,0.6};
    static const char* ylabels_aux[] = {"A","B","C","D","E","F"};
    if (ImPlot::BeginPlot("##Ticks")) {
        ImPlot::SetupAxesLimits(2.5,5,0,1000);
        ImPlot::SetupAxis(ImAxis_Y2, nullptr, ImPlotAxisFlags_AuxDefault);
        ImPlot::SetupAxis(ImAxis_Y3, nullptr, ImPlotAxisFlags_AuxDefault);
        if (custom_fmt) {
            ImPlot::SetupAxisFormat(ImAxis_X1, "%g ms");
            ImPlot::SetupAxisFormat(ImAxis_Y1, MetricFormatter, (void*)"Hz");
            ImPlot::SetupAxisFormat(ImAxis_Y2, "%g dB");
            ImPlot::SetupAxisFormat(ImAxis_Y3, MetricFormatter, (void*)"m");
        }
        if (custom_ticks) {
            ImPlot::SetupAxisTicks(ImAxis_X1, &pi,1,custom_labels ? pi_str : nullptr, true);
            ImPlot::SetupAxisTicks(ImAxis_Y1, yticks, 4, custom_labels ? ylabels : nullptr, false);
            ImPlot::SetupAxisTicks(ImAxis_Y2, yticks_aux, 3, custom_labels ? ylabels_aux : nullptr, false);
            ImPlot::SetupAxisTicks(ImAxis_Y3, 0, 1, 6, custom_labels ? ylabels_aux : nullptr, false);
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_CustomStyles() {
    ImPlot::PushColormap(ImPlotColormap_Deep);
    // normally you wouldn't change the entire style each frame
    ImPlotStyle backup = ImPlot::GetStyle();
    MyImPlot::StyleSeaborn();
    if (ImPlot::BeginPlot("seaborn style")) {
        ImPlot::SetupAxes( "x-axis", "y-axis");
        ImPlot::SetupAxesLimits(-0.5f, 9.5f, 0, 10);
        unsigned int lin[10] = {8,8,9,7,8,8,8,9,7,8};
        unsigned int bar[10] = {1,2,5,3,4,1,2,5,3,4};
        unsigned int dot[10] = {7,6,6,7,8,5,6,5,8,7};
        ImPlot::PlotBars("Bars", bar, 10, 0.5f);
        ImPlot::PlotLine("Line", lin, 10);
        ImPlot::NextColormapColor(); // skip green
        ImPlot::PlotScatter("Scatter", dot, 10);
        ImPlot::EndPlot();
    }
    ImPlot::GetStyle() = backup;
    ImPlot::PopColormap();
}

//-----------------------------------------------------------------------------

void Demo_CustomRendering() {
    if (ImPlot::BeginPlot("##CustomRend")) {
        ImVec2 cntr = ImPlot::PlotToPixels(ImPlotPoint(0.5f,  0.5f));
        ImVec2 rmin = ImPlot::PlotToPixels(ImPlotPoint(0.25f, 0.75f));
        ImVec2 rmax = ImPlot::PlotToPixels(ImPlotPoint(0.75f, 0.25f));
        ImPlot::PushPlotClipRect();
        ImPlot::GetPlotDrawList()->AddCircleFilled(cntr,20,IM_COL32(255,255,0,255),20);
        ImPlot::GetPlotDrawList()->AddRect(rmin, rmax, IM_COL32(128,0,255,255));
        ImPlot::PopPlotClipRect();
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_LegendPopups() {
    ImGui::BulletText("You can implement legend context menus to inject per-item controls and widgets.");
    ImGui::BulletText("Right click the legend label/icon to edit custom item attributes.");

    static float  frequency = 0.1f;
    static float  amplitude = 0.5f;
    static ImVec4 color     = ImVec4(1,1,0,1);
    static float  alpha     = 1.0f;
    static bool   line      = false;
    static float  thickness = 1;
    static bool   markers   = false;
    static bool   shaded    = false;

    static float vals[101];
    for (int i = 0; i < 101; ++i)
        vals[i] = amplitude * sinf(frequency * i);

    if (ImPlot::BeginPlot("Right Click the Legend")) {
        ImPlot::SetupAxesLimits(0,100,-1,1);
        // rendering logic
        ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, alpha);
        if (!line) {
            ImPlot::SetNextFillStyle(color);
            ImPlot::PlotBars("Right Click Me", vals, 101);
        }
        else {
            if (markers) ImPlot::SetNextMarkerStyle(ImPlotMarker_Square);
            ImPlot::SetNextLineStyle(color, thickness);
            ImPlot::PlotLine("Right Click Me", vals, 101);
            if (shaded) ImPlot::PlotShaded("Right Click Me",vals,101);
        }
        ImPlot::PopStyleVar();
        // custom legend context menu
        if (ImPlot::BeginLegendPopup("Right Click Me")) {
            ImGui::SliderFloat("Frequency",&frequency,0,1,"%0.2f");
            ImGui::SliderFloat("Amplitude",&amplitude,0,1,"%0.2f");
            ImGui::Separator();
            ImGui::ColorEdit3("Color",&color.x);
            ImGui::SliderFloat("Transparency",&alpha,0,1,"%.2f");
            ImGui::Checkbox("Line Plot", &line);
            if (line) {
                ImGui::SliderFloat("Thickness", &thickness, 0, 5);
                ImGui::Checkbox("Markers", &markers);
                ImGui::Checkbox("Shaded",&shaded);
            }
            ImPlot::EndLegendPopup();
        }
        ImPlot::EndPlot();
    }
}

//-----------------------------------------------------------------------------

void Demo_ColormapWidgets() {
    static int cmap = ImPlotColormap_Viridis;

    if (ImPlot::ColormapButton("Button",ImVec2(0,0),cmap)) {
        cmap = (cmap + 1) % ImPlot::GetColormapCount();
    }

    static float t = 0.5f;
    static ImVec4 col;
    ImGui::ColorButton("##Display",col,ImGuiColorEditFlags_NoInputs);
    ImGui::SameLine();
    ImPlot::ColormapSlider("Slider", &t, &col, "%.3f", cmap);

    ImPlot::ColormapIcon(cmap); ImGui::SameLine(); ImGui::Text("Icon");

    static ImPlotColormapScaleFlags flags = 0;
    static float scale[2] = {0, 100};
    ImPlot::ColormapScale("Scale",scale[0],scale[1],ImVec2(0,0),"%g dB",flags,cmap);
    ImGui::InputFloat2("Scale",scale);
    CHECKBOX_FLAG(flags, ImPlotColormapScaleFlags_NoLabel);
    CHECKBOX_FLAG(flags, ImPlotColormapScaleFlags_Opposite);
    CHECKBOX_FLAG(flags, ImPlotColormapScaleFlags_Invert);
}

//-----------------------------------------------------------------------------

void Demo_CustomPlottersAndTooltips()  {
    ImGui::BulletText("You can create custom plotters or extend ImPlot using implot_internal.h.");
    double dates[]  = {1546300800,1546387200,1546473600,1546560000,1546819200,1546905600,1546992000,1547078400,1547164800,1547424000,1547510400,1547596800,1547683200,1547769600,1547942400,1548028800,1548115200,1548201600,1548288000,1548374400,1548633600,1548720000,1548806400,1548892800,1548979200,1549238400,1549324800,1549411200,1549497600,1549584000,1549843200,1549929600,1550016000,1550102400,1550188800,1550361600,1550448000,1550534400,1550620800,1550707200,1550793600,1551052800,1551139200,1551225600,1551312000,1551398400,1551657600,1551744000,1551830400,1551916800,1552003200,1552262400,1552348800,1552435200,1552521600,1552608000,1552867200,1552953600,1553040000,1553126400,1553212800,1553472000,1553558400,1553644800,1553731200,1553817600,1554076800,1554163200,1554249600,1554336000,1554422400,1554681600,1554768000,1554854400,1554940800,1555027200,1555286400,1555372800,1555459200,1555545600,1555632000,1555891200,1555977600,1556064000,1556150400,1556236800,1556496000,1556582400,1556668800,1556755200,1556841600,1557100800,1557187200,1557273600,1557360000,1557446400,1557705600,1557792000,1557878400,1557964800,1558051200,1558310400,1558396800,1558483200,1558569600,1558656000,1558828800,1558915200,1559001600,1559088000,1559174400,1559260800,1559520000,1559606400,1559692800,1559779200,1559865600,1560124800,1560211200,1560297600,1560384000,1560470400,1560729600,1560816000,1560902400,1560988800,1561075200,1561334400,1561420800,1561507200,1561593600,1561680000,1561939200,1562025600,1562112000,1562198400,1562284800,1562544000,1562630400,1562716800,1562803200,1562889600,1563148800,1563235200,1563321600,1563408000,1563494400,1563753600,1563840000,1563926400,1564012800,1564099200,1564358400,1564444800,1564531200,1564617600,1564704000,1564963200,1565049600,1565136000,1565222400,1565308800,1565568000,1565654400,1565740800,1565827200,1565913600,1566172800,1566259200,1566345600,1566432000,1566518400,1566777600,1566864000,1566950400,1567036800,1567123200,1567296000,1567382400,1567468800,1567555200,1567641600,1567728000,1567987200,1568073600,1568160000,1568246400,1568332800,1568592000,1568678400,1568764800,1568851200,1568937600,1569196800,1569283200,1569369600,1569456000,1569542400,1569801600,1569888000,1569974400,1570060800,1570147200,1570406400,1570492800,1570579200,1570665600,1570752000,1571011200,1571097600,1571184000,1571270400,1571356800,1571616000,1571702400,1571788800,1571875200,1571961600};
    double opens[]  = {1284.7,1319.9,1318.7,1328,1317.6,1321.6,1314.3,1325,1319.3,1323.1,1324.7,1321.3,1323.5,1322,1281.3,1281.95,1311.1,1315,1314,1313.1,1331.9,1334.2,1341.3,1350.6,1349.8,1346.4,1343.4,1344.9,1335.6,1337.9,1342.5,1337,1338.6,1337,1340.4,1324.65,1324.35,1349.5,1371.3,1367.9,1351.3,1357.8,1356.1,1356,1347.6,1339.1,1320.6,1311.8,1314,1312.4,1312.3,1323.5,1319.1,1327.2,1332.1,1320.3,1323.1,1328,1330.9,1338,1333,1335.3,1345.2,1341.1,1332.5,1314,1314.4,1310.7,1314,1313.1,1315,1313.7,1320,1326.5,1329.2,1314.2,1312.3,1309.5,1297.4,1293.7,1277.9,1295.8,1295.2,1290.3,1294.2,1298,1306.4,1299.8,1302.3,1297,1289.6,1302,1300.7,1303.5,1300.5,1303.2,1306,1318.7,1315,1314.5,1304.1,1294.7,1293.7,1291.2,1290.2,1300.4,1284.2,1284.25,1301.8,1295.9,1296.2,1304.4,1323.1,1340.9,1341,1348,1351.4,1351.4,1343.5,1342.3,1349,1357.6,1357.1,1354.7,1361.4,1375.2,1403.5,1414.7,1433.2,1438,1423.6,1424.4,1418,1399.5,1435.5,1421.25,1434.1,1412.4,1409.8,1412.2,1433.4,1418.4,1429,1428.8,1420.6,1441,1460.4,1441.7,1438.4,1431,1439.3,1427.4,1431.9,1439.5,1443.7,1425.6,1457.5,1451.2,1481.1,1486.7,1512.1,1515.9,1509.2,1522.3,1513,1526.6,1533.9,1523,1506.3,1518.4,1512.4,1508.8,1545.4,1537.3,1551.8,1549.4,1536.9,1535.25,1537.95,1535.2,1556,1561.4,1525.6,1516.4,1507,1493.9,1504.9,1506.5,1513.1,1506.5,1509.7,1502,1506.8,1521.5,1529.8,1539.8,1510.9,1511.8,1501.7,1478,1485.4,1505.6,1511.6,1518.6,1498.7,1510.9,1510.8,1498.3,1492,1497.7,1484.8,1494.2,1495.6,1495.6,1487.5,1491.1,1495.1,1506.4};
    double highs[]  = {1284.75,1320.6,1327,1330.8,1326.8,1321.6,1326,1328,1325.8,1327.1,1326,1326,1323.5,1322.1,1282.7,1282.95,1315.8,1316.3,1314,1333.2,1334.7,1341.7,1353.2,1354.6,1352.2,1346.4,1345.7,1344.9,1340.7,1344.2,1342.7,1342.1,1345.2,1342,1350,1324.95,1330.75,1369.6,1374.3,1368.4,1359.8,1359,1357,1356,1353.4,1340.6,1322.3,1314.1,1316.1,1312.9,1325.7,1323.5,1326.3,1336,1332.1,1330.1,1330.4,1334.7,1341.1,1344.2,1338.8,1348.4,1345.6,1342.8,1334.7,1322.3,1319.3,1314.7,1316.6,1316.4,1315,1325.4,1328.3,1332.2,1329.2,1316.9,1312.3,1309.5,1299.6,1296.9,1277.9,1299.5,1296.2,1298.4,1302.5,1308.7,1306.4,1305.9,1307,1297.2,1301.7,1305,1305.3,1310.2,1307,1308,1319.8,1321.7,1318.7,1316.2,1305.9,1295.8,1293.8,1293.7,1304.2,1302,1285.15,1286.85,1304,1302,1305.2,1323,1344.1,1345.2,1360.1,1355.3,1363.8,1353,1344.7,1353.6,1358,1373.6,1358.2,1369.6,1377.6,1408.9,1425.5,1435.9,1453.7,1438,1426,1439.1,1418,1435,1452.6,1426.65,1437.5,1421.5,1414.1,1433.3,1441.3,1431.4,1433.9,1432.4,1440.8,1462.3,1467,1443.5,1444,1442.9,1447,1437.6,1440.8,1445.7,1447.8,1458.2,1461.9,1481.8,1486.8,1522.7,1521.3,1521.1,1531.5,1546.1,1534.9,1537.7,1538.6,1523.6,1518.8,1518.4,1514.6,1540.3,1565,1554.5,1556.6,1559.8,1541.9,1542.9,1540.05,1558.9,1566.2,1561.9,1536.2,1523.8,1509.1,1506.2,1532.2,1516.6,1519.7,1515,1519.5,1512.1,1524.5,1534.4,1543.3,1543.3,1542.8,1519.5,1507.2,1493.5,1511.4,1525.8,1522.2,1518.8,1515.3,1518,1522.3,1508,1501.5,1503,1495.5,1501.1,1497.9,1498.7,1492.1,1499.4,1506.9,1520.9};
    double lows[]   = {1282.85,1315,1318.7,1309.6,1317.6,1312.9,1312.4,1319.1,1319,1321,1318.1,1321.3,1319.9,1312,1280.5,1276.15,1308,1309.9,1308.5,1312.3,1329.3,1333.1,1340.2,1347,1345.9,1338,1340.8,1335,1332,1337.9,1333,1336.8,1333.2,1329.9,1340.4,1323.85,1324.05,1349,1366.3,1351.2,1349.1,1352.4,1350.7,1344.3,1338.9,1316.3,1308.4,1306.9,1309.6,1306.7,1312.3,1315.4,1319,1327.2,1317.2,1320,1323,1328,1323,1327.8,1331.7,1335.3,1336.6,1331.8,1311.4,1310,1309.5,1308,1310.6,1302.8,1306.6,1313.7,1320,1322.8,1311,1312.1,1303.6,1293.9,1293.5,1291,1277.9,1294.1,1286,1289.1,1293.5,1296.9,1298,1299.6,1292.9,1285.1,1288.5,1296.3,1297.2,1298.4,1298.6,1302,1300.3,1312,1310.8,1301.9,1292,1291.1,1286.3,1289.2,1289.9,1297.4,1283.65,1283.25,1292.9,1295.9,1290.8,1304.2,1322.7,1336.1,1341,1343.5,1345.8,1340.3,1335.1,1341.5,1347.6,1352.8,1348.2,1353.7,1356.5,1373.3,1398,1414.7,1427,1416.4,1412.7,1420.1,1396.4,1398.8,1426.6,1412.85,1400.7,1406,1399.8,1404.4,1415.5,1417.2,1421.9,1415,1413.7,1428.1,1434,1435.7,1427.5,1429.4,1423.9,1425.6,1427.5,1434.8,1422.3,1412.1,1442.5,1448.8,1468.2,1484.3,1501.6,1506.2,1498.6,1488.9,1504.5,1518.3,1513.9,1503.3,1503,1506.5,1502.1,1503,1534.8,1535.3,1541.4,1528.6,1525.6,1535.25,1528.15,1528,1542.6,1514.3,1510.7,1505.5,1492.1,1492.9,1496.8,1493.1,1503.4,1500.9,1490.7,1496.3,1505.3,1505.3,1517.9,1507.4,1507.1,1493.3,1470.5,1465,1480.5,1501.7,1501.4,1493.3,1492.1,1505.1,1495.7,1478,1487.1,1480.8,1480.6,1487,1488.3,1484.8,1484,1490.7,1490.4,1503.1};
    double closes[] = {1283.35,1315.3,1326.1,1317.4,1321.5,1317.4,1323.5,1319.2,1321.3,1323.3,1319.7,1325.1,1323.6,1313.8,1282.05,1279.05,1314.2,1315.2,1310.8,1329.1,1334.5,1340.2,1340.5,1350,1347.1,1344.3,1344.6,1339.7,1339.4,1343.7,1337,1338.9,1340.1,1338.7,1346.8,1324.25,1329.55,1369.6,1372.5,1352.4,1357.6,1354.2,1353.4,1346,1341,1323.8,1311.9,1309.1,1312.2,1310.7,1324.3,1315.7,1322.4,1333.8,1319.4,1327.1,1325.8,1330.9,1325.8,1331.6,1336.5,1346.7,1339.2,1334.7,1313.3,1316.5,1312.4,1313.4,1313.3,1312.2,1313.7,1319.9,1326.3,1331.9,1311.3,1313.4,1309.4,1295.2,1294.7,1294.1,1277.9,1295.8,1291.2,1297.4,1297.7,1306.8,1299.4,1303.6,1302.2,1289.9,1299.2,1301.8,1303.6,1299.5,1303.2,1305.3,1319.5,1313.6,1315.1,1303.5,1293,1294.6,1290.4,1291.4,1302.7,1301,1284.15,1284.95,1294.3,1297.9,1304.1,1322.6,1339.3,1340.1,1344.9,1354,1357.4,1340.7,1342.7,1348.2,1355.1,1355.9,1354.2,1362.1,1360.1,1408.3,1411.2,1429.5,1430.1,1426.8,1423.4,1425.1,1400.8,1419.8,1432.9,1423.55,1412.1,1412.2,1412.8,1424.9,1419.3,1424.8,1426.1,1423.6,1435.9,1440.8,1439.4,1439.7,1434.5,1436.5,1427.5,1432.2,1433.3,1441.8,1437.8,1432.4,1457.5,1476.5,1484.2,1519.6,1509.5,1508.5,1517.2,1514.1,1527.8,1531.2,1523.6,1511.6,1515.7,1515.7,1508.5,1537.6,1537.2,1551.8,1549.1,1536.9,1529.4,1538.05,1535.15,1555.9,1560.4,1525.5,1515.5,1511.1,1499.2,1503.2,1507.4,1499.5,1511.5,1513.4,1515.8,1506.2,1515.1,1531.5,1540.2,1512.3,1515.2,1506.4,1472.9,1489,1507.9,1513.8,1512.9,1504.4,1503.9,1512.8,1500.9,1488.7,1497.6,1483.5,1494,1498.3,1494.1,1488.1,1487.5,1495.7,1504.7,1505.3};
    static bool tooltip = true;
    ImGui::Checkbox("Show Tooltip", &tooltip);
    ImGui::SameLine();
    static ImVec4 bullCol = ImVec4(0.000f, 1.000f, 0.441f, 1.000f);
    static ImVec4 bearCol = ImVec4(0.853f, 0.050f, 0.310f, 1.000f);
    ImGui::SameLine(); ImGui::ColorEdit4("##Bull", &bullCol.x, ImGuiColorEditFlags_NoInputs);
    ImGui::SameLine(); ImGui::ColorEdit4("##Bear", &bearCol.x, ImGuiColorEditFlags_NoInputs);
    ImPlot::GetStyle().UseLocalTime = false;

    if (ImPlot::BeginPlot("Candlestick Chart",ImVec2(-1,0))) {
        ImPlot::SetupAxes(nullptr,nullptr,0,ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_RangeFit);
        ImPlot::SetupAxesLimits(1546300800, 1571961600, 1250, 1600);
        ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_Time);
        ImPlot::SetupAxisLimitsConstraints(ImAxis_X1, 1546300800, 1571961600);
        ImPlot::SetupAxisZoomConstraints(ImAxis_X1, 60*60*24*14, 1571961600-1546300800);
        ImPlot::SetupAxisFormat(ImAxis_Y1, "$%.0f");
        MyImPlot::PlotCandlestick("GOOGL",dates, opens, closes, lows, highs, 218, tooltip, 0.25f, bullCol, bearCol);
        ImPlot::EndPlot();
    }
    }

//-----------------------------------------------------------------------------
// DEMO WINDOW
//-----------------------------------------------------------------------------

void DemoHeader(const char* label, void(*demo)()) {
    if (ImGui::TreeNodeEx(label)) {
        demo();
        ImGui::TreePop();
    }
}

void ShowDemoWindow(bool* p_open) {
    static bool show_implot_metrics      = false;
    static bool show_implot_style_editor = false;
    static bool show_imgui_metrics       = false;
    static bool show_imgui_style_editor  = false;
    static bool show_imgui_demo          = false;

    if (show_implot_metrics) {
        ImPlot::ShowMetricsWindow(&show_implot_metrics);
    }
    if (show_implot_style_editor) {
        ImGui::SetNextWindowSize(ImVec2(415,762), ImGuiCond_Appearing);
        ImGui::Begin("Style Editor (ImPlot)", &show_implot_style_editor);
        ImPlot::ShowStyleEditor();
        ImGui::End();
    }
    if (show_imgui_style_editor) {
        ImGui::Begin("Style Editor (ImGui)", &show_imgui_style_editor);
        ImGui::ShowStyleEditor();
        ImGui::End();
    }
    if (show_imgui_metrics) {
        ImGui::ShowMetricsWindow(&show_imgui_metrics);
    }
    if (show_imgui_demo) {
        ImGui::ShowDemoWindow(&show_imgui_demo);
    }
    ImGui::SetNextWindowPos(ImVec2(50, 50), ImGuiCond_FirstUseEver);
    ImGui::SetNextWindowSize(ImVec2(600, 750), ImGuiCond_FirstUseEver);
    ImGui::Begin("ImPlot Demo", p_open, ImGuiWindowFlags_MenuBar);
    if (ImGui::BeginMenuBar()) {
        if (ImGui::BeginMenu("Tools")) {
            ImGui::MenuItem("Metrics",      nullptr, &show_implot_metrics);
            ImGui::MenuItem("Style Editor", nullptr, &show_implot_style_editor);
            ImGui::Separator();
            ImGui::MenuItem("ImGui Metrics",       nullptr, &show_imgui_metrics);
            ImGui::MenuItem("ImGui Style Editor",  nullptr, &show_imgui_style_editor);
            ImGui::MenuItem("ImGui Demo",          nullptr, &show_imgui_demo);
            ImGui::EndMenu();
        }
        ImGui::EndMenuBar();
    }
    //-------------------------------------------------------------------------
    ImGui::Text("ImPlot says hello. (%s)", IMPLOT_VERSION);
    // display warning about 16-bit indices
    static bool showWarning = sizeof(ImDrawIdx)*8 == 16 && (ImGui::GetIO().BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset) == false;
    if (showWarning) {
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1,1,0,1));
        ImGui::TextWrapped("WARNING: ImDrawIdx is 16-bit and ImGuiBackendFlags_RendererHasVtxOffset is false. Expect visual glitches and artifacts! See README for more information.");
        ImGui::PopStyleColor();
    }

    ImGui::Spacing();

    if (ImGui::BeginTabBar("ImPlotDemoTabs")) {
        if (ImGui::BeginTabItem("Plots")) {
            DemoHeader("Line Plots", Demo_LinePlots);
            DemoHeader("Filled Line Plots", Demo_FilledLinePlots);
            DemoHeader("Shaded Plots##", Demo_ShadedPlots);
            DemoHeader("Scatter Plots", Demo_ScatterPlots);
            DemoHeader("Realtime Plots", Demo_RealtimePlots);
            DemoHeader("Stairstep Plots", Demo_StairstepPlots);
            DemoHeader("Bar Plots", Demo_BarPlots);
            DemoHeader("Bar Groups", Demo_BarGroups);
            DemoHeader("Bar Stacks", Demo_BarStacks);
            DemoHeader("Error Bars", Demo_ErrorBars);
            DemoHeader("Stem Plots##", Demo_StemPlots);
            DemoHeader("Infinite Lines", Demo_InfiniteLines);
            DemoHeader("Pie Charts", Demo_PieCharts);
            DemoHeader("Heatmaps", Demo_Heatmaps);
            DemoHeader("Histogram", Demo_Histogram);
            DemoHeader("Histogram 2D", Demo_Histogram2D);
            DemoHeader("Digital Plots", Demo_DigitalPlots);
            DemoHeader("Images", Demo_Images);
            DemoHeader("Markers and Text", Demo_MarkersAndText);
            DemoHeader("NaN Values", Demo_NaNValues);
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Subplots")) {
            DemoHeader("Sizing", Demo_SubplotsSizing);
            DemoHeader("Item Sharing", Demo_SubplotItemSharing);
            DemoHeader("Axis Linking", Demo_SubplotAxisLinking);
            DemoHeader("Tables", Demo_Tables);
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Axes")) {
            DemoHeader("Log Scale", Demo_LogScale);
            DemoHeader("Symmetric Log Scale", Demo_SymmetricLogScale);
            DemoHeader("Time Scale", Demo_TimeScale);
            DemoHeader("Custom Scale", Demo_CustomScale);
            DemoHeader("Multiple Axes", Demo_MultipleAxes);
            DemoHeader("Tick Labels", Demo_TickLabels);
            DemoHeader("Linked Axes", Demo_LinkedAxes);
            DemoHeader("Axis Constraints", Demo_AxisConstraints);
            DemoHeader("Equal Axes", Demo_EqualAxes);
            DemoHeader("Auto-Fitting Data", Demo_AutoFittingData);
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Tools")) {
            DemoHeader("Offset and Stride", Demo_OffsetAndStride);
            DemoHeader("Drag Points", Demo_DragPoints);
            DemoHeader("Drag Lines", Demo_DragLines);
            DemoHeader("Drag Rects", Demo_DragRects);
            DemoHeader("Querying", Demo_Querying);
            DemoHeader("Annotations", Demo_Annotations);
            DemoHeader("Tags", Demo_Tags);
            DemoHeader("Drag and Drop", Demo_DragAndDrop);
            DemoHeader("Legend Options", Demo_LegendOptions);
            DemoHeader("Legend Popups", Demo_LegendPopups);
            DemoHeader("Colormap Widgets", Demo_ColormapWidgets);
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Custom")) {
            DemoHeader("Custom Styles", Demo_CustomStyles);
            DemoHeader("Custom Data and Getters", Demo_CustomDataAndGetters);
            DemoHeader("Custom Rendering", Demo_CustomRendering);
            DemoHeader("Custom Plotters and Tooltips", Demo_CustomPlottersAndTooltips);
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Config")) {
            Demo_Config();
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Help")) {
            Demo_Help();
            ImGui::EndTabItem();
        }
        ImGui::EndTabBar();
    }
    ImGui::End();
}

} // namespace ImPlot

namespace MyImPlot {

ImPlotPoint SineWave(int idx, void* data) {
    WaveData* wd = (WaveData*)data;
    double x = idx * wd->X;
    return ImPlotPoint(x, wd->Offset + wd->Amp * sin(2 * 3.14 * wd->Freq * x));
}

ImPlotPoint SawWave(int idx, void* data) {
    WaveData* wd = (WaveData*)data;
    double x = idx * wd->X;
    return ImPlotPoint(x, wd->Offset + wd->Amp * (-2 / 3.14 * atan(cos(3.14 * wd->Freq * x) / sin(3.14 * wd->Freq * x))));
}

ImPlotPoint Spiral(int idx, void*) {
    float r = 0.9f;            // outer radius
    float a = 0;               // inner radius
    float b = 0.05f;           // increment per rev
    float n = (r - a) / b;     // number  of revolutions
    double th = 2 * n * 3.14;  // angle
    float Th = float(th * idx / (1000 - 1));
    return ImPlotPoint(0.5f+(a + b*Th / (2.0f * (float) 3.14))*cos(Th),
                       0.5f + (a + b*Th / (2.0f * (float)3.14))*sin(Th));
}

void Sparkline(const char* id, const float* values, int count, float min_v, float max_v, int offset, const ImVec4& col, const ImVec2& size) {
    ImPlot::PushStyleVar(ImPlotStyleVar_PlotPadding, ImVec2(0,0));
    if (ImPlot::BeginPlot(id,size,ImPlotFlags_CanvasOnly|ImPlotFlags_NoChild)) {
        ImPlot::SetupAxes(nullptr,nullptr,ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_NoDecorations);
        ImPlot::SetupAxesLimits(0, count - 1, min_v, max_v, ImGuiCond_Always);
        ImPlot::SetNextLineStyle(col);
        ImPlot::SetNextFillStyle(col, 0.25);
        ImPlot::PlotLine(id, values, count, 1, 0, ImPlotLineFlags_Shaded, offset);
        ImPlot::EndPlot();
    }
    ImPlot::PopStyleVar();
}

void StyleSeaborn() {

    ImPlotStyle& style              = ImPlot::GetStyle();

    ImVec4* colors                  = style.Colors;
    colors[ImPlotCol_Line]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_Fill]          = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
    colors[ImPlotCol_MarkerFill]    = IMPLOT_AUTO_COL;
    colors[ImPlotCol_ErrorBar]      = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_FrameBg]       = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImPlotCol_PlotBg]        = ImVec4(0.92f, 0.92f, 0.95f, 1.00f);
    colors[ImPlotCol_PlotBorder]    = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    colors[ImPlotCol_LegendBg]      = ImVec4(0.92f, 0.92f, 0.95f, 1.00f);
    colors[ImPlotCol_LegendBorder]  = ImVec4(0.80f, 0.81f, 0.85f, 1.00f);
    colors[ImPlotCol_LegendText]    = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_TitleText]     = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_InlayText]     = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_AxisText]      = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
    colors[ImPlotCol_AxisGrid]      = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
    colors[ImPlotCol_AxisBgHovered]   = ImVec4(0.92f, 0.92f, 0.95f, 1.00f);
    colors[ImPlotCol_AxisBgActive]    = ImVec4(0.92f, 0.92f, 0.95f, 0.75f);
    colors[ImPlotCol_Selection]     = ImVec4(1.00f, 0.65f, 0.00f, 1.00f);
    colors[ImPlotCol_Crosshairs]    = ImVec4(0.23f, 0.10f, 0.64f, 0.50f);

    style.LineWeight       = 1.5;
    style.Marker           = ImPlotMarker_None;
    style.MarkerSize       = 4;
    style.MarkerWeight     = 1;
    style.FillAlpha        = 1.0f;
    style.ErrorBarSize     = 5;
    style.ErrorBarWeight   = 1.5f;
    style.DigitalBitHeight = 8;
    style.DigitalBitGap    = 4;
    style.PlotBorderSize   = 0;
    style.MinorAlpha       = 1.0f;
    style.MajorTickLen     = ImVec2(0,0);
    style.MinorTickLen     = ImVec2(0,0);
    style.MajorTickSize    = ImVec2(0,0);
    style.MinorTickSize    = ImVec2(0,0);
    style.MajorGridSize    = ImVec2(1.2f,1.2f);
    style.MinorGridSize    = ImVec2(1.2f,1.2f);
    style.PlotPadding      = ImVec2(12,12);
    style.LabelPadding     = ImVec2(5,5);
    style.LegendPadding    = ImVec2(5,5);
    style.MousePosPadding  = ImVec2(5,5);
    style.PlotMinSize      = ImVec2(300,225);
}

} // namespaece MyImPlot

// WARNING:
//
// You can use "implot_internal.h" to build custom plotting fuctions or extend ImPlot.
// However, note that forward compatibility of this file is not guaranteed and the
// internal API is subject to change. At some point we hope to bring more of this
// into the public API and expose the necessary building blocks to fully support
// custom plotters. For now, proceed at your own risk!

#include "implot_internal.h"

namespace MyImPlot {

template <typename T>
int BinarySearch(const T* arr, int l, int r, T x) {
    if (r >= l) {
        int mid = l + (r - l) / 2;
        if (arr[mid] == x)
            return mid;
        if (arr[mid] > x)
            return BinarySearch(arr, l, mid - 1, x);
        return BinarySearch(arr, mid + 1, r, x);
    }
    return -1;
}

void PlotCandlestick(const char* label_id, const double* xs, const double* opens, const double* closes, const double* lows, const double* highs, int count, bool tooltip, float width_percent, ImVec4 bullCol, ImVec4 bearCol) {

    // get ImGui window DrawList
    ImDrawList* draw_list = ImPlot::GetPlotDrawList();
    // calc real value width
    double half_width = count > 1 ? (xs[1] - xs[0]) * width_percent : width_percent;

    // custom tool
    if (ImPlot::IsPlotHovered() && tooltip) {
        ImPlotPoint mouse   = ImPlot::GetPlotMousePos();
        mouse.x             = ImPlot::RoundTime(ImPlotTime::FromDouble(mouse.x), ImPlotTimeUnit_Day).ToDouble();
        float  tool_l       = ImPlot::PlotToPixels(mouse.x - half_width * 1.5, mouse.y).x;
        float  tool_r       = ImPlot::PlotToPixels(mouse.x + half_width * 1.5, mouse.y).x;
        float  tool_t       = ImPlot::GetPlotPos().y;
        float  tool_b       = tool_t + ImPlot::GetPlotSize().y;
        ImPlot::PushPlotClipRect();
        draw_list->AddRectFilled(ImVec2(tool_l, tool_t), ImVec2(tool_r, tool_b), IM_COL32(128,128,128,64));
        ImPlot::PopPlotClipRect();
        // find mouse location index
        int idx = BinarySearch(xs, 0, count - 1, mouse.x);
        // render tool tip (won't be affected by plot clip rect)
        if (idx != -1) {
            ImGui::BeginTooltip();
            char buff[32];
            ImPlot::FormatDate(ImPlotTime::FromDouble(xs[idx]),buff,32,ImPlotDateFmt_DayMoYr,ImPlot::GetStyle().UseISO8601);
            ImGui::Text("Day:   %s",  buff);
            ImGui::Text("Open:  $%.2f", opens[idx]);
            ImGui::Text("Close: $%.2f", closes[idx]);
            ImGui::Text("Low:   $%.2f", lows[idx]);
            ImGui::Text("High:  $%.2f", highs[idx]);
            ImGui::EndTooltip();
        }
    }

    // begin plot item
    if (ImPlot::BeginItem(label_id)) {
        // override legend icon color
        ImPlot::GetCurrentItem()->Color = IM_COL32(64,64,64,255);
        // fit data if requested
        if (ImPlot::FitThisFrame()) {
            for (int i = 0; i < count; ++i) {
                ImPlot::FitPoint(ImPlotPoint(xs[i], lows[i]));
                ImPlot::FitPoint(ImPlotPoint(xs[i], highs[i]));
            }
        }
        // render data
        for (int i = 0; i < count; ++i) {
            ImVec2 open_pos  = ImPlot::PlotToPixels(xs[i] - half_width, opens[i]);
            ImVec2 close_pos = ImPlot::PlotToPixels(xs[i] + half_width, closes[i]);
            ImVec2 low_pos   = ImPlot::PlotToPixels(xs[i], lows[i]);
            ImVec2 high_pos  = ImPlot::PlotToPixels(xs[i], highs[i]);
            ImU32 color      = ImGui::GetColorU32(opens[i] > closes[i] ? bearCol : bullCol);
            draw_list->AddLine(low_pos, high_pos, color);
            draw_list->AddRectFilled(open_pos, close_pos, color);
        }

        // end plot item
        ImPlot::EndItem();
    }
}

} // namespace MyImplot


================================================
FILE: Source/External/imgui_tools/implot/implot_internal.h
================================================
// MIT License

// Copyright (c) 2022 Evan Pezent

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// ImPlot v0.14

// You may use this file to debug, understand or extend ImPlot features but we
// don't provide any guarantee of forward compatibility!

//-----------------------------------------------------------------------------
// [SECTION] Header Mess
//-----------------------------------------------------------------------------

#pragma once

#include <time.h>
#include "imgui_internal.h"

#ifndef IMPLOT_VERSION
#error Must include implot.h before implot_internal.h
#endif


// Support for pre-1.84 versions. ImPool's GetSize() -> GetBufSize()
#if (IMGUI_VERSION_NUM < 18303)
#define GetBufSize GetSize
#endif

//-----------------------------------------------------------------------------
// [SECTION] Constants
//-----------------------------------------------------------------------------

// Constants can be changed unless stated otherwise. We may move some of these
// to ImPlotStyleVar_ over time.

// Mimimum allowable timestamp value 01/01/1970 @ 12:00am (UTC) (DO NOT DECREASE THIS)
#define IMPLOT_MIN_TIME  0
// Maximum allowable timestamp value 01/01/3000 @ 12:00am (UTC) (DO NOT INCREASE THIS)
#define IMPLOT_MAX_TIME  32503680000
// Default label format for axis labels
#define IMPLOT_LABEL_FORMAT "%g"
// Max character size for tick labels
#define IMPLOT_LABEL_MAX_SIZE 32

//-----------------------------------------------------------------------------
// [SECTION] Macros
//-----------------------------------------------------------------------------

#define IMPLOT_NUM_X_AXES ImAxis_Y1
#define IMPLOT_NUM_Y_AXES (ImAxis_COUNT - IMPLOT_NUM_X_AXES)

// Split ImU32 color into RGB components [0 255]
#define IM_COL32_SPLIT_RGB(col,r,g,b) \
    ImU32 r = ((col >> IM_COL32_R_SHIFT) & 0xFF); \
    ImU32 g = ((col >> IM_COL32_G_SHIFT) & 0xFF); \
    ImU32 b = ((col >> IM_COL32_B_SHIFT) & 0xFF);

//-----------------------------------------------------------------------------
// [SECTION] Forward Declarations
//-----------------------------------------------------------------------------

struct ImPlotTick;
struct ImPlotAxis;
struct ImPlotAxisColor;
struct ImPlotItem;
struct ImPlotLegend;
struct ImPlotPlot;
struct ImPlotNextPlotData;
struct ImPlotTicker;

//-----------------------------------------------------------------------------
// [SECTION] Context Pointer
//-----------------------------------------------------------------------------

#ifndef GImPlot
extern IMPLOT_API ImPlotContext* GImPlot; // Current implicit context pointer
#endif

//-----------------------------------------------------------------------------
// [SECTION] Generic Helpers
//-----------------------------------------------------------------------------

// Computes the common (base-10) logarithm
static inline float  ImLog10(float x)  { return log10f(x); }
static inline double ImLog10(double x) { return log10(x);  }
static inline float  ImSinh(float x)   { return sinhf(x);  }
static inline double ImSinh(double x)  { return sinh(x);   }
static inline float  ImAsinh(float x)  { return asinhf(x); }
static inline double ImAsinh(double x) { return asinh(x);  }
// Returns true if a flag is set
template <typename TSet, typename TFlag>
static inline bool ImHasFlag(TSet set, TFlag flag) { return (set & flag) == flag; }
// Flips a flag in a flagset
template <typename TSet, typename TFlag>
static inline void ImFlipFlag(TSet& set, TFlag flag) { ImHasFlag(set, flag) ? set &= ~flag : set |= flag; }
// Linearly remaps x from [x0 x1] to [y0 y1].
template <typename T>
static inline T ImRemap(T x, T x0, T x1, T y0, T y1) { return y0 + (x - x0) * (y1 - y0) / (x1 - x0); }
// Linear rempas x from [x0 x1] to [0 1]
template <typename T>
static inline T ImRemap01(T x, T x0, T x1) { return (x - x0) / (x1 - x0); }
// Returns always positive modulo (assumes r != 0)
static inline int ImPosMod(int l, int r) { return (l % r + r) % r; }
// Returns true if val is NAN
static inline bool ImNan(double val) { return isnan(val); }
// Returns true if val is NAN or INFINITY
static inline bool ImNanOrInf(double val) { return !(val >= -DBL_MAX && val <= DBL_MAX) || ImNan(val); }
// Turns NANs to 0s
static inline double ImConstrainNan(double val) { return ImNan(val) ? 0 : val; }
// Turns infinity to floating point maximums
static inline double ImConstrainInf(double val) { return val >= DBL_MAX ?  DBL_MAX : val <= -DBL_MAX ? - DBL_MAX : val; }
// Turns numbers less than or equal to 0 to 0.001 (sort of arbitrary, is there a better way?)
static inline double ImConstrainLog(double val) { return val <= 0 ? 0.001f : val; }
// Turns numbers less than 0 to zero
static inline double ImConstrainTime(double val) { return val < IMPLOT_MIN_TIME ? IMPLOT_MIN_TIME : (val > IMPLOT_MAX_TIME ? IMPLOT_MAX_TIME : val); }
// True if two numbers are approximately equal using units in the last place.
static inline bool ImAlmostEqual(double v1, double v2, int ulp = 2) { return ImAbs(v1-v2) < DBL_EPSILON * ImAbs(v1+v2) * ulp || ImAbs(v1-v2) < DBL_MIN; }
// Finds min value in an unsorted array
template <typename T>
static inline T ImMinArray(const T* values, int count) { T m = values[0]; for (int i = 1; i < count; ++i) { if (values[i] < m) { m = values[i]; } } return m; }
// Finds the max value in an unsorted array
template <typename T>
static inline T ImMaxArray(const T* values, int count) { T m = values[0]; for (int i = 1; i < count; ++i) { if (values[i] > m) { m = values[i]; } } return m; }
// Finds the min and max value in an unsorted array
template <typename T>
static inline void ImMinMaxArray(const T* values, int count, T* min_out, T* max_out) {
    T Min = values[0]; T Max = values[0];
    for (int i = 1; i < count; ++i) {
        if (values[i] < Min) { Min = values[i]; }
        if (values[i] > Max) { Max = values[i]; }
    }
    *min_out = Min; *max_out = Max;
}
// Finds the sim of an array
template <typename T>
static inline T ImSum(const T* values, int count) {
    T sum  = 0;
    for (int i = 0; i < count; ++i)
        sum += values[i];
    return sum;
}
// Finds the mean of an array
template <typename T>
static inline double ImMean(const T* values, int count) {
    double den = 1.0 / count;
    double mu  = 0;
    for (int i = 0; i < count; ++i)
        mu += (double)values[i] * den;
    return mu;
}
// Finds the sample standard deviation of an array
template <typename T>
static inline double ImStdDev(const T* values, int count) {
    double den = 1.0 / (count - 1.0);
    double mu  = ImMean(values, count);
    double x   = 0;
    for (int i = 0; i < count; ++i)
        x += ((double)values[i] - mu) * ((double)values[i] - mu) * den;
    return sqrt(x);
}
// Mix color a and b by factor s in [0 256]
static inline ImU32 ImMixU32(ImU32 a, ImU32 b, ImU32 s) {
#ifdef IMPLOT_MIX64
    const ImU32 af = 256-s;
    const ImU32 bf = s;
    const ImU64 al = (a & 0x00ff00ff) | (((ImU64)(a & 0xff00ff00)) << 24);
    const ImU64 bl = (b & 0x00ff00ff) | (((ImU64)(b & 0xff00ff00)) << 24);
    const ImU64 mix = (al * af + bl * bf);
    return ((mix >> 32) & 0xff00ff00) | ((mix & 0xff00ff00) >> 8);
#else
    const ImU32 af = 256-s;
    const ImU32 bf = s;
    const ImU32 al = (a & 0x00ff00ff);
    const ImU32 ah = (a & 0xff00ff00) >> 8;
    const ImU32 bl = (b & 0x00ff00ff);
    const ImU32 bh = (b & 0xff00ff00) >> 8;
    const ImU32 ml = (al * af + bl * bf);
    const ImU32 mh = (ah * af + bh * bf);
    return (mh & 0xff00ff00) | ((ml & 0xff00ff00) >> 8);
#endif
}

// Lerp across an array of 32-bit collors given t in [0.0 1.0]
static inline ImU32 ImLerpU32(const ImU32* colors, int size, float t) {
    int i1 = (int)((size - 1 ) * t);
    int i2 = i1 + 1;
    if (i2 == size || size == 1)
        return colors[i1];
    float den = 1.0f / (size - 1);
    float t1 = i1 * den;
    float t2 = i2 * den;
    float tr = ImRemap01(t, t1, t2);
    return ImMixU32(colors[i1], colors[i2], (ImU32)(tr*256));
}

// Set alpha channel of 32-bit color from float in range [0.0 1.0]
static inline ImU32 ImAlphaU32(ImU32 col, float alpha) {
    return col & ~((ImU32)((1.0f-alpha)*255)<<IM_COL32_A_SHIFT);
}

// Returns true of two ranges overlap
template <typename T>
static inline bool ImOverlaps(T min_a, T max_a, T min_b, T max_b) {
    return min_a <= max_b && min_b <= max_a;
}

//-----------------------------------------------------------------------------
// [SECTION] ImPlot Enums
//-----------------------------------------------------------------------------

typedef int ImPlotTimeUnit;    // -> enum ImPlotTimeUnit_
typedef int ImPlotDateFmt;     // -> enum ImPlotDateFmt_
typedef int ImPlotTimeFmt;     // -> enum ImPlotTimeFmt_

enum ImPlotTimeUnit_ {
    ImPlotTimeUnit_Us,  // microsecond
    ImPlotTimeUnit_Ms,  // millisecond
    ImPlotTimeUnit_S,   // second
    ImPlotTimeUnit_Min, // minute
    ImPlotTimeUnit_Hr,  // hour
    ImPlotTimeUnit_Day, // day
    ImPlotTimeUnit_Mo,  // month
    ImPlotTimeUnit_Yr,  // year
    ImPlotTimeUnit_COUNT
};

enum ImPlotDateFmt_ {              // default        [ ISO 8601     ]
    ImPlotDateFmt_None = 0,
    ImPlotDateFmt_DayMo,           // 10/3           [ --10-03      ]
    ImPlotDateFmt_DayMoYr,         // 10/3/91        [ 1991-10-03   ]
    ImPlotDateFmt_MoYr,            // Oct 1991       [ 1991-10      ]
    ImPlotDateFmt_Mo,              // Oct            [ --10         ]
    ImPlotDateFmt_Yr               // 1991           [ 1991         ]
};

enum ImPlotTimeFmt_ {              // default        [ 24 Hour Clock ]
    ImPlotTimeFmt_None = 0,
    ImPlotTimeFmt_Us,              // .428 552       [ .428 552     ]
    ImPlotTimeFmt_SUs,             // :29.428 552    [ :29.428 552  ]
    ImPlotTimeFmt_SMs,             // :29.428        [ :29.428      ]
    ImPlotTimeFmt_S,               // :29            [ :29          ]
    ImPlotTimeFmt_MinSMs,          // 21:29.428      [ 21:29.428    ]
    ImPlotTimeFmt_HrMinSMs,        // 7:21:29.428pm  [ 19:21:29.428 ]
    ImPlotTimeFmt_HrMinS,          // 7:21:29pm      [ 19:21:29     ]
    ImPlotTimeFmt_HrMin,           // 7:21pm         [ 19:21        ]
    ImPlotTimeFmt_Hr               // 7pm            [ 19:00        ]
};

//-----------------------------------------------------------------------------
// [SECTION] Callbacks
//-----------------------------------------------------------------------------

typedef void (*ImPlotLocator)(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);

//-----------------------------------------------------------------------------
// [SECTION] Structs
//-----------------------------------------------------------------------------

// Combined date/time format spec
struct ImPlotDateTimeSpec {
    ImPlotDateTimeSpec() {}
    ImPlotDateTimeSpec(ImPlotDateFmt date_fmt, ImPlotTimeFmt time_fmt, bool use_24_hr_clk = false, bool use_iso_8601 = false) {
        Date           = date_fmt;
        Time           = time_fmt;
        UseISO8601     = use_iso_8601;
        Use24HourClock = use_24_hr_clk;
    }
    ImPlotDateFmt Date;
    ImPlotTimeFmt Time;
    bool UseISO8601;
    bool Use24HourClock;
};

// Two part timestamp struct.
struct ImPlotTime {
    time_t S;  // second part
    int    Us; // microsecond part
    ImPlotTime() { S = 0; Us = 0; }
    ImPlotTime(time_t s, int us = 0) { S  = s + us / 1000000; Us = us % 1000000; }
    void RollOver() { S  = S + Us / 1000000;  Us = Us % 1000000; }
    double ToDouble() const { return (double)S + (double)Us / 1000000.0; }
    static ImPlotTime FromDouble(double t) { return ImPlotTime((time_t)t, (int)(t * 1000000 - floor(t) * 1000000)); }
};

static inline ImPlotTime operator+(const ImPlotTime& lhs, const ImPlotTime& rhs)
{ return ImPlotTime(lhs.S + rhs.S, lhs.Us + rhs.Us); }
static inline ImPlotTime operator-(const ImPlotTime& lhs, const ImPlotTime& rhs)
{ return ImPlotTime(lhs.S - rhs.S, lhs.Us - rhs.Us); }
static inline bool operator==(const ImPlotTime& lhs, const ImPlotTime& rhs)
{ return lhs.S == rhs.S && lhs.Us == rhs.Us; }
static inline bool operator<(const ImPlotTime& lhs, const ImPlotTime& rhs)
{ return lhs.S == rhs.S ? lhs.Us < rhs.Us : lhs.S < rhs.S; }
static inline bool operator>(const ImPlotTime& lhs, const ImPlotTime& rhs)
{ return rhs < lhs; }
static inline bool operator<=(const ImPlotTime& lhs, const ImPlotTime& rhs)
{ return lhs < rhs || lhs == rhs; }
static inline bool operator>=(const ImPlotTime& lhs, const ImPlotTime& rhs)
{ return lhs > rhs || lhs == rhs; }

// Colormap data storage
struct ImPlotColormapData {
    ImVector<ImU32> Keys;
    ImVector<int>   KeyCounts;
    ImVector<int>   KeyOffsets;
    ImVector<ImU32> Tables;
    ImVector<int>   TableSizes;
    ImVector<int>   TableOffsets;
    ImGuiTextBuffer Text;
    ImVector<int>   TextOffsets;
    ImVector<bool>  Quals;
    ImGuiStorage    Map;
    int             Count;

    ImPlotColormapData() { Count = 0; }

    int Append(const char* name, const ImU32* keys, int count, bool qual) {
        if (GetIndex(name) != -1)
            return -1;
        KeyOffsets.push_back(Keys.size());
        KeyCounts.push_back(count);
        Keys.reserve(Keys.size()+count);
        for (int i = 0; i < count; ++i)
            Keys.push_back(keys[i]);
        TextOffsets.push_back(Text.size());
        Text.append(name, name + strlen(name) + 1);
        Quals.push_back(qual);
        ImGuiID id = ImHashStr(name);
        int idx = Count++;
        Map.SetInt(id,idx);
        _AppendTable(idx);
        return idx;
    }

    void _AppendTable(ImPlotColormap cmap) {
        int key_count     = GetKeyCount(cmap);
        const ImU32* keys = GetKeys(cmap);
        int off = Tables.size();
        TableOffsets.push_back(off);
        if (IsQual(cmap)) {
            Tables.reserve(key_count);
            for (int i = 0; i < key_count; ++i)
                Tables.push_back(keys[i]);
            TableSizes.push_back(key_count);
        }
        else {
            int max_size = 255 * (key_count-1) + 1;
            Tables.reserve(off + max_size);
            // ImU32 last = keys[0];
            // Tables.push_back(last);
            // int n = 1;
            for (int i = 0; i < key_count-1; ++i) {
                for (int s = 0; s < 255; ++s) {
                    ImU32 a = keys[i];
                    ImU32 b = keys[i+1];
                    ImU32 c = ImMixU32(a,b,s);
                    // if (c != last) {
                        Tables.push_back(c);
                        // last = c;
                        // n++;
                    // }
                }
            }
            ImU32 c = keys[key_count-1];
            // if (c != last) {
                Tables.push_back(c);
                // n++;
            // }
            // TableSizes.push_back(n);
            TableSizes.push_back(max_size);
        }
    }

    void RebuildTables() {
        Tables.resize(0);
        TableSizes.resize(0);
        TableOffsets.resize(0);
        for (int i = 0; i < Count; ++i)
            _AppendTable(i);
    }

    inline bool           IsQual(ImPlotColormap cmap) const                      { return Quals[cmap];                                                }
    inline const char*    GetName(ImPlotColormap cmap) const                     { return cmap < Count ? Text.Buf.Data + TextOffsets[cmap] : nullptr; }
    inline ImPlotColormap GetIndex(const char* name) const                       { ImGuiID key = ImHashStr(name); return Map.GetInt(key,-1);          }

    inline const ImU32*   GetKeys(ImPlotColormap cmap) const                     { return &Keys[KeyOffsets[cmap]];                                    }
    inline int            GetKeyCount(ImPlotColormap cmap) const                 { return KeyCounts[cmap];                                            }
    inline ImU32          GetKeyColor(ImPlotColormap cmap, int idx) const        { return Keys[KeyOffsets[cmap]+idx];                                 }
    inline void           SetKeyColor(ImPlotColormap cmap, int idx, ImU32 value) { Keys[KeyOffsets[cmap]+idx] = value; RebuildTables();               }

    inline const ImU32*   GetTable(ImPlotColormap cmap) const                    { return &Tables[TableOffsets[cmap]];                                }
    inline int            GetTableSize(ImPlotColormap cmap) const                { return TableSizes[cmap];                                           }
    inline ImU32          GetTableColor(ImPlotColormap cmap, int idx) const      { return Tables[TableOffsets[cmap]+idx];                             }

    inline ImU32 LerpTable(ImPlotColormap cmap, float t) const {
        int off = TableOffsets[cmap];
        int siz = TableSizes[cmap];
        int idx = Quals[cmap] ? ImClamp((int)(siz*t),0,siz-1) : (int)((siz - 1) * t + 0.5f);
        return Tables[off + idx];
    }
};

// ImPlotPoint with positive/negative error values
struct ImPlotPointError {
    double X, Y, Neg, Pos;
    ImPlotPointError(double x, double y, double neg, double pos) {
        X = x; Y = y; Neg = neg; Pos = pos;
    }
};

// Interior plot label/annotation
struct ImPlotAnnotation {
    ImVec2 Pos;
    ImVec2 Offset;
    ImU32  ColorBg;
    ImU32  ColorFg;
    int    TextOffset;
    bool   Clamp;
    ImPlotAnnotation() {
        ColorBg = ColorFg = 0;
        TextOffset = 0;
        Clamp = false;
    }
};

// Collection of plot labels
struct ImPlotAnnotationCollection {

    ImVector<ImPlotAnnotation> Annotations;
    ImGuiTextBuffer            TextBuffer;
    int                        Size;

    ImPlotAnnotationCollection() { Reset(); }

    void AppendV(const ImVec2& pos, const ImVec2& off, ImU32 bg, ImU32 fg, bool clamp, const char* fmt,  va_list args) IM_FMTLIST(7) {
        ImPlotAnnotation an;
        an.Pos = pos; an.Offset = off;
        an.ColorBg = bg; an.ColorFg = fg;
        an.TextOffset = TextBuffer.size();
        an.Clamp = clamp;
        Annotations.push_back(an);
        TextBuffer.appendfv(fmt, args);
        const char nul[] = "";
        TextBuffer.append(nul,nul+1);
        Size++;
    }

    void Append(const ImVec2& pos, const ImVec2& off, ImU32 bg, ImU32 fg, bool clamp, const char* fmt,  ...) IM_FMTARGS(7) {
        va_list args;
        va_start(args, fmt);
        AppendV(pos, off, bg, fg, clamp, fmt, args);
        va_end(args);
    }

    const char* GetText(int idx) {
        return TextBuffer.Buf.Data + Annotations[idx].TextOffset;
    }

    void Reset() {
        Annotations.shrink(0);
        TextBuffer.Buf.shrink(0);
        Size = 0;
    }
};

struct ImPlotTag {
    ImAxis Axis;
    double Value;
    ImU32  ColorBg;
    ImU32  ColorFg;
    int    TextOffset;
};

struct ImPlotTagCollection {

    ImVector<ImPlotTag> Tags;
    ImGuiTextBuffer     TextBuffer;
    int                 Size;

    ImPlotTagCollection() { Reset(); }

    void AppendV(ImAxis axis, double value, ImU32 bg, ImU32 fg, const char* fmt, va_list args) IM_FMTLIST(6) {
        ImPlotTag tag;
        tag.Axis = axis;
        tag.Value = value;
        tag.ColorBg = bg;
        tag.ColorFg = fg;
        tag.TextOffset = TextBuffer.size();
        Tags.push_back(tag);
        TextBuffer.appendfv(fmt, args);
        const char nul[] = "";
        TextBuffer.append(nul,nul+1);
        Size++;
    }

    void Append(ImAxis axis, double value, ImU32 bg, ImU32 fg, const char* fmt, ...) IM_FMTARGS(6) {
        va_list args;
        va_start(args, fmt);
        AppendV(axis, value, bg, fg, fmt, args);
        va_end(args);
    }

    const char* GetText(int idx) {
        return TextBuffer.Buf.Data + Tags[idx].TextOffset;
    }

    void Reset() {
        Tags.shrink(0);
        TextBuffer.Buf.shrink(0);
        Size = 0;
    }
};

// Tick mark info
struct ImPlotTick
{
    double PlotPos;
    float  PixelPos;
    ImVec2 LabelSize;
    int    TextOffset;
    bool   Major;
    bool   ShowLabel;
    int    Level;
    int    Idx;

    ImPlotTick(double value, bool major, int level, bool show_label) {
        PixelPos     = 0;
        PlotPos      = value;
        Major        = major;
        ShowLabel    = show_label;
        Level        = level;
        TextOffset   = -1;
    }
};

// Collection of ticks
struct ImPlotTicker {
    ImVector<ImPlotTick> Ticks;
    ImGuiTextBuffer      TextBuffer;
    ImVec2               MaxSize;
    ImVec2               LateSize;
    int                  Levels;

    ImPlotTicker() {
        Reset();
    }

    ImPlotTick& AddTick(double value, bool major, int level, bool show_label, const char* label) {
        ImPlotTick tick(value, major, level, show_label);
        if (show_label && label != nullptr) {
            tick.TextOffset = TextBuffer.size();
            TextBuffer.append(label, label + strlen(label) + 1);
            tick.LabelSize = ImGui::CalcTextSize(TextBuffer.Buf.Data + tick.TextOffset);
        }
        return AddTick(tick);
    }

    ImPlotTick& AddTick(double value, bool major, int level, bool show_label, ImPlotFormatter formatter, void* data) {
        ImPlotTick tick(value, major, level, show_label);
        if (show_label && formatter != nullptr) {
            char buff[IMPLOT_LABEL_MAX_SIZE];
            tick.TextOffset = TextBuffer.size();
            formatter(tick.PlotPos, buff, sizeof(buff), data);
            TextBuffer.append(buff, buff + strlen(buff) + 1);
            tick.LabelSize = ImGui::CalcTextSize(TextBuffer.Buf.Data + tick.TextOffset);
        }
        return AddTick(tick);
    }

    inline ImPlotTick& AddTick(ImPlotTick tick) {
        if (tick.ShowLabel) {
            MaxSize.x     =  tick.LabelSize.x > MaxSize.x ? tick.LabelSize.x : MaxSize.x;
            MaxSize.y     =  tick.LabelSize.y > MaxSize.y ? tick.LabelSize.y : MaxSize.y;
        }
        tick.Idx = Ticks.size();
        Ticks.push_back(tick);
        return Ticks.back();
    }

    const char* GetText(int idx) const {
        return TextBuffer.Buf.Data + Ticks[idx].TextOffset;
    }

    const char* GetText(const ImPlotTick& tick) {
        return GetText(tick.Idx);
    }

    void OverrideSizeLate(const ImVec2& size) {
        LateSize.x = size.x > LateSize.x ? size.x : LateSize.x;
        LateSize.y = size.y > LateSize.y ? size.y : LateSize.y;
    }

    void Reset() {
        Ticks.shrink(0);
        TextBuffer.Buf.shrink(0);
        MaxSize = LateSize;
        LateSize = ImVec2(0,0);
        Levels = 1;
    }

    int TickCount() const {
        return Ticks.Size;
    }
};

// Axis state information that must persist after EndPlot
struct ImPlotAxis
{
    ImGuiID              ID;
    ImPlotAxisFlags      Flags;
    ImPlotAxisFlags      PreviousFlags;
    ImPlotRange          Range;
    ImPlotCond           RangeCond;
    ImPlotScale          Scale;
    ImPlotRange          FitExtents;
    ImPlotAxis*          OrthoAxis;
    ImPlotRange          ConstraintRange;
    ImPlotRange          ConstraintZoom;

    ImPlotTicker         Ticker;
    ImPlotFormatter      Formatter;
    void*                FormatterData;
    char                 FormatSpec[16];
    ImPlotLocator        Locator;

    double*              LinkedMin;
    double*              LinkedMax;

    int                  PickerLevel;
    ImPlotTime           PickerTimeMin, PickerTimeMax;

    ImPlotTransform      TransformForward;
    ImPlotTransform      TransformInverse;
    void*                TransformData;
    float                PixelMin, PixelMax;
    double               ScaleMin, ScaleMax;
    double               ScaleToPixel;
    float                Datum1, Datum2;

    ImRect               HoverRect;
    int                  LabelOffset;
    ImU32                ColorMaj, ColorMin, ColorTick, ColorTxt, ColorBg, ColorHov, ColorAct, ColorHiLi;

    bool                 Enabled;
    bool                 Vertical;
    bool                 FitThisFrame;
    bool                 HasRange;
    bool                 HasFormatSpec;
    bool                 ShowDefaultTicks;
    bool                 Hovered;
    bool                 Held;

    ImPlotAxis() {
        ID               = 0;
        Flags            = PreviousFlags = ImPlotAxisFlags_None;
        Range.Min        = 0;
        Range.Max        = 1;
        Scale            = ImPlotScale_Linear;
        TransformForward = TransformInverse = nullptr;
        TransformData    = nullptr;
        FitExtents.Min   = HUGE_VAL;
        FitExtents.Max   = -HUGE_VAL;
        OrthoAxis        = nullptr;
        ConstraintRange  = ImPlotRange(-INFINITY,INFINITY);
        ConstraintZoom   = ImPlotRange(DBL_MIN,INFINITY);
        LinkedMin        = LinkedMax = nullptr;
        PickerLevel      = 0;
        Datum1           = Datum2 = 0;
        PixelMin         = PixelMax = 0;
        LabelOffset      = -1;
        ColorMaj         = ColorMin = ColorTick = ColorTxt = ColorBg = ColorHov = ColorAct = 0;
        ColorHiLi        = IM_COL32_BLACK_TRANS;
        Formatter        = nullptr;
        FormatterData    = nullptr;
        Locator          = nullptr;
        Enabled          = Hovered = Held = FitThisFrame = HasRange = HasFormatSpec = false;
        ShowDefaultTicks = true;
    }

    inline void Reset() {
        Enabled          = false;
        Scale            = ImPlotScale_Linear;
        TransformForward = TransformInverse = nullptr;
        TransformData    = nullptr;
        LabelOffset      = -1;
        HasFormatSpec    = false;
        Formatter        = nullptr;
        FormatterData    = nullptr;
        Locator          = nullptr;
        ShowDefaultTicks = true;
        FitThisFrame     = false;
        FitExtents.Min   = HUGE_VAL;
        FitExtents.Max   = -HUGE_VAL;
        OrthoAxis        = nullptr;
        ConstraintRange  = ImPlotRange(-INFINITY,INFINITY);
        ConstraintZoom   = ImPlotRange(DBL_MIN,INFINITY);
        Ticker.Reset();
    }

    inline bool SetMin(double _min, bool force=false) {
        if (!force && IsLockedMin())
            return false;
        _min = ImConstrainNan(ImConstrainInf(_min));
        if (_min < ConstraintRange.Min)
            _min = ConstraintRange.Min;
        double z = Range.Max - _min;
        if (z < ConstraintZoom.Min)
            _min = Range.Max - ConstraintZoom.Min;
        if (z > ConstraintZoom.Max)
            _min = Range.Max - ConstraintZoom.Max;
        if (_min >= Range.Max)
            return false;
        Range.Min = _min;
        PickerTimeMin = ImPlotTime::FromDouble(Range.Min);
        UpdateTransformCache();
        return true;
    };

    inline bool SetMax(double _max, bool force=false) {
        if (!force && IsLockedMax())
            return false;
        _max = ImConstrainNan(ImConstrainInf(_max));
        if (_max > ConstraintRange.Max)
            _max = ConstraintRange.Max;
        double z = _max - Range.Min;
        if (z < ConstraintZoom.Min)
            _max = Range.Min + ConstraintZoom.Min;
        if (z > ConstraintZoom.Max)
            _max = Range.Min + ConstraintZoom.Max;
        if (_max <= Range.Min)
            return false;
        Range.Max = _max;
        PickerTimeMax = ImPlotTime::FromDouble(Range.Max);
        UpdateTransformCache();
        return true;
    };

    inline void SetRange(double v1, double v2) {
        Range.Min = ImMin(v1,v2);
        Range.Max = ImMax(v1,v2);
        Constrain();
        PickerTimeMin = ImPlotTime::FromDouble(Range.Min);
        PickerTimeMax = ImPlotTime::FromDouble(Range.Max);
        UpdateTransformCache();
    }

    inline void SetRange(const ImPlotRange& range) {
        SetRange(range.Min, range.Max);
    }

    inline void SetAspect(double unit_per_pix) {
        double new_size = unit_per_pix * PixelSize();
        double delta    = (new_size - Range.Size()) * 0.5;
        if (IsLocked())
            return;
        else if (IsLockedMin() && !IsLockedMax())
            SetRange(Range.Min, Range.Max  + 2*delta);
        else if (!IsLockedMin() && IsLockedMax())
            SetRange(Range.Min - 2*delta, Range.Max);
        else
            SetRange(Range.Min - delta, Range.Max + delta);
    }

    inline float PixelSize() const { return ImAbs(PixelMax - PixelMin); }

    inline double GetAspect() const { return Range.Size() / PixelSize(); }

    inline void Constrain() {
        Range.Min = ImConstrainNan(ImConstrainInf(Range.Min));
        Range.Max = ImConstrainNan(ImConstrainInf(Range.Max));
        if (Range.Min < ConstraintRange.Min)
            Range.Min = ConstraintRange.Min;
        if (Range.Max > ConstraintRange.Max)
            Range.Max = ConstraintRange.Max;
        double z = Range.Size();
        if (z < ConstraintZoom.Min) {
            double delta = (ConstraintZoom.Min - z) * 0.5;
            Range.Min -= delta;
            Range.Max += delta;
        }
        if (z > ConstraintZoom.Max) {
            double delta = (z - ConstraintZoom.Max) * 0.5;
            Range.Min += delta;
            Range.Max -= delta;
        }
        if (Range.Max <= Range.Min)
            Range.Max = Range.Min + DBL_EPSILON;
    }

    inline void UpdateTransformCache() {
        ScaleToPixel = (PixelMax - PixelMin) / Range.Size();
        if (TransformForward != nullptr) {
            ScaleMin = TransformForward(Range.Min, TransformData);
            ScaleMax = TransformForward(Range.Max, TransformData);
        }
        else {
            ScaleMin = Range.Min;
            ScaleMax = Range.Max;
        }
    }

    inline float PlotToPixels(double plt) const {
        if (TransformForward != nullptr) {
            double s = TransformForward(plt, TransformData);
            double t = (s - ScaleMin) / (ScaleMax - ScaleMin);
            plt      = Range.Min + Range.Size() * t;
        }
        return (float)(PixelMin + ScaleToPixel * (plt - Range.Min));
    }


    inline double PixelsToPlot(float pix) const {
        double plt = (pix - PixelMin) / ScaleToPixel + Range.Min;
        if (TransformInverse != nullptr) {
            double t = (plt - Range.Min) / Range.Size();
            double s = t * (ScaleMax - ScaleMin) + ScaleMin;
            plt = TransformInverse(s, TransformData);
        }
        return plt;
    }

    inline void ExtendFit(double v) {
        if (!ImNanOrInf(v) && v >= ConstraintRange.Min && v <= ConstraintRange.Max) {
            FitExtents.Min = v < FitExtents.Min ? v : FitExtents.Min;
            FitExtents.Max = v > FitExtents.Max ? v : FitExtents.Max;
        }
    }

    inline void ExtendFitWith(ImPlotAxis& alt, double v, double v_alt) {
        if (ImHasFlag(Flags, ImPlotAxisFlags_RangeFit) && !alt.Range.Contains(v_alt))
            return;
        if (!ImNanOrInf(v) && v >= ConstraintRange.Min && v <= ConstraintRange.Max) {
            FitExtents.Min = v < FitExtents.Min ? v : FitExtents.Min;
            FitExtents.Max = v > FitExtents.Max ? v : FitExtents.Max;
        }
    }

    inline void ApplyFit(float padding) {
        const double ext_size = FitExtents.Size() * 0.5;
        FitExtents.Min -= ext_size * padding;
        FitExtents.Max += ext_size * padding;
        if (!IsLockedMin() && !ImNanOrInf(FitExtents.Min))
            Range.Min = FitExtents.Min;
        if (!IsLockedMax() && !ImNanOrInf(FitExtents.Max))
            Range.Max = FitExtents.Max;
        if (ImAlmostEqual(Range.Min, Range.Max))  {
            Range.Max += 0.5;
            Range.Min -= 0.5;
        }
        Constrain();
        UpdateTransformCache();
    }

    inline bool HasLabel()          const { return LabelOffset != -1 && !ImHasFlag(Flags, ImPlotAxisFlags_NoLabel);                          }
    inline bool HasGridLines()      const { return !ImHasFlag(Flags, ImPlotAxisFlags_NoGridLines);                                           }
    inline bool HasTickLabels()     const { return !ImHasFlag(Flags, ImPlotAxisFlags_NoTickLabels);                                          }
    inline bool HasTickMarks()      const { return !ImHasFlag(Flags, ImPlotAxisFlags_NoTickMarks);                                           }
    inline bool WillRender()        const { return Enabled && (HasGridLines() || HasTickLabels() || HasTickMarks());                         }
    inline bool IsOpposite()        const { return ImHasFlag(Flags, ImPlotAxisFlags_Opposite);                                               }
    inline bool IsInverted()        const { return ImHasFlag(Flags, ImPlotAxisFlags_Invert);                                                 }
    inline bool IsForeground()      const { return ImHasFlag(Flags, ImPlotAxisFlags_Foreground);                                             }
    inline bool IsAutoFitting()     const { return ImHasFlag(Flags, ImPlotAxisFlags_AutoFit);                                                }
    inline bool CanInitFit()        const { return !ImHasFlag(Flags, ImPlotAxisFlags_NoInitialFit) && !HasRange && !LinkedMin && !LinkedMax; }
    inline bool IsRangeLocked()     const { return HasRange && RangeCond == ImPlotCond_Always;                                               }
    inline bool IsLockedMin()       const { return !Enabled || IsRangeLocked() || ImHasFlag(Flags, ImPlotAxisFlags_LockMin);                 }
    inline bool IsLockedMax()       const { return !Enabled || IsRangeLocked() || ImHasFlag(Flags, ImPlotAxisFlags_LockMax);                 }
    inline bool IsLocked()          const { return IsLockedMin() && IsLockedMax();                                                           }
    inline bool IsInputLockedMin()  const { return IsLockedMin() || IsAutoFitting();                                                         }
    inline bool IsInputLockedMax()  const { return IsLockedMax() || IsAutoFitting();                                                         }
    inline bool IsInputLocked()     const { return IsLocked()    || IsAutoFitting();                                                         }
    inline bool HasMenus()          const { return !ImHasFlag(Flags, ImPlotAxisFlags_NoMenus);                                               }

    inline bool IsPanLocked(bool increasing) {
        if (ImHasFlag(Flags, ImPlotAxisFlags_PanStretch)) {
            return IsInputLocked();
        }
        else {
            if (IsLockedMin() || IsLockedMax() || IsAutoFitting())
                return false;
            if (increasing)
                return Range.Max == ConstraintRange.Max;
            else
                return Range.Min == ConstraintRange.Min;
        }
    }

    void PushLinks() {
        if (LinkedMin) { *LinkedMin = Range.Min; }
        if (LinkedMax) { *LinkedMax = Range.Max; }
    }

    void PullLinks() {
        if (LinkedMin) { SetMin(*LinkedMin,true); }
        if (LinkedMax) { SetMax(*LinkedMax,true); }
    }
};

// Align plots group data
struct ImPlotAlignmentData {
    bool  Vertical;
    float PadA;
    float PadB;
    float PadAMax;
    float PadBMax;
    ImPlotAlignmentData() {
        Vertical    = true;
        PadA = PadB = PadAMax = PadBMax = 0;
    }
    void Begin() { PadAMax = PadBMax = 0; }
    void Update(float& pad_a, float& pad_b, float& delta_a, float& delta_b) {
        float bak_a = pad_a; float bak_b = pad_b;
        if (PadAMax < pad_a) { PadAMax = pad_a; }
        if (PadBMax < pad_b) { PadBMax = pad_b; }
        if (pad_a < PadA)    { pad_a = PadA; delta_a = pad_a - bak_a; } else { delta_a = 0; }
        if (pad_b < PadB)    { pad_b = PadB; delta_b = pad_b - bak_b; } else { delta_b = 0; }
    }
    void End()   { PadA = PadAMax; PadB = PadBMax;      }
    void Reset() { PadA = PadB = PadAMax = PadBMax = 0; }
};

// State information for Plot items
struct ImPlotItem
{
    ImGuiID      ID;
    ImU32        Color;
    ImRect       LegendHoverRect;
    int          NameOffset;
    bool         Show;
    bool         LegendHovered;
    bool         SeenThisFrame;

    ImPlotItem() {
        ID            = 0;
        Color         = IM_COL32_WHITE;
        NameOffset    = -1;
        Show          = true;
        SeenThisFrame = false;
        LegendHovered = false;
    }

    ~ImPlotItem() { ID = 0; }
};

// Holds Legend state
struct ImPlotLegend
{
    ImPlotLegendFlags Flags;
    ImPlotLegendFlags PreviousFlags;
    ImPlotLocation    Location;
    ImPlotLocation    PreviousLocation;
    ImVector<int>     Indices;
    ImGuiTextBuffer   Labels;
    ImRect            Rect;
    bool              Hovered;
    bool              Held;
    bool              CanGoInside;

    ImPlotLegend() {
        Flags        = PreviousFlags = ImPlotLegendFlags_None;
        CanGoInside  = true;
        Hovered      = Held = false;
        Location     = PreviousLocation = ImPlotLocation_NorthWest;
    }

    void Reset() { Indices.shrink(0); Labels.Buf.shrink(0); }
};

// Holds Items and Legend data
struct ImPlotItemGroup
{
    ImGuiID            ID;
    ImPlotLegend       Legend;
    ImPool<ImPlotItem> ItemPool;
    int                ColormapIdx;

    ImPlotItemGroup() { ID = 0; ColormapIdx = 0; }

    int         GetItemCount() const             { return ItemPool.GetBufSize();                                 }
    ImGuiID     GetItemID(const char*  label_id) { return ImGui::GetID(label_id); /* GetIDWithSeed */            }
    ImPlotItem* GetItem(ImGuiID id)              { return ItemPool.GetByKey(id);                                 }
    ImPlotItem* GetItem(const char* label_id)    { return GetItem(GetItemID(label_id));                          }
    ImPlotItem* GetOrAddItem(ImGuiID id)         { return ItemPool.GetOrAddByKey(id);                            }
    ImPlotItem* GetItemByIndex(int i)            { return ItemPool.GetByIndex(i);                                }
    int         GetItemIndex(ImPlotItem* item)   { return ItemPool.GetIndex(item);                               }
    int         GetLegendCount() const           { return Legend.Indices.size();                                 }
    ImPlotItem* GetLegendItem(int i)             { return ItemPool.GetByIndex(Legend.Indices[i]);                }
    const char* GetLegendLabel(int i)            { return Legend.Labels.Buf.Data + GetLegendItem(i)->NameOffset; }
    void        Reset()                          { ItemPool.Clear(); Legend.Reset(); ColormapIdx = 0;            }
};

// Holds Plot state information that must persist after EndPlot
struct ImPlotPlot
{
    ImGuiID              ID;
    ImPlotFlags          Flags;
    ImPlotFlags          PreviousFlags;
    ImPlotLocation       MouseTextLocation;
    ImPlotMouseTextFlags MouseTextFlags;
    ImPlotAxis           Axes[ImAxis_COUNT];
    ImGuiTextBuffer      TextBuffer;
    ImPlotItemGroup      Items;
    ImAxis               CurrentX;
    ImAxis               CurrentY;
    ImRect               FrameRect;
    ImRect               CanvasRect;
    ImRect               PlotRect;
    ImRect               AxesRect;
    ImRect               SelectRect;
    ImVec2               SelectStart;
    int                  TitleOffset;
    bool                 JustCreated;
    bool                 Initialized;
    bool                 SetupLocked;
    bool                 FitThisFrame;
    bool                 Hovered;
    bool                 Held;
    bool                 Selecting;
    bool                 Selected;
    bool                 ContextLocked;

    ImPlotPlot() {
        Flags             = PreviousFlags = ImPlotFlags_None;
        for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i)
            XAxis(i).Vertical = false;
        for (int i = 0; i < IMPLOT_NUM_Y_AXES; ++i)
            YAxis(i).Vertical = true;
        SelectStart       = ImVec2(0,0);
        CurrentX          = ImAxis_X1;
        CurrentY          = ImAxis_Y1;
        MouseTextLocation  = ImPlotLocation_South | ImPlotLocation_East;
        MouseTextFlags     = ImPlotMouseTextFlags_None;
        TitleOffset       = -1;
        JustCreated       = true;
        Initialized = SetupLocked = FitThisFrame = false;
        Hovered = Held = Selected = Selecting = ContextLocked = false;
    }

    inline bool IsInputLocked() const {
        for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i) {
            if (!XAxis(i).IsInputLocked())
                return false;
        }
        for (int i = 0; i < IMPLOT_NUM_Y_AXES; ++i) {
            if (!YAxis(i).IsInputLocked())
                return false;
        }
        return true;
    }

    inline void ClearTextBuffer() { TextBuffer.Buf.shrink(0); }

    inline void SetTitle(const char* title) {
        if (title && ImGui::FindRenderedTextEnd(title, nullptr) != title) {
            TitleOffset = TextBuffer.size();
            TextBuffer.append(title, title + strlen(title) + 1);
        }
        else {
            TitleOffset = -1;
        }
    }
    inline bool HasTitle() const { return TitleOffset != -1 && !ImHasFlag(Flags, ImPlotFlags_NoTitle); }
    inline const char* GetTitle() const { return TextBuffer.Buf.Data + TitleOffset; }

    inline       ImPlotAxis& XAxis(int i)       { return Axes[ImAxis_X1 + i]; }
    inline const ImPlotAxis& XAxis(int i) const { return Axes[ImAxis_X1 + i]; }
    inline       ImPlotAxis& YAxis(int i)       { return Axes[ImAxis_Y1 + i]; }
    inline const ImPlotAxis& YAxis(int i) const { return Axes[ImAxis_Y1 + i]; }

    inline int EnabledAxesX() {
        int cnt = 0;
        for (int i = 0; i < IMPLOT_NUM_X_AXES; ++i)
            cnt += XAxis(i).Enabled;
        return cnt;
    }

    inline int EnabledAxesY() {
        int cnt = 0;
        for (int i = 0; i < IMPLOT_NUM_Y_AXES; ++i)
            cnt += YAxis(i).Enabled;
        return cnt;
    }

    inline void SetAxisLabel(ImPlotAxis& axis, const char* label) {
        if (label && ImGui::FindRenderedTextEnd(label, nullptr) != label) {
            axis.LabelOffset = TextBuffer.size();
            TextBuffer.append(label, label + strlen(label) + 1);
        }
        else {
            axis.LabelOffset = -1;
        }
    }

    inline const char* GetAxisLabel(const ImPlotAxis& axis) const { return TextBuffer.Buf.Data + axis.LabelOffset; }
};

// Holds subplot data that must persist after EndSubplot
struct ImPlotSubplot {
    ImGuiID                       ID;
    ImPlotSubplotFlags            Flags;
    ImPlotSubplotFlags            PreviousFlags;
    ImPlotItemGroup               Items;
    int                           Rows;
    int                           Cols;
    int                           CurrentIdx;
    ImRect                        FrameRect;
    ImRect                        GridRect;
    ImVec2                        CellSize;
    ImVector<ImPlotAlignmentData> RowAlignmentData;
    ImVector<ImPlotAlignmentData> ColAlignmentData;
    ImVector<float>               RowRatios;
    ImVector<float>               ColRatios;
    ImVector<ImPlotRange>         RowLinkData;
    ImVector<ImPlotRange>         ColLinkData;
    float                         TempSizes[2];
    bool                          FrameHovered;
    bool                          HasTitle;

    ImPlotSubplot() {
        ID                          = 0;
        Flags = PreviousFlags       = ImPlotSubplotFlags_None;
        Rows = Cols = CurrentIdx    = 0;
        FrameHovered                = false;
        Items.Legend.Location       = ImPlotLocation_North;
        Items.Legend.Flags          = ImPlotLegendFlags_Horizontal|ImPlotLegendFlags_Outside;
        Items.Legend.CanGoInside    = false;
        TempSizes[0] = TempSizes[1] = 0;
        FrameHovered                = false;
        HasTitle                    = false;
    }
};

// Temporary data storage for upcoming plot
struct ImPlotNextPlotData
{
    ImPlotCond  RangeCond[ImAxis_COUNT];
    ImPlotRange Range[ImAxis_COUNT];
    bool        HasRange[ImAxis_COUNT];
    bool        Fit[ImAxis_COUNT];
    double*     LinkedMin[ImAxis_COUNT];
    double*     LinkedMax[ImAxis_COUNT];

    ImPlotNextPlotData() { Reset(); }

    void Reset() {
        for (int i = 0; i < ImAxis_COUNT; ++i) {
            HasRange[i]                 = false;
            Fit[i]                      = false;
            LinkedMin[i] = LinkedMax[i] = nullptr;
        }
    }

};

// Temporary data storage for upcoming item
struct ImPlotNextItemData {
    ImVec4          Colors[5]; // ImPlotCol_Line, ImPlotCol_Fill, ImPlotCol_MarkerOutline, ImPlotCol_MarkerFill, ImPlotCol_ErrorBar
    float           LineWeight;
    ImPlotMarker    Marker;
    float           MarkerSize;
    float           MarkerWeight;
    float           FillAlpha;
    float           ErrorBarSize;
    float           ErrorBarWeight;
    float           DigitalBitHeight;
    float           DigitalBitGap;
    bool            RenderLine;
    bool            RenderFill;
    bool            RenderMarkerLine;
    bool            RenderMarkerFill;
    bool            HasHidden;
    bool            Hidden;
    ImPlotCond      HiddenCond;
    ImPlotNextItemData() { Reset(); }
    void Reset() {
        for (int i = 0; i < 5; ++i)
            Colors[i] = IMPLOT_AUTO_COL;
        LineWeight    = MarkerSize = MarkerWeight = FillAlpha = ErrorBarSize = ErrorBarWeight = DigitalBitHeight = DigitalBitGap = IMPLOT_AUTO;
        Marker        = IMPLOT_AUTO;
        HasHidden     = Hidden = false;
    }
};

// Holds state information that must persist between calls to BeginPlot()/EndPlot()
struct ImPlotContext {
    // Plot States
    ImPool<ImPlotPlot>    Plots;
    ImPool<ImPlotSubplot> Subplots;
    ImPlotPlot*           CurrentPlot;
    ImPlotSubplot*        CurrentSubplot;
    ImPlotItemGroup*      CurrentItems;
    ImPlotItem*           CurrentItem;
    ImPlotItem*           PreviousItem;

    // Tick Marks and Labels
    ImPlotTicker CTicker;

    // Annotation and Tabs
    ImPlotAnnotationCollection Annotations;
    ImPlotTagCollection        Tags;

    // Flags
    bool ChildWindowMade;

    // Style and Colormaps
    ImPlotStyle                 Style;
    ImVector<ImGuiColorMod>     ColorModifiers;
    ImVector<ImGuiStyleMod>     StyleModifiers;
    ImPlotColormapData          ColormapData;
    ImVector<ImPlotColormap>    ColormapModifiers;

    // Time
    tm Tm;

    // Temp data for general use
    ImVector<double>   TempDouble1, TempDouble2;
    ImVector<int>      TempInt1;

    // Misc
    int                DigitalPlotItemCnt;
    int                DigitalPlotOffset;
    ImPlotNextPlotData NextPlotData;
    ImPlotNextItemData NextItemData;
    ImPlotInputMap     InputMap;
    bool               OpenContextThisFrame;
    ImGuiTextBuffer    MousePosStringBuilder;
    ImPlotItemGroup*   SortItems;

    // Align plots
    ImPool<ImPlotAlignmentData> AlignmentData;
    ImPlotAlignmentData*        CurrentAlignmentH;
    ImPlotAlignmentData*        CurrentAlignmentV;
};

//-----------------------------------------------------------------------------
// [SECTION] Internal API
// No guarantee of forward compatibility here!
//-----------------------------------------------------------------------------

namespace ImPlot {

//-----------------------------------------------------------------------------
// [SECTION] Context Utils
//-----------------------------------------------------------------------------

// Initializes an ImPlotContext
IMPLOT_API void Initialize(ImPlotContext* ctx);
// Resets an ImPlot context for the next call to BeginPlot
IMPLOT_API void ResetCtxForNextPlot(ImPlotContext* ctx);
// Resets an ImPlot context for the next call to BeginAlignedPlots
IMPLOT_API void ResetCtxForNextAlignedPlots(ImPlotContext* ctx);
// Resets an ImPlot context for the next call to BeginSubplot
IMPLOT_API void ResetCtxForNextSubplot(ImPlotContext* ctx);

//-----------------------------------------------------------------------------
// [SECTION] Plot Utils
//-----------------------------------------------------------------------------

// Gets a plot from the current ImPlotContext
IMPLOT_API ImPlotPlot* GetPlot(const char* title);
// Gets the current plot from the current ImPlotContext
IMPLOT_API ImPlotPlot* GetCurrentPlot();
// Busts the cache for every plot in the current context
IMPLOT_API void BustPlotCache();

// Shows a plot's context menu.
IMPLOT_API void ShowPlotContextMenu(ImPlotPlot& plot);

//-----------------------------------------------------------------------------
// [SECTION] Setup Utils
//-----------------------------------------------------------------------------

// Lock Setup and call SetupFinish if necessary.
static inline void SetupLock() {
    ImPlotContext& gp = *GImPlot;
    if (!gp.CurrentPlot->SetupLocked)
        SetupFinish();
    gp.CurrentPlot->SetupLocked = true;
}

//-----------------------------------------------------------------------------
// [SECTION] Subplot Utils
//-----------------------------------------------------------------------------

// Advances to next subplot
IMPLOT_API void SubplotNextCell();

// Shows a subplot's context menu.
IMPLOT_API void ShowSubplotsContextMenu(ImPlotSubplot& subplot);

//-----------------------------------------------------------------------------
// [SECTION] Item Utils
//-----------------------------------------------------------------------------

// Begins a new item. Returns false if the item should not be plotted. Pushes PlotClipRect.
IMPLOT_API bool BeginItem(const char* label_id, ImPlotItemFlags flags=0, ImPlotCol recolor_from=IMPLOT_AUTO);

// Same as above but with fitting functionality.
template <typename _Fitter>
bool BeginItemEx(const char* label_id, const _Fitter& fitter, ImPlotItemFlags flags=0, ImPlotCol recolor_from=IMPLOT_AUTO) {
    if (BeginItem(label_id, flags, recolor_from)) {
        ImPlotPlot& plot = *GetCurrentPlot();
        if (plot.FitThisFrame && !ImHasFlag(flags, ImPlotItemFlags_NoFit))
            fitter.Fit(plot.Axes[plot.CurrentX], plot.Axes[plot.CurrentY]);
        return true;
    }
    return false;
}

// Ends an item (call only if BeginItem returns true). Pops PlotClipRect.
IMPLOT_API void EndItem();

// Register or get an existing item from the current plot.
IMPLOT_API ImPlotItem* RegisterOrGetItem(const char* label_id, ImPlotItemFlags flags, bool* just_created = nullptr);
// Get a plot item from the current plot.
IMPLOT_API ImPlotItem* GetItem(const char* label_id);
// Gets the current item.
IMPLOT_API ImPlotItem* GetCurrentItem();
// Busts the cache for every item for every plot in the current context.
IMPLOT_API void BustItemCache();

//-----------------------------------------------------------------------------
// [SECTION] Axis Utils
//-----------------------------------------------------------------------------

// Returns true if any enabled axis is locked from user input.
static inline bool AnyAxesInputLocked(ImPlotAxis* axes, int count) {
    for (int i = 0; i < count; ++i) {
        if (axes[i].Enabled && axes[i].IsInputLocked())
            return true;
    }
    return false;
}

// Returns true if all enabled axes are locked from user input.
static inline bool AllAxesInputLocked(ImPlotAxis* axes, int count) {
    for (int i = 0; i < count; ++i) {
        if (axes[i].Enabled && !axes[i].IsInputLocked())
            return false;
    }
    return true;
}

static inline bool AnyAxesHeld(ImPlotAxis* axes, int count) {
    for (int i = 0; i < count; ++i) {
        if (axes[i].Enabled && axes[i].Held)
            return true;
    }
    return false;
}

static inline bool AnyAxesHovered(ImPlotAxis* axes, int count) {
    for (int i = 0; i < count; ++i) {
        if (axes[i].Enabled && axes[i].Hovered)
            return true;
    }
    return false;
}

// Returns true if the user has requested data to be fit.
static inline bool FitThisFrame() {
    return GImPlot->CurrentPlot->FitThisFrame;
}

// Extends the current plot's axes so that it encompasses a vertical line at x
static inline void FitPointX(double x) {
    ImPlotPlot& plot   = *GetCurrentPlot();
    ImPlotAxis& x_axis = plot.Axes[plot.CurrentX];
    x_axis.ExtendFit(x);
}

// Extends the current plot's axes so that it encompasses a horizontal line at y
static inline void FitPointY(double y) {
    ImPlotPlot& plot   = *GetCurrentPlot();
    ImPlotAxis& y_axis = plot.Axes[plot.CurrentY];
    y_axis.ExtendFit(y);
}

// Extends the current plot's axes so that it encompasses point p
static inline void FitPoint(const ImPlotPoint& p) {
    ImPlotPlot& plot   = *GetCurrentPlot();
    ImPlotAxis& x_axis = plot.Axes[plot.CurrentX];
    ImPlotAxis& y_axis = plot.Axes[plot.CurrentY];
    x_axis.ExtendFitWith(y_axis, p.x, p.y);
    y_axis.ExtendFitWith(x_axis, p.y, p.x);
}

// Returns true if two ranges overlap
static inline bool RangesOverlap(const ImPlotRange& r1, const ImPlotRange& r2)
{ return r1.Min <= r2.Max && r2.Min <= r1.Max; }

// Shows an axis's context menu.
IMPLOT_API void ShowAxisContextMenu(ImPlotAxis& axis, ImPlotAxis* equal_axis, bool time_allowed = false);

//-----------------------------------------------------------------------------
// [SECTION] Legend Utils
//-----------------------------------------------------------------------------

// Gets the position of an inner rect that is located inside of an outer rect according to an ImPlotLocation and padding amount.
IMPLOT_API ImVec2 GetLocationPos(const ImRect& outer_rect, const ImVec2& inner_size, ImPlotLocation location, const ImVec2& pad = ImVec2(0,0));
// Calculates the bounding box size of a legend
IMPLOT_API ImVec2 CalcLegendSize(ImPlotItemGroup& items, const ImVec2& pad, const ImVec2& spacing, bool vertical);
// Renders legend entries into a bounding box
IMPLOT_API bool ShowLegendEntries(ImPlotItemGroup& items, const ImRect& legend_bb, bool interactable, const ImVec2& pad, const ImVec2& spacing, bool vertical, ImDrawList& DrawList);
// Shows an alternate legend for the plot identified by #title_id, outside of the plot frame (can be called before or after of Begin/EndPlot but must occur in the same ImGui window!).
IMPLOT_API void ShowAltLegend(const char* title_id, bool vertical = true, const ImVec2 size = ImVec2(0,0), bool interactable = true);
// Shows an legends's context menu.
IMPLOT_API bool ShowLegendContextMenu(ImPlotLegend& legend, bool visible);

//-----------------------------------------------------------------------------
// [SECTION] Label Utils
//-----------------------------------------------------------------------------

// Create a a string label for a an axis value
IMPLOT_API void LabelAxisValue(const ImPlotAxis& axis, double value, char* buff, int size, bool round = false);

//-----------------------------------------------------------------------------
// [SECTION] Styling Utils
//-----------------------------------------------------------------------------

// Get styling data for next item (call between Begin/EndItem)
static inline const ImPlotNextItemData& GetItemData() { return GImPlot->NextItemData; }

// Returns true if a color is set to be automatically determined
static inline bool IsColorAuto(const ImVec4& col) { return col.w == -1; }
// Returns true if a style color is set to be automatically determined
static inline bool IsColorAuto(ImPlotCol idx) { return IsColorAuto(GImPlot->Style.Colors[idx]); }
// Returns the automatically deduced style color
IMPLOT_API ImVec4 GetAutoColor(ImPlotCol idx);

// Returns the style color whether it is automatic or custom set
static inline ImVec4 GetStyleColorVec4(ImPlotCol idx) { return IsColorAuto(idx) ? GetAutoColor(idx) : GImPlot->Style.Colors[idx]; }
static inline ImU32  GetStyleColorU32(ImPlotCol idx)  { return ImGui::ColorConvertFloat4ToU32(GetStyleColorVec4(idx)); }

// Draws vertical text. The position is the bottom left of the text rect.
IMPLOT_API void AddTextVertical(ImDrawList *DrawList, ImVec2 pos, ImU32 col, const char* text_begin, const char* text_end = nullptr);
// Draws multiline horizontal text centered.
IMPLOT_API void AddTextCentered(ImDrawList* DrawList, ImVec2 top_center, ImU32 col, const char* text_begin, const char* text_end = nullptr);
// Calculates the size of vertical text
static inline ImVec2 CalcTextSizeVertical(const char *text) {
    ImVec2 sz = ImGui::CalcTextSize(text);
    return ImVec2(sz.y, sz.x);
}
// Returns white or black text given background color
static inline ImU32 CalcTextColor(const ImVec4& bg) { return (bg.x * 0.299f + bg.y * 0.587f + bg.z * 0.114f) > 0.5f ? IM_COL32_BLACK : IM_COL32_WHITE; }
static inline ImU32 CalcTextColor(ImU32 bg)         { return CalcTextColor(ImGui::ColorConvertU32ToFloat4(bg)); }
// Lightens or darkens a color for hover
static inline ImU32 CalcHoverColor(ImU32 col)       {  return ImMixU32(col, CalcTextColor(col), 32); }

// Clamps a label position so that it fits a rect defined by Min/Max
static inline ImVec2 ClampLabelPos(ImVec2 pos, const ImVec2& size, const ImVec2& Min, const ImVec2& Max) {
    if (pos.x < Min.x)              pos.x = Min.x;
    if (pos.y < Min.y)              pos.y = Min.y;
    if ((pos.x + size.x) > Max.x)   pos.x = Max.x - size.x;
    if ((pos.y + size.y) > Max.y)   pos.y = Max.y - size.y;
    return pos;
}

// Returns a color from the Color map given an index >= 0 (modulo will be performed).
IMPLOT_API ImU32  GetColormapColorU32(int idx, ImPlotColormap cmap);
// Returns the next unused colormap color and advances the colormap. Can be used to skip colors if desired.
IMPLOT_API ImU32  NextColormapColorU32();
// Linearly interpolates a color from the current colormap given t between 0 and 1.
IMPLOT_API ImU32  SampleColormapU32(float t, ImPlotColormap cmap);

// Render a colormap bar
IMPLOT_API void RenderColorBar(const ImU32* colors, int size, ImDrawList& DrawList, const ImRect& bounds, bool vert, bool reversed, bool continuous);

//-----------------------------------------------------------------------------
// [SECTION] Math and Misc Utils
//-----------------------------------------------------------------------------

// Rounds x to powers of 2,5 and 10 for generating axis labels (from Graphics Gems 1 Chapter 11.2)
IMPLOT_API double NiceNum(double x, bool round);
// Computes order of magnitude of double.
static inline int OrderOfMagnitude(double val) { return val == 0 ? 0 : (int)(floor(log10(fabs(val)))); }
// Returns the precision required for a order of magnitude.
static inline int OrderToPrecision(int order) { return order > 0 ? 0 : 1 - order; }
// Returns a floating point precision to use given a value
static inline int Precision(double val) { return OrderToPrecision(OrderOfMagnitude(val)); }
// Round a value to a given precision
static inline double RoundTo(double val, int prec) { double p = pow(10,(double)prec); return floor(val*p+0.5)/p; }

// Returns the intersection point of two lines A and B (assumes they are not parallel!)
static inline ImVec2 Intersection(const ImVec2& a1, const ImVec2& a2, const ImVec2& b1, const ImVec2& b2) {
    float v1 = (a1.x * a2.y - a1.y * a2.x);  float v2 = (b1.x * b2.y - b1.y * b2.x);
    float v3 = ((a1.x - a2.x) * (b1.y - b2.y) - (a1.y - a2.y) * (b1.x - b2.x));
    return ImVec2((v1 * (b1.x - b2.x) - v2 * (a1.x - a2.x)) / v3, (v1 * (b1.y - b2.y) - v2 * (a1.y - a2.y)) / v3);
}

// Fills a buffer with n samples linear interpolated from vmin to vmax
template <typename T>
void FillRange(ImVector<T>& buffer, int n, T vmin, T vmax) {
    buffer.resize(n);
    T step = (vmax - vmin) / (n - 1);
    for (int i = 0; i < n; ++i) {
        buffer[i] = vmin + i * step;
    }
}

// Calculate histogram bin counts and widths
template <typename T>
static inline void CalculateBins(const T* values, int count, ImPlotBin meth, const ImPlotRange& range, int& bins_out, double& width_out) {
    switch (meth) {
        case ImPlotBin_Sqrt:
            bins_out  = (int)ceil(sqrt(count));
            break;
        case ImPlotBin_Sturges:
            bins_out  = (int)ceil(1.0 + log2(count));
            break;
        case ImPlotBin_Rice:
            bins_out  = (int)ceil(2 * cbrt(count));
            break;
        case ImPlotBin_Scott:
            width_out = 3.49 * ImStdDev(values, count) / cbrt(count);
            bins_out  = (int)round(range.Size() / width_out);
            break;
    }
    width_out = range.Size() / bins_out;
}

//-----------------------------------------------------------------------------
// Time Utils
//-----------------------------------------------------------------------------

// Returns true if year is leap year (366 days long)
static inline bool IsLeapYear(int year) {
    return  year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
}
// Returns the number of days in a month, accounting for Feb. leap years. #month is zero indexed.
static inline int GetDaysInMonth(int year, int month) {
    static const int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    return  days[month] + (int)(month == 1 && IsLeapYear(year));
}

// Make a UNIX timestamp from a tm struct expressed in UTC time (i.e. GMT timezone).
IMPLOT_API ImPlotTime MkGmtTime(struct tm *ptm);
// Make a tm struct expressed in UTC time (i.e. GMT timezone) from a UNIX timestamp.
IMPLOT_API tm* GetGmtTime(const ImPlotTime& t, tm* ptm);

// Make a UNIX timestamp from a tm struct expressed in local time.
IMPLOT_API ImPlotTime MkLocTime(struct tm *ptm);
// Make a tm struct expressed in local time from a UNIX timestamp.
IMPLOT_API tm* GetLocTime(const ImPlotTime& t, tm* ptm);

// NB: The following functions only work if there is a current ImPlotContext because the
// internal tm struct is owned by the context! They are aware of ImPlotStyle.UseLocalTime.

// Make a timestamp from time components.
// year[1970-3000], month[0-11], day[1-31], hour[0-23], min[0-59], sec[0-59], us[0,999999]
IMPLOT_API ImPlotTime MakeTime(int year, int month = 0, int day = 1, int hour = 0, int min = 0, int sec = 0, int us = 0);
// Get year component from timestamp [1970-3000]
IMPLOT_API int GetYear(const ImPlotTime& t);

// Adds or subtracts time from a timestamp. #count > 0 to add, < 0 to subtract.
IMPLOT_API ImPlotTime AddTime(const ImPlotTime& t, ImPlotTimeUnit unit, int count);
// Rounds a timestamp down to nearest unit.
IMPLOT_API ImPlotTime FloorTime(const ImPlotTime& t, ImPlotTimeUnit unit);
// Rounds a timestamp up to the nearest unit.
IMPLOT_API ImPlotTime CeilTime(const ImPlotTime& t, ImPlotTimeUnit unit);
// Rounds a timestamp up or down to the nearest unit.
IMPLOT_API ImPlotTime RoundTime(const ImPlotTime& t, ImPlotTimeUnit unit);
// Combines the date of one timestamp with the time-of-day of another timestamp.
IMPLOT_API ImPlotTime CombineDateTime(const ImPlotTime& date_part, const ImPlotTime& time_part);

// Formats the time part of timestamp t into a buffer according to #fmt
IMPLOT_API int FormatTime(const ImPlotTime& t, char* buffer, int size, ImPlotTimeFmt fmt, bool use_24_hr_clk);
// Formats the date part of timestamp t into a buffer according to #fmt
IMPLOT_API int FormatDate(const ImPlotTime& t, char* buffer, int size, ImPlotDateFmt fmt, bool use_iso_8601);
// Formats the time and/or date parts of a timestamp t into a buffer according to #fmt
IMPLOT_API int FormatDateTime(const ImPlotTime& t, char* buffer, int size, ImPlotDateTimeSpec fmt);

// Shows a date picker widget block (year/month/day).
// #level = 0 for day, 1 for month, 2 for year. Modified by user interaction.
// #t will be set when a day is clicked and the function will return true.
// #t1 and #t2 are optional dates to highlight.
IMPLOT_API bool ShowDatePicker(const char* id, int* level, ImPlotTime* t, const ImPlotTime* t1 = nullptr, const ImPlotTime* t2 = nullptr);
// Shows a time picker widget block (hour/min/sec).
// #t will be set when a new hour, minute, or sec is selected or am/pm is toggled, and the function will return true.
IMPLOT_API bool ShowTimePicker(const char* id, ImPlotTime* t);

//-----------------------------------------------------------------------------
// [SECTION] Transforms
//-----------------------------------------------------------------------------

static inline double TransformForward_Log10(double v, void*) {
    v = v <= 0.0 ? DBL_MIN : v;
    return ImLog10(v);
}

static inline double TransformInverse_Log10(double v, void*) {
    return ImPow(10, v);
}

static inline double TransformForward_SymLog(double v, void*) {
    return 2.0 * ImAsinh(v / 2.0);
}

static inline double TransformInverse_SymLog(double v, void*) {
    return 2.0 * ImSinh(v / 2.0);
}

static inline double TransformForward_Logit(double v, void*) {
    v = ImClamp(v, DBL_MIN, 1.0 - DBL_EPSILON);
    return ImLog10(v / (1 - v));
}

static inline double TransformInverse_Logit(double v, void*) {
    return 1.0 / (1.0 + ImPow(10,-v));
}

//-----------------------------------------------------------------------------
// [SECTION] Formatters
//-----------------------------------------------------------------------------

static inline int Formatter_Default(double value, char* buff, int size, void* data) {
    char* fmt = (char*)data;
    return ImFormatString(buff, size, fmt, value);
}

static inline int Formatter_Logit(double value, char* buff, int size, void*) {
    if (value == 0.5)
        return ImFormatString(buff,size,"1/2");
    else if (value < 0.5)
        return ImFormatString(buff,size,"%g", value);
    else
        return ImFormatString(buff,size,"1 - %g", 1 - value);
}

struct Formatter_Time_Data {
    ImPlotTime Time;
    ImPlotDateTimeSpec Spec;
    ImPlotFormatter UserFormatter;
    void* UserFormatterData;
};

static inline int Formatter_Time(double, char* buff, int size, void* data) {
    Formatter_Time_Data* ftd = (Formatter_Time_Data*)data;
    return FormatDateTime(ftd->Time, buff, size, ftd->Spec);
}

//------------------------------------------------------------------------------
// [SECTION] Locator
//------------------------------------------------------------------------------

void Locator_Default(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);
void Locator_Time(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);
void Locator_Log10(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);
void Locator_SymLog(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);

} // namespace ImPlot


================================================
FILE: Source/External/imgui_tools/implot/implot_items.cpp
================================================
// MIT License

// Copyright (c) 2020 Evan Pezent

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// ImPlot v0.14

#define IMGUI_DEFINE_MATH_OPERATORS
#include "implot.h"
#include "implot_internal.h"

//-----------------------------------------------------------------------------
// [SECTION] Macros and Defines
//-----------------------------------------------------------------------------

#define SQRT_1_2 0.70710678118f
#define SQRT_3_2 0.86602540378f

#ifndef IMPLOT_NO_FORCE_INLINE
    #ifdef _MSC_VER
        #define IMPLOT_INLINE __forceinline
    #elif defined(__GNUC__)
        #define IMPLOT_INLINE inline __attribute__((__always_inline__))
    #elif defined(__CLANG__)
        #if __has_attribute(__always_inline__)
            #define IMPLOT_INLINE inline __attribute__((__always_inline__))
        #else
            #define IMPLOT_INLINE inline
        #endif
    #else
        #define IMPLOT_INLINE inline
    #endif
#else
    #define IMPLOT_INLINE inline
#endif

#if defined __SSE__ || defined __x86_64__ || defined _M_X64
#ifndef IMGUI_ENABLE_SSE
#include <immintrin.h>
#endif
static IMPLOT_INLINE float  ImInvSqrt(float x) { return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x))); }
#else
static IMPLOT_INLINE float  ImInvSqrt(float x) { return 1.0f / sqrtf(x); }
#endif

#define IMPLOT_NORMALIZE2F_OVER_ZERO(VX,VY) do { float d2 = VX*VX + VY*VY; if (d2 > 0.0f) { float inv_len = ImInvSqrt(d2); VX *= inv_len; VY *= inv_len; } } while (0)

// Support for pre-1.82 versions. Users on 1.82+ can use 0 (default) flags to mean "all corners" but in order to support older versions we are more explicit.
#if (IMGUI_VERSION_NUM < 18102) && !defined(ImDrawFlags_RoundCornersAll)
#define ImDrawFlags_RoundCornersAll ImDrawCornerFlags_All
#endif

//-----------------------------------------------------------------------------
// [SECTION] Template instantiation utility
//-----------------------------------------------------------------------------

// By default, templates are instantiated for `float`, `double`, and for the following integer types, which are defined in imgui.h:
//     signed char         ImS8;   // 8-bit signed integer
//     unsigned char       ImU8;   // 8-bit unsigned integer
//     signed short        ImS16;  // 16-bit signed integer
//     unsigned short      ImU16;  // 16-bit unsigned integer
//     signed int          ImS32;  // 32-bit signed integer == int
//     unsigned int        ImU32;  // 32-bit unsigned integer
//     signed   long long  ImS64;  // 64-bit signed integer
//     unsigned long long  ImU64;  // 64-bit unsigned integer
// (note: this list does *not* include `long`, `unsigned long` and `long double`)
//
// You can customize the supported types by defining IMPLOT_CUSTOM_NUMERIC_TYPES at compile time to define your own type list.
//    As an example, you could use the compile time define given by the line below in order to support only float and double.
//        -DIMPLOT_CUSTOM_NUMERIC_TYPES="(float)(double)"
//    In order to support all known C++ types, use:
//        -DIMPLOT_CUSTOM_NUMERIC_TYPES="(signed char)(unsigned char)(signed short)(unsigned short)(signed int)(unsigned int)(signed long)(unsigned long)(signed long long)(unsigned long long)(float)(double)(long double)"

#ifdef IMPLOT_CUSTOM_NUMERIC_TYPES
    #define IMPLOT_NUMERIC_TYPES IMPLOT_CUSTOM_NUMERIC_TYPES
#else
    #define IMPLOT_NUMERIC_TYPES (ImS8)(ImU8)(ImS16)(ImU16)(ImS32)(ImU32)(ImS64)(ImU64)(float)(double)
#endif

// CALL_INSTANTIATE_FOR_NUMERIC_TYPES will duplicate the template instantion code `INSTANTIATE_MACRO(T)` on supported types.
#define _CAT(x, y) _CAT_(x, y)
#define _CAT_(x,y) x ## y
#define _INSTANTIATE_FOR_NUMERIC_TYPES(chain) _CAT(_INSTANTIATE_FOR_NUMERIC_TYPES_1 chain, _END)
#define _INSTANTIATE_FOR_NUMERIC_TYPES_1(T) INSTANTIATE_MACRO(T); _INSTANTIATE_FOR_NUMERIC_TYPES_2
#define _INSTANTIATE_FOR_NUMERIC_TYPES_2(T) INSTANTIATE_MACRO(T); _INSTANTIATE_FOR_NUMERIC_TYPES_1
#define _INSTANTIATE_FOR_NUMERIC_TYPES_1_END
#define _INSTANTIATE_FOR_NUMERIC_TYPES_2_END
#define CALL_INSTANTIATE_FOR_NUMERIC_TYPES() _INSTANTIATE_FOR_NUMERIC_TYPES(IMPLOT_NUMERIC_TYPES);

namespace ImPlot {

//-----------------------------------------------------------------------------
// [SECTION] Utils
//-----------------------------------------------------------------------------

// Calc maximum index size of ImDrawIdx
template <typename T>
struct MaxIdx { static const unsigned int Value; };
template <> const unsigned int MaxIdx<unsigned short>::Value = 65535;
template <> const unsigned int MaxIdx<unsigned int>::Value   = 4294967295;

IMPLOT_INLINE void GetLineRenderProps(const ImDrawList& draw_list, float& half_weight, ImVec2& tex_uv0, ImVec2& tex_uv1) {
    const bool aa = ImHasFlag(draw_list.Flags, ImDrawListFlags_AntiAliasedLines) &&
                    ImHasFlag(draw_list.Flags, ImDrawListFlags_AntiAliasedLinesUseTex);
    if (aa) {
        ImVec4 tex_uvs = draw_list._Data->TexUvLines[(int)(half_weight*2)];
        tex_uv0 = ImVec2(tex_uvs.x, tex_uvs.y);
        tex_uv1 = ImVec2(tex_uvs.z, tex_uvs.w);
        half_weight += 1;
    }
    else {
        tex_uv0 = tex_uv1 = draw_list._Data->TexUvWhitePixel;
    }
}

IMPLOT_INLINE void PrimLine(ImDrawList& draw_list, const ImVec2& P1, const ImVec2& P2, float half_weight, ImU32 col, const ImVec2& tex_uv0, const ImVec2 tex_uv1) {
    float dx = P2.x - P1.x;
    float dy = P2.y - P1.y;
    IMPLOT_NORMALIZE2F_OVER_ZERO(dx, dy);
    dx *= half_weight;
    dy *= half_weight;
    draw_list._VtxWritePtr[0].pos.x = P1.x + dy;
    draw_list._VtxWritePtr[0].pos.y = P1.y - dx;
    draw_list._VtxWritePtr[0].uv    = tex_uv0;
    draw_list._VtxWritePtr[0].col   = col;
    draw_list._VtxWritePtr[1].pos.x = P2.x + dy;
    draw_list._VtxWritePtr[1].pos.y = P2.y - dx;
    draw_list._VtxWritePtr[1].uv    = tex_uv0;
    draw_list._VtxWritePtr[1].col   = col;
    draw_list._VtxWritePtr[2].pos.x = P2.x - dy;
    draw_list._VtxWritePtr[2].pos.y = P2.y + dx;
    draw_list._VtxWritePtr[2].uv    = tex_uv1;
    draw_list._VtxWritePtr[2].col   = col;
    draw_list._VtxWritePtr[3].pos.x = P1.x - dy;
    draw_list._VtxWritePtr[3].pos.y = P1.y + dx;
    draw_list._VtxWritePtr[3].uv    = tex_uv1;
    draw_list._VtxWritePtr[3].col   = col;
    draw_list._VtxWritePtr += 4;
    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 1);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 2);
    draw_list._IdxWritePtr[3] = (ImDrawIdx)(draw_list._VtxCurrentIdx);
    draw_list._IdxWritePtr[4] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 2);
    draw_list._IdxWritePtr[5] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 3);
    draw_list._IdxWritePtr += 6;
    draw_list._VtxCurrentIdx += 4;
}

IMPLOT_INLINE void PrimRectFill(ImDrawList& draw_list, const ImVec2& Pmin, const ImVec2& Pmax, ImU32 col, const ImVec2& uv) {
    draw_list._VtxWritePtr[0].pos   = Pmin;
    draw_list._VtxWritePtr[0].uv    = uv;
    draw_list._VtxWritePtr[0].col   = col;
    draw_list._VtxWritePtr[1].pos   = Pmax;
    draw_list._VtxWritePtr[1].uv    = uv;
    draw_list._VtxWritePtr[1].col   = col;
    draw_list._VtxWritePtr[2].pos.x = Pmin.x;
    draw_list._VtxWritePtr[2].pos.y = Pmax.y;
    draw_list._VtxWritePtr[2].uv    = uv;
    draw_list._VtxWritePtr[2].col   = col;
    draw_list._VtxWritePtr[3].pos.x = Pmax.x;
    draw_list._VtxWritePtr[3].pos.y = Pmin.y;
    draw_list._VtxWritePtr[3].uv    = uv;
    draw_list._VtxWritePtr[3].col   = col;
    draw_list._VtxWritePtr += 4;
    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 1);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 2);
    draw_list._IdxWritePtr[3] = (ImDrawIdx)(draw_list._VtxCurrentIdx);
    draw_list._IdxWritePtr[4] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 1);
    draw_list._IdxWritePtr[5] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 3);
    draw_list._IdxWritePtr += 6;
    draw_list._VtxCurrentIdx += 4;
}

IMPLOT_INLINE void PrimRectLine(ImDrawList& draw_list, const ImVec2& Pmin, const ImVec2& Pmax, float weight, ImU32 col, const ImVec2& uv) {

    draw_list._VtxWritePtr[0].pos.x = Pmin.x;
    draw_list._VtxWritePtr[0].pos.y = Pmin.y;
    draw_list._VtxWritePtr[0].uv    = uv;
    draw_list._VtxWritePtr[0].col   = col;

    draw_list._VtxWritePtr[1].pos.x = Pmin.x;
    draw_list._VtxWritePtr[1].pos.y = Pmax.y;
    draw_list._VtxWritePtr[1].uv    = uv;
    draw_list._VtxWritePtr[1].col   = col;

    draw_list._VtxWritePtr[2].pos.x = Pmax.x;
    draw_list._VtxWritePtr[2].pos.y = Pmax.y;
    draw_list._VtxWritePtr[2].uv    = uv;
    draw_list._VtxWritePtr[2].col   = col;

    draw_list._VtxWritePtr[3].pos.x = Pmax.x;
    draw_list._VtxWritePtr[3].pos.y = Pmin.y;
    draw_list._VtxWritePtr[3].uv    = uv;
    draw_list._VtxWritePtr[3].col   = col;

    draw_list._VtxWritePtr[4].pos.x = Pmin.x + weight;
    draw_list._VtxWritePtr[4].pos.y = Pmin.y + weight;
    draw_list._VtxWritePtr[4].uv    = uv;
    draw_list._VtxWritePtr[4].col   = col;

    draw_list._VtxWritePtr[5].pos.x = Pmin.x + weight;
    draw_list._VtxWritePtr[5].pos.y = Pmax.y - weight;
    draw_list._VtxWritePtr[5].uv    = uv;
    draw_list._VtxWritePtr[5].col   = col;

    draw_list._VtxWritePtr[6].pos.x = Pmax.x - weight;
    draw_list._VtxWritePtr[6].pos.y = Pmax.y - weight;
    draw_list._VtxWritePtr[6].uv    = uv;
    draw_list._VtxWritePtr[6].col   = col;

    draw_list._VtxWritePtr[7].pos.x = Pmax.x - weight;
    draw_list._VtxWritePtr[7].pos.y = Pmin.y + weight;
    draw_list._VtxWritePtr[7].uv    = uv;
    draw_list._VtxWritePtr[7].col   = col;

    draw_list._VtxWritePtr += 8;

    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 0);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 1);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 5);
    draw_list._IdxWritePtr += 3;

    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 0);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 5);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 4);
    draw_list._IdxWritePtr += 3;

    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 1);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 2);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 6);
    draw_list._IdxWritePtr += 3;

    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 1);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 6);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 5);
    draw_list._IdxWritePtr += 3;

    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 2);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 3);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 7);
    draw_list._IdxWritePtr += 3;

    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 2);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 7);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 6);
    draw_list._IdxWritePtr += 3;

    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 3);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 0);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 4);
    draw_list._IdxWritePtr += 3;

    draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 3);
    draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 4);
    draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 7);
    draw_list._IdxWritePtr += 3;

    draw_list._VtxCurrentIdx += 8;
}


//-----------------------------------------------------------------------------
// [SECTION] Item Utils
//-----------------------------------------------------------------------------

ImPlotItem* RegisterOrGetItem(const char* label_id, ImPlotItemFlags flags, bool* just_created) {
    ImPlotContext& gp = *GImPlot;
    ImPlotItemGroup& Items = *gp.CurrentItems;
    ImGuiID id = Items.GetItemID(label_id);
    if (just_created != nullptr)
        *just_created = Items.GetItem(id) == nullptr;
    ImPlotItem* item = Items.GetOrAddItem(id);
    if (item->SeenThisFrame)
        return item;
    item->SeenThisFrame = true;
    int idx = Items.GetItemIndex(item);
    item->ID = id;
    if (!ImHasFlag(flags, ImPlotItemFlags_NoLegend) && ImGui::FindRenderedTextEnd(label_id, nullptr) != label_id) {
        Items.Legend.Indices.push_back(idx);
        item->NameOffset = Items.Legend.Labels.size();
        Items.Legend.Labels.append(label_id, label_id + strlen(label_id) + 1);
    }
    else {
        item->Show = true;
    }
    return item;
}

ImPlotItem* GetItem(const char* label_id) {
    ImPlotContext& gp = *GImPlot;
    return gp.CurrentItems->GetItem(label_id);
}

bool IsItemHidden(const char* label_id) {
    ImPlotItem* item = GetItem(label_id);
    return item != nullptr && !item->Show;
}

ImPlotItem* GetCurrentItem() {
    ImPlotContext& gp = *GImPlot;
    return gp.CurrentItem;
}

void SetNextLineStyle(const ImVec4& col, float weight) {
    ImPlotContext& gp = *GImPlot;
    gp.NextItemData.Colors[ImPlotCol_Line] = col;
    gp.NextItemData.LineWeight             = weight;
}

void SetNextFillStyle(const ImVec4& col, float alpha) {
    ImPlotContext& gp = *GImPlot;
    gp.NextItemData.Colors[ImPlotCol_Fill] = col;
    gp.NextItemData.FillAlpha              = alpha;
}

void SetNextMarkerStyle(ImPlotMarker marker, float size, const ImVec4& fill, float weight, const ImVec4& outline) {
    ImPlotContext& gp = *GImPlot;
    gp.NextItemData.Marker                          = marker;
    gp.NextItemData.Colors[ImPlotCol_MarkerFill]    = fill;
    gp.NextItemData.MarkerSize                      = size;
    gp.NextItemData.Colors[ImPlotCol_MarkerOutline] = outline;
    gp.NextItemData.MarkerWeight                    = weight;
}

void SetNextErrorBarStyle(const ImVec4& col, float size, float weight) {
    ImPlotContext& gp = *GImPlot;
    gp.NextItemData.Colors[ImPlotCol_ErrorBar] = col;
    gp.NextItemData.ErrorBarSize               = size;
    gp.NextItemData.ErrorBarWeight             = weight;
}

ImVec4 GetLastItemColor() {
    ImPlotContext& gp = *GImPlot;
    if (gp.PreviousItem)
        return ImGui::ColorConvertU32ToFloat4(gp.PreviousItem->Color);
    return ImVec4();
}

void BustItemCache() {
    ImPlotContext& gp = *GImPlot;
    for (int p = 0; p < gp.Plots.GetBufSize(); ++p) {
        ImPlotPlot& plot = *gp.Plots.GetByIndex(p);
        plot.Items.Reset();
    }
    for (int p = 0; p < gp.Subplots.GetBufSize(); ++p) {
        ImPlotSubplot& subplot = *gp.Subplots.GetByIndex(p);
        subplot.Items.Reset();
    }
}

void BustColorCache(const char* plot_title_id) {
    ImPlotContext& gp = *GImPlot;
    if (plot_title_id == nullptr) {
        BustItemCache();
    }
    else {
        ImGuiID id = ImGui::GetCurrentWindow()->GetID(plot_title_id);
        ImPlotPlot* plot = gp.Plots.GetByKey(id);
        if (plot != nullptr)
            plot->Items.Reset();
        else {
            ImPlotSubplot* subplot = gp.Subplots.GetByKey(id);
            if (subplot != nullptr)
                subplot->Items.Reset();
        }
    }
}

//-----------------------------------------------------------------------------
// [SECTION] BeginItem / EndItem
//-----------------------------------------------------------------------------

static const float ITEM_HIGHLIGHT_LINE_SCALE = 2.0f;
static const float ITEM_HIGHLIGHT_MARK_SCALE = 1.25f;

// Begins a new item. Returns false if the item should not be plotted.
bool BeginItem(const char* label_id, ImPlotItemFlags flags, ImPlotCol recolor_from) {
    ImPlotContext& gp = *GImPlot;
    IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "PlotX() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    bool just_created;
    ImPlotItem* item = RegisterOrGetItem(label_id, flags, &just_created);
    // set current item
    gp.CurrentItem = item;
    ImPlotNextItemData& s = gp.NextItemData;
    // set/override item color
    if (recolor_from != -1) {
        if (!IsColorAuto(s.Colors[recolor_from]))
            item->Color = ImGui::ColorConvertFloat4ToU32(s.Colors[recolor_from]);
        else if (!IsColorAuto(gp.Style.Colors[recolor_from]))
            item->Color = ImGui::ColorConvertFloat4ToU32(gp.Style.Colors[recolor_from]);
        else if (just_created)
            item->Color = NextColormapColorU32();
    }
    else if (just_created) {
        item->Color = NextColormapColorU32();
    }
    // hide/show item
    if (gp.NextItemData.HasHidden) {
        if (just_created || gp.NextItemData.HiddenCond == ImGuiCond_Always)
            item->Show = !gp.NextItemData.Hidden;
    }
    if (!item->Show) {
        // reset next item data
        gp.NextItemData.Reset();
        gp.PreviousItem = item;
        gp.CurrentItem  = nullptr;
        return false;
    }
    else {
        ImVec4 item_color = ImGui::ColorConvertU32ToFloat4(item->Color);
        // stage next item colors
        s.Colors[ImPlotCol_Line]           = IsColorAuto(s.Colors[ImPlotCol_Line])          ? ( IsColorAuto(ImPlotCol_Line)           ? item_color                 : gp.Style.Colors[ImPlotCol_Line]          ) : s.Colors[ImPlotCol_Line];
        s.Colors[ImPlotCol_Fill]           = IsColorAuto(s.Colors[ImPlotCol_Fill])          ? ( IsColorAuto(ImPlotCol_Fill)           ? item_color                 : gp.Style.Colors[ImPlotCol_Fill]          ) : s.Colors[ImPlotCol_Fill];
        s.Colors[ImPlotCol_MarkerOutline]  = IsColorAuto(s.Colors[ImPlotCol_MarkerOutline]) ? ( IsColorAuto(ImPlotCol_MarkerOutline)  ? s.Colors[ImPlotCol_Line]   : gp.Style.Colors[ImPlotCol_MarkerOutline] ) : s.Colors[ImPlotCol_MarkerOutline];
        s.Colors[ImPlotCol_MarkerFill]     = IsColorAuto(s.Colors[ImPlotCol_MarkerFill])    ? ( IsColorAuto(ImPlotCol_MarkerFill)     ? s.Colors[ImPlotCol_Line]   : gp.Style.Colors[ImPlotCol_MarkerFill]    ) : s.Colors[ImPlotCol_MarkerFill];
        s.Colors[ImPlotCol_ErrorBar]       = IsColorAuto(s.Colors[ImPlotCol_ErrorBar])      ? ( GetStyleColorVec4(ImPlotCol_ErrorBar)                                                                         ) : s.Colors[ImPlotCol_ErrorBar];
        // stage next item style vars
        s.LineWeight         = s.LineWeight       < 0 ? gp.Style.LineWeight       : s.LineWeight;
        s.Marker             = s.Marker           < 0 ? gp.Style.Marker           : s.Marker;
        s.MarkerSize         = s.MarkerSize       < 0 ? gp.Style.MarkerSize       : s.MarkerSize;
        s.MarkerWeight       = s.MarkerWeight     < 0 ? gp.Style.MarkerWeight     : s.MarkerWeight;
        s.FillAlpha          = s.FillAlpha        < 0 ? gp.Style.FillAlpha        : s.FillAlpha;
        s.ErrorBarSize       = s.ErrorBarSize     < 0 ? gp.Style.ErrorBarSize     : s.ErrorBarSize;
        s.ErrorBarWeight     = s.ErrorBarWeight   < 0 ? gp.Style.ErrorBarWeight   : s.ErrorBarWeight;
        s.DigitalBitHeight   = s.DigitalBitHeight < 0 ? gp.Style.DigitalBitHeight : s.DigitalBitHeight;
        s.DigitalBitGap      = s.DigitalBitGap    < 0 ? gp.Style.DigitalBitGap    : s.DigitalBitGap;
        // apply alpha modifier(s)
        s.Colors[ImPlotCol_Fill].w       *= s.FillAlpha;
        s.Colors[ImPlotCol_MarkerFill].w *= s.FillAlpha; // TODO: this should be separate, if it at all
        // apply highlight mods
        if (item->LegendHovered) {
            if (!ImHasFlag(gp.CurrentItems->Legend.Flags, ImPlotLegendFlags_NoHighlightItem)) {
                s.LineWeight   *= ITEM_HIGHLIGHT_LINE_SCALE;
                s.MarkerSize   *= ITEM_HIGHLIGHT_MARK_SCALE;
                s.MarkerWeight *= ITEM_HIGHLIGHT_LINE_SCALE;
                // TODO: how to highlight fills?
            }
            if (!ImHasFlag(gp.CurrentItems->Legend.Flags, ImPlotLegendFlags_NoHighlightAxis)) {
                if (gp.CurrentPlot->EnabledAxesX() > 1)
                    gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentX].ColorHiLi = item->Color;
                if (gp.CurrentPlot->EnabledAxesY() > 1)
                    gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentY].ColorHiLi = item->Color;
            }
        }
        // set render flags
        s.RenderLine       = s.Colors[ImPlotCol_Line].w          > 0 && s.LineWeight > 0;
        s.RenderFill       = s.Colors[ImPlotCol_Fill].w          > 0;
        s.RenderMarkerFill = s.Colors[ImPlotCol_MarkerFill].w    > 0;
        s.RenderMarkerLine = s.Colors[ImPlotCol_MarkerOutline].w > 0 && s.MarkerWeight > 0;
        // push rendering clip rect
        PushPlotClipRect();
        return true;
    }
}

// Ends an item (call only if BeginItem returns true)
void EndItem() {
    ImPlotContext& gp = *GImPlot;
    // pop rendering clip rect
    PopPlotClipRect();
    // reset next item data
    gp.NextItemData.Reset();
    // set current item
    gp.PreviousItem = gp.CurrentItem;
    gp.CurrentItem  = nullptr;
}

//-----------------------------------------------------------------------------
// [SECTION] Indexers
//-----------------------------------------------------------------------------

template <typename T>
IMPLOT_INLINE T IndexData(const T* data, int idx, int count, int offset, int stride) {
    const int s = ((offset == 0) << 0) | ((stride == sizeof(T)) << 1);
    switch (s) {
        case 3 : return data[idx];
        case 2 : return data[(offset + idx) % count];
        case 1 : return *(const T*)(const void*)((const unsigned char*)data + (size_t)((idx) ) * stride);
        case 0 : return *(const T*)(const void*)((const unsigned char*)data + (size_t)((offset + idx) % count) * stride);
        default: return T(0);
    }
}

template <typename T>
struct IndexerIdx {
    IndexerIdx(const T* data, int count, int offset = 0, int stride = sizeof(T)) :
        Data(data),
        Count(count),
        Offset(count ? ImPosMod(offset, count) : 0),
        Stride(stride)
    { }
    template <typename I> IMPLOT_INLINE double operator()(I idx) const {
        return (double)IndexData(Data, idx, Count, Offset, Stride);
    }
    const T* Data;
    int Count;
    int Offset;
    int Stride;
};

template <typename _Indexer1, typename _Indexer2>
struct IndexerAdd {
    IndexerAdd(const _Indexer1& indexer1, const _Indexer2& indexer2, double scale1 = 1, double scale2 = 1)
        : Indexer1(indexer1),
          Indexer2(indexer2),
          Scale1(scale1),
          Scale2(scale2),
          Count(ImMin(Indexer1.Count, Indexer2.Count))
    { }
    template <typename I> IMPLOT_INLINE double operator()(I idx) const {
        return Scale1 * Indexer1(idx) + Scale2 * Indexer2(idx);
    }
    const _Indexer1& Indexer1;
    const _Indexer2& Indexer2;
    double Scale1;
    double Scale2;
    int Count;
};

struct IndexerLin {
    IndexerLin(double m, double b) : M(m), B(b) { }
    template <typename I> IMPLOT_INLINE double operator()(I idx) const {
        return M * idx + B;
    }
    const double M;
    const double B;
};

struct IndexerConst {
    IndexerConst(double ref) : Ref(ref) { }
    template <typename I> IMPLOT_INLINE double operator()(I) const { return Ref; }
    const double Ref;
};

//-----------------------------------------------------------------------------
// [SECTION] Getters
//-----------------------------------------------------------------------------

template <typename _IndexerX, typename _IndexerY>
struct GetterXY {
    GetterXY(_IndexerX x, _IndexerY y, int count) : IndxerX(x), IndxerY(y), Count(count) { }
    template <typename I> IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
        return ImPlotPoint(IndxerX(idx),IndxerY(idx));
    }
    const _IndexerX IndxerX;
    const _IndexerY IndxerY;
    const int Count;
};

/// Interprets a user's function pointer as ImPlotPoints
struct GetterFuncPtr {
    GetterFuncPtr(ImPlotGetter getter, void* data, int count) :
        Getter(getter),
        Data(data),
        Count(count)
    { }
    template <typename I> IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
        return Getter(idx, Data);
    }
    ImPlotGetter Getter;
    void* const Data;
    const int Count;
};

template <typename _Getter>
struct GetterOverrideX {
    GetterOverrideX(_Getter getter, double x) : Getter(getter), X(x), Count(getter.Count) { }
    template <typename I> IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
        ImPlotPoint p = Getter(idx);
        p.x = X;
        return p;
    }
    const _Getter Getter;
    const double X;
    const int Count;
};

template <typename _Getter>
struct GetterOverrideY {
    GetterOverrideY(_Getter getter, double y) : Getter(getter), Y(y), Count(getter.Count) { }
    template <typename I> IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
        ImPlotPoint p = Getter(idx);
        p.y = Y;
        return p;
    }
    const _Getter Getter;
    const double Y;
    const int Count;
};

template <typename _Getter>
struct GetterLoop {
    GetterLoop(_Getter getter) : Getter(getter), Count(getter.Count + 1) { }
    template <typename I> IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
        idx = idx % (Count - 1);
        return Getter(idx);
    }
    const _Getter Getter;
    const int Count;
};

template <typename T>
struct GetterError {
    GetterError(const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) :
        Xs(xs),
        Ys(ys),
        Neg(neg),
        Pos(pos),
        Count(count),
        Offset(count ? ImPosMod(offset, count) : 0),
        Stride(stride)
    { }
    template <typename I> IMPLOT_INLINE ImPlotPointError operator()(I idx) const {
        return ImPlotPointError((double)IndexData(Xs,  idx, Count, Offset, Stride),
                                (double)IndexData(Ys,  idx, Count, Offset, Stride),
                                (double)IndexData(Neg, idx, Count, Offset, Stride),
                                (double)IndexData(Pos, idx, Count, Offset, Stride));
    }
    const T* const Xs;
    const T* const Ys;
    const T* const Neg;
    const T* const Pos;
    const int Count;
    const int Offset;
    const int Stride;
};

//-----------------------------------------------------------------------------
// [SECTION] Fitters
//-----------------------------------------------------------------------------

template <typename _Getter1>
struct Fitter1 {
    Fitter1(const _Getter1& getter) : Getter(getter) { }
    void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
        for (int i = 0; i < Getter.Count; ++i) {
            ImPlotPoint p = Getter(i);
            x_axis.ExtendFitWith(y_axis, p.x, p.y);
            y_axis.ExtendFitWith(x_axis, p.y, p.x);
        }
    }
    const _Getter1& Getter;
};

template <typename _Getter1>
struct FitterX {
    FitterX(const _Getter1& getter) : Getter(getter) { }
    void Fit(ImPlotAxis& x_axis, ImPlotAxis&) const {
        for (int i = 0; i < Getter.Count; ++i) {
            ImPlotPoint p = Getter(i);
            x_axis.ExtendFit(p.x);
        }
    }
    const _Getter1& Getter;
};

template <typename _Getter1>
struct FitterY {
    FitterY(const _Getter1& getter) : Getter(getter) { }
    void Fit(ImPlotAxis&, ImPlotAxis& y_axis) const {
        for (int i = 0; i < Getter.Count; ++i) {
            ImPlotPoint p = Getter(i);
            y_axis.ExtendFit(p.y);
        }
    }
    const _Getter1& Getter;
};

template <typename _Getter1, typename _Getter2>
struct Fitter2 {
    Fitter2(const _Getter1& getter1, const _Getter2& getter2) : Getter1(getter1), Getter2(getter2) { }
    void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
        for (int i = 0; i < Getter1.Count; ++i) {
            ImPlotPoint p = Getter1(i);
            x_axis.ExtendFitWith(y_axis, p.x, p.y);
            y_axis.ExtendFitWith(x_axis, p.y, p.x);
        }
        for (int i = 0; i < Getter2.Count; ++i) {
            ImPlotPoint p = Getter2(i);
            x_axis.ExtendFitWith(y_axis, p.x, p.y);
            y_axis.ExtendFitWith(x_axis, p.y, p.x);
        }
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
};

template <typename _Getter1, typename _Getter2>
struct FitterBarV {
    FitterBarV(const _Getter1& getter1, const _Getter2& getter2, double width) :
        Getter1(getter1),
        Getter2(getter2),
        HalfWidth(width*0.5)
    { }
    void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
        int count = ImMin(Getter1.Count, Getter2.Count);
        for (int i = 0; i < count; ++i) {
            ImPlotPoint p1 = Getter1(i); p1.x -= HalfWidth;
            ImPlotPoint p2 = Getter2(i); p2.x += HalfWidth;
            x_axis.ExtendFitWith(y_axis, p1.x, p1.y);
            y_axis.ExtendFitWith(x_axis, p1.y, p1.x);
            x_axis.ExtendFitWith(y_axis, p2.x, p2.y);
            y_axis.ExtendFitWith(x_axis, p2.y, p2.x);
        }
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
    const double    HalfWidth;
};

template <typename _Getter1, typename _Getter2>
struct FitterBarH {
    FitterBarH(const _Getter1& getter1, const _Getter2& getter2, double height) :
        Getter1(getter1),
        Getter2(getter2),
        HalfHeight(height*0.5)
    { }
    void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
        int count = ImMin(Getter1.Count, Getter2.Count);
        for (int i = 0; i < count; ++i) {
            ImPlotPoint p1 = Getter1(i); p1.y -= HalfHeight;
            ImPlotPoint p2 = Getter2(i); p2.y += HalfHeight;
            x_axis.ExtendFitWith(y_axis, p1.x, p1.y);
            y_axis.ExtendFitWith(x_axis, p1.y, p1.x);
            x_axis.ExtendFitWith(y_axis, p2.x, p2.y);
            y_axis.ExtendFitWith(x_axis, p2.y, p2.x);
        }
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
    const double    HalfHeight;
};

struct FitterRect {
    FitterRect(const ImPlotPoint& pmin, const ImPlotPoint& pmax) :
        Pmin(pmin),
        Pmax(pmax)
    { }
    FitterRect(const ImPlotRect& rect) :
        FitterRect(rect.Min(), rect.Max())
    { }
    void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
        x_axis.ExtendFitWith(y_axis, Pmin.x, Pmin.y);
        y_axis.ExtendFitWith(x_axis, Pmin.y, Pmin.x);
        x_axis.ExtendFitWith(y_axis, Pmax.x, Pmax.y);
        y_axis.ExtendFitWith(x_axis, Pmax.y, Pmax.x);
    }
    const ImPlotPoint Pmin;
    const ImPlotPoint Pmax;
};

//-----------------------------------------------------------------------------
// [SECTION] Transformers
//-----------------------------------------------------------------------------

struct Transformer1 {
    Transformer1(double pixMin, double pltMin, double pltMax, double m, double scaMin, double scaMax, ImPlotTransform fwd, void* data) :
        ScaMin(scaMin),
        ScaMax(scaMax),
        PltMin(pltMin),
        PltMax(pltMax),
        PixMin(pixMin),
        M(m),
        TransformFwd(fwd),
        TransformData(data)
    { }

    template <typename T> IMPLOT_INLINE float operator()(T p) const {
        if (TransformFwd != nullptr) {
            double s = TransformFwd(p, TransformData);
            double t = (s - ScaMin) / (ScaMax - ScaMin);
            p = PltMin + (PltMax - PltMin) * t;
        }
        return (float)(PixMin + M * (p - PltMin));
    }

    double ScaMin, ScaMax, PltMin, PltMax, PixMin, M;
    ImPlotTransform TransformFwd;
    void*           TransformData;
};

struct Transformer2 {
    Transformer2(const ImPlotAxis& x_axis, const ImPlotAxis& y_axis) :
        Tx(x_axis.PixelMin,
           x_axis.Range.Min,
           x_axis.Range.Max,
           x_axis.ScaleToPixel,
           x_axis.ScaleMin,
           x_axis.ScaleMax,
           x_axis.TransformForward,
           x_axis.TransformData),
        Ty(y_axis.PixelMin,
           y_axis.Range.Min,
           y_axis.Range.Max,
           y_axis.ScaleToPixel,
           y_axis.ScaleMin,
           y_axis.ScaleMax,
           y_axis.TransformForward,
           y_axis.TransformData)
    { }

    Transformer2(const ImPlotPlot& plot) :
        Transformer2(plot.Axes[plot.CurrentX], plot.Axes[plot.CurrentY])
    { }

    Transformer2() :
        Transformer2(*GImPlot->CurrentPlot)
    { }

    template <typename P> IMPLOT_INLINE ImVec2 operator()(const P& plt) const {
        ImVec2 out;
        out.x = Tx(plt.x);
        out.y = Ty(plt.y);
        return out;
    }

    template <typename T> IMPLOT_INLINE ImVec2 operator()(T x, T y) const {
        ImVec2 out;
        out.x = Tx(x);
        out.y = Ty(y);
        return out;
    }

    Transformer1 Tx;
    Transformer1 Ty;
};

//-----------------------------------------------------------------------------
// [SECTION] Renderers
//-----------------------------------------------------------------------------

struct RendererBase {
    RendererBase(int prims, int idx_consumed, int vtx_consumed) :
        Prims(prims),
        IdxConsumed(idx_consumed),
        VtxConsumed(vtx_consumed)
    { }
    const int Prims;
    Transformer2 Transformer;
    const int IdxConsumed;
    const int VtxConsumed;
};

template <class _Getter>
struct RendererLineStrip : RendererBase {
    RendererLineStrip(const _Getter& getter, ImU32 col, float weight) :
        RendererBase(getter.Count - 1, 6, 4),
        Getter(getter),
        Col(col),
        HalfWeight(ImMax(1.0f,weight)*0.5f)
    {
        P1 = this->Transformer(Getter(0));
    }
    void Init(ImDrawList& draw_list) const {
        GetLineRenderProps(draw_list, HalfWeight, UV0, UV1);
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P2 = this->Transformer(Getter(prim + 1));
        if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
            P1 = P2;
            return false;
        }
        PrimLine(draw_list,P1,P2,HalfWeight,Col,UV0,UV1);
        P1 = P2;
        return true;
    }
    const _Getter& Getter;
    const ImU32 Col;
    mutable float HalfWeight;
    mutable ImVec2 P1;
    mutable ImVec2 UV0;
    mutable ImVec2 UV1;
};

template <class _Getter>
struct RendererLineStripSkip : RendererBase {
    RendererLineStripSkip(const _Getter& getter, ImU32 col, float weight) :
        RendererBase(getter.Count - 1, 6, 4),
        Getter(getter),
        Col(col),
        HalfWeight(ImMax(1.0f,weight)*0.5f)
    {
        P1 = this->Transformer(Getter(0));
    }
    void Init(ImDrawList& draw_list) const {
        GetLineRenderProps(draw_list, HalfWeight, UV0, UV1);
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P2 = this->Transformer(Getter(prim + 1));
        if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
            if (!ImNan(P2.x) && !ImNan(P2.y))
                P1 = P2;
            return false;
        }
        PrimLine(draw_list,P1,P2,HalfWeight,Col,UV0,UV1);
        if (!ImNan(P2.x) && !ImNan(P2.y))
            P1 = P2;
        return true;
    }
    const _Getter& Getter;
    const ImU32 Col;
    mutable float HalfWeight;
    mutable ImVec2 P1;
    mutable ImVec2 UV0;
    mutable ImVec2 UV1;
};

template <class _Getter>
struct RendererLineSegments1 : RendererBase {
    RendererLineSegments1(const _Getter& getter, ImU32 col, float weight) :
        RendererBase(getter.Count / 2, 6, 4),
        Getter(getter),
        Col(col),
        HalfWeight(ImMax(1.0f,weight)*0.5f)
    { }
    void Init(ImDrawList& draw_list) const {
        GetLineRenderProps(draw_list, HalfWeight, UV0, UV1);
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P1 = this->Transformer(Getter(prim*2+0));
        ImVec2 P2 = this->Transformer(Getter(prim*2+1));
        if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2))))
            return false;
        PrimLine(draw_list,P1,P2,HalfWeight,Col,UV0,UV1);
        return true;
    }
    const _Getter& Getter;
    const ImU32 Col;
    mutable float HalfWeight;
    mutable ImVec2 UV0;
    mutable ImVec2 UV1;
};

template <class _Getter1, class _Getter2>
struct RendererLineSegments2 : RendererBase {
    RendererLineSegments2(const _Getter1& getter1, const _Getter2& getter2, ImU32 col, float weight) :
        RendererBase(ImMin(getter1.Count, getter1.Count), 6, 4),
        Getter1(getter1),
        Getter2(getter2),
        Col(col),
        HalfWeight(ImMax(1.0f,weight)*0.5f)
    {}
    void Init(ImDrawList& draw_list) const {
        GetLineRenderProps(draw_list, HalfWeight, UV0, UV1);
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P1 = this->Transformer(Getter1(prim));
        ImVec2 P2 = this->Transformer(Getter2(prim));
        if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2))))
            return false;
        PrimLine(draw_list,P1,P2,HalfWeight,Col,UV0,UV1);
        return true;
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
    const ImU32 Col;
    mutable float HalfWeight;
    mutable ImVec2 UV0;
    mutable ImVec2 UV1;
};

template <class _Getter1, class _Getter2>
struct RendererBarsFillV : RendererBase {
    RendererBarsFillV(const _Getter1& getter1, const _Getter2& getter2, ImU32 col, double width) :
        RendererBase(ImMin(getter1.Count, getter1.Count), 6, 4),
        Getter1(getter1),
        Getter2(getter2),
        Col(col),
        HalfWidth(width/2)
    {}
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImPlotPoint p1 = Getter1(prim);
        ImPlotPoint p2 = Getter2(prim);
        p1.x += HalfWidth;
        p2.x -= HalfWidth;
        ImVec2 P1 = this->Transformer(p1);
        ImVec2 P2 = this->Transformer(p2);
        float width_px = ImAbs(P1.x-P2.x);
        if (width_px < 1.0f) {
            P1.x += P1.x > P2.x ? (1-width_px) / 2 : (width_px-1) / 2;
            P2.x += P2.x > P1.x ? (1-width_px) / 2 : (width_px-1) / 2;
        }
        ImVec2 PMin = ImMin(P1, P2);
        ImVec2 PMax = ImMax(P1, P2);
        if (!cull_rect.Overlaps(ImRect(PMin, PMax)))
            return false;
        PrimRectFill(draw_list,PMin,PMax,Col,UV);
        return true;
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
    const ImU32 Col;
    const double HalfWidth;
    mutable ImVec2 UV;
};

template <class _Getter1, class _Getter2>
struct RendererBarsFillH : RendererBase {
    RendererBarsFillH(const _Getter1& getter1, const _Getter2& getter2, ImU32 col, double height) :
        RendererBase(ImMin(getter1.Count, getter1.Count), 6, 4),
        Getter1(getter1),
        Getter2(getter2),
        Col(col),
        HalfHeight(height/2)
    {}
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImPlotPoint p1 = Getter1(prim);
        ImPlotPoint p2 = Getter2(prim);
        p1.y += HalfHeight;
        p2.y -= HalfHeight;
        ImVec2 P1 = this->Transformer(p1);
        ImVec2 P2 = this->Transformer(p2);
        float height_px = ImAbs(P1.y-P2.y);
        if (height_px < 1.0f) {
            P1.y += P1.y > P2.y ? (1-height_px) / 2 : (height_px-1) / 2;
            P2.y += P2.y > P1.y ? (1-height_px) / 2 : (height_px-1) / 2;
        }
        ImVec2 PMin = ImMin(P1, P2);
        ImVec2 PMax = ImMax(P1, P2);
        if (!cull_rect.Overlaps(ImRect(PMin, PMax)))
            return false;
        PrimRectFill(draw_list,PMin,PMax,Col,UV);
        return true;
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
    const ImU32 Col;
    const double HalfHeight;
    mutable ImVec2 UV;
};

template <class _Getter1, class _Getter2>
struct RendererBarsLineV : RendererBase {
    RendererBarsLineV(const _Getter1& getter1, const _Getter2& getter2, ImU32 col, double width, float weight) :
        RendererBase(ImMin(getter1.Count, getter1.Count), 24, 8),
        Getter1(getter1),
        Getter2(getter2),
        Col(col),
        HalfWidth(width/2),
        Weight(weight)
    {}
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImPlotPoint p1 = Getter1(prim);
        ImPlotPoint p2 = Getter2(prim);
        p1.x += HalfWidth;
        p2.x -= HalfWidth;
        ImVec2 P1 = this->Transformer(p1);
        ImVec2 P2 = this->Transformer(p2);
        float width_px = ImAbs(P1.x-P2.x);
        if (width_px < 1.0f) {
            P1.x += P1.x > P2.x ? (1-width_px) / 2 : (width_px-1) / 2;
            P2.x += P2.x > P1.x ? (1-width_px) / 2 : (width_px-1) / 2;
        }
        ImVec2 PMin = ImMin(P1, P2);
        ImVec2 PMax = ImMax(P1, P2);
        if (!cull_rect.Overlaps(ImRect(PMin, PMax)))
            return false;
        PrimRectLine(draw_list,PMin,PMax,Weight,Col,UV);
        return true;
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
    const ImU32 Col;
    const double HalfWidth;
    const float Weight;
    mutable ImVec2 UV;
};

template <class _Getter1, class _Getter2>
struct RendererBarsLineH : RendererBase {
    RendererBarsLineH(const _Getter1& getter1, const _Getter2& getter2, ImU32 col, double height, float weight) :
        RendererBase(ImMin(getter1.Count, getter1.Count), 24, 8),
        Getter1(getter1),
        Getter2(getter2),
        Col(col),
        HalfHeight(height/2),
        Weight(weight)
    {}
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImPlotPoint p1 = Getter1(prim);
        ImPlotPoint p2 = Getter2(prim);
        p1.y += HalfHeight;
        p2.y -= HalfHeight;
        ImVec2 P1 = this->Transformer(p1);
        ImVec2 P2 = this->Transformer(p2);
        float height_px = ImAbs(P1.y-P2.y);
        if (height_px < 1.0f) {
            P1.y += P1.y > P2.y ? (1-height_px) / 2 : (height_px-1) / 2;
            P2.y += P2.y > P1.y ? (1-height_px) / 2 : (height_px-1) / 2;
        }
        ImVec2 PMin = ImMin(P1, P2);
        ImVec2 PMax = ImMax(P1, P2);
        if (!cull_rect.Overlaps(ImRect(PMin, PMax)))
            return false;
        PrimRectLine(draw_list,PMin,PMax,Weight,Col,UV);
        return true;
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
    const ImU32 Col;
    const double HalfHeight;
    const float Weight;
    mutable ImVec2 UV;
};


template <class _Getter>
struct RendererStairsPre : RendererBase {
    RendererStairsPre(const _Getter& getter, ImU32 col, float weight) :
        RendererBase(getter.Count - 1, 12, 8),
        Getter(getter),
        Col(col),
        HalfWeight(ImMax(1.0f,weight)*0.5f)
    {
        P1 = this->Transformer(Getter(0));
    }
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P2 = this->Transformer(Getter(prim + 1));
        if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
            P1 = P2;
            return false;
        }
        PrimRectFill(draw_list, ImVec2(P1.x - HalfWeight, P1.y), ImVec2(P1.x + HalfWeight, P2.y), Col, UV);
        PrimRectFill(draw_list, ImVec2(P1.x, P2.y + HalfWeight), ImVec2(P2.x, P2.y - HalfWeight), Col, UV);
        P1 = P2;
        return true;
    }
    const _Getter& Getter;
    const ImU32 Col;
    mutable float HalfWeight;
    mutable ImVec2 P1;
    mutable ImVec2 UV;
};

template <class _Getter>
struct RendererStairsPost : RendererBase {
    RendererStairsPost(const _Getter& getter, ImU32 col, float weight) :
        RendererBase(getter.Count - 1, 12, 8),
        Getter(getter),
        Col(col),
        HalfWeight(ImMax(1.0f,weight) * 0.5f)
    {
        P1 = this->Transformer(Getter(0));
    }
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P2 = this->Transformer(Getter(prim + 1));
        if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
            P1 = P2;
            return false;
        }
        PrimRectFill(draw_list, ImVec2(P1.x, P1.y + HalfWeight), ImVec2(P2.x, P1.y - HalfWeight), Col, UV);
        PrimRectFill(draw_list, ImVec2(P2.x - HalfWeight, P2.y), ImVec2(P2.x + HalfWeight, P1.y), Col, UV);
        P1 = P2;
        return true;
    }
    const _Getter& Getter;
    const ImU32 Col;
    mutable float HalfWeight;
    mutable ImVec2 P1;
    mutable ImVec2 UV;
};

template <class _Getter>
struct RendererStairsPreShaded : RendererBase {
    RendererStairsPreShaded(const _Getter& getter, ImU32 col) :
        RendererBase(getter.Count - 1, 6, 4),
        Getter(getter),
        Col(col)
    {
        P1 = this->Transformer(Getter(0));
        Y0 = this->Transformer(ImPlotPoint(0,0)).y;
    }
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P2 = this->Transformer(Getter(prim + 1));
        ImVec2 PMin(ImMin(P1.x, P2.x), ImMin(Y0, P2.y));
        ImVec2 PMax(ImMax(P1.x, P2.x), ImMax(Y0, P2.y));
        if (!cull_rect.Overlaps(ImRect(PMin, PMax))) {
            P1 = P2;
            return false;
        }
        PrimRectFill(draw_list, PMin, PMax, Col, UV);
        P1 = P2;
        return true;
    }
    const _Getter& Getter;
    const ImU32 Col;
    float Y0;
    mutable ImVec2 P1;
    mutable ImVec2 UV;
};

template <class _Getter>
struct RendererStairsPostShaded : RendererBase {
    RendererStairsPostShaded(const _Getter& getter, ImU32 col) :
        RendererBase(getter.Count - 1, 6, 4),
        Getter(getter),
        Col(col)
    {
        P1 = this->Transformer(Getter(0));
        Y0 = this->Transformer(ImPlotPoint(0,0)).y;
    }
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P2 = this->Transformer(Getter(prim + 1));
        ImVec2 PMin(ImMin(P1.x, P2.x), ImMin(P1.y, Y0));
        ImVec2 PMax(ImMax(P1.x, P2.x), ImMax(P1.y, Y0));
        if (!cull_rect.Overlaps(ImRect(PMin, PMax))) {
            P1 = P2;
            return false;
        }
        PrimRectFill(draw_list, PMin, PMax, Col, UV);
        P1 = P2;
        return true;
    }
    const _Getter& Getter;
    const ImU32 Col;
    float Y0;
    mutable ImVec2 P1;
    mutable ImVec2 UV;
};



template <class _Getter1, class _Getter2>
struct RendererShaded : RendererBase {
    RendererShaded(const _Getter1& getter1, const _Getter2& getter2, ImU32 col) :
        RendererBase(ImMin(getter1.Count, getter2.Count) - 1, 6, 5),
        Getter1(getter1),
        Getter2(getter2),
        Col(col)
    {
        P11 = this->Transformer(Getter1(0));
        P12 = this->Transformer(Getter2(0));
    }
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 P21 = this->Transformer(Getter1(prim+1));
        ImVec2 P22 = this->Transformer(Getter2(prim+1));
        ImRect rect(ImMin(ImMin(ImMin(P11,P12),P21),P22), ImMax(ImMax(ImMax(P11,P12),P21),P22));
        if (!cull_rect.Overlaps(rect)) {
            P11 = P21;
            P12 = P22;
            return false;
        }
        const int intersect = (P11.y > P12.y && P22.y > P21.y) || (P12.y > P11.y && P21.y > P22.y);
        ImVec2 intersection = Intersection(P11,P21,P12,P22);
        draw_list._VtxWritePtr[0].pos = P11;
        draw_list._VtxWritePtr[0].uv  = UV;
        draw_list._VtxWritePtr[0].col = Col;
        draw_list._VtxWritePtr[1].pos = P21;
        draw_list._VtxWritePtr[1].uv  = UV;
        draw_list._VtxWritePtr[1].col = Col;
        draw_list._VtxWritePtr[2].pos = intersection;
        draw_list._VtxWritePtr[2].uv  = UV;
        draw_list._VtxWritePtr[2].col = Col;
        draw_list._VtxWritePtr[3].pos = P12;
        draw_list._VtxWritePtr[3].uv  = UV;
        draw_list._VtxWritePtr[3].col = Col;
        draw_list._VtxWritePtr[4].pos = P22;
        draw_list._VtxWritePtr[4].uv  = UV;
        draw_list._VtxWritePtr[4].col = Col;
        draw_list._VtxWritePtr += 5;
        draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx);
        draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 1 + intersect);
        draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 3);
        draw_list._IdxWritePtr[3] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 1);
        draw_list._IdxWritePtr[4] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 4);
        draw_list._IdxWritePtr[5] = (ImDrawIdx)(draw_list._VtxCurrentIdx + 3 - intersect);
        draw_list._IdxWritePtr += 6;
        draw_list._VtxCurrentIdx += 5;
        P11 = P21;
        P12 = P22;
        return true;
    }
    const _Getter1& Getter1;
    const _Getter2& Getter2;
    const ImU32 Col;
    mutable ImVec2 P11;
    mutable ImVec2 P12;
    mutable ImVec2 UV;
};

struct RectC {
    ImPlotPoint Pos;
    ImPlotPoint HalfSize;
    ImU32 Color;
};

template <typename _Getter>
struct RendererRectC : RendererBase {
    RendererRectC(const _Getter& getter) :
        RendererBase(getter.Count, 6, 4),
        Getter(getter)
    {}
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        RectC rect = Getter(prim);
        ImVec2 P1 = this->Transformer(rect.Pos.x - rect.HalfSize.x , rect.Pos.y - rect.HalfSize.y);
        ImVec2 P2 = this->Transformer(rect.Pos.x + rect.HalfSize.x , rect.Pos.y + rect.HalfSize.y);
        if ((rect.Color & IM_COL32_A_MASK) == 0 || !cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2))))
            return false;
        PrimRectFill(draw_list,P1,P2,rect.Color,UV);
        return true;
    }
    const _Getter& Getter;
    mutable ImVec2 UV;
};

//-----------------------------------------------------------------------------
// [SECTION] RenderPrimitives
//-----------------------------------------------------------------------------

/// Renders primitive shapes in bulk as efficiently as possible.
template <class _Renderer>
void RenderPrimitivesEx(const _Renderer& renderer, ImDrawList& draw_list, const ImRect& cull_rect) {
    unsigned int prims        = renderer.Prims;
    unsigned int prims_culled = 0;
    unsigned int idx          = 0;
    renderer.Init(draw_list);
    while (prims) {
        // find how many can be reserved up to end of current draw command's limit
        unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - draw_list._VtxCurrentIdx) / renderer.VtxConsumed);
        // make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
        if (cnt >= ImMin(64u, prims)) {
            if (prims_culled >= cnt)
                prims_culled -= cnt; // reuse previous reservation
            else {
                // add more elements to previous reservation
                draw_list.PrimReserve((cnt - prims_culled) * renderer.IdxConsumed, (cnt - prims_culled) * renderer.VtxConsumed);
                prims_culled = 0;
            }
        }
        else
        {
            if (prims_culled > 0) {
                draw_list.PrimUnreserve(prims_culled * renderer.IdxConsumed, prims_culled * renderer.VtxConsumed);
                prims_culled = 0;
            }
            cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*draw_list._VtxCurrentIdx*/) / renderer.VtxConsumed);
            // reserve new draw command
            draw_list.PrimReserve(cnt * renderer.IdxConsumed, cnt * renderer.VtxConsumed);
        }
        prims -= cnt;
        for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
            if (!renderer.Render(draw_list, cull_rect, idx))
                prims_culled++;
        }
    }
    if (prims_culled > 0)
        draw_list.PrimUnreserve(prims_culled * renderer.IdxConsumed, prims_culled * renderer.VtxConsumed);
}

template <template <class> class _Renderer, class _Getter, typename ...Args>
void RenderPrimitives1(const _Getter& getter, Args... args) {
    ImDrawList& draw_list = *GetPlotDrawList();
    const ImRect& cull_rect = GetCurrentPlot()->PlotRect;
    RenderPrimitivesEx(_Renderer<_Getter>(getter,args...), draw_list, cull_rect);
}

template <template <class,class> class _Renderer, class _Getter1, class _Getter2, typename ...Args>
void RenderPrimitives2(const _Getter1& getter1, const _Getter2& getter2, Args... args) {
    ImDrawList& draw_list = *GetPlotDrawList();
    const ImRect& cull_rect = GetCurrentPlot()->PlotRect;
    RenderPrimitivesEx(_Renderer<_Getter1,_Getter2>(getter1,getter2,args...), draw_list, cull_rect);
}

//-----------------------------------------------------------------------------
// [SECTION] Markers
//-----------------------------------------------------------------------------

template <class _Getter>
struct RendererMarkersFill : RendererBase {
    RendererMarkersFill(const _Getter& getter, const ImVec2* marker, int count, float size, ImU32 col) :
        RendererBase(getter.Count, (count-2)*3, count),
        Getter(getter),
        Marker(marker),
        Count(count),
        Size(size),
        Col(col)
    { }
    void Init(ImDrawList& draw_list) const {
        UV = draw_list._Data->TexUvWhitePixel;
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 p = this->Transformer(Getter(prim));
        if (p.x >= cull_rect.Min.x && p.y >= cull_rect.Min.y && p.x <= cull_rect.Max.x && p.y <= cull_rect.Max.y) {
            for (int i = 0; i < Count; i++) {
                draw_list._VtxWritePtr[0].pos.x = p.x + Marker[i].x * Size;
                draw_list._VtxWritePtr[0].pos.y = p.y + Marker[i].y * Size;
                draw_list._VtxWritePtr[0].uv = UV;
                draw_list._VtxWritePtr[0].col = Col;
                draw_list._VtxWritePtr++;
            }
            for (int i = 2; i < Count; i++) {
                draw_list._IdxWritePtr[0] = (ImDrawIdx)(draw_list._VtxCurrentIdx);
                draw_list._IdxWritePtr[1] = (ImDrawIdx)(draw_list._VtxCurrentIdx + i - 1);
                draw_list._IdxWritePtr[2] = (ImDrawIdx)(draw_list._VtxCurrentIdx + i);
                draw_list._IdxWritePtr += 3;
            }
            draw_list._VtxCurrentIdx += (ImDrawIdx)Count;
            return true;
        }
        return false;
    }
    const _Getter& Getter;
    const ImVec2* Marker;
    const int Count;
    const float Size;
    const ImU32 Col;
    mutable ImVec2 UV;
};


template <class _Getter>
struct RendererMarkersLine : RendererBase {
    RendererMarkersLine(const _Getter& getter, const ImVec2* marker, int count, float size, float weight, ImU32 col) :
        RendererBase(getter.Count, count/2*6, count/2*4),
        Getter(getter),
        Marker(marker),
        Count(count),
        HalfWeight(ImMax(1.0f,weight)*0.5f),
        Size(size),
        Col(col)
    { }
    void Init(ImDrawList& draw_list) const {
        GetLineRenderProps(draw_list, HalfWeight, UV0, UV1);
    }
    IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_rect, int prim) const {
        ImVec2 p = this->Transformer(Getter(prim));
        if (p.x >= cull_rect.Min.x && p.y >= cull_rect.Min.y && p.x <= cull_rect.Max.x && p.y <= cull_rect.Max.y) {
            for (int i = 0; i < Count; i = i + 2) {
                ImVec2 p1(p.x + Marker[i].x * Size, p.y + Marker[i].y * Size);
                ImVec2 p2(p.x + Marker[i+1].x * Size, p.y + Marker[i+1].y * Size);
                PrimLine(draw_list, p1, p2, HalfWeight, Col, UV0, UV1);
            }
            return true;
        }
        return false;
    }
    const _Getter& Getter;
    const ImVec2* Marker;
    const int Count;
    mutable float HalfWeight;
    const float Size;
    const ImU32 Col;
    mutable ImVec2 UV0;
    mutable ImVec2 UV1;
};

static const ImVec2 MARKER_FILL_CIRCLE[10]  = {ImVec2(1.0f, 0.0f), ImVec2(0.809017f, 0.58778524f),ImVec2(0.30901697f, 0.95105654f),ImVec2(-0.30901703f, 0.9510565f),ImVec2(-0.80901706f, 0.5877852f),ImVec2(-1.0f, 0.0f),ImVec2(-0.80901694f, -0.58778536f),ImVec2(-0.3090171f, -0.9510565f),ImVec2(0.30901712f, -0.9510565f),ImVec2(0.80901694f, -0.5877853f)};
static const ImVec2 MARKER_FILL_SQUARE[4]   = {ImVec2(SQRT_1_2,SQRT_1_2), ImVec2(SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,SQRT_1_2)};
static const ImVec2 MARKER_FILL_DIAMOND[4]  = {ImVec2(1, 0), ImVec2(0, -1), ImVec2(-1, 0), ImVec2(0, 1)};
static const ImVec2 MARKER_FILL_UP[3]       = {ImVec2(SQRT_3_2,0.5f),ImVec2(0,-1),ImVec2(-SQRT_3_2,0.5f)};
static const ImVec2 MARKER_FILL_DOWN[3]     = {ImVec2(SQRT_3_2,-0.5f),ImVec2(0,1),ImVec2(-SQRT_3_2,-0.5f)};
static const ImVec2 MARKER_FILL_LEFT[3]     = {ImVec2(-1,0), ImVec2(0.5, SQRT_3_2), ImVec2(0.5, -SQRT_3_2)};
static const ImVec2 MARKER_FILL_RIGHT[3]    = {ImVec2(1,0), ImVec2(-0.5, SQRT_3_2), ImVec2(-0.5, -SQRT_3_2)};

static const ImVec2 MARKER_LINE_CIRCLE[20]  = {
    ImVec2(1.0f, 0.0f),
    ImVec2(0.809017f, 0.58778524f),
    ImVec2(0.809017f, 0.58778524f),
    ImVec2(0.30901697f, 0.95105654f),
    ImVec2(0.30901697f, 0.95105654f),
    ImVec2(-0.30901703f, 0.9510565f),
    ImVec2(-0.30901703f, 0.9510565f),
    ImVec2(-0.80901706f, 0.5877852f),
    ImVec2(-0.80901706f, 0.5877852f),
    ImVec2(-1.0f, 0.0f),
    ImVec2(-1.0f, 0.0f),
    ImVec2(-0.80901694f, -0.58778536f),
    ImVec2(-0.80901694f, -0.58778536f),
    ImVec2(-0.3090171f, -0.9510565f),
    ImVec2(-0.3090171f, -0.9510565f),
    ImVec2(0.30901712f, -0.9510565f),
    ImVec2(0.30901712f, -0.9510565f),
    ImVec2(0.80901694f, -0.5877853f),
    ImVec2(0.80901694f, -0.5877853f),
    ImVec2(1.0f, 0.0f)
};
static const ImVec2 MARKER_LINE_SQUARE[8]   = {ImVec2(SQRT_1_2,SQRT_1_2), ImVec2(SQRT_1_2,-SQRT_1_2), ImVec2(SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,SQRT_1_2), ImVec2(-SQRT_1_2,SQRT_1_2), ImVec2(SQRT_1_2,SQRT_1_2)};
static const ImVec2 MARKER_LINE_DIAMOND[8]  = {ImVec2(1, 0), ImVec2(0, -1), ImVec2(0, -1), ImVec2(-1, 0), ImVec2(-1, 0), ImVec2(0, 1), ImVec2(0, 1), ImVec2(1, 0)};
static const ImVec2 MARKER_LINE_UP[6]       = {ImVec2(SQRT_3_2,0.5f), ImVec2(0,-1),ImVec2(0,-1),ImVec2(-SQRT_3_2,0.5f),ImVec2(-SQRT_3_2,0.5f),ImVec2(SQRT_3_2,0.5f)};
static const ImVec2 MARKER_LINE_DOWN[6]     = {ImVec2(SQRT_3_2,-0.5f),ImVec2(0,1),ImVec2(0,1),ImVec2(-SQRT_3_2,-0.5f), ImVec2(-SQRT_3_2,-0.5f), ImVec2(SQRT_3_2,-0.5f)};
static const ImVec2 MARKER_LINE_LEFT[6]     = {ImVec2(-1,0), ImVec2(0.5, SQRT_3_2),  ImVec2(0.5, SQRT_3_2),  ImVec2(0.5, -SQRT_3_2) , ImVec2(0.5, -SQRT_3_2) , ImVec2(-1,0) };
static const ImVec2 MARKER_LINE_RIGHT[6]    = {ImVec2(1,0),  ImVec2(-0.5, SQRT_3_2), ImVec2(-0.5, SQRT_3_2), ImVec2(-0.5, -SQRT_3_2), ImVec2(-0.5, -SQRT_3_2), ImVec2(1,0) };
static const ImVec2 MARKER_LINE_ASTERISK[6] = {ImVec2(-SQRT_3_2, -0.5f), ImVec2(SQRT_3_2, 0.5f),  ImVec2(-SQRT_3_2, 0.5f), ImVec2(SQRT_3_2, -0.5f), ImVec2(0, -1), ImVec2(0, 1)};
static const ImVec2 MARKER_LINE_PLUS[4]     = {ImVec2(-1, 0), ImVec2(1, 0), ImVec2(0, -1), ImVec2(0, 1)};
static const ImVec2 MARKER_LINE_CROSS[4]    = {ImVec2(-SQRT_1_2,-SQRT_1_2),ImVec2(SQRT_1_2,SQRT_1_2),ImVec2(SQRT_1_2,-SQRT_1_2),ImVec2(-SQRT_1_2,SQRT_1_2)};

template <typename _Getter>
void RenderMarkers(const _Getter& getter, ImPlotMarker marker, float size, bool rend_fill, ImU32 col_fill, bool rend_line, ImU32 col_line, float weight) {
    if (rend_fill) {
        switch (marker) {
            case ImPlotMarker_Circle  : RenderPrimitives1<RendererMarkersFill>(getter,MARKER_FILL_CIRCLE,10,size,col_fill); break;
            case ImPlotMarker_Square  : RenderPrimitives1<RendererMarkersFill>(getter,MARKER_FILL_SQUARE, 4,size,col_fill); break;
            case ImPlotMarker_Diamond : RenderPrimitives1<RendererMarkersFill>(getter,MARKER_FILL_DIAMOND,4,size,col_fill); break;
            case ImPlotMarker_Up      : RenderPrimitives1<RendererMarkersFill>(getter,MARKER_FILL_UP,     3,size,col_fill); break;
            case ImPlotMarker_Down    : RenderPrimitives1<RendererMarkersFill>(getter,MARKER_FILL_DOWN,   3,size,col_fill); break;
            case ImPlotMarker_Left    : RenderPrimitives1<RendererMarkersFill>(getter,MARKER_FILL_LEFT,   3,size,col_fill); break;
            case ImPlotMarker_Right   : RenderPrimitives1<RendererMarkersFill>(getter,MARKER_FILL_RIGHT,  3,size,col_fill); break;
        }
    }
    if (rend_line) {
        switch (marker) {
            case ImPlotMarker_Circle    : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_CIRCLE, 20,size,weight,col_line); break;
            case ImPlotMarker_Square    : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_SQUARE,  8,size,weight,col_line); break;
            case ImPlotMarker_Diamond   : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_DIAMOND, 8,size,weight,col_line); break;
            case ImPlotMarker_Up        : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_UP,      6,size,weight,col_line); break;
            case ImPlotMarker_Down      : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_DOWN,    6,size,weight,col_line); break;
            case ImPlotMarker_Left      : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_LEFT,    6,size,weight,col_line); break;
            case ImPlotMarker_Right     : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_RIGHT,   6,size,weight,col_line); break;
            case ImPlotMarker_Asterisk  : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_ASTERISK,6,size,weight,col_line); break;
            case ImPlotMarker_Plus      : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_PLUS,    4,size,weight,col_line); break;
            case ImPlotMarker_Cross     : RenderPrimitives1<RendererMarkersLine>(getter,MARKER_LINE_CROSS,   4,size,weight,col_line); break;
        }
    }
}

//-----------------------------------------------------------------------------
// [SECTION] PlotLine
//-----------------------------------------------------------------------------

template <typename _Getter>
void PlotLineEx(const char* label_id, const _Getter& getter, ImPlotLineFlags flags) {
    if (BeginItemEx(label_id, Fitter1<_Getter>(getter), flags, ImPlotCol_Line)) {
        const ImPlotNextItemData& s = GetItemData();
        if (getter.Count > 1) {
            if (ImHasFlag(flags, ImPlotLineFlags_Shaded) && s.RenderFill) {
                const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
                GetterOverrideY<_Getter> getter2(getter, 0);
                RenderPrimitives2<RendererShaded>(getter,getter2,col_fill);
            }
            if (s.RenderLine) {
                const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
                if (ImHasFlag(flags,ImPlotLineFlags_Segments)) {
                    RenderPrimitives1<RendererLineSegments1>(getter,col_line,s.LineWeight);
                }
                else if (ImHasFlag(flags, ImPlotLineFlags_Loop)) {
                    if (ImHasFlag(flags, ImPlotLineFlags_SkipNaN))
                        RenderPrimitives1<RendererLineStripSkip>(GetterLoop<_Getter>(getter),col_line,s.LineWeight);
                    else
                        RenderPrimitives1<RendererLineStrip>(GetterLoop<_Getter>(getter),col_line,s.LineWeight);
                }
                else {
                    if (ImHasFlag(flags, ImPlotLineFlags_SkipNaN))
                        RenderPrimitives1<RendererLineStripSkip>(getter,col_line,s.LineWeight);
                    else
                        RenderPrimitives1<RendererLineStrip>(getter,col_line,s.LineWeight);
                }
            }
        }
        // render markers
        if (s.Marker != ImPlotMarker_None) {
            if (ImHasFlag(flags, ImPlotLineFlags_NoClip)) {
                PopPlotClipRect();
                PushPlotClipRect(s.MarkerSize);
            }
            const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
            const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
            RenderMarkers<_Getter>(getter, s.Marker, s.MarkerSize, s.RenderMarkerFill, col_fill, s.RenderMarkerLine, col_line, s.MarkerWeight);
        }
        EndItem();
    }
}

template <typename T>
void PlotLine(const char* label_id, const T* values, int count, double xscale, double x0, ImPlotLineFlags flags, int offset, int stride) {
    GetterXY<IndexerLin,IndexerIdx<T>> getter(IndexerLin(xscale,x0),IndexerIdx<T>(values,count,offset,stride),count);
    PlotLineEx(label_id, getter, flags);
}

template <typename T>
void PlotLine(const char* label_id, const T* xs, const T* ys, int count, ImPlotLineFlags flags, int offset, int stride) {
    GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
    PlotLineEx(label_id, getter, flags);
}

#define INSTANTIATE_MACRO(T) \
    template IMPLOT_API void PlotLine<T> (const char* label_id, const T* values, int count, double xscale, double x0, ImPlotLineFlags flags, int offset, int stride); \
    template IMPLOT_API void PlotLine<T>(const char* label_id, const T* xs, const T* ys, int count, ImPlotLineFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

// custom
void PlotLineG(const char* label_id, ImPlotGetter getter_func, void* data, int count, ImPlotLineFlags flags) {
    GetterFuncPtr getter(getter_func,data, count);
    PlotLineEx(label_id, getter, flags);
}

//-----------------------------------------------------------------------------
// [SECTION] PlotScatter
//-----------------------------------------------------------------------------

template <typename Getter>
void PlotScatterEx(const char* label_id, const Getter& getter, ImPlotScatterFlags flags) {
    if (BeginItemEx(label_id, Fitter1<Getter>(getter), flags, ImPlotCol_MarkerOutline)) {
        const ImPlotNextItemData& s = GetItemData();
        ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle: s.Marker;
        if (marker != ImPlotMarker_None) {
            if (ImHasFlag(flags,ImPlotScatterFlags_NoClip)) {
                PopPlotClipRect();
                PushPlotClipRect(s.MarkerSize);
            }
            const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
            const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
            RenderMarkers<Getter>(getter, marker, s.MarkerSize, s.RenderMarkerFill, col_fill, s.RenderMarkerLine, col_line, s.MarkerWeight);
        }
        EndItem();
    }
}

template <typename T>
void PlotScatter(const char* label_id, const T* values, int count, double xscale, double x0, ImPlotScatterFlags flags, int offset, int stride) {
    GetterXY<IndexerLin,IndexerIdx<T>> getter(IndexerLin(xscale,x0),IndexerIdx<T>(values,count,offset,stride),count);
    PlotScatterEx(label_id, getter, flags);
}

template <typename T>
void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, ImPlotScatterFlags flags, int offset, int stride) {
    GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
    return PlotScatterEx(label_id, getter, flags);
}

#define INSTANTIATE_MACRO(T) \
    template IMPLOT_API void PlotScatter<T>(const char* label_id, const T* values, int count, double xscale, double x0, ImPlotScatterFlags flags, int offset, int stride); \
    template IMPLOT_API void PlotScatter<T>(const char* label_id, const T* xs, const T* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

// custom
void PlotScatterG(const char* label_id, ImPlotGetter getter_func, void* data, int count, ImPlotScatterFlags flags) {
    GetterFuncPtr getter(getter_func,data, count);
    return PlotScatterEx(label_id, getter, flags);
}

//-----------------------------------------------------------------------------
// [SECTION] PlotStairs
//-----------------------------------------------------------------------------

template <typename Getter>
void PlotStairsEx(const char* label_id, const Getter& getter, ImPlotStairsFlags flags) {
    if (BeginItemEx(label_id, Fitter1<Getter>(getter), flags, ImPlotCol_Line)) {
        const ImPlotNextItemData& s = GetItemData();
        if (getter.Count > 1 ) {
            if (s.RenderFill && ImHasFlag(flags,ImPlotStairsFlags_Shaded)) {
                const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
                if (ImHasFlag(flags, ImPlotStairsFlags_PreStep))
                    RenderPrimitives1<RendererStairsPreShaded>(getter,col_fill);
                else
                    RenderPrimitives1<RendererStairsPostShaded>(getter,col_fill);
            }
            if (s.RenderLine) {
                const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
                if (ImHasFlag(flags, ImPlotStairsFlags_PreStep))
                    RenderPrimitives1<RendererStairsPre>(getter,col_line,s.LineWeight);
                else
                    RenderPrimitives1<RendererStairsPost>(getter,col_line,s.LineWeight);
            }
        }
        // render markers
        if (s.Marker != ImPlotMarker_None) {
            PopPlotClipRect();
            PushPlotClipRect(s.MarkerSize);
            const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
            const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
            RenderMarkers<Getter>(getter, s.Marker, s.MarkerSize, s.RenderMarkerFill, col_fill, s.RenderMarkerLine, col_line, s.MarkerWeight);
        }
        EndItem();
    }
}

template <typename T>
void PlotStairs(const char* label_id, const T* values, int count, double xscale, double x0, ImPlotStairsFlags flags, int offset, int stride) {
    GetterXY<IndexerLin,IndexerIdx<T>> getter(IndexerLin(xscale,x0),IndexerIdx<T>(values,count,offset,stride),count);
    PlotStairsEx(label_id, getter, flags);
}

template <typename T>
void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, ImPlotStairsFlags flags, int offset, int stride) {
    GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
    return PlotStairsEx(label_id, getter, flags);
}

#define INSTANTIATE_MACRO(T) \
    template IMPLOT_API void PlotStairs<T> (const char* label_id, const T* values, int count, double xscale, double x0, ImPlotStairsFlags flags, int offset, int stride); \
    template IMPLOT_API void PlotStairs<T>(const char* label_id, const T* xs, const T* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

// custom
void PlotStairsG(const char* label_id, ImPlotGetter getter_func, void* data, int count, ImPlotStairsFlags flags) {
    GetterFuncPtr getter(getter_func,data, count);
    return PlotStairsEx(label_id, getter, flags);
}

//-----------------------------------------------------------------------------
// [SECTION] PlotShaded
//-----------------------------------------------------------------------------

template <typename Getter1, typename Getter2>
void PlotShadedEx(const char* label_id, const Getter1& getter1, const Getter2& getter2, ImPlotShadedFlags flags) {
    if (BeginItemEx(label_id, Fitter2<Getter1,Getter2>(getter1,getter2), flags, ImPlotCol_Fill)) {
        const ImPlotNextItemData& s = GetItemData();
        if (s.RenderFill) {
            const ImU32 col = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
            RenderPrimitives2<RendererShaded>(getter1,getter2,col);
        }
        EndItem();
    }
}

template <typename T>
void PlotShaded(const char* label_id, const T* values, int count, double y_ref, double xscale, double x0, ImPlotShadedFlags flags, int offset, int stride) {
    if (!(y_ref > -DBL_MAX))
        y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Min;
    if (!(y_ref < DBL_MAX))
        y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Max;
    GetterXY<IndexerLin,IndexerIdx<T>> getter1(IndexerLin(xscale,x0),IndexerIdx<T>(values,count,offset,stride),count);
    GetterXY<IndexerLin,IndexerConst>  getter2(IndexerLin(xscale,x0),IndexerConst(y_ref),count);
    PlotShadedEx(label_id, getter1, getter2, flags);
}

template <typename T>
void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double y_ref, ImPlotShadedFlags flags, int offset, int stride) {
    if (y_ref == -HUGE_VAL)
        y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Min;
    if (y_ref == HUGE_VAL)
        y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Max;
    GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter1(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
    GetterXY<IndexerIdx<T>,IndexerConst>  getter2(IndexerIdx<T>(xs,count,offset,stride),IndexerConst(y_ref),count);
    PlotShadedEx(label_id, getter1, getter2, flags);
}


template <typename T>
void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, ImPlotShadedFlags flags, int offset, int stride) {
    GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter1(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys1,count,offset,stride),count);
    GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter2(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys2,count,offset,stride),count);
    PlotShadedEx(label_id, getter1, getter2, flags);
}

#define INSTANTIATE_MACRO(T) \
    template IMPLOT_API void PlotShaded<T>(const char* label_id, const T* values, int count, double y_ref, double xscale, double x0, ImPlotShadedFlags flags, int offset, int stride); \
    template IMPLOT_API void PlotShaded<T>(const char* label_id, const T* xs, const T* ys, int count, double y_ref, ImPlotShadedFlags flags, int offset, int stride); \
    template IMPLOT_API void PlotShaded<T>(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

// custom
void PlotShadedG(const char* label_id, ImPlotGetter getter_func1, void* data1, ImPlotGetter getter_func2, void* data2, int count, ImPlotShadedFlags flags) {
    GetterFuncPtr getter1(getter_func1, data1, count);
    GetterFuncPtr getter2(getter_func2, data2, count);
    PlotShadedEx(label_id, getter1, getter2, flags);
}

//-----------------------------------------------------------------------------
// [SECTION] PlotBars
//-----------------------------------------------------------------------------

template <typename Getter1, typename Getter2>
void PlotBarsVEx(const char* label_id, const Getter1& getter1, const Getter2 getter2, double width, ImPlotBarsFlags flags) {
    if (BeginItemEx(label_id, FitterBarV<Getter1,Getter2>(getter1,getter2,width), flags, ImPlotCol_Fill)) {
        const ImPlotNextItemData& s = GetItemData();
        const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
        const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
        bool rend_fill = s.RenderFill;
        bool rend_line = s.RenderLine;
        if (rend_fill) {
            RenderPrimitives2<RendererBarsFillV>(getter1,getter2,col_fill,width);
            if (rend_line && col_fill == col_line)
                rend_line = false;
        }
        if (rend_line) {
            RenderPrimitives2<RendererBarsLineV>(getter1,getter2,col_line,width,s.LineWeight);
        }
        EndItem();
    }
}

template <typename Getter1, typename Getter2>
void PlotBarsHEx(const char* label_id, const Getter1& getter1, const Getter2& getter2, double height, ImPlotBarsFlags flags) {
    if (BeginItemEx(label_id, FitterBarH<Getter1,Getter2>(getter1,getter2,height), flags, ImPlotCol_Fill)) {
        const ImPlotNextItemData& s = GetItemData();
        const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
        const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
        bool rend_fill = s.RenderFill;
        bool rend_line = s.RenderLine;
        if (rend_fill) {
            RenderPrimitives2<RendererBarsFillH>(getter1,getter2,col_fill,height);
            if (rend_line && col_fill == col_line)
                rend_line = false;
        }
        if (rend_line) {
            RenderPrimitives2<RendererBarsLineH>(getter1,getter2,col_line,height,s.LineWeight);
        }
        EndItem();
    }
}

template <typename T>
void PlotBars(const char* label_id, const T* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride) {
    if (ImHasFlag(flags, ImPlotBarsFlags_Horizontal)) {
        GetterXY<IndexerIdx<T>,IndexerLin> getter1(IndexerIdx<T>(values,count,offset,stride),IndexerLin(1.0,shift),count);
        GetterXY<IndexerConst,IndexerLin>  getter2(IndexerConst(0),IndexerLin(1.0,shift),count);
        PlotBarsHEx(label_id, getter1, getter2, bar_size, flags);
    }
    else {
        GetterXY<IndexerLin,IndexerIdx<T>> getter1(IndexerLin(1.0,shift),IndexerIdx<T>(values,count,offset,stride),count);
        GetterXY<IndexerLin,IndexerConst>  getter2(IndexerLin(1.0,shift),IndexerConst(0),count);
        PlotBarsVEx(label_id, getter1, getter2, bar_size, flags);
    }
}

template <typename T>
void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride) {
    if (ImHasFlag(flags, ImPlotBarsFlags_Horizontal)) {
        GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter1(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
        GetterXY<IndexerConst, IndexerIdx<T>> getter2(IndexerConst(0),IndexerIdx<T>(ys,count,offset,stride),count);
        PlotBarsHEx(label_id, getter1, getter2, bar_size, flags);
    }
    else {
        GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter1(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
        GetterXY<IndexerIdx<T>,IndexerConst>  getter2(IndexerIdx<T>(xs,count,offset,stride),IndexerConst(0),count);
        PlotBarsVEx(label_id, getter1, getter2, bar_size, flags);
    }
}

#define INSTANTIATE_MACRO(T) \
    template IMPLOT_API void PlotBars<T>(const char* label_id, const T* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride); \
    template IMPLOT_API void PlotBars<T>(const char* label_id, const T* xs, const T* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

void PlotBarsG(const char* label_id, ImPlotGetter getter_func, void* data, int count, double bar_size, ImPlotBarsFlags flags) {
    if (ImHasFlag(flags, ImPlotBarsFlags_Horizontal)) {
        GetterFuncPtr getter1(getter_func, data, count);
        GetterOverrideX<GetterFuncPtr> getter2(getter1,0);
        PlotBarsHEx(label_id, getter1, getter2, bar_size, flags);
    }
    else {
        GetterFuncPtr getter1(getter_func, data, count);
        GetterOverrideY<GetterFuncPtr> getter2(getter1,0);
        PlotBarsVEx(label_id, getter1, getter2, bar_size, flags);
    }
}

//-----------------------------------------------------------------------------
// [SECTION] PlotBarGroups
//-----------------------------------------------------------------------------

template <typename T>
void PlotBarGroups(const char* const label_ids[], const T* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags) {
    const bool horz = ImHasFlag(flags, ImPlotBarGroupsFlags_Horizontal);
    const bool stack = ImHasFlag(flags, ImPlotBarGroupsFlags_Stacked);
    if (stack) {
        SetupLock();
        ImPlotContext& gp = *GImPlot;
        gp.TempDouble1.resize(4*group_count);
        double* temp = gp.TempDouble1.Data;
        double* neg =      &temp[0];
        double* pos =      &temp[group_count];
        double* curr_min = &temp[group_count*2];
        double* curr_max = &temp[group_count*3];
        for (int g = 0; g < group_count*2; ++g)
            temp[g] = 0;
        if (horz) {
            for (int i = 0; i < item_count; ++i) {
                if (!IsItemHidden(label_ids[i])) {
                    for (int g = 0; g < group_count; ++g) {
                        double v = (double)values[i*group_count+g];
                        if (v > 0) {
                            curr_min[g] = pos[g];
                            curr_max[g] = curr_min[g] + v;
                            pos[g]      += v;
                        }
                        else {
                            curr_max[g] = neg[g];
                            curr_min[g] = curr_max[g] + v;
                            neg[g]      += v;
                        }
                    }
                }
                GetterXY<IndexerIdx<double>,IndexerLin> getter1(IndexerIdx<double>(curr_min,group_count),IndexerLin(1.0,shift),group_count);
                GetterXY<IndexerIdx<double>,IndexerLin> getter2(IndexerIdx<double>(curr_max,group_count),IndexerLin(1.0,shift),group_count);
                PlotBarsHEx(label_ids[i],getter1,getter2,group_size,0);
            }
        }
        else {
            for (int i = 0; i < item_count; ++i) {
                if (!IsItemHidden(label_ids[i])) {
                    for (int g = 0; g < group_count; ++g) {
                        double v = (double)values[i*group_count+g];
                        if (v > 0) {
                            curr_min[g] = pos[g];
                            curr_max[g] = curr_min[g] + v;
                            pos[g]      += v;
                        }
                        else {
                            curr_max[g] = neg[g];
                            curr_min[g] = curr_max[g] + v;
                            neg[g]      += v;
                        }
                    }
                }
                GetterXY<IndexerLin,IndexerIdx<double>> getter1(IndexerLin(1.0,shift),IndexerIdx<double>(curr_min,group_count),group_count);
                GetterXY<IndexerLin,IndexerIdx<double>> getter2(IndexerLin(1.0,shift),IndexerIdx<double>(curr_max,group_count),group_count);
                PlotBarsVEx(label_ids[i],getter1,getter2,group_size,0);
            }
        }
    }
    else {
        const double subsize = group_size / item_count;
        if (horz) {
            for (int i = 0; i < item_count; ++i) {
                const double subshift = (i+0.5)*subsize - group_size/2;
                PlotBars(label_ids[i],&values[i*group_count],group_count,subsize,subshift+shift,ImPlotBarsFlags_Horizontal);
            }
        }
        else {
            for (int i = 0; i < item_count; ++i) {
                const double subshift = (i+0.5)*subsize - group_size/2;
                PlotBars(label_ids[i],&values[i*group_count],group_count,subsize,subshift+shift);
            }
        }
    }
}

#define INSTANTIATE_MACRO(T) template IMPLOT_API void PlotBarGroups<T>(const char* const label_ids[], const T* values, int items, int groups, double width, double shift, ImPlotBarGroupsFlags flags);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

//-----------------------------------------------------------------------------
// [SECTION] PlotErrorBars
//-----------------------------------------------------------------------------

template <typename _GetterPos, typename _GetterNeg>
void PlotErrorBarsVEx(const char* label_id, const _GetterPos& getter_pos, const _GetterNeg& getter_neg, ImPlotErrorBarsFlags flags) {
    if (BeginItemEx(label_id, Fitter2<_GetterPos,_GetterNeg>(getter_pos, getter_neg), flags, IMPLOT_AUTO)) {
        const ImPlotNextItemData& s = GetItemData();
        ImDrawList& draw_list = *GetPlotDrawList();
        const ImU32 col = ImGui::GetColorU32(s.Colors[ImPlotCol_ErrorBar]);
        const bool rend_whisker  = s.ErrorBarSize > 0;
        const float half_whisker = s.ErrorBarSize * 0.5f;
        for (int i = 0; i < getter_pos.Count; ++i) {
            ImVec2 p1 = PlotToPixels(getter_neg(i),IMPLOT_AUTO,IMPLOT_AUTO);
            ImVec2 p2 = PlotToPixels(getter_pos(i),IMPLOT_AUTO,IMPLOT_AUTO);
            draw_list.AddLine(p1,p2,col, s.ErrorBarWeight);
            if (rend_whisker) {
                draw_list.AddLine(p1 - ImVec2(half_whisker, 0), p1 + ImVec2(half_whisker, 0), col, s.ErrorBarWeight);
                draw_list.AddLine(p2 - ImVec2(half_whisker, 0), p2 + ImVec2(half_whisker, 0), col, s.ErrorBarWeight);
            }
        }
        EndItem();
    }
}

template <typename _GetterPos, typename _GetterNeg>
void PlotErrorBarsHEx(const char* label_id, const _GetterPos& getter_pos, const _GetterNeg& getter_neg, ImPlotErrorBarsFlags flags) {
    if (BeginItemEx(label_id, Fitter2<_GetterPos,_GetterNeg>(getter_pos, getter_neg), flags, IMPLOT_AUTO)) {
        const ImPlotNextItemData& s = GetItemData();
        ImDrawList& draw_list = *GetPlotDrawList();
        const ImU32 col = ImGui::GetColorU32(s.Colors[ImPlotCol_ErrorBar]);
        const bool rend_whisker  = s.ErrorBarSize > 0;
        const float half_whisker = s.ErrorBarSize * 0.5f;
        for (int i = 0; i < getter_pos.Count; ++i) {
            ImVec2 p1 = PlotToPixels(getter_neg(i),IMPLOT_AUTO,IMPLOT_AUTO);
            ImVec2 p2 = PlotToPixels(getter_pos(i),IMPLOT_AUTO,IMPLOT_AUTO);
            draw_list.AddLine(p1, p2, col, s.ErrorBarWeight);
            if (rend_whisker) {
                draw_list.AddLine(p1 - ImVec2(0, half_whisker), p1 + ImVec2(0, half_whisker), col, s.ErrorBarWeight);
                draw_list.AddLine(p2 - ImVec2(0, half_whisker), p2 + ImVec2(0, half_whisker), col, s.ErrorBarWeight);
            }
        }
        EndItem();
    }
}

template <typename T>
void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride) {
    PlotErrorBars(label_id, xs, ys, err, err, count, flags, offset, stride);
}

template <typename T>
void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride) {
    IndexerIdx<T> indexer_x(xs, count,offset,stride);
    IndexerIdx<T> indexer_y(ys, count,offset,stride);
    IndexerIdx<T> indexer_n(neg,count,offset,stride);
    IndexerIdx<T> indexer_p(pos,count,offset,stride);
    GetterError<T> getter(xs, ys, neg, pos, count, offset, stride);
    if (ImHasFlag(flags, ImPlotErrorBarsFlags_Horizontal)) {
        IndexerAdd<IndexerIdx<T>,IndexerIdx<T>> indexer_xp(indexer_x, indexer_p, 1,  1);
        IndexerAdd<IndexerIdx<T>,IndexerIdx<T>> indexer_xn(indexer_x, indexer_n, 1, -1);
        GetterXY<IndexerAdd<IndexerIdx<T>,IndexerIdx<T>>,IndexerIdx<T>> getter_p(indexer_xp, indexer_y, count);
        GetterXY<IndexerAdd<IndexerIdx<T>,IndexerIdx<T>>,IndexerIdx<T>> getter_n(indexer_xn, indexer_y, count);
        PlotErrorBarsHEx(label_id, getter_p, getter_n, flags);
    }
    else {
        IndexerAdd<IndexerIdx<T>,IndexerIdx<T>> indexer_yp(indexer_y, indexer_p, 1,  1);
        IndexerAdd<IndexerIdx<T>,IndexerIdx<T>> indexer_yn(indexer_y, indexer_n, 1, -1);
        GetterXY<IndexerIdx<T>,IndexerAdd<IndexerIdx<T>,IndexerIdx<T>>> getter_p(indexer_x, indexer_yp, count);
        GetterXY<IndexerIdx<T>,IndexerAdd<IndexerIdx<T>,IndexerIdx<T>>> getter_n(indexer_x, indexer_yn, count);
        PlotErrorBarsVEx(label_id, getter_p, getter_n, flags);
    }
}

#define INSTANTIATE_MACRO(T) \
    template IMPLOT_API void PlotErrorBars<T>(const char* label_id, const T* xs, const T* ys, const T* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride); \
    template IMPLOT_API void PlotErrorBars<T>(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

//-----------------------------------------------------------------------------
// [SECTION] PlotStems
//-----------------------------------------------------------------------------

template <typename _GetterM, typename _GetterB>
void PlotStemsEx(const char* label_id, const _GetterM& get_mark, const _GetterB& get_base, ImPlotStemsFlags flags) {
    if (BeginItemEx(label_id, Fitter2<_GetterM,_GetterB>(get_mark,get_base), flags, ImPlotCol_Line)) {
        const ImPlotNextItemData& s = GetItemData();
        // render stems
        if (s.RenderLine) {
            const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
            RenderPrimitives2<RendererLineSegments2>(get_mark, get_base, col_line, s.LineWeight);
        }
        // render markers
        if (s.Marker != ImPlotMarker_None) {
            PopPlotClipRect();
            PushPlotClipRect(s.MarkerSize);
            const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
            const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
            RenderMarkers<_GetterM>(get_mark, s.Marker, s.MarkerSize, s.RenderMarkerFill, col_fill, s.RenderMarkerLine, col_line, s.MarkerWeight);
        }
        EndItem();
    }
}

template <typename T>
void PlotStems(const char* label_id, const T* values, int count, double ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride) {
    if (ImHasFlag(flags, ImPlotStemsFlags_Horizontal)) {
        GetterXY<IndexerIdx<T>,IndexerLin> get_mark(IndexerIdx<T>(values,count,offset,stride),IndexerLin(scale,start),count);
        GetterXY<IndexerConst,IndexerLin>  get_base(IndexerConst(ref),IndexerLin(scale,start),count);
        PlotStemsEx(label_id, get_mark, get_base, flags);
    }
    else {
        GetterXY<IndexerLin,IndexerIdx<T>> get_mark(IndexerLin(scale,start),IndexerIdx<T>(values,count,offset,stride),count);
        GetterXY<IndexerLin,IndexerConst>  get_base(IndexerLin(scale,start),IndexerConst(ref),count);
        PlotStemsEx(label_id, get_mark, get_base, flags);
    }
}

template <typename T>
void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double ref, ImPlotStemsFlags flags, int offset, int stride) {
    if (ImHasFlag(flags, ImPlotStemsFlags_Horizontal)) {
        GetterXY<IndexerIdx<T>,IndexerIdx<T>> get_mark(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
        GetterXY<IndexerConst,IndexerIdx<T>>  get_base(IndexerConst(ref),IndexerIdx<T>(ys,count,offset,stride),count);
        PlotStemsEx(label_id, get_mark, get_base, flags);
    }
    else {
        GetterXY<IndexerIdx<T>,IndexerIdx<T>> get_mark(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
        GetterXY<IndexerIdx<T>,IndexerConst>  get_base(IndexerIdx<T>(xs,count,offset,stride),IndexerConst(ref),count);
        PlotStemsEx(label_id, get_mark, get_base, flags);
    }
}

#define INSTANTIATE_MACRO(T) \
    template IMPLOT_API void PlotStems<T>(const char* label_id, const T* values, int count, double ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride); \
    template IMPLOT_API void PlotStems<T>(const char* label_id, const T* xs, const T* ys, int count, double ref, ImPlotStemsFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO


//-----------------------------------------------------------------------------
// [SECTION] PlotInfLines
//-----------------------------------------------------------------------------

template <typename T>
void PlotInfLines(const char* label_id, const T* values, int count, ImPlotInfLinesFlags flags, int offset, int stride) {
    const ImPlotRect lims = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO);
    if (ImHasFlag(flags, ImPlotInfLinesFlags_Horizontal)) {
        GetterXY<IndexerConst,IndexerIdx<T>> get_min(IndexerConst(lims.X.Min),IndexerIdx<T>(values,count,offset,stride),count);
        GetterXY<IndexerConst,IndexerIdx<T>> get_max(IndexerConst(lims.X.Max),IndexerIdx<T>(values,count,offset,stride),count);
        if (BeginItemEx(label_id, FitterY<GetterXY<IndexerConst,IndexerIdx<T>>>(get_min), flags, ImPlotCol_Line)) {
            const ImPlotNextItemData& s = GetItemData();
            const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
            if (s.RenderLine)
                RenderPrimitives2<RendererLineSegments2>(get_min, get_max, col_line, s.LineWeight);
            EndItem();
        }
    }
    else {
        GetterXY<IndexerIdx<T>,IndexerConst> get_min(IndexerIdx<T>(values,count,offset,stride),IndexerConst(lims.Y.Min),count);
        GetterXY<IndexerIdx<T>,IndexerConst> get_max(IndexerIdx<T>(values,count,offset,stride),IndexerConst(lims.Y.Max),count);
        if (BeginItemEx(label_id, FitterX<GetterXY<IndexerIdx<T>,IndexerConst>>(get_min), flags, ImPlotCol_Line)) {
            const ImPlotNextItemData& s = GetItemData();
            const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
            if (s.RenderLine)
                RenderPrimitives2<RendererLineSegments2>(get_min, get_max, col_line, s.LineWeight);
            EndItem();
        }
    }
}
#define INSTANTIATE_MACRO(T) template IMPLOT_API void PlotInfLines<T>(const char* label_id, const T* xs, int count, ImPlotInfLinesFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

//-----------------------------------------------------------------------------
// [SECTION] PlotPieChart
//-----------------------------------------------------------------------------

IMPLOT_INLINE void RenderPieSlice(ImDrawList& draw_list, const ImPlotPoint& center, double radius, double a0, double a1, ImU32 col) {
    const float resolution = 50 / (2 * IM_PI);
    ImVec2 buffer[52];
    buffer[0] = PlotToPixels(center,IMPLOT_AUTO,IMPLOT_AUTO);
    int n = ImMax(3, (int)((a1 - a0) * resolution));
    double da = (a1 - a0) / (n - 1);
    int i = 0;
    for (; i < n; ++i) {
        double a = a0 + i * da;
        buffer[i + 1] = PlotToPixels(center.x + radius * cos(a), center.y + radius * sin(a),IMPLOT_AUTO,IMPLOT_AUTO);
    }
    buffer[i+1] = buffer[0];
    // fill
    draw_list.AddConvexPolyFilled(buffer, n + 1, col);
    // border (for AA)
    draw_list.AddPolyline(buffer, n + 2, col, 0, 2.0f);
}

template <typename T>
void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, const char* fmt, double angle0, ImPlotPieChartFlags flags) {
    IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != nullptr, "PlotPieChart() needs to be called between BeginPlot() and EndPlot()!");
    ImDrawList & draw_list = *GetPlotDrawList();
    double sum = 0;
    for (int i = 0; i < count; ++i)
        sum += (double)values[i];
    const bool normalize = ImHasFlag(flags,ImPlotPieChartFlags_Normalize) || sum > 1.0;
    ImPlotPoint center(x,y);
    PushPlotClipRect();
    double a0 = angle0 * 2 * IM_PI / 360.0;
    double a1 = angle0 * 2 * IM_PI / 360.0;
    ImPlotPoint Pmin = ImPlotPoint(x-radius,y-radius);
    ImPlotPoint Pmax = ImPlotPoint(x+radius,y+radius);
    for (int i = 0; i < count; ++i) {
        double percent = normalize ? (double)values[i] / sum : (double)values[i];
        a1 = a0 + 2 * IM_PI * percent;
        if (BeginItemEx(label_ids[i], FitterRect(Pmin,Pmax))) {
            ImU32 col = GetCurrentItem()->Color;
            if (percent < 0.5) {
                RenderPieSlice(draw_list, center, radius, a0, a1, col);
            }
            else  {
                RenderPieSlice(draw_list, center, radius, a0, a0 + (a1 - a0) * 0.5, col);
                RenderPieSlice(draw_list, center, radius, a0 + (a1 - a0) * 0.5, a1, col);
            }
            EndItem();
        }
        a0 = a1;
    }
    if (fmt != nullptr) {
        a0 = angle0 * 2 * IM_PI / 360.0;
        a1 = angle0 * 2 * IM_PI / 360.0;
        char buffer[32];
        for (int i = 0; i < count; ++i) {
            ImPlotItem* item = GetItem(label_ids[i]);
            double percent = normalize ? (double)values[i] / sum : (double)values[i];
            a1 = a0 + 2 * IM_PI * percent;
            if (item->Show) {
                ImFormatString(buffer, 32, fmt, (double)values[i]);
                ImVec2 size = ImGui::CalcTextSize(buffer);
                double angle = a0 + (a1 - a0) * 0.5;
                ImVec2 pos = PlotToPixels(center.x + 0.5 * radius * cos(angle), center.y + 0.5 * radius * sin(angle),IMPLOT_AUTO,IMPLOT_AUTO);
                ImU32 col  = CalcTextColor(ImGui::ColorConvertU32ToFloat4(item->Color));
                draw_list.AddText(pos - size * 0.5f, col, buffer);
            }
            a0 = a1;
        }
    }
    PopPlotClipRect();
}
#define INSTANTIATE_MACRO(T) template IMPLOT_API void PlotPieChart<T>(const char* const label_ids[], const T* values, int count, double x, double y, double radius, const char* fmt, double angle0, ImPlotPieChartFlags flags);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

//-----------------------------------------------------------------------------
// [SECTION] PlotHeatmap
//-----------------------------------------------------------------------------

template <typename T>
struct GetterHeatmapRowMaj {
    GetterHeatmapRowMaj(const T* values, int rows, int cols, double scale_min, double scale_max, double width, double height, double xref, double yref, double ydir) :
        Values(values),
        Count(rows*cols),
        Rows(rows),
        Cols(cols),
        ScaleMin(scale_min),
        ScaleMax(scale_max),
        Width(width),
        Height(height),
        XRef(xref),
        YRef(yref),
        YDir(ydir),
        HalfSize(Width*0.5, Height*0.5)
    { }
    template <typename I> IMPLOT_INLINE RectC operator()(I idx) const {
        double val = (double)Values[idx];
        const int r = idx / Cols;
        const int c = idx % Cols;
        const ImPlotPoint p(XRef + HalfSize.x + c*Width, YRef + YDir * (HalfSize.y + r*Height));
        RectC rect;
        rect.Pos = p;
        rect.HalfSize = HalfSize;
        const float t = ImClamp((float)ImRemap01(val, ScaleMin, ScaleMax),0.0f,1.0f);
        ImPlotContext& gp = *GImPlot;
        rect.Color = gp.ColormapData.LerpTable(gp.Style.Colormap, t);
        return rect;
    }
    const T* const Values;
    const int Count, Rows, Cols;
    const double ScaleMin, ScaleMax, Width, Height, XRef, YRef, YDir;
    const ImPlotPoint HalfSize;
};

template <typename T>
struct GetterHeatmapColMaj {
    GetterHeatmapColMaj(const T* values, int rows, int cols, double scale_min, double scale_max, double width, double height, double xref, double yref, double ydir) :
        Values(values),
        Count(rows*cols),
        Rows(rows),
        Cols(cols),
        ScaleMin(scale_min),
        ScaleMax(scale_max),
        Width(width),
        Height(height),
        XRef(xref),
        YRef(yref),
        YDir(ydir),
        HalfSize(Width*0.5, Height*0.5)
    { }
    template <typename I> IMPLOT_INLINE RectC operator()(I idx) const {
        double val = (double)Values[idx];
        const int r = idx % Cols;
        const int c = idx / Cols;
        const ImPlotPoint p(XRef + HalfSize.x + c*Width, YRef + YDir * (HalfSize.y + r*Height));
        RectC rect;
        rect.Pos = p;
        rect.HalfSize = HalfSize;
        const float t = ImClamp((float)ImRemap01(val, ScaleMin, ScaleMax),0.0f,1.0f);
        ImPlotContext& gp = *GImPlot;
        rect.Color = gp.ColormapData.LerpTable(gp.Style.Colormap, t);
        return rect;
    }
    const T* const Values;
    const int Count, Rows, Cols;
    const double ScaleMin, ScaleMax, Width, Height, XRef, YRef, YDir;
    const ImPlotPoint HalfSize;
};

template <typename T>
void RenderHeatmap(ImDrawList& draw_list, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, bool reverse_y, bool col_maj) {
    ImPlotContext& gp = *GImPlot;
    Transformer2 transformer;
    if (scale_min == 0 && scale_max == 0) {
        T temp_min, temp_max;
        ImMinMaxArray(values,rows*cols,&temp_min,&temp_max);
        scale_min = (double)temp_min;
        scale_max = (double)temp_max;
    }
    if (scale_min == scale_max) {
        ImVec2 a = transformer(bounds_min);
        ImVec2 b = transformer(bounds_max);
        ImU32  col = GetColormapColorU32(0,gp.Style.Colormap);
        draw_list.AddRectFilled(a, b, col);
        return;
    }
    const double yref = reverse_y ? bounds_max.y : bounds_min.y;
    const double ydir = reverse_y ? -1 : 1;
    if (col_maj) {
        GetterHeatmapColMaj<T> getter(values, rows, cols, scale_min, scale_max, (bounds_max.x - bounds_min.x) / cols, (bounds_max.y - bounds_min.y) / rows, bounds_min.x, yref, ydir);
        RenderPrimitives1<RendererRectC>(getter);
    }
    else {
        GetterHeatmapRowMaj<T> getter(values, rows, cols, scale_min, scale_max, (bounds_max.x - bounds_min.x) / cols, (bounds_max.y - bounds_min.y) / rows, bounds_min.x, yref, ydir);
        RenderPrimitives1<RendererRectC>(getter);
    }
    // labels
    if (fmt != nullptr) {
        const double w = (bounds_max.x - bounds_min.x) / cols;
        const double h = (bounds_max.y - bounds_min.y) / rows;
        const ImPlotPoint half_size(w*0.5,h*0.5);
        int i = 0;
        if (col_maj) {
            for (int c = 0; c < cols; ++c) {
                for (int r = 0; r < rows; ++r) {
                    ImPlotPoint p;
                    p.x = bounds_min.x + 0.5*w + c*w;
                    p.y = yref + ydir * (0.5*h + r*h);
                    ImVec2 px = transformer(p);
                    char buff[32];
                    ImFormatString(buff, 32, fmt, values[i]);
                    ImVec2 size = ImGui::CalcTextSize(buff);
                    double t = ImClamp(ImRemap01((double)values[i], scale_min, scale_max),0.0,1.0);
                    ImVec4 color = SampleColormap((float)t);
                    ImU32 col = CalcTextColor(color);
                    draw_list.AddText(px - size * 0.5f, col, buff);
                    i++;
                }
            }
        }
        else {
            for (int r = 0; r < rows; ++r) {
                for (int c = 0; c < cols; ++c) {
                    ImPlotPoint p;
                    p.x = bounds_min.x + 0.5*w + c*w;
                    p.y = yref + ydir * (0.5*h + r*h);
                    ImVec2 px = transformer(p);
                    char buff[32];
                    ImFormatString(buff, 32, fmt, values[i]);
                    ImVec2 size = ImGui::CalcTextSize(buff);
                    double t = ImClamp(ImRemap01((double)values[i], scale_min, scale_max),0.0,1.0);
                    ImVec4 color = SampleColormap((float)t);
                    ImU32 col = CalcTextColor(color);
                    draw_list.AddText(px - size * 0.5f, col, buff);
                    i++;
                }
            }
        }
    }
}

template <typename T>
void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, ImPlotHeatmapFlags flags) {
    if (BeginItemEx(label_id, FitterRect(bounds_min, bounds_max))) {
        ImDrawList& draw_list = *GetPlotDrawList();
        const bool col_maj = ImHasFlag(flags, ImPlotHeatmapFlags_ColMajor);
        RenderHeatmap(draw_list, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max, true, col_maj);
        EndItem();
    }
}
#define INSTANTIATE_MACRO(T) template IMPLOT_API void PlotHeatmap<T>(const char* label_id, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, ImPlotHeatmapFlags flags);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

//-----------------------------------------------------------------------------
// [SECTION] PlotHistogram
//-----------------------------------------------------------------------------

template <typename T>
double PlotHistogram(const char* label_id, const T* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags) {

    const bool cumulative = ImHasFlag(flags, ImPlotHistogramFlags_Cumulative);
    const bool density    = ImHasFlag(flags, ImPlotHistogramFlags_Density);
    const bool outliers   = !ImHasFlag(flags, ImPlotHistogramFlags_NoOutliers);

    if (count <= 0 || bins == 0)
        return 0;

    if (range.Min == 0 && range.Max == 0) {
        T Min, Max;
        ImMinMaxArray(values, count, &Min, &Max);
        range.Min = (double)Min;
        range.Max = (double)Max;
    }

    double width;
    if (bins < 0)
        CalculateBins(values, count, bins, range, bins, width);
    else
        width = range.Size() / bins;

    ImPlotContext& gp = *GImPlot;
    ImVector<double>& bin_centers = gp.TempDouble1;
    ImVector<double>& bin_counts  = gp.TempDouble2;
    bin_centers.resize(bins);
    bin_counts.resize(bins);
    int below = 0;

    for (int b = 0; b < bins; ++b) {
        bin_centers[b] = range.Min + b * width + width * 0.5;
        bin_counts[b] = 0;
    }
    int counted = 0;
    double max_count = 0;
    for (int i = 0; i < count; ++i) {
        double val = (double)values[i];
        if (range.Contains(val)) {
            const int b = ImClamp((int)((val - range.Min) / width), 0, bins - 1);
            bin_counts[b] += 1.0;
            if (bin_counts[b] > max_count)
                max_count = bin_counts[b];
            counted++;
        }
        else if (val < range.Min) {
            below++;
        }
    }
    if (cumulative && density) {
        if (outliers)
            bin_counts[0] += below;
        for (int b = 1; b < bins; ++b)
            bin_counts[b] += bin_counts[b-1];
        double scale = 1.0 / (outliers ? count : counted);
        for (int b = 0; b < bins; ++b)
            bin_counts[b] *= scale;
        max_count = bin_counts[bins-1];
    }
    else if (cumulative) {
        if (outliers)
            bin_counts[0] += below;
        for (int b = 1; b < bins; ++b)
            bin_counts[b] += bin_counts[b-1];
        max_count = bin_counts[bins-1];
    }
    else if (density) {
        double scale = 1.0 / ((outliers ? count : counted) * width);
        for (int b = 0; b < bins; ++b)
            bin_counts[b] *= scale;
        max_count *= scale;
    }
    if (ImHasFlag(flags, ImPlotHistogramFlags_Horizontal))
        PlotBars(label_id, &bin_counts.Data[0], &bin_centers.Data[0], bins, bar_scale*width, ImPlotBarsFlags_Horizontal);
    else
        PlotBars(label_id, &bin_centers.Data[0], &bin_counts.Data[0], bins, bar_scale*width);
    return max_count;
}
#define INSTANTIATE_MACRO(T) template IMPLOT_API double PlotHistogram<T>(const char* label_id, const T* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

//-----------------------------------------------------------------------------
// [SECTION] PlotHistogram2D
//-----------------------------------------------------------------------------

template <typename T>
double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags) {

    // const bool cumulative = ImHasFlag(flags, ImPlotHistogramFlags_Cumulative); NOT SUPPORTED
    const bool density  = ImHasFlag(flags, ImPlotHistogramFlags_Density);
    const bool outliers = !ImHasFlag(flags, ImPlotHistogramFlags_NoOutliers);
    const bool col_maj  = ImHasFlag(flags, ImPlotHistogramFlags_ColMajor);

    if (count <= 0 || x_bins == 0 || y_bins == 0)
        return 0;

    if (range.X.Min == 0 && range.X.Max == 0) {
        T Min, Max;
        ImMinMaxArray(xs, count, &Min, &Max);
        range.X.Min = (double)Min;
        range.X.Max = (double)Max;
    }
    if (range.Y.Min == 0 && range.Y.Max == 0) {
        T Min, Max;
        ImMinMaxArray(ys, count, &Min, &Max);
        range.Y.Min = (double)Min;
        range.Y.Max = (double)Max;
    }

    double width, height;
    if (x_bins < 0)
        CalculateBins(xs, count, x_bins, range.X, x_bins, width);
    else
        width = range.X.Size() / x_bins;
    if (y_bins < 0)
        CalculateBins(ys, count, y_bins, range.Y, y_bins, height);
    else
        height = range.Y.Size() / y_bins;

    const int bins = x_bins * y_bins;

    ImPlotContext& gp = *GImPlot;
    ImVector<double>& bin_counts = gp.TempDouble1;
    bin_counts.resize(bins);

    for (int b = 0; b < bins; ++b)
        bin_counts[b] = 0;

    int counted = 0;
    double max_count = 0;
    for (int i = 0; i < count; ++i) {
        if (range.Contains((double)xs[i], (double)ys[i])) {
            const int xb = ImClamp( (int)((double)(xs[i] - range.X.Min) / width)  , 0, x_bins - 1);
            const int yb = ImClamp( (int)((double)(ys[i] - range.Y.Min) / height) , 0, y_bins - 1);
            const int b  = yb * x_bins + xb;
            bin_counts[b] += 1.0;
            if (bin_counts[b] > max_count)
                max_count = bin_counts[b];
            counted++;
        }
    }
    if (density) {
        double scale = 1.0 / ((outliers ? count : counted) * width * height);
        for (int b = 0; b < bins; ++b)
            bin_counts[b] *= scale;
        max_count *= scale;
    }

    if (BeginItemEx(label_id, FitterRect(range))) {
        ImDrawList& draw_list = *GetPlotDrawList();
        RenderHeatmap(draw_list, &bin_counts.Data[0], y_bins, x_bins, 0, max_count, nullptr, range.Min(), range.Max(), false, col_maj);
        EndItem();
    }
    return max_count;
}
#define INSTANTIATE_MACRO(T) template IMPLOT_API double PlotHistogram2D<T>(const char* label_id,   const T*   xs, const T*   ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

//-----------------------------------------------------------------------------
// [SECTION] PlotDigital
//-----------------------------------------------------------------------------

// TODO: Make this behave like all the other plot types (.e. not fixed in y axis)

template <typename Getter>
void PlotDigitalEx(const char* label_id, Getter getter, ImPlotDigitalFlags flags) {
    if (BeginItem(label_id, flags, ImPlotCol_Fill)) {
        ImPlotContext& gp = *GImPlot;
        ImDrawList& draw_list = *GetPlotDrawList();
        const ImPlotNextItemData& s = GetItemData();
        if (getter.Count > 1 && s.RenderFill) {
            ImPlotPlot& plot   = *gp.CurrentPlot;
            ImPlotAxis& x_axis = plot.Axes[plot.CurrentX];
            ImPlotAxis& y_axis = plot.Axes[plot.CurrentY];

            int pixYMax = 0;
            ImPlotPoint itemData1 = getter(0);
            for (int i = 0; i < getter.Count; ++i) {
                ImPlotPoint itemData2 = getter(i);
                if (ImNanOrInf(itemData1.y)) {
                    itemData1 = itemData2;
                    continue;
                }
                if (ImNanOrInf(itemData2.y)) itemData2.y = ImConstrainNan(ImConstrainInf(itemData2.y));
                int pixY_0 = (int)(s.LineWeight);
                itemData1.y = ImMax(0.0, itemData1.y);
                float pixY_1_float = s.DigitalBitHeight * (float)itemData1.y;
                int pixY_1 = (int)(pixY_1_float); //allow only positive values
                int pixY_chPosOffset = (int)(ImMax(s.DigitalBitHeight, pixY_1_float) + s.DigitalBitGap);
                pixYMax = ImMax(pixYMax, pixY_chPosOffset);
                ImVec2 pMin = PlotToPixels(itemData1,IMPLOT_AUTO,IMPLOT_AUTO);
                ImVec2 pMax = PlotToPixels(itemData2,IMPLOT_AUTO,IMPLOT_AUTO);
                int pixY_Offset = 0; //20 pixel from bottom due to mouse cursor label
                pMin.y = (y_axis.PixelMin) + ((-gp.DigitalPlotOffset)                   - pixY_Offset);
                pMax.y = (y_axis.PixelMin) + ((-gp.DigitalPlotOffset) - pixY_0 - pixY_1 - pixY_Offset);
                //plot only one rectangle for same digital state
                while (((i+2) < getter.Count) && (itemData1.y == itemData2.y)) {
                    const int in = (i + 1);
                    itemData2 = getter(in);
                    if (ImNanOrInf(itemData2.y)) break;
                    pMax.x = PlotToPixels(itemData2,IMPLOT_AUTO,IMPLOT_AUTO).x;
                    i++;
                }
                //do not extend plot outside plot range
                if (pMin.x < x_axis.PixelMin) pMin.x = x_axis.PixelMin;
                if (pMax.x < x_axis.PixelMin) pMax.x = x_axis.PixelMin;
                if (pMin.x > x_axis.PixelMax) pMin.x = x_axis.PixelMax;
                if (pMax.x > x_axis.PixelMax) pMax.x = x_axis.PixelMax;
                //plot a rectangle that extends up to x2 with y1 height
                if ((pMax.x > pMin.x) && (gp.CurrentPlot->PlotRect.Contains(pMin) || gp.CurrentPlot->PlotRect.Contains(pMax))) {
                    // ImVec4 colAlpha = item->Color;
                    // colAlpha.w = item->Highlight ? 1.0f : 0.9f;
                    draw_list.AddRectFilled(pMin, pMax, ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]));
                }
                itemData1 = itemData2;
            }
            gp.DigitalPlotItemCnt++;
            gp.DigitalPlotOffset += pixYMax;
        }
        EndItem();
    }
}


template <typename T>
void PlotDigital(const char* label_id, const T* xs, const T* ys, int count, ImPlotDigitalFlags flags, int offset, int stride) {
    GetterXY<IndexerIdx<T>,IndexerIdx<T>> getter(IndexerIdx<T>(xs,count,offset,stride),IndexerIdx<T>(ys,count,offset,stride),count);
    return PlotDigitalEx(label_id, getter, flags);
}
#define INSTANTIATE_MACRO(T) template IMPLOT_API void PlotDigital<T>(const char* label_id, const T* xs, const T* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
CALL_INSTANTIATE_FOR_NUMERIC_TYPES()
#undef INSTANTIATE_MACRO

// custom
void PlotDigitalG(const char* label_id, ImPlotGetter getter_func, void* data, int count, ImPlotDigitalFlags flags) {
    GetterFuncPtr getter(getter_func,data,count);
    return PlotDigitalEx(label_id, getter, flags);
}

//-----------------------------------------------------------------------------
// [SECTION] PlotImage
//-----------------------------------------------------------------------------

void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPoint& bmin, const ImPlotPoint& bmax, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& tint_col, ImPlotImageFlags) {
    if (BeginItemEx(label_id, FitterRect(bmin,bmax))) {
        ImU32 tint_col32 = ImGui::ColorConvertFloat4ToU32(tint_col);
        GetCurrentItem()->Color = tint_col32;
        ImDrawList& draw_list = *GetPlotDrawList();
        ImVec2 p1 = PlotToPixels(bmin.x, bmax.y,IMPLOT_AUTO,IMPLOT_AUTO);
        ImVec2 p2 = PlotToPixels(bmax.x, bmin.y,IMPLOT_AUTO,IMPLOT_AUTO);
        PushPlotClipRect();
        draw_list.AddImage(user_texture_id, p1, p2, uv0, uv1, tint_col32);
        PopPlotClipRect();
        EndItem();
    }
}

//-----------------------------------------------------------------------------
// [SECTION] PlotText
//-----------------------------------------------------------------------------

void PlotText(const char* text, double x, double y, const ImVec2& pixel_offset, ImPlotTextFlags flags) {
    IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != nullptr, "PlotText() needs to be called between BeginPlot() and EndPlot()!");
    SetupLock();
    ImDrawList & draw_list = *GetPlotDrawList();
    PushPlotClipRect();
    ImU32 colTxt = GetStyleColorU32(ImPlotCol_InlayText);
    if (ImHasFlag(flags,ImPlotTextFlags_Vertical)) {
        ImVec2 siz = CalcTextSizeVertical(text) * 0.5f;
        ImVec2 ctr = siz * 0.5f;
        ImVec2 pos = PlotToPixels(ImPlotPoint(x,y),IMPLOT_AUTO,IMPLOT_AUTO) + ImVec2(-ctr.x, ctr.y) + pixel_offset;
        if (FitThisFrame() && !ImHasFlag(flags, ImPlotItemFlags_NoFit)) {
            FitPoint(PixelsToPlot(pos));
            FitPoint(PixelsToPlot(pos.x + siz.x, pos.y - siz.y));
        }
        AddTextVertical(&draw_list, pos, colTxt, text);
    }
    else {
        ImVec2 siz = ImGui::CalcTextSize(text);
        ImVec2 pos = PlotToPixels(ImPlotPoint(x,y),IMPLOT_AUTO,IMPLOT_AUTO) - siz * 0.5f + pixel_offset;
        if (FitThisFrame() && !ImHasFlag(flags, ImPlotItemFlags_NoFit)) {
            FitPoint(PixelsToPlot(pos));
            FitPoint(PixelsToPlot(pos+siz));
        }
        draw_list.AddText(pos, colTxt, text);
    }
    PopPlotClipRect();
}

//-----------------------------------------------------------------------------
// [SECTION] PlotDummy
//-----------------------------------------------------------------------------

void PlotDummy(const char* label_id, ImPlotDummyFlags flags) {
    if (BeginItem(label_id, flags, ImPlotCol_Line))
        EndItem();
}

} // namespace ImPlot


================================================
FILE: Source/External/imgui_tools/xmake.lua
================================================


================================================
FILE: Source/External/mustache/mustache.hpp
================================================
/*
 * Boost Software License - Version 1.0
 *
 * Mustache
 * Copyright 2015-2020 Kevin Wojniak
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 *
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef KAINJOW_MUSTACHE_HPP
#define KAINJOW_MUSTACHE_HPP

#include <cassert>
#include <cctype>
#include <functional>
#include <iostream>
#include <memory>
#include <sstream>
#include <unordered_map>
#include <vector>

#define KAINJOW_MUSTACHE_VERSION_MAJOR 5
#define KAINJOW_MUSTACHE_VERSION_MINOR 0
#define KAINJOW_MUSTACHE_VERSION_PATCH 0

namespace kainjow {
namespace mustache {

template <typename string_type>
string_type trim(const string_type& s) {
    auto it = s.begin();
    while (it != s.end() && std::isspace(*it)) {
        it++;
    }
    auto rit = s.rbegin();
    while (rit.base() != it && std::isspace(*rit)) {
        rit++;
    }
    return {it, rit.base()};
}

template <typename string_type>
string_type html_escape(const string_type& s) {
    string_type ret;
    ret.reserve(s.size()*2);
    for (const auto ch : s) {
        switch (ch) {
            case '&':
                ret.append({'&','a','m','p',';'});
                break;
            case '<':
                ret.append({'&','l','t',';'});
                break;
            case '>':
                ret.append({'&','g','t',';'});
                break;
            case '\"':
                ret.append({'&','q','u','o','t',';'});
                break;
            case '\'':
                ret.append({'&','a','p','o','s',';'});
                break;
            default:
                ret.append(1, ch);
                break;
        }
    }
    return ret;
}

template <typename string_type>
std::vector<string_type> split(const string_type& s, typename string_type::value_type delim) {
    std::vector<string_type> elems;
    std::basic_stringstream<typename string_type::value_type> ss(s);
    string_type item;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

template <typename string_type>
class basic_renderer {
public:
    using type1 = std::function<string_type(const string_type&)>;
    using type2 = std::function<string_type(const string_type&, bool escaped)>;

    string_type operator()(const string_type& text) const {
        return type1_(text);
    }

    string_type operator()(const string_type& text, bool escaped) const {
        return type2_(text, escaped);
    }

private:
    basic_renderer(const type1& t1, const type2& t2)
        : type1_(t1)
        , type2_(t2)
    {}

    const type1& type1_;
    const type2& type2_;

    template <typename StringType>
    friend class basic_mustache;
};

template <typename string_type>
class basic_lambda_t {
public:
    using type1 = std::function<string_type(const string_type&)>;
    using type2 = std::function<string_type(const string_type&, const basic_renderer<string_type>& render)>;

    basic_lambda_t(const type1& t) : type1_(new type1(t)) {}
    basic_lambda_t(const type2& t) : type2_(new type2(t)) {}

    bool is_type1() const { return static_cast<bool>(type1_); }
    bool is_type2() const { return static_cast<bool>(type2_); }

    const type1& type1_value() const { return *type1_; }
    const type2& type2_value() const { return *type2_; }

    // Copying
    basic_lambda_t(const basic_lambda_t& l) {
        if (l.type1_) {
            type1_.reset(new type1(*l.type1_));
        } else if (l.type2_) {
            type2_.reset(new type2(*l.type2_));
        }
    }

    string_type operator()(const string_type& text) const {
        return (*type1_)(text);
    }

    string_type operator()(const string_type& text, const basic_renderer<string_type>& render) const {
        return (*type2_)(text, render);
    }

private:
    std::unique_ptr<type1> type1_;
    std::unique_ptr<type2> type2_;
};

template <typename string_type>
class basic_data;
template <typename string_type>
using basic_object = std::unordered_map<string_type, basic_data<string_type>>;
template <typename string_type>
using basic_list = std::vector<basic_data<string_type>>;
template <typename string_type>
using basic_partial = std::function<string_type()>;
template <typename string_type>
using basic_lambda = typename basic_lambda_t<string_type>::type1;
template <typename string_type>
using basic_lambda2 = typename basic_lambda_t<string_type>::type2;

template <typename string_type>
class basic_data {
public:
    enum class type {
        object,
        string,
        list,
        bool_true,
        bool_false,
        partial,
        lambda,
        lambda2,
        invalid,
    };

    // Construction
    basic_data() : basic_data(type::object) {
    }
    basic_data(const string_type& string) : type_{type::string} {
        str_.reset(new string_type(string));
    }
    basic_data(const typename string_type::value_type* string) : type_{type::string} {
        str_.reset(new string_type(string));
    }
    basic_data(const basic_object<string_type>& obj) : type_{type::object} {
        obj_.reset(new basic_object<string_type>(obj));
    }
    basic_data(const basic_list<string_type>& l) : type_{type::list} {
        list_.reset(new basic_list<string_type>(l));
    }
    basic_data(type t) : type_{t} {
        switch (type_) {
            case type::object:
                obj_.reset(new basic_object<string_type>);
                break;
            case type::string:
                str_.reset(new string_type);
                break;
            case type::list:
                list_.reset(new basic_list<string_type>);
                break;
            default:
                break;
        }
    }
    basic_data(const string_type& name, const basic_data& var) : basic_data{} {
        set(name, var);
    }
    basic_data(const basic_partial<string_type>& p) : type_{type::partial} {
        partial_.reset(new basic_partial<string_type>(p));
    }
    basic_data(const basic_lambda<string_type>& l) : type_{type::lambda} {
        lambda_.reset(new basic_lambda_t<string_type>(l));
    }
    basic_data(const basic_lambda2<string_type>& l) : type_{type::lambda2} {
        lambda_.reset(new basic_lambda_t<string_type>(l));
    }
    basic_data(const basic_lambda_t<string_type>& l) {
        if (l.is_type1()) {
            type_ = type::lambda;
        } else if (l.is_type2()) {
            type_ = type::lambda2;
        }
        lambda_.reset(new basic_lambda_t<string_type>(l));
    }
    basic_data(bool b) : type_{b ? type::bool_true : type::bool_false} {
    }

    // Copying
    basic_data(const basic_data& dat) : type_(dat.type_) {
        if (dat.obj_) {
            obj_.reset(new basic_object<string_type>(*dat.obj_));
        } else if (dat.str_) {
            str_.reset(new string_type(*dat.str_));
        } else if (dat.list_) {
            list_.reset(new basic_list<string_type>(*dat.list_));
        } else if (dat.partial_) {
            partial_.reset(new basic_partial<string_type>(*dat.partial_));
        } else if (dat.lambda_) {
            lambda_.reset(new basic_lambda_t<string_type>(*dat.lambda_));
        }
    }

    // Move
    basic_data(basic_data&& dat) : type_{dat.type_} {
        if (dat.obj_) {
            obj_ = std::move(dat.obj_);
        } else if (dat.str_) {
            str_ = std::move(dat.str_);
        } else if (dat.list_) {
            list_ = std::move(dat.list_);
        } else if (dat.partial_) {
            partial_ = std::move(dat.partial_);
        } else if (dat.lambda_) {
            lambda_ = std::move(dat.lambda_);
        }
        dat.type_ = type::invalid;
    }
    basic_data& operator= (basic_data&& dat) {
        if (this != &dat) {
            obj_.reset();
            str_.reset();
            list_.reset();
            partial_.reset();
            lambda_.reset();
            if (dat.obj_) {
                obj_ = std::move(dat.obj_);
            } else if (dat.str_) {
                str_ = std::move(dat.str_);
            } else if (dat.list_) {
                list_ = std::move(dat.list_);
            } else if (dat.partial_) {
                partial_ = std::move(dat.partial_);
            } else if (dat.lambda_) {
                lambda_ = std::move(dat.lambda_);
            }
            type_ = dat.type_;
            dat.type_ = type::invalid;
        }
        return *this;
    }

    // Type info
    bool is_object() const {
        return type_ == type::object;
    }
    bool is_string() const {
        return type_ == type::string;
    }
    bool is_list() const {
        return type_ == type::list;
    }
    bool is_bool() const {
        return is_true() || is_false();
    }
    bool is_true() const {
        return type_ == type::bool_true;
    }
    bool is_false() const {
        return type_ == type::bool_false;
    }
    bool is_partial() const {
        return type_ == type::partial;
    }
    bool is_lambda() const {
        return type_ == type::lambda;
    }
    bool is_lambda2() const {
        return type_ == type::lambda2;
    }
    bool is_invalid() const {
        return type_ == type::invalid;
    }

    // Object data
    bool is_empty_object() const {
        return is_object() && obj_->empty();
    }
    bool is_non_empty_object() const {
        return is_object() && !obj_->empty();
    }
    void set(const string_type& name, const basic_data& var) {
        if (is_object()) {
            auto it = obj_->find(name);
            if (it != obj_->end()) {
                obj_->erase(it);
            }
            obj_->insert(std::pair<string_type,basic_data>{name, var});
        }
    }
    const basic_data* get(const string_type& name) const {
        if (!is_object()) {
            return nullptr;
        }
        const auto& it = obj_->find(name);
        if (it == obj_->end()) {
            return nullptr;
        }
        return &it->second;
    }

    // List data
    void push_back(const basic_data& var) {
        if (is_list()) {
            list_->push_back(var);
        }
    }
    const basic_list<string_type>& list_value() const {
        return *list_;
    }
    bool is_empty_list() const {
        return is_list() && list_->empty();
    }
    bool is_non_empty_list() const {
        return is_list() && !list_->empty();
    }
    basic_data& operator<< (const basic_data& data) {
        push_back(data);
        return *this;
    }

    // String data
    const string_type& string_value() const {
        return *str_;
    }

    basic_data& operator[] (const string_type& key) {
        return (*obj_)[key];
    }

    const basic_partial<string_type>& partial_value() const {
        return (*partial_);
    }

    const basic_lambda<string_type>& lambda_value() const {
        return lambda_->type1_value();
    }

    const basic_lambda2<string_type>& lambda2_value() const {
        return lambda_->type2_value();
    }

private:
    type type_;
    std::unique_ptr<basic_object<string_type>> obj_;
    std::unique_ptr<string_type> str_;
    std::unique_ptr<basic_list<string_type>> list_;
    std::unique_ptr<basic_partial<string_type>> partial_;
    std::unique_ptr<basic_lambda_t<string_type>> lambda_;
};

template <typename string_type>
class delimiter_set {
public:
    string_type begin;
    string_type end;
    delimiter_set()
        : begin(default_begin)
        , end(default_end)
    {}
    bool is_default() const { return begin == default_begin && end == default_end; }
    static const string_type default_begin;
    static const string_type default_end;
};

template <typename string_type>
const string_type delimiter_set<string_type>::default_begin(2, '{');
template <typename string_type>
const string_type delimiter_set<string_type>::default_end(2, '}');

template <typename string_type>
class basic_context {
public:
    virtual ~basic_context() = default;
    virtual void push(const basic_data<string_type>* data) = 0;
    virtual void pop() = 0;

    virtual const basic_data<string_type>* get(const string_type& name) const = 0;
    virtual const basic_data<string_type>* get_partial(const string_type& name) const = 0;
};

template <typename string_type>
class context : public basic_context<string_type> {
public:
    context(const basic_data<string_type>* data) {
        push(data);
    }

    context() {
    }

    virtual void push(const basic_data<string_type>* data) override {
        items_.insert(items_.begin(), data);
    }

    virtual void pop() override {
        items_.erase(items_.begin());
    }

    virtual const basic_data<string_type>* get(const string_type& name) const override {
        // process {{.}} name
        if (name.size() == 1 && name.at(0) == '.') {
            return items_.front();
        }
        if (name.find('.') == string_type::npos) {
            // process normal name without having to split which is slower
            for (const auto& item : items_) {
                const auto var = item->get(name);
                if (var) {
                    return var;
                }
            }
            return nullptr;
        }
        // process x.y-like name
        const auto names = split(name, '.');
        for (const auto& item : items_) {
            auto var = item;
            for (const auto& n : names) {
                var = var->get(n);
                if (!var) {
                    break;
                }
            }
            if (var) {
                return var;
            }
        }
        return nullptr;
    }

    virtual const basic_data<string_type>* get_partial(const string_type& name) const override {
        for (const auto& item : items_) {
            const auto var = item->get(name);
            if (var) {
                return var;
            }
        }
        return nullptr;
    }

    context(const context&) = delete;
    context& operator= (const context&) = delete;

private:
    std::vector<const basic_data<string_type>*> items_;
};

template <typename string_type>
class line_buffer_state {
public:
    string_type data;
    bool contained_section_tag = false;

    bool is_empty_or_contains_only_whitespace() const {
        for (const auto ch : data) {
            // don't look at newlines
            if (ch != ' ' && ch != '\t') {
                return false;
            }
        }
        return true;
    }

    void clear() {
        data.clear();
        contained_section_tag = false;
    }
};

template <typename string_type>
class context_internal {
public:
    basic_context<string_type>& ctx;
    delimiter_set<string_type> delim_set;
    line_buffer_state<string_type> line_buffer;

    context_internal(basic_context<string_type>& a_ctx)
        : ctx(a_ctx)
    {
    }
};

enum class tag_type {
    text,
    variable,
    unescaped_variable,
    section_begin,
    section_end,
    section_begin_inverted,
    comment,
    partial,
    set_delimiter,
};

template <typename string_type>
class mstch_tag /* gcc doesn't allow "tag tag;" so rename the class :( */ {
public:
    string_type name;
    tag_type type = tag_type::text;
    std::shared_ptr<string_type> section_text;
    std::shared_ptr<delimiter_set<string_type>> delim_set;
    bool is_section_begin() const {
        return type == tag_type::section_begin || type == tag_type::section_begin_inverted;
    }
    bool is_section_end() const {
        return type == tag_type::section_end;
    }
};

template <typename string_type>
class context_pusher {
public:
    context_pusher(context_internal<string_type>& ctx, const basic_data<string_type>* data)
        : ctx_(ctx)
    {
        ctx.ctx.push(data);
    }
    ~context_pusher() {
        ctx_.ctx.pop();
    }
    context_pusher(const context_pusher&) = delete;
    context_pusher& operator= (const context_pusher&) = delete;
private:
    context_internal<string_type>& ctx_;
};

template <typename string_type>
class component {
private:
    using string_size_type = typename string_type::size_type;

public:
    string_type text;
    mstch_tag<string_type> tag;
    std::vector<component> children;
    string_size_type position = string_type::npos;

    enum class walk_control {
        walk, // "continue" is reserved :/
        stop,
        skip,
    };
    using walk_callback = std::function<walk_control(component&)>;

    component() {}
    component(const string_type& t, string_size_type p) : text(t), position(p) {}

    bool is_text() const {
        return tag.type == tag_type::text;
    }

    bool is_newline() const {
        return is_text() && ((text.size() == 2 && text[0] == '\r' && text[1] == '\n') ||
        (text.size() == 1 && (text[0] == '\n' || text[0] == '\r')));
    }

    bool is_non_newline_whitespace() const {
        return is_text() && !is_newline() && text.size() == 1 && (text[0] == ' ' || text[0] == '\t');
    }

    void walk_children(const walk_callback& callback) {
        for (auto& child : children) {
            if (child.walk(callback) != walk_control::walk) {
                break;
            }
        }
    }

private:
    walk_control walk(const walk_callback& callback) {
        walk_control control{callback(*this)};
        if (control == walk_control::stop) {
            return control;
        } else if (control == walk_control::skip) {
            return walk_control::walk;
        }
        for (auto& child : children) {
            control = child.walk(callback);
            if (control == walk_control::stop) {
                return control;
            }
        }
        return control;
    }
};

template <typename string_type>
class parser {
public:
    parser(const string_type& input, context_internal<string_type>& ctx, component<string_type>& root_component, string_type& error_message)
    {
        parse(input, ctx, root_component, error_message);
    }

private:
    void parse(const string_type& input, context_internal<string_type>& ctx, component<string_type>& root_component, string_type& error_message) const {
        using string_size_type = typename string_type::size_type;
        using streamstring = std::basic_ostringstream<typename string_type::value_type>;

        const string_type brace_delimiter_end_unescaped(3, '}');
        const string_size_type input_size{input.size()};

        bool current_delimiter_is_brace{ctx.delim_set.is_default()};

        std::vector<component<string_type>*> sections{&root_component};
        std::vector<string_size_type> section_starts;
        string_type current_text;
        string_size_type current_text_position = string_type::npos;

        current_text.reserve(input_size);

        const auto process_current_text = [&current_text, &current_text_position, &sections]() {
            if (!current_text.empty()) {
                const component<string_type> comp{current_text, current_text_position};
                sections.back()->children.push_back(comp);
                current_text.clear();
                current_text_position = string_type::npos;
            }
        };

        const std::vector<string_type> whitespace{
            string_type(1, '\r') + string_type(1, '\n'),
            string_type(1, '\n'),
            string_type(1, '\r'),
            string_type(1, ' '),
            string_type(1, '\t'),
        };

        for (string_size_type input_position = 0; input_position != input_size;) {
            bool parse_tag = false;

            if (input.compare(input_position, ctx.delim_set.begin.size(), ctx.delim_set.begin) == 0) {
                process_current_text();

                // Tag start delimiter
                parse_tag = true;
            } else {
                bool parsed_whitespace = false;
                for (const auto& whitespace_text : whitespace) {
                    if (input.compare(input_position, whitespace_text.size(), whitespace_text) == 0) {
                        process_current_text();

                        const component<string_type> comp{whitespace_text, input_position};
                        sections.back()->children.push_back(comp);
                        input_position += whitespace_text.size();

                        parsed_whitespace = true;
                        break;
                    }
                }

                if (!parsed_whitespace) {
                    if (current_text.empty()) {
                        current_text_position = input_position;
                    }
                    current_text.append(1, input[input_position]);
                    input_position++;
                }
            }

            if (!parse_tag) {
                continue;
            }

            // Find the next tag start delimiter
            const string_size_type tag_location_start = input_position;

            // Find the next tag end delimiter
            string_size_type tag_contents_location{tag_location_start + ctx.delim_set.begin.size()};
            const bool tag_is_unescaped_var{current_delimiter_is_brace && tag_location_start != (input_size - 2) && input.at(tag_contents_location) == ctx.delim_set.begin.at(0)};
            const string_type& current_tag_delimiter_end{tag_is_unescaped_var ? brace_delimiter_end_unescaped : ctx.delim_set.end};
            const auto current_tag_delimiter_end_size = current_tag_delimiter_end.size();
            if (tag_is_unescaped_var) {
                ++tag_contents_location;
            }
            const string_size_type tag_location_end{input.find(current_tag_delimiter_end, tag_contents_location)};
            if (tag_location_end == string_type::npos) {
                streamstring ss;
                ss << "Unclosed tag at " << tag_location_start;
                error_message.assign(ss.str());
                return;
            }

            // Parse tag
            const string_type tag_contents{trim(string_type{input, tag_contents_location, tag_location_end - tag_contents_location})};
            component<string_type> comp;
            if (!tag_contents.empty() && tag_contents[0] == '=') {
                if (!parse_set_delimiter_tag(tag_contents, ctx.delim_set)) {
                    streamstring ss;
                    ss << "Invalid set delimiter tag at " << tag_location_start;
                    error_message.assign(ss.str());
                    return;
                }
                current_delimiter_is_brace = ctx.delim_set.is_default();
                comp.tag.type = tag_type::set_delimiter;
                comp.tag.delim_set.reset(new delimiter_set<string_type>(ctx.delim_set));
            }
            if (comp.tag.type != tag_type::set_delimiter) {
                parse_tag_contents(tag_is_unescaped_var, tag_contents, comp.tag);
            }
            comp.position = tag_location_start;
            sections.back()->children.push_back(comp);

            // Start next search after this tag
            input_position = tag_location_end + current_tag_delimiter_end_size;

            // Push or pop sections
            if (comp.tag.is_section_begin()) {
                sections.push_back(&sections.back()->children.back());
                section_starts.push_back(input_position);
            } else if (comp.tag.is_section_end()) {
                if (sections.size() == 1) {
                    streamstring ss;
                    ss << "Unopened section \"" << comp.tag.name << "\" at " << comp.position;
                    error_message.assign(ss.str());
                    return;
                }
                sections.back()->tag.section_text.reset(new string_type(input.substr(section_starts.back(), tag_location_start - section_starts.back())));
                sections.pop_back();
                section_starts.pop_back();
            }
        }

        process_current_text();

        // Check for sections without an ending tag
        root_component.walk_children([&error_message](component<string_type>& comp) -> typename component<string_type>::walk_control {
            if (!comp.tag.is_section_begin()) {
                return component<string_type>::walk_control::walk;
            }
            if (comp.children.empty() || !comp.children.back().tag.is_section_end() || comp.children.back().tag.name != comp.tag.name) {
                streamstring ss;
                ss << "Unclosed section \"" << comp.tag.name << "\" at " << comp.position;
                error_message.assign(ss.str());
                return component<string_type>::walk_control::stop;
            }
            comp.children.pop_back(); // remove now useless end section component
            return component<string_type>::walk_control::walk;
        });
        if (!error_message.empty()) {
            return;
        }
    }

    bool is_set_delimiter_valid(const string_type& delimiter) const {
        // "Custom delimiters may not contain whitespace or the equals sign."
        for (const auto ch : delimiter) {
            if (ch == '=' || std::isspace(ch)) {
                return false;
            }
        }
        return true;
    }

    bool parse_set_delimiter_tag(const string_type& contents, delimiter_set<string_type>& delimiter_set) const {
        // Smallest legal tag is "=X X="
        if (contents.size() < 5) {
            return false;
        }
        if (contents.back() != '=') {
            return false;
        }
        const auto contents_substr = trim(contents.substr(1, contents.size() - 2));
        const auto spacepos = contents_substr.find(' ');
        if (spacepos == string_type::npos) {
            return false;
        }
        const auto nonspace = contents_substr.find_first_not_of(' ', spacepos + 1);
        assert(nonspace != string_type::npos);
        const string_type begin = contents_substr.substr(0, spacepos);
        const string_type end = contents_substr.substr(nonspace, contents_substr.size() - nonspace);
        if (!is_set_delimiter_valid(begin) || !is_set_delimiter_valid(end)) {
            return false;
        }
        delimiter_set.begin = begin;
        delimiter_set.end = end;
        return true;
    }

    void parse_tag_contents(bool is_unescaped_var, const string_type& contents, mstch_tag<string_type>& tag) const {
        if (is_unescaped_var) {
            tag.type = tag_type::unescaped_variable;
            tag.name = contents;
        } else if (contents.empty()) {
            tag.type = tag_type::variable;
            tag.name.clear();
        } else {
            switch (contents.at(0)) {
                case '#':
                    tag.type = tag_type::section_begin;
                    break;
                case '^':
                    tag.type = tag_type::section_begin_inverted;
                    break;
                case '/':
                    tag.type = tag_type::section_end;
                    break;
                case '>':
                    tag.type = tag_type::partial;
                    break;
                case '&':
                    tag.type = tag_type::unescaped_variable;
                    break;
                case '!':
                    tag.type = tag_type::comment;
                    break;
                default:
                    tag.type = tag_type::variable;
                    break;
            }
            if (tag.type == tag_type::variable) {
                tag.name = contents;
            } else {
                string_type name{contents};
                name.erase(name.begin());
                tag.name = trim(name);
            }
        }
    }
};

template <typename StringType>
class basic_mustache {
public:
    using string_type = StringType;

    basic_mustache(const string_type& input)
        : basic_mustache() {
        context<string_type> ctx;
        context_internal<string_type> context{ctx};
        parser<string_type> parser{input, context, root_component_, error_message_};
    }

    bool is_valid() const {
        return error_message_.empty();
    }

    const string_type& error_message() const {
        return error_message_;
    }

    using escape_handler = std::function<string_type(const string_type&)>;
    void set_custom_escape(const escape_handler& escape_fn) {
        escape_ = escape_fn;
    }

    template <typename stream_type>
    stream_type& render(const basic_data<string_type>& data, stream_type& stream) {
        render(data, [&stream](const string_type& str) {
            stream << str;
        });
        return stream;
    }

    string_type render(const basic_data<string_type>& data) {
        std::basic_ostringstream<typename string_type::value_type> ss;
        return render(data, ss).str();
    }

    template <typename stream_type>
    stream_type& render(basic_context<string_type>& ctx, stream_type& stream) {
        context_internal<string_type> context{ctx};
        render([&stream](const string_type& str) {
            stream << str;
        }, context);
        return stream;
    }

    string_type render(basic_context<string_type>& ctx) {
        std::basic_ostringstream<typename string_type::value_type> ss;
        return render(ctx, ss).str();
    }

    using render_handler = std::function<void(const string_type&)>;
    void render(const basic_data<string_type>& data, const render_handler& handler) {
        if (!is_valid()) {
            return;
        }
        context<string_type> ctx{&data};
        context_internal<string_type> context{ctx};
        render(handler, context);
    }

    basic_mustache()
        : escape_(html_escape<string_type>)
    {
    }
    
private:
    using string_size_type = typename string_type::size_type;


    basic_mustache(const string_type& input, context_internal<string_type>& ctx)
        : basic_mustache() {
        parser<string_type> parser{input, ctx, root_component_, error_message_};
    }

    string_type render(context_internal<string_type>& ctx) {
        std::basic_ostringstream<typename string_type::value_type> ss;
        render([&ss](const string_type& str) {
            ss << str;
        }, ctx);
        return ss.str();
    }

    void render(const render_handler& handler, context_internal<string_type>& ctx, bool root_renderer = true) {
        root_component_.walk_children([&handler, &ctx, this](component<string_type>& comp) -> typename component<string_type>::walk_control {
            return render_component(handler, ctx, comp);
        });
        // process the last line, but only for the top-level renderer
        if (root_renderer) {
            render_current_line(handler, ctx, nullptr);
        }
    }

    void render_current_line(const render_handler& handler, context_internal<string_type>& ctx, const component<string_type>* comp) const {
        // We're at the end of a line, so check the line buffer state to see
        // if the line had tags in it, and also if the line is now empty or
        // contains whitespace only. if this situation is true, skip the line.
        bool output = true;
        if (ctx.line_buffer.contained_section_tag && ctx.line_buffer.is_empty_or_contains_only_whitespace()) {
            output = false;
        }
        if (output) {
            handler(ctx.line_buffer.data);
            if (comp) {
                handler(comp->text);
            }
        }
        ctx.line_buffer.clear();
    }

    void render_result(context_internal<string_type>& ctx, const string_type& text) const {
        ctx.line_buffer.data.append(text);
    }

    typename component<string_type>::walk_control render_component(const render_handler& handler, context_internal<string_type>& ctx, component<string_type>& comp) {
        if (comp.is_text()) {
            if (comp.is_newline()) {
                render_current_line(handler, ctx, &comp);
            } else {
                render_result(ctx, comp.text);
            }
            return component<string_type>::walk_control::walk;
        }

        const mstch_tag<string_type>& tag{comp.tag};
        const basic_data<string_type>* var = nullptr;
        switch (tag.type) {
            case tag_type::variable:
            case tag_type::unescaped_variable:
                if ((var = ctx.ctx.get(tag.name)) != nullptr) {
                    if (!render_variable(handler, var, ctx, tag.type == tag_type::variable)) {
                        return component<string_type>::walk_control::stop;
                    }
                }
                break;
            case tag_type::section_begin:
                if ((var = ctx.ctx.get(tag.name)) != nullptr) {
                    if (var->is_lambda() || var->is_lambda2()) {
                        if (!render_lambda(handler, var, ctx, render_lambda_escape::optional, *comp.tag.section_text, true)) {
                            return component<string_type>::walk_control::stop;
                        }
                    } else if (!var->is_false() && !var->is_empty_list()) {
                        render_section(handler, ctx, comp, var);
                    }
                }
                return component<string_type>::walk_control::skip;
            case tag_type::section_begin_inverted:
                if ((var = ctx.ctx.get(tag.name)) == nullptr || var->is_false() || var->is_empty_list()) {
                    render_section(handler, ctx, comp, var);
                }
                return component<string_type>::walk_control::skip;
            case tag_type::partial:
                if ((var = ctx.ctx.get_partial(tag.name)) != nullptr && (var->is_partial() || var->is_string())) {
                    const auto& partial_result = var->is_partial() ? var->partial_value()() : var->string_value();
                    basic_mustache tmpl{partial_result};
                    tmpl.set_custom_escape(escape_);
                    if (!tmpl.is_valid()) {
                        error_message_ = tmpl.error_message();
                    } else {
                        tmpl.render(handler, ctx, false);
                        if (!tmpl.is_valid()) {
                            error_message_ = tmpl.error_message();
                        }
                    }
                    if (!tmpl.is_valid()) {
                        return component<string_type>::walk_control::stop;
                    }
                }
                break;
            case tag_type::set_delimiter:
                ctx.delim_set = *comp.tag.delim_set;
                break;
            default:
                break;
        }

        return component<string_type>::walk_control::walk;
    }

    enum class render_lambda_escape {
        escape,
        unescape,
        optional,
    };

    bool render_lambda(const render_handler& handler, const basic_data<string_type>* var, context_internal<string_type>& ctx, render_lambda_escape escape, const string_type& text, bool parse_with_same_context) {
        const typename basic_renderer<string_type>::type2 render2 = [this, &ctx, parse_with_same_context, escape](const string_type& text, bool escaped) {
            const auto process_template = [this, &ctx, escape, escaped](basic_mustache& tmpl) -> string_type {
                if (!tmpl.is_valid()) {
                    error_message_ = tmpl.error_message();
                    return {};
                }
                context_internal<string_type> render_ctx{ctx.ctx}; // start a new line_buffer
                const auto str = tmpl.render(render_ctx);
                if (!tmpl.is_valid()) {
                    error_message_ = tmpl.error_message();
                    return {};
                }
                bool do_escape = false;
                switch (escape) {
                    case render_lambda_escape::escape:
                        do_escape = true;
                        break;
                    case render_lambda_escape::unescape:
                        do_escape = false;
                        break;
                    case render_lambda_escape::optional:
                        do_escape = escaped;
                        break;
                }
                return do_escape ? escape_(str) : str;
            };
            if (parse_with_same_context) {
                basic_mustache tmpl{text, ctx};
                tmpl.set_custom_escape(escape_);
                return process_template(tmpl);
            }
            basic_mustache tmpl{text};
            tmpl.set_custom_escape(escape_);
            return process_template(tmpl);
        };
        const typename basic_renderer<string_type>::type1 render = [&render2](const string_type& text) {
            return render2(text, false);
        };
        if (var->is_lambda2()) {
            const basic_renderer<string_type> renderer{render, render2};
            render_result(ctx, var->lambda2_value()(text, renderer));
        } else {
            render_current_line(handler, ctx, nullptr);
            render_result(ctx, render(var->lambda_value()(text)));
        }
        return error_message_.empty();
    }

    bool render_variable(const render_handler& handler, const basic_data<string_type>* var, context_internal<string_type>& ctx, bool escaped) {
        if (var->is_string()) {
            const auto& varstr = var->string_value();
            render_result(ctx, escaped ? escape_(varstr) : varstr);
        } else if (var->is_lambda()) {
            const render_lambda_escape escape_opt = escaped ? render_lambda_escape::escape : render_lambda_escape::unescape;
            return render_lambda(handler, var, ctx, escape_opt, {}, false);
        } else if (var->is_lambda2()) {
            using streamstring = std::basic_ostringstream<typename string_type::value_type>;
            streamstring ss;
            ss << "Lambda with render argument is not allowed for regular variables";
            error_message_ = ss.str();
            return false;
        }
        return true;
    }

    void render_section(const render_handler& handler, context_internal<string_type>& ctx, component<string_type>& incomp, const basic_data<string_type>* var) {
        const auto callback = [&handler, &ctx, this](component<string_type>& comp) -> typename component<string_type>::walk_control {
            return render_component(handler, ctx, comp);
        };
        if (var && var->is_non_empty_list()) {
            for (const auto& item : var->list_value()) {
                // account for the section begin tag
                ctx.line_buffer.contained_section_tag = true;

                const context_pusher<string_type> ctxpusher{ctx, &item};
                incomp.walk_children(callback);

                // ctx may have been cleared. account for the section end tag
                ctx.line_buffer.contained_section_tag = true;
            }
        } else if (var) {
            // account for the section begin tag
            ctx.line_buffer.contained_section_tag = true;

            const context_pusher<string_type> ctxpusher{ctx, var};
            incomp.walk_children(callback);

            // ctx may have been cleared. account for the section end tag
            ctx.line_buffer.contained_section_tag = true;
        } else {
            // account for the section begin tag
            ctx.line_buffer.contained_section_tag = true;

            incomp.walk_children(callback);

            // ctx may have been cleared. account for the section end tag
            ctx.line_buffer.contained_section_tag = true;
        }
    }

private:
    string_type error_message_;
    component<string_type> root_component_;
    escape_handler escape_;
};

using mustache = basic_mustache<std::string>;
using data = basic_data<mustache::string_type>;
using object = basic_object<mustache::string_type>;
using list = basic_list<mustache::string_type>;
using partial = basic_partial<mustache::string_type>;
using renderer = basic_renderer<mustache::string_type>;
using lambda = basic_lambda<mustache::string_type>;
using lambda2 = basic_lambda2<mustache::string_type>;
using lambda_t = basic_lambda_t<mustache::string_type>;

using mustachew = basic_mustache<std::wstring>;
using dataw = basic_data<mustachew::string_type>;

} // namespace mustache
} // namespace kainjow

#endif // KAINJOW_MUSTACHE_HPP


================================================
FILE: Source/External/slang/docs/64bit-type-support.md
================================================
Slang 64-bit Type Support
=========================

## Summary

* Not all targets support 64 bit types, or all 64 bit types 
  * 64 bit integers generally require later APIs/shader models
* When specifying 64 bit literals *always* use the type suffixes (ie `L`, `ULL`, `LL`) 
* GPU target/s generally do not support all double intrinsics 
  * Typically missing are trascendentals (sin, cos etc), logarithm and exponental functions
  * CUDA is the exception supporting nearly all double intrinsics
* D3D 
  * D3D targets *appear* to support double intrinsics (like sin, cos, log etc), but behind the scenes they are actually being converted to float
  * When using D3D12, it is best to use DXIL if you use double because there are some serious issues around double and DXBC
* VK will produce an error in validation if a double intrinsic is used it does support (which is most of them)
* Vector and Matrix types have even spottier than scalar intrinsic support across targets

Overview
========

The Slang language supports 64 bit built in types. Such as

* double
* uint64_t
* int64_t

This also applies to vector and matrix versions of these types. 

Unfortunately if a specific target supports the type or the typical HLSL instrinsic functions (such as sin/cos/max/min etc) depends very much on the target. 

Special attention has to be made with respect to literal 64 bit types. By default float and integer literals if they do not have an explicit suffix are assumed to be 32 bit. There is a variety of reasons for this design choice - the main one being around by default behavior of getting good performance. The suffixes required for 64 bit types are as follows

```
// double - 'l' or 'L'

double a = 1.34e-200L;
// WRONG!: This is the same as b = double(float(1.34e-200)) which will be 0. Will produce a warning.
double b = 1.34e-200; 

// int64_t - 'll' or 'LL' (or combination of upper/lower)

int64_t c = -5436365345345234ll;
// WRONG!: This is the same as d = int64_t(int32_t(-5436365345345234)) which means d ! = -5436365345345234LL. 
// Will produce a warning.
int64_t d = -5436365345345234;      

int64_t e = ~0LL;       // Same as 0xffffffffffffffff
// Does produce the same result as 'e' because equivalent int64_t(~int32_t(0))
int64_t f = ~0;         

// uint64_t - 'ull' or 'ULL' (or combination of upper/lower)

uint64_t g = 0x8000000000000000ull; 
// WRONG!: This is the same as h = uint64_t(uint32_t(0x8000000000000000)) which means h = 0
// Will produce a warning.
uint64_t h = 0x8000000000000000u;   

uint64_t i = ~0ull;       // Same as 0xffffffffffffffff
uint64_t j = ~0;          // Equivalent to 'i' because uint64_t(int64_t(~int32_t(0)));
```

These issues are discussed more on issue [#1185](https://github.com/shader-slang/slang/issues/1185)

Double support
==============

Target   | Compiler/Binary  |  Double Type   |   Intrinsics          |  Notes
---------|------------------|----------------|-----------------------|-----------
CPU      |                  |      Yes       |          Yes          |  1
CUDA     | Nvrtx/PTX        |      Yes       |          Yes          |  1
D3D12    | DXC/DXIL         |      Yes       |          Small Subset |  4 
Vulkan   | GlSlang/Spir-V   |      Yes       |          Partial      |  2
D3D11    | FXC/DXBC         |      Yes       |          Small Subset |  4
D3D12    | FXC/DXBC         |      Yes       |          Small Subset |  3, 4

1) CUDA and CPU support most intrinsics, with the notable exception currently of matrix invert
2) In terms of lack of general intrinsic support, the restriction is described in  https://www.khronos.org/registry/spir-v/specs/1.0/GLSL.std.450.html

The following intrinsics are available for Vulkan 

`fmod` (as %), `rcp`, `sign`, `saturate`, `sqrt`, `rsqrt`, `frac`, `ceil`, `floor`, `trunc`, `abs`, `min`, `max`, `smoothstep`, `lerp`, `clamp`, `step` and `asuint`. 

These are tested in the test `tests/hlsl-intrinsic/scalar-double-vk-intrinsic.slang`.

What is missing are transedentals, expX, logX. 

Note that GlSlang does produce Spir-V that contains double intrinsic calls for the missing intrinsics, the failure happens when validating the Spir-V 

```
Validation: error 0:  [ UNASSIGNED-CoreValidation-Shader-InconsistentSpirv ] Object: VK_NULL_HANDLE (Type = 0) | SPIR-V module not valid: GLSL.std.450 Sin: expected Result Type to be a 16 or 32-bit scalar or vector float type
  %57 = OpExtInst %double %1 Sin %56
```

3) That if a RWStructuredBuffer<double> is used on D3D12 with DXBC, and a double is written, it can lead to incorrect behavior. Thus it is recommended not to use double with dxbc, but to use dxil to keep things simple. A test showing this problem is `tests/bugs/dxbc-double-problem.slang`. The test `tests/hlsl-intrinsic/scalar-double-simple.slang` shows not using a double resource, doubles do appear to work on D3D12 DXBC. 

4) If you compile code using double and intrinsics through Slang at first blush it will seem to work. Assuming there are no errors in your code, your code will even typically appear to work correctly. Unfortunately what is really happening is the backend compiler (fxc or dxc) compiler is narrowing double to float and then using float intrinsics. It typically generates a warning when this happens, but unless there is an error in your code you will not see these warnings because dxc doesn't appear to have a mechanism to return warnings if there isn't an error. This is why everything appears to work - but actually any intrinsic call is losing precision silently. 

Note on dxc by default Slang disables warnings - warnings need to be enabled to see the narrowing warnings. 

There is another exception around the use of % - if you do this with double it will return an error saying on float is supported. 

It appears that no intrinsics are available for double with fxc. 

On dxc the following intrinsics are available with double::

`rcp`, `sign`, `saturate`, `abs`, `min`, `max`, `clamp`, `asuint`. 

These are tested in the test `tests/hlsl-intrinsic/scalar-double-d3d-intrinsic.slang`.

There is no suport for transcendentals (`sin`, `cos` etc) or `log`/`exp`. More surprising is that`sqrt`, `rsqrt`, `frac`, `ceil`, `floor`, `trunc`, `step`, `lerp`, `smoothstep` are also not supported.

uint64_t and int64_t Support
============================

Target   | Compiler/Binary  | u/int64_t Type |  Intrinsic support | Notes
---------|------------------|----------------|--------------------|--------
CPU      |                  |      Yes       |          Yes       |   
CUDA     | Nvrtx/PTX        |      Yes       |          Yes       |   
Vulkan   | GlSlang/Spir-V   |      Yes       |          Yes       |   
D3D12    | DXC/DXIL         |      Yes       |          Yes       |   1
D3D11    | FXC/DXBC         |      No        |          No        |   2
D3D12    | FXC/DXBC         |      No        |          No        |   2

1) The [sm6.0 docs](https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/hlsl-shader-model-6-0-features-for-direct3d-12) describe only supporting uint64_t, but dxc says int64_t is supported in [HLSL 2016](https://github.com/Microsoft/DirectXShaderCompiler/wiki/Language-Versions). Tests show that this is indeed the case.

2) uint64_t support requires https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/hlsl-shader-model-6-0-features-for-direct3d-12, so DXBC is not a target.

The intrinsics available on uint64_t type are `abs`, `min`, `max`, `clamp` and `countbits`.
The intrinsics available on uint64_t type are `abs`, `min`, `max` and `clamp`.

GLSL
====

GLSL/Spir-v based targets do not support 'generated' intrinsics on matrix types. For example 'sin(mat)' will not work on GLSL/Spir-v.



================================================
FILE: Source/External/slang/docs/README.md
================================================
Slang Documentation
===================

This directory contains documentation for the Slang system.
Some of the documentation is intended for users of the language and compiler, while other documentation is intended for developers contributing to the project.

Getting Started
---------------

The Slang [User's Guide](https://shader-slang.github.io/slang/user-guide/) provides an introduction to the Slang language and its major features.

The [API user's guide](api-users-guide.md) gives information on how to drive Slang programmatically from an application.
There is also documentation specific to using the [`slangc`](command-line-slangc.md) command-line tool.

Advanced Users
--------------

For the benefit of advanced users we provide detailed documentation on how Slang compiles code for specific platforms.
The [target compatibility guide](target-compatibility.md) gives an overview of feature compatibility for targets. 

The [CPU target guide](cpu-target.md) gives information on compiling Slang or C++ source into shared libraries/executables or functions that can be directly executed. It also covers how to generate C++ code from Slang source.  

The [CUDA target guide](cuda-target.md) provides information on compiling Slang/HLSL or CUDA source. Slang can compile to equivalent CUDA source, as well as to PTX via the nvrtc CUDA complier.

Contributors
------------

For contributors to the Slang project, the information under the [`design/`](design/) directory may help explain the rationale behind certain design decisions and help when ramping up in the codebase.

Research
--------

The Slang project is based on a long history of research work. While understanding this research is not necessary for working with Slang, it may be instructive for understanding the big-picture goals of the language, as well as why certain critical decisions were made.

A [paper](http://graphics.cs.cmu.edu/projects/slang/) on the Slang system was accepted into SIGGRAPH 2018, and it provides an overview of the language and the compiler implementation.
Yong He's [dissertation](http://graphics.cs.cmu.edu/projects/renderergenerator/yong_he_thesis.pdf) provided more detailed discussion of the design of the Slang system.


================================================
FILE: Source/External/slang/docs/api-users-guide.md
================================================
Slang API User's Guide
======================

This document is intended to guide user's who want to integrate Slang into their application programmatically.
It covers issues around building and linking Slang, as well as giving an overview of the main API functionality.

Preliminaries
-------------

Before using the Slang API, you'll need to link Slang into your application.
We recommend using a pre-built binary package, available through GitHub [releases](https://github.com/shader-slang/slang/releases).

Just add the downloaded package to your include path, and make sure to add (or copy) the `slang.dll` and `slang-glslang.dll` libraries into the path of your executable.

Getting Started with the API
----------------------------

### Include the Header

In order to use the Slang API, you'll need to include its header:

```c
#include <slang.h>
```

While the Slang implementation is C++, the header exposes a pure C interface (plus a few wrappers that only get defined for C++).

### Create a Session

All interactions with the Slang API are under the control of a *session*, represented by the type `SlangSession`:

```c++
SlangSession* session = spCreateSession(NULL);
```

You can think of the session as owning resources that can be re-used across multiple compiles.
Most notably this includes the shader "standard library," which will be parsed and checked when you first create a session.
By re-using a session across multiple files, you can avoid paying the cost of loading the standard library multiple times.

When you are done with a session, you'll want to destroy it to free up these resources:

```c++
spDestroySession(session);
```

**Warning**: The majority of the Slang API is *not* currently thread safe. It is possible to use Slang across multiple threads but requires care. See the section on [multithreading](#multithreading) for more details. 

### Create a Compile Request

A *compile request* represents an interaction where you ask Slang to compile one or more files for you, and produce some output.
A `SlangCompileRequest` object is used both to hold the input for the request (what files and entry points you want to compile), and to communicate back output (error messages and/or code).

You can create a request using an existing session:

```c++
SlangCompileRequest* request = spCreateCompileRequest(session);
```

When you are done with the request you will need to destroy it to free resources:

```c++
spDestroyCompileRequest(request);
```

### Specify Compilation Options

#### Code Generation Target

When invoking the compiler, it is important to specify what kind of code you'd like Slang to generate.
This is done using the `SlangCompileTarget` options.
For example, to request output as SPIR-V binary code:

```c++
spSetCodeGenTarget(request, SLANG_SPIRV);
```

#### Include Paths

If you will be passing files with `#include` directives to Slang, you'll need to specify where it should look for those files:

```c++
spAddSearchPath(request, "some/path/");
```

Note that for now Slang does not support any kind of "virtual file-system," although that is obviously a desirable feature to add.

#### Preprocessor Definitions

If you want any kind of preprocessor macros to be defined when compiling your code, you can add global macro definitions to the compile request:

```c++
spAddPreprocessorDefine(request, "ENABLE_FOO", "1")
```

Note that Slang currently doesn't provide an automatic definition like `__SLANG__` to identify the compiler, so you might want to do that manually, if you need to have files that are processed by Slang and other tools.

```c++
spAddPreprocessorDefine(request, "__SLANG__", "1")
```

### Specify Input Code and Entry Points

Once you've made your global configuration of the compile request, it is time to start adding source code.
The Slang model is that a compile request involves one or more *translation units*, each of which may comprise one or more *source files* (or strings), and which might define one or more *entry points*.

In the case of HLSL or GLSL code, each translation unit will usually have only a single source file or string.
In the case of GLSL, a translation unit will only expose a single entry point.

#### Translation Units

To add a translation unit to the compile request:

```c++
int translationUnitIndex = spAddTranslationUnit(request, SLANG_SOURCE_LANGUAGE_HLSL, "");
```

The first argument is the compile request.
The second argument is the source language for the translation unit (you may not have a single translation unit that mixes source files in different languages).
The last argument is an optional name for the translation unit; Slang currently doesn't do anything with this value.

The `spAddTranslationUnit` function returns the zero-based index of the translation unit you added.
You don't need to use this return value, because it will be deterministic (the first translation unit gets `0`, the next gets `1`, etc.), but the API returns it in case it saves you from having to track it with your own counter.
The translation unit index is used in subsequent API calls that modify or query the translation unit.

#### Source Files/Strings

Once you've created a translation unit, you can add source code to it.
Source code can either come from a file or a string:

```c++
spAddTranslationUnitSourceFile(request, translationUnitIndex, "some/file.hlsl");

// or:

spAddTranslationUnitSourceString(
    request,
    translationUnitIndex,
    "file.hlsl",
    "/* source code */ ...");
```

Note that even in the case where you provide a string, you need to provide a file name (even a made-up one) so that Slang can use it in error messages.

#### Entry Points

Once you've added source code to your translation unit, you can specify which entry point(s) you want to compile in the translation unit:

```c++
int entryPointIndex = spAddEntryPoint(
    request,
    translationUnitIndex,
    "main",
    profileID);
```

This adds an entry point to be compiled to the compilation `request`.
An entry point named `"main"` will be looked up in translation unit `translationUnitIndex` and code will be generated based on the given `profileID` (a value of type `SlangProfileID`).

In order to get a profile to use, you'll typically want to look one up by name:

```c++
SlangProfileID profileID = spFindProfile(session, "ps_5_0");
```

The names of profiles passed to this function are the same as are available for command-line [`slangc`](command-line-slangc.md).

Like `spAddTranslationUnit`, `spAddEntryPoint` returns a zero-based index for the entry point.
Note that this index is for all entry points in the compile request (not per-translation-unit).

### Compiling and Checking Diagnostics

With all the setup out of the way, it is finally time to actually compile things:

```c++
int anyErrors = spCompile(request);
```

The `spCompile` function will compile all the translation units and entry points you specified.
If any errors were encountered during compilation, then `spCompile` will return a non-zero result.
To find out what went wrong, you can get a null-terminated log of error messages with:

```c++
char const* diagnostics = spGetDiagnosticOutput(request);
```

The diagnostic output will also contain any warnings produced, even if the compilation didn't have any errors.
Note that the returned pointer is guaranteed to live at least as long as the compile request, but no longer.
If you need to retain the data for later use, then you must make your own copy.

If any errors occurred, you shouldn't expect to read any useful output (other than the diagnostics) from the request; you should destroy it and move on.

### Reading Output Code

If you compilation was successful, then you probably want to extract the output code that was generated.
Slang provides access to the generated code for each entry point:

```c++
size_t dataSize = 0;
void const* data = spGetEntryPointCode(request, entryPointIndex, &dataSize);
```

As a shorthand, if you expect the output to be textual source-code:

```c++
char const* code = spGetEntryPointSource(request, entryPointIndex);
```

Note that the pointer returned by these functions is guaranteed to remain live as long as the compileRequest is alive, but no longer.
If you need to retain the output code for longer, you need to make a copy.

### Reflection Information

If a compilation is successful, Slang also produces reflection information that the application can query:

```c++
SlangReflection* reflection = spGetReflection(request);
```

Note that just as with output code, the reflection object (and all other objects queried from it) is guaranteed to live as long as the request is alive, but no longer.
Unlike the other data, there is no easy way to save the reflection data for later user (we do not currently implement serialization for reflection data).
Applications are encouraged to extract whatever information they need before destroying the compilation request.

For convenience (since the reflection API surface area is large), the Slang API provides a C++ wrapper interface around the reflection API, and this document will show code examples using those wrappers:

```c++
slang::ShaderReflection* shaderReflection = slang::ShaderReflection::get(request);
```

#### Program Reflection

When looking at the whole program (`slang::ShaderReflection`) we can enumerate global-scope shader parameters:

```c++
unsigned parameterCount = shaderReflection->getParameterCount();
for(unsigned pp = 0; pp < parameterCount; pp++)
{
	slang::VariableLayoutReflection* parameter =
	    shaderReflection->getParameterByIndex(pp);
	// ...
}
```

We can also enumerate the compile entry points, in order to inspect their parameters:

```c++
SlangUInt entryPointCount = shaderRefelction->getEntryPointCount();
for(SlangUInt ee = 0; ee < entryPointCount; ee++)
{
	slang::EntryPointReflection* entryPoint =
	    shaderReflection->getEntryPointByIndex(ee);
	// ...
}
```

Slang's reflection API does not currently expose by-name lookup of parameters, but this is obviously a desirable feature.

#### Variable Layouts

In the Slang reflection API, we draw a distinction between a *variable* (a particular declaration in the code), from a *variable layout* which has been laid out according to some API-specific rules.
It is possible for the same variable (e.g., a `struct` field) to be laid out multiple times, with different results (e.g., if the same `struct` type is used both for a `cbuffer` member and a varying shader `in` parameter).

For most purposes, a `VariableLayoutReflection` represents what a shading language user thinks of as a "shader parameter."
We can query a parameter for its name:

```c++
char const* parameterName = parameter->getName();
```

An application will typically want to know where a parameter got "bound."
In the simple case, we can query this information directly:

```c++
slang::ParameterCategory category = parameter->getCategory();
unsigned index = parameter->getBindingIndex();
unsigned space = parameter->getBindingSpace();
```

For a simple global-scope "resource" parameter (e.g., HLSL `Texture2D t : register(t3)`) the `category` tells what kind of resource the parameter consumes (e.g., `slang::ParameterCategory::ShaderResource`), the `index` gives the register number (`3`), and `space` gives the register "space" (`0`) as added for D3D12.

In the case of SPIR-V output a binding index corresponds to the `binding` layout qualifier, and the binding space corresponds to the `set`.
The main difference from D3D is that the `category` will usually be `slang::ParameterCategory::DescriptorTableSlot`.

Textures, samplers, and constant buffers all follow this same basic pattern.
For uniform parameters (e.g., members of an HLSL `cbuffer`), the binding "space" is unused, the category is `slang::ParameterCategory::Uniform`, and the "index" is the byte offset of the parameter in its parent.

The above are the simple cases, where a parameter only consumes a single kind of resource.
In HLSL, however, we can do things like combine textures, samplers, and uniform values in a `struct` type, so given a parameter of such a type, the reflection API needs to be able to report appropriate layout information for each of the different categories of resource.

If `getCategory()` returns `slang::ParameterCategory::Mixed`, then the user can query additional information:

```c++
unsigned categoryCount = parameter->getCategoryCount();
for(unsigned cc = 0; cc < categoryCount; cc++)
{
	slang::ParameterCategory category = parameter->getCategoryByIndex(cc);

	size_t offsetForCategory = parameter->getOffset(category);
	size_t spaceForCategory = parameter->getBindingSpace(category);

	// ...
}
```

A loop like this lets you enumerate all of the resource types consumed by a parameter, and get a starting offset (and space) for each category.

#### Type Layouts

Just knowing where a shader parameter *starts* is only part of the story, of course.
We also need to know how many resources (e.g., registers, bytes of uniform data, ...) it consumes, how many elements it occupies (if it is an array), and what "sub-parameters" it might include.

For these kinds of queries, we need to look at the *type layout* of a parameter:

```c++
slang::TypeLayoutReflection* typeLayout = parameter->getTypeLayout();
```

Just as with the distinction between a variable and a variable layout, a type layout represents a particular type in the source code that has been laid out according to API-specific rules.
A single type like `float[10]` might be laid out differently in different contexts (e.g., using GLSL `std140` vs. `std430` rules).

The first thing we want to know about a type is its *kind*:

```c++
slang::TypeReflection::Kind kind = typeLayout->getKind();
```

The available cases for `slang::TypeReflection::Kind` include `Scalar`, `Vector`, `Array`, `Struct`, etc.

For any type layout, you can query the resources it consumes, or a particular parameter category:

```c++
// query the number of bytes of constant-buffer storage used by a type layout
size_t sizeInBytes = typeLayout->getSize(slang::ParameterCategory::Uniform);

// query the number of HLSL `t` registers used by a type layout
size_t tRegCount = typeLayout->getSize(slang::ParameterCategory::ShaderResource);
```

##### Arrays

If you have a type layout with kind `Array` you can query information about the number and type of elements:

```c++
size_t arrayElementCount = typeLayout->getElementCount();
slang::TypeLayoutReflection* elementTypeLayout = typeLayout->getElementTypeLayout();
sie_t arrayElementStride = typeLayout->getElementStride(category);
```

An array of unknown size will currently report zero elements.
The "stride" of an array is the amount of resources (e.g., the number of bytes of uniform data) that need to be skipped between consecutive array elements.
This need *not* be the same as `elementTypeLayout->getSize(category)`, and there are two notable cases to be aware of:

- An array in a constant buffer may have a stride larger than the element size. E.g., a `float a[10]` in a D3D or `std140` constant buffer will have 4-byte elements, but a stride of 16.

- An array of resources in Vulkan will have a stride of *zero* descriptor-table slots, because the entire array is allocated a single `binding`.

##### Structures

If you have a type layout with kind `Struct`, you can query information about the fields:

```c++
unsigned fieldCount = typeLayout->getFieldCount();
for(unsigned ff = 0; ff < fieldCount; ff++)
{
	VariableLayoutReflection* field = typeLayout->getFieldByIndex(ff);
	// ...
}
```

Each field is represented as a full variable layout, so application code can recursively extract full information.

An important caveat to be aware of when recursing into structure types like this, is that the layout information on a field is relative to the start of the parent type layout, and not absolute.
This is perhaps not surprising in the case of `slang::ParameterCategory::Uniform`: if you ask a field in a `struct` type for its byte offset, it will return the offset from the start of the `struct`.

Where this can trip up users is when a `struct` type contains fields of other categories (e.g., a structure with a `Texture2D` in it).
In these cases, the "binding index" of a structure field in a relative offset from whatever binding index is given to the parent structure.

The basic rule is that no matter what category of binding resource (bytes, registers, etc.) you are talking about, the index/offset of `a.b.c` must be computed by adding together the offsets of `a`, `b` and `c`.

#### Entry Points

Given an `EntryPointReflection` we can query its name and stage:

```c++
char const* entryPointName = entryPoint->getName();
SlangStage stage = entryPoint->getStage();
```

You can also enumerate the parameters of the entry point (that is, those that were written as parameters of the entry-point function):

```c++
unsigned parameterCount = entryPoint->getParameterCount();
for(unsigned pp = 0; pp < parameterCount; pp++)
{
	slang::VariableLayoutReflection* parameter =
	    entryPoint->getParameterByIndex(pp);
	// ...
}
```

In the case of a compute shader entry point, you can also query the user-specified thread-group size (if any):

```c++
SlangUInt threadGroupSize[3];
entryPoint->getComputeThreadGruopSize(3, &threadGroupSize[0]);
```

### Checking Dependencies

If you are implementing some kind of "hot reload" system for shaders, then you probably need to know what files on disk a particular compilation request ended up depending on.
Slang provides a simple API for enumerating these, on a successful compile:

```c++
int depCount = spGetDependencyFileCount(request);
for(int dep = 0; dep < depCount; dep++)
{
	char const* depPath = spGetDependencyFilePath(request, dep);
	// ...
}
```

This will enumerate all file paths that were referenced by the compile, either directly through the API or via a `#include` directive.

### Setting Other Options

There are other compilation options that are more specialized, and less often used.

If HLSL or GLSL input code uses constructs that Slang doesn't understand (that is, it is giving spurious error messages) it may be possible to make progress by suppressing Slang's semantic checking for these languages:

```c++
spSetCompileFlags(request, SLANG_COMPILE_FLAG_NO_CHECKING);
```

If you are trying to debug shader compilation issues in a large application, it may be helpful to have Slang dump all the intermediate code it generates to disk:

```c++
spSetDumpIntermediates(request, true);
```

If you don't like the way that Slang adds `#line` directives to generated source code, you can control this behavior:

```c++
spSetLineDirectiveMode(request, SLANG_LINE_DIRECTIVE_MODE_NONE);
```

### <a id="multithreading"/>Multithreading

The only functions which are currently thread safe are 

```C++
SlangSession* spCreateSession(const char* deprecated);
SlangResult slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession);
SlangResult slang_createGlobalSessionWithoutStdLib(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession);
ISlangBlob* slang_getEmbeddedStdLib();
SlangResult slang::createGlobalSession(slang::IGlobalSession** outGlobalSession);
const char* spGetBuildTagString();
```

This assumes Slang has been built with the C++ multithreaded runtime, as is the default.

All other functions and methods are not [reentrant](https://en.wikipedia.org/wiki/Reentrancy_(computing)) and can only execute on a single thread. More precisely function and methods can only be called on a *single* thread at *any one time*. This means for example a global session can be used across multiple threads, as long as some synchronisation enforces that only one thread can be in a Slang call at any one time.

Much of the Slang API is available through [COM interfaces](https://en.wikipedia.org/wiki/Component_Object_Model). In strict COM interfaces should be atomically reference counted. Currently *MOST* Slang API COM interfaces are *NOT* atomic reference counted. One exception is the `ISlangSharedLibrary` interface when produced from [host-callable](cpu-target.md#host-callable). It is atomically reference counted, allowing it to persist and be used beyond the original compilation and be freed on a different thread. 

A Slang compile request/s (`slang::ICompileRequest` or `SlangCompileRequest`) can be thought of belonging to the Slang global session (`slang::IGlobalSession` or `SlangSession`) it was created from.  Note that *creating* a global session is currently a fairly costly process, whereas the cost of creating and destroying a request is relatively small. 

The *simplest* way to multithread would be for a thread to 

* Create a global session
* Create request/s from that session 
* Compile
* Destroy request/s
* Destroy the global session 

This works, but typically isn't very efficient with multiple compilations because of the cost of creating the global session each time. 

A significant improvement is to limit the global session cost via a pool. 

* Get a global session from a global session pool 
* *Optionally* set any state on the global session
* Create request/s from the global session 
* Compile
* Destroy request/s
* Return the global session to the global session pool

Care is needed with the pool because the global session holds state, so it is either important to have a condition that all global sessions hold the same state, or all state is setup on the session when it's removed from the pool for use. Global sessions use a significant amount of memory, so an implementation may want to limit how many global sessions are available and their lifetimes.

More nuance is possible in so far as the use of global session/requests *can* move between threads as long as use is only ever on one thread at any one time. Another style of implementation could use a thread pool, and associate global sessions with threads in the pool for example.

Slang can hold references to user implemented functions and interfaces such as `ISlangFileSystem` and `SlangDiagnosticCallback`. If Slang is used in a multithreaded manner such implementations typically must also be thread safe.


================================================
FILE: Source/External/slang/docs/building.md
================================================
# Building Slang From Source

## Get the Source Code 

Clone [this](https://github.com/shader-slang/slang) repository, and then run:

```
% git submodule update --init
```

The submodule update step is required to pull in dependencies used for testing infrastructure as well as the `glslang` compiler that we currently use for generating SPIR-V. 

## Windows Using Visual Studio

If you are using Visual Studio on Windows, then you can just open `slang.sln` and build your desired platform/configuration. `slang.sln` and associated project files are actually just generated using [`premake5`](https://premake.github.io/). See instructions in premake section below for further explanation.
 
Whilst using the provided `slang.sln` solution is a fast and easy way to get a build to work, it does not make all binary dependencies available which can add features and improve performance (such as [slang-llvm](https://github.com/shader-slang/slang-llvm)). To get the binary dependencies create the solution using [`premake5`](https://premake.github.io/) described in a later section.
 
## Other Targets

Slang uses [`premake5`](https://premake.github.io/) to generate projects (such as `Makefile`s) that can then be used to build Slang binaries from source. 

For Linux and other targets the section below on `premake` describes the process. 

Some targets below are described as 'unofficial'. In practice this means that they are not tested as part of contiguous integration. Thus unfortunately it is quite possible from time to time for them to break on a merge of a PR. That said, if broken it is likely only very minor changes are needed to make them work again. 

### Generated Files

Slang as part of it's build process generates header files, which are then used to compile the main Slang project. If you use `premake` to create your project, it will automatically generate these files before compiling the rest of the Slang. These are the current header generations which are created via the `slang-generate` and other tools... 

* core.meta.slang -> core.meta.slang.h
* hlsl.meta.slang -> hlsl.meta.slang.h 

Other files that are generated have `generated` as part of their name.

It may be necessary or desirable to create a build of Slang without using `premake`. 

One way to do this would be to first compile slang-generate and then invoke it directly or as a dependency in your build. Another perhaps simpler way would be to first compile the same Slang source on another system that does support `premake`, or using a preexisting build mechanism (such as Visual Studio projects on Windows). Then copy the generated header files to your target system. This is appropriate because the generated files are indentical across platforms. It does of course mean that if `core.meta.slang` or `hlsl.meta.slang` files change the headers will need to be regenerated. 

## Premake

Slang uses the tool [`premake5`](https://premake.github.io/) in order to generate projects that can be built on different targets. On Linux premake will generate Makefile/s and on windows it will generate a Visual Studio solution. Information on invoking premake for different kinds of targets can be found [here](https://github.com/premake/premake-core/wiki/Using-Premake). 

Slang includes `premake5` as part of `slang-binaries` which is in the `external` directory. For the external directory to be setup it is necessary to have updated submodules with `git submodule update --init`. 

If you are on a unix-like operating system such as OSX/Linux, it may be necesary to make premake5 executable. Use 

```
% chmod u+x external/slang-binaries/premake/***path to premake version and os***/premake5
```

Alternatively you can download and install [`premake5`](https://premake.github.io/) on your build system. 

Run `premake5` with `--help` to in the root of the Slang project to see available command line options (assuming `premake5` is in your `PATH`):
 
```
% premake5 --help
```

To download and use binaries for a particular architecture the [slang-pack](https://github.com/shader-slang/slang-binaries/tree/master/lua-modules) package manager can be invoked via the additional `--deps` and `--arch` options. If `--arch` isn't specified it defaults to `x64`. On Windows targets, the Visual Studio platform setting should be consistent with the `--arch` option such that the appropriate binary dependencies are available. The `--deps=true` option just indicates that on invoking premake it should make the binary dependencies for the `arch` available. 

Supported `--arch` options are

* x64
* x86
* aarch64
* arm

For Unix like targets that might have `clang` or `gcc` compilers available you can select which one via the `-cc` option. For example...

```
% premake5 gmake --cc=clang --deps=true --arch=x64
```

or 

```
% premake5 gmake --cc=gcc --deps=true --arch=x64
```

If you want to build the [`glslang`](https://github.com/KhronosGroup/glslang) library that Slang uses, add the option `--build-glslang=true`.

# Projects using `make`

The Slang project does not include Makefiles by default - they need to be generated via `premake`. Please read the section on your target operating system on how to use `premake` to create Makefiles. 

If building a Makefile based project, for example on Linux, OSX or [Cygwin](https://cygwin.com/), the configuration needs to be specified when invoking make, the following are typical...

```
% make config=release_x64
% make config=debug_x64
% make config=release_x86
% make config=debug_x86
% make config=release_aarch64
% make config=debug_aarch64
```

To check what compiler is being used/command line options you can add `verbose=1` to `make` command line. For example

```
% make config=debug_x64 verbose=1
```

### Windows

First download and install [`premake5`](https://premake.github.io/) on your build system. Open up a command line and go to the root directory of the slang source tree (ie the directory containing `slang.h`).
 
Assuming premake5 is in your `PATH`, you can create a Visual Studio 2017 project for Slang with the following command line

```
% premake5 vs2017 --deps=true --arch=x64
```

For Visual Studio 2019 use

```
% premake5 vs2019 --deps=true --arch=x64
```

These should create a slang.sln in the same directory and which you can then open in the appropriate Visual Studio. Building will build all of Slang, examples and it's test infrastructure.

### Linux 

On Linux we need to generate Makefiles using `premake`. Please read the `premake` section for more details. 

In the terminal go to the root directory of the slang source tree (ie the directory containing `slang.h`). Assuming `premake5` is in your `PATH` use  

```
% premake5 gmake --deps=true --arch=x64
```

To create a release build use

```
% make config=release_x64
```
 
You can vary the compiler to use via the --cc option with 'gcc' or 'clang' for example

### Mac OSX

Note that OSX isn't an official target. 

On Mac OSX to generate Makefiles or an XCode project we use `premake`. Please read the `premake` section for more details. 

```
% premake5 gmake --deps=true --arch=x64
```

If you want to build `glslang` (necessary for Slang to output SPIR-V for example), then the additional `--build-glslang` option should be used

```
% premake5 gmake --build-glslang=true --deps=true --arch=x64
```

To build for release you can use...

```
% make config=release_x64
```

Slang can also be built within the Xcode IDE. Invoke `premake` as follows

```
% premake5 xcode4 --deps=true --arch=x64
```

Then open the `slang.xcworkspace` project inside of Xcode and build. 

### Cygwin

Note that Cygwin isn't an official target. 

One issue with building on [Cygwin](https://cygwin.com/), is that there isn't a binary version of `premake` currently available. It may be possible to make this work by building `premake` from source, and then just doing `premake5 gmake`. Here we use another approach - using the windows `premake` to create a Cygwin project. To do this use the command line...

```
% premake5 --target-detail=cygwin gmake --deps=true --arch=x64
```

## Testing

When slang is built from source it also builds tools to be able to test the Slang compiler. Testing is achieved using the `slang-test` tool. The binaries are placed in the appropriate directory underneath `bin`. It is important that you initiate the test binary from the root directory of the slang source tree, such that all tests can be correctly located.

For example to run the tests on a windows release x64 build from the command line, in the root directory of slang source tree you can use...

```
% bin\windows-x64\release\slang-test
```

Note that on windows if you want to run all of the tests from inside visual studio, it is necessary to set the `Working Directory` under "slang-test project" > "Configuration Properties" > "Debugging" > "Working Directory" to the root directory of the slang source tree. You can do this by setting it to `$(ProjectDir)/../..` for all configurations.

If you only see 'unit-tests' being run (unit tests are prefixed with 'unit-tests/') then the working directory is not correctly set. Most tests are text files describing the test held in the `tests` directory in the root of the slang project. 

See the [documentation on testing](../tools/slang-test/README.md) for more information.
 


================================================
FILE: Source/External/slang/docs/command-line-slangc.md
================================================
Using the `slangc` Command-Line Compiler
========================================

The `slangc` command-line tool is used to compile or cross-compile shader source code.

```
slangc [<options>] <file1> [<file2>...]

```

Simple Examples
---------------

### HLSL

When compiling an HLSL shader, you must specify the path to your shader code file as well as the target shader model (profile) and shader stage to use.
For example, to see D3D bytecode assembly for a fragment shader entry point:

    slangc my-shader.hlsl -profile sm_5_0 -stage fragment

To direct that output to a bytecode file:

    slangc my-shader.hlsl -profile sm_5_0 -stage fragment -o my-shader.dxbc

If the entry-point function has a name other than the default `main`, then this is specified with `-entry`:

    slangc my-shader.hlsl -profile sm_5_0 -entry psMain -stage fragment 

If you are using the `[shader("...")]` syntax to mark your entry points, then you may leave off the `-stage` option:

    slangc my-shader.hlsl -profile sm_5_0 -entry psMain

### Slang

Compiling an entry point from a Slang file is similar to HLSL, except that you must also specify a desired code generation target, because there is no assumed default (like DXBC for Direct3D Shader Model 5.x).

To get DXBC assembly written to the console:

    slangc my-shader.slang -profile sm_5_0 -stage fragment -entry main -target dxbc

To get SPIR-V assembly:

    slangc my-shader.slang -profile sm_5_0 -stage fragment -entry main -target spriv

The code generation target is implicit when writing to a file with an appropriate extension.
To write DXBC, SPIR-V, or GLSL to files, use:

    slangc my-shader.slang -profile sm_5_0 -entry main -stage fragment -o my-shader.dxbc
    slangc my-shader.slang -profile sm_6_0 -entry main -stage fragment -o my-shader.dxil
    slangc my-shader.slang -profile glsl_450 -entry main -stage fragment -o my-shader.spv

Multiple Entry Points
---------------------

`slangc` can compile multiple entry points, which may span multiple files in a single invocation.
This is useful when you are taking advantage of Slang's ability to automatically assign binding locations to shader parameters, because the compiler can take all of your entry points into account when assigning location (avoiding overlap between entry points that will be used together).

When specifying multiple entry points, you use multiple `-entry` options on the command line.
The main thing to be aware of is that any `-stage` options apply to the most recent `-entry` point, and the same goes for any `-o` options to specify per-entry-point output files.
For example, here is a command line to compile both vertex and fragment shader entry points from a single file and output them to distinct DXBC files:

    slangc -profile sm_5_0 my-shader.hlsl 
                          -entry vsMain -stage vertex   -o my-shader.vs.dxbc
                          -entry fsMain -stage fragment -o my-shader.fs.dxbc

If your shader entry points are spread across multiple HLSL files, then each `-entry` option indicates an entry point in the preceding file.
For example, if the preceding example put its vertex and fragment entry points in distinct files, the command line would be:

    slangc -profile sm_5_0 my-shader.vs.hlsl -entry vsMain -stage vertex   -o my-shader.vs.dxbc
                           my-shader.fs.hlsl -entry fsMain -stage fragment -o my-shader.fs.dxbc

Note that when compiling multiple `.slang` files in one invocation, they will all be compiled together as a single module (with a single global namespace) so that the relative order of `-entry` options and source files does not matter.

These long command lines obviously aren't pleasant.
We encourage applications that require complex shader compilation workflows to use the Slang API directly so that they can implement compilation that follows application conventions/policy.
The ability to specify compilation actions like this on the command line is primarily intended a testing and debugging tool.

Options
-------

For completeness, here are the options that `slangc` currently accepts:

* `-v`: Displays the build version. This is the contents of `git describe --tags`. It is typically only set from automated builds (such as distros available on github). A user build will by default be 'unknown'. 

* `-D <name>[=<value>]`: Insert a preprocessor macro definition
  * The space between `-D` and `<name>` is optional
  * If no `<value>` is specified, Slang will define the macro with an empty value

* `-I <path>`: Add a path to be used in resolving `#include` and `import` operations
  * The space between `-I` and `<path>` is optional

* `-entry <name>`: Specify the name of the entry-point function
  * When compiling from a single file, this defaults to `main` *if* you specify a stage using `-stage`
  * Multiple `-entry` options may appear on the command line. When they do, the file associated with the entry point will be the first one found when searching to the left in the command line.

* `-stage <name>`: Specify the stage of an entry-point function
  * When there are multiple entry points, a `-stage` option applies to the most recent `-entry` point specified
  * When there is only a single entry point, the `-stage` option may appear anywhere on the command line
  * The traditional stages are named as follows:
    * `vertex`
    * `hull`: D3D Hull Shader and GL/VK Tessellation Control Shader
    * `domain`: D3D Domain Shader and GL/VK Tessellation Evaluation Shader
    * `geometry`
    * `fragment` / `pixel`: D3D Pixel Shader and GL/VK Fragment Shader
    * `compute`
  * The stages for ray tracing use the following names:
    * `raygeneration`
    * `intersection`
    * `anyhit`
    * `closesthit`
    * `miss`
    * `callable`

* `-target <format>`: Specifies the format in which code should be generated. Values for `<target>` are:
  * `glsl`: GLSL source code
  * `hlsl`: HLSL source code
  * `spirv`: SPIR-V intermediate language binary.
  * `spirv-assembly` / `spirv-asm`: SPIR-V intermediate language assembly
  * `dxbc`: DirectX shader bytecode binary
  * `dxbc-assembly` / `dxbc-asm`: DirectX shader bytecode assembly
  * `dxil`: DirectX Intermediate Language binary
  * `dxil-assembly` / `dxil-asm`: DirectX Intermediate Language assembly

* `-profile <profile>`: Specify the "profile" to use for the code generation target, which represents an abstact feature level as defined by a particular API standard. Available values include:
  * The Direct3D "Shader Model" levels are available as `sm_{4_0,4_1,5_0,5_1,6_0,6_1,6_2,6_3,6_4,6_5,6_6}`
  * Profiles corresponding to GLSL langauge versions are available as `glsl_{110,120,130,140,150,330,400,410,420,430,440,450,460}`
  * As a convenience, names matching traditional HLSL shader profiles are provided such that, e.g., `-profile vs_5_0` is an abbreviation for `-profile sm_5_0 -stage vertex`

* `-o <path>`: Specify a path where generated output should be written
  * When multiple `-entry` options are present, each `-o` associates with the first `-entry` to its left.

* `-pass-through <name>`: Don't actually perform Slang parsing/checking/etc. on the input and instead pass it through (more or less) unmodified to the existing compiler `<name>`
  * `fxc`: Use the `D3DCompile` API as exposed by `d3dcompiler_47.dll`
  * `glslang`: Use Slang's internal version of `glslang` as exposed by `slang-glslang.dll`
  * `dxc`: Use DirectXShaderCompiler (https://github.com/Microsoft/DirectXShaderCompiler)
  * These are intended for debugging/testing purposes, when you want to be able to see what these existing compilers do with the "same" input and options

* `-verbose-paths`: When displaying diagnostic output aim to display more detailed path information. In practice this is typically the complete 'canonical' path to the source file used.

* `-g`: Include debug information in the generated code, where possible. Currently only supported for DXBC and DXIL output (not SPIR-V).

* `-O`: Control optimization levels. This currently only affects DXBC and DXIL generation.
  * `-O0`: Disable all optimizations
  * `-O1`, `-O`: Enable a default level of optimization. This is the default if no `-O` options are used.
  * `-O2`: Enable aggressive optimizations for speed.
  * `-O3`: Enable further optimizations, which might have a significant impact on compile time, or involve unwanted tradeoffs in terms of code size.

* `--`: Stop parsing options, and treat the rest of the command line as input paths

* `-output-includes`: After pre-processing has been performed will output to via the diagnostics the hierarchy of paths to source files reached 

* -Xname to specify arguments to downstream tool `name` (covered in more detail in "Downstream Arguments")

<a id="downstream-arguments"></a>
### Downstream Arguments

During a Slang compilation work may be performed by multiple other stages including downstream compilers and linkers. It isn't possible in general or perhaps even desirable to provide Slang command line equivalents of every option available at every stage of compilation. It is useful to be able to set options specific to a particular compilation stage - to alter code generation, linkage and other options.

The mechanism used here is based on the `-X` mechanism used in GCC, to specify arguments to the linker.

```
-Xlinker option
```

When used, `option` is not interpreted by GCC, but is passed to the linker once compilation is complete. Slang extends this idea in several ways. First there are many more 'downstream' stages available to Slang than just `linker`. These different stages are known as `SlangPassThrough` types in the API and have the following names

* `fxc` - FXC HLSL compiler
* `dxc` - DXC HLSL compiler
* `glslang` - GLSLANG GLSL compiler
* `visualstudio` - Visual Studio C/C++ compiler
* `clang` - Clang C/C++ compiler
* `gcc` - GCC C/C++ compiler
* `genericcpp` - A generic C++ compiler (can be any one of visual studio, clang or gcc depending on system and availability)
* `nvrtc` - NVRTC CUDA compiler

The Slang command line allows you to specify an argument to these downstream compilers, by using their name after the `-X`. So for example to send an option `-Gfa` through to DXC you can use 

```
-Xdxc -Gfa
```

Note that if an option is available via normal Slang command line options then these should be used. This will generally work across multiple targets, but also avoids options clashing which is undefined behavior currently. The `-X` mechanism is best used for options that are unavailable through normal Slang mechanisms. 

If you want to pass multiple options using this mechanism the `-Xdxc` needs to be in front of every options. For example 

```
-Xdxc -Gfa -Xdxc -Vd
```

Would reach `dxc` as 

```
-Gfa -Vd
```

This can get a little repetitive especially if there are many parameters, so Slang adds a mechanism to have multiple options passed by using an ellipsis `...`. The syntax is as follows

```
-Xdxc... -Gfa -Vd -X.
```

The `...` at the end indicates all the following parameters should be sent to `dxc` until it reaches the matching terminating `-X.` or the end of the command line. 

It is also worth noting that `-X...` options can be nested. This would allow a GCC downstream compilation to control linking, for example with

```
-Xgcc -Xlinker --split -X.
```

In this example gcc would see

```
-Xlinker --split
```

And the linker would see (as passed through by gcc) 

```
--split
```

Setting options for tools that aren't used in a Slang compilation has no effect. This allows for setting `-X` options specific for all downstream tools on a command line, and they are only used as part of a compilation that needs them.

NOTE! Not all tools that Slang uses downstream make command line argument parsing available. `FXC` and `GLSLANG` currently do not have any command line argument passing as part of their integration, although this could change in the future.

The `-X` mechanism is also supported by render-test tool. In this usage `slang` becomes a downstream tool. Thus you can use the `dxc` option `-Gfa` in a render-test via 

```
-Xslang... -Xdxc -Gfa -X.
```

Means that the dxc compilation in the render test (assuming dxc is invoked) will receive 

```
-Gfa
```

Some options are made available via the same mechanism for all downstream compilers. 

* Use `-I` to specify include path for downstream compilers

For example to specify an include path "somePath" to DXC you can use...

```
-Xdxc -IsomePath
```

### Specifying where dlls/shared libraries are loaded from

On windows if you want a dll loaded from a specific path, the path must be specified absolutely. See the [LoadLibrary documentation](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya) for more details. A relative path will cause Windows to check all locations along it's search procedure.

On linux it's similar, but any path (relative or not) will override the regular search mechanism. See [dlopen](https://man7.org/linux/man-pages/man3/dlopen.3.html) for more details. 

* `-dxc-path`: Sets the path where dxc dll/shared libraries are loaded from (dxcompiler & dxil).

* `-fxc-path`: Sets the path where fxc dll is loaded from (d3dcompiler_47.dll). 

* `-glslang-path`: Sets where the Slang specific 'slang-glslang' is loaded from

Paths can specify a directory that holds the appropriate binaries. It can also be used to name a specific downstream binary - be it a shared library or an executable. Note that if it is a shared library, it is not necessary to provide the full filesystem name - just the path and/or name that will be used to load it. For example on windows `fxc` can be loaded from `D:/mydlls` with

* `D:/mydlls` - will look for `d3dcompiler_47.dll` in this directory
* `D:/mydlls/d3dcompiler_47` - it's not necessary to specify .dll to load a dll on windows
* `D:/mydlls/d3dcompiler_47.dll` - it is also possible name the shared library explicitly for example

The name of the shared library/executable can be used to specify a specific version, for example by using `D:/mydlls/dxcompiler-some-version` for a specific version of `dxc`. 

Limitations
-----------

A major limitation of the `slangc` command today is that there is no provision for getting reflection data out along with the compiled shader code.
For now, the command-line tool is best seen as a debugging/testing tool, and all serious applications should drive Slang through the API.


================================================
FILE: Source/External/slang/docs/cpu-target.md
================================================
Slang CPU Target Support
========================

Slang has preliminary support for producing CPU source and binaries. 

# Features

* Can compile C/C++/Slang source to binaries (executables, shared libraries or [directly executable](#host-callable))
* Does *not* require a C/C++ be installed if [slang-llvm](#slang-llvm) is available (as distributed with slang binary distributions)
* Can compile Slang source into C++ source code
* Supports compute style shaders 

# Limitations

These limitations apply to Slang transpiling to C++. 

* Barriers are not supported (making these work would require an ABI change)
* Atomics are not currently supported
* Limited support for [out of bounds](#out-of-bounds) accesses handling
* Entry point/s cannot be named `main` (this is because downstream C++ compiler/s expecting a regular `main`)
* `float16_t` type is not currently supported

For current C++ source output, the compiler needs to support partial specialization. 

# How it works

The initial version works by using a 'downstream' C/C++ compiler. A C++ compiler does *not* in general need to be installed on a system to compile and execute code as long as [slang-llvm](#slang-llvm) is available. A [regular C/C++](#regular-cpp) compiler can also be used, allowing access to tooling, such as profiling and debuggers, as well as being able to use regular host development features such as linking, libraries, shared libraries/dlls and executables. 

The C/C++ backend can be directly accessed much like 'dxc', 'fxc' of 'glslang' can, using the pass-through mechanism with the following new backends... 

```
SLANG_PASS_THROUGH_CLANG,                   ///< Clang C/C++ compiler 
SLANG_PASS_THROUGH_VISUAL_STUDIO,           ///< Visual studio C/C++ compiler
SLANG_PASS_THROUGH_GCC,                     ///< GCC C/C++ compiler
SLANG_PASS_THROUGH_LLVM,                    ///< slang-llvm 'compiler' - includes LLVM and Clang
SLANG_PASS_THROUGH_GENERIC_C_CPP,           ///< Generic C or C++ compiler, which is decided by the source type
```

Sometimes it is not important which C/C++ compiler is used, and this can be specified via the 'Generic C/C++' option. This will aim to use the compiler that is most likely binary compatible with the compiler that was used to build the Slang binary being used. 

To make it possible for Slang to produce CPU code, in this first iteration we convert Slang code into C/C++ which can subsequently be compiled into CPU code. If source is desired instead of a binary this can be specified via the SlangCompileTarget. These can be specified on the `slangc` command line as `-target cpp`.

When using the 'pass through' mode for a CPU based target it is currently necessary to set an entry point, even though it's basically ignored. 

In the API the `SlangCompileTarget`s are 

```
SLANG_C_SOURCE             ///< The C language
SLANG_CPP_SOURCE           ///< The C++ language
SLANG_HOST_CPP_SOURCE,     ///< C++ code for `host` style 
```        
   
Using the `-target` command line option

* C_SOURCE: c
* CPP_SOURCE: cpp,c++,cxx
* HOST_CPP_SOURCE: host-cpp,host-c++,host-cxx

Note! Output of C source is not currently supported.

If a CPU binary is required this can be specified as a `SlangCompileTarget` of 
   
```   
SLANG_EXECUTABLE                ///< Executable (for hosting CPU/OS)
SLANG_SHADER_SHARED_LIBRARY     ///< A shared library/Dll (for hosting CPU/OS)
SLANG_SHADER_HOST_CALLABLE      ///< A CPU target that makes `compute kernel` compiled code available to be run immediately 
SLANG_HOST_HOST_CALLABLE        ///< A CPU target that makes `scalar` compiled code available to be run immediately
SLANG_OBJECT_CODE,              ///< Object code that can be used for later linking
```

Using the `-target` command line option

* EXECUTABLE: exe, executable
* SHADER_SHARED_LIBRARY: sharedlib, sharedlibrary, dll
* SHADER_HOST_CALLABLE: callable, host-callable
* OBJECT_CODE: object-conde
* HOST_HOST_CALLABLE: host-host-callable
    
Using `host-callable` types from the the command line, other than to test such code compile and can be loaded for host execution.

For launching a [shader like](#compile-style) Slang code on the CPU, there typically needs to be binding of values passed the entry point function. How this works is described in the [ABI section](#abi). Functions *can* be executed directly but care must be taken to [export](#visibility) them and such that there isn't an issue with [context threading](#context-threading).

If a binary target is requested, the binary contents can be returned in a ISlangBlob just like for other targets. When using a [regular C/C++ compiler](#regular-cpp) the CPU binary typically must be saved as a file and then potentially marked for execution by the OS. It may be possible to load shared libraries or dlls from memory - but doing so is a non standard feature, that requires unusual work arounds. If possible it is typically fastest and easiest to use [slang-llvm](#slang-llvm) to directly execute slang or C/C++ code.

## <a id="compile-style"/>Compilation Styles

There are currently two styles of *compilation style* supported - `host` and `shader`. 

The `shader` style implies 

* The code *can* be executed in a GPU-kernel like execution model, launched across multiple threads (as described in the [ABI](#abi)) 
* Currently no reference counting
* Only functionality from the Slang stdlib, built in HLSL or anything supplied by a [COM interfaces](#com-interface) is available
* Currently [slang-llvm](#slang-llvm) only supports the `shader` style

The `host` style implies 

* Execution style is akin to more regular CPU scalar code
* Typically requires linking with `slang-rt` and use of `slang-rt` types such as `Slang::String` 
* Allows use of `new` 
* Allows the use of `class` for reference counted types
* COM interfaces are reference counted

The styles as used with [host-callable](#host-callable) are indicated via the API by 

```
SLANG_SHADER_HOST_CALLABLE  ///< A CPU target that makes `compute kernel` compiled code available to be run immediately 
SLANG_HOST_HOST_CALLABLE    ///< A CPU target that makes `scalar` compiled code available to be run immediately
```

Or via the `-target` command line options

* For 'shader' `callable` `host-callable`
* For 'host' `host-host-callable`

For an example of the `host` style please look at "examples/cpu-hello-world".

## <a id="host-callable"/>Host callable

Slang supports `host-callable` compilation targets which allow for the direct execution of the compiled code on the CPU. Currently this style of execution is supported if [slang-llvm](#slang-llvm) or a [regular C/C++ compiler](#regular-cpp) are available.

There are currently two [compilation styles](#compile-style) supported. 

In order to call into `host-callable` code after compilation it's necessary to access the result via the `ISlangSharedLibrary` interface. 

Please look at the [ABI](#abi) section for more specifics around ABI usage especially for `shader` [compile styles](#compile-style).

```C++
    slang::ICompileRequest* request = ...;

    const SlangResult compileRes = request->compile();

    // Even if there were no errors that forced compilation to fail, the
    // compiler may have produced "diagnostic" output such as warnings.
    // We will go ahead and print that output here.
    //
    if(auto diagnostics = request->getDiagnosticOutput())
    {
        printf("%s", diagnostics);
    }

    // Get the 'shared library' (note that this doesn't necessarily have to be implemented as a shared library
    // it's just an interface to executable code).
    ComPtr<ISlangSharedLibrary> sharedLibrary;
    SLANG_RETURN_ON_FAIL(request->getTargetHostCallable(0, sharedLibrary.writeRef()));

    // We can now find exported functions/variables via findSymbolAddressByName

    // For a __global public __extern_cpp int myGlobal;
    {    
        auto myGlobalPtr = (int*)sharedLibrary->findSymbolAddressByName("myGlobal");
        if (myGlobalPtr)
        {
            *myGlobalPtr = 10;
        }
    }
    
    // To get a function 
    // 
    // public __extern_cpp int add(int a, int b);
    
    // Test a free function
    {
        typedef int (*AddFunc)(int a, int b); 
        auto func = (AddFunc)sharedLibrary->findFuncByName("add");

        if (func)
        {
            // Let's add!
            int c = func(10, 20):
        }
    }
```

## <a id="slang-llvm"/>slang-llvm

`slang-llvm` is a special Slang version of [LLVM](https://llvm.org/). It's current main purpose is to allow compiling C/C++ such that it is [directly available](#host-callable) for execution using the LLVM JIT feature. If `slang-llvm` is available it is the default downstream compiler for [host-callable](#host-callable). This is because it allows for faster compilation, avoids the file system, and can execute the compiled code directly. [Regular C/C++ compilers](#regular-cpp) can be used for [host-callable](#host-callable) but requires writing source files to the file system and creating/loading shared-libraries/dlls to make the feature work.  Additionally using `slang-llvm` avoids the need for a C/C++ compiler installed on a target system.   
 
`slang-llvm` contains the Clang C++ compiler, so it is possible to also compile and execute C/C++ code in the [host-callable](#host-callable) style. 

Limitations of using `slang-llvm`
 
* Can only currently be used for [shader style](#compile-style) 
  * Cannot produce object files, libraries, OS executables or binaries 
* Is *limited* because it is not possible to directly access libraries such as the C or C++ standard libraries (see [COM interface](#com-interface) for a work-around)
* It's not possible to source debug into `slang-llvm` compiled code running on the JIT (see [debugging](#debugging) for a work-around)
* Not currently possible to return as a ISlangBlob representation 

You can detect if `slang-llvm` is available via

```C++
    slang::IGlobalSession* slangSession = ...;
    const bool hasSlangLlvm = SLANG_SUCCEEDED(slangSession->checkPassThroughSupport(SLANG_PASS_THROUGH_LLVM)); 
```

## <a id="regular-cpp"/>Regular C/C++ compilers

Slang can work with regular C/C++ 'downstream' compilers. It has been tested to work with Visual Studio, Clang and G++/Gcc on Windows and Linux.

Under the covers when Slang is used to generate a binary via a C/C++ compiler, it must do so through the file system. Currently this means the source (say generated by Slang) and the binary (produced by the C/C++ compiler) must all be files. To make this work Slang uses temporary files. The reasoning for hiding this mechanism, other than simplicity, is that it allows using with [slang-llvm](#slang-llvm) without any changes. 

## <a id="visibility"/>Visibility

In a typical Slang [shader like](#compile-style) scenario, functionality is exposed via entry points. It can be convenient and desirable to be able to call Slang functions directly from application code, and not just via entry points. By default non entry point functions are *removed* if they are not reachable by the specified entry point. Additionally for non entry point functions Slang typically generates function names that differ from the original name. 

To work around these two issues the `public` and `__extern_cpp` modifiers can be used.

`public` makes the variable or function visible outside of the module even if it isn't used within the module. For the function to work it will also keep around any function or variable it accesses. 

Note! Some care is needed here around [context threading](#context-threading) - if a function or any function a function accesses requires state held in the context, the signature of the function will be altered to include the context as the first parameter.

Making a function or variable `public` does not mean that the name remains the same. To indicate that the name should not be altered use the `__extern_cpp` modifier. For example

```
// myGlobal will be visible to the application (note the __global modifier additionally means it has C++ global behavior)
__global public __extern_cpp int myGlobal;

// myFunc is available to the application
public __extern_cpp myFunc(int a) 
{
    return a * a;
}
```

## <a id="com-interface"/>COM interface support

Slang has preliminary support for [Component Object Model (COM)](https://en.wikipedia.org/wiki/Component_Object_Model) interfaces in CPU code. 

```
[COM]
interface IDoThings
{
    int doThing(int a, int b);
    int calcHash(NativeString in);
    void printMessage(NativeString nativeString);
}
```

This support provides a way for an application to provide access to functionality in the application runtime - essentially it allows Slang code to call into application code. To do this a COM interface can be created that exposes the desired functionality. The interface/s can be made available through any of the normal mechanisms - such as through a constant buffer variable. Additionally [`__global`](#actual-global) provides a way to make functions available to Slang code without the need for [context threading](#context-threading).

The example "examples/cpu-com-example" shows this at work.

## <a id="actual-global"/>Global support

The Slang language is based on the HLSL language. This heritage means that globals have slightly different meaning to typical C/C++ usage. 

```
int myGlobal;                           ///< A constant value stored in a constant buffer
static int staticMyGlobal;              ///< A global that cannot be seen by the application 
static const int staticConstMyGlobal;   ///< A fixed value
``` 

The variable `myGlobal` will be a member of a constant buffer, meaning it's value can only change via bindings and not during execution. For some uses having `myGlobal` in the constant buffer might be appropriate, for example

* It's use is reached from a [shader style](#compile-style) entry point 
* It's value is constant across the launch 

In Slang a variable can be declared as global in the C/C++ sense via the `__global` modifier. For example

```
__global int myGlobal;
```

Doing so means

* `myGlobal` will not be defined in the constant buffer
* It can be used in functions that do not have access to the [constant buffer](#context-threading)
* It can be modified in the kernel 
* Can only be used on CPU targets (currently `__global` is not supported on the GPU targets)

One disadvantage of using `__global` is in multi-threaded environments, with multiple launches on multiple CPU threads, there is only one global and will likely cause problems unless the global value is the same across all threads.

It may be useful to set a global directly via host code, without having to write a function to enable the access. This is possible by using [`public`](#visibility) and [`__extern_cpp`](#visibility) modifiers. For example 

```
__global public __extern_cpp int myGlobal;
```

The global can now be set from host code via

```C++
    slang::ICompileRequest = ...;

    // Get the 'shared library' (note that this doesn't necessarily have to be implemented as a shared library
    // it's just an interface to executable code).
    ComPtr<ISlangSharedLibrary> sharedLibrary;
    SLANG_RETURN_ON_FAIL(request->getTargetHostCallable(0, sharedLibrary.writeRef()));

    // Set myGlobal to 20
    {
        auto myGlobalPtr = (int*)sharedLibrary->findSymbolAddressByName("myGlobal");
        *myGlobalPtr = 20;
    }
```

In terms of reflection `__global` variables are not visibile. 

## NativeString

Slang supports a rich 'String' type when using the [host style](#compile-style), which for C++ targets is implemented as the `Slang::String` C++ type. The type is only available on CPU targets that support `slang-rt`. 

Some limited String-like support is available via `NativeString` type which for C/C++ CPU targets is equivalent to `const char*`. For GPU targets this will use the same hash mechanism as normally available. 

`NativeString` is supported by all [shader compilation styles](#compile-style) including [slang-llvm](#slang-llvm).

TODO(JS): What happens with String with shader compile style on CPU? Shouldn't it be the same as GPU (and reflected as such in reflection)?

## Debugging

It is currently not possible to step into LLVM-JIT code when using [slang-llvm](#slang-llvm). Fortunately it is possible to step into code compiled via a [regular C/C++ compiler](#regular-cpp). 

Below is a code snippet showing how to swich to a [regular C/C++ compiler](#regular-cpp) at runtime. 

```C++
    SlangPassThrough findRegularCppCompiler(slang::IGlobalSession* slangSession)
    {
        // Current list of 'regular' C/C++ compilers
        const SlangPassThrough cppCompilers[] = 
        {
            SLANG_PASS_THROUGH_VISUAL_STUDIO,
            SLANG_PASS_THROUGH_GCC,
            SLANG_PASS_THROUGH_CLANG,
        };
        // Do we have a C++ compiler
        for (const auto compiler : cppCompilers)
        {
            if (SLANG_SUCCEEDED(slangSession->checkPassThroughSupport(compiler)))
            {
                return compile;
            }
        }
        return SLANG_PASS_THROUGH_NONE;
    }

    SlangResult useRegularCppCompiler(slang::IGlobalSession* session)
    {
        const auto regularCppCompiler = findRegularCppCompiler(session)
        if (regularCppCompiler != SLANG_PASS_THROUGH_NONE)
        {
            slangSession->setDownstreamCompilerForTransition(SLANG_CPP_SOURCE, SLANG_SHADER_HOST_CALLABLE, regularCppCompiler);
            slangSession->setDownstreamCompilerForTransition(SLANG_CPP_SOURCE, SLANG_HOST_HOST_CALLABLE, regularCppCompiler);
            return SLANG_OK;
        }
        return SLANG_FAIL;
    }
```        

It is generally recommended to use [slang-llvm](#slang-llvm) if that is appropriate, but to switch to using a [regular C/C++ compiler](#regular-cpp) when debugging is needed. This should be largely transparent to most code.

Executing CPU Code
==================

In typical Slang operation when code is compiled it produces either source or a binary that can then be loaded by another API such as a rendering API. With CPU code the binary produced could be saved to a file and then executed as an exe or a shared library/dll. In practice though it is common to want to be able to execute compiled code immediately. Having to save off to a file and then load again can be awkward. It is also not necessarily the case that code needs to be saved to a file to be executed. 

To handle being able call code directly, code can be compiled using the [host-callable](#host-callable).

For pass through compilation of C/C++ this mechanism allows any functions marked for export to be directly queried. Marking for export is a C/C++ compiler specific feature. Look at the definition of `SLANG_PRELUDE_EXPORT` in the [C++ prelude](#prelude).

For a complete example on how to execute CPU code using `spGetEntryPointHostCallable`/`getEntryPointHostCallable` look at code in `example/cpu-hello-world`. 

<a id="abi"/>Application Binary Interface (ABI)
===

Say we have some Slang source like the following:

```
struct Thing { int a; int b; }

Texture2D<float> tex;
SamplerState sampler;
RWStructuredBuffer<int> outputBuffer;        
ConstantBuffer<Thing> thing3;        
        
[numthreads(4, 1, 1)]
void computeMain(
    uint3 dispatchThreadID : SV_DispatchThreadID, 
    uniform Thing thing, 
    uniform Thing thing2)
{
   // ...
}
```

When compiled into a [shader compile style](#compile-style) shared library/dll/host-callable - how is it invoked? An entry point in the Slang source code produces several exported functions. The 'default' exported function has the same name as the entry point in the original source. It has the signature  

```
void computeMain(ComputeVaryingInput* varyingInput, UniformEntryPointParams* uniformParams, UniformState* uniformState);
```

NOTE! Using `main` as an entry point name should be avoided if CPU is a target because it typically causes compilation errors due it's normal C/C++ usage.

ComputeVaryingInput is defined in the prelude as 

```
struct ComputeVaryingInput
{
    uint3 startGroupID;
    uint3 endGroupID;
};
```

`ComputeVaryingInput` allows specifying a range of groupIDs to execute - all the ids in a grid from startGroup to endGroup, but not including the endGroupIDs. Most compute APIs allow specifying an x,y,z extent on 'dispatch'. This would be equivalent as having startGroupID = { 0, 0, 0} and endGroupID = { x, y, z }. The exported function allows setting a range of groupIDs such that client code could dispatch different parts of the work to different cores. This group range mechanism was chosen as the 'default' mechanism as it is most likely to achieve the best performance.

There are two other functions that consist of the entry point name postfixed with `_Thread` and `_Group`. For the entry point 'computeMain' these functions would be accessable from the shared library interface as `computeMain_Group` and `computeMain_Thread`. `_Group` has the same signature as the listed for computeMain, but it doesn't execute a range, only the single group specified by startGroupID (endGroupID is ignored). That is all of the threads within the group (as specified by `[numthreads]`) will be executed in a single call. 

It may be desirable to have even finer control of how execution takes place down to the level of individual 'thread's and this can be achieved with the `_Thread` style. The signature looks as follows

```
struct ComputeThreadVaryingInput
{
    uint3 groupID;
    uint3 groupThreadID;
};

void computeMain_Thread(ComputeThreadVaryingInput* varyingInput, UniformEntryPointParams* uniformParams, UniformState* uniformState);
```

When invoking the kernel at the `thread` level it is a question of updating the groupID/groupThreadID, to specify which thread of the computation to execute. For the example above we have `[numthreads(4, 1, 1)]`. This means groupThreadID.x can vary from 0-3 and .y and .z must be 0. That groupID.x indicates which 'group of 4' to execute. So groupID.x = 1, with groupThreadID.x=0,1,2,3 runs the 4th, 5th, 6th and 7th 'thread'. Being able to invoke each thread in this way is flexible - in that any specific thread can specified and executed. It is not necessarily very efficient because there is the call overhead and a small amount of extra work that is performed inside the kernel. 

Note that the `_Thread` style signature is likely to change to support 'groupshared' variables in the near future.

In terms of performance the 'default' function is probably the most efficient for most common usages. The `_Group` style allows for slightly less loop overhead, but with many invocations this will likely be drowned out by the extra call/setup overhead. The `_Thread` style in most situations will be the slowest, with even more call overhead, and less options for the C/C++ compiler to use faster paths. 

The UniformState and UniformEntryPointParams struct typically vary by shader. UniformState holds 'normal' bindings, whereas UniformEntryPointParams hold the uniform entry point parameters. Where specific bindings or parameters are located can be determined by reflection. The structures for the example above would be something like the following... 

```
struct UniformEntryPointParams
{
    Thing thing;
    Thing thing2;
};

struct UniformState
{
    Texture2D<float > tex;
    SamplerState sampler;
    RWStructuredBuffer<int32_t> outputBuffer;
    Thing* thing3;
};   
```

Notice that of the entry point parameters `dispatchThreadID` is not part of UniformEntryPointParams and this is because it is not uniform.

`ConstantBuffer` and `ParameterBlock` will become pointers to the type they hold (as `thing3` is in the above structure).
 
`StructuredBuffer<T>`,`RWStructuredBuffer<T>` become

```
    T* data;
    size_t count;
```    

`ByteAddressBuffer`, `RWByteAddressBuffer` become 

```
    uint32_t* data;
    size_t sizeInBytes;
```    


Resource types become pointers to interfaces that implement their features. For example `Texture2D` become a pointer to a `ITexture2D` interface that has to be implemented in client side code. Similarly SamplerState and SamplerComparisonState become `ISamplerState` and `ISamplerComparisonState`.  
 
The actual definitions for the interfaces for resource types, and types are specified in 'slang-cpp-types.h' in the `prelude` directory.

## Unsized arrays

Unsized arrays can be used, which are indicated by an array with no size as in `[]`. For example 

```
    RWStructuredBuffer<int> arrayOfArrays[];
```

With normal 'sized' arrays, the elements are just stored contiguously within wherever they are defined. With an unsized array they map to `Array<T>` which is...

```
    T* data;
    size_t count;
```    

Note that there is no method in the shader source to get the `count`, even though on the CPU target it is stored and easily available. This is because of the behavior on GPU targets 

* That the count has to be stored elsewhere (unlike with CPU) 
* On some GPU targets there is no bounds checking - accessing outside the bound values can cause *undefined behavior*
* The elements may be laid out *contiguously* on GPU

In practice this means if you want to access the `count` in shader code it will need to be passed by another mechanism - such as within a constant buffer. It is possible in the future support may be added to allow direct access of `count` work across targets transparently. 

It is perhaps worth noting that the CPU allows us to have an indirection (a pointer to the unsized arrays contents) which has the potential for more flexibility than is possible on GPU targets. GPU target typically require the elements to be placed 'contiguously' from their location in their `container` - be that registers or in memory. This means on GPU targets there may be other restrictions on where unsized arrays can be placed in a structure for example, such as only at the end. If code needs to work across targets this means these restrictions will need to be followed across targets. 

## <a id="context-threading"/>Context Threading

The [shader compile style](#compile-style) brings some extra issues to bare. In the HLSL compute kernel launch model application visible variables and resource are bound. As described in the [ABI](#abi) section these bindings and additional information identifying a compute thread are passed into the launch as a context. Take for example the code snippet below

```
int myGlobal;

int myFunc(int v)
{
    return myGlobal + v;
}

int anotherFunc(int a, int b)
{
    return a + b;
}

[numthreads(4, 1, 1)]
void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
{    
    outputBuffer[dispatchThreadID.x] = myFunc(dispatchThreadID.x) + anotherFunc(1, dispatchThreadID.y);
}
```

The function `myFunc` accesses a variable `myGlobal` that is held within a constant buffer. The function cannot be meaningfully executed without access to the context, and the context is available as a parameter passed through `computeMain` entry point at launch. This means the *actual* signature of this function in output code will be something like

```
int32_t myFunc_0(KernelContext_0 * kernelContext_0)
{
    return *(&(*(&kernelContext_0->globalParams_0))->myGlobal_0) + int(1);
}
```

The context parameter has been *threaded* into this function. This *threading* will happen to any function that accesses any state that is held in the context. This behavior also happens transitively - if a function *could* call *any* another function that requires the context, the context will be threaded through to it also.

If application code assumed `myFunc` could be called with no parameters a crash would likely ensue. Note that `anotherFunc` does not have the issue because it doesn't perform an access that needs the context, and so no context threading is added.

If a global is desired in a function that wants to be called from the application, the [`__global`](#actual-global) modifier can be used.

## <a id="prelude"/>Prelude

For C++ targets, there is code to support the Slang generated source defined within the 'prelude'. The prelude is inserted text placed before the Slang generated C++ source. For the Slang command line tools as well as the test infrastructure, the prelude functionality is achieved through a `#include` in the prelude text of the `prelude/slang-cpp-prelude.h` specified with an absolute path. Doing so means other files the `slang-cpp-prelude.h` might need can be specified relatively, and include paths for the backend C/C++ compiler do not need to be modified. 

The prelude needs to define 

* 'Built in' types (vector, matrix, 'object'-like Texture, SamplerState etc) 
* Scalar intrinsic function implementations
* Compiler based definations/tweaks 

For the Slang prelude this is split into the following files...

* 'prelude/slang-cpp-prelude.h' - Header that includes all the other requirements & some compiler tweaks
* 'prelude/slang-cpp-scalar-intrinsics.h' - Scalar intrinsic implementations
* 'prelude/slang-cpp-types.h' - The 'built in types' 
* 'slang.h' - Slang header is used for majority of compiler based definitions

For a client application - as long as the requirements of the generated code are met, the prelude can be implemented by whatever mechanism is appropriate for the client. For example the implementation could be replaced with another implementation, or the prelude could contain all of the required text for compilation. Setting the prelude text can be achieved with the method on the global session...

```
/** Set the 'prelude' for generated code for a 'downstream compiler'.
@param passThrough The downstream compiler for generated code that will have the prelude applied to it. 
@param preludeText The text added pre-pended verbatim before the generated source

That for pass-through usage, prelude is not pre-pended, preludes are for code generation only. 
*/
virtual SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerPrelude(
SlangPassThrough passThrough,
const char* preludeText) = 0;
```

It may be useful to be able to include `slang-cpp-types.h` in C++ code to access the types that are used in the generated code. This introduces a problem in that the types used in the generated code might clash with types in client code. To work around this problem, you can wrap all of the types defined in the prelude with a namespace of your choosing. For example 

```
#define SLANG_PRELUDE_NAMESPACE CPPPrelude
#include "../../prelude/slang-cpp-types.h"
``` 

Would wrap all the Slang prelude types in the namespace `CPPPrelude`, such that say a `StructuredBuffer<int32_t>` could be specified in C++ source code as `CPPPrelude::StructuredBuffer<int32_t>`.

The code that sets up the prelude for the test infrastucture and command line usage can be found in ```TestToolUtil::setSessionDefaultPrelude```. Essentially this determines what the absolute path is to `slang-cpp-prelude.h` is and then just makes the prelude `#include "the absolute path"`.

The *default* prelude is set to the contents of the files for C++ held in the prelude directory and is held within the Slang shared library. It is therefore typically not necessary to distribute Slang with prelude files.

Language aspects
================

# Arrays passed by Value

Slang follows the HLSL convention that arrays are passed by value. This is in contrast the C/C++ where arrays are passed by reference. To make generated C/C++ follow this convention an array is turned into a 'FixedArray' struct type. Sinces classes by default in C/C++ are passed by reference the wrapped array is also. 

To get something similar to C/C++ operation the array can be marked `inout` to make it passed by reference. 

Limitations
===========

# <a id="out-of-bounds"/>Out of bounds access

In HLSL code if an access is made out of bounds of a StructuredBuffer, execution proceceeds. If an out of bounds read is performed, a zeroed value is returned. If an out of bounds write is performed it's effectively a noop, as the value is discarded. On the CPU target this behavior is *not* supported by default. 

For a debug CPU build an out of bounds access will assert, for a release build the behaviour is by default undefined. A limited Limited [zero index](#zero-index) out of bounds mechanism is supported, but must be enabled.

The reason for this is that such an access is difficult and/or slow to implement the identical GPU behavior on the CPU. The underlying problem is `operator[]` typically returns a reference to the contained value. If this is out of bounds - it's not clear what to return, in particular because the value may be read or written and moreover elements of the type might be written. In practice this means a global zeroed value cannot be returned. 

This could be somewhat supported if code gen worked as followed for say

```
RWStructuredBuffer<float4> values;
values[3].x = 10;
```

Produces

```
template <typename T>
struct RWStructuredBuffer
{
    T& at(size_t index, T& defValue) { return index < size ? values[index] : defValue; } 

    T* values;
    size_t size;
};

RWStructuredBuffer<float4> values;

// ...
Vector<float, 3> defValue = {};         // Zero initialize such that read access returns default values
values.at(3).x = 10;
```

Note that '[] 'would be turned into the `at` function, which takes the default value as a paramter provided by the caller. If this is then written to then only the defValue is corrupted.  Even this mechanism not be quite right, because if we write and then read again from the out of bounds reference in HLSL we may expect that 0 is returned, whereas here we get the value that was last written.

## <a id="zero-index"/>Zero index bound checking

If bounds checking is wanted in order to avoid undefined behavior and limit how memory is accessed `zero indexed` bounds checking might be appropriate. When enabled if an access is out of bounds the value at the zero index is returned. This is quite different behavior than the typical GPU behavior, but is fairly efficient and simple to implement. Importantly it means behavior is well defined and always 'in range' assuming there is an element.

To enable zero indexing bounds checking pass in the define `SLANG_ENABLE_BOUND_ZERO_INDEX` to a Slang compilation. This define is passed down to C++ and CUDA compilations, and the code in the CUDA and C++ preludes implement the feature. Note that zero indexed bounds checking will slow down accesses that are checked.

The C++ implementation of the feature can be seen by looking at the file "prelude/slang-cpp-types.h". For CUDA "prelude/slang-cuda-prelude.h".

The bounds checking macros are guarded such it is possible to replace the implementations, without directly altering the prelude.

TODO
====

# Main

* groupshared is not yet supported
* Output of header files 
* Output multiple entry points

# Internal Slang compiler features

These issues are more internal Slang features/improvements 

* Currently only generates C++ code, it would be fairly straight forward to support C (especially if we have 'intrinsic definitions')
* Have 'intrinsic definitions' in standard library - such that they can be generated where appropriate 
  + This will simplify the C/C++ code generation as means Slang language will generate must of the appropriate code
* Currently 'construct' IR inst is supported as is, we may want to split out to separate instructions for specific scenarios
* Refactoring around swizzle. Currently in emit it has to check for a variety of scenarios - could be simplified with an IR pass and perhaps more specific instructions. 


================================================
FILE: Source/External/slang/docs/cuda-target.md
================================================
Slang CUDA Target Support
=========================

Slang has preliminary support for producing CUDA source, and PTX binaries using (NVRTC)[https://docs.nvidia.com/cuda/nvrtc/index.html]. 

NOTE! NVRTC is only available for 64-bit operating systems. On Windows Visual Studio make sure you are compiling for 'x64' and/or use 64 bit Slang binaries. 

# Features

* Can compile Slang source into CUDA source code
* Supports compute style shaders 
* Supports a 'bindless' CPU like model
* Can compile CUDA source to PTX through 'pass through' mechansism

# Limitations

These limitations apply to Slang transpiling to CUDA. 

* Only supports the 'texture object' style binding (The texture object API is only supported on devices of compute capability 3.0 or higher. )
* Samplers are not separate objects in CUDA - they are combined into a single 'TextureObject'. So samplers are effectively ignored on CUDA targets. 
* When using a TextureArray.Sample (layered texture in CUDA) - the index will be treated as an int, as this is all CUDA allows
* Care must be used in using `WaveGetLaneIndex` wave intrinsic - it will only give the right results for appropriate launches
* CUDA 'surfaces' are used for textures which are read/write (aka RWTexture). 

The following are a work in progress or not implemented but are planned to be so in the future

* Some resource types remain unsupported, and not all methods on all types are supported

# How it works

For producing PTX binaries Slang uses (NVRTC)[https://docs.nvidia.com/cuda/nvrtc/index.html]. NVRTC dll/shared library has to be available to Slang (for example in the appropriate PATH for example) for it to be able to produce PTX.

The NVRTC compiler can be accessed directly via the pass through mechanism and is identifed by the enum value `SLANG_PASS_THROUGH_NVRTC`.

Much like other targets that use downstream compilers Slang can be used to compile CUDA source directly to PTX via the pass through mechansism. The Slang command line options will broadly be mapped down to the appropriate options for the NVRTC compilation. In the API the `SlangCompileTarget` for CUDA is `SLANG_CUDA_SOURCE` and for PTX is `SLANG_PTX`. These can also be specified on the Slang command line as `-target cuda` and `-target ptx`. 

## Locating NVRTC

Finding NVRTC can require some nuance if a specific version is required. On the command line the `-nvrtc-path` option can be used to set the `path` to NVRTC. Also `spProcessCommandLineArguments`/`processCommandLineArguments` with `-nvrtc-path` or `setDownstreamCompilerPath` with `SLANG_PASS_THROUGH_NVRTC` can be used to set the location and/or name of NVRTC via the API. 

Important points of note are

* The name of the shared library should *not* include any extension (such as `.dll`/`.so`/`.dynlib`) or prefix (such as `lib`).
* The path also *doesn't* have to be path, it can just be the shared library name. Doing so will mean it will be searched for by whatever the default mechanism is on the target. 
* If a path and/or name is specified for NVRTC - this will be the *only* version searched for.
 
If a path/name is *not* specified for NVRTC, Slang will attempt to load a shared library called `nvrtc`. For non Windows targets this should be enough to find and load the latest version.
 
On Windows NVRTC dlls have a name the contains the version number, for example `nvrtc64_102_0.dll`. This will lead to the load of just `nvrtc` to fail. One approach to fix this is to place the NVRTC dll and associated files in the same directory as slang.dll, and rename the main dll to `nvrtc.dll`. Another approach is to specify directly on the command line the name including the version, as previously discussed. For example  

`-nvrtc-path nvrtc64_102_0` 
 
will load NVRTC 10.2 assuming that version of the dll can be found via the normal lookup mechanism.

On Windows if NVRTC is not loadable directly as 'nvrtc' Slang will attempt to search for the newest version of NVRTC on your system. The places searched are...

* The instance directory (where the slang.dll and/or program exe is)
* The CUDA_PATH enivonment variable (if set)
* Directories in PATH that look like a CUDA installation.

If a candidate is found via an earlier mechanism, subsequent searches are not performed. If multiple candidates are found, Slang tries the newest version first.

Binding 
=======

Say we have some Slang source like the following:

```
struct Thing { int a; int b; }

Texture2D<float> tex;
SamplerState sampler;
RWStructuredBuffer<int> outputBuffer;        
ConstantBuffer<Thing> thing3;        
        
[numthreads(4, 1, 1)]
void computeMain(
    uint3 dispatchThreadID : SV_DispatchThreadID, 
    uniform Thing thing, 
    uniform Thing thing2)
{
   // ...
}
```

This will be turned into a CUDA entry point with 

```
struct UniformEntryPointParams
{
    Thing thing;
    Thing thing2;
};

struct UniformState
{
    CUtexObject tex;                // This is the combination of a texture and a sampler(!)
    SamplerState sampler;           // This variable exists within the layout, but it's value is not used.
    RWStructuredBuffer<int32_t> outputBuffer;    // This is implemented as a template in the CUDA prelude. It's just a pointer, and a size
    Thing* thing3;                  // Constant buffers map to pointers
};   

// [numthreads(4, 1, 1)]
extern "C" __global__  void computeMain(UniformEntryPointParams* params, UniformState* uniformState)
```

With CUDA - the caller specifies how threading is broken up, so `[numthreads]` is available through reflection, and in a comment in output source code but does not produce varying code. 

The UniformState and UniformEntryPointParams struct typically vary by shader. UniformState holds 'normal' bindings, whereas UniformEntryPointParams hold the uniform entry point parameters. Where specific bindings or parameters are located can be determined by reflection. The structures for the example above would be something like the following... 

`StructuredBuffer<T>`,`RWStructuredBuffer<T>` become

```
    T* data;
    size_t count;
```    

`ByteAddressBuffer`, `RWByteAddressBuffer` become 

```
    uint32_t* data;
    size_t sizeInBytes;
```  

## Texture

Read only textures will be bound as the opaque CUDA type CUtexObject. This type is the combination of both a texture AND a sampler. This is somewhat different from HLSL, where there can be separate `SamplerState` variables. This allows access of a single texture binding with different types of sampling. 

If code relys on this behavior it will be necessary to bind multiple CtexObjects with different sampler settings, accessing the same texture data. 

Slang has some preliminary support for TextureSampler type - a combined Texture and SamplerState. To write Slang code that can target CUDA and other platforms using this mechanism will expose the semantics appropriately within the source.  
 
Load is only supported for Texture1D, and the mip map selection argument is ignored. This is because there is tex1Dfetch and no higher dimensional equivalents. CUDA also only allows such access if the backing array is linear memory - meaning the bound texture cannot have mip maps - thus making the mip map parameter superflous anyway. RWTexture does allow Load on other texture types.  
 
## RWTexture 
 
RWTexture types are converted into CUsurfObject type. 

In regular CUDA it is not possible to do a format conversion on an access to a CUsurfObject. Slang does add support for hardware write conversions where they are available. To enable the feature it is necessary to attribute your RWTexture with `format`. For example

```
[format("rg16f")]
RWTexture2D<float2> rwt2D_2;
```

The format names used are the same as for (GLSL layout format types)[https://www.khronos.org/opengl/wiki/Layout_Qualifier_(GLSL)]. If no format is specified Slang will *assume* that the format is the same as the type specified. 

Note that the format attribution is on variables/paramters/fields and not part of the type system. This means that if you have a scenario like...

```
[format(rg16f)]
RWTexture2d<float2> g_texture;

float2 getValue(RWTexture2D<float2> t)
{
    return t[int2(0, 0];
}

void doThing()
{
    float2 v = getValue(g_texture);
}
```

Even `getValue` will receive t *without* the format attribute, and so will access it, presumably erroneously. A work around for this specific scenario would be to attribute the parameter

```
float2 getValue([format("rg16f")] RWTexture2D<float2> t)
{
    return t[int2(0, 0];
}
```

This will only work correctly if `getValue` is called with a `t` that has that format attribute. As it stands no checking is performed on this matching so no error or warning will be produced if there is a mismatch. 

There is limited software support for doing a conversion on reading. Currently this only supports only 1D, 2D, 3D RWTexture, backed with half1, half2 or half4. For this path to work NVRTC must have the `cuda_fp16.h` and associated files available. Please check the section on `Half Support`.

If hardware read conversions are desired, this can be achieved by having a Texture<T> that uses the surface of a RWTexture<T>. Using the Texture<T> not only allows hardware conversion but also filtering. 

It is also worth noting that CUsurfObjects in CUDA are NOT allowed to have mip maps. 

By default surface access uses cudaBoundaryModeZero, this can be replaced using the macro SLANG_CUDA_BOUNDARY_MODE in the CUDA prelude. For HW format conversions the macro SLANG_PTX_BOUNDARY_MODE. These boundary settings are in effect global for the whole of the kernel. 

`SLANG_CUDA_BOUNDARY_MODE` can be one of

* cudaBoundaryModeZero      causes an execution trap on out-of-bounds addresses
* cudaBoundaryModeClamp     stores data at the nearest surface location (sized appropriately)
* cudaBoundaryModeTrap      drops stores to out-of-bounds addresses 

`SLANG_PTX_BOUNDARY_MODE` can be one of `trap`, `clamp` or `zero`. In general it is recommended to have both set to the same type of value, for example `cudaBoundaryModeZero` and `zero`.

## Sampler

Samplers are in effect ignored in CUDA output. Currently we do output a variable `SamplerState`, but this value is never accessed within the kernel and so can be ignored. More discussion on this behavior is in `Texture` section.

## Unsized arrays

Unsized arrays can be used, which are indicated by an array with no size as in `[]`. For example 

```
    RWStructuredBuffer<int> arrayOfArrays[];
```

With normal 'sized' arrays, the elements are just stored contiguously within wherever they are defined. With an unsized array they map to `Array<T>` which is...

```
    T* data;
    size_t count;
```    

Note that there is no method in the shader source to get the `count`, even though on the CUDA target it is stored and easily available. This is because of the behavior on GPU targets 

* That the count has to be stored elsewhere (unlike with CUDA) 
* On some GPU targets there is no bounds checking - accessing outside the bound values can cause *undefined behavior*
* The elements may be laid out *contiguously* on GPU

In practice this means if you want to access the `count` in shader code it will need to be passed by another mechanism - such as within a constant buffer. It is possible in the future support may be added to allow direct access of `count` work across targets transparently. 

## Prelude

For CUDA the code to support the code generated by Slang is partly defined within the 'prelude'. The prelude is inserted text placed before the generated CUDA source code. For the Slang command line tools as well as the test infrastructure, the prelude functionality is achieved through a `#include` in the prelude text of the `prelude/slang-cuda-prelude.h` specified with an absolute path. Doing so means other files the `slang-cuda-prelude.h` might need can be specified relatively, and include paths for the backend compiler do not need to be modified. 

The prelude needs to define 

* 'Built in' types (vector, matrix, 'object'-like Texture, SamplerState etc) 
* Scalar intrinsic function implementations
* Compiler based definations/tweaks 

For a client application - as long as the requirements of the generated code are met, the prelude can be implemented by whatever mechanism is appropriate for the client. For example the implementation could be replaced with another implementation, or the prelude could contain all of the required text for compilation. Setting the prelude text can be achieved with the method on the global session...

```
/** Set the 'prelude' for generated code for a 'downstream compiler'.
@param passThrough The downstream compiler for generated code that will have the prelude applied to it. 
@param preludeText The text added pre-pended verbatim before the generated source

That for pass-through usage, prelude is not pre-pended, preludes are for code generation only. 
*/

void setDownstreamCompilerPrelude(SlangPassThrough passThrough, const char* preludeText);
```

The code that sets up the prelude for the test infrastucture and command line usage can be found in ```TestToolUtil::setSessionDefaultPrelude```. Essentially this determines what the absolute path is to `slang-cpp-prelude.h` is and then just makes the prelude `#include "the absolute path"`.

Half Support
============

Slang supports the half/float16 types on CUDA. To do so NVRTC must have access to the `cuda_fp16.h` and `cuda_fp16.hpp` files that are typically distributed as part of the CUDA SDK. When Slang detects the use of half in source, it will define `SLANG_CUDA_ENABLE_HALF` when `slang-cuda-prelude.h` is included. This will in turn try to include `cuda_fp16.h` and enable extra functionality within the prelude for half support. 

Slang tries several mechanisms to locate `cuda_fp16.h` when NVRTC is initiated. The first mechanism is to look in the include paths that are passed to Slang. If `cuda_fp16.h` can be found in one of these paths, no more searching will be performed. 

If this fails, the path where NVRTC is located will be searched. In that path "include" and "CUDA/include" paths will be searched. This is probably most suitable for Windows based targets, where NVRTC dll is placed along with other binaries. The "CUDA/include" path is used to try and make clear in this scenario what the contained files are for. 

If this fails Slang will look for the CUDA_PATH environmental variable, as is typically set during a CUDA SDK installation. 

If this fails - the prelude include of `cuda_fp16.h` will most likely fail on NVRTC invocation.

CUDA has the `__half` and `__half2` types defined in `cuda_fp16.h`. The `__half2` can produce results just as quickly as doing the same operation on `__half` - in essence for some operations `__half2` is [SIMD](https://en.wikipedia.org/wiki/SIMD) like. The half implementation in Slang tries to take advantage of this optimization. 

Since Slang supports up to 4 wide vectors Slang has to build on CUDAs half support. The types _`_half3` and `__half4` are implemented in `slang-cuda-prelude.h` for this reason. It is worth noting that `__half3` is made up of a `__half2` and a `__half`. As `__half2` is 4 byte aligned, this means `__half3` is actually 8 bytes, rather than 6 bytes that might be expected.

One area where this optimization isn't fully used is in comparisons - as in effect Slang treats all the vector/matrix half comparisons as if they are scalar. This could be perhaps be improved on in the future. Doing so would require using features that are not directly available in the CUDA headers. 

Wave Intrinsics
===============

There is broad support for [HLSL Wave intrinsics](https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/hlsl-shader-model-6-0-features-for-direct3d-12), including support for [SM 6.5 intrinsics](https://microsoft.github.io/DirectX-Specs/d3d/HLSL_ShaderModel6_5.html). 

Most Wave intrinsics will work with vector, matrix or scalar types of typical built in types - uint, int, float, double, uint64_t, int64_t.  

The support is provided via both the Slang stdlib as well as the Slang CUDA prelude found in 'prelude/slang-cuda-prelude.h'. Many Wave intrinsics are not directly applicable within CUDA which supplies a more low level mechanisms. The implementation of most Wave functions work most optimally if a 'Wave' where all lanes are used. If all lanes from index 0 to pow2(n) -1  are used (which is also true if all lanes are used) a binary reduction is typically applied. If this is not the case the implementation fallsback on a slow path which is linear in the number of active lanes, and so is typically significantly less performant. 

For more a more concrete example take 

```
int sum = WaveActiveSum(...);
```

When computing the sum, if all lanes (32 on CUDA), the computation will require 5 steps to complete (2^5 = 32). If say just one lane is not being used it will take 31 steps to complete (because it is now linear in amount of lanes). So just having one lane disabled required 6 times as many steps. If lanes with 0 - 15 are active, it will take 4 steps to complete (2^4 = 16). 

In the future it may be possible to improve on the performance of the 'slow' path, however it will always remain the most efficient generally for all of 0 to pow2(n) - 1 lanes to be active. 

It is also worth noting that lane communicating intrinsics performance will be impacted by the 'size' of the data communicated. The size here is at a minimum the amount of built in scalar types used in the processing. The CUDA language only allows direct communication with built in scalar types. 

Thus 

```
int3 v = ...;
int3 sum = WaveActiveSum(v);
```

Will require 3 times as many steps as the earlier scalar example just using a single int. 

## WaveGetLaneIndex

'WaveGetLaneIndex' defaults to `(threadIdx.x & SLANG_CUDA_WARP_MASK)`. Depending on how the kernel is launched this could be incorrect. There other ways to get lane index, for example using inline assembly. This mechanism though is apparently slower than the simple method used here. There is support for using the asm mechnism in the CUDA prelude using the `SLANG_USE_ASM_LANE_ID` preprocessor define to enable the feature. 

There is potential to calculate the lane id using the [numthreads] markup in Slang/HLSL, but that also requires some assumptions of how that maps to a lane index. 

## Unsupported Intrinsics

* Intrinsics which only work in pixel shaders
  + QuadXXXX intrinsics
  
Limitations
===========

Some features are not available because they cannot be mapped with appropriate behavior to a target. Other features are unavailable because of resources to devote to more unusual features. 

* Not all Wave intrinsics are supported
* There is not complete support for all methods on 'objects' like textures etc. 
* Does not currently support combined 'TextureSampler'. A Texture behaves equivalently to a TextureSampler and Samplers are ignored.
* Half type is not currently supported
* GetDimensions is not available on any Texture type currently - as there doesn't appear to be a CUDA equivalent 

Language aspects
================

# Arrays passed by Value

Slang follows the HLSL convention that arrays are passed by value. This is in contrast with CUDA where arrays follow C++ conventions and are passed by reference. To make generated CUDA follow this convention an array is turned into a 'FixedArray' struct type. 

To get something more similar to CUDA/C++ operation the array can be marked in out or inout to make it passed by reference. 


================================================
FILE: Source/External/slang/docs/doc-system.md
================================================
Slang Doc System 
================

Slang contains a rudimentary documentation generation system. The mechanism used to mark up source is similar to [doxygen](https://www.doxygen.nl/manual/docblocks.html). Namely

```
/**
 ... text ... (JavaDoc style)
 */
void someFunctionA() {} 
 
/*!
 .. text .. (QT style)
 another line
 */ 
void someFunctionB() {} 
 
/// ... text ... (Multi line)
/// another line
void someFunctionC() {}
 
//!... text ...  (QT Multi line)
//! another line
void someFunctionD() {}
 
```
 
All of the above examples will add the documentation for the declaration that appears after them. Also note that this slightly diverges from doxygen in that an empty line before and after in a multi line comment is *not* required.

We can also document the parameters to a function similarly

```
/// My function
void myFunction(
    /// The A parameter 
    int a, 
    /// The B parameter
    int b);
```

If you just need a single line comment to describe something, you can place the documentation after the parameter as in

```

/// My function
void myFunction(    int a,      //< The A parameter     
                    int b)      //< The B parameter
{}
```

This same mechanisms work for other kinds of common situations such as with enums 

```
/// An enum
enum AnEnum
{
    Value, ///< A value
    /// Another value
    /// With a multi-line comment
    AnotherValue,
};
```

Like `doxygen` we can also have multi line comments after a declaration for example

```
/// An enum
enum AnEnum
{
    Value, ///< A value
           ///< Some more information about `Value`
           
    /// Another value
    /// With a multi-line comment
    AnotherValue,
};
```




To actually get Slang to output documentation you can use the `-doc` option from the `slangc` command line, or pass it in as parameter to `spProcessCommandLineArguments` or `processCommandLineArguments`. The documentation is currently output by default to the same `ISlangWriter` stream as diagnostics. So for `slangc` this will generally mean the terminal/stderr. 

Currently the Slang doc system does not support any of the 'advanced' doxygen documentation features. If you add documentation to a declaration it is expected to be in [markdown](https://guides.github.com/features/mastering-markdown/). 

Currently the only documentation style supported is a single file 'markdown' output. Future versions will support splitting into multiple files and linking between them. Also future versions may also support other documentation formats/standards.

It is possible to generate documentation for Slangs internal `stdlib`. This can be achieved with `slangc` via

```
slangc -doc -compile-stdlib
```

The documentation will be written to a file `stdlib-doc.md`.

It should be noted that it is not necessary to add markup to a declaration for the documentation system to output documentation for it. Without the markup the documentation is going to be very limited, in essence saying the declaration exists and other aspects that are available from the source. This may not be very helpful. For this reason and other reasons there is a mechanism to control the visibility of items in your source. 

There are 3 visibility levels 'public', 'internal' and 'hidden'/'private'. There is a special comment that controls visibility for subsequent lines. The special comment starts with `//@` as shown below.

```
//@ public:

void thisFunctionAppearsInDocs() {}

//@ internal:

void thisFunctionCouldAppearInInternalDocs() {}

//@ hidden:

void thisFunctionWillNotAppearInDocs() {}
```




================================================
FILE: Source/External/slang/docs/faq.md
================================================
Frequently Asked Questions
==========================

### How did this project start?

The Slang project forked off from the ["Spire"](https://github.com/spire-lang/spire) shading language research project.
In particular, Slang aims to take the lessons learned in that research effort (about how to make more productive shader compilation languages and tools) and apply them to a stystem that is easier to adopt, and hopefully moreamenable to production use.

### Why should I use Slang instead of glslang, hlsl2glslfork, the Microsoft open-source HLSL compiler, etc.?

If you are mostly just shoping around for a tool to get HLSL shaders working on other graphics APIs, then [this](http://aras-p.info/blog/2014/03/28/cross-platform-shaders-in-2014/) blog post is probably a good place to start.

If one of those tools meets your requirements, then you should probably use it.
Slang is a small project, and early in development, so you might find that you hit fewer bumps in the road with one of the more established tools out there.

The goal of the Slang project is not to make "yet another HLSL-to-GLSL translator," but rather to create a shading language and supporting toolchain that improves developer productivity (and happiness) over the existing HLSL language and toolchain, while providing a reasonable adoption path for developers who have an existing investment in HLSL shader code.
If you think that is something interesting and worth supporting, then please get involved!

### What would make a shading language more productive?

This is probably best answered by pointing to the most recent publication from the Spire research project:

[Shader Components: Modular and High Performance Shader Development](http://graphics.cs.cmu.edu/projects/shadercomp/)

Some other papers for those who would like to read up on our inspiration:

[A System for Rapid Exploration of Shader Optimization Choices](http://graphics.cs.cmu.edu/projects/spire/)
[Spark: Modular, Composable Shaders for Graphics Hardware](https://graphics.stanford.edu/papers/spark/)

### Who is using Slang?

Right now the only user of Slang is the [Falcor](https://github.com/NVIDIA/Falcor) real-time rendering framework developed and used by NVIDIA Research.
The implementation of Slang has so far focused heavily on the needs of Falcor.

### Won't we all just be using C/C++ for shaders soon?

The great thing about both Vulkan and D3D12 moving to publicly-documented binary intermediate langugaes (SPIR-V and DXIL, respectively) is that there is plenty of room for language innovation on top of these interfaces.

Having support for writing GPU shaders in a reasonably-complete C/C++ language would be great.
We are supportive of efforts in the "C++ for shaders" direction.

The Slang effort is about trying to solve the challenges that are unique to the real-time graphics domain, and that won't magically get better by switching to C++.


================================================
FILE: Source/External/slang/docs/language-guide.md
================================================
Slang Language Guide
====================

This document will try to describe the main characteristis of the Slang language that might make it different from other shading languages you have used.

The Basics
----------

Slang is similar to HLSL, and it is expected that many HLSL programs can be used as Slang code with no modifications.
Big-picture stuff that is supported:

* A C-style preprocessor
* Ordinary function, `struct`, `typedef`, etc. declarations
* The standard vector/matrix types like `float3` and `float4x4`
* The less-used explicit `vector<T,N>` and `matrix<T,R,C>` types
* `cbuffer` declarations for uniform parameters
* Global-scope declarations of texture/sampler parameters, including with `register` annotations
* Entry points with varying `in`/`out` parameters using semantics (including `SV_*` system-value semantics)
* The built-in templated resource types like `Texture2D<T>` with their object-oriented syntax for sampling operations
* Attributes like `[unroll]` are parsed, and passed along for HLSL/DXBC output, but dropped for other targets
* `struct` types that contain textures/samplers as well as ordinary uniform data, both as function parameters and in constant buffers
* The built-in functions up through Shader Model 6.0 (as documented on MSDN) are supported

New Features
------------

### Import Declarations

In order to support better software modularity, and also to deal with the issue of how to integrate shader libraries written in Slang into other langauges, Slang introduces an `import` declaration construct.

The basic idea is that if you write a file `foo.slang` like this:

```hlsl
// foo.slang

float4 someFunc(float4 x) { return x; }
```

you can then import this code into another file in Slang, HLSL, or GLSL:

```hlsl
// bar.slang

import foo;

float4 someOtherFunc(float4 y) { return someFunc(y); }
```

The simplest way to think of it is that the `import foo` declaration instructs the compiler to look for `foo.slang` (in the same search paths it uses for `#include` files), and give an error if it isn't found.
If `foo.slang` is found, then the compiler will go ahead and parse and type-check that file, and make any declarations there visible to the original file (`bar.glsl` in this example).

When it comes time to generate output code, Slang will output any declarations from `import`ed files that were actually used (it skips those that are never referenced), and it will cross-compile them as needed for the chosen target.

A few other details worth knowing about `import` declarations:

* The name you use on the `import` line gets translated into a file name with some very simple rules. An underscore (`_`) in the name turns into a dash (`-`) in the file name, and dot separators (`.`) turn into directory seprators (`/`). After these substitutions, `.slang` is added to the end of the name.

* If there are multiple `import` declarations naming the same file, it will only be imported once. This is also true for nested imports.

* Currently importing does not imply any kind of namespacing; all global declarations still occupy a single namespace, and collisions between different imported files (or between a file and the code it imports) are possible. This is a bug.

* If file `A.slang` imports `B.slang`, and then some other file does `import A;`, then only the names from `A.slang` are brought into scope, not those from `B.slang`. This behavior can be controlled by having `A.slang` use `__exported import B;` to also re-export the declarations it imports from `B`.

* An import is *not* like a `#include`, and so the file that does the `import` can't see preprocessor macros defined in the imported file (and vice versa). Think of `import foo;` as closer to `using namspace foo;` in C++ (perhaps without the same baggage).

### Explicit Parameter Blocks

One of the most important new features of modern APIs like Direct3D 12 and Vulkan is an interface for providing shader parameters using efficient *parameter blocks* that can be stored in GPU memory (these are implemented as descritpor tables/sets in D3D12/Vulkan, and "attribute buffers" in Metal).
However, HLSL and GLSL don't support explicit syntax for parmaeter blocks, and so shader programmers are left to manually pack parameters into blocks either using `register`/`layout` modifiers, or with API-based remapping (in the D3D12 case).

Slang supports a simple and explicit syntax for exploiting parameter blocks:

```hlsl
struct ViewParams
{
	float3 cameraPos;
	float4x4 viewProj;
	TextureCube envMap;
};

ParameterBlock<ViewParams> gViewParams;
```

In this example, the fields of `gViewParams` will be assigned to registers/bindings in a way that supports allocating them into a single parameter block.
For example, when generating GLSL for Vulkan, the Slang compiler will generate a single `uniform` block (for `cameraPos` and `viewProj`) and a global `textureCube` for `envMap`, both decorated with the same `layout(set = ...)`.


### Interfaces

Slang supports declaring `interface`s that user-defined `struct` types can implement.
For example, here is a simple interface for light sources:

```hlsl
// light.slang

struct LightSample { float3 intensity; float3 direction; };

interface ILight
{
	LightSample sample(float3 position);
}
```

We can now define a simple user type that "conforms to" (implements) the `ILight` interface:

```hlsl
// point-light.slang

import light;

struct PointLight : ILight
{
	float3 position;
	float3 intensity;

	LightSample sample(float3 hitPos)
	{
		float3 delta = hitPos - position;
		float distance = length(delta);

		LightSample sample;
		sample.direction = delta / distance;
		sample.intensity = intensity * falloff(distance);
		return sample;
	}
}
```

### Generics

Slang supports *generic* declarations, using the commong angle-brack (`<>`) syntax from languages like C#, Java, etc.
For example, here is a generic function that works with any type of light:

```hlsl
// diffuse.slang
import light;

float4 computeDiffuse<L : ILight>( float4 albedo, float3 P, float3 N, L light )
{
	LightSample sample = light.sample(P);
	float nDotL = max(0, dot(N, sample.direction));
	return albedo * nDotL;
}
```

The `computeDiffuse` function works with any type `L` that implements the `ILight` interface.
Unlike with C++ templates, the `computeDiffuse` function can be compiled and type-checked once (you won't suddenly get unexpected error messages when plugging in a new type).

#### Global-Scope Generic Parameters

Putting generic parameter directly on functions is helpful, but in many cases existing HLSL shaders declare their parameters at global scope.
For example, we might have a shader that uses a global declaration of material parameters:

```hlsl
Material gMaterial;
```

In order to allow such a shader to be converted to use a generic parameter for the material type (to allow for specialization), Slang supports declaring type parameters at the global scope:

```hlsl
type_param M : IMaterial;
M gMaterial;
```

Conceptually, you can think of this syntax as wrapping your entire shader program in a generic with parameter `<M : IMaterial>`.
This isn't beautiful syntax, but it may help when incrementally porting an existing HLSL codebase to use Slang's features.

### Associated Types

Sometimes it is difficult to define an interface because each type that implements it might need to make its own choice about some intermediate type.
As a concrete example, suppose we want to define an interface `IMaterial` for material surface shaders, where each material might use its own BRDF.
We want to support evaluating the *pattern* of the surface separate from the reflectance function.

```hlsl
// A reflectance function
interface IBRDF
{
	float3 eval(float3 wi, float3 wo);
}
struct DisneyBRDF : IBRDF { ... };
struct KajiyaKay : IBRDF { ... };

// a surface pattern
interface IMaterial
{
	??? evalPattern(float3 position, float2 uv);
}
```

What is the type `???` that `evalPattern` should return? We know that it needs to be a type that supports `IBRDF`, but *which* type?
One material might want to use `DisneyBRDF` while another wants to use `KajiyaKay`.

The solution in Slang, as in modern languages like Swift and Rust, is to use *associated types* to express the depdence of the BRDF type on the material type:

```hlsl
interface IMaterial
{
	associatedtype B : IBRDF;
	B evalPattern(float3 position, float2 uv);
}

struct MyCoolMaterial : IMaterial
{
	typedef DisneyBRDF B;
	B evalPattern(float3 position, float2 uv)
	{ ... }
}
```

Associated types are an advanced concept, and we only recommend using them when they are needed to define a usable interface.


Future Extensions
-----------------

### Implicit Generics Syntax

The syntax for generics and interfaces in Slang is currently explicit, but verbose:

```hlsl
float4 computeDiffuse<L : ILight>( L light, ... )
{ ... }
```

As a future change, we would like to allow using an interface like `ILight` as an ordinary parameter type:

```hlsl
float4 computeDiffuse( ILight light, ... )
{ ... }
```

This simpler syntax would act like "syntactic sugar" for the existing explicit generics syntax, so it would retain all of the important performance properties.

### Returning a Value of Interface Type

While the above dealt with using an interface as a parameter type, we would eventually like to support using an interface as the *return* type of a function:

```hlsl
ILight getALightSource(Scene scene) { ... }
```

Implementing this case efficiently is more challenging. In most cases, an associated type can be used instead when an interface return type would be desired.


Not Supported
-------------

Some features of the current HLSL language are not supported, but probably will be given enough time/resources:

* Local variables of texture/sampler type (or that contain these)
* Matrix swizzles
* Explicit `packoffset` annotations on members of `cbuffer`s

Some things from HLSL are *not* planned to be supported, unless there is significant outcry from users:

* Pre-D3D10/11 syntax and operations
* The "effect" system, and the related `<>` annotation syntax
* Explicit `register` bindings on textures/samplers nested in `cbuffer`s
* Any further work towards making HLSL a subset of C++ (simply because implementing a full C++ compiler is way out of scope for the Slang project)


================================================
FILE: Source/External/slang/docs/layout.md
================================================
Parameter Layout Rules
======================

An important goal of the Slang project is that the rules for how shader parameters get assigned to `register`s/`binding`s is completely deterministic, so that users can rely on the compiler's behavior.
This document will attempt to explain the rules that Slang employs at a high level.
Eventually it might evolve into a formal specification of the expected behavior.

Guarantees
----------

The whole point of having a deterministic layout approach is the guarantees that it gives to users, so we will start by explicitly stating the guarantees that users can rely upon:

* A single top-level shader parameter will always occupy a contiguous range of bindings/registers for each resource type it consumes (e.g., a contiguous range of `t` registers, a contiguous range of bytes in a `cbuffer`, etc.).

* The amount of resources a parameter consumes depends only on its type, and top-level context in which it appears (e.g., is it in a `cbuffer`? an entry-point varying parameter? etc.).

* A shader parameter that is declared the same way in two different programs will get the same *amount* of resources (registers/bytes) allocated for it in both programs, but it might get a different starting offset/register.

* Changing the bodies of functions in shader code cannot change the layout of shader parameters. In particular, just because a shader parameter is "dead" does not mean it gets eliminated.

* If the user doesn't use explicit `register`/`layout` modifiers to bind parameters, then each module will get a contiguous range of bindings, and the overall program will always use a contiguous range starting from zero for each resource type.

Overview of the Layout Algorithm
--------------------------------

Layout is applied to a Slang *compile request* which comprises one or more *translation units* of user code, and zero or more `import`ed modules.
The compile request also specifies zero or more *entry points* to be compiled, where each entry point identifies a function and a profile to use.

Layout is always done with respect to a chosen *target*, and different targets might compute the resource usage for types differently, or apply different alignment.
Within a single target there may also be different layout rules (e.g., the difference between GLSL `std140` and `std430`).

Layout proceeds in four main phases:

1. Establish a global ordering on shader parameters
2. Compute the resource requirements of each shader parameter
3. Process shader parameters with fixed binding modifiers
4. Allocate bindings to parameter without fixed binding modifiers

Ordering (and Collapsing) Shader Parameters
-------------------------------------------

Shader parameters from the user's code always precede shader parameters from imported modules.
The order of parameters in the user's code is derived by "walking" through the code as follows:

* Walk through each translation unit in the order they were added via API (or the order they were listed on the command line)

* Walk through each source file of a translation unit in the order they were added/listed

* Walk through global-scope shader paramter declarations (global variables, `cbuffer`s, etc.) in the order they are listed in the (preprocessed) file.

* After all global parameters for a translation unit have been walked, walk through any entry points in the translation unit.

* When walking through an entry point, walk through all of its function parameters (both uniforms and varyings) in order, and then walk the function result as a varying output parameter.

When dealing with global-scope parameters in the user's code, it is possible for the "same" parameter to appear in multiple translation units.
Any two global shader parameters in user code with the same name are assumed to represent the same parameter, and will only be included in the global order at the first location where they are seen.
It is an error for the different declarations to have a mismatch in type, or conflicting explicit bindings.

Parameters from `import`ed modules are enumerated after the user code, using the order in which modules were first `import`ed.
The order of parameters within each module is the same as when the module was compiled, which matches the ordering given above.

Computing Resource Requirements
-------------------------------

Each shader parameter computes its resource requirements based on its type, and how it is declared.

* Global-scope parameters, entry point `uniform` parameters, and `cbuffer` decalrations all use the "default" layout rules

* Entry point non-`uniform` parameters use "varying" layout rules, either input or output

* A few other special case rules exist (e.g., for laying out the elements of a `StructuredBuffer`), but most users will not need to worry about these

Note that the "default" rules are different for D3D and GL/Vulkan targets, because they have slightly different packing behavior.

### Plain Old Data

Under the default rules simple scalar types (`bool`, `int`, `float`, etc.) are laid out as "uniform" data (that is, bytes of ordinary memory).
In most cases, the size matches the expected data type size (although be aware that most targets treat `bool` as a synonym for `int`) and the alignment is the same as the size.

### Vectors

Vectors are laid out as N sequential scalars.
Under HLSL rules, a vector has the same alignment as its scalar type.
Under GLSL `std140` rules, a vector has an alignment that is its size rounded up to the next power of two (so a `float3` has `float4` alignment).

### Opaque Types

"Opaque" types include resource/sampler types like `Texture2D` and `SamplerState`.
These consume a single "slot" of the appropriate category for the chosen API.

Note that when compiling for D3D, a `Texture2D` and a `SamplerState` will consume different resources (`t` and `s` registers, respectively), but when compiling for Vulkan, they both consume the same resource ("descriptor table slot").

Opaque types currently all have an alignment of one.

### Structures

A structure is laid out by initializing a counter for each resource type, and then processing fields sequential (in declaration order):

* Compute resource usage for the field's type

* Adjust counters based on the alignment of the field for each resource type where it has non-zero usage

* Assign an offset to the field for each resource type where it has non-zero usage

* Add the resource usage of the field to the counters


An important wrinkle is that when doing layout for HLSL, we must ensure that if a field with uniform data that is smaller than 16 bytes would straddle a 16-byte boundary, we advance to the next 16-byte aligned offset.

The overall alignment of a `struct` is the maximum alignment of its fields or the default alignment (if it is larger).
The default alignment is 16 for both D3D and Vulkan targets.

The final resource usage of a `struct` is rounded up to a multiple of the alignment for each resource type. Note that we allow a `struct` to consume zero bytes of uniform storage.

It is important to note that a `struct` type can use resources of many different kinds, so in general we cannot talk about the "size" of a type, but only its size for a particular kind of resource (uniform bytes, texture registers, etc.).

### Sized Arrays

For uniform data, the size of the element type is rounded up to the target-specific minimum (e.g., 16 for D3D and Vulkan constant buffers) to arrive at the *stride* of the array. The total size of the array is then the stride times the element count.

For opaque resource types, the D3D case simply takes the stride to be the number of registers consumed by each element, and multiplies this by the element count.

For Vulkan, an array of resources uses only a single `binding`, so that the stride is always zero for these resource kinds, and the resource usage of an array is the same as its element type.

### Unsized Arrays

The uniform part of an unsized array has the same stride as for the sized case, but an effectively infinite size.

For register/binding resource usage, a Vulkan unsized array is just like a sized one, while a D3D array will consume a full register *space* instead of individual registers.

### Constant Buffers

To determine the resource usage of a constant buffer (either a `cbuffer { ... }` declaration or a `ConstantBuffer<T>`) we look at the resource usage of its element type.

If the element uses any uniform data, the constant buffer will use at least one constant-buffer register (or whatever the target-specific resource is).
If the element uses any non-uniform data, that usage will be added to that of the constant buffer.

### Parameter Blocks

A parameter block is similar to a constant buffer.
If the element type uses any uniform data, we compute resource usage for a constant buffer.
We then add in any non-uniform resource usage for the element types.

If the target requires use of register spaces (e.g., for Vulkan), then a parameter block uses a single register space; otherwise it exposes the resource usage of its element type directly.

Processing Explicit Binding Modifiers
-------------------------------------

If the user put an explicit binding modifier on a parameter, and that modifier applies to the current target, then we use it and "reserve" space in the overall binding range.

Traditional HLSL `register` modifiers only apply for D3D targets.
Slang currently allows GLSL-style `layout(binding =...)` modifiers to be attached to shader parameters, and will use those modifiers for GL/Vulkan targets.

If two parameters reserve overlapping ranges, we currently issue an error.
This may be downgraded to a warning for targets that support overlapping ranges.

Allocating Bindings to Parameters
---------------------------------

Once ranges have been reserved for parameters with explicit bindings, the compiler goes through all parameters again, in the global order and assigns them bindings based on their resource requirements.

For each resource type used by a parameter, it is allocated the first contiguous range of resources of that type that have not been reserved.

Splitting of Arrays
-------------------

In order to support `struct` types that mix uniform and non-uniform data, the Slang compiler always "splits" these types.
For example, given:

```hlsl
struct LightInfo { float3 pos; Texture2D shadowMap; };

LightInfo gLight;
```

Slang will generate code like:

```hlsl
float3 gLight_pos;
Texture2D gLight_shadowMap;
```

In a simple case like the above, this doesn't affect layout at all, but once arrays get involved, the layout can be more complicated. Consider this case:

```hlsl
struct Pair { Texture2D a; Texture2D b; };
Pair gPairs[8];
```

The output from the splitting step is equivalent to:

```hlsl
Texture2D gPairs_a[8];
Texture2D gPairs_b[8];
```

While this transformation is critical for having a type layout algorithm that applies across all APIs (and also it is pretty much required to work around various bugs in downstream compilers), it has the important down-side that the value `gPairs[0]` does not occupy a contiguous range of registers (although the top-level shader parameter `gPairs` *does*).

The Slang reflection API will correctly report the information about this situation:

* The "stride" of the `gPairs` array will be reported as one, because `gPairs[n+1].a` is always one register after `gPairs[n].a`.

* The offset of the `gPairs.b` field will be reported as 8, because `gPairs[0].b` will be 8 registers after the starting register for `gPairs`.

The Slang API tries to provide the best information it can in this case, but it is still important for users who mix arrays and complex `struct` types to know how the compiler will lay them out.

Generics
--------

Generic type parameters complicate these layout rules.
For example, we cannot compute the exact resource requirements for a `vector<T,3>` without knowing what the type `T` is.

When computing layouts for fully specialized types or programs, no special considerations are needed: the rules as described in this document still apply.
One important consequence to understand is that given a type like:

```hlsl
struct MyStuff<T>
{
	int a;
	T b;
	int c;
}
```

the offset computed for the `c` field depends on the concrete type that gets plugged in for `T`.
We think this is the least surprising behavior for programmers who might be familiar with things like C++ template specialization.

In cases where confusion about a field like `c` getting different offsets in different specializations is a concern, users are encouraged to declare types so that all non-generic-dependent fields come before generic-dependent ones.


================================================
FILE: Source/External/slang/docs/linking.md
================================================
Slang Linking
=============

The Slang feature around libraries and linking are a *work in progress*. Future versions of Slang are likely to change the API and binary compatibility. Also note that currently reflection is mainly unsupported. 

In many languages it is possible to compile source files into binaries such as libraries and object files. Later these files can be combined perhaps with other source files to produce a result such as an executable. Slang now has experimental support for such a feature. 

To make such a feature work we need a few abilities

* To create a library from source 
* A way for symbols to be exported and imported
* Linkage - ability to combine source/libraries to produce things (such as other libraries, executables, etc)
* A way to specify libraries to be used in linkage


Binding
-------

Due to how the feature currently works, if a library contains any kind of binding (implicit or explicit) it should be considered platform specific. When linking with libraries, the libraries will not supply any reflection, other than minimal entry point information. Any source compiled and linked against does follow normal Slang rules in terms of implicit binding assignments and reflection.  

In practice this means that libraries either have to have no binding or manual binding. If any library has manual binding, this binding must be ensured to not clash with either implict or explicit binding in the source or other linked libraries. It is not guaranteed that Slang or downstream compilers will report binding clashes. 

If platform independent libraries are linked against source compilation then appropriate reflection and normal Slang implicit binding rules apply.

Libraries
---------

A library can be created from source from the Slang command line with the `-o` option naming the output file. The filename currently requires a `slang-lib` or `slang-module` extension. This extension will mean the library will be stored as serialized Slang IR. The option `-no-codegen` is also typically specified because we don't want to generate any *target* code, such as dxil, spir-v and so forth when producing a library, just the Slang IR. 

For example

```
slangc -no-codegen tests/serialization/extern/module-a.slang -o tests/serialization/extern/module-a.slang-lib
```

From the slang API we need to indicate the container format and to disable target code generation 

```
    SlangCompileRequest* compileRequest = ...;
    SlangCompileFlags slangCompileFlags = ...;
    
    slangCompileFlags |= SLANG_COMPILE_FLAG_NO_CODEGEN;

    spSetOutputContainerFormat(compileRequest, SLANG_CONTAINER_FORMAT_SLANG_MODULE);
```

When the compilation is completed the resulting serialized IR code can be accessed via 

```
// To get the contents as a blob - whose scope can be maintained by the application

    {
        ComPtr<ISlangBlob> blob;
        if (SLANG_SUCCEEDED(spGetContainerCode(compileRequest, blob.writeRef())))
        {
            // Do something with the blob
        }
    }

    // To directly get the contents, will only remain valid as long as compileRequest stays in scope
    // and without subsequent calls to spCompile on the request
    {
        size_t size;
        const void* data = spGetCompileRequestCode(compileRequest, size);
    }
```

Libraries can contain entry points. It is necessary though that the entry point is specified during the compilation producing the library. This can be achieved by specifying a function as an entry point via the API or command line through the normal mechanisms. 

Entry points can also be specified in source via the `[shader()]` attribute. For example

```
[shader("compute")]
void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
{
    // ... 
}
```

Slang libraries are stored as serialized Slang IR. That Slang IR currently maintains no forward or backward compatibility, and a new version of Slang may either produce incompatible IR, or be unable to consume previous versions IR.

By default Slang stores serialized Slang IR in a compressed `lite` format. It can also be stored without any addition compression. These options can be specified via the command line via

```
-ir-compression lite
-ir-compression none
```

They are also available via the API through the `spProcessCommandLineArguments` function. 

Note that Slang can consume and process either `lite` or `none` styles transparently. Also mixing compressed libraries with uncompressed libraries also works. 

Symbols
-------

Linkage is the process of combining of libraries and source to produce something. The mechanism used with Slang, is that items that are going to be imported or exported are named. As the Slang language supports function overloading and generics, it is not possible to just use a function name or a type name to uniquely identify an item. Thus exported and imported names are 'mangled' to include this additional information. This is not unlike how C++ produces mangled names for symbols for similar reasons.

Symbols within a module are additionally uniquely marked with the name of the module, and thus the module name becomes part of the mangled name. This has implications for includes. For example say we have two modules, and they both #include a header file that contains a function. That function will appear as two separate functions - one defined in each module, because a #include is a textual the function will be defined once in each module and with each module name.

By default Slang will provide linkage symbols for all global symbols - types or functions, including declarations. In the future this is likely to change with declarations *not* being exported by default. 

To mark a declaration as having it's definition defined elsewhere outside the current module, the `[__extern]` attribute can be used. For example 

```
[__extern] Thing makeThing(int a, int b);
``` 

With types the `[__extern]` attribute can also be used. For the moment though a type declaration that is externed still needs to be a type definition. Therefore to declare a type to be imported from elsewhere we actually have to write

```
[__extern] struct Thing {};
```

Which looks a little like a definition of `Thing` but because of the `[__extern]` it actually means that `Thing` is defined elsewhere. 

The mechanism for making other symbols available from a library and/or source within Slang is through `import`. Currently though `import` does not support importing of libraries. 

This means that a work around (aka hack) is needed so linkage works with a library. The short term fix, until importing of libraries is available, is to allow overriding of the name of the module - typically so that all symbols appear in the same module name. For example say we have two modules `module-a` and `module-b`, if `module-a` and `module-b` use the same module name they will be able to access one anothers symbols during linkage. 

Specifying the module name can be achieve on the command line with the `-module-name` option as in

```
slangc -module-name somename -no-codegen tests/serialization/extern/module-a.slang -o tests/serialization/extern/module-a.slang-lib
```

From the API the module name can be specified via 

```
spSetDefaultModuleName(compileRequest, "somename");
```

The `[__extern]` attribute and the use of module names, are temporary functionality until more complete support for libraries and linkage is implemented. 

Linkage
-------

The linkage process used in Slang is purposefully fairly straight forwards. When linkage occurs all items with linkage have a identifying mangled name. That for some mangled names there could be multiple definitions - for example a declaration of a function and a definition of that function. If there are multiple definitions, linking aims to determine the one that is 'best' which is then used. A definition is better than a declaration. And a definition that is specific to the current target is taken as better than some other definition. 

If there are multiple identical definitions, or definitions where it cannot be determed if one is better than another then one is taken at effectively random. This therefore assumes that if there are multiple definitions that they are in effect the same. 

If after the linkage process there are declarations that are used, without a definition, then linkage will fail with an unfound symbol.

Specifying Libraries
--------------------
  
When compiling there needs to be a mechanism to specify library or libraries that will be used during linkage. From the command line this can be achieved with the `-r` option. For example...

```
slangc -target dxil -profile sm_6_3 computeMain.slang -entry computeMain -stage compute -r module-a.slang-lib -o linked.dxil
```

Note that multiple `-r` options can be specified on a command line to reference multiple libraries. 

From the API use

```
SLANG_API SlangResult spAddLibraryReference(
    SlangCompileRequest*    request,
    const void* libData,
    size_t libDataSize)
```
    
The libData/libDataSize is the binary data that was was either loaded from a `slang-lib` file or was the result of a compilation of a module and the library contents retrieved via `spGetContainerCode` or `spGetCompileRequestCode`. 

As with -r command line option, multiple libraries can be added to a SlangCompileRequest and all will be searched for relevant symbolds during linking. 

Reflection
----------

In general reflection is *not* available post linkage currently. A subset of functionality is available though including

* spGetReflection
* spReflection_getEntryPointCount
* spReflection_getEntryPointByIndex
* spReflectionEntryPoint_getName

That other reflection functions currently either do not work or may *crash*. 

Other issues
------------

In languages such as C++, if I want to define a struct on the stack I need it's definition

```
struct Thing;

int main()
{
    // Won't compile we need the *definition* not just a declaration
    Thing thing;
    return 0;
}
```

It does not matter that Thing might be defined in another library or object file. For compilation of main, we have to have the definition of Thing. 

In Slang and libraries this is not the case. If I have a file `module-a.slang`
 
```
struct Thing
{
    int a; 
    float b;
};
```

And then I compile another file and include the library that contains Thing I *can* just use the Thing type 

```

// I have to say that Thing is externally defined
[__extern] struct Thing {};

void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
{
    // This is fine in Slang - as long is Thing *is* defined in a referenced library
    Thing thing;
    // ... 
}
```

This is possible because when linkage occurs the code is actually *Slang IR*, and Slang IR contains the information necessary for the use of the Thing type. 

It also worth noting that if the `-obfuscate` feature is used, all libraries and source must also have `-obfuscate` enabled, for linking to work. 


Examples
--------

Examples of compiling of libraries and linking with them can be found within tests/serialization. 

================================================
FILE: Source/External/slang/docs/nvapi-support.md
================================================
NVAPI Support
=============

Slang provides support for [NVAPI](https://developer.nvidia.com/nvapi) in several ways

* Slang allows the use of NVAPI directly, by the inclusion of the `#include "nvHLSLExtns.h"` header in your Slang code. Doing so will make all the NVAPI functions directly available and usable within your Slang source code.
* NVAPI is used to provide features implicitly for certain targets. For example support for [RWByteAddressBuffer atomics](target-compatibility.md) on HLSL based targets is supported currently via NVAPI.
* Direct and implicit NVAPI usage can be freely mixed. 

Direct usage of NVAPI
=====================

Direct usage of NVAPI just requires the inclusion of the appropriate NVAPI header, typically with `#include "nvHLSLExtns.h` within your Slang source. As is required by NVAPI before the `#include` it is necessary to specify the slot and perhaps space usage. For example a typical direct NVAPI usage inside a Slang source file might contain something like...

```
#define NV_SHADER_EXTN_SLOT u0 
#include "nvHLSLExtns.h"
```

In order for the include to work, it is necessary for the include path to include the folder that contains the nvHLSLExtns.h and associated headers.

Implicit usage of NVAPI
=======================

It is convenient and powerful to be able to directly use NVAPI calls, but will only work on such targets that support the mechansism, even if there is a way to support the functionality some other way.

Slang provides some cross platform features on HLSL based targets that are implemented via NVAPI. For example RWByteAddressBuffer atomics are supported on Vulkan, DX12 and CUDA. On DX12 they are made available via NVAPI, whilst CUDA and Vulkan have direct support. When compiling Slang code that uses RWByteAddressBuffer atomics Slang will emit HLSL code that use NVAPI. In order for the downstream compiler to be able to compile this HLSL it must be able to include the NVAPI header `nvHLSLExtns.h`. 

It worth discussing briefly how this mechanism works. Slang has a 'prelude' mechanism for different source targets. The prelude is a piece of text that is inserted before the source that is output from compiling the input Slang source code. There is a default prelude for HLSL that is something like 

```
#ifdef SLANG_HLSL_ENABLE_NVAPI
#include "nvHLSLExtns.h"
#endif
```

If there are any calls to NVAPI implicitly from Slang source, then the following is emitted before the prelude

```
#define SLANG_HLSL_ENABLE_NVAPI 1
#define NV_SHADER_EXTN_SLOT u0
#define NV_SHADER_EXTN_REGISTER_SPACE space0
```

Thus causing the prelude to include nvHLSLExtns.h, and specifying the slot and potentially the space as is required for inclusion of nvHLSLExtns.h.

The actual values for the slot and optionally the space, are found by Slang examining the values of those values at the end of preprocessing input Slang source files. 

This means that if you compile Slang source that has implicit use NVAPI, the slot and optionally the space must be defined. This can be achieved with a command line -D, throught the API or through having suitable `#define`s in the Slang source code.

It is worth noting if you *replace* the default HLSL prelude, and use NVAPI then it will be necessary to have something like the default HLSL prelude part of your custom prelude.

Downstream Compiler Include
---------------------------

There is a subtle detail that is perhaps worth noting here around the downstream compiler and `#include`s. When Slang outputs HLSL it typically does not contain any `#include`, because all of the `#include` in the original source code have been handled by Slang. Slang then outputs everything required to compile to the downstream compiler *without* any `#include`. When NVAPI is used explicitly this is still the case - the NVAPI headers are consumed by Slang, and then Slang will output HLSL that does not contain any `#include`.

The astute reader may have noticed that the default Slang HLSL prelude *does* contain an include, which is enabled via SLANG_HLSL_ENABLE_NVAPI macro which Slang will set with implicit NVAPI use. 

```
#ifdef SLANG_HLSL_ENABLE_NVAPI
#include "nvHLSLExtns.h"
#endif
```

This means that the *downstream* compiler (such as DXC and FXC) must be able to handle this include. Include paths can be specified for downstream compilers via the [-X mechanism](command-line-slangc.md#downstream-arguments). So for example...

```
-Xfxc -IpathTo/nvapi -Xdxc -IpathTo/nvapi
```

In the explicit scenario where `nvHLSLExtns.h` is included in Slang source, the include path must be specified in Slang through the regular mechanisms. 

In a scenario with both implicit and explicit use, both Slang *and* the downstream compiler need to have a suitable path specified. Things can be more complicated if there is mixed implicit/explicit NVAPI usage and in the Slang source the include path is set up such that NVAPI is included with 

```
#include "nvapi/nvHLSLExtns.h"
```

Since Slang and the downstream compilers can specify different include paths, the downstream compiler include path can be such that `#include "nvHLSLExtns.h"` works with the default prelude.

Another way of working around this issue is to alter the prelude for downstream compilers such that it contains an absolute path for the `#include`. This is the mechanism that is currently used with the Slang test infrastructure. 

Links
-----

More details on how this works can be found in the following PR

* [Simplify workflow when using NVAPI #1556](https://github.com/shader-slang/slang/pull/1556)


================================================
FILE: Source/External/slang/docs/repro.md
================================================
Slang Compilation Reproduction
==============================

Slang has both API and command line support for reproducing compilations, so called 'repro' functionality.

One use of the feature is if a compilation fails, or produces an unexpected or wrong result, it provides a simple to use mechanism where the compilation can be repeated or 'reproduced', most often on another machine. Instead of having to describe all the options, and make sure all of the files that are used are copied, and in such a way that it repeats the result, all that is required is for the compilation to be run on the host machine with repro capture enabled, and then that 'repro' used for a compilation on the test machine. There are also some mechanisms where the contents of the orginal compilation can be altered.

The actual data saved is the contents of the SlangCompileReqest. Currently no state is saved from the SlangSession. Saving and loading a SlangCompileRequest into a new SlangCompileRequest should provide two SlangCompileRequests with the same state, and with the second compile request having access to all the files contents the original request had directly in memory. 

There are a few command line options

* `-dump-repro [filename]` dumps the compilations state (ie post attempting to compile) to the file specified afterwards
* `-extract-repro [filename]` extracts the contents of the repro file. The contained files are placed in a directory with a name, the same as the repro file minus the extension. Also contains a 'manifest'.
* `-load-repro [filename]` loads the repro and compiles using it's options. Note this must be the last arg on the command line.
* `-dump-repro-on-error` if a compilation fails will attempt to save a repro (using a filename generated from first source filename)
* `-repro-file-system [filename]` makes the repros file contents appear as the file system during a compilation. Does not set any compilation options.
* `-load-repro-directory [directory]` compiles all of the .slang-repro files found in `directory`

The `manifest` made available via `-extract-repro` provides some very useful information

* Provides an approximation of the command line that will produce the same compilation under [compile-line]
* A list of all the unique files held in the repro [files]. It specified their 'unique name' (as used to identify in the repro) and their unique identifier as used by the file system.
* A list of how paths map to unique files. Listed as the path used to access, followed by the unique name used in the repro

First it is worth just describing what is required to reproduce a compilation. Most straightforwardly the options setup for the compilation need to be stored. This would include any flags, and defines, include paths, entry points, input filenames and so forth. Also needed will be the contents of any files that were specified. This might be files on the file system, but could also be 'files' specified as strings through the slang API. Lastly we need any files that were referenced as part of the compilation - this could be include files, or module source files and so forth. All of this information is bundled up together into a file that can then later be loaded and compiled. This is broadly speaking all of the data that is stored within a repro file. 

In order to capture a complete repro file typically a compilation has to be attempted. The state before compilation can be recorded (through the API for example), but it may not be enough to repeat a compilation, as files referenced by the compilation would not yet have been accessed. The repro feature records all of these accesses and contents of such files such that compilation can either be completed or at least to the same point as was reached on the host machine. 

One of the more subtle issues around reproducing a compilation is around filenames. Using the API, a client can specify source files without names, or multiple files with the same name. If files are loaded via `ISlangFileSystem`, they are typically part of a hiearchical file system. This could mean they are referenced relatively. This means there can be distinct files with the same name but differenciated by directory. The files may not easily be reconstructed back into a similar hieararchical file system - as depending on the include paths (or perhaps other mechanisms) the 'files' and their contents could be arranged in a manner very hard to replicate. To work around this the repro feature does not attempt to replicate a hierarchical file system. Instead it gives every file a unique name based on their original name. If there are multiple files with the same name it will 'uniquify' them by appending an index. Doing so means that the contents of the file system can just be held as a flat collection of files. This is not enough to enable repeating the compilation though, as we now need Slang to know which files to reference when they are requested, as they are now no longer part of a hierarchical file system and their names may have been altered. To achieve this the repro functionality stores off a map of all path requests to their contents (or lack there of). Doing so means that the file system still appears to Slang as it did in the original compilation, even with all the files being actually stored using the simpler 'flat' arrangement. 

This means that when a repro is 'extracted' it does so to a directory which holds the files with their unique 'flat' names. The name of the directory is the name of the repro file without it's extension, or if it has no extension, with the postfix '-files'. This directory will be referered to from now on as the `repro directory`.

When a repro is loaded, before files are loaded from the repro itself, they will first be looked for via their unique names in the `repro directory`. If they are not there the contents of the repro file will be used. If they are there, their contents will be used instead of the contents in the repro. This provides a simple mechanism to be able to alter the source in a repro. The steps more concretely would be...

1) First extract the repro (say with `-extract-repro`)
2) Go to the `repro directory` and edit files that you wish to change. You can also just delete files that do not need changing, as they will be loaded from the repro.
3) Load the repro - it will now load any files requested from the `repro directory`

Now you might want to change the compilation options. Using -load-repro it will compile with the options as given. It is not possible to change those options as part of -load-repro. If you want to change the compilation options (and files), you can use -extract-repro, and look at the manifest which will list a command line that will typically repeat the compilation. Now you can just attach the repro as a file system, and set the command line options as appropriate, based on the command line listed in the manifest. Note! If there is a fairly complex directory hierarchy, it may be necessary to specify the input sources paths *as if* they are held on the original files system. You can see how these map in the manifest. 

Note that currently is is disabled to access any new source files - they will be determined as `not found`. This behaviour could be changed such that the regular file system was used, or the ISlangFilesystem set on the API is used as a fallback. 

There currently isn't a mechanism to alter the options of a repro from the command line (other than altering the contents of the source). The reason for this is because of how command lines are processed currently in Slang. A future update could enable specifying a repro and then altering the command line options used. It can be achieved through the API though. Once the repro is loaded via the `spLoadRepro` function, options can be changed as normal. The two major places where option alteration may have surprising behavior are... 

1) Altering the include paths - unless this may break the mechanism used to map paths to files stored in the repro file
2) Altering the ISlangFileSystem. That to make the contents of the file system appear to be that of the repro, slang uses a ISlangFileSystemExt that uses the contents of the repro file and/or the `repro directory`. If you replace the file system this mechanism will no longer work. 

There are currently several API calls for using the repro functionality 

```
SLANG_API SlangResult spEnableReproCapture(
        SlangCompileRequest* request);
    
SLANG_API SlangResult spLoadRepro(
        SlangCompileRequest* request,
        ISlangFileSystem* fileSystem,
        const void* data,
        size_t size);

SLANG_API SlangResult spSaveRepro(
        SlangCompileRequest* request,
        ISlangBlob** outBlob
    );
    
SLANG_API SlangResult spExtractRepro(
    SlangSession* session, 
    const void* reproData, 
    size_t reproDataSize, 
    ISlangFileSystemExt* fileSystem);    

SLANG_API SlangResult spLoadReproAsFileSystem(
    SlangSession* session,
    const void* reproData,
    size_t reproDataSize,
    ISlangFileSystem* replaceFileSystem,
    ISlangFileSystemExt** outFileSystem);
   
```

The fileSystem parameter passed to `spLoadRepro` provides the mechanism for client code to replace the files that are held within the repro. NOTE! That the files will be loaded from this file system with their `unique names` as if they are part of the flat file system. If an attempt to load a file fails, the file within the repro is used. That `spLoadRepro` is typically performed on a new 'unused' SlangCompileRequest. After a call to `spLoadRepro` normal functions to alter the state of the SlangCompileRequest are available. 

The function `spEnableReproCapture` should be set after any ISlangFileSystem has been set (if any), but before any compilation. It ensures that everything that the ISlangFileSystem accesses will be correctly recorded. Note that if a ISlangFileSystem/ISlangFileSystemExt isn't explicitly set (ie the default is used), then a request will automatically be set up to record everything appropriate and a call to this function isn't strictly required.  
    
The function `spExtractRepro` allows for extracting the files used in a request (along with the associated manifest). They files and manifest are stored under the 'unique names' in the root of the user provided ISlangFileSystemExt.     
    
The function `spLoadReproAsFileSystem` creates a file system that can access the contents of the repro with the same paths that were used on the originating system. The ISlangFileSystemExt produced can be set on a request and used for compilation.    
    
Repro files are currently stored in a binary format. This format is sensitive to changes in the API, as well as internal state within a SlangCompileRequest. This means that the functionality can only be guarenteed to work with exactly the same version of Slang on the same version of compiler. In practice things are typically not so draconian, and future versions will aim to provide a more clear slang repro versioning system, and work will be performed to make more generally usable. 

Finally this version of the repo system does not take into account endianess at all. The system the repro is saved from must have the same endianess as the system loaded on.


================================================
FILE: Source/External/slang/docs/shader-playground.md
================================================
Using Slang on Shader Playground
================================

A fast and simple way to try out Slang is by using the [Shader Playground](http://shader-playground.timjones.io/) website. This site allows easy and interactive testing of shader code across several compilers including Slang without having to install anything on your local machine.

Using the Slang compiler is as simple as selecting 'Slang' from the box in the top left corner from the [Shader Playground](http://shader-playground.timjones.io/). This selects the Slang language for input, and the Slang compiler for compilation. The output of the compilation is shown in the right hand panel.

The default 'Output format' is HLSL. For graphics shaders the 'Output format' can be changed to

* DXIL 
* SPIR-V
* DXBC
* HLSL
* GLSL

Additionally for compute based shaders it can be set to

* C++
* CUDA
* PTX

For binary formats (such as DXIL/SPIR-V/DXBC) the output will be displayed as the applicable disassembly.

Note that C++ and CUDA output include a 'prelude'. The prelude remains the same across compilations, with the code generated for the input Slang source placed at the very end of the output. 



================================================
FILE: Source/External/slang/docs/stdlib-doc.md
================================================
--------------------------------------------------------------------------------
# `__BuiltinArithmeticType.init`

## Signature 

```
__BuiltinArithmeticType.init(int value);
```

## Parameters

* `value`

--------------------------------------------------------------------------------
# `__BuiltinFloatingPointType.init`

## Signature 

```
__BuiltinFloatingPointType.init(float value);
```

## Parameters

* `value`

--------------------------------------------------------------------------------
# `__BuiltinFloatingPointType.getPi`

## Description

Get the value of the mathematical constant pi in this type.

## Signature 

```
__BuiltinFloatingPointType.This __BuiltinFloatingPointType.getPi();
```

--------------------------------------------------------------------------------
# `struct ConstantBuffer<T>`

## Generic Parameters

* `T`

--------------------------------------------------------------------------------
# `struct TextureBuffer<T>`

## Generic Parameters

* `T`

--------------------------------------------------------------------------------
# `struct ParameterBlock<T>`

## Generic Parameters

* `T`

--------------------------------------------------------------------------------
# `struct SamplerState`

## Description

Sampling state for filtered texture fetches.

--------------------------------------------------------------------------------
# `struct SamplerComparisonState`

## Description

Sampling state for filtered texture fetches that include a comparison operation before filtering.

--------------------------------------------------------------------------------
# `struct Texture1D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Texture1D<T>.CalculateLevelOfDetail`

## Signature 

```
float Texture1D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture1D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Texture1D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture1D<T>.GetDimensions`

## Signature 

```
void Texture1D<T>.GetDimensions(out uint width);
void Texture1D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             numberOfLevels);
void Texture1D<T>.GetDimensions(out float width);
void Texture1D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture1D<T>.Load`

## Signature 

```
/// See Availability 1
T Texture1D<T>.Load(vector<int,2> location);
/// See Availability 2
T Texture1D<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset);
/// See Availability 3
T Texture1D<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture1D<T>.subscript`

## Signature 

```
T Texture1D<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Texture1D<T>.Sample`

## Signature 

```
/// See Availability 1
T Texture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location);
/// See Availability 2
T Texture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 3
T Texture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp);
T Texture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Texture1D<T>.SampleBias`

## Signature 

```
T Texture1D<T>.SampleBias(
    SamplerState         s,
    vector<float,1>      location,
    float                bias);
T Texture1D<T>.SampleBias(
    SamplerState         s,
    vector<float,1>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Texture1D<T>.SampleCmp`

## Signature 

```
float Texture1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
float Texture1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture1D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Texture1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
/// See Availability 2
float Texture1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture1D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Texture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T Texture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T Texture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Texture1D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Texture1D<T>.SampleLevel(
    SamplerState         s,
    vector<float,1>      location,
    float                level);
/// See Availability 2
T Texture1D<T>.SampleLevel(
    SamplerState         s,
    vector<float,1>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Texture1D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture1D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture1D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture1D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture1D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWTexture1D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.CalculateLevelOfDetail`

## Signature 

```
float RWTexture1D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWTexture1D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.GetDimensions`

## Signature 

```
void RWTexture1D<T>.GetDimensions(out uint width);
void RWTexture1D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             numberOfLevels);
void RWTexture1D<T>.GetDimensions(out float width);
void RWTexture1D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture1D<T>.Load(vector<int,1> location);
/// See Availability 2
T RWTexture1D<T>.Load(
    vector<int,1>        location,
    vector<int,1>        offset);
/// See Availability 3
T RWTexture1D<T>.Load(
    vector<int,1>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.subscript`

## Signature 

```
T RWTexture1D<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.Sample`

## Signature 

```
/// See Availability 1
T RWTexture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location);
/// See Availability 2
T RWTexture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 3
T RWTexture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp);
T RWTexture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.SampleBias`

## Signature 

```
T RWTexture1D<T>.SampleBias(
    SamplerState         s,
    vector<float,1>      location,
    float                bias);
T RWTexture1D<T>.SampleBias(
    SamplerState         s,
    vector<float,1>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.SampleCmp`

## Signature 

```
float RWTexture1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
float RWTexture1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWTexture1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
/// See Availability 2
float RWTexture1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWTexture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T RWTexture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T RWTexture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWTexture1D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWTexture1D<T>.SampleLevel(
    SamplerState         s,
    vector<float,1>      location,
    float                level);
/// See Availability 2
T RWTexture1D<T>.SampleLevel(
    SamplerState         s,
    vector<float,1>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWTexture1D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture1D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture1D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture1D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture1D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture1D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedTexture1D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedTexture1D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture1D<T>.GetDimensions(out uint width);
void RasterizerOrderedTexture1D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             numberOfLevels);
void RasterizerOrderedTexture1D<T>.GetDimensions(out float width);
void RasterizerOrderedTexture1D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1D<T>.Load(vector<int,1> location);
T RasterizerOrderedTexture1D<T>.Load(
    vector<int,1>        location,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedTexture1D<T>.Load(
    vector<int,1>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture1D<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location);
/// See Availability 2
T RasterizerOrderedTexture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 3
T RasterizerOrderedTexture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp);
T RasterizerOrderedTexture1D<T>.Sample(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.SampleBias`

## Signature 

```
T RasterizerOrderedTexture1D<T>.SampleBias(
    SamplerState         s,
    vector<float,1>      location,
    float                bias);
T RasterizerOrderedTexture1D<T>.SampleBias(
    SamplerState         s,
    vector<float,1>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedTexture1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
float RasterizerOrderedTexture1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedTexture1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedTexture1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T RasterizerOrderedTexture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedTexture1D<T>.SampleGrad(
    SamplerState         s,
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1D<T>.SampleLevel(
    SamplerState         s,
    vector<float,1>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedTexture1D<T>.SampleLevel(
    SamplerState         s,
    vector<float,1>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture1D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.Gather(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location);
vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
    SamplerState         s,
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Texture1DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Texture1DMS<T>.GetDimensions`

## Signature 

```
void Texture1DMS<T>.GetDimensions(
    out uint             width,
    out uint             sampleCount);
void Texture1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Texture1DMS<T>.GetDimensions(
    out float            width,
    out float            sampleCount);
void Texture1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture1DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Texture1DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Texture1DMS<T>.Load`

## Signature 

```
/// See Availability 1
T Texture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex);
T Texture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T Texture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture1DMS<T>.subscript`

## Signature 

```
T Texture1DMS<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWTexture1DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWTexture1DMS<T>.GetDimensions`

## Signature 

```
void RWTexture1DMS<T>.GetDimensions(
    out uint             width,
    out uint             sampleCount);
void RWTexture1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWTexture1DMS<T>.GetDimensions(
    out float            width,
    out float            sampleCount);
void RWTexture1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture1DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWTexture1DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWTexture1DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex);
T RWTexture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T RWTexture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture1DMS<T>.subscript`

## Signature 

```
T RWTexture1DMS<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture1DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DMS<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture1DMS<T>.GetDimensions(
    out uint             width,
    out uint             sampleCount);
void RasterizerOrderedTexture1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedTexture1DMS<T>.GetDimensions(
    out float            width,
    out float            sampleCount);
void RasterizerOrderedTexture1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedTexture1DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex);
T RasterizerOrderedTexture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedTexture1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DMS<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture1DMS<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct Texture1DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float Texture1DArray<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Texture1DArray<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.GetDimensions`

## Signature 

```
void Texture1DArray<T>.GetDimensions(
    out uint             width,
    out uint             elements);
void Texture1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             numberOfLevels);
void Texture1DArray<T>.GetDimensions(
    out float            width,
    out float            elements);
void Texture1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.Load`

## Signature 

```
/// See Availability 1
T Texture1DArray<T>.Load(vector<int,3> location);
T Texture1DArray<T>.Load(
    vector<int,3>        location,
    vector<int,1>        offset);
/// See Availability 2
T Texture1DArray<T>.Load(
    vector<int,3>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.subscript`

## Signature 

```
T Texture1DArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T Texture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
T Texture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 3
T Texture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp);
T Texture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.SampleBias`

## Signature 

```
T Texture1DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias);
T Texture1DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.SampleCmp`

## Signature 

```
float Texture1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float Texture1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Texture1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float Texture1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Texture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T Texture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T Texture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Texture1DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Texture1DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level);
/// See Availability 2
T Texture1DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Texture1DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Texture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWTexture1DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RWTexture1DArray<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWTexture1DArray<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.GetDimensions`

## Signature 

```
void RWTexture1DArray<T>.GetDimensions(
    out uint             width,
    out uint             elements);
void RWTexture1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             numberOfLevels);
void RWTexture1DArray<T>.GetDimensions(
    out float            width,
    out float            elements);
void RWTexture1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture1DArray<T>.Load(vector<int,2> location);
/// See Availability 2
T RWTexture1DArray<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset);
/// See Availability 3
T RWTexture1DArray<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.subscript`

## Signature 

```
T RWTexture1DArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RWTexture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
T RWTexture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 3
T RWTexture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp);
T RWTexture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.SampleBias`

## Signature 

```
T RWTexture1DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias);
T RWTexture1DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.SampleCmp`

## Signature 

```
float RWTexture1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float RWTexture1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWTexture1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float RWTexture1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWTexture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T RWTexture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T RWTexture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWTexture1DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWTexture1DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level);
/// See Availability 2
T RWTexture1DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWTexture1DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture1DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedTexture1DArray<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedTexture1DArray<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,1>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture1DArray<T>.GetDimensions(
    out uint             width,
    out uint             elements);
void RasterizerOrderedTexture1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             numberOfLevels);
void RasterizerOrderedTexture1DArray<T>.GetDimensions(
    out float            width,
    out float            elements);
void RasterizerOrderedTexture1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1DArray<T>.Load(vector<int,2> location);
T RasterizerOrderedTexture1DArray<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedTexture1DArray<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture1DArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
T RasterizerOrderedTexture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 3
T RasterizerOrderedTexture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp);
T RasterizerOrderedTexture1DArray<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.SampleBias`

## Signature 

```
T RasterizerOrderedTexture1DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias);
T RasterizerOrderedTexture1DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedTexture1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float RasterizerOrderedTexture1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedTexture1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedTexture1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T RasterizerOrderedTexture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedTexture1DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedTexture1DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture1DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Texture1DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Texture1DMSArray<T>.GetDimensions`

## Signature 

```
void Texture1DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             elements,
    out uint             sampleCount);
void Texture1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Texture1DMSArray<T>.GetDimensions(
    out float            width,
    out float            elements,
    out float            sampleCount);
void Texture1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture1DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Texture1DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Texture1DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T Texture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T Texture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T Texture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture1DMSArray<T>.subscript`

## Signature 

```
T Texture1DMSArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWTexture1DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWTexture1DMSArray<T>.GetDimensions`

## Signature 

```
void RWTexture1DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             elements,
    out uint             sampleCount);
void RWTexture1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWTexture1DMSArray<T>.GetDimensions(
    out float            width,
    out float            elements,
    out float            sampleCount);
void RWTexture1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture1DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWTexture1DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWTexture1DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T RWTexture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T RWTexture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture1DMSArray<T>.subscript`

## Signature 

```
T RWTexture1DMSArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture1DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DMSArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture1DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             elements,
    out uint             sampleCount);
void RasterizerOrderedTexture1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedTexture1DMSArray<T>.GetDimensions(
    out float            width,
    out float            elements,
    out float            sampleCount);
void RasterizerOrderedTexture1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedTexture1DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T RasterizerOrderedTexture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedTexture1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture1DMSArray<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture1DMSArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct Texture2D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Texture2D<T>.CalculateLevelOfDetail`

## Signature 

```
float Texture2D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture2D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Texture2D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture2D<T>.GetDimensions`

## Signature 

```
void Texture2D<T>.GetDimensions(
    out uint             width,
    out uint             height);
void Texture2D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void Texture2D<T>.GetDimensions(
    out float            width,
    out float            height);
void Texture2D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture2D<T>.Load`

## Signature 

```
/// See Availability 1
T Texture2D<T>.Load(vector<int,3> location);
T Texture2D<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset);
/// See Availability 2
T Texture2D<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture2D<T>.subscript`

## Signature 

```
T Texture2D<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Texture2D<T>.Sample`

## Signature 

```
/// See Availability 1
T Texture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
T Texture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
T Texture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp);
T Texture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Texture2D<T>.SampleBias`

## Signature 

```
T Texture2D<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias);
T Texture2D<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Texture2D<T>.SampleCmp`

## Signature 

```
float Texture2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float Texture2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture2D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Texture2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float Texture2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture2D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Texture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T Texture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T Texture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Texture2D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Texture2D<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level);
/// See Availability 2
T Texture2D<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Texture2D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture2D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture2D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture2D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture2D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWTexture2D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.CalculateLevelOfDetail`

## Signature 

```
float RWTexture2D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWTexture2D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.GetDimensions`

## Signature 

```
void RWTexture2D<T>.GetDimensions(
    out uint             width,
    out uint             height);
void RWTexture2D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void RWTexture2D<T>.GetDimensions(
    out float            width,
    out float            height);
void RWTexture2D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture2D<T>.Load(vector<int,2> location);
/// See Availability 2
T RWTexture2D<T>.Load(
    vector<int,2>        location,
    vector<int,2>        offset);
/// See Availability 3
T RWTexture2D<T>.Load(
    vector<int,2>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.subscript`

## Signature 

```
T RWTexture2D<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.Sample`

## Signature 

```
/// See Availability 1
T RWTexture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
T RWTexture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
T RWTexture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp);
T RWTexture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.SampleBias`

## Signature 

```
T RWTexture2D<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias);
T RWTexture2D<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.SampleCmp`

## Signature 

```
float RWTexture2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float RWTexture2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWTexture2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float RWTexture2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWTexture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T RWTexture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T RWTexture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWTexture2D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWTexture2D<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level);
/// See Availability 2
T RWTexture2D<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWTexture2D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture2D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture2D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture2D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture2D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture2D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedTexture2D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedTexture2D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture2D<T>.GetDimensions(
    out uint             width,
    out uint             height);
void RasterizerOrderedTexture2D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void RasterizerOrderedTexture2D<T>.GetDimensions(
    out float            width,
    out float            height);
void RasterizerOrderedTexture2D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2D<T>.Load(vector<int,2> location);
T RasterizerOrderedTexture2D<T>.Load(
    vector<int,2>        location,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedTexture2D<T>.Load(
    vector<int,2>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture2D<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
T RasterizerOrderedTexture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
T RasterizerOrderedTexture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp);
T RasterizerOrderedTexture2D<T>.Sample(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.SampleBias`

## Signature 

```
T RasterizerOrderedTexture2D<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias);
T RasterizerOrderedTexture2D<T>.SampleBias(
    SamplerState         s,
    vector<float,2>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedTexture2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float RasterizerOrderedTexture2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedTexture2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedTexture2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T RasterizerOrderedTexture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedTexture2D<T>.SampleGrad(
    SamplerState         s,
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2D<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedTexture2D<T>.SampleLevel(
    SamplerState         s,
    vector<float,2>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture2D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.Gather(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
    SamplerState         s,
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Texture2DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Texture2DMS<T>.GetDimensions`

## Signature 

```
void Texture2DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void Texture2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Texture2DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void Texture2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture2DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Texture2DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Texture2DMS<T>.Load`

## Signature 

```
/// See Availability 1
T Texture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T Texture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T Texture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture2DMS<T>.subscript`

## Signature 

```
T Texture2DMS<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWTexture2DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWTexture2DMS<T>.GetDimensions`

## Signature 

```
void RWTexture2DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void RWTexture2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWTexture2DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void RWTexture2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture2DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWTexture2DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWTexture2DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T RWTexture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T RWTexture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture2DMS<T>.subscript`

## Signature 

```
T RWTexture2DMS<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture2DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DMS<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture2DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void RasterizerOrderedTexture2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedTexture2DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void RasterizerOrderedTexture2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedTexture2DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T RasterizerOrderedTexture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedTexture2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DMS<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture2DMS<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct Texture2DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float Texture2DArray<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Texture2DArray<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.GetDimensions`

## Signature 

```
void Texture2DArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void Texture2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void Texture2DArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void Texture2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.Load`

## Signature 

```
/// See Availability 1
T Texture2DArray<T>.Load(vector<int,4> location);
T Texture2DArray<T>.Load(
    vector<int,4>        location,
    vector<int,2>        offset);
/// See Availability 2
T Texture2DArray<T>.Load(
    vector<int,4>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.subscript`

## Signature 

```
T Texture2DArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T Texture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
T Texture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
T Texture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp);
T Texture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.SampleBias`

## Signature 

```
T Texture2DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias);
T Texture2DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.SampleCmp`

## Signature 

```
float Texture2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float Texture2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Texture2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float Texture2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Texture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T Texture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T Texture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Texture2DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Texture2DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level);
/// See Availability 2
T Texture2DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Texture2DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Texture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWTexture2DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RWTexture2DArray<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWTexture2DArray<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.GetDimensions`

## Signature 

```
void RWTexture2DArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void RWTexture2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void RWTexture2DArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void RWTexture2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture2DArray<T>.Load(vector<int,3> location);
/// See Availability 2
T RWTexture2DArray<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset);
/// See Availability 3
T RWTexture2DArray<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.subscript`

## Signature 

```
T RWTexture2DArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RWTexture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
T RWTexture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
T RWTexture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp);
T RWTexture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.SampleBias`

## Signature 

```
T RWTexture2DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias);
T RWTexture2DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.SampleCmp`

## Signature 

```
float RWTexture2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float RWTexture2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWTexture2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float RWTexture2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWTexture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T RWTexture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T RWTexture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWTexture2DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWTexture2DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level);
/// See Availability 2
T RWTexture2DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWTexture2DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture2DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedTexture2DArray<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedTexture2DArray<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,2>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture2DArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void RasterizerOrderedTexture2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void RasterizerOrderedTexture2DArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void RasterizerOrderedTexture2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2DArray<T>.Load(vector<int,3> location);
T RasterizerOrderedTexture2DArray<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedTexture2DArray<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture2DArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
T RasterizerOrderedTexture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
T RasterizerOrderedTexture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp);
T RasterizerOrderedTexture2DArray<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.SampleBias`

## Signature 

```
T RasterizerOrderedTexture2DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias);
T RasterizerOrderedTexture2DArray<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedTexture2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float RasterizerOrderedTexture2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedTexture2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedTexture2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T RasterizerOrderedTexture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedTexture2DArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedTexture2DArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture2DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Texture2DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Texture2DMSArray<T>.GetDimensions`

## Signature 

```
void Texture2DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void Texture2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Texture2DMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void Texture2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture2DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Texture2DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Texture2DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T Texture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T Texture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T Texture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture2DMSArray<T>.subscript`

## Signature 

```
T Texture2DMSArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWTexture2DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWTexture2DMSArray<T>.GetDimensions`

## Signature 

```
void RWTexture2DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void RWTexture2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWTexture2DMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void RWTexture2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture2DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWTexture2DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWTexture2DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RWTexture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T RWTexture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture2DMSArray<T>.subscript`

## Signature 

```
T RWTexture2DMSArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture2DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DMSArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture2DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void RasterizerOrderedTexture2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedTexture2DMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void RasterizerOrderedTexture2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedTexture2DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RasterizerOrderedTexture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedTexture2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture2DMSArray<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture2DMSArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct Texture3D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Texture3D<T>.CalculateLevelOfDetail`

## Signature 

```
float Texture3D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture3D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Texture3D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `Texture3D<T>.GetDimensions`

## Signature 

```
void Texture3D<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth);
void Texture3D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             numberOfLevels);
void Texture3D<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth);
void Texture3D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture3D<T>.Load`

## Signature 

```
/// See Availability 1
T Texture3D<T>.Load(vector<int,4> location);
T Texture3D<T>.Load(
    vector<int,4>        location,
    vector<int,3>        offset);
/// See Availability 2
T Texture3D<T>.Load(
    vector<int,4>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture3D<T>.subscript`

## Signature 

```
T Texture3D<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Texture3D<T>.Sample`

## Signature 

```
/// See Availability 1
T Texture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
T Texture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 3
T Texture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp);
T Texture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Texture3D<T>.SampleBias`

## Signature 

```
T Texture3D<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias);
T Texture3D<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Texture3D<T>.SampleCmp`

## Signature 

```
float Texture3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float Texture3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture3D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Texture3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float Texture3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Texture3D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Texture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
T Texture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset);
/// See Availability 2
T Texture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Texture3D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Texture3D<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level);
/// See Availability 2
T Texture3D<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Texture3D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture3D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture3D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture3D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Texture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Texture3D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Texture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Texture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Texture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Texture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Texture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Texture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWTexture3D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.CalculateLevelOfDetail`

## Signature 

```
float RWTexture3D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWTexture3D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.GetDimensions`

## Signature 

```
void RWTexture3D<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth);
void RWTexture3D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             numberOfLevels);
void RWTexture3D<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth);
void RWTexture3D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture3D<T>.Load(vector<int,3> location);
/// See Availability 2
T RWTexture3D<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset);
/// See Availability 3
T RWTexture3D<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.subscript`

## Signature 

```
T RWTexture3D<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.Sample`

## Signature 

```
/// See Availability 1
T RWTexture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
T RWTexture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 3
T RWTexture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp);
T RWTexture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.SampleBias`

## Signature 

```
T RWTexture3D<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias);
T RWTexture3D<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.SampleCmp`

## Signature 

```
float RWTexture3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float RWTexture3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWTexture3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float RWTexture3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWTexture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
T RWTexture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset);
/// See Availability 2
T RWTexture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWTexture3D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWTexture3D<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level);
/// See Availability 2
T RWTexture3D<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWTexture3D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture3D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture3D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture3D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWTexture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWTexture3D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWTexture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture3D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedTexture3D<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedTexture3D<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture3D<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth);
void RasterizerOrderedTexture3D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             numberOfLevels);
void RasterizerOrderedTexture3D<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth);
void RasterizerOrderedTexture3D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture3D<T>.Load(vector<int,3> location);
T RasterizerOrderedTexture3D<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedTexture3D<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture3D<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
T RasterizerOrderedTexture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 3
T RasterizerOrderedTexture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp);
T RasterizerOrderedTexture3D<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.SampleBias`

## Signature 

```
T RasterizerOrderedTexture3D<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias);
T RasterizerOrderedTexture3D<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedTexture3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float RasterizerOrderedTexture3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedTexture3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedTexture3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
T RasterizerOrderedTexture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedTexture3D<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture3D<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedTexture3D<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture3D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTexture3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Texture3DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Texture3DMS<T>.GetDimensions`

## Signature 

```
void Texture3DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount);
void Texture3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Texture3DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount);
void Texture3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Texture3DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Texture3DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Texture3DMS<T>.Load`

## Signature 

```
/// See Availability 1
T Texture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T Texture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T Texture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Texture3DMS<T>.subscript`

## Signature 

```
T Texture3DMS<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWTexture3DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWTexture3DMS<T>.GetDimensions`

## Signature 

```
void RWTexture3DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount);
void RWTexture3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWTexture3DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount);
void RWTexture3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWTexture3DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWTexture3DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWTexture3DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RWTexture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RWTexture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T RWTexture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWTexture3DMS<T>.subscript`

## Signature 

```
T RWTexture3DMS<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTexture3DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3DMS<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTexture3DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount);
void RasterizerOrderedTexture3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedTexture3DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount);
void RasterizerOrderedTexture3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedTexture3DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTexture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RasterizerOrderedTexture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedTexture3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTexture3DMS<T>.subscript`

## Signature 

```
T RasterizerOrderedTexture3DMS<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct TextureCube<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `TextureCube<T>.CalculateLevelOfDetail`

## Signature 

```
float TextureCube<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `TextureCube<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float TextureCube<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `TextureCube<T>.GetDimensions`

## Signature 

```
void TextureCube<T>.GetDimensions(
    out uint             width,
    out uint             height);
void TextureCube<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void TextureCube<T>.GetDimensions(
    out float            width,
    out float            height);
void TextureCube<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `TextureCube<T>.Load`

## Signature 

```
/// See Availability 1
T TextureCube<T>.Load(vector<int,4> location);
T TextureCube<T>.Load(
    vector<int,4>        location,
    vector<int,3>        offset);
/// See Availability 2
T TextureCube<T>.Load(
    vector<int,4>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `TextureCube<T>.Sample`

## Signature 

```
/// See Availability 1
T TextureCube<T>.Sample(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
T TextureCube<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    float                clamp);
T TextureCube<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `TextureCube<T>.SampleBias`

## Signature 

```
T TextureCube<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`

--------------------------------------------------------------------------------
# `TextureCube<T>.SampleCmp`

## Signature 

```
float TextureCube<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`

--------------------------------------------------------------------------------
# `TextureCube<T>.SampleCmpLevelZero`

## Signature 

```
float TextureCube<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`

--------------------------------------------------------------------------------
# `TextureCube<T>.SampleGrad`

## Signature 

```
T TextureCube<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`

--------------------------------------------------------------------------------
# `TextureCube<T>.SampleLevel`

## Signature 

```
T TextureCube<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `s`
* `location`
* `level`

--------------------------------------------------------------------------------
# `extension TextureCube`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `TextureCube.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension TextureCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `TextureCube.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension TextureCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `TextureCube.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension TextureCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `TextureCube.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTextureCube<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedTextureCube<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedTextureCube<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTextureCube<T>.GetDimensions(
    out uint             width,
    out uint             height);
void RasterizerOrderedTextureCube<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void RasterizerOrderedTextureCube<T>.GetDimensions(
    out float            width,
    out float            height);
void RasterizerOrderedTextureCube<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTextureCube<T>.Load(vector<int,3> location);
T RasterizerOrderedTextureCube<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedTextureCube<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTextureCube<T>.Sample(
    SamplerState         s,
    vector<float,3>      location);
/// See Availability 2
T RasterizerOrderedTextureCube<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    float                clamp);
T RasterizerOrderedTextureCube<T>.Sample(
    SamplerState         s,
    vector<float,3>      location,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.SampleBias`

## Signature 

```
T RasterizerOrderedTextureCube<T>.SampleBias(
    SamplerState         s,
    vector<float,3>      location,
    float                bias);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedTextureCube<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.SampleCmpLevelZero`

## Signature 

```
float RasterizerOrderedTextureCube<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.SampleGrad`

## Signature 

```
T RasterizerOrderedTextureCube<T>.SampleGrad(
    SamplerState         s,
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube<T>.SampleLevel`

## Signature 

```
T RasterizerOrderedTextureCube<T>.SampleLevel(
    SamplerState         s,
    vector<float,3>      location,
    float                level);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `s`
* `location`
* `level`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTextureCube`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTextureCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTextureCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTextureCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.Gather(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location);
vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
    SamplerState         s,
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct TextureCubeMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`

--------------------------------------------------------------------------------
# `TextureCubeMS<T>.GetDimensions`

## Signature 

```
void TextureCubeMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void TextureCubeMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void TextureCubeMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void TextureCubeMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `TextureCubeMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> TextureCubeMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `TextureCubeMS<T>.Load`

## Signature 

```
/// See Availability 1
T TextureCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T TextureCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T TextureCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTextureCubeMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeMS<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTextureCubeMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void RasterizerOrderedTextureCubeMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedTextureCubeMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void RasterizerOrderedTextureCubeMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedTextureCubeMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeMS<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTextureCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RasterizerOrderedTextureCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedTextureCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `struct TextureCubeArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Sample`
* `SampleBias`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `TextureCubeArray<T>.CalculateLevelOfDetail`

## Signature 

```
float TextureCubeArray<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `TextureCubeArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float TextureCubeArray<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `TextureCubeArray<T>.GetDimensions`

## Signature 

```
void TextureCubeArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void TextureCubeArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void TextureCubeArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void TextureCubeArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `TextureCubeArray<T>.Sample`

## Signature 

```
/// See Availability 1
T TextureCubeArray<T>.Sample(
    SamplerState         s,
    vector<float,4>      location);
/// See Availability 2
T TextureCubeArray<T>.Sample(
    SamplerState         s,
    vector<float,4>      location,
    float                clamp);
T TextureCubeArray<T>.Sample(
    SamplerState         s,
    vector<float,4>      location,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `TextureCubeArray<T>.SampleBias`

## Signature 

```
T TextureCubeArray<T>.SampleBias(
    SamplerState         s,
    vector<float,4>      location,
    float                bias);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`

--------------------------------------------------------------------------------
# `TextureCubeArray<T>.SampleGrad`

## Signature 

```
T TextureCubeArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,4>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`

--------------------------------------------------------------------------------
# `TextureCubeArray<T>.SampleLevel`

## Signature 

```
T TextureCubeArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,4>      location,
    float                level);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `s`
* `location`
* `level`

--------------------------------------------------------------------------------
# `extension TextureCubeArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `TextureCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension TextureCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `TextureCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension TextureCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `TextureCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension TextureCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `TextureCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `TextureCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> TextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTextureCubeArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Sample`
* `SampleBias`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedTextureCubeArray<T>.CalculateLevelOfDetail(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedTextureCubeArray<T>.CalculateLevelOfDetailUnclamped(
    SamplerState         s,
    vector<float,3>      location);
```

## Parameters

* `s`
* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTextureCubeArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void RasterizerOrderedTextureCubeArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void RasterizerOrderedTextureCubeArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void RasterizerOrderedTextureCubeArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedTextureCubeArray<T>.Sample(
    SamplerState         s,
    vector<float,4>      location);
/// See Availability 2
T RasterizerOrderedTextureCubeArray<T>.Sample(
    SamplerState         s,
    vector<float,4>      location,
    float                clamp);
T RasterizerOrderedTextureCubeArray<T>.Sample(
    SamplerState         s,
    vector<float,4>      location,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray<T>.SampleBias`

## Signature 

```
T RasterizerOrderedTextureCubeArray<T>.SampleBias(
    SamplerState         s,
    vector<float,4>      location,
    float                bias);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `bias`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray<T>.SampleGrad`

## Signature 

```
T RasterizerOrderedTextureCubeArray<T>.SampleGrad(
    SamplerState         s,
    vector<float,4>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `gradX`
* `gradY`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray<T>.SampleLevel`

## Signature 

```
T RasterizerOrderedTextureCubeArray<T>.SampleLevel(
    SamplerState         s,
    vector<float,4>      location,
    float                level);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `s`
* `location`
* `level`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTextureCubeArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location);
vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTextureCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location);
vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTextureCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location);
vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedTextureCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location);
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
    SamplerState         s,
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct TextureCubeMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`

--------------------------------------------------------------------------------
# `TextureCubeMSArray<T>.GetDimensions`

## Signature 

```
void TextureCubeMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void TextureCubeMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void TextureCubeMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void TextureCubeMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `TextureCubeMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> TextureCubeMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedTextureCubeMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeMSArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedTextureCubeMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void RasterizerOrderedTextureCubeMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedTextureCubeMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void RasterizerOrderedTextureCubeMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedTextureCubeMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedTextureCubeMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `struct Sampler1D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Sampler1D<T>.CalculateLevelOfDetail`

## Signature 

```
float Sampler1D<T>.CalculateLevelOfDetail(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler1D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Sampler1D<T>.CalculateLevelOfDetailUnclamped(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler1D<T>.GetDimensions`

## Signature 

```
void Sampler1D<T>.GetDimensions(out uint width);
void Sampler1D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             numberOfLevels);
void Sampler1D<T>.GetDimensions(out float width);
void Sampler1D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler1D<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler1D<T>.Load(vector<int,2> location);
/// See Availability 2
T Sampler1D<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset);
/// See Availability 3
T Sampler1D<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler1D<T>.subscript`

## Signature 

```
T Sampler1D<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler1D<T>.Sample`

## Signature 

```
/// See Availability 1
T Sampler1D<T>.Sample(vector<float,1> location);
/// See Availability 2
T Sampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 3
T Sampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp);
T Sampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Sampler1D<T>.SampleBias`

## Signature 

```
T Sampler1D<T>.SampleBias(
    vector<float,1>      location,
    float                bias);
T Sampler1D<T>.SampleBias(
    vector<float,1>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Sampler1D<T>.SampleCmp`

## Signature 

```
float Sampler1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
float Sampler1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler1D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Sampler1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
/// See Availability 2
float Sampler1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler1D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Sampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T Sampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T Sampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Sampler1D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Sampler1D<T>.SampleLevel(
    vector<float,1>      location,
    float                level);
/// See Availability 2
T Sampler1D<T>.SampleLevel(
    vector<float,1>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Sampler1D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1D.Gather(vector<float,1> location);
vector<T,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1D.GatherRed(vector<float,1> location);
vector<T,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1D.GatherGreen(vector<float,1> location);
vector<T,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1D.GatherBlue(vector<float,1> location);
vector<T,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1D.GatherAlpha(vector<float,1> location);
vector<T,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1D.Gather(vector<float,1> location);
vector<float,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1D.GatherRed(vector<float,1> location);
vector<float,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1D.GatherGreen(vector<float,1> location);
vector<float,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1D.GatherBlue(vector<float,1> location);
vector<float,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1D.GatherAlpha(vector<float,1> location);
vector<float,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1D.Gather(vector<float,1> location);
vector<int,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1D.GatherRed(vector<float,1> location);
vector<int,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1D.GatherGreen(vector<float,1> location);
vector<int,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1D.GatherBlue(vector<float,1> location);
vector<int,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1D.GatherAlpha(vector<float,1> location);
vector<int,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1D.Gather(vector<float,1> location);
vector<uint,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1D.GatherRed(vector<float,1> location);
vector<uint,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1D.GatherGreen(vector<float,1> location);
vector<uint,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1D.GatherBlue(vector<float,1> location);
vector<uint,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1D.GatherAlpha(vector<float,1> location);
vector<uint,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWSampler1D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.CalculateLevelOfDetail`

## Signature 

```
float RWSampler1D<T>.CalculateLevelOfDetail(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWSampler1D<T>.CalculateLevelOfDetailUnclamped(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.GetDimensions`

## Signature 

```
void RWSampler1D<T>.GetDimensions(out uint width);
void RWSampler1D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             numberOfLevels);
void RWSampler1D<T>.GetDimensions(out float width);
void RWSampler1D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler1D<T>.Load(vector<int,1> location);
/// See Availability 2
T RWSampler1D<T>.Load(
    vector<int,1>        location,
    vector<int,1>        offset);
/// See Availability 3
T RWSampler1D<T>.Load(
    vector<int,1>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.subscript`

## Signature 

```
T RWSampler1D<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.Sample`

## Signature 

```
/// See Availability 1
T RWSampler1D<T>.Sample(vector<float,1> location);
/// See Availability 2
T RWSampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 3
T RWSampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp);
T RWSampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.SampleBias`

## Signature 

```
T RWSampler1D<T>.SampleBias(
    vector<float,1>      location,
    float                bias);
T RWSampler1D<T>.SampleBias(
    vector<float,1>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.SampleCmp`

## Signature 

```
float RWSampler1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
float RWSampler1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWSampler1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
/// See Availability 2
float RWSampler1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWSampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T RWSampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T RWSampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWSampler1D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWSampler1D<T>.SampleLevel(
    vector<float,1>      location,
    float                level);
/// See Availability 2
T RWSampler1D<T>.SampleLevel(
    vector<float,1>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWSampler1D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1D.Gather(vector<float,1> location);
vector<T,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1D.GatherRed(vector<float,1> location);
vector<T,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1D.GatherGreen(vector<float,1> location);
vector<T,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1D.GatherBlue(vector<float,1> location);
vector<T,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1D.GatherAlpha(vector<float,1> location);
vector<T,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1D.Gather(vector<float,1> location);
vector<float,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1D.GatherRed(vector<float,1> location);
vector<float,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1D.GatherGreen(vector<float,1> location);
vector<float,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1D.GatherBlue(vector<float,1> location);
vector<float,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1D.GatherAlpha(vector<float,1> location);
vector<float,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1D.Gather(vector<float,1> location);
vector<int,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1D.GatherRed(vector<float,1> location);
vector<int,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1D.GatherGreen(vector<float,1> location);
vector<int,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1D.GatherBlue(vector<float,1> location);
vector<int,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1D.GatherAlpha(vector<float,1> location);
vector<int,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1D.Gather(vector<float,1> location);
vector<uint,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1D.GatherRed(vector<float,1> location);
vector<uint,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1D.GatherGreen(vector<float,1> location);
vector<uint,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1D.GatherBlue(vector<float,1> location);
vector<uint,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1D.GatherAlpha(vector<float,1> location);
vector<uint,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler1D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedSampler1D<T>.CalculateLevelOfDetail(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedSampler1D<T>.CalculateLevelOfDetailUnclamped(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler1D<T>.GetDimensions(out uint width);
void RasterizerOrderedSampler1D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             numberOfLevels);
void RasterizerOrderedSampler1D<T>.GetDimensions(out float width);
void RasterizerOrderedSampler1D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1D<T>.Load(vector<int,1> location);
T RasterizerOrderedSampler1D<T>.Load(
    vector<int,1>        location,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedSampler1D<T>.Load(
    vector<int,1>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler1D<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1D<T>.Sample(vector<float,1> location);
/// See Availability 2
T RasterizerOrderedSampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 3
T RasterizerOrderedSampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp);
T RasterizerOrderedSampler1D<T>.Sample(
    vector<float,1>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.SampleBias`

## Signature 

```
T RasterizerOrderedSampler1D<T>.SampleBias(
    vector<float,1>      location,
    float                bias);
T RasterizerOrderedSampler1D<T>.SampleBias(
    vector<float,1>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedSampler1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
float RasterizerOrderedSampler1D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedSampler1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedSampler1D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,1>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T RasterizerOrderedSampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedSampler1D<T>.SampleGrad(
    vector<float,1>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1D<T>.SampleLevel(
    vector<float,1>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedSampler1D<T>.SampleLevel(
    vector<float,1>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler1D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.Gather(vector<float,1> location);
vector<T,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.GatherRed(vector<float,1> location);
vector<T,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.GatherGreen(vector<float,1> location);
vector<T,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.GatherBlue(vector<float,1> location);
vector<T,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.GatherAlpha(vector<float,1> location);
vector<T,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.Gather(vector<float,1> location);
vector<float,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.GatherRed(vector<float,1> location);
vector<float,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.GatherGreen(vector<float,1> location);
vector<float,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.GatherBlue(vector<float,1> location);
vector<float,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.GatherAlpha(vector<float,1> location);
vector<float,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.Gather(vector<float,1> location);
vector<int,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.GatherRed(vector<float,1> location);
vector<int,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.GatherGreen(vector<float,1> location);
vector<int,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.GatherBlue(vector<float,1> location);
vector<int,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.GatherAlpha(vector<float,1> location);
vector<int,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler1D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.Gather(vector<float,1> location);
vector<uint,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.Gather(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.GatherRed(vector<float,1> location);
vector<uint,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.GatherRed(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.GatherGreen(vector<float,1> location);
vector<uint,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.GatherGreen(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.GatherBlue(vector<float,1> location);
vector<uint,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.GatherBlue(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.GatherAlpha(vector<float,1> location);
vector<uint,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1D.GatherAlpha(
    vector<float,1>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Sampler1DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Sampler1DMS<T>.GetDimensions`

## Signature 

```
void Sampler1DMS<T>.GetDimensions(
    out uint             width,
    out uint             sampleCount);
void Sampler1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Sampler1DMS<T>.GetDimensions(
    out float            width,
    out float            sampleCount);
void Sampler1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler1DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Sampler1DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Sampler1DMS<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex);
T Sampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T Sampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler1DMS<T>.subscript`

## Signature 

```
T Sampler1DMS<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWSampler1DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWSampler1DMS<T>.GetDimensions`

## Signature 

```
void RWSampler1DMS<T>.GetDimensions(
    out uint             width,
    out uint             sampleCount);
void RWSampler1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWSampler1DMS<T>.GetDimensions(
    out float            width,
    out float            sampleCount);
void RWSampler1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler1DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWSampler1DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWSampler1DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex);
T RWSampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T RWSampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler1DMS<T>.subscript`

## Signature 

```
T RWSampler1DMS<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler1DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DMS<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler1DMS<T>.GetDimensions(
    out uint             width,
    out uint             sampleCount);
void RasterizerOrderedSampler1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedSampler1DMS<T>.GetDimensions(
    out float            width,
    out float            sampleCount);
void RasterizerOrderedSampler1DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedSampler1DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex);
T RasterizerOrderedSampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedSampler1DMS<T>.Load(
    vector<int,1>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DMS<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler1DMS<T>.subscript(uint location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct Sampler1DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float Sampler1DArray<T>.CalculateLevelOfDetail(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Sampler1DArray<T>.CalculateLevelOfDetailUnclamped(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.GetDimensions`

## Signature 

```
void Sampler1DArray<T>.GetDimensions(
    out uint             width,
    out uint             elements);
void Sampler1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             numberOfLevels);
void Sampler1DArray<T>.GetDimensions(
    out float            width,
    out float            elements);
void Sampler1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler1DArray<T>.Load(vector<int,3> location);
T Sampler1DArray<T>.Load(
    vector<int,3>        location,
    vector<int,1>        offset);
/// See Availability 2
T Sampler1DArray<T>.Load(
    vector<int,3>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.subscript`

## Signature 

```
T Sampler1DArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T Sampler1DArray<T>.Sample(vector<float,2> location);
/// See Availability 2
T Sampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 3
T Sampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp);
T Sampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.SampleBias`

## Signature 

```
T Sampler1DArray<T>.SampleBias(
    vector<float,2>      location,
    float                bias);
T Sampler1DArray<T>.SampleBias(
    vector<float,2>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.SampleCmp`

## Signature 

```
float Sampler1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float Sampler1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Sampler1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float Sampler1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Sampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T Sampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T Sampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Sampler1DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Sampler1DArray<T>.SampleLevel(
    vector<float,2>      location,
    float                level);
/// See Availability 2
T Sampler1DArray<T>.SampleLevel(
    vector<float,2>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Sampler1DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1DArray.Gather(vector<float,2> location);
vector<T,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1DArray.GatherRed(vector<float,2> location);
vector<T,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1DArray.GatherGreen(vector<float,2> location);
vector<T,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1DArray.GatherBlue(vector<float,2> location);
vector<T,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler1DArray.GatherAlpha(vector<float,2> location);
vector<T,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1DArray.Gather(vector<float,2> location);
vector<float,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1DArray.GatherRed(vector<float,2> location);
vector<float,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1DArray.GatherGreen(vector<float,2> location);
vector<float,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1DArray.GatherBlue(vector<float,2> location);
vector<float,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler1DArray.GatherAlpha(vector<float,2> location);
vector<float,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1DArray.Gather(vector<float,2> location);
vector<int,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1DArray.GatherRed(vector<float,2> location);
vector<int,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1DArray.GatherGreen(vector<float,2> location);
vector<int,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1DArray.GatherBlue(vector<float,2> location);
vector<int,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler1DArray.GatherAlpha(vector<float,2> location);
vector<int,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1DArray.Gather(vector<float,2> location);
vector<uint,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1DArray.GatherRed(vector<float,2> location);
vector<uint,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1DArray.GatherGreen(vector<float,2> location);
vector<uint,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1DArray.GatherBlue(vector<float,2> location);
vector<uint,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler1DArray.GatherAlpha(vector<float,2> location);
vector<uint,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> Sampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWSampler1DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RWSampler1DArray<T>.CalculateLevelOfDetail(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWSampler1DArray<T>.CalculateLevelOfDetailUnclamped(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.GetDimensions`

## Signature 

```
void RWSampler1DArray<T>.GetDimensions(
    out uint             width,
    out uint             elements);
void RWSampler1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             numberOfLevels);
void RWSampler1DArray<T>.GetDimensions(
    out float            width,
    out float            elements);
void RWSampler1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler1DArray<T>.Load(vector<int,2> location);
/// See Availability 2
T RWSampler1DArray<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset);
/// See Availability 3
T RWSampler1DArray<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.subscript`

## Signature 

```
T RWSampler1DArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RWSampler1DArray<T>.Sample(vector<float,2> location);
/// See Availability 2
T RWSampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 3
T RWSampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp);
T RWSampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.SampleBias`

## Signature 

```
T RWSampler1DArray<T>.SampleBias(
    vector<float,2>      location,
    float                bias);
T RWSampler1DArray<T>.SampleBias(
    vector<float,2>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.SampleCmp`

## Signature 

```
float RWSampler1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float RWSampler1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWSampler1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float RWSampler1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWSampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T RWSampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T RWSampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWSampler1DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWSampler1DArray<T>.SampleLevel(
    vector<float,2>      location,
    float                level);
/// See Availability 2
T RWSampler1DArray<T>.SampleLevel(
    vector<float,2>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWSampler1DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1DArray.Gather(vector<float,2> location);
vector<T,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1DArray.GatherRed(vector<float,2> location);
vector<T,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1DArray.GatherGreen(vector<float,2> location);
vector<T,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1DArray.GatherBlue(vector<float,2> location);
vector<T,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler1DArray.GatherAlpha(vector<float,2> location);
vector<T,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1DArray.Gather(vector<float,2> location);
vector<float,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1DArray.GatherRed(vector<float,2> location);
vector<float,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1DArray.GatherGreen(vector<float,2> location);
vector<float,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1DArray.GatherBlue(vector<float,2> location);
vector<float,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler1DArray.GatherAlpha(vector<float,2> location);
vector<float,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1DArray.Gather(vector<float,2> location);
vector<int,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1DArray.GatherRed(vector<float,2> location);
vector<int,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1DArray.GatherGreen(vector<float,2> location);
vector<int,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1DArray.GatherBlue(vector<float,2> location);
vector<int,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler1DArray.GatherAlpha(vector<float,2> location);
vector<int,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1DArray.Gather(vector<float,2> location);
vector<uint,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1DArray.GatherRed(vector<float,2> location);
vector<uint,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1DArray.GatherGreen(vector<float,2> location);
vector<uint,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1DArray.GatherBlue(vector<float,2> location);
vector<uint,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler1DArray.GatherAlpha(vector<float,2> location);
vector<uint,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RWSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler1DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedSampler1DArray<T>.CalculateLevelOfDetail(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedSampler1DArray<T>.CalculateLevelOfDetailUnclamped(vector<float,1> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler1DArray<T>.GetDimensions(
    out uint             width,
    out uint             elements);
void RasterizerOrderedSampler1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             numberOfLevels);
void RasterizerOrderedSampler1DArray<T>.GetDimensions(
    out float            width,
    out float            elements);
void RasterizerOrderedSampler1DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1DArray<T>.Load(vector<int,2> location);
T RasterizerOrderedSampler1DArray<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedSampler1DArray<T>.Load(
    vector<int,2>        location,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler1DArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1DArray<T>.Sample(vector<float,2> location);
/// See Availability 2
T RasterizerOrderedSampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 3
T RasterizerOrderedSampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp);
T RasterizerOrderedSampler1DArray<T>.Sample(
    vector<float,2>      location,
    vector<int,1>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.SampleBias`

## Signature 

```
T RasterizerOrderedSampler1DArray<T>.SampleBias(
    vector<float,2>      location,
    float                bias);
T RasterizerOrderedSampler1DArray<T>.SampleBias(
    vector<float,2>      location,
    float                bias,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedSampler1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float RasterizerOrderedSampler1DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedSampler1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedSampler1DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY);
T RasterizerOrderedSampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedSampler1DArray<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,1>      gradX,
    vector<float,1>      gradY,
    vector<int,1>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1DArray<T>.SampleLevel(
    vector<float,2>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedSampler1DArray<T>.SampleLevel(
    vector<float,2>      location,
    float                level,
    vector<int,1>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler1DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.Gather(vector<float,2> location);
vector<T,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.GatherRed(vector<float,2> location);
vector<T,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.GatherGreen(vector<float,2> location);
vector<T,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.GatherBlue(vector<float,2> location);
vector<T,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.GatherAlpha(vector<float,2> location);
vector<T,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.Gather(vector<float,2> location);
vector<float,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.GatherRed(vector<float,2> location);
vector<float,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.GatherGreen(vector<float,2> location);
vector<float,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.GatherBlue(vector<float,2> location);
vector<float,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.GatherAlpha(vector<float,2> location);
vector<float,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.Gather(vector<float,2> location);
vector<int,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.GatherRed(vector<float,2> location);
vector<int,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.GatherGreen(vector<float,2> location);
vector<int,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.GatherBlue(vector<float,2> location);
vector<int,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.GatherAlpha(vector<float,2> location);
vector<int,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler1DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.Gather(vector<float,2> location);
vector<uint,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.Gather(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.GatherRed(vector<float,2> location);
vector<uint,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.GatherRed(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.GatherGreen(vector<float,2> location);
vector<uint,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.GatherGreen(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.GatherBlue(vector<float,2> location);
vector<uint,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.GatherBlue(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.GatherAlpha(vector<float,2> location);
vector<uint,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler1DArray.GatherAlpha(
    vector<float,2>      location,
    vector<int,1>        offset1,
    vector<int,1>        offset2,
    vector<int,1>        offset3,
    vector<int,1>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Sampler1DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Sampler1DMSArray<T>.GetDimensions`

## Signature 

```
void Sampler1DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             elements,
    out uint             sampleCount);
void Sampler1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Sampler1DMSArray<T>.GetDimensions(
    out float            width,
    out float            elements,
    out float            sampleCount);
void Sampler1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler1DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Sampler1DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Sampler1DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T Sampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T Sampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler1DMSArray<T>.subscript`

## Signature 

```
T Sampler1DMSArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWSampler1DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWSampler1DMSArray<T>.GetDimensions`

## Signature 

```
void RWSampler1DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             elements,
    out uint             sampleCount);
void RWSampler1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWSampler1DMSArray<T>.GetDimensions(
    out float            width,
    out float            elements,
    out float            sampleCount);
void RWSampler1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler1DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWSampler1DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWSampler1DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T RWSampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T RWSampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler1DMSArray<T>.subscript`

## Signature 

```
T RWSampler1DMSArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler1DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DMSArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler1DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             elements,
    out uint             sampleCount);
void RasterizerOrderedSampler1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedSampler1DMSArray<T>.GetDimensions(
    out float            width,
    out float            elements,
    out float            sampleCount);
void RasterizerOrderedSampler1DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedSampler1DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T RasterizerOrderedSampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset);
/// See Availability 2
T RasterizerOrderedSampler1DMSArray<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,1>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler1DMSArray<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler1DMSArray<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct Sampler2D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Sampler2D<T>.CalculateLevelOfDetail`

## Signature 

```
float Sampler2D<T>.CalculateLevelOfDetail(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler2D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Sampler2D<T>.CalculateLevelOfDetailUnclamped(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler2D<T>.GetDimensions`

## Signature 

```
void Sampler2D<T>.GetDimensions(
    out uint             width,
    out uint             height);
void Sampler2D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void Sampler2D<T>.GetDimensions(
    out float            width,
    out float            height);
void Sampler2D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler2D<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler2D<T>.Load(vector<int,3> location);
T Sampler2D<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset);
/// See Availability 2
T Sampler2D<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler2D<T>.subscript`

## Signature 

```
T Sampler2D<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler2D<T>.Sample`

## Signature 

```
/// See Availability 1
T Sampler2D<T>.Sample(vector<float,2> location);
/// See Availability 2
T Sampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
T Sampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp);
T Sampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Sampler2D<T>.SampleBias`

## Signature 

```
T Sampler2D<T>.SampleBias(
    vector<float,2>      location,
    float                bias);
T Sampler2D<T>.SampleBias(
    vector<float,2>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Sampler2D<T>.SampleCmp`

## Signature 

```
float Sampler2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float Sampler2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler2D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Sampler2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float Sampler2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler2D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Sampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T Sampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T Sampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Sampler2D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Sampler2D<T>.SampleLevel(
    vector<float,2>      location,
    float                level);
/// See Availability 2
T Sampler2D<T>.SampleLevel(
    vector<float,2>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Sampler2D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<T,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<T,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<T,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<T,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<T,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<float,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<float,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<float,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<float,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<float,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<int,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<int,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<int,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<int,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<int,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<uint,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<uint,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<uint,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<uint,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<uint,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWSampler2D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.CalculateLevelOfDetail`

## Signature 

```
float RWSampler2D<T>.CalculateLevelOfDetail(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWSampler2D<T>.CalculateLevelOfDetailUnclamped(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.GetDimensions`

## Signature 

```
void RWSampler2D<T>.GetDimensions(
    out uint             width,
    out uint             height);
void RWSampler2D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void RWSampler2D<T>.GetDimensions(
    out float            width,
    out float            height);
void RWSampler2D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler2D<T>.Load(vector<int,2> location);
/// See Availability 2
T RWSampler2D<T>.Load(
    vector<int,2>        location,
    vector<int,2>        offset);
/// See Availability 3
T RWSampler2D<T>.Load(
    vector<int,2>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.subscript`

## Signature 

```
T RWSampler2D<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.Sample`

## Signature 

```
/// See Availability 1
T RWSampler2D<T>.Sample(vector<float,2> location);
/// See Availability 2
T RWSampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
T RWSampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp);
T RWSampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.SampleBias`

## Signature 

```
T RWSampler2D<T>.SampleBias(
    vector<float,2>      location,
    float                bias);
T RWSampler2D<T>.SampleBias(
    vector<float,2>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.SampleCmp`

## Signature 

```
float RWSampler2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float RWSampler2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWSampler2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float RWSampler2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWSampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T RWSampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T RWSampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWSampler2D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWSampler2D<T>.SampleLevel(
    vector<float,2>      location,
    float                level);
/// See Availability 2
T RWSampler2D<T>.SampleLevel(
    vector<float,2>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWSampler2D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<T,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<T,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<T,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<T,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<T,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<float,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<float,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<float,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<float,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<float,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<int,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<int,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<int,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<int,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<int,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<uint,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<uint,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<uint,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<uint,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<uint,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler2D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedSampler2D<T>.CalculateLevelOfDetail(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedSampler2D<T>.CalculateLevelOfDetailUnclamped(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler2D<T>.GetDimensions(
    out uint             width,
    out uint             height);
void RasterizerOrderedSampler2D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void RasterizerOrderedSampler2D<T>.GetDimensions(
    out float            width,
    out float            height);
void RasterizerOrderedSampler2D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2D<T>.Load(vector<int,2> location);
T RasterizerOrderedSampler2D<T>.Load(
    vector<int,2>        location,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedSampler2D<T>.Load(
    vector<int,2>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler2D<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2D<T>.Sample(vector<float,2> location);
/// See Availability 2
T RasterizerOrderedSampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
T RasterizerOrderedSampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp);
T RasterizerOrderedSampler2D<T>.Sample(
    vector<float,2>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.SampleBias`

## Signature 

```
T RasterizerOrderedSampler2D<T>.SampleBias(
    vector<float,2>      location,
    float                bias);
T RasterizerOrderedSampler2D<T>.SampleBias(
    vector<float,2>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedSampler2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
float RasterizerOrderedSampler2D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedSampler2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedSampler2D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,2>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T RasterizerOrderedSampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedSampler2D<T>.SampleGrad(
    vector<float,2>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2D<T>.SampleLevel(
    vector<float,2>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedSampler2D<T>.SampleLevel(
    vector<float,2>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler2D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler2D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2D.Gather(vector<float,2> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.Gather(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2D.GatherRed(vector<float,2> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.GatherRed(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2D.GatherGreen(vector<float,2> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.GatherGreen(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2D.GatherBlue(vector<float,2> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.GatherBlue(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2D.GatherAlpha(vector<float,2> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2D.GatherAlpha(
    vector<float,2>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Sampler2DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Sampler2DMS<T>.GetDimensions`

## Signature 

```
void Sampler2DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void Sampler2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Sampler2DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void Sampler2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler2DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Sampler2DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Sampler2DMS<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T Sampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T Sampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler2DMS<T>.subscript`

## Signature 

```
T Sampler2DMS<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWSampler2DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWSampler2DMS<T>.GetDimensions`

## Signature 

```
void RWSampler2DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void RWSampler2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWSampler2DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void RWSampler2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler2DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWSampler2DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWSampler2DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T RWSampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T RWSampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler2DMS<T>.subscript`

## Signature 

```
T RWSampler2DMS<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler2DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DMS<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler2DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void RasterizerOrderedSampler2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedSampler2DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void RasterizerOrderedSampler2DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedSampler2DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex);
T RasterizerOrderedSampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedSampler2DMS<T>.Load(
    vector<int,2>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DMS<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler2DMS<T>.subscript(vector<uint,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct Sampler2DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float Sampler2DArray<T>.CalculateLevelOfDetail(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Sampler2DArray<T>.CalculateLevelOfDetailUnclamped(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.GetDimensions`

## Signature 

```
void Sampler2DArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void Sampler2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void Sampler2DArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void Sampler2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler2DArray<T>.Load(vector<int,4> location);
T Sampler2DArray<T>.Load(
    vector<int,4>        location,
    vector<int,2>        offset);
/// See Availability 2
T Sampler2DArray<T>.Load(
    vector<int,4>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.subscript`

## Signature 

```
T Sampler2DArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T Sampler2DArray<T>.Sample(vector<float,3> location);
/// See Availability 2
T Sampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
T Sampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp);
T Sampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.SampleBias`

## Signature 

```
T Sampler2DArray<T>.SampleBias(
    vector<float,3>      location,
    float                bias);
T Sampler2DArray<T>.SampleBias(
    vector<float,3>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.SampleCmp`

## Signature 

```
float Sampler2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float Sampler2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Sampler2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float Sampler2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Sampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T Sampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T Sampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Sampler2DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Sampler2DArray<T>.SampleLevel(
    vector<float,3>      location,
    float                level);
/// See Availability 2
T Sampler2DArray<T>.SampleLevel(
    vector<float,3>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Sampler2DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<T,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<T,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<T,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<T,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<T,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<float,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<float,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<float,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<float,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<float,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<int,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<int,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<int,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<int,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<int,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<uint,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<uint,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<uint,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<uint,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<uint,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> Sampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWSampler2DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RWSampler2DArray<T>.CalculateLevelOfDetail(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWSampler2DArray<T>.CalculateLevelOfDetailUnclamped(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.GetDimensions`

## Signature 

```
void RWSampler2DArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void RWSampler2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void RWSampler2DArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void RWSampler2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler2DArray<T>.Load(vector<int,3> location);
/// See Availability 2
T RWSampler2DArray<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset);
/// See Availability 3
T RWSampler2DArray<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.subscript`

## Signature 

```
T RWSampler2DArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RWSampler2DArray<T>.Sample(vector<float,3> location);
/// See Availability 2
T RWSampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
T RWSampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp);
T RWSampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.SampleBias`

## Signature 

```
T RWSampler2DArray<T>.SampleBias(
    vector<float,3>      location,
    float                bias);
T RWSampler2DArray<T>.SampleBias(
    vector<float,3>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.SampleCmp`

## Signature 

```
float RWSampler2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float RWSampler2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWSampler2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float RWSampler2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWSampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T RWSampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T RWSampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWSampler2DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWSampler2DArray<T>.SampleLevel(
    vector<float,3>      location,
    float                level);
/// See Availability 2
T RWSampler2DArray<T>.SampleLevel(
    vector<float,3>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWSampler2DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<T,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<T,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<T,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<T,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<T,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<float,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<float,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<float,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<float,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<float,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<int,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<int,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<int,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<int,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<int,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<uint,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<uint,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<uint,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<uint,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<uint,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RWSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler2DArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedSampler2DArray<T>.CalculateLevelOfDetail(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedSampler2DArray<T>.CalculateLevelOfDetailUnclamped(vector<float,2> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler2DArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void RasterizerOrderedSampler2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void RasterizerOrderedSampler2DArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void RasterizerOrderedSampler2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2DArray<T>.Load(vector<int,3> location);
T RasterizerOrderedSampler2DArray<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedSampler2DArray<T>.Load(
    vector<int,3>        location,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler2DArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2DArray<T>.Sample(vector<float,3> location);
/// See Availability 2
T RasterizerOrderedSampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
T RasterizerOrderedSampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp);
T RasterizerOrderedSampler2DArray<T>.Sample(
    vector<float,3>      location,
    vector<int,2>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.SampleBias`

## Signature 

```
T RasterizerOrderedSampler2DArray<T>.SampleBias(
    vector<float,3>      location,
    float                bias);
T RasterizerOrderedSampler2DArray<T>.SampleBias(
    vector<float,3>      location,
    float                bias,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedSampler2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float RasterizerOrderedSampler2DArray<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedSampler2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedSampler2DArray<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY);
T RasterizerOrderedSampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedSampler2DArray<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,2>      gradX,
    vector<float,2>      gradY,
    vector<int,2>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2DArray<T>.SampleLevel(
    vector<float,3>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedSampler2DArray<T>.SampleLevel(
    vector<float,3>      location,
    float                level,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler2DArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<T,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<float,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<int,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler2DArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2DArray.Gather(vector<float,3> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.Gather(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2DArray.GatherRed(vector<float,3> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.GatherRed(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2DArray.GatherGreen(vector<float,3> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.GatherGreen(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2DArray.GatherBlue(vector<float,3> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.GatherBlue(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler2DArray.GatherAlpha(vector<float,3> location);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset,
    out uint             status);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4);
/// See Availability 3
vector<uint,4> RasterizerOrderedSampler2DArray.GatherAlpha(
    vector<float,3>      location,
    vector<int,2>        offset1,
    vector<int,2>        offset2,
    vector<int,2>        offset3,
    vector<int,2>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Sampler2DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Sampler2DMSArray<T>.GetDimensions`

## Signature 

```
void Sampler2DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void Sampler2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Sampler2DMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void Sampler2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler2DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Sampler2DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Sampler2DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T Sampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T Sampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler2DMSArray<T>.subscript`

## Signature 

```
T Sampler2DMSArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWSampler2DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWSampler2DMSArray<T>.GetDimensions`

## Signature 

```
void RWSampler2DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void RWSampler2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWSampler2DMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void RWSampler2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler2DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWSampler2DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWSampler2DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RWSampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T RWSampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler2DMSArray<T>.subscript`

## Signature 

```
T RWSampler2DMSArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler2DMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DMSArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler2DMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void RasterizerOrderedSampler2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedSampler2DMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void RasterizerOrderedSampler2DMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedSampler2DMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DMSArray<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RasterizerOrderedSampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset);
/// See Availability 2
T RasterizerOrderedSampler2DMSArray<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,2>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler2DMSArray<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler2DMSArray<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct Sampler3D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `Sampler3D<T>.CalculateLevelOfDetail`

## Signature 

```
float Sampler3D<T>.CalculateLevelOfDetail(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler3D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float Sampler3D<T>.CalculateLevelOfDetailUnclamped(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler3D<T>.GetDimensions`

## Signature 

```
void Sampler3D<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth);
void Sampler3D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             numberOfLevels);
void Sampler3D<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth);
void Sampler3D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler3D<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler3D<T>.Load(vector<int,4> location);
T Sampler3D<T>.Load(
    vector<int,4>        location,
    vector<int,3>        offset);
/// See Availability 2
T Sampler3D<T>.Load(
    vector<int,4>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler3D<T>.subscript`

## Signature 

```
T Sampler3D<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `Sampler3D<T>.Sample`

## Signature 

```
/// See Availability 1
T Sampler3D<T>.Sample(vector<float,3> location);
/// See Availability 2
T Sampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 3
T Sampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp);
T Sampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `Sampler3D<T>.SampleBias`

## Signature 

```
T Sampler3D<T>.SampleBias(
    vector<float,3>      location,
    float                bias);
T Sampler3D<T>.SampleBias(
    vector<float,3>      location,
    float                bias,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `Sampler3D<T>.SampleCmp`

## Signature 

```
float Sampler3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float Sampler3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler3D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float Sampler3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float Sampler3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `Sampler3D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T Sampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
T Sampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset);
/// See Availability 2
T Sampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `Sampler3D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T Sampler3D<T>.SampleLevel(
    vector<float,3>      location,
    float                level);
/// See Availability 2
T Sampler3D<T>.SampleLevel(
    vector<float,3>      location,
    float                level,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension Sampler3D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler3D.Gather(vector<float,3> location);
vector<T,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler3D.GatherRed(vector<float,3> location);
vector<T,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler3D.GatherGreen(vector<float,3> location);
vector<T,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler3D.GatherBlue(vector<float,3> location);
vector<T,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> Sampler3D.GatherAlpha(vector<float,3> location);
vector<T,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler3D.Gather(vector<float,3> location);
vector<float,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler3D.GatherRed(vector<float,3> location);
vector<float,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler3D.GatherGreen(vector<float,3> location);
vector<float,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler3D.GatherBlue(vector<float,3> location);
vector<float,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> Sampler3D.GatherAlpha(vector<float,3> location);
vector<float,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler3D.Gather(vector<float,3> location);
vector<int,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler3D.GatherRed(vector<float,3> location);
vector<int,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler3D.GatherGreen(vector<float,3> location);
vector<int,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler3D.GatherBlue(vector<float,3> location);
vector<int,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> Sampler3D.GatherAlpha(vector<float,3> location);
vector<int,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension Sampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `Sampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler3D.Gather(vector<float,3> location);
vector<uint,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Sampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler3D.GatherRed(vector<float,3> location);
vector<uint,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Sampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler3D.GatherGreen(vector<float,3> location);
vector<uint,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Sampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler3D.GatherBlue(vector<float,3> location);
vector<uint,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Sampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `Sampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> Sampler3D.GatherAlpha(vector<float,3> location);
vector<uint,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> Sampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RWSampler3D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.CalculateLevelOfDetail`

## Signature 

```
float RWSampler3D<T>.CalculateLevelOfDetail(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RWSampler3D<T>.CalculateLevelOfDetailUnclamped(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.GetDimensions`

## Signature 

```
void RWSampler3D<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth);
void RWSampler3D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             numberOfLevels);
void RWSampler3D<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth);
void RWSampler3D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler3D<T>.Load(vector<int,3> location);
/// See Availability 2
T RWSampler3D<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset);
/// See Availability 3
T RWSampler3D<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** **CUDA** 
2. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.subscript`

## Signature 

```
T RWSampler3D<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.Sample`

## Signature 

```
/// See Availability 1
T RWSampler3D<T>.Sample(vector<float,3> location);
/// See Availability 2
T RWSampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 3
T RWSampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp);
T RWSampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.SampleBias`

## Signature 

```
T RWSampler3D<T>.SampleBias(
    vector<float,3>      location,
    float                bias);
T RWSampler3D<T>.SampleBias(
    vector<float,3>      location,
    float                bias,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.SampleCmp`

## Signature 

```
float RWSampler3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float RWSampler3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RWSampler3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float RWSampler3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RWSampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
T RWSampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset);
/// See Availability 2
T RWSampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RWSampler3D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RWSampler3D<T>.SampleLevel(
    vector<float,3>      location,
    float                level);
/// See Availability 2
T RWSampler3D<T>.SampleLevel(
    vector<float,3>      location,
    float                level,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RWSampler3D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler3D.Gather(vector<float,3> location);
vector<T,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler3D.GatherRed(vector<float,3> location);
vector<T,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler3D.GatherGreen(vector<float,3> location);
vector<T,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler3D.GatherBlue(vector<float,3> location);
vector<T,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RWSampler3D.GatherAlpha(vector<float,3> location);
vector<T,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler3D.Gather(vector<float,3> location);
vector<float,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler3D.GatherRed(vector<float,3> location);
vector<float,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler3D.GatherGreen(vector<float,3> location);
vector<float,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler3D.GatherBlue(vector<float,3> location);
vector<float,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RWSampler3D.GatherAlpha(vector<float,3> location);
vector<float,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler3D.Gather(vector<float,3> location);
vector<int,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler3D.GatherRed(vector<float,3> location);
vector<int,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler3D.GatherGreen(vector<float,3> location);
vector<int,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler3D.GatherBlue(vector<float,3> location);
vector<int,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RWSampler3D.GatherAlpha(vector<float,3> location);
vector<int,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RWSampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RWSampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler3D.Gather(vector<float,3> location);
vector<uint,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler3D.GatherRed(vector<float,3> location);
vector<uint,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler3D.GatherGreen(vector<float,3> location);
vector<uint,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler3D.GatherBlue(vector<float,3> location);
vector<uint,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RWSampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RWSampler3D.GatherAlpha(vector<float,3> location);
vector<uint,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RWSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler3D<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `subscript`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedSampler3D<T>.CalculateLevelOfDetail(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedSampler3D<T>.CalculateLevelOfDetailUnclamped(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler3D<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth);
void RasterizerOrderedSampler3D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             numberOfLevels);
void RasterizerOrderedSampler3D<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth);
void RasterizerOrderedSampler3D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler3D<T>.Load(vector<int,3> location);
T RasterizerOrderedSampler3D<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedSampler3D<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler3D<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler3D<T>.Sample(vector<float,3> location);
/// See Availability 2
T RasterizerOrderedSampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 3
T RasterizerOrderedSampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp);
T RasterizerOrderedSampler3D<T>.Sample(
    vector<float,3>      location,
    vector<int,3>        offset,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `location`
* `offset`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.SampleBias`

## Signature 

```
T RasterizerOrderedSampler3D<T>.SampleBias(
    vector<float,3>      location,
    float                bias);
T RasterizerOrderedSampler3D<T>.SampleBias(
    vector<float,3>      location,
    float                bias,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedSampler3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
float RasterizerOrderedSampler3D<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.SampleCmpLevelZero`

## Signature 

```
/// See Availability 1
float RasterizerOrderedSampler3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
/// See Availability 2
float RasterizerOrderedSampler3D<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`
* `offset`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.SampleGrad`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
T RasterizerOrderedSampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedSampler3D<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY,
    vector<int,3>        offset,
    float                lodClamp);
```

## Availability

1. **GLSL** **HLSL** 
2. **GLSL** `GL_ARB_sparse_texture_clamp` **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`
* `offset`
* `lodClamp`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D<T>.SampleLevel`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler3D<T>.SampleLevel(
    vector<float,3>      location,
    float                level);
/// See Availability 2
T RasterizerOrderedSampler3D<T>.SampleLevel(
    vector<float,3>      location,
    float                level,
    vector<int,3>        offset);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `location`
* `level`
* `offset`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler3D`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.Gather(vector<float,3> location);
vector<T,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.GatherRed(vector<float,3> location);
vector<T,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.GatherGreen(vector<float,3> location);
vector<T,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.GatherBlue(vector<float,3> location);
vector<T,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.GatherAlpha(vector<float,3> location);
vector<T,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.Gather(vector<float,3> location);
vector<float,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.GatherRed(vector<float,3> location);
vector<float,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.GatherGreen(vector<float,3> location);
vector<float,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.GatherBlue(vector<float,3> location);
vector<float,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.GatherAlpha(vector<float,3> location);
vector<float,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.Gather(vector<float,3> location);
vector<int,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.GatherRed(vector<float,3> location);
vector<int,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.GatherGreen(vector<float,3> location);
vector<int,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.GatherBlue(vector<float,3> location);
vector<int,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.GatherAlpha(vector<float,3> location);
vector<int,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSampler3D`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.Gather(vector<float,3> location);
vector<uint,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.GatherRed(vector<float,3> location);
vector<uint,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.GatherGreen(vector<float,3> location);
vector<uint,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.GatherBlue(vector<float,3> location);
vector<uint,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3D.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.GatherAlpha(vector<float,3> location);
vector<uint,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSampler3D.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct Sampler3DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Sampler3DMS<T>.GetDimensions`

## Signature 

```
void Sampler3DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount);
void Sampler3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount,
    out uint             numberOfLevels);
void Sampler3DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount);
void Sampler3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `Sampler3DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> Sampler3DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `Sampler3DMS<T>.Load`

## Signature 

```
/// See Availability 1
T Sampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T Sampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T Sampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `Sampler3DMS<T>.subscript`

## Signature 

```
T Sampler3DMS<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RWSampler3DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWSampler3DMS<T>.GetDimensions`

## Signature 

```
void RWSampler3DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount);
void RWSampler3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RWSampler3DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount);
void RWSampler3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RWSampler3DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RWSampler3DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RWSampler3DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RWSampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RWSampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T RWSampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RWSampler3DMS<T>.subscript`

## Signature 

```
T RWSampler3DMS<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSampler3DMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3DMS<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSampler3DMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount);
void RasterizerOrderedSampler3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             depth,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedSampler3DMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount);
void RasterizerOrderedSampler3DMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            depth,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `depth`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3DMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedSampler3DMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3DMS<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RasterizerOrderedSampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedSampler3DMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSampler3DMS<T>.subscript`

## Signature 

```
T RasterizerOrderedSampler3DMS<T>.subscript(vector<uint,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `struct SamplerCube<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `SamplerCube<T>.CalculateLevelOfDetail`

## Signature 

```
float SamplerCube<T>.CalculateLevelOfDetail(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `SamplerCube<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float SamplerCube<T>.CalculateLevelOfDetailUnclamped(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `SamplerCube<T>.GetDimensions`

## Signature 

```
void SamplerCube<T>.GetDimensions(
    out uint             width,
    out uint             height);
void SamplerCube<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void SamplerCube<T>.GetDimensions(
    out float            width,
    out float            height);
void SamplerCube<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `SamplerCube<T>.Load`

## Signature 

```
/// See Availability 1
T SamplerCube<T>.Load(vector<int,4> location);
T SamplerCube<T>.Load(
    vector<int,4>        location,
    vector<int,3>        offset);
/// See Availability 2
T SamplerCube<T>.Load(
    vector<int,4>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `SamplerCube<T>.Sample`

## Signature 

```
/// See Availability 1
T SamplerCube<T>.Sample(vector<float,3> location);
/// See Availability 2
T SamplerCube<T>.Sample(
    vector<float,3>      location,
    float                clamp);
T SamplerCube<T>.Sample(
    vector<float,3>      location,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `location`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `SamplerCube<T>.SampleBias`

## Signature 

```
T SamplerCube<T>.SampleBias(
    vector<float,3>      location,
    float                bias);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`

--------------------------------------------------------------------------------
# `SamplerCube<T>.SampleCmp`

## Signature 

```
float SamplerCube<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`

--------------------------------------------------------------------------------
# `SamplerCube<T>.SampleCmpLevelZero`

## Signature 

```
float SamplerCube<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`

--------------------------------------------------------------------------------
# `SamplerCube<T>.SampleGrad`

## Signature 

```
T SamplerCube<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`

--------------------------------------------------------------------------------
# `SamplerCube<T>.SampleLevel`

## Signature 

```
T SamplerCube<T>.SampleLevel(
    vector<float,3>      location,
    float                level);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `location`
* `level`

--------------------------------------------------------------------------------
# `extension SamplerCube`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `SamplerCube.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCube.Gather(vector<float,3> location);
vector<T,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCube.GatherRed(vector<float,3> location);
vector<T,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCube.GatherGreen(vector<float,3> location);
vector<T,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCube.GatherBlue(vector<float,3> location);
vector<T,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCube.GatherAlpha(vector<float,3> location);
vector<T,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension SamplerCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `SamplerCube.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCube.Gather(vector<float,3> location);
vector<float,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCube.GatherRed(vector<float,3> location);
vector<float,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCube.GatherGreen(vector<float,3> location);
vector<float,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCube.GatherBlue(vector<float,3> location);
vector<float,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCube.GatherAlpha(vector<float,3> location);
vector<float,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension SamplerCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `SamplerCube.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCube.Gather(vector<float,3> location);
vector<int,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCube.GatherRed(vector<float,3> location);
vector<int,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCube.GatherGreen(vector<float,3> location);
vector<int,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCube.GatherBlue(vector<float,3> location);
vector<int,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCube.GatherAlpha(vector<float,3> location);
vector<int,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension SamplerCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `SamplerCube.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCube.Gather(vector<float,3> location);
vector<uint,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCube.GatherRed(vector<float,3> location);
vector<uint,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCube.GatherGreen(vector<float,3> location);
vector<uint,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCube.GatherBlue(vector<float,3> location);
vector<uint,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCube.GatherAlpha(vector<float,3> location);
vector<uint,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSamplerCube<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Load`
* `Sample`
* `SampleBias`
* `SampleCmp`
* `SampleCmpLevelZero`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedSamplerCube<T>.CalculateLevelOfDetail(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedSamplerCube<T>.CalculateLevelOfDetailUnclamped(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSamplerCube<T>.GetDimensions(
    out uint             width,
    out uint             height);
void RasterizerOrderedSamplerCube<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void RasterizerOrderedSamplerCube<T>.GetDimensions(
    out float            width,
    out float            height);
void RasterizerOrderedSamplerCube<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSamplerCube<T>.Load(vector<int,3> location);
T RasterizerOrderedSamplerCube<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedSamplerCube<T>.Load(
    vector<int,3>        location,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSamplerCube<T>.Sample(vector<float,3> location);
/// See Availability 2
T RasterizerOrderedSamplerCube<T>.Sample(
    vector<float,3>      location,
    float                clamp);
T RasterizerOrderedSamplerCube<T>.Sample(
    vector<float,3>      location,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `location`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.SampleBias`

## Signature 

```
T RasterizerOrderedSamplerCube<T>.SampleBias(
    vector<float,3>      location,
    float                bias);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.SampleCmp`

## Signature 

```
float RasterizerOrderedSamplerCube<T>.SampleCmp(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.SampleCmpLevelZero`

## Signature 

```
float RasterizerOrderedSamplerCube<T>.SampleCmpLevelZero(
    SamplerComparisonState s,
    vector<float,3>      location,
    float                compareValue);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `s`
* `location`
* `compareValue`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.SampleGrad`

## Signature 

```
T RasterizerOrderedSamplerCube<T>.SampleGrad(
    vector<float,3>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube<T>.SampleLevel`

## Signature 

```
T RasterizerOrderedSamplerCube<T>.SampleLevel(
    vector<float,3>      location,
    float                level);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `location`
* `level`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSamplerCube`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.Gather(vector<float,3> location);
vector<T,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.GatherRed(vector<float,3> location);
vector<T,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.GatherGreen(vector<float,3> location);
vector<T,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.GatherBlue(vector<float,3> location);
vector<T,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.GatherAlpha(vector<float,3> location);
vector<T,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSamplerCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.Gather(vector<float,3> location);
vector<float,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.GatherRed(vector<float,3> location);
vector<float,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.GatherGreen(vector<float,3> location);
vector<float,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.GatherBlue(vector<float,3> location);
vector<float,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.GatherAlpha(vector<float,3> location);
vector<float,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSamplerCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.Gather(vector<float,3> location);
vector<int,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.GatherRed(vector<float,3> location);
vector<int,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.GatherGreen(vector<float,3> location);
vector<int,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.GatherBlue(vector<float,3> location);
vector<int,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.GatherAlpha(vector<float,3> location);
vector<int,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSamplerCube`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.Gather(vector<float,3> location);
vector<uint,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.Gather(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.GatherRed(vector<float,3> location);
vector<uint,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.GatherRed(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.GatherGreen(vector<float,3> location);
vector<uint,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.GatherGreen(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.GatherBlue(vector<float,3> location);
vector<uint,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.GatherBlue(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCube.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.GatherAlpha(vector<float,3> location);
vector<uint,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCube.GatherAlpha(
    vector<float,3>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct SamplerCubeMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`

--------------------------------------------------------------------------------
# `SamplerCubeMS<T>.GetDimensions`

## Signature 

```
void SamplerCubeMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void SamplerCubeMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void SamplerCubeMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void SamplerCubeMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `SamplerCubeMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> SamplerCubeMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `SamplerCubeMS<T>.Load`

## Signature 

```
/// See Availability 1
T SamplerCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T SamplerCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T SamplerCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSamplerCubeMS<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`
* `Load`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeMS<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSamplerCubeMS<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             sampleCount);
void RasterizerOrderedSamplerCubeMS<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedSamplerCubeMS<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            sampleCount);
void RasterizerOrderedSamplerCubeMS<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeMS<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedSamplerCubeMS<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeMS<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSamplerCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex);
T RasterizerOrderedSamplerCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset);
/// See Availability 2
T RasterizerOrderedSamplerCubeMS<T>.Load(
    vector<int,3>        location,
    int                  sampleIndex,
    vector<int,3>        offset,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `sampleIndex`
* `offset`
* `status`

--------------------------------------------------------------------------------
# `struct SamplerCubeArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Sample`
* `SampleBias`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `SamplerCubeArray<T>.CalculateLevelOfDetail`

## Signature 

```
float SamplerCubeArray<T>.CalculateLevelOfDetail(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `SamplerCubeArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float SamplerCubeArray<T>.CalculateLevelOfDetailUnclamped(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `SamplerCubeArray<T>.GetDimensions`

## Signature 

```
void SamplerCubeArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void SamplerCubeArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void SamplerCubeArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void SamplerCubeArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `SamplerCubeArray<T>.Sample`

## Signature 

```
/// See Availability 1
T SamplerCubeArray<T>.Sample(vector<float,4> location);
/// See Availability 2
T SamplerCubeArray<T>.Sample(
    vector<float,4>      location,
    float                clamp);
T SamplerCubeArray<T>.Sample(
    vector<float,4>      location,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `location`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `SamplerCubeArray<T>.SampleBias`

## Signature 

```
T SamplerCubeArray<T>.SampleBias(
    vector<float,4>      location,
    float                bias);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`

--------------------------------------------------------------------------------
# `SamplerCubeArray<T>.SampleGrad`

## Signature 

```
T SamplerCubeArray<T>.SampleGrad(
    vector<float,4>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`

--------------------------------------------------------------------------------
# `SamplerCubeArray<T>.SampleLevel`

## Signature 

```
T SamplerCubeArray<T>.SampleLevel(
    vector<float,4>      location,
    float                level);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `location`
* `level`

--------------------------------------------------------------------------------
# `extension SamplerCubeArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `SamplerCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCubeArray.Gather(vector<float,4> location);
vector<T,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCubeArray.GatherRed(vector<float,4> location);
vector<T,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCubeArray.GatherGreen(vector<float,4> location);
vector<T,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCubeArray.GatherBlue(vector<float,4> location);
vector<T,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> SamplerCubeArray.GatherAlpha(vector<float,4> location);
vector<T,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension SamplerCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `SamplerCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCubeArray.Gather(vector<float,4> location);
vector<float,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCubeArray.GatherRed(vector<float,4> location);
vector<float,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCubeArray.GatherGreen(vector<float,4> location);
vector<float,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCubeArray.GatherBlue(vector<float,4> location);
vector<float,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> SamplerCubeArray.GatherAlpha(vector<float,4> location);
vector<float,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension SamplerCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `SamplerCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCubeArray.Gather(vector<float,4> location);
vector<int,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCubeArray.GatherRed(vector<float,4> location);
vector<int,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCubeArray.GatherGreen(vector<float,4> location);
vector<int,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCubeArray.GatherBlue(vector<float,4> location);
vector<int,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> SamplerCubeArray.GatherAlpha(vector<float,4> location);
vector<int,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension SamplerCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `SamplerCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCubeArray.Gather(vector<float,4> location);
vector<uint,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCubeArray.GatherRed(vector<float,4> location);
vector<uint,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCubeArray.GatherGreen(vector<float,4> location);
vector<uint,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCubeArray.GatherBlue(vector<float,4> location);
vector<uint,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `SamplerCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> SamplerCubeArray.GatherAlpha(vector<float,4> location);
vector<uint,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> SamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSamplerCubeArray<T>`

## Generic Parameters

* `T`

## Methods

* `CalculateLevelOfDetail`
* `CalculateLevelOfDetailUnclamped`
* `GetDimensions`
* `Sample`
* `SampleBias`
* `SampleGrad`
* `SampleLevel`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray<T>.CalculateLevelOfDetail`

## Signature 

```
float RasterizerOrderedSamplerCubeArray<T>.CalculateLevelOfDetail(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray<T>.CalculateLevelOfDetailUnclamped`

## Signature 

```
float RasterizerOrderedSamplerCubeArray<T>.CalculateLevelOfDetailUnclamped(vector<float,3> location);
```

## Parameters

* `location`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSamplerCubeArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void RasterizerOrderedSamplerCubeArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void RasterizerOrderedSamplerCubeArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void RasterizerOrderedSamplerCubeArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray<T>.Sample`

## Signature 

```
/// See Availability 1
T RasterizerOrderedSamplerCubeArray<T>.Sample(vector<float,4> location);
/// See Availability 2
T RasterizerOrderedSamplerCubeArray<T>.Sample(
    vector<float,4>      location,
    float                clamp);
T RasterizerOrderedSamplerCubeArray<T>.Sample(
    vector<float,4>      location,
    float                clamp,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `location`
* `clamp`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray<T>.SampleBias`

## Signature 

```
T RasterizerOrderedSamplerCubeArray<T>.SampleBias(
    vector<float,4>      location,
    float                bias);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `bias`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray<T>.SampleGrad`

## Signature 

```
T RasterizerOrderedSamplerCubeArray<T>.SampleGrad(
    vector<float,4>      location,
    vector<float,3>      gradX,
    vector<float,3>      gradY);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `location`
* `gradX`
* `gradY`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray<T>.SampleLevel`

## Signature 

```
T RasterizerOrderedSamplerCubeArray<T>.SampleLevel(
    vector<float,4>      location,
    float                level);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `location`
* `level`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSamplerCubeArray`

## Generic Parameters

* `T`
* `N`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.Gather(vector<float,4> location);
vector<T,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherRed(vector<float,4> location);
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherGreen(vector<float,4> location);
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherBlue(vector<float,4> location);
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(vector<float,4> location);
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<T,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSamplerCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.Gather(vector<float,4> location);
vector<float,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherRed(vector<float,4> location);
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherGreen(vector<float,4> location);
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherBlue(vector<float,4> location);
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(vector<float,4> location);
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<float,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSamplerCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.Gather(vector<float,4> location);
vector<int,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherRed(vector<float,4> location);
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherGreen(vector<float,4> location);
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherBlue(vector<float,4> location);
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(vector<float,4> location);
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<int,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `extension RasterizerOrderedSamplerCubeArray`

## Methods

* `Gather`
* `GatherRed`
* `GatherGreen`
* `GatherBlue`
* `GatherAlpha`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.Gather`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.Gather(vector<float,4> location);
vector<uint,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.Gather(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherRed`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherRed(vector<float,4> location);
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherRed(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherGreen`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherGreen(vector<float,4> location);
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherGreen(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherBlue`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherBlue(vector<float,4> location);
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherBlue(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeArray.GatherAlpha`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(vector<float,4> location);
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset,
    out uint             status);
/// See Availability 1
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4);
/// See Availability 2
vector<uint,4> RasterizerOrderedSamplerCubeArray.GatherAlpha(
    vector<float,4>      location,
    vector<int,3>        offset1,
    vector<int,3>        offset2,
    vector<int,3>        offset3,
    vector<int,3>        offset4,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `offset`
* `status`
* `offset1`
* `offset2`
* `offset3`
* `offset4`

--------------------------------------------------------------------------------
# `struct SamplerCubeMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`

--------------------------------------------------------------------------------
# `SamplerCubeMSArray<T>.GetDimensions`

## Signature 

```
void SamplerCubeMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void SamplerCubeMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void SamplerCubeMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void SamplerCubeMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `SamplerCubeMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> SamplerCubeMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedSamplerCubeMSArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `GetSamplePosition`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeMSArray<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedSamplerCubeMSArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount);
void RasterizerOrderedSamplerCubeMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             sampleCount,
    out uint             numberOfLevels);
void RasterizerOrderedSamplerCubeMSArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount);
void RasterizerOrderedSamplerCubeMSArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            sampleCount,
    out float            numberOfLevels);
```

## Availability

**GLSL** `GLSL450`, `GL_EXT_samplerless_texture_functions` **HLSL** 

## Parameters

* `width`
* `height`
* `elements`
* `sampleCount`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `RasterizerOrderedSamplerCubeMSArray<T>.GetSamplePosition`

## Signature 

```
vector<float,2> RasterizerOrderedSamplerCubeMSArray<T>.GetSamplePosition(int s);
```

## Parameters

* `s`

--------------------------------------------------------------------------------
# `bit_cast`

## Signature 

```
T bit_cast<T, U>(U value);
```

## Parameters

* `T`
* `U`
* `value`

--------------------------------------------------------------------------------
# `createDynamicObject`

## Signature 

```
T createDynamicObject<T, U>(
    uint                 typeId,
    U                    value);
```

## Parameters

* `T`
* `U`
* `typeId`
* `value`

--------------------------------------------------------------------------------
# `reinterpret`

## Signature 

```
T reinterpret<T, U>(U value);
```

## Parameters

* `T`
* `U`
* `value`

--------------------------------------------------------------------------------
# `getStringHash`

## Description

Given a string returns an integer hash of that string.

## Signature 

```
int getStringHash(String string);
```

## Parameters

* `string`

--------------------------------------------------------------------------------
# `beginInvocationInterlock`

## Description

Mark beginning of "interlocked" operations in a fragment shader.

## Signature 

```
void beginInvocationInterlock();
```

## Availability

**GLSL** `GLSL420`, `GL_ARB_fragment_shader_interlock` **HLSL** 

--------------------------------------------------------------------------------
# `endInvocationInterlock`

## Description

Mark end of "interlocked" operations in a fragment shader.

## Signature 

```
void endInvocationInterlock();
```

## Availability

**GLSL** `GLSL420`, `GL_ARB_fragment_shader_interlock` **HLSL** 

--------------------------------------------------------------------------------
# enum _AttributeTargets

## Values 

* _Struct_
* _Var_
* _Function_
--------------------------------------------------------------------------------
# `struct AppendStructuredBuffer<T>`

## Generic Parameters

* `T`

## Methods

* `Append`
* `GetDimensions`

--------------------------------------------------------------------------------
# `AppendStructuredBuffer<T>.Append`

## Signature 

```
void AppendStructuredBuffer<T>.Append(T value);
```

## Parameters

* `value`

--------------------------------------------------------------------------------
# `AppendStructuredBuffer<T>.GetDimensions`

## Signature 

```
void AppendStructuredBuffer<T>.GetDimensions(
    out uint             numStructs,
    out uint             stride);
```

## Parameters

* `numStructs`
* `stride`

--------------------------------------------------------------------------------
# `struct ByteAddressBuffer`

## Methods

* `GetDimensions`
* `Load2`
* `Load3`
* `Load4`

--------------------------------------------------------------------------------
# `ByteAddressBuffer.GetDimensions`

## Signature 

```
void ByteAddressBuffer.GetDimensions(out uint dim);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dim`

--------------------------------------------------------------------------------
# `ByteAddressBuffer.Load2`

## Signature 

```
/// See Availability 1
vector<uint,2> ByteAddressBuffer.Load2(int location);
/// See Availability 2
vector<uint,2> ByteAddressBuffer.Load2(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `ByteAddressBuffer.Load3`

## Signature 

```
/// See Availability 1
vector<uint,3> ByteAddressBuffer.Load3(int location);
/// See Availability 2
vector<uint,3> ByteAddressBuffer.Load3(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `ByteAddressBuffer.Load4`

## Signature 

```
/// See Availability 1
vector<uint,4> ByteAddressBuffer.Load4(int location);
/// See Availability 2
vector<uint,4> ByteAddressBuffer.Load4(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `ByteAddressBuffer.Load`

## Signature 

```
/// See Availability 1
uint ByteAddressBuffer.Load(int location);
/// See Availability 2
uint ByteAddressBuffer.Load(
    int                  location,
    out uint             status);
T ByteAddressBuffer.Load<T>(int location);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `location`
* `status`

--------------------------------------------------------------------------------
# `struct StructuredBuffer<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `StructuredBuffer<T>.GetDimensions`

## Signature 

```
void StructuredBuffer<T>.GetDimensions(
    out uint             numStructs,
    out uint             stride);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `numStructs`
* `stride`

--------------------------------------------------------------------------------
# `StructuredBuffer<T>.Load`

## Signature 

```
/// See Availability 1
T StructuredBuffer<T>.Load(int location);
/// See Availability 2
T StructuredBuffer<T>.Load(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `StructuredBuffer<T>.subscript`

## Signature 

```
T StructuredBuffer<T>.subscript(uint index);
```

## Parameters

* `index`

--------------------------------------------------------------------------------
# `struct ConsumeStructuredBuffer<T>`

## Generic Parameters

* `T`

## Methods

* `Consume`
* `GetDimensions`

--------------------------------------------------------------------------------
# `ConsumeStructuredBuffer<T>.Consume`

## Signature 

```
T ConsumeStructuredBuffer<T>.Consume();
```

--------------------------------------------------------------------------------
# `ConsumeStructuredBuffer<T>.GetDimensions`

## Signature 

```
void ConsumeStructuredBuffer<T>.GetDimensions(
    out uint             numStructs,
    out uint             stride);
```

## Parameters

* `numStructs`
* `stride`

--------------------------------------------------------------------------------
# `struct InputPatch<T, N:int>`

## Generic Parameters

* `T`
* `N`

## Methods

* `subscript`

--------------------------------------------------------------------------------
# `InputPatch<T, N:int>.subscript`

## Signature 

```
T InputPatch<T, N:int>.subscript(uint index);
```

## Parameters

* `index`

--------------------------------------------------------------------------------
# `struct OutputPatch<T, N:int>`

## Generic Parameters

* `T`
* `N`

## Methods

* `subscript`

--------------------------------------------------------------------------------
# `OutputPatch<T, N:int>.subscript`

## Signature 

```
T OutputPatch<T, N:int>.subscript(uint index);
```

## Parameters

* `index`

--------------------------------------------------------------------------------
# `struct RWByteAddressBuffer`

## Methods

* `GetDimensions`
* `Load2`
* `Load3`
* `Load4`
* `InterlockedAddF32`
* `InterlockedAddI64`
* `InterlockedCompareExchangeU64`
* `InterlockedMaxU64`
* `InterlockedMinU64`
* `InterlockedAndU64`
* `InterlockedOrU64`
* `InterlockedXorU64`
* `InterlockedExchangeU64`
* `InterlockedAdd64`
* `InterlockedCompareExchange64`
* `InterlockedAdd`
* `InterlockedAnd`
* `InterlockedCompareExchange`
* `InterlockedCompareStore`
* `InterlockedExchange`
* `InterlockedMax`
* `InterlockedMin`
* `InterlockedOr`
* `InterlockedXor`
* `Store2`
* `Store3`
* `Store4`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.GetDimensions`

## Signature 

```
void RWByteAddressBuffer.GetDimensions(out uint dim);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dim`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.Load2`

## Signature 

```
/// See Availability 1
vector<uint,2> RWByteAddressBuffer.Load2(int location);
/// See Availability 2
vector<uint,2> RWByteAddressBuffer.Load2(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.Load3`

## Signature 

```
/// See Availability 1
vector<uint,3> RWByteAddressBuffer.Load3(int location);
/// See Availability 2
vector<uint,3> RWByteAddressBuffer.Load3(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.Load4`

## Signature 

```
/// See Availability 1
vector<uint,4> RWByteAddressBuffer.Load4(int location);
/// See Availability 2
vector<uint,4> RWByteAddressBuffer.Load4(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.Load`

## Signature 

```
/// See Availability 1
uint RWByteAddressBuffer.Load(int location);
/// See Availability 2
uint RWByteAddressBuffer.Load(
    int                  location,
    out uint             status);
T RWByteAddressBuffer.Load<T>(int location);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `location`
* `status`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedAddF32`

## Signature 

```
void RWByteAddressBuffer.InterlockedAddF32(
    uint                 byteAddress,
    float                valueToAdd,
    out float            originalValue);
void RWByteAddressBuffer.InterlockedAddF32(
    uint                 byteAddress,
    float                valueToAdd);
```

## Availability

**HLSL** `NVAPI` **CUDA** `SM 2.0` 

## Parameters

* `byteAddress`
* `valueToAdd`
* `originalValue`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedAddI64`

## Signature 

```
void RWByteAddressBuffer.InterlockedAddI64(
    uint                 byteAddress,
    int64_t              valueToAdd,
    out int64_t          originalValue);
void RWByteAddressBuffer.InterlockedAddI64(
    uint                 byteAddress,
    int64_t              valueToAdd);
```

## Availability

**HLSL** **CUDA** `SM 6.0` 

## Parameters

* `byteAddress`
* `valueToAdd`
* `originalValue`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedCompareExchangeU64`

## Signature 

```
void RWByteAddressBuffer.InterlockedCompareExchangeU64(
    uint                 byteAddress,
    uint64_t             compareValue,
    uint64_t             value,
    out uint64_t         outOriginalValue);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `byteAddress`
* `compareValue`
* `value`
* `outOriginalValue`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedMaxU64`

## Signature 

```
uint64_t RWByteAddressBuffer.InterlockedMaxU64(
    uint                 byteAddress,
    uint64_t             value);
```

## Availability

**HLSL** **CUDA** `SM 3.5` 

## Parameters

* `byteAddress`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedMinU64`

## Signature 

```
uint64_t RWByteAddressBuffer.InterlockedMinU64(
    uint                 byteAddress,
    uint64_t             value);
```

## Availability

**HLSL** **CUDA** `SM 3.5` 

## Parameters

* `byteAddress`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedAndU64`

## Signature 

```
uint64_t RWByteAddressBuffer.InterlockedAndU64(
    uint                 byteAddress,
    uint64_t             value);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `byteAddress`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedOrU64`

## Signature 

```
uint64_t RWByteAddressBuffer.InterlockedOrU64(
    uint                 byteAddress,
    uint64_t             value);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `byteAddress`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedXorU64`

## Signature 

```
uint64_t RWByteAddressBuffer.InterlockedXorU64(
    uint                 byteAddress,
    uint64_t             value);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `byteAddress`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedExchangeU64`

## Signature 

```
uint64_t RWByteAddressBuffer.InterlockedExchangeU64(
    uint                 byteAddress,
    uint64_t             value);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `byteAddress`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedAdd64`

## Signature 

```
void RWByteAddressBuffer.InterlockedAdd64(
    uint                 byteAddress,
    int64_t              valueToAdd,
    out int64_t          outOriginalValue);
void RWByteAddressBuffer.InterlockedAdd64(
    uint                 byteAddress,
    uint64_t             valueToAdd,
    out uint64_t         outOriginalValue);
```

## Parameters

* `byteAddress`
* `valueToAdd`
* `outOriginalValue`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedCompareExchange64`

## Signature 

```
void RWByteAddressBuffer.InterlockedCompareExchange64(
    uint                 byteAddress,
    int64_t              compareValue,
    int64_t              value,
    out int64_t          outOriginalValue);
void RWByteAddressBuffer.InterlockedCompareExchange64(
    uint                 byteAddress,
    uint64_t             compareValue,
    uint64_t             value,
    out uint64_t         outOriginalValue);
```

## Parameters

* `byteAddress`
* `compareValue`
* `value`
* `outOriginalValue`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedAdd`

## Signature 

```
void RWByteAddressBuffer.InterlockedAdd(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RWByteAddressBuffer.InterlockedAdd(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedAnd`

## Signature 

```
void RWByteAddressBuffer.InterlockedAnd(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RWByteAddressBuffer.InterlockedAnd(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedCompareExchange`

## Signature 

```
void RWByteAddressBuffer.InterlockedCompareExchange(
    uint                 dest,
    uint                 compare_value,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `compare_value`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedCompareStore`

## Signature 

```
void RWByteAddressBuffer.InterlockedCompareStore(
    uint                 dest,
    uint                 compare_value,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `compare_value`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedExchange`

## Signature 

```
void RWByteAddressBuffer.InterlockedExchange(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedMax`

## Signature 

```
void RWByteAddressBuffer.InterlockedMax(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RWByteAddressBuffer.InterlockedMax(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedMin`

## Signature 

```
void RWByteAddressBuffer.InterlockedMin(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RWByteAddressBuffer.InterlockedMin(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedOr`

## Signature 

```
void RWByteAddressBuffer.InterlockedOr(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RWByteAddressBuffer.InterlockedOr(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.InterlockedXor`

## Signature 

```
void RWByteAddressBuffer.InterlockedXor(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RWByteAddressBuffer.InterlockedXor(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.Store2`

## Signature 

```
void RWByteAddressBuffer.Store2(
    uint                 address,
    vector<uint,2>       value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `address`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.Store3`

## Signature 

```
void RWByteAddressBuffer.Store3(
    uint                 address,
    vector<uint,3>       value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `address`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.Store4`

## Signature 

```
void RWByteAddressBuffer.Store4(
    uint                 address,
    vector<uint,4>       value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `address`
* `value`

--------------------------------------------------------------------------------
# `RWByteAddressBuffer.Store`

## Signature 

```
/// See Availability 1
void RWByteAddressBuffer.Store(
    uint                 address,
    uint                 value);
/// See Availability 2
void RWByteAddressBuffer.Store<T>(
    int                  offset,
    T                    value);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `address`
* `value`
* `offset`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedByteAddressBuffer`

## Methods

* `GetDimensions`
* `Load2`
* `Load3`
* `Load4`
* `InterlockedAdd`
* `InterlockedAnd`
* `InterlockedCompareExchange`
* `InterlockedCompareStore`
* `InterlockedExchange`
* `InterlockedMax`
* `InterlockedMin`
* `InterlockedOr`
* `InterlockedXor`
* `Store2`
* `Store3`
* `Store4`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.GetDimensions`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.GetDimensions(out uint dim);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dim`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.Load2`

## Signature 

```
/// See Availability 1
vector<uint,2> RasterizerOrderedByteAddressBuffer.Load2(int location);
/// See Availability 2
vector<uint,2> RasterizerOrderedByteAddressBuffer.Load2(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.Load3`

## Signature 

```
/// See Availability 1
vector<uint,3> RasterizerOrderedByteAddressBuffer.Load3(int location);
/// See Availability 2
vector<uint,3> RasterizerOrderedByteAddressBuffer.Load3(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.Load4`

## Signature 

```
/// See Availability 1
vector<uint,4> RasterizerOrderedByteAddressBuffer.Load4(int location);
/// See Availability 2
vector<uint,4> RasterizerOrderedByteAddressBuffer.Load4(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.Load`

## Signature 

```
/// See Availability 1
uint RasterizerOrderedByteAddressBuffer.Load(int location);
/// See Availability 2
uint RasterizerOrderedByteAddressBuffer.Load(
    int                  location,
    out uint             status);
T RasterizerOrderedByteAddressBuffer.Load<T>(int location);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `location`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedAdd`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedAdd(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RasterizerOrderedByteAddressBuffer.InterlockedAdd(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedAnd`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedAnd(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RasterizerOrderedByteAddressBuffer.InterlockedAnd(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedCompareExchange`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedCompareExchange(
    uint                 dest,
    uint                 compare_value,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `compare_value`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedCompareStore`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedCompareStore(
    uint                 dest,
    uint                 compare_value,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `compare_value`
* `value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedExchange`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedExchange(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedMax`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedMax(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RasterizerOrderedByteAddressBuffer.InterlockedMax(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedMin`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedMin(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RasterizerOrderedByteAddressBuffer.InterlockedMin(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedOr`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedOr(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RasterizerOrderedByteAddressBuffer.InterlockedOr(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.InterlockedXor`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.InterlockedXor(
    uint                 dest,
    uint                 value,
    out uint             original_value);
void RasterizerOrderedByteAddressBuffer.InterlockedXor(
    uint                 dest,
    uint                 value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.Store2`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.Store2(
    uint                 address,
    vector<uint,2>       value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `address`
* `value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.Store3`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.Store3(
    uint                 address,
    vector<uint,3>       value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `address`
* `value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.Store4`

## Signature 

```
void RasterizerOrderedByteAddressBuffer.Store4(
    uint                 address,
    vector<uint,4>       value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `address`
* `value`

--------------------------------------------------------------------------------
# `RasterizerOrderedByteAddressBuffer.Store`

## Signature 

```
/// See Availability 1
void RasterizerOrderedByteAddressBuffer.Store(
    uint                 address,
    uint                 value);
/// See Availability 2
void RasterizerOrderedByteAddressBuffer.Store<T>(
    int                  offset,
    T                    value);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `address`
* `value`
* `offset`

--------------------------------------------------------------------------------
# `struct RWStructuredBuffer<T>`

## Generic Parameters

* `T`

## Methods

* `DecrementCounter`
* `GetDimensions`
* `IncrementCounter`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWStructuredBuffer<T>.DecrementCounter`

## Signature 

```
uint RWStructuredBuffer<T>.DecrementCounter();
```

--------------------------------------------------------------------------------
# `RWStructuredBuffer<T>.GetDimensions`

## Signature 

```
void RWStructuredBuffer<T>.GetDimensions(
    out uint             numStructs,
    out uint             stride);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `numStructs`
* `stride`

--------------------------------------------------------------------------------
# `RWStructuredBuffer<T>.IncrementCounter`

## Signature 

```
uint RWStructuredBuffer<T>.IncrementCounter();
```

--------------------------------------------------------------------------------
# `RWStructuredBuffer<T>.Load`

## Signature 

```
/// See Availability 1
T RWStructuredBuffer<T>.Load(int location);
/// See Availability 2
T RWStructuredBuffer<T>.Load(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RWStructuredBuffer<T>.subscript`

## Signature 

```
T RWStructuredBuffer<T>.subscript(uint index);
```

## Parameters

* `index`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedStructuredBuffer<T>`

## Generic Parameters

* `T`

## Methods

* `DecrementCounter`
* `GetDimensions`
* `IncrementCounter`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedStructuredBuffer<T>.DecrementCounter`

## Signature 

```
uint RasterizerOrderedStructuredBuffer<T>.DecrementCounter();
```

--------------------------------------------------------------------------------
# `RasterizerOrderedStructuredBuffer<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedStructuredBuffer<T>.GetDimensions(
    out uint             numStructs,
    out uint             stride);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `numStructs`
* `stride`

--------------------------------------------------------------------------------
# `RasterizerOrderedStructuredBuffer<T>.IncrementCounter`

## Signature 

```
uint RasterizerOrderedStructuredBuffer<T>.IncrementCounter();
```

--------------------------------------------------------------------------------
# `RasterizerOrderedStructuredBuffer<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedStructuredBuffer<T>.Load(int location);
/// See Availability 2
T RasterizerOrderedStructuredBuffer<T>.Load(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedStructuredBuffer<T>.subscript`

## Signature 

```
T RasterizerOrderedStructuredBuffer<T>.subscript(uint index);
```

## Parameters

* `index`

--------------------------------------------------------------------------------
# `struct PointStream<T>`

## Generic Parameters

* `T`

## Methods

* `Append`
* `RestartStrip`

--------------------------------------------------------------------------------
# `PointStream<T>.Append`

## Signature 

```
void PointStream<T>.Append(T value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `value`

--------------------------------------------------------------------------------
# `PointStream<T>.RestartStrip`

## Signature 

```
void PointStream<T>.RestartStrip();
```

## Availability

**GLSL** **HLSL** 

--------------------------------------------------------------------------------
# `struct LineStream<T>`

## Generic Parameters

* `T`

## Methods

* `Append`
* `RestartStrip`

--------------------------------------------------------------------------------
# `LineStream<T>.Append`

## Signature 

```
void LineStream<T>.Append(T value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `value`

--------------------------------------------------------------------------------
# `LineStream<T>.RestartStrip`

## Signature 

```
void LineStream<T>.RestartStrip();
```

## Availability

**GLSL** **HLSL** 

--------------------------------------------------------------------------------
# `struct TriangleStream<T>`

## Generic Parameters

* `T`

## Methods

* `Append`
* `RestartStrip`

--------------------------------------------------------------------------------
# `TriangleStream<T>.Append`

## Signature 

```
void TriangleStream<T>.Append(T value);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `value`

--------------------------------------------------------------------------------
# `TriangleStream<T>.RestartStrip`

## Signature 

```
void TriangleStream<T>.RestartStrip();
```

## Availability

**GLSL** **HLSL** 

--------------------------------------------------------------------------------
# `abort`

## Signature 

```
void abort();
```

--------------------------------------------------------------------------------
# `abs`

## Signature 

```
/// See Availability 1
T abs<T>(T x);
/// See Availability 2
vector<T,N> abs<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> abs<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `acos`

## Signature 

```
/// See Availability 1
T acos<T>(T x);
/// See Availability 2
vector<T,N> acos<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> acos<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `all`

## Signature 

```
/// See Availability 1
bool all<T>(T x);
bool all<T, N:int>(vector<T,N> x);
/// See Availability 2
bool all<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `AllMemoryBarrier`

## Signature 

```
void AllMemoryBarrier();
```

## Availability

**GLSL** **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `AllMemoryBarrierWithGroupSync`

## Signature 

```
void AllMemoryBarrierWithGroupSync();
```

## Availability

**GLSL** **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `any`

## Signature 

```
/// See Availability 1
bool any<T>(T x);
bool any<T, N:int>(vector<T,N> x);
/// See Availability 2
bool any<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `asdouble`

## Signature 

```
double asdouble(
    uint                 lowbits,
    uint                 highbits);
```

## Availability

**GLSL** `GL_ARB_gpu_shader5` **HLSL** **SPIRV** 

## Parameters

* `lowbits`
* `highbits`

--------------------------------------------------------------------------------
# `asfloat`

## Signature 

```
/// See Availability 1
float asfloat(int x);
float asfloat(uint x);
vector<float,N> asfloat<N:int>(vector<int,N> x);
vector<float,N> asfloat<N:int>(vector<uint,N> x);
/// See Availability 2
matrix<float,N,M> asfloat<N:int, M:int>(matrix<int,N,M> x);
matrix<float,N,M> asfloat<N:int, M:int>(matrix<uint,N,M> x);
float asfloat(float x);
vector<float,N> asfloat<N:int>(vector<float,N> x);
matrix<float,N,M> asfloat<N:int, M:int>(matrix<float,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `asin`

## Signature 

```
/// See Availability 1
T asin<T>(T x);
/// See Availability 2
vector<T,N> asin<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> asin<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `asint`

## Signature 

```
/// See Availability 1
int asint(float x);
int asint(uint x);
vector<int,N> asint<N:int>(vector<float,N> x);
vector<int,N> asint<N:int>(vector<uint,N> x);
/// See Availability 2
matrix<int,N,M> asint<N:int, M:int>(matrix<float,N,M> x);
matrix<int,N,M> asint<N:int, M:int>(matrix<uint,N,M> x);
int asint(int x);
vector<int,N> asint<N:int>(vector<int,N> x);
matrix<int,N,M> asint<N:int, M:int>(matrix<int,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `asuint`

## Signature 

```
/// See Availability 1
void asuint(
    double               value,
    out uint             lowbits,
    out uint             highbits);
/// See Availability 2
uint asuint(float x);
uint asuint(int x);
vector<uint,N> asuint<N:int>(vector<float,N> x);
vector<uint,N> asuint<N:int>(vector<int,N> x);
/// See Availability 3
matrix<uint,N,M> asuint<N:int, M:int>(matrix<float,N,M> x);
matrix<uint,N,M> asuint<N:int, M:int>(matrix<int,N,M> x);
uint asuint(uint x);
vector<uint,N> asuint<N:int>(vector<uint,N> x);
matrix<uint,N,M> asuint<N:int, M:int>(matrix<uint,N,M> x);
```

## Availability

1. **GLSL** `GL_ARB_gpu_shader5` **HLSL** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `N`
* `M`
* `value`
* `lowbits`
* `highbits`
* `x`

--------------------------------------------------------------------------------
# `asuint16`

## Signature 

```
/// See Availability 1
uint16_t asuint16(uint16_t value);
vector<uint16_t,N> asuint16<N:int>(vector<uint16_t,N> value);
matrix<uint16_t,R,C> asuint16<R:int, C:int>(matrix<uint16_t,R,C> value);
uint16_t asuint16(int16_t value);
vector<uint16_t,N> asuint16<N:int>(vector<int16_t,N> value);
matrix<uint16_t,R,C> asuint16<R:int, C:int>(matrix<int16_t,R,C> value);
/// See Availability 2
uint16_t asuint16(half value);
/// See Availability 1
vector<uint16_t,N> asuint16<N:int>(vector<half,N> value);
matrix<uint16_t,R,C> asuint16<R:int, C:int>(matrix<half,R,C> value);
```

## Availability

1. **HLSL** 
2. **GLSL** **HLSL** **CUDA** 

## Parameters

* `N`
* `R`
* `C`
* `value`

--------------------------------------------------------------------------------
# `asint16`

## Signature 

```
/// See Availability 1
int16_t asint16(int16_t value);
vector<int16_t,N> asint16<N:int>(vector<int16_t,N> value);
matrix<int16_t,R,C> asint16<R:int, C:int>(matrix<int16_t,R,C> value);
int16_t asint16(uint16_t value);
vector<int16_t,N> asint16<N:int>(vector<uint16_t,N> value);
matrix<int16_t,R,C> asint16<R:int, C:int>(matrix<uint16_t,R,C> value);
/// See Availability 2
int16_t asint16(half value);
/// See Availability 1
vector<int16_t,N> asint16<N:int>(vector<half,N> value);
matrix<int16_t,R,C> asint16<R:int, C:int>(matrix<half,R,C> value);
```

## Availability

1. **HLSL** 
2. **HLSL** **CUDA** 

## Parameters

* `N`
* `R`
* `C`
* `value`

--------------------------------------------------------------------------------
# `asfloat16`

## Signature 

```
/// See Availability 1
half asfloat16(half value);
vector<half,N> asfloat16<N:int>(vector<half,N> value);
matrix<half,R,C> asfloat16<R:int, C:int>(matrix<half,R,C> value);
/// See Availability 2
half asfloat16(uint16_t value);
/// See Availability 1
vector<half,N> asfloat16<N:int>(vector<uint16_t,N> value);
matrix<half,R,C> asfloat16<R:int, C:int>(matrix<uint16_t,R,C> value);
/// See Availability 3
half asfloat16(int16_t value);
/// See Availability 1
vector<half,N> asfloat16<N:int>(vector<int16_t,N> value);
matrix<half,R,C> asfloat16<R:int, C:int>(matrix<int16_t,R,C> value);
```

## Availability

1. **HLSL** 
2. **GLSL** **HLSL** **CUDA** 
3. **HLSL** **CUDA** 

## Parameters

* `N`
* `R`
* `C`
* `value`

--------------------------------------------------------------------------------
# `atan`

## Signature 

```
/// See Availability 1
T atan<T>(T x);
/// See Availability 2
vector<T,N> atan<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> atan<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `atan2`

## Signature 

```
/// See Availability 1
T atan2<T>(
    T                    y,
    T                    x);
/// See Availability 2
vector<T,N> atan2<T, N:int>(
    vector<T,N>          y,
    vector<T,N>          x);
/// See Availability 3
matrix<T,N,M> atan2<T, N:int, M:int>(
    matrix<T,N,M>        y,
    matrix<T,N,M>        x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `y`
* `x`

--------------------------------------------------------------------------------
# `ceil`

## Signature 

```
/// See Availability 1
T ceil<T>(T x);
/// See Availability 2
vector<T,N> ceil<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> ceil<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `CheckAccessFullyMapped`

## Signature 

```
bool CheckAccessFullyMapped(uint status);
```

## Parameters

* `status`

--------------------------------------------------------------------------------
# `clamp`

## Signature 

```
/// See Availability 1
T clamp<T>(
    T                    x,
    T                    minBound,
    T                    maxBound);
vector<T,N> clamp<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          minBound,
    vector<T,N>          maxBound);
/// See Availability 2
matrix<T,N,M> clamp<T, N:int, M:int>(
    matrix<T,N,M>        x,
    matrix<T,N,M>        minBound,
    matrix<T,N,M>        maxBound);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `minBound`
* `maxBound`

--------------------------------------------------------------------------------
# `clip`

## Signature 

```
void clip<T>(T x);
void clip<T, N:int>(vector<T,N> x);
void clip<T, N:int, M:int>(matrix<T,N,M> x);
```

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `cos`

## Signature 

```
/// See Availability 1
T cos<T>(T x);
/// See Availability 2
vector<T,N> cos<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> cos<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `cosh`

## Signature 

```
/// See Availability 1
T cosh<T>(T x);
/// See Availability 2
vector<T,N> cosh<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> cosh<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `countbits`

## Signature 

```
uint countbits(uint value);
```

## Availability

**GLSL** **HLSL** **CPP** **CUDA** 

## Parameters

* `value`

--------------------------------------------------------------------------------
# `cross`

## Signature 

```
vector<T,3> cross<T>(
    vector<T,3>          left,
    vector<T,3>          right);
```

## Availability

**GLSL** **HLSL** **SPIRV** 

## Parameters

* `T`
* `left`
* `right`

--------------------------------------------------------------------------------
# `D3DCOLORtoUBYTE4`

## Signature 

```
vector<int,4> D3DCOLORtoUBYTE4(vector<float,4> color);
```

## Parameters

* `color`

--------------------------------------------------------------------------------
# `ddx`

## Signature 

```
/// See Availability 1
T ddx<T>(T x);
vector<T,N> ddx<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> ddx<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `ddx_coarse`

## Signature 

```
/// See Availability 1
T ddx_coarse<T>(T x);
vector<T,N> ddx_coarse<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> ddx_coarse<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** `GL_ARB_derivative_control` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `ddx_fine`

## Signature 

```
/// See Availability 1
T ddx_fine<T>(T x);
vector<T,N> ddx_fine<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> ddx_fine<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** `GL_ARB_derivative_control` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `ddy`

## Signature 

```
/// See Availability 1
T ddy<T>(T x);
vector<T,N> ddy<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> ddy<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `ddy_coarse`

## Signature 

```
/// See Availability 1
T ddy_coarse<T>(T x);
vector<T,N> ddy_coarse<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> ddy_coarse<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** `GL_ARB_derivative_control` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `ddy_fine`

## Signature 

```
/// See Availability 1
T ddy_fine<T>(T x);
vector<T,N> ddy_fine<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> ddy_fine<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** `GL_ARB_derivative_control` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `degrees`

## Signature 

```
/// See Availability 1
T degrees<T>(T x);
vector<T,N> degrees<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> degrees<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `determinant`

## Signature 

```
T determinant<T, N:int>(matrix<T,N,N> m);
```

## Availability

**GLSL** **HLSL** **SPIRV** 

## Parameters

* `T`
* `N`
* `m`

--------------------------------------------------------------------------------
# `DeviceMemoryBarrier`

## Signature 

```
void DeviceMemoryBarrier();
```

## Availability

**GLSL** **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `DeviceMemoryBarrierWithGroupSync`

## Signature 

```
void DeviceMemoryBarrierWithGroupSync();
```

## Availability

**GLSL** **HLSL** 

--------------------------------------------------------------------------------
# `distance`

## Signature 

```
T distance<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          y);
```

## Availability

**GLSL** **HLSL** **SPIRV** 

## Parameters

* `T`
* `N`
* `x`
* `y`

--------------------------------------------------------------------------------
# `dot`

## Signature 

```
T dot<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          y);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `x`
* `y`

--------------------------------------------------------------------------------
# `dst`

## Signature 

```
vector<T,4> dst<T>(
    vector<T,4>          x,
    vector<T,4>          y);
```

## Parameters

* `T`
* `x`
* `y`

--------------------------------------------------------------------------------
# `EvaluateAttributeAtCentroid`

## Signature 

```
/// See Availability 1
T EvaluateAttributeAtCentroid<T>(T x);
vector<T,N> EvaluateAttributeAtCentroid<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> EvaluateAttributeAtCentroid<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `EvaluateAttributeAtSample`

## Signature 

```
/// See Availability 1
T EvaluateAttributeAtSample<T>(
    T                    x,
    uint                 sampleindex);
vector<T,N> EvaluateAttributeAtSample<T, N:int>(
    vector<T,N>          x,
    uint                 sampleindex);
/// See Availability 2
matrix<T,N,M> EvaluateAttributeAtSample<T, N:int, M:int>(
    matrix<T,N,M>        x,
    uint                 sampleindex);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `sampleindex`

--------------------------------------------------------------------------------
# `EvaluateAttributeSnapped`

## Signature 

```
/// See Availability 1
T EvaluateAttributeSnapped<T>(
    T                    x,
    vector<int,2>        offset);
vector<T,N> EvaluateAttributeSnapped<T, N:int>(
    vector<T,N>          x,
    vector<int,2>        offset);
/// See Availability 2
matrix<T,N,M> EvaluateAttributeSnapped<T, N:int, M:int>(
    matrix<T,N,M>        x,
    vector<int,2>        offset);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `offset`

--------------------------------------------------------------------------------
# `exp`

## Signature 

```
/// See Availability 1
T exp<T>(T x);
/// See Availability 2
vector<T,N> exp<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> exp<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `exp2`

## Signature 

```
/// See Availability 1
T exp2<T>(T x);
/// See Availability 2
vector<T,N> exp2<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> exp2<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `f32tof16`

## Signature 

```
/// See Availability 1
uint f32tof16(float value);
/// See Availability 2
vector<uint,N> f32tof16<N:int>(vector<float,N> value);
```

## Availability

1. **GLSL** `GLSL420` **HLSL** 
2. **HLSL** 

## Parameters

* `N`
* `value`

--------------------------------------------------------------------------------
# `f16tof32`

## Signature 

```
/// See Availability 1
float f16tof32(uint value);
/// See Availability 2
vector<float,N> f16tof32<N:int>(vector<uint,N> value);
/// See Availability 3
float f16tof32(half value);
/// See Availability 4
vector<float,N> f16tof32<N:int>(vector<half,N> value);
```

## Availability

1. **GLSL** `GLSL420` **HLSL** 
2. **HLSL** 
3. **GLSL** `GLSL420` **HLSL** **CUDA** 
4. **HLSL** **CUDA** 

## Parameters

* `N`
* `value`

--------------------------------------------------------------------------------
# `f32tof16_`

## Signature 

```
/// See Availability 1
half f32tof16_(float value);
/// See Availability 2
vector<half,N> f32tof16_<N:int>(vector<float,N> value);
```

## Availability

1. **GLSL** `GLSL420` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `N`
* `value`

--------------------------------------------------------------------------------
# `faceforward`

## Signature 

```
vector<T,N> faceforward<T, N:int>(
    vector<T,N>          n,
    vector<T,N>          i,
    vector<T,N>          ng);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `n`
* `i`
* `ng`

--------------------------------------------------------------------------------
# `firstbithigh`

## Signature 

```
/// See Availability 1
int firstbithigh(int value);
/// See Availability 2
vector<int,N> firstbithigh<N:int>(vector<int,N> value);
/// See Availability 1
uint firstbithigh(uint value);
/// See Availability 2
vector<uint,N> firstbithigh<N:int>(vector<uint,N> value);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 

## Parameters

* `N`
* `value`

--------------------------------------------------------------------------------
# `firstbitlow`

## Signature 

```
/// See Availability 1
int firstbitlow(int value);
/// See Availability 2
vector<int,N> firstbitlow<N:int>(vector<int,N> value);
/// See Availability 1
uint firstbitlow(uint value);
/// See Availability 2
vector<uint,N> firstbitlow<N:int>(vector<uint,N> value);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 

## Parameters

* `N`
* `value`

--------------------------------------------------------------------------------
# `floor`

## Signature 

```
/// See Availability 1
T floor<T>(T x);
/// See Availability 2
vector<T,N> floor<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> floor<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `fma`

## Signature 

```
/// See Availability 1
double fma(
    double               a,
    double               b,
    double               c);
/// See Availability 2
vector<double,N> fma<N:int>(
    vector<double,N>     a,
    vector<double,N>     b,
    vector<double,N>     c);
/// See Availability 3
matrix<double,N,M> fma<N:int, M:int>(
    matrix<double,N,M>   a,
    matrix<double,N,M>   b,
    matrix<double,N,M>   c);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `N`
* `M`
* `a`
* `b`
* `c`

--------------------------------------------------------------------------------
# `fmod`

## Signature 

```
/// See Availability 1
T fmod<T>(
    T                    x,
    T                    y);
/// See Availability 2
vector<T,N> fmod<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          y);
matrix<T,N,M> fmod<T, N:int, M:int>(
    matrix<T,N,M>        x,
    matrix<T,N,M>        y);
```

## Availability

1. **HLSL** **CPP** **CUDA** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `y`

--------------------------------------------------------------------------------
# `frac`

## Signature 

```
/// See Availability 1
T frac<T>(T x);
/// See Availability 2
vector<T,N> frac<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> frac<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `frexp`

## Signature 

```
/// See Availability 1
T frexp<T>(
    T                    x,
    out T                exp);
vector<T,N> frexp<T, N:int>(
    vector<T,N>          x,
    out vector<T,N>      exp);
/// See Availability 2
matrix<T,N,M> frexp<T, N:int, M:int>(
    matrix<T,N,M>        x,
    out matrix<T,N,M>    exp);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `exp`

--------------------------------------------------------------------------------
# `fwidth`

## Signature 

```
/// See Availability 1
T fwidth<T>(T x);
/// See Availability 2
vector<T,N> fwidth<T, N:int>(vector<T,N> x);
/// See Availability 1
matrix<T,N,M> fwidth<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **HLSL** 
2. **GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `GetAttributeAtVertex`

## Description

 Get the value of a vertex attribute at a specific vertex.

 The `GetAttributeAtVertex()` function can be used in a fragment shader
 to get the value of the given `attribute` at the vertex of the primitive
 that corresponds to the given `vertexIndex`.

 Note that the `attribute` must have been a declared varying input to
 the fragment shader with the `nointerpolation` modifier.

 This function can be applied to scalars, vectors, and matrices of
 built-in scalar types.

 Note: these functions are not curently implemented for Vulkan/SPIR-V output.

## Signature 

```
T GetAttributeAtVertex<T>(
    T                    attribute,
    uint                 vertexIndex);
vector<T,N> GetAttributeAtVertex<T, N:int>(
    vector<T,N>          attribute,
    uint                 vertexIndex);
matrix<T,N,M> GetAttributeAtVertex<T, N:int, M:int>(
    matrix<T,N,M>        attribute,
    uint                 vertexIndex);
```

## Availability

**GLSL** `GLSL450`, `GL_NV_fragment_shader_barycentric` **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `attribute`
* `vertexIndex`

--------------------------------------------------------------------------------
# `GetRenderTargetSampleCount`

## Signature 

```
uint GetRenderTargetSampleCount();
```

--------------------------------------------------------------------------------
# `GetRenderTargetSamplePosition`

## Signature 

```
vector<float,2> GetRenderTargetSamplePosition(int Index);
```

## Parameters

* `Index`

--------------------------------------------------------------------------------
# `GroupMemoryBarrier`

## Signature 

```
void GroupMemoryBarrier();
```

## Availability

**GLSL** **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `GroupMemoryBarrierWithGroupSync`

## Signature 

```
void GroupMemoryBarrierWithGroupSync();
```

## Availability

**GLSL** **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `InterlockedAdd`

## Signature 

```
void InterlockedAdd(
    int                  dest,
    int                  value);
void InterlockedAdd(
    uint                 dest,
    uint                 value);
void InterlockedAdd(
    int                  dest,
    int                  value,
    out int              original_value);
void InterlockedAdd(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `InterlockedAnd`

## Signature 

```
void InterlockedAnd(
    int                  dest,
    int                  value);
void InterlockedAnd(
    uint                 dest,
    uint                 value);
void InterlockedAnd(
    int                  dest,
    int                  value,
    out int              original_value);
void InterlockedAnd(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `InterlockedCompareExchange`

## Signature 

```
void InterlockedCompareExchange(
    int                  dest,
    int                  compare_value,
    int                  value,
    out int              original_value);
void InterlockedCompareExchange(
    uint                 dest,
    uint                 compare_value,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `compare_value`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `InterlockedCompareStore`

## Signature 

```
void InterlockedCompareStore(
    int                  dest,
    int                  compare_value,
    int                  value);
void InterlockedCompareStore(
    uint                 dest,
    uint                 compare_value,
    uint                 value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `compare_value`
* `value`

--------------------------------------------------------------------------------
# `InterlockedExchange`

## Signature 

```
void InterlockedExchange(
    int                  dest,
    int                  value,
    out int              original_value);
void InterlockedExchange(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `InterlockedMax`

## Signature 

```
void InterlockedMax(
    int                  dest,
    int                  value);
void InterlockedMax(
    uint                 dest,
    uint                 value);
void InterlockedMax(
    int                  dest,
    int                  value,
    out int              original_value);
void InterlockedMax(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `InterlockedMin`

## Signature 

```
void InterlockedMin(
    int                  dest,
    int                  value);
void InterlockedMin(
    uint                 dest,
    uint                 value);
void InterlockedMin(
    int                  dest,
    int                  value,
    out int              original_value);
void InterlockedMin(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `InterlockedOr`

## Signature 

```
void InterlockedOr(
    int                  dest,
    int                  value);
void InterlockedOr(
    uint                 dest,
    uint                 value);
void InterlockedOr(
    int                  dest,
    int                  value,
    out int              original_value);
void InterlockedOr(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `InterlockedXor`

## Signature 

```
void InterlockedXor(
    int                  dest,
    int                  value);
void InterlockedXor(
    uint                 dest,
    uint                 value);
void InterlockedXor(
    int                  dest,
    int                  value,
    out int              original_value);
void InterlockedXor(
    uint                 dest,
    uint                 value,
    out uint             original_value);
```

## Availability

**GLSL** **HLSL** **CUDA** 

## Parameters

* `dest`
* `value`
* `original_value`

--------------------------------------------------------------------------------
# `isfinite`

## Signature 

```
/// See Availability 1
bool isfinite<T>(T x);
/// See Availability 2
vector<bool,N> isfinite<T, N:int>(vector<T,N> x);
matrix<bool,N,M> isfinite<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **HLSL** **CPP** **CUDA** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `isinf`

## Signature 

```
/// See Availability 1
bool isinf<T>(T x);
/// See Availability 2
vector<bool,N> isinf<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<bool,N,M> isinf<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **CPP** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `isnan`

## Signature 

```
/// See Availability 1
bool isnan<T>(T x);
/// See Availability 2
vector<bool,N> isnan<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<bool,N,M> isnan<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **CPP** **CUDA** 
2. **GLSL** **HLSL** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `ldexp`

## Signature 

```
/// See Availability 1
T ldexp<T>(
    T                    x,
    T                    exp);
vector<T,N> ldexp<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          exp);
/// See Availability 2
matrix<T,N,M> ldexp<T, N:int, M:int>(
    matrix<T,N,M>        x,
    matrix<T,N,M>        exp);
```

## Availability

1. **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `exp`

--------------------------------------------------------------------------------
# `length`

## Signature 

```
T length<T, N:int>(vector<T,N> x);
```

## Availability

**GLSL** **HLSL** **SPIRV** 

## Parameters

* `T`
* `N`
* `x`

--------------------------------------------------------------------------------
# `lerp`

## Signature 

```
/// See Availability 1
T lerp<T>(
    T                    x,
    T                    y,
    T                    s);
vector<T,N> lerp<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          y,
    vector<T,N>          s);
/// See Availability 2
matrix<T,N,M> lerp<T, N:int, M:int>(
    matrix<T,N,M>        x,
    matrix<T,N,M>        y,
    matrix<T,N,M>        s);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `y`
* `s`

--------------------------------------------------------------------------------
# `lit`

## Signature 

```
vector<float,4> lit(
    float                n_dot_l,
    float                n_dot_h,
    float                m);
```

## Parameters

* `n_dot_l`
* `n_dot_h`
* `m`

--------------------------------------------------------------------------------
# `log`

## Signature 

```
/// See Availability 1
T log<T>(T x);
/// See Availability 2
vector<T,N> log<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> log<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `log10`

## Signature 

```
/// See Availability 1
T log10<T>(T x);
/// See Availability 2
vector<T,N> log10<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> log10<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `log2`

## Signature 

```
/// See Availability 1
T log2<T>(T x);
/// See Availability 2
vector<T,N> log2<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> log2<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `mad`

## Signature 

```
/// See Availability 1
T mad<T>(
    T                    mvalue,
    T                    avalue,
    T                    bvalue);
/// See Availability 2
vector<T,N> mad<T, N:int>(
    vector<T,N>          mvalue,
    vector<T,N>          avalue,
    vector<T,N>          bvalue);
/// See Availability 3
matrix<T,N,M> mad<T, N:int, M:int>(
    matrix<T,N,M>        mvalue,
    matrix<T,N,M>        avalue,
    matrix<T,N,M>        bvalue);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `mvalue`
* `avalue`
* `bvalue`

--------------------------------------------------------------------------------
# `max`

## Signature 

```
/// See Availability 1
T max<T>(
    T                    x,
    T                    y);
/// See Availability 2
vector<T,N> max<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          y);
/// See Availability 3
matrix<T,N,M> max<T, N:int, M:int>(
    matrix<T,N,M>        x,
    matrix<T,N,M>        y);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `y`

--------------------------------------------------------------------------------
# `min`

## Signature 

```
/// See Availability 1
T min<T>(
    T                    x,
    T                    y);
/// See Availability 2
vector<T,N> min<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          y);
/// See Availability 3
matrix<T,N,M> min<T, N:int, M:int>(
    matrix<T,N,M>        x,
    matrix<T,N,M>        y);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `y`

--------------------------------------------------------------------------------
# `modf`

## Signature 

```
/// See Availability 1
T modf<T>(
    T                    x,
    out T                ip);
/// See Availability 2
vector<T,N> modf<T, N:int>(
    vector<T,N>          x,
    out vector<T,N>      ip);
/// See Availability 1
matrix<T,N,M> modf<T, N:int, M:int>(
    matrix<T,N,M>        x,
    out matrix<T,N,M>    ip);
```

## Availability

1. **HLSL** 
2. **GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `ip`

--------------------------------------------------------------------------------
# `msad4`

## Signature 

```
vector<uint,4> msad4(
    uint                 reference,
    vector<uint,2>       source,
    vector<uint,4>       accum);
```

## Parameters

* `reference`
* `source`
* `accum`

--------------------------------------------------------------------------------
# `mul`

## Signature 

```
/// See Availability 1
T mul<T>(
    T                    x,
    T                    y);
vector<T,N> mul<T, N:int>(
    vector<T,N>          x,
    T                    y);
vector<T,N> mul<T, N:int>(
    T                    x,
    vector<T,N>          y);
matrix<T,N,M> mul<T, N:int, M:int>(
    matrix<T,N,M>        x,
    T                    y);
matrix<T,N,M> mul<T, N:int, M:int>(
    T                    x,
    matrix<T,N,M>        y);
/// See Availability 2
T mul<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          y);
vector<T,M> mul<T, N:int, M:int>(
    vector<T,N>          left,
    matrix<T,N,M>        right);
vector<T,N> mul<T, N:int, M:int>(
    matrix<T,N,M>        left,
    vector<T,M>          right);
matrix<T,R,C> mul<T, R:int, N:int, C:int>(
    matrix<T,R,N>        right,
    matrix<T,N,C>        left);
```

## Availability

1. **HLSL** 
2. **GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `R`
* `C`
* `x`
* `y`
* `left`
* `right`

--------------------------------------------------------------------------------
# `noise`

## Signature 

```
float noise(float x);
float noise<N:int>(vector<float,N> x);
```

## Parameters

* `N`
* `x`

--------------------------------------------------------------------------------
# `NonUniformResourceIndex`

## Signature 

```
uint NonUniformResourceIndex(uint index);
int NonUniformResourceIndex(int index);
```

## Availability

**GLSL** `GL_EXT_nonuniform_qualifier` **HLSL** 

## Parameters

* `index`

--------------------------------------------------------------------------------
# `normalize`

## Signature 

```
vector<T,N> normalize<T, N:int>(vector<T,N> x);
```

## Availability

**GLSL** **HLSL** **SPIRV** 

## Parameters

* `T`
* `N`
* `x`

--------------------------------------------------------------------------------
# `pow`

## Signature 

```
/// See Availability 1
T pow<T>(
    T                    x,
    T                    y);
/// See Availability 2
vector<T,N> pow<T, N:int>(
    vector<T,N>          x,
    vector<T,N>          y);
/// See Availability 3
matrix<T,N,M> pow<T, N:int, M:int>(
    matrix<T,N,M>        x,
    matrix<T,N,M>        y);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `y`

--------------------------------------------------------------------------------
# `Process2DQuadTessFactorsAvg`

## Signature 

```
void Process2DQuadTessFactorsAvg(
    in vector<float,4>   RawEdgeFactors,
    in vector<float,2>   InsideScale,
    out vector<float,4>  RoundedEdgeTessFactors,
    out vector<float,2>  RoundedInsideTessFactors,
    out vector<float,2>  UnroundedInsideTessFactors);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactors`
* `UnroundedInsideTessFactors`

--------------------------------------------------------------------------------
# `Process2DQuadTessFactorsMax`

## Signature 

```
void Process2DQuadTessFactorsMax(
    in vector<float,4>   RawEdgeFactors,
    in vector<float,2>   InsideScale,
    out vector<float,4>  RoundedEdgeTessFactors,
    out vector<float,2>  RoundedInsideTessFactors,
    out vector<float,2>  UnroundedInsideTessFactors);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactors`
* `UnroundedInsideTessFactors`

--------------------------------------------------------------------------------
# `Process2DQuadTessFactorsMin`

## Signature 

```
void Process2DQuadTessFactorsMin(
    in vector<float,4>   RawEdgeFactors,
    in vector<float,2>   InsideScale,
    out vector<float,4>  RoundedEdgeTessFactors,
    out vector<float,2>  RoundedInsideTessFactors,
    out vector<float,2>  UnroundedInsideTessFactors);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactors`
* `UnroundedInsideTessFactors`

--------------------------------------------------------------------------------
# `ProcessIsolineTessFactors`

## Signature 

```
void ProcessIsolineTessFactors(
    in float             RawDetailFactor,
    in float             RawDensityFactor,
    out float            RoundedDetailFactor,
    out float            RoundedDensityFactor);
```

## Parameters

* `RawDetailFactor`
* `RawDensityFactor`
* `RoundedDetailFactor`
* `RoundedDensityFactor`

--------------------------------------------------------------------------------
# `ProcessQuadTessFactorsAvg`

## Signature 

```
void ProcessQuadTessFactorsAvg(
    in vector<float,4>   RawEdgeFactors,
    in float             InsideScale,
    out vector<float,4>  RoundedEdgeTessFactors,
    out vector<float,2>  RoundedInsideTessFactors,
    out vector<float,2>  UnroundedInsideTessFactors);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactors`
* `UnroundedInsideTessFactors`

--------------------------------------------------------------------------------
# `ProcessQuadTessFactorsMax`

## Signature 

```
void ProcessQuadTessFactorsMax(
    in vector<float,4>   RawEdgeFactors,
    in float             InsideScale,
    out vector<float,4>  RoundedEdgeTessFactors,
    out vector<float,2>  RoundedInsideTessFactors,
    out vector<float,2>  UnroundedInsideTessFactors);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactors`
* `UnroundedInsideTessFactors`

--------------------------------------------------------------------------------
# `ProcessQuadTessFactorsMin`

## Signature 

```
void ProcessQuadTessFactorsMin(
    in vector<float,4>   RawEdgeFactors,
    in float             InsideScale,
    out vector<float,4>  RoundedEdgeTessFactors,
    out vector<float,2>  RoundedInsideTessFactors,
    out vector<float,2>  UnroundedInsideTessFactors);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactors`
* `UnroundedInsideTessFactors`

--------------------------------------------------------------------------------
# `ProcessTriTessFactorsAvg`

## Signature 

```
void ProcessTriTessFactorsAvg(
    in vector<float,3>   RawEdgeFactors,
    in float             InsideScale,
    out vector<float,3>  RoundedEdgeTessFactors,
    out float            RoundedInsideTessFactor,
    out float            UnroundedInsideTessFactor);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactor`
* `UnroundedInsideTessFactor`

--------------------------------------------------------------------------------
# `ProcessTriTessFactorsMax`

## Signature 

```
void ProcessTriTessFactorsMax(
    in vector<float,3>   RawEdgeFactors,
    in float             InsideScale,
    out vector<float,3>  RoundedEdgeTessFactors,
    out float            RoundedInsideTessFactor,
    out float            UnroundedInsideTessFactor);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactor`
* `UnroundedInsideTessFactor`

--------------------------------------------------------------------------------
# `ProcessTriTessFactorsMin`

## Signature 

```
void ProcessTriTessFactorsMin(
    in vector<float,3>   RawEdgeFactors,
    in float             InsideScale,
    out vector<float,3>  RoundedEdgeTessFactors,
    out float            RoundedInsideTessFactors,
    out float            UnroundedInsideTessFactors);
```

## Parameters

* `RawEdgeFactors`
* `InsideScale`
* `RoundedEdgeTessFactors`
* `RoundedInsideTessFactors`
* `UnroundedInsideTessFactors`

--------------------------------------------------------------------------------
# `radians`

## Signature 

```
/// See Availability 1
T radians<T>(T x);
vector<T,N> radians<T, N:int>(vector<T,N> x);
/// See Availability 2
matrix<T,N,M> radians<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `rcp`

## Signature 

```
T rcp<T>(T x);
vector<T,N> rcp<T, N:int>(vector<T,N> x);
matrix<T,N,M> rcp<T, N:int, M:int>(matrix<T,N,M> x);
```

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `reflect`

## Signature 

```
vector<T,N> reflect<T, N:int>(
    vector<T,N>          i,
    vector<T,N>          n);
```

## Availability

**GLSL** **HLSL** **SPIRV** 

## Parameters

* `T`
* `N`
* `i`
* `n`

--------------------------------------------------------------------------------
# `refract`

## Signature 

```
vector<T,N> refract<T, N:int>(
    vector<T,N>          i,
    vector<T,N>          n,
    T                    eta);
```

## Availability

**GLSL** **HLSL** **SPIRV** 

## Parameters

* `T`
* `N`
* `i`
* `n`
* `eta`

--------------------------------------------------------------------------------
# `reversebits`

## Signature 

```
/// See Availability 1
uint reversebits(uint value);
/// See Availability 2
vector<uint,N> reversebits<N:int>(vector<uint,N> value);
```

## Availability

1. **GLSL** **HLSL** **CPP** **CUDA** 
2. **GLSL** **HLSL** 

## Parameters

* `N`
* `value`

--------------------------------------------------------------------------------
# `round`

## Signature 

```
/// See Availability 1
T round<T>(T x);
/// See Availability 2
vector<T,N> round<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> round<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `rsqrt`

## Signature 

```
/// See Availability 1
T rsqrt<T>(T x);
/// See Availability 2
vector<T,N> rsqrt<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> rsqrt<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `saturate`

## Signature 

```
T saturate<T>(T x);
vector<T,N> saturate<T, N:int>(vector<T,N> x);
matrix<T,N,M> saturate<T, N:int, M:int>(matrix<T,N,M> x);
```

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `sign`

## Signature 

```
/// See Availability 1
int sign<T>(T x);
/// See Availability 2
vector<int,N> sign<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<int,N,M> sign<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `sin`

## Signature 

```
/// See Availability 1
T sin<T>(T x);
/// See Availability 2
vector<T,N> sin<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> sin<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `sincos`

## Signature 

```
/// See Availability 1
void sincos<T>(
    T                    x,
    out T                s,
    out T                c);
/// See Availability 2
void sincos<T, N:int>(
    vector<T,N>          x,
    out vector<T,N>      s,
    out vector<T,N>      c);
void sincos<T, N:int, M:int>(
    matrix<T,N,M>        x,
    out matrix<T,N,M>    s,
    out matrix<T,N,M>    c);
```

## Availability

1. **HLSL** **CUDA** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`
* `s`
* `c`

--------------------------------------------------------------------------------
# `sinh`

## Signature 

```
/// See Availability 1
T sinh<T>(T x);
/// See Availability 2
vector<T,N> sinh<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> sinh<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `smoothstep`

## Signature 

```
/// See Availability 1
T smoothstep<T>(
    T                    min,
    T                    max,
    T                    x);
vector<T,N> smoothstep<T, N:int>(
    vector<T,N>          min,
    vector<T,N>          max,
    vector<T,N>          x);
/// See Availability 2
matrix<T,N,M> smoothstep<T, N:int, M:int>(
    matrix<T,N,M>        min,
    matrix<T,N,M>        max,
    matrix<T,N,M>        x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `min`
* `max`
* `x`

--------------------------------------------------------------------------------
# `sqrt`

## Signature 

```
/// See Availability 1
T sqrt<T>(T x);
/// See Availability 2
vector<T,N> sqrt<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> sqrt<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `step`

## Signature 

```
/// See Availability 1
T step<T>(
    T                    y,
    T                    x);
vector<T,N> step<T, N:int>(
    vector<T,N>          y,
    vector<T,N>          x);
/// See Availability 2
matrix<T,N,M> step<T, N:int, M:int>(
    matrix<T,N,M>        y,
    matrix<T,N,M>        x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `y`
* `x`

--------------------------------------------------------------------------------
# `tan`

## Signature 

```
/// See Availability 1
T tan<T>(T x);
/// See Availability 2
vector<T,N> tan<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> tan<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `tanh`

## Signature 

```
/// See Availability 1
T tanh<T>(T x);
/// See Availability 2
vector<T,N> tanh<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> tanh<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `transpose`

## Signature 

```
matrix<T,M,N> transpose<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

**GLSL** **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `trunc`

## Signature 

```
/// See Availability 1
T trunc<T>(T x);
/// See Availability 2
vector<T,N> trunc<T, N:int>(vector<T,N> x);
/// See Availability 3
matrix<T,N,M> trunc<T, N:int, M:int>(matrix<T,N,M> x);
```

## Availability

1. **GLSL** **HLSL** **SPIRV** **CPP** **CUDA** 
2. **GLSL** **HLSL** **SPIRV** 
3. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `x`

--------------------------------------------------------------------------------
# `WaveGetConvergedMask`

## Signature 

```
uint WaveGetConvergedMask();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `WaveGetActiveMask`

## Signature 

```
uint WaveGetActiveMask();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** 

--------------------------------------------------------------------------------
# `WaveMaskIsFirstLane`

## Signature 

```
bool WaveMaskIsFirstLane(uint mask);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3` **HLSL** **CUDA** 

## Parameters

* `mask`

--------------------------------------------------------------------------------
# `WaveMaskAllTrue`

## Signature 

```
bool WaveMaskAllTrue(
    uint                 mask,
    bool                 condition);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3` **HLSL** **CUDA** 

## Parameters

* `mask`
* `condition`

--------------------------------------------------------------------------------
# `WaveMaskAnyTrue`

## Signature 

```
bool WaveMaskAnyTrue(
    uint                 mask,
    bool                 condition);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3` **HLSL** **CUDA** 

## Parameters

* `mask`
* `condition`

--------------------------------------------------------------------------------
# `WaveMaskBallot`

## Signature 

```
uint WaveMaskBallot(
    uint                 mask,
    bool                 condition);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** **CUDA** 

## Parameters

* `mask`
* `condition`

--------------------------------------------------------------------------------
# `WaveMaskCountBits`

## Signature 

```
uint WaveMaskCountBits(
    uint                 mask,
    bool                 value);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot` **HLSL** **CUDA** 

## Parameters

* `mask`
* `value`

--------------------------------------------------------------------------------
# `AllMemoryBarrierWithWaveMaskSync`

## Signature 

```
void AllMemoryBarrierWithWaveMaskSync(uint mask);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3` **HLSL** **CUDA** 

## Parameters

* `mask`

--------------------------------------------------------------------------------
# `GroupMemoryBarrierWithWaveMaskSync`

## Signature 

```
void GroupMemoryBarrierWithWaveMaskSync(uint mask);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3` **HLSL** **CUDA** 

## Parameters

* `mask`

--------------------------------------------------------------------------------
# `AllMemoryBarrierWithWaveSync`

## Signature 

```
void AllMemoryBarrierWithWaveSync();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3` **HLSL** 

--------------------------------------------------------------------------------
# `GroupMemoryBarrierWithWaveSync`

## Signature 

```
void GroupMemoryBarrierWithWaveSync();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `WaveMaskBroadcastLaneAt`

## Signature 

```
/// See Availability 1
T WaveMaskBroadcastLaneAt<T>(
    uint                 mask,
    T                    value,
    int                  lane);
vector<T,N> WaveMaskBroadcastLaneAt<T, N:int>(
    uint                 mask,
    vector<T,N>          value,
    int                  lane);
/// See Availability 2
matrix<T,N,M> WaveMaskBroadcastLaneAt<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        value,
    int                  lane);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `value`
* `lane`

--------------------------------------------------------------------------------
# `WaveMaskReadLaneAt`

## Signature 

```
/// See Availability 1
T WaveMaskReadLaneAt<T>(
    uint                 mask,
    T                    value,
    int                  lane);
vector<T,N> WaveMaskReadLaneAt<T, N:int>(
    uint                 mask,
    vector<T,N>          value,
    int                  lane);
/// See Availability 2
matrix<T,N,M> WaveMaskReadLaneAt<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        value,
    int                  lane);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_shuffle`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `value`
* `lane`

--------------------------------------------------------------------------------
# `WaveMaskShuffle`

## Signature 

```
/// See Availability 1
T WaveMaskShuffle<T>(
    uint                 mask,
    T                    value,
    int                  lane);
vector<T,N> WaveMaskShuffle<T, N:int>(
    uint                 mask,
    vector<T,N>          value,
    int                  lane);
/// See Availability 2
matrix<T,N,M> WaveMaskShuffle<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        value,
    int                  lane);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_shuffle`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `value`
* `lane`

--------------------------------------------------------------------------------
# `WaveMaskPrefixCountBits`

## Signature 

```
uint WaveMaskPrefixCountBits(
    uint                 mask,
    bool                 value);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** **CUDA** 

## Parameters

* `mask`
* `value`

--------------------------------------------------------------------------------
# `WaveMaskBitAnd`

## Signature 

```
/// See Availability 1
T WaveMaskBitAnd<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskBitAnd<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskBitAnd<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskBitOr`

## Signature 

```
/// See Availability 1
T WaveMaskBitOr<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskBitOr<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskBitOr<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskBitXor`

## Signature 

```
/// See Availability 1
T WaveMaskBitXor<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskBitXor<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskBitXor<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskMax`

## Signature 

```
/// See Availability 1
T WaveMaskMax<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskMax<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskMax<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskMin`

## Signature 

```
/// See Availability 1
T WaveMaskMin<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskMin<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskMin<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskProduct`

## Signature 

```
/// See Availability 1
T WaveMaskProduct<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskProduct<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskProduct<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskSum`

## Signature 

```
/// See Availability 1
T WaveMaskSum<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskSum<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskSum<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskAllEqual`

## Signature 

```
/// See Availability 1
bool WaveMaskAllEqual<T>(
    uint                 mask,
    T                    value);
bool WaveMaskAllEqual<T, N:int>(
    uint                 mask,
    vector<T,N>          value);
/// See Availability 2
bool WaveMaskAllEqual<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        value);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3` **HLSL** **CUDA** `SM 7.0` 
2. **HLSL** **CUDA** `SM 7.0` 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `value`

--------------------------------------------------------------------------------
# `WaveMaskPrefixProduct`

## Signature 

```
/// See Availability 1
T WaveMaskPrefixProduct<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskPrefixProduct<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskPrefixProduct<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskPrefixSum`

## Signature 

```
/// See Availability 1
T WaveMaskPrefixSum<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskPrefixSum<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskPrefixSum<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskReadLaneFirst`

## Signature 

```
/// See Availability 1
T WaveMaskReadLaneFirst<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskReadLaneFirst<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskReadLaneFirst<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskMatch`

## Signature 

```
uint WaveMaskMatch<T>(
    uint                 mask,
    T                    value);
uint WaveMaskMatch<T, N:int>(
    uint                 mask,
    vector<T,N>          value);
uint WaveMaskMatch<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        value);
```

## Availability

**HLSL** **CUDA** `SM 7.0` 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `value`

--------------------------------------------------------------------------------
# `WaveMaskPrefixBitAnd`

## Signature 

```
/// See Availability 1
T WaveMaskPrefixBitAnd<T>(
    uint                 mask,
    T                    expr);
/// See Availability 2
vector<T,N> WaveMaskPrefixBitAnd<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 3
matrix<T,N,M> WaveMaskPrefixBitAnd<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
3. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskPrefixBitOr`

## Signature 

```
/// See Availability 1
T WaveMaskPrefixBitOr<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskPrefixBitOr<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskPrefixBitOr<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `WaveMaskPrefixBitXor`

## Signature 

```
/// See Availability 1
T WaveMaskPrefixBitXor<T>(
    uint                 mask,
    T                    expr);
vector<T,N> WaveMaskPrefixBitXor<T, N:int>(
    uint                 mask,
    vector<T,N>          expr);
/// See Availability 2
matrix<T,N,M> WaveMaskPrefixBitXor<T, N:int, M:int>(
    uint                 mask,
    matrix<T,N,M>        expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `mask`
* `expr`

--------------------------------------------------------------------------------
# `QuadReadLaneAt`

## Signature 

```
T QuadReadLaneAt<T>(
    T                    sourceValue,
    uint                 quadLaneID);
vector<T,N> QuadReadLaneAt<T, N:int>(
    vector<T,N>          sourceValue,
    uint                 quadLaneID);
matrix<T,N,M> QuadReadLaneAt<T, N:int, M:int>(
    matrix<T,N,M>        sourceValue,
    uint                 quadLaneID);
```

## Parameters

* `T`
* `N`
* `M`
* `sourceValue`
* `quadLaneID`

--------------------------------------------------------------------------------
# `QuadReadAcrossX`

## Signature 

```
T QuadReadAcrossX<T>(T localValue);
vector<T,N> QuadReadAcrossX<T, N:int>(vector<T,N> localValue);
matrix<T,N,M> QuadReadAcrossX<T, N:int, M:int>(matrix<T,N,M> localValue);
```

## Parameters

* `T`
* `N`
* `M`
* `localValue`

--------------------------------------------------------------------------------
# `QuadReadAcrossY`

## Signature 

```
T QuadReadAcrossY<T>(T localValue);
vector<T,N> QuadReadAcrossY<T, N:int>(vector<T,N> localValue);
matrix<T,N,M> QuadReadAcrossY<T, N:int, M:int>(matrix<T,N,M> localValue);
```

## Parameters

* `T`
* `N`
* `M`
* `localValue`

--------------------------------------------------------------------------------
# `QuadReadAcrossDiagonal`

## Signature 

```
T QuadReadAcrossDiagonal<T>(T localValue);
vector<T,N> QuadReadAcrossDiagonal<T, N:int>(vector<T,N> localValue);
matrix<T,N,M> QuadReadAcrossDiagonal<T, N:int, M:int>(matrix<T,N,M> localValue);
```

## Parameters

* `T`
* `N`
* `M`
* `localValue`

--------------------------------------------------------------------------------
# `WaveActiveBitAnd`

## Signature 

```
/// See Availability 1
T WaveActiveBitAnd<T>(T expr);
vector<T,N> WaveActiveBitAnd<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WaveActiveBitAnd<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveActiveBitOr`

## Signature 

```
/// See Availability 1
T WaveActiveBitOr<T>(T expr);
vector<T,N> WaveActiveBitOr<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WaveActiveBitOr<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveActiveBitXor`

## Signature 

```
/// See Availability 1
T WaveActiveBitXor<T>(T expr);
vector<T,N> WaveActiveBitXor<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WaveActiveBitXor<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveActiveMax`

## Signature 

```
/// See Availability 1
T WaveActiveMax<T>(T expr);
vector<T,N> WaveActiveMax<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WaveActiveMax<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveActiveMin`

## Signature 

```
/// See Availability 1
T WaveActiveMin<T>(T expr);
vector<T,N> WaveActiveMin<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WaveActiveMin<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveActiveProduct`

## Signature 

```
/// See Availability 1
T WaveActiveProduct<T>(T expr);
vector<T,N> WaveActiveProduct<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WaveActiveProduct<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveActiveSum`

## Signature 

```
/// See Availability 1
T WaveActiveSum<T>(T expr);
vector<T,N> WaveActiveSum<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WaveActiveSum<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveActiveAllEqual`

## Signature 

```
/// See Availability 1
bool WaveActiveAllEqual<T>(T value);
bool WaveActiveAllEqual<T, N:int>(vector<T,N> value);
/// See Availability 2
bool WaveActiveAllEqual<T, N:int, M:int>(matrix<T,N,M> value);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `value`

--------------------------------------------------------------------------------
# `WaveActiveAllTrue`

## Signature 

```
bool WaveActiveAllTrue(bool condition);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3` **HLSL** 

## Parameters

* `condition`

--------------------------------------------------------------------------------
# `WaveActiveAnyTrue`

## Signature 

```
bool WaveActiveAnyTrue(bool condition);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3` **HLSL** 

## Parameters

* `condition`

--------------------------------------------------------------------------------
# `WaveActiveBallot`

## Signature 

```
vector<uint,4> WaveActiveBallot(bool condition);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** 

## Parameters

* `condition`

--------------------------------------------------------------------------------
# `WaveActiveCountBits`

## Signature 

```
uint WaveActiveCountBits(bool value);
```

## Parameters

* `value`

--------------------------------------------------------------------------------
# `WaveGetLaneCount`

## Signature 

```
uint WaveGetLaneCount();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `WaveGetLaneIndex`

## Signature 

```
uint WaveGetLaneIndex();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `WaveIsFirstLane`

## Signature 

```
bool WaveIsFirstLane();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3` **HLSL** 

--------------------------------------------------------------------------------
# `_WaveCountBits`

## Signature 

```
uint _WaveCountBits(vector<uint,4> value);
```

## Parameters

* `value`

--------------------------------------------------------------------------------
# `WavePrefixProduct`

## Signature 

```
/// See Availability 1
T WavePrefixProduct<T>(T expr);
vector<T,N> WavePrefixProduct<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WavePrefixProduct<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WavePrefixSum`

## Signature 

```
/// See Availability 1
T WavePrefixSum<T>(T expr);
vector<T,N> WavePrefixSum<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WavePrefixSum<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveReadLaneFirst`

## Signature 

```
/// See Availability 1
T WaveReadLaneFirst<T>(T expr);
vector<T,N> WaveReadLaneFirst<T, N:int>(vector<T,N> expr);
/// See Availability 2
matrix<T,N,M> WaveReadLaneFirst<T, N:int, M:int>(matrix<T,N,M> expr);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `expr`

--------------------------------------------------------------------------------
# `WaveBroadcastLaneAt`

## Signature 

```
/// See Availability 1
T WaveBroadcastLaneAt<T>(
    T                    value,
    int                  lane);
vector<T,N> WaveBroadcastLaneAt<T, N:int>(
    vector<T,N>          value,
    int                  lane);
/// See Availability 2
matrix<T,N,M> WaveBroadcastLaneAt<T, N:int, M:int>(
    matrix<T,N,M>        value,
    int                  lane);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `value`
* `lane`

--------------------------------------------------------------------------------
# `WaveReadLaneAt`

## Signature 

```
/// See Availability 1
T WaveReadLaneAt<T>(
    T                    value,
    int                  lane);
vector<T,N> WaveReadLaneAt<T, N:int>(
    vector<T,N>          value,
    int                  lane);
/// See Availability 2
matrix<T,N,M> WaveReadLaneAt<T, N:int, M:int>(
    matrix<T,N,M>        value,
    int                  lane);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_shuffle`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `value`
* `lane`

--------------------------------------------------------------------------------
# `WaveShuffle`

## Signature 

```
/// See Availability 1
T WaveShuffle<T>(
    T                    value,
    int                  lane);
vector<T,N> WaveShuffle<T, N:int>(
    vector<T,N>          value,
    int                  lane);
/// See Availability 2
matrix<T,N,M> WaveShuffle<T, N:int, M:int>(
    matrix<T,N,M>        value,
    int                  lane);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_shuffle`, `SPIR-V 1.3` **HLSL** 
2. **HLSL** 

## Parameters

* `T`
* `N`
* `M`
* `value`
* `lane`

--------------------------------------------------------------------------------
# `WavePrefixCountBits`

## Signature 

```
uint WavePrefixCountBits(bool value);
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** 

## Parameters

* `value`

--------------------------------------------------------------------------------
# `WaveGetConvergedMulti`

## Signature 

```
vector<uint,4> WaveGetConvergedMulti();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `WaveGetActiveMulti`

## Signature 

```
vector<uint,4> WaveGetActiveMulti();
```

## Availability

**GLSL** `GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3` **HLSL** 

--------------------------------------------------------------------------------
# `WaveMatch`

## Signature 

```
vector<uint,4> WaveMatch<T>(T value);
vector<uint,4> WaveMatch<T, N:int>(vector<T,N> value);
vector<uint,4> WaveMatch<T, N:int, M:int>(matrix<T,N,M> value);
```

## Parameters

* `T`
* `N`
* `M`
* `value`

--------------------------------------------------------------------------------
# `WaveMultiPrefixCountBits`

## Signature 

```
uint WaveMultiPrefixCountBits(
    bool                 value,
    vector<uint,4>       mask);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `value`
* `mask`

--------------------------------------------------------------------------------
# `WaveMultiPrefixBitAnd`

## Signature 

```
/// See Availability 1
T WaveMultiPrefixBitAnd<T>(
    T                    expr,
    vector<uint,4>       mask);
vector<T,N> WaveMultiPrefixBitAnd<T, N:int>(
    vector<T,N>          expr,
    vector<uint,4>       mask);
/// See Availability 2
matrix<T,N,M> WaveMultiPrefixBitAnd<T, N:int, M:int>(
    matrix<T,N,M>        expr,
    vector<uint,4>       mask);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `expr`
* `mask`

--------------------------------------------------------------------------------
# `WaveMultiPrefixBitOr`

## Signature 

```
/// See Availability 1
T WaveMultiPrefixBitOr<T>(
    T                    expr,
    vector<uint,4>       mask);
vector<T,N> WaveMultiPrefixBitOr<T, N:int>(
    vector<T,N>          expr,
    vector<uint,4>       mask);
/// See Availability 2
matrix<T,N,M> WaveMultiPrefixBitOr<T, N:int, M:int>(
    matrix<T,N,M>        expr,
    vector<uint,4>       mask);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `expr`
* `mask`

--------------------------------------------------------------------------------
# `WaveMultiPrefixBitXor`

## Signature 

```
/// See Availability 1
T WaveMultiPrefixBitXor<T>(
    T                    expr,
    vector<uint,4>       mask);
vector<T,N> WaveMultiPrefixBitXor<T, N:int>(
    vector<T,N>          expr,
    vector<uint,4>       mask);
/// See Availability 2
matrix<T,N,M> WaveMultiPrefixBitXor<T, N:int, M:int>(
    matrix<T,N,M>        expr,
    vector<uint,4>       mask);
```

## Availability

1. **GLSL** `GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3` **HLSL** **CUDA** 
2. **HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `expr`
* `mask`

--------------------------------------------------------------------------------
# `WaveMultiPrefixProduct`

## Signature 

```
T WaveMultiPrefixProduct<T>(
    T                    value,
    vector<uint,4>       mask);
vector<T,N> WaveMultiPrefixProduct<T, N:int>(
    vector<T,N>          value,
    vector<uint,4>       mask);
matrix<T,N,M> WaveMultiPrefixProduct<T, N:int, M:int>(
    matrix<T,N,M>        value,
    vector<uint,4>       mask);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `value`
* `mask`

--------------------------------------------------------------------------------
# `WaveMultiPrefixSum`

## Signature 

```
T WaveMultiPrefixSum<T>(
    T                    value,
    vector<uint,4>       mask);
vector<T,N> WaveMultiPrefixSum<T, N:int>(
    vector<T,N>          value,
    vector<uint,4>       mask);
matrix<T,N,M> WaveMultiPrefixSum<T, N:int, M:int>(
    matrix<T,N,M>        value,
    vector<uint,4>       mask);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `T`
* `N`
* `M`
* `value`
* `mask`

--------------------------------------------------------------------------------
# `struct Buffer<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `Buffer<T>.GetDimensions`

## Signature 

```
void Buffer<T>.GetDimensions(out uint dim);
```

## Parameters

* `dim`

--------------------------------------------------------------------------------
# `Buffer<T>.Load`

## Signature 

```
/// See Availability 1
T Buffer<T>.Load(int location);
/// See Availability 2
T Buffer<T>.Load(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `Buffer<T>.subscript`

## Signature 

```
T Buffer<T>.subscript(uint index);
```

## Parameters

* `index`

--------------------------------------------------------------------------------
# `struct RWBuffer<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RWBuffer<T>.GetDimensions`

## Signature 

```
void RWBuffer<T>.GetDimensions(out uint dim);
```

## Parameters

* `dim`

--------------------------------------------------------------------------------
# `RWBuffer<T>.Load`

## Signature 

```
/// See Availability 1
T RWBuffer<T>.Load(int location);
/// See Availability 2
T RWBuffer<T>.Load(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RWBuffer<T>.subscript`

## Signature 

```
T RWBuffer<T>.subscript(uint index);
```

## Parameters

* `index`

--------------------------------------------------------------------------------
# `struct RasterizerOrderedBuffer<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`
* `Load`
* `subscript`

--------------------------------------------------------------------------------
# `RasterizerOrderedBuffer<T>.GetDimensions`

## Signature 

```
void RasterizerOrderedBuffer<T>.GetDimensions(out uint dim);
```

## Parameters

* `dim`

--------------------------------------------------------------------------------
# `RasterizerOrderedBuffer<T>.Load`

## Signature 

```
/// See Availability 1
T RasterizerOrderedBuffer<T>.Load(int location);
/// See Availability 2
T RasterizerOrderedBuffer<T>.Load(
    int                  location,
    out uint             status);
```

## Availability

1. **GLSL** `GL_EXT_samplerless_texture_functions` **HLSL** 
2. **HLSL** 

## Parameters

* `location`
* `status`

--------------------------------------------------------------------------------
# `RasterizerOrderedBuffer<T>.subscript`

## Signature 

```
T RasterizerOrderedBuffer<T>.subscript(uint index);
```

## Parameters

* `index`

--------------------------------------------------------------------------------
# RAY_FLAG_NONE

```
uint RAY_FLAG_NONE
```

--------------------------------------------------------------------------------
# RAY_FLAG_FORCE_OPAQUE

```
uint RAY_FLAG_FORCE_OPAQUE
```

--------------------------------------------------------------------------------
# RAY_FLAG_FORCE_NON_OPAQUE

```
uint RAY_FLAG_FORCE_NON_OPAQUE
```

--------------------------------------------------------------------------------
# RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH

```
uint RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH
```

--------------------------------------------------------------------------------
# RAY_FLAG_SKIP_CLOSEST_HIT_SHADER

```
uint RAY_FLAG_SKIP_CLOSEST_HIT_SHADER
```

--------------------------------------------------------------------------------
# RAY_FLAG_CULL_BACK_FACING_TRIANGLES

```
uint RAY_FLAG_CULL_BACK_FACING_TRIANGLES
```

--------------------------------------------------------------------------------
# RAY_FLAG_CULL_FRONT_FACING_TRIANGLES

```
uint RAY_FLAG_CULL_FRONT_FACING_TRIANGLES
```

--------------------------------------------------------------------------------
# RAY_FLAG_CULL_OPAQUE

```
uint RAY_FLAG_CULL_OPAQUE
```

--------------------------------------------------------------------------------
# RAY_FLAG_CULL_NON_OPAQUE

```
uint RAY_FLAG_CULL_NON_OPAQUE
```

--------------------------------------------------------------------------------
# RAY_FLAG_SKIP_TRIANGLES

```
uint RAY_FLAG_SKIP_TRIANGLES
```

--------------------------------------------------------------------------------
# RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES

```
uint RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES
```

--------------------------------------------------------------------------------
# `struct RayDesc`

## Fields

* `Origin`
* `TMin`
* `Direction`
* `TMax`

--------------------------------------------------------------------------------
# `struct RaytracingAccelerationStructure`

--------------------------------------------------------------------------------
# `struct BuiltInTriangleIntersectionAttributes`

## Fields

* `barycentrics`

--------------------------------------------------------------------------------
# `CallShader`

## Signature 

```
void CallShader<Payload>(
    uint                 shaderIndex,
    inout Payload        payload);
```

## Parameters

* `Payload`
* `shaderIndex`
* `payload`

--------------------------------------------------------------------------------
# `TraceRay`

## Signature 

```
void TraceRay<payload_t>(
    RaytracingAccelerationStructure AccelerationStructure,
    uint                 RayFlags,
    uint                 InstanceInclusionMask,
    uint                 RayContributionToHitGroupIndex,
    uint                 MultiplierForGeometryContributionToHitGroupIndex,
    uint                 MissShaderIndex,
    RayDesc              Ray,
    inout payload_t      Payload);
```

## Availability

**HLSL** **CUDA** 

## Parameters

* `payload_t`
* `AccelerationStructure`
* `RayFlags`
* `InstanceInclusionMask`
* `RayContributionToHitGroupIndex`
* `MultiplierForGeometryContributionToHitGroupIndex`
* `MissShaderIndex`
* `Ray`
* `Payload`

--------------------------------------------------------------------------------
# `TraceMotionRay`

## Signature 

```
void TraceMotionRay<payload_t>(
    RaytracingAccelerationStructure AccelerationStructure,
    uint                 RayFlags,
    uint                 InstanceInclusionMask,
    uint                 RayContributionToHitGroupIndex,
    uint                 MultiplierForGeometryContributionToHitGroupIndex,
    uint                 MissShaderIndex,
    RayDesc              Ray,
    float                CurrentTime,
    inout payload_t      Payload);
```

## Parameters

* `payload_t`
* `AccelerationStructure`
* `RayFlags`
* `InstanceInclusionMask`
* `RayContributionToHitGroupIndex`
* `MultiplierForGeometryContributionToHitGroupIndex`
* `MissShaderIndex`
* `Ray`
* `CurrentTime`
* `Payload`

--------------------------------------------------------------------------------
# `ReportHit`

## Signature 

```
bool ReportHit<A>(
    float                tHit,
    uint                 hitKind,
    A                    attributes);
```

## Parameters

* `A`
* `tHit`
* `hitKind`
* `attributes`

--------------------------------------------------------------------------------
# `IgnoreHit`

## Signature 

```
void IgnoreHit();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `AcceptHitAndEndSearch`

## Signature 

```
void AcceptHitAndEndSearch();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `DispatchRaysIndex`

## Signature 

```
vector<uint,3> DispatchRaysIndex();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `DispatchRaysDimensions`

## Signature 

```
vector<uint,3> DispatchRaysDimensions();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `WorldRayOrigin`

## Signature 

```
vector<float,3> WorldRayOrigin();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `WorldRayDirection`

## Signature 

```
vector<float,3> WorldRayDirection();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `RayTMin`

## Signature 

```
float RayTMin();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `RayTCurrent`

## Signature 

```
float RayTCurrent();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `RayFlags`

## Signature 

```
uint RayFlags();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `InstanceIndex`

## Signature 

```
uint InstanceIndex();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `InstanceID`

## Signature 

```
uint InstanceID();
```

## Availability

**GLSL** `__glslRayTracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `PrimitiveIndex`

## Signature 

```
uint PrimitiveIndex();
```

## Availability

**GLSL** `__glslRayTracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `ObjectRayOrigin`

## Signature 

```
vector<float,3> ObjectRayOrigin();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `ObjectRayDirection`

## Signature 

```
vector<float,3> ObjectRayDirection();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# `ObjectToWorld3x4`

## Signature 

```
matrix<float,3,4> ObjectToWorld3x4();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** 

--------------------------------------------------------------------------------
# `WorldToObject3x4`

## Signature 

```
matrix<float,3,4> WorldToObject3x4();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** 

--------------------------------------------------------------------------------
# `ObjectToWorld4x3`

## Signature 

```
matrix<float,4,3> ObjectToWorld4x3();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** 

--------------------------------------------------------------------------------
# `WorldToObject4x3`

## Signature 

```
matrix<float,4,3> WorldToObject4x3();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** 

--------------------------------------------------------------------------------
# `RayCurrentTime`

## Signature 

```
float RayCurrentTime();
```

## Availability

**GLSL** `GLSL460`, `GL_NV_ray_tracing_motion_blur` **HLSL** 

--------------------------------------------------------------------------------
# `ObjectToWorld`

## Signature 

```
matrix<float,3,4> ObjectToWorld();
```

--------------------------------------------------------------------------------
# `WorldToObject`

## Signature 

```
matrix<float,3,4> WorldToObject();
```

--------------------------------------------------------------------------------
# `HitKind`

## Signature 

```
uint HitKind();
```

## Availability

**GLSL** `GL_EXT_ray_tracing`, `GL_NV_ray_tracing` **HLSL** **CUDA** 

--------------------------------------------------------------------------------
# HIT_KIND_TRIANGLE_FRONT_FACE

```
uint HIT_KIND_TRIANGLE_FRONT_FACE
```

--------------------------------------------------------------------------------
# HIT_KIND_TRIANGLE_BACK_FACE

```
uint HIT_KIND_TRIANGLE_BACK_FACE
```

--------------------------------------------------------------------------------
# `dot4add_u8packed`

## Signature 

```
uint dot4add_u8packed(
    uint                 left,
    uint                 right,
    uint                 acc);
```

## Parameters

* `left`
* `right`
* `acc`

--------------------------------------------------------------------------------
# `dot4add_i8packed`

## Signature 

```
int dot4add_i8packed(
    uint                 left,
    uint                 right,
    int                  acc);
```

## Parameters

* `left`
* `right`
* `acc`

--------------------------------------------------------------------------------
# `dot2add`

## Signature 

```
float dot2add(
    vector<float,2>      left,
    vector<float,2>      right,
    float                acc);
```

## Parameters

* `left`
* `right`
* `acc`

--------------------------------------------------------------------------------
# `SetMeshOutputCounts`

## Signature 

```
void SetMeshOutputCounts(
    uint                 vertexCount,
    uint                 primitiveCount);
```

## Parameters

* `vertexCount`
* `primitiveCount`

--------------------------------------------------------------------------------
# `DispatchMesh`

## Signature 

```
void DispatchMesh<P>(
    uint                 threadGroupCountX,
    uint                 threadGroupCountY,
    uint                 threadGroupCountZ,
    P                    meshPayload);
```

## Parameters

* `P`
* `threadGroupCountX`
* `threadGroupCountY`
* `threadGroupCountZ`
* `meshPayload`

--------------------------------------------------------------------------------
# `struct SAMPLER_FEEDBACK_MIN_MIP`

*Implements:* `__BuiltinSamplerFeedbackType`

--------------------------------------------------------------------------------
# `struct SAMPLER_FEEDBACK_MIP_REGION_USED`

*Implements:* `__BuiltinSamplerFeedbackType`

--------------------------------------------------------------------------------
# `struct FeedbackTexture2D<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`

--------------------------------------------------------------------------------
# `FeedbackTexture2D<T>.GetDimensions`

## Signature 

```
void FeedbackTexture2D<T>.GetDimensions(
    out uint             width,
    out uint             height);
void FeedbackTexture2D<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             numberOfLevels);
void FeedbackTexture2D<T>.GetDimensions(
    out float            width,
    out float            height);
void FeedbackTexture2D<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            numberOfLevels);
```

## Parameters

* `width`
* `height`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `FeedbackTexture2D<T>.WriteSamplerFeedbackLevel`

## Signature 

```
void FeedbackTexture2D<T>.WriteSamplerFeedbackLevel<S>(
    Texture2D            tex,
    SamplerState         samp,
    vector<float,2>      location,
    float                lod);
```

## Availability

**HLSL** **CPP** 

## Parameters

* `S`
* `tex`
* `samp`
* `location`
* `lod`

--------------------------------------------------------------------------------
# `FeedbackTexture2D<T>.WriteSamplerFeedback`

## Signature 

```
void FeedbackTexture2D<T>.WriteSamplerFeedback<S>(
    Texture2D            tex,
    SamplerState         samp,
    vector<float,2>      location,
    float                clamp);
void FeedbackTexture2D<T>.WriteSamplerFeedback<S>(
    Texture2D            tex,
    SamplerState         samp,
    vector<float,2>      location);
```

## Availability

**HLSL** **CPP** 

## Parameters

* `S`
* `tex`
* `samp`
* `location`
* `clamp`

--------------------------------------------------------------------------------
# `FeedbackTexture2D<T>.WriteSamplerFeedbackBias`

## Signature 

```
void FeedbackTexture2D<T>.WriteSamplerFeedbackBias<S>(
    Texture2D            tex,
    SamplerState         samp,
    vector<float,2>      location,
    float                bias,
    float                clamp);
void FeedbackTexture2D<T>.WriteSamplerFeedbackBias<S>(
    Texture2D            tex,
    SamplerState         samp,
    vector<float,2>      location,
    float                bias);
```

## Availability

**HLSL** **CPP** 

## Parameters

* `S`
* `tex`
* `samp`
* `location`
* `bias`
* `clamp`

--------------------------------------------------------------------------------
# `FeedbackTexture2D<T>.WriteSamplerFeedbackGrad`

## Signature 

```
void FeedbackTexture2D<T>.WriteSamplerFeedbackGrad<S>(
    Texture2D            tex,
    SamplerState         samp,
    vector<float,2>      location,
    vector<float,2>      ddx,
    vector<float,2>      ddy,
    float                clamp);
void FeedbackTexture2D<T>.WriteSamplerFeedbackGrad<S>(
    Texture2D            tex,
    SamplerState         samp,
    vector<float,2>      location,
    vector<float,2>      ddx,
    vector<float,2>      ddy);
```

## Availability

**HLSL** **CPP** 

## Parameters

* `S`
* `tex`
* `samp`
* `location`
* `ddx`
* `ddy`
* `clamp`

--------------------------------------------------------------------------------
# `struct FeedbackTexture2DArray<T>`

## Generic Parameters

* `T`

## Methods

* `GetDimensions`

--------------------------------------------------------------------------------
# `FeedbackTexture2DArray<T>.GetDimensions`

## Signature 

```
void FeedbackTexture2DArray<T>.GetDimensions(
    out uint             width,
    out uint             height,
    out uint             elements);
void FeedbackTexture2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out uint             width,
    out uint             height,
    out uint             elements,
    out uint             numberOfLevels);
void FeedbackTexture2DArray<T>.GetDimensions(
    out float            width,
    out float            height,
    out float            elements);
void FeedbackTexture2DArray<T>.GetDimensions(
    uint                 mipLevel,
    out float            width,
    out float            height,
    out float            elements,
    out float            numberOfLevels);
```

## Parameters

* `width`
* `height`
* `elements`
* `mipLevel`
* `numberOfLevels`

--------------------------------------------------------------------------------
# `FeedbackTexture2DArray<T>.WriteSamplerFeedbackLevel`

## Signature 

```
void FeedbackTexture2DArray<T>.WriteSamplerFeedbackLevel<S>(
    Texture2DArray       texArray,
    SamplerState         samp,
    vector<float,3>      location,
    float                lod);
```

## Availability

**HLSL** **CPP** 

## Parameters

* `S`
* `texArray`
* `samp`
* `location`
* `lod`

--------------------------------------------------------------------------------
# `FeedbackTexture2DArray<T>.WriteSamplerFeedback`

## Signature 

```
void FeedbackTexture2DArray<T>.WriteSamplerFeedback<S>(
    Texture2DArray       texArray,
    SamplerState         samp,
    vector<float,3>      location,
    float                clamp);
void FeedbackTexture2DArray<T>.WriteSamplerFeedback<S>(
    Texture2DArray       texArray,
    SamplerState         samp,
    vector<float,3>      location);
```

## Availability

**HLSL** **CPP** 

## Parameters

* `S`
* `texArray`
* `samp`
* `location`
* `clamp`

--------------------------------------------------------------------------------
# `FeedbackTexture2DArray<T>.WriteSamplerFeedbackBias`

## Signature 

```
void FeedbackTexture2DArray<T>.WriteSamplerFeedbackBias<S>(
    Texture2DArray       texArray,
    SamplerState         samp,
    vector<float,3>      location,
    float                bias,
    float                clamp);
void FeedbackTexture2DArray<T>.WriteSamplerFeedbackBias<S>(
    Texture2DArray       texArray,
    SamplerState         samp,
    vector<float,3>      location,
    float                bias);
```

## Availability

**HLSL** **CPP** 

## Parameters

* `S`
* `texArray`
* `samp`
* `location`
* `bias`
* `clamp`

--------------------------------------------------------------------------------
# `FeedbackTexture2DArray<T>.WriteSamplerFeedbackGrad`

## Signature 

```
void FeedbackTexture2DArray<T>.WriteSamplerFeedbackGrad<S>(
    Texture2DArray       texArray,
    SamplerState         samp,
    vector<float,3>      location,
    vector<float,3>      ddx,
    vector<float,3>      ddy,
    float                clamp);
void FeedbackTexture2DArray<T>.WriteSamplerFeedbackGrad<S>(
    Texture2DArray       texArray,
    SamplerState         samp,
    vector<float,3>      location,
    vector<float,3>      ddx,
    vector<float,3>      ddy);
```

## Availability

**HLSL** **CPP** 

## Parameters

* `S`
* `texArray`
* `samp`
* `location`
* `ddx`
* `ddy`
* `clamp`

--------------------------------------------------------------------------------
# `GeometryIndex`

## Signature 

```
uint GeometryIndex();
```

## Availability

**GLSL** `GL_EXT_ray_tracing` **HLSL** 

--------------------------------------------------------------------------------
# COMMITTED_NOTHING

```
uint COMMITTED_NOTHING
```

--------------------------------------------------------------------------------
# COMMITTED_TRIANGLE_HIT

```
uint COMMITTED_TRIANGLE_HIT
```

--------------------------------------------------------------------------------
# COMMITTED_PROCEDURAL_PRIMITIVE_HIT

```
uint COMMITTED_PROCEDURAL_PRIMITIVE_HIT
```

--------------------------------------------------------------------------------
# CANDIDATE_NON_OPAQUE_TRIANGLE

```
uint CANDIDATE_NON_OPAQUE_TRIANGLE
```

--------------------------------------------------------------------------------
# CANDIDATE_PROCEDURAL_PRIMITIVE

```
uint CANDIDATE_PROCEDURAL_PRIMITIVE
```

--------------------------------------------------------------------------------
# `struct RayQuery<rayFlags:uint>`

## Generic Parameters

* `rayFlags`

## Methods

* `init`
* `TraceRayInline`
* `Proceed`
* `Abort`
* `CandidateType`
* `CandidateObjectToWorld3x4`
* `CandidateObjectToWorld4x3`
* `CandidateWorldToObject3x4`
* `CandidateWorldToObject4x3`
* `CandidateInstanceIndex`
* `CandidateInstanceID`
* `CandidateGeometryIndex`
* `CandidatePrimitiveIndex`
* `CandidateInstanceContributionToHitGroupIndex`
* `CandidateObjectRayOrigin`
* `CandidateObjectRayDirection`
* `CandidateProceduralPrimitiveNonOpaque`
* `CandidateTriangleFrontFace`
* `CandidateTriangleBarycentrics`
* `CandidateTriangleRayT`
* `CommitNonOpaqueTriangleHit`
* `CommitProceduralPrimitiveHit`
* `CommittedStatus`
* `CommittedObjectToWorld3x4`
* `CommittedObjectToWorld4x3`
* `CommittedWorldToObject3x4`
* `CommittedWorldToObject4x3`
* `CommittedRayT`
* `CommittedInstanceIndex`
* `CommittedInstanceID`
* `CommittedGeometryIndex`
* `CommittedPrimitiveIndex`
* `CommittedInstanceContributionToHitGroupIndex`
* `CommittedObjectRayOrigin`
* `CommittedObjectRayDirection`
* `CommittedTriangleFrontFace`
* `CommittedTriangleBarycentrics`
* `RayFlags`
* `WorldRayOrigin`
* `WorldRayDirection`
* `RayTMin`

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.init`

## Signature 

```
RayQuery<rayFlags:uint>.init();
```

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.TraceRayInline`

## Signature 

```
void RayQuery<rayFlags:uint>.TraceRayInline(
    RaytracingAccelerationStructure accelerationStructure,
    uint                 rayFlags,
    uint                 instanceInclusionMask,
    RayDesc              ray);
```

## Parameters

* `accelerationStructure`
* `rayFlags`
* `instanceInclusionMask`
* `ray`

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.Proceed`

## Signature 

```
bool RayQuery<rayFlags:uint>.Proceed();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.Abort`

## Signature 

```
void RayQuery<rayFlags:uint>.Abort();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateType`

## Signature 

```
uint RayQuery<rayFlags:uint>.CandidateType();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateObjectToWorld3x4`

## Signature 

```
matrix<float,3,4> RayQuery<rayFlags:uint>.CandidateObjectToWorld3x4();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateObjectToWorld4x3`

## Signature 

```
matrix<float,4,3> RayQuery<rayFlags:uint>.CandidateObjectToWorld4x3();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateWorldToObject3x4`

## Signature 

```
matrix<float,3,4> RayQuery<rayFlags:uint>.CandidateWorldToObject3x4();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateWorldToObject4x3`

## Signature 

```
matrix<float,4,3> RayQuery<rayFlags:uint>.CandidateWorldToObject4x3();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateInstanceIndex`

## Signature 

```
uint RayQuery<rayFlags:uint>.CandidateInstanceIndex();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateInstanceID`

## Signature 

```
uint RayQuery<rayFlags:uint>.CandidateInstanceID();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateGeometryIndex`

## Signature 

```
uint RayQuery<rayFlags:uint>.CandidateGeometryIndex();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidatePrimitiveIndex`

## Signature 

```
uint RayQuery<rayFlags:uint>.CandidatePrimitiveIndex();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateInstanceContributionToHitGroupIndex`

## Signature 

```
uint RayQuery<rayFlags:uint>.CandidateInstanceContributionToHitGroupIndex();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateObjectRayOrigin`

## Signature 

```
vector<float,3> RayQuery<rayFlags:uint>.CandidateObjectRayOrigin();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateObjectRayDirection`

## Signature 

```
vector<float,3> RayQuery<rayFlags:uint>.CandidateObjectRayDirection();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateProceduralPrimitiveNonOpaque`

## Signature 

```
bool RayQuery<rayFlags:uint>.CandidateProceduralPrimitiveNonOpaque();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateTriangleFrontFace`

## Signature 

```
bool RayQuery<rayFlags:uint>.CandidateTriangleFrontFace();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateTriangleBarycentrics`

## Signature 

```
vector<float,2> RayQuery<rayFlags:uint>.CandidateTriangleBarycentrics();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CandidateTriangleRayT`

## Signature 

```
float RayQuery<rayFlags:uint>.CandidateTriangleRayT();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommitNonOpaqueTriangleHit`

## Signature 

```
void RayQuery<rayFlags:uint>.CommitNonOpaqueTriangleHit();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommitProceduralPrimitiveHit`

## Signature 

```
void RayQuery<rayFlags:uint>.CommitProceduralPrimitiveHit(float t);
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

## Parameters

* `t`

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedStatus`

## Signature 

```
uint RayQuery<rayFlags:uint>.CommittedStatus();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedObjectToWorld3x4`

## Signature 

```
matrix<float,3,4> RayQuery<rayFlags:uint>.CommittedObjectToWorld3x4();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedObjectToWorld4x3`

## Signature 

```
matrix<float,4,3> RayQuery<rayFlags:uint>.CommittedObjectToWorld4x3();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedWorldToObject3x4`

## Signature 

```
matrix<float,3,4> RayQuery<rayFlags:uint>.CommittedWorldToObject3x4();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedWorldToObject4x3`

## Signature 

```
matrix<float,4,3> RayQuery<rayFlags:uint>.CommittedWorldToObject4x3();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedRayT`

## Signature 

```
float RayQuery<rayFlags:uint>.CommittedRayT();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedInstanceIndex`

## Signature 

```
uint RayQuery<rayFlags:uint>.CommittedInstanceIndex();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedInstanceID`

## Signature 

```
uint RayQuery<rayFlags:uint>.CommittedInstanceID();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedGeometryIndex`

## Signature 

```
uint RayQuery<rayFlags:uint>.CommittedGeometryIndex();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedPrimitiveIndex`

## Signature 

```
uint RayQuery<rayFlags:uint>.CommittedPrimitiveIndex();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedInstanceContributionToHitGroupIndex`

## Signature 

```
uint RayQuery<rayFlags:uint>.CommittedInstanceContributionToHitGroupIndex();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedObjectRayOrigin`

## Signature 

```
vector<float,3> RayQuery<rayFlags:uint>.CommittedObjectRayOrigin();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedObjectRayDirection`

## Signature 

```
vector<float,3> RayQuery<rayFlags:uint>.CommittedObjectRayDirection();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedTriangleFrontFace`

## Signature 

```
bool RayQuery<rayFlags:uint>.CommittedTriangleFrontFace();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.CommittedTriangleBarycentrics`

## Signature 

```
vector<float,2> RayQuery<rayFlags:uint>.CommittedTriangleBarycentrics();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.RayFlags`

## Signature 

```
uint RayQuery<rayFlags:uint>.RayFlags();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.WorldRayOrigin`

## Signature 

```
vector<float,3> RayQuery<rayFlags:uint>.WorldRayOrigin();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.WorldRayDirection`

## Signature 

```
vector<float,3> RayQuery<rayFlags:uint>.WorldRayDirection();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `RayQuery<rayFlags:uint>.RayTMin`

## Signature 

```
float RayQuery<rayFlags:uint>.RayTMin();
```

## Availability

**GLSL** `GLSL460`, `GL_EXT_ray_query` **HLSL** 

--------------------------------------------------------------------------------
# `struct VkSubpassInput<T>`

## Generic Parameters

* `T`

## Methods

* `SubpassLoad`

--------------------------------------------------------------------------------
# `VkSubpassInput<T>.SubpassLoad`

## Signature 

```
T VkSubpassInput<T>.SubpassLoad();
```

--------------------------------------------------------------------------------
# `struct VkSubpassInputMS<T>`

## Generic Parameters

* `T`

## Methods

* `SubpassLoad`

--------------------------------------------------------------------------------
# `VkSubpassInputMS<T>.SubpassLoad`

## Signature 

```
T VkSubpassInputMS<T>.SubpassLoad(int sampleIndex);
```

## Parameters

* `sampleIndex`



================================================
FILE: Source/External/slang/docs/target-compatibility.md
================================================
Slang Target Compatibility 
==========================

Shader Model (SM) numbers are D3D Shader Model versions, unless explicitly stated otherwise.
OpenGL compatibility is not listed here, because OpenGL isn't an officially supported target. 

Items with a + means that the feature is anticipated to be added in the future.
Items with ^ means there is some discussion about support later in the document for this target.

| Feature                     |    D3D11     |    D3D12     |     VK     |      CUDA     |    CPU
|-----------------------------|--------------|--------------|------------|---------------|---------------
| Half Type                   |     No       |     Yes ^    |   Yes      |     Yes ^     |    No +
| Double Type                 |     Yes      |     Yes      |   Yes      |     Yes       |    Yes
| Double Intrinsics           |     No       |   Limited +  |  Limited   |     Most      |    Yes
| u/int8_t Type               |     No       |   No         |   Yes ^    |     Yes       |    Yes
| u/int16_t Type              |     No       |   Yes ^      |   Yes ^    |     Yes       |    Yes
| u/int64_t Type              |     No       |   Yes ^      |   Yes      |     Yes       |    Yes
| u/int64_t Intrinsics        |     No       |   No         |   Yes      |     Yes       |    Yes
| int matrix                  |     Yes      |   Yes        |   No +     |     Yes       |    Yes
| tex.GetDimension            |     Yes      |   Yes        |   Yes      |     No        |    Yes
| SM6.0 Wave Intrinsics       |     No       |   Yes        |  Partial   |     Yes ^     |    No
| SM6.0 Quad Intrinsics       |     No       |   Yes        |   No +     |     No        |    No
| SM6.5 Wave Intrinsics       |     No       |   Yes ^      |   No +     |     Yes ^     |    No
| WaveMask Intrinsics         |     Yes ^    |   Yes ^      |   Yes +    |     Yes       |    No
| WaveShuffle                 |     No       |   Limited ^  |   Yes      |     Yes       |    No
| Tesselation                 |     Yes ^    |   Yes ^      |   No +     |     No        |    No
| Graphics Pipeline           |     Yes      |   Yes        |   Yes      |     No        |    No
| Ray Tracing DXR 1.0         |     No       |   Yes ^      |   Yes ^    |     No        |    No
| Ray Tracing DXR 1.1         |     No       |   Yes        |   No +     |     No        |    No
| Native Bindless             |     No       |    No        |   No       |     Yes       |    Yes
| Buffer bounds               |     Yes      |   Yes        |   Yes      |   Limited ^   |    Limited ^
| Resource bounds             |     Yes      |   Yes        |   Yes      | Yes (optional)|    Yes
| Atomics                     |     Yes      |   Yes        |   Yes      |     Yes       |    Yes
| Group shared mem/Barriers   |     Yes      |   Yes        |   Yes      |     Yes       |    No + 
| TextureArray.Sample float   |     Yes      |   Yes        |   Yes      |     No        |    Yes
| Separate Sampler            |     Yes      |   Yes        |   Yes      |     No        |    Yes
| tex.Load                    |     Yes      |   Yes        |   Yes      |  Limited ^    |    Yes
| Full bool                   |     Yes      |   Yes        |   Yes      |     No        |    Yes ^ 
| Mesh Shader                 |     No       |   No +       |   No +     |     No        |    No
| `[unroll]`                  |     Yes      |   Yes        |   Yes ^    |     Yes       |    Limited + 
| Atomics                     |     Yes      |   Yes        |   Yes      |     Yes       |    No + 
| Atomics on RWBuffer         |     Yes      |   Yes        |   Yes      |     No        |    No + 
| Sampler Feedback            |     No       |   Yes        |   No +     |     No        |    Yes ^
| RWByteAddressBuffer Atomic  |     No       |   Yes ^      |   Yes ^    |     Yes       |    No +

## Half Type

There appears to be a problem writing to a StructuredBuffer containing half on D3D12. D3D12 also appears to have problems doing calculations with half.

In order for half to work in CUDA, NVRTC must be able to include `cuda_fp16.h` and related files. Please read the [CUDA target documentation](cuda-target.md) for more details. 

## u/int8_t Type

Not currently supported in D3D11/D3D12 because not supported in HLSL/DXIL/DXBC. 

Supported in Vulkan via the extensions `GL_EXT_shader_explicit_arithmetic_types` and `GL_EXT_shader_8bit_storage`.

## u/int16_t Type

Requires SM6.2 which requires DXIL and therefore DXC and D3D12. For DXC this is discussed [here](https://github.com/Microsoft/DirectXShaderCompiler/wiki/16-Bit-Scalar-Types).

Supported in Vulkan via the extensions `GL_EXT_shader_explicit_arithmetic_types` and `GL_EXT_shader_16bit_storage`.

## u/int64_t Type

Requires SM6.0 which requires DXIL for D3D12. Therefore not available with DXBC on D3D11 or D3D12.

## int matrix

Means can use matrix types containing integer types. 

## tex.GetDimensions

tex.GetDimensions is the GetDimensions method on 'texture' objects. This is not supported on CUDA as CUDA has no equivalent functionality to get these values. GetDimensions work on Buffer resource types on CUDA.

## SM6.0 Wave Intrinsics

CUDA has premliminary support for Wave Intrinsics, introduced in [PR #1352](https://github.com/shader-slang/slang/pull/1352). Slang synthesizes the 'WaveMask' based on program flow and the implied 'programmer view' of exectution. This support is built on top of WaveMask intrinsics with Wave Intrinsics being replaced with WaveMask Intrinsic calls with Slang generating the code to calculate the appropriate WaveMasks.

Please read [PR #1352](https://github.com/shader-slang/slang/pull/1352) for a better description of the status.

## SM6.5 Wave Intrinsics

SM6.5 Wave Intrinsics are supported, but requires a downstream DXC compiler that supports SM6.5. As it stands the DXC shipping with windows does not. 

## WaveMask Intrinsics

In order to map better to the CUDA sync/mask model Slang supports 'WaveMask' intrinsics. They operate in broadly the same way as the Wave intrinsics, but require the programmer to specify the lanes that are involved. To write code that uses wave intrinsics acrosss targets including CUDA, currently the WaveMask intrinsics must be used. For this to work, the masks passed to the WaveMask functions should exactly match the 'Active lanes' concept that HLSL uses, otherwise the result is undefined. 

The WaveMask intrinsics are not part of HLSL and are only available on Slang.

## WaveShuffle

`WaveShuffle` and `WaveBroadcastLaneAt` are Slang specific intrinsic additions to expand the options available around `WaveReadLaneAt`. 

To be clear this means they will not compile directly on 'standard' HLSL compilers such as `dxc`, but Slang HLSL *output* (which will not contain these intrinsics) can (and typically is) compiled via dxc.

The difference between them can be summarized as follows

* WaveBroadcastLaneAt - laneId must be a compile time constant 
* WaveReadLaneAt - laneId can be dynamic but *MUST* be the same value across the Wave ie 'dynamically uniform' across the Wave
* WaveShuffle - laneId can be truly dynamic (NOTE! That it is not strictly truly available currently on all targets, specifically HLSL)

Other than the different restrictions on laneId they act identically to WaveReadLaneAt.

`WaveBroadcastLaneAt` and `WaveReadLaneAt` will work on all targets that support wave intrinsics, with the only current restriction being that on GLSL targets, only scalars and vectors are supported.

`WaveShuffle` will always work on CUDA/Vulkan. 

On HLSL based targets currently `WaveShuffle` will be converted into `WaveReadLaneAt`. Strictly speaking this means it *requires* the `laneId` to be `dynamically uniform` across the Wave. In practice some hardware supports the loosened usage, and others does not. In the future this may be fixed in Slang and/or HLSL to work across all hardware. For now if you use `WaveShuffle` on HLSL based targets it will be necessary to confirm that `WaveReadLaneAt` has the loosened behavior for all the hardware intended. If target hardware does not support the loosened restrictions it's behavior is undefined. 

## Tesselation

Although tesselation stages should work on D3D11 and D3D12 they are not tested within our test framework, and may have problems. 

## Native Bindless  

Bindless is possible on targets that support it - but is not the default behavior for those targets, and typically require significant effort in Slang code. 

'Native Bindless' targets use a form of 'bindless' for all targets. On CUDA this requires the target to use 'texture object' style binding and for the device to have 'compute capability 3.0' or higher.

## Resource bounds 

For CUDA this is optional as can be controlled via the SLANG_CUDA_BOUNDARY_MODE macro in the `slang-cuda-prelude.h`. By default it's behavior is `cudaBoundaryModeZero`.

## Buffer Bounds

This is the feature when accessing outside of the bounds of a Buffer there is well defined behavior - on read returning all 0s, and on write, the write being ignored.

On CPU there is only bounds checking on debug compilation of C++ code. This will assert if the access is out of range.

On CUDA out of bounds accesses default to element 0 (!). The behavior can be controlled via the SLANG_CUDA_BOUND_CHECK macro in the `slang-cuda-prelude.h`. This behavior may seem a little strange - and it requires a buffer that has at least one member to not do something nasty. It is really a 'least worst' answer to a difficult problem and is better than out of range accesses or worse writes.

## TextureArray.Sample float 

When using 'Sample' on a TextureArray, CUDA treats the array index parameter as an int, even though it is passed as a float.

## Separate Sampler

This feature means that a multiple Samplers can be used with a Texture. In terms of the HLSL code this can be seen as the 'SamplerState' being a parameter passed to the 'Sample' method on a texture object. 

On CUDA the SamplerState is ignored, because on this target a 'texture object' is the Texture and Sampler combination.

## Graphics Pipeline

CPU and CUDA only currently support compute shaders. 

## Ray Tracing DXR 1.0

Vulkan does not support a local root signature, but there is the concept of a 'shader record'. In Slang a single constant buffer can be marked as a shader record with the `[[vk::shader_record]]` attribute, for example:

```
[[vk::shader_record]]
cbuffer ShaderRecord
{
	uint shaderRecordID;
} 
```

In practice to write shader code that works across D3D12 and VK you should have a single constant buffer marked as 'shader record' for VK and then on D3D that constant buffer should be bound in the local root signature on D3D. 

## tex.Load

tex.Load is only supported on CUDA for Texture1D. Additionally CUDA only allows such access for linear memory, meaning the bound texture can also not have mip maps. Load *is* allowed on RWTexture types of other dimensions including 1D on CUDA.

## Full bool

Means fully featured bool support. CUDA has issues around bool because there isn't a vector bool type built in. Currently bool aliases to an int vector type. 

On CPU there are some issues in so far as bool's size is not well defined in size an alignment. Most C++ compilers now use a byte to represent a bool. In the past it has been backed by an int on some compilers. 

## `[unroll]`

The unroll attribute allows for unrolling `for` loops. At the moment the feature is dependent on downstream compiler support which is mixed. In the longer term the intention is for Slang to contain it's own loop unroller - and therefore not be dependent on the feature on downstream compilers. 

On C++ this attribute becomes SLANG_UNROLL which is defined in the prelude. This can be predefined if there is a suitable mechanism, if there isn't a definition SLANG_UNROLL will be an empty definition. 

On GLSL and VK targets loop unrolling uses the [GL_EXT_control_flow_attributes](https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GL_EXT_control_flow_attributes.txt) extension.

Slang does have a cross target mechanism to [unroll loops](language-reference/06-statements.md), in the section `Compile-Time For Statement`.

## Atomics on RWBuffer

For VK the GLSL output from Slang seems plausible, but VK binding fails in tests harness.

On CUDA RWBuffer becomes CUsurfObject, which is a 'texture' type and does not support atomics. 

On the CPU atomics are not supported, but will be in the future.

## Sampler Feedback

The HLSL [sampler feedback feature](https://microsoft.github.io/DirectX-Specs/d3d/SamplerFeedback.html) is available for DirectX12. The features requires shader model 6.5 and therefore a version of [DXC](https://github.com/Microsoft/DirectXShaderCompiler) that supports that model or higher. The Shader Model 6.5 requirement also means only DXIL binary format is supported. 

There doesn't not appear to be a similar feature available in Vulkan yet, but when it is available support should be addeed.

For CPU targets there is the IFeedbackTexture interface that requires an implemention for use. Slang does not currently include CPU implementations for texture types.  

## RWByteAddressBuffer Atomic

The additional supported methods on RWByteAddressBuffer are...

```
void RWByteAddressBuffer::InterlockedAddF32(uint byteAddress, float valueToAdd, out float originalValue);
void RWByteAddressBuffer::InterlockedAddF32(uint byteAddress, float valueToAdd);

void RWByteAddressBuffer::InterlockedAddI64(uint byteAddress, int64_t valueToAdd, out int64_t originalValue);
void RWByteAddressBuffer::InterlockedAddI64(uint byteAddress, int64_t valueToAdd);

void RWByteAddressBuffer::InterlockedCompareExchangeU64(uint byteAddress, uint64_t compareValue, uint64_t value, out uint64_t outOriginalValue);

uint64_t RWByteAddressBuffer::InterlockedExchangeU64(uint byteAddress, uint64_t value);

uint64_t RWByteAddressBuffer::InterlockedMaxU64(uint byteAddress, uint64_t value);
uint64_t RWByteAddressBuffer::InterlockedMinU64(uint byteAddress, uint64_t value);

uint64_t RWByteAddressBuffer::InterlockedAndU64(uint byteAddress, uint64_t value);
uint64_t RWByteAddressBuffer::InterlockedOrU64(uint byteAddress, uint64_t value);
uint64_t RWByteAddressBuffer::InterlockedXorU64(uint byteAddress, uint64_t value);
```

On HLSL based targets this functionality is achieved using [NVAPI](https://developer.nvidia.com/nvapi). Support for NVAPI is described
in the separate [NVAPI Support](nvapi-support.md) document.  

On Vulkan, for float the [`GL_EXT_shader_atomic_float`](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_atomic_float.html) extension is required. For int64 the [`GL_EXT_shader_atomic_int64`](https://raw.githubusercontent.com/KhronosGroup/GLSL/master/extensions/ext/GL_EXT_shader_atomic_int64.txt) extension is required.

CUDA requires SM6.0 or higher for int64 support. 


================================================
FILE: Source/External/slang/docs/wave-intrinsics.md
================================================
Wave Intrinsics
===============

Slang has support for Wave intrinsics introduced to HLSL in [SM6.0](https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/hlsl-shader-model-6-0-features-for-direct3d-12) and [SM6.5](https://github.com/microsoft/DirectX-Specs/blob/master/d3d/HLSL_ShaderModel6_5.md). All intrinsics are available on D3D12, and a subset on Vulkan. 

On GLSL targets such as Vulkan wave intrinsics map to ['subgroup' extension] (https://github.com/KhronosGroup/GLSL/blob/master/extensions/khr/GL_KHR_shader_subgroup.txt).  There is no subgroup support for Matrix types, and currently this means that Matrix is not a supported type for Wave intrinsics on Vulkan, but may be in the future.

Also introduced are some 'non standard' Wave intrinsics which are only available on Slang. All WaveMask intrinsics are non standard. Other non standard intrinsics expose more accurately different behaviours which are either not distinguished on HLSL, or perhaps currently unavailable. Two examples would be `WaveShuffle` and `WaveBroadcastLaneAt`. 

There are three styles of wave intrinsics...

## WaveActive

The majority of 'regular' HLSL Wave intrinsics which operate on implicit 'active' lanes. 

In the [DXC Wiki](https://github.com/Microsoft/DirectXShaderCompiler/wiki/Wave-Intrinsics) active lanes are described as

> These intrinsics are dependent on active lanes and therefore flow control. In the model of this document, implementations
> must enforce that the number of active lanes exactly corresponds to the programmer’s view of flow control.
 
In practice this appears to imply that the programming model is that all lanes operate in 'lock step'. That the 'active lanes' are the lanes doing processing at a particular point in the control flow. On some hardware this may match how processing actually works. There is also a large amount of hardware in the field that doesn't follow this model, and allows lanes to diverge and not necessarily on flow control. On this style of hardware Active intrinsics may act to also converge lanes to give the appearance of 'in step' ness. 
 
## WaveMask

The WaveMask intrinsics take an explicit mask of lanes to operate on, in the same vein as CUDA. Requesting data from a from an inactive lane, can lead to undefined behavior, that includes locking up the shader. The WaveMask is an integer type that can hold the maximum amount of active lanes for this model - currently 32. In the future the WaveMask type may be made an opaque type, but can largely be operated on as if it is an integer.

Using WaveMask intrinsics is generally more verbose and prone to error than the 'Active' style, but it does have a few advantages

* It works across all supported targets - including CUDA (currently WaveActive intrinics do not)
* Gives more fine control
* Might allow for higher performance (for example it gives more control of divergence)
* Maps most closely to CUDA

On D3D12 and Vulkan the WaveMask instrinsics can be used, but the mask is effectively ignored. For this to work across targets including CUDA, the mask must be calculated such that it exactly matches that of HLSL defined 'active' lanes, else the behavior is undefined. 

The WaveMask intrinsics are a non standard Slang feature, and may change in the future. 

```
RWStructuredBuffer<int> outputBuffer;

[numthreads(4, 1, 1)]
void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
{
    // It is the programmers responsibility to determine the inital mask, and that is dependent on the launch
    // It's common to launch such that all lanes are active - with CUDA this would mean 32 lanes. 
    // Here the launch only has 4 lanes active, and so the initial mask is 0xf.
    const WaveMask mask0 = 0xf;
    
    int idx = int(dispatchThreadID.x);
    
    int value = 0;
    
    // When there is a conditional/flow control we typically need to work out a new mask.
    // This can be achieved by calling WaveMaskBallot with the current mask, and the condition
    // used in the flow control - here the subsequent 'if'.
    const WaveMask mask1 = WaveMaskBallot(mask0, idx == 2);
    
    if (idx == 2)
    {
        // At this point the mask is `mask1`, although no WaveMask intrinsics are used along this path, 
        // so it's not used.
    
        // diverge
        return;
    }
    
    // If we get here, the active lanes must be the opposite of mask1 (because we took the other side of the condition), but cannot include
    // any lanes which were not active before. We can calculate this as mask0 & ~mask1.
    
    const WaveMask mask2 = mask0 & ~mask1;
    
    // mask2 holds the correct active mask to use with WaveMaskMin
    value = WaveMaskMin(mask2, idx + 1);
    
    // Write out the result
    outputBuffer[idx] = value;
}
```

Many of the nuances of writing code in this way are discussed in the [CUDA documentation](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#warp-vote-functions).

The above example written via the regular intrinsics is significantly simpler, as we do not need to track 'active lanes' in the masks. 

```
RWStructuredBuffer<int> outputBuffer;

[numthreads(4, 1, 1)]
void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
{
    int idx = int(dispatchThreadID.x);
    
    int value = 0;
    
    if (idx == 2)
    {    
        // diverge
        return;
    }
    
    value = WaveActiveMin(idx + 1);
    
    // Write out the result
    outputBuffer[idx] = value;
}
```

## WaveMulti

The standard 'Multi' intrinsics were added to HLSL is SM6.5, they can specify a mask of lanes via uint4. They introduce some intrinsics that work in a similar fashion to the `WaveMask` intrinsics. The available intrisnics is currently significantly restricted compared to WaveMask. 

Standard Wave intrinsics
=========================

The Wave Intrinsics supported on Slang are listed below. Note that typically T generic types also include vector and matrix forms. 

```
// Lane info

uint WaveGetLaneCount();

uint WaveGetLaneIndex();

bool WaveIsFirstLane();

// Ballot

bool WaveActiveAllTrue(bool condition);

bool WaveActiveAnyTrue(bool condition);

uint4 WaveActiveBallot(bool condition);

uint WaveActiveCountBits(bool value);

// Across Lanes

T WaveActiveBitAnd<T>(T expr);

T WaveActiveBitOr<T>(T expr);

T WaveActiveBitXor<T>(T expr);

T WaveActiveMax<T>(T expr);

T WaveActiveMin<T>(T expr);

T WaveActiveProduct<T>(T expr);

T WaveActiveSum<T>(T expr);

bool WaveActiveAllEqual<T>(T value);

// Prefix

T WavePrefixProduct<T>(T expr);

T WavePrefixSum<T>(T expr);

// Communication

T WaveReadLaneFirst<T>(T expr);

T WaveReadLaneAt<T>(T value, int lane);

// Prefix

uint WavePrefixCountBits(bool value);

// Shader model 6.5 stuff
// https://github.com/microsoft/DirectX-Specs/blob/master/d3d/HLSL_ShaderModel6_5.md

uint4 WaveMatch<T>(T value);

uint WaveMultiPrefixCountBits(bool value, uint4 mask);

T WaveMultiPrefixBitAnd<T>(T expr, uint4 mask);

T WaveMultiPrefixBitOr<T>(T expr, uint4 mask);

T WaveMultiPrefixBitXor<T>(T expr, uint4 mask);

T WaveMultiPrefixProduct<T>(T value, uint4 mask);

T WaveMultiPrefixSum<T>(T value, uint4 mask);
```

Non Standard Wave Intrinsics
============================

The following intrinsics are not part of the HLSL Wave intrinsics standard, but were added to Slang for a variety of reasons. Within the following signatures T can be scalar, vector or matrix, except on Vulkan which doesn't (currently) support Matrix.

```
T WaveBroadcastLaneAt<T>(T value, constexpr int lane);

T WaveShuffle<T>(T value, int lane);

uint4 WaveGetActiveMulti();

uint4 WaveGetConvergedMulti();

// Barriers 

void AllMemoryBarrierWithWaveSync();

void GroupMemoryBarrierWithWaveSync();
```

## Description

```
T WaveBroadcastLaneAt<T>(T value, constexpr int lane);
```

All lanes receive the value specified in lane. Lane must be an active lane, otherwise the result is undefined. 
This is a more restricive version of `WaveReadLaneAt` - which can take a non constexpr lane, *but* must be the same value for all lanes in the warp. Or 'dynamically uniform' as described in the HLSL documentation. 

```
T WaveShuffle<T>(T value, int lane);
```

Shuffle is a less restrictive version of `WaveReadLaneAt` in that it has no restriction on the lane value - it does *not* require the value to be same on all lanes. 

There isn't explicit support for WaveShuffle in HLSL, and for now it will emit `WaveReadLaneAt`. As it turns out for a sizable set of hardware WaveReadLaneAt does work correctly when the lane is not 'dynamically uniform'. This is not necessarily the case for hardware general though, so if targetting HLSL it is important to make sure that this does work correctly on your target hardware.

Our intention is that Slang will support the appropriate HLSL mechanism that makes this work on all hardware when it's available.  

```
void AllMemoryBarrierWithWaveSync();
```

Synchronizes all lanes to the same AllMemoryBarrierWithWaveSync in program flow. Orders all memory accesses such that accesses after the barrier can be seen by writes before.  

```
void GroupMemoryBarrierWithWaveSync();
```

Synchronizes all lanes to the same GroupMemoryBarrierWithWaveSync in program flow. Orders group shared memory accesses such that accesses after the barrier can be seen by writes before.  

Wave Mask Intrinsics
====================

CUDA has a different programming model for inter warp/wave communication based around masks of active lanes. This is because the CUDA programming model allows for divergence that is more granualar than just on program flow, and that there isn't implied reconvergence at the end of a conditional. 

In the future Slang may have the capability to work out the masks required such that the regular HLSL Wave intrinsics work. As it stands there does not appear to be any way to implement the regular Wave intrinsics directly. To work around this problem we introduce 'WaveMask' intrinsics, which are essentially the same as the regular HLSL Wave intrinsics with the first parameter as the WaveMask which identifies the participating lanes. 

The WaveMask intrinsics will work across targets, but *only* if on CUDA targets the mask captures exactly the same lanes as the 'Active' lanes concept in HLSL. If the masks deviate then the behavior is undefined. On non CUDA based targets currently the mask is ignored. This behavior may change on GLSL which has an extension to support a more CUDA like behavior.  

Most of the `WaveMask` functions are identical to the regular Wave intrinsics, but they take a WaveMask as the first parameter, and the intrinsic name starts with `WaveMask`. 

```
WaveMask WaveGetConvergedMask();
```

Gets the mask of lanes which are converged within the Wave. Note that this is *not* the same as Active threads, and may be some subset of that. It is equivalent to the `__activemask()` in CUDA.

On non CUDA targets the the function will return all lanes as active - even though this is not the case. This is 'ok' in so far as on non CUDA targets the mask is ignored. It is *not* okay if the code uses the value other than as a superset of the 'really converged' lanes. For example testing the bit's and changing behavior would likely not work correctly on non CUDA targets. 

```
void AllMemoryBarrierWithWaveMaskSync(WaveMask mask);
```

Same as AllMemoryBarrierWithWaveSync but takes a mask of active lanes to sync with. 

```
void GroupMemoryBarrierWithWaveMaskSync(WaveMask mask);
```

Same as GroupMemoryBarrierWithWaveSync but takes a mask of active lanes to sync with. 
 
The intrinsics that make up the Slang `WaveMask` extension. 
 
```
// Lane info

WaveMask WaveGetConvergedMask();

WaveMask WaveGetActiveMask();

bool WaveMaskIsFirstLane(WaveMask mask);

// Ballot

bool WaveMaskAllTrue(WaveMask mask, bool condition);

bool WaveMaskAnyTrue(WaveMask mask, bool condition);

WaveMask WaveMaskBallot(WaveMask mask, bool condition);

WaveMask WaveMaskCountBits(WaveMask mask, bool value);

WaveMask WaveMaskMatch<T>(WaveMask mask, T value);

// Barriers

void AllMemoryBarrierWithWaveMaskSync(WaveMask mask);

void GroupMemoryBarrierWithWaveMaskSync(WaveMask mask);

// Across lane ops

T WaveMaskBitAnd<T>(WaveMask mask, T expr);

T WaveMaskBitOr<T>(WaveMask mask, T expr);

T WaveMaskBitXor<T>(WaveMask mask, T expr);

T WaveMaskMax<T>(WaveMask mask, T expr);

T WaveMaskMin<T>(WaveMask mask, T expr);

T WaveMaskProduct<T>(WaveMask mask, T expr);

T WaveMaskSum<T>(WaveMask mask, T expr);

bool WaveMaskAllEqual<T>(WaveMask mask, T value);

// Prefix

T WaveMaskPrefixProduct<T>(WaveMask mask, T expr);

T WaveMaskPrefixSum<T>(WaveMask mask, T expr);

T WaveMaskPrefixBitAnd<T>(WaveMask mask, T expr);

T WaveMaskPrefixBitOr<T>(WaveMask mask, T expr);

T WaveMaskPrefixBitXor<T>(WaveMask mask, T expr);

uint WaveMaskPrefixCountBits(WaveMask mask, bool value);

// Communication

T WaveMaskReadLaneFirst<T>(WaveMask mask, T expr);

T WaveMaskBroadcastLaneAt<T>(WaveMask mask, T value, constexpr int lane);

T WaveMaskReadLaneAt<T>(WaveMask mask, T value, int lane);

T WaveMaskShuffle<T>(WaveMask mask, T value, int lane);
```

 

================================================
FILE: Source/External/slang/prelude/slang-cpp-host-prelude.h
================================================
#ifndef SLANG_CPP_HOST_PRELUDE_H
#define SLANG_CPP_HOST_PRELUDE_H

#include <cstdio>
#include <cmath>
#include <cstring>

#define SLANG_COM_PTR_ENABLE_REF_OPERATOR 1

#include "../source/slang-rt/slang-rt.h"
#include "../slang-com-ptr.h"
#include "slang-cpp-types.h"

#ifdef SLANG_LLVM
#include "slang-llvm.h"
#else // SLANG_LLVM
#   if SLANG_GCC_FAMILY && __GNUC__ < 6
#       include <cmath>
#       define SLANG_PRELUDE_STD std::
#   else
#       include <math.h>
#       define SLANG_PRELUDE_STD
#   endif

#   include <assert.h>
#   include <stdlib.h>
#   include <string.h>
#   include <stdint.h>
#endif // SLANG_LLVM


#include "slang-cpp-scalar-intrinsics.h"

using namespace Slang;

template<typename TResult, typename... Args>
using Slang_FuncType = TResult(SLANG_MCALL *)(Args...);

#endif


================================================
FILE: Source/External/slang/prelude/slang-cpp-prelude.h
================================================
#ifndef SLANG_CPP_PRELUDE_H
#define SLANG_CPP_PRELUDE_H

// Because the signiture of isnan, isfinite, and is isinf changed in C++, we use the macro
// to use the version in the std namespace. 
// https://stackoverflow.com/questions/39130040/cmath-hides-isnan-in-math-h-in-c14-c11
 
#ifdef SLANG_LLVM
#include "slang-llvm.h"
#else // SLANG_LLVM
#   if SLANG_GCC_FAMILY && __GNUC__ < 6
#       include <cmath>
#       define SLANG_PRELUDE_STD std::
#   else
#       include <math.h>
#       define SLANG_PRELUDE_STD
#   endif

#   include <assert.h>
#   include <stdlib.h>
#   include <string.h>
#   include <stdint.h>
#endif // SLANG_LLVM

#if defined(_MSC_VER)
#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport)
#else
#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__((__visibility__("default")))
//#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport)) __attribute__((__visibility__("default")))
#endif    

#ifdef __cplusplus    
#   define SLANG_PRELUDE_EXTERN_C extern "C"
#   define SLANG_PRELUDE_EXTERN_C_START extern "C" {
#   define SLANG_PRELUDE_EXTERN_C_END }
#else
#   define SLANG_PRELUDE_EXTERN_C 
#   define SLANG_PRELUDE_EXTERN_C_START
#   define SLANG_PRELUDE_EXTERN_C_END 
#endif    

#define SLANG_PRELUDE_EXPORT SLANG_PRELUDE_EXTERN_C SLANG_PRELUDE_SHARED_LIB_EXPORT
#define SLANG_PRELUDE_EXPORT_START SLANG_PRELUDE_EXTERN_C_START SLANG_PRELUDE_SHARED_LIB_EXPORT
#define SLANG_PRELUDE_EXPORT_END SLANG_PRELUDE_EXTERN_C_END

#ifndef SLANG_INFINITY
#   define SLANG_INFINITY   INFINITY
#endif

// Detect the compiler type

#ifndef SLANG_COMPILER
#    define SLANG_COMPILER

/*
Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/
NOTE that SLANG_VC holds the compiler version - not just 1 or 0
*/
#    if defined(_MSC_VER)
#        if _MSC_VER >= 1900
#            define SLANG_VC 14
#        elif _MSC_VER >= 1800
#            define SLANG_VC 12
#        elif _MSC_VER >= 1700
#            define SLANG_VC 11
#        elif _MSC_VER >= 1600
#            define SLANG_VC 10
#        elif _MSC_VER >= 1500
#            define SLANG_VC 9
#        else
#            error "unknown version of Visual C++ compiler"
#        endif
#    elif defined(__clang__)
#        define SLANG_CLANG 1
#    elif defined(__SNC__)
#        define SLANG_SNC 1
#    elif defined(__ghs__)
#        define SLANG_GHS 1
#    elif defined(__GNUC__) /* note: __clang__, __SNC__, or __ghs__ imply __GNUC__ */
#        define SLANG_GCC 1
#    else
#        error "unknown compiler"
#    endif
/*
Any compilers not detected by the above logic are now now explicitly zeroed out.
*/
#    ifndef SLANG_VC
#        define SLANG_VC 0
#    endif
#    ifndef SLANG_CLANG
#        define SLANG_CLANG 0
#    endif
#    ifndef SLANG_SNC
#        define SLANG_SNC 0
#    endif
#    ifndef SLANG_GHS
#        define SLANG_GHS 0
#    endif
#    ifndef SLANG_GCC
#        define SLANG_GCC 0
#    endif
#endif /* SLANG_COMPILER */

/*
The following section attempts to detect the target platform being compiled for.

If an application defines `SLANG_PLATFORM` before including this header,
they take responsibility for setting any compiler-dependent macros
used later in the file.

Most applications should not need to touch this section.
*/
#ifndef SLANG_PLATFORM
#    define SLANG_PLATFORM
/**
Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/
*/
#    if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP
#        define SLANG_WINRT 1 /* Windows Runtime, either on Windows RT or Windows 8 */
#    elif defined(XBOXONE)
#        define SLANG_XBOXONE 1
#    elif defined(_WIN64) /* note: XBOXONE implies _WIN64 */
#        define SLANG_WIN64 1
#    elif defined(_M_PPC)
#        define SLANG_X360 1
#    elif defined(_WIN32) /* note: _M_PPC implies _WIN32 */
#        define SLANG_WIN32 1
#    elif defined(__ANDROID__)
#        define SLANG_ANDROID 1
#    elif defined(__linux__) || defined(__CYGWIN__) /* note: __ANDROID__ implies __linux__ */
#        define SLANG_LINUX 1
#    elif defined(__APPLE__) && !defined(SLANG_LLVM)
#        include "TargetConditionals.h"
#        if TARGET_OS_MAC
#            define SLANG_OSX 1
#        else
#            define SLANG_IOS 1
#        endif
#    elif defined(__APPLE__)
// On `slang-llvm` we can't inclue "TargetConditionals.h" in general, so for now assume its OSX.
#       define SLANG_OSX 1
#    elif defined(__CELLOS_LV2__)
#        define SLANG_PS3 1
#    elif defined(__ORBIS__)
#        define SLANG_PS4 1
#    elif defined(__SNC__) && defined(__arm__)
#        define SLANG_PSP2 1
#    elif defined(__ghs__)
#        define SLANG_WIIU 1
#    else
#        error "unknown target platform"
#    endif


/*
Any platforms not detected by the above logic are now now explicitly zeroed out.
*/
#    ifndef SLANG_WINRT
#        define SLANG_WINRT 0
#    endif
#    ifndef SLANG_XBOXONE
#        define SLANG_XBOXONE 0
#    endif
#    ifndef SLANG_WIN64
#        define SLANG_WIN64 0
#    endif
#    ifndef SLANG_X360
#        define SLANG_X360 0
#    endif
#    ifndef SLANG_WIN32
#        define SLANG_WIN32 0
#    endif
#    ifndef SLANG_ANDROID
#        define SLANG_ANDROID 0
#    endif
#    ifndef SLANG_LINUX
#        define SLANG_LINUX 0
#    endif
#    ifndef SLANG_IOS
#        define SLANG_IOS 0
#    endif
#    ifndef SLANG_OSX
#        define SLANG_OSX 0
#    endif
#    ifndef SLANG_PS3
#        define SLANG_PS3 0
#    endif
#    ifndef SLANG_PS4
#        define SLANG_PS4 0
#    endif
#    ifndef SLANG_PSP2
#        define SLANG_PSP2 0
#    endif
#    ifndef SLANG_WIIU
#        define SLANG_WIIU 0
#    endif
#endif /* SLANG_PLATFORM */

/* Shorthands for "families" of compilers/platforms */
#define SLANG_GCC_FAMILY (SLANG_CLANG || SLANG_SNC || SLANG_GHS || SLANG_GCC)
#define SLANG_WINDOWS_FAMILY (SLANG_WINRT || SLANG_WIN32 || SLANG_WIN64)
#define SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE || SLANG_X360 || SLANG_WINDOWS_FAMILY)
#define SLANG_LINUX_FAMILY (SLANG_LINUX || SLANG_ANDROID)
#define SLANG_APPLE_FAMILY (SLANG_IOS || SLANG_OSX)                  /* equivalent to #if __APPLE__ */
#define SLANG_UNIX_FAMILY (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */

// GCC Specific
#if SLANG_GCC_FAMILY
#	define SLANG_ALIGN_OF(T)	__alignof__(T)
// Use this macro instead of offsetof, because gcc produces warning if offsetof is used on a 
// non POD type, even though it produces the correct result
#   define SLANG_OFFSET_OF(T, ELEMENT) (size_t(&((T*)1)->ELEMENT) - 1)
#endif // SLANG_GCC_FAMILY

// Microsoft VC specific
#if SLANG_VC
#   define SLANG_ALIGN_OF(T) __alignof(T)
#endif // SLANG_VC

// Default impls

#ifndef SLANG_OFFSET_OF
#   define SLANG_OFFSET_OF(X, Y) offsetof(X, Y)
#endif

// If slang.h has been included we don't need any of these definitions
#ifndef SLANG_H

/* Macro for declaring if a method is no throw. Should be set before the return parameter. */
#ifndef SLANG_NO_THROW
#   if SLANG_WINDOWS_FAMILY && !defined(SLANG_DISABLE_EXCEPTIONS)
#       define SLANG_NO_THROW __declspec(nothrow)
#   endif
#endif
#ifndef SLANG_NO_THROW
#   define SLANG_NO_THROW
#endif

/* The `SLANG_STDCALL` and `SLANG_MCALL` defines are used to set the calling
convention for interface methods.
*/
#ifndef SLANG_STDCALL
#   if SLANG_MICROSOFT_FAMILY
#       define SLANG_STDCALL __stdcall
#   else
#       define SLANG_STDCALL
#   endif
#endif
#ifndef SLANG_MCALL
#   define SLANG_MCALL SLANG_STDCALL
#endif

#ifndef SLANG_FORCE_INLINE
#    define SLANG_FORCE_INLINE inline
#endif

// TODO(JS): Should these be in slang-cpp-types.h? 
// They are more likely to clash with slang.h

struct SlangUUID
{
    uint32_t data1;
    uint16_t data2;
    uint16_t data3;
    uint8_t  data4[8];
};

typedef int32_t SlangResult;

struct ISlangUnknown
{
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) = 0;
    virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() = 0;
    virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() = 0;
};

#define SLANG_COM_INTERFACE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
    public: \
    SLANG_FORCE_INLINE static const SlangUUID& getTypeGuid() \
    { \
        static const SlangUUID guid = { a, b, c, d0, d1, d2, d3, d4, d5, d6, d7 }; \
        return guid; \
    }
#endif // SLANG_H

// Includes

#include "slang-cpp-types.h"
#include "slang-cpp-scalar-intrinsics.h"

// TODO(JS): Hack! Output C++ code from slang can copy uninitialized variables. 
#if defined(_MSC_VER)
#   pragma warning(disable : 4700)
#endif

#ifndef SLANG_UNROLL
#   define SLANG_UNROLL
#endif

#endif


================================================
FILE: Source/External/slang/prelude/slang-cpp-scalar-intrinsics.h
================================================
#ifndef SLANG_PRELUDE_SCALAR_INTRINSICS_H
#define SLANG_PRELUDE_SCALAR_INTRINSICS_H

#if !defined(SLANG_LLVM) && SLANG_PROCESSOR_X86_64 && SLANG_VC
//  If we have visual studio and 64 bit processor, we can assume we have popcnt, and can include x86 intrinsics
#   include <intrin.h>
#endif

#ifndef SLANG_FORCE_INLINE
#    define SLANG_FORCE_INLINE inline
#endif

#ifdef SLANG_PRELUDE_NAMESPACE
namespace SLANG_PRELUDE_NAMESPACE {
#endif

#ifndef SLANG_PRELUDE_PI
#   define SLANG_PRELUDE_PI           3.14159265358979323846
#endif


union Union32 
{
    uint32_t u;
    int32_t i;
    float f;
};

union Union64
{
    uint64_t u;
    int64_t i;
    double d;
};

// 32 bit cast conversions
SLANG_FORCE_INLINE int32_t _bitCastFloatToInt(float f) { Union32 u; u.f = f; return u.i; }
SLANG_FORCE_INLINE float _bitCastIntToFloat(int32_t i) { Union32 u; u.i = i; return u.f; }
SLANG_FORCE_INLINE uint32_t _bitCastFloatToUInt(float f) { Union32 u; u.f = f; return u.u; }
SLANG_FORCE_INLINE float _bitCastUIntToFloat(uint32_t ui) { Union32 u; u.u = ui; return u.f; }

// ----------------------------- F16 -----------------------------------------


// This impl is based on FloatToHalf that is in Slang codebase
uint32_t f32tof16(const float value)
{
    const uint32_t inBits = _bitCastFloatToUInt(value);

    // bits initially set to just the sign bit
    uint32_t bits = (inBits >> 16) & 0x8000;
    // Mantissa can't be used as is, as it holds last bit, for rounding.
    uint32_t m = (inBits >> 12) & 0x07ff;
    uint32_t e = (inBits >> 23) & 0xff;

    if (e < 103)
    {
        // It's zero
        return bits;
    }
    if (e == 0xff)
    {
        // Could be a NAN or INF. Is INF if *input* mantissa is 0.
        
        // Remove last bit for rounding to make output mantissa.
        m >>= 1;
       
        // We *assume* float16/float32 signaling bit and remaining bits
        // semantics are the same. (The signalling bit convention is target specific!).
        // Non signal bit's usage within mantissa for a NAN are also target specific.
      
        // If the m is 0, it could be because the result is INF, but it could also be because all the 
        // bits that made NAN were dropped as we have less mantissa bits in f16. 
           
        // To fix for this we make non zero if m is 0 and the input mantissa was not.
        // This will (typically) produce a signalling NAN.
        m += uint32_t(m == 0 && (inBits & 0x007fffffu));
       
        // Combine for output
        return (bits | 0x7c00u | m);
    }
    if (e > 142)
    {
        // INF. 
        return bits | 0x7c00u;
    }
    if (e < 113)
    {
        m |= 0x0800u;
        bits |= (m >> (114 - e)) + ((m >> (113 - e)) & 1);
        return bits;
    }
    bits |= ((e - 112) << 10) | (m >> 1);
    bits += m & 1;
    return bits;
}

static const float g_f16tof32Magic = _bitCastIntToFloat((127 + (127 - 15)) << 23);

float f16tof32(const uint32_t value)
{
    const uint32_t sign = (value & 0x8000) << 16;
    uint32_t exponent = (value & 0x7c00) >> 10;
    uint32_t mantissa = (value & 0x03ff);

    if (exponent == 0)
    {
        // If mantissa is 0 we are done, as output is 0. 
        // If it's not zero we must have a denormal.
        if (mantissa)
        {
            // We have a denormal so use the magic to do exponent adjust
            return _bitCastIntToFloat(sign | ((value & 0x7fff) << 13)) * g_f16tof32Magic;
        }
    }
    else 
    {
        // If the exponent is NAN or INF exponent is 0x1f on input. 
        // If that's the case, we just need to set the exponent to 0xff on output
        // and the mantissa can just stay the same. If its 0 it's INF, else it is NAN and we just copy the bits
        //
        // Else we need to correct the exponent in the normalized case.
        exponent = (exponent == 0x1F) ? 0xff : (exponent + (-15 + 127));
    }
    
    return _bitCastUIntToFloat(sign | (exponent << 23) | (mantissa << 13));
}

// ----------------------------- F32 -----------------------------------------

// Helpers
SLANG_FORCE_INLINE float F32_calcSafeRadians(float radians);

#ifdef SLANG_LLVM

SLANG_PRELUDE_EXTERN_C_START

// Unary 
float F32_ceil(float f);
float F32_floor(float f);
float F32_round(float f);
float F32_sin(float f);
float F32_cos(float f);
float F32_tan(float f);
float F32_asin(float f);
float F32_acos(float f);
float F32_atan(float f);
float F32_sinh(float f);
float F32_cosh(float f);
float F32_tanh(float f);
float F32_log2(float f);
float F32_log(float f);
float F32_log10(float f);
float F32_exp2(float f);
float F32_exp(float f);
float F32_abs(float f);
float F32_trunc(float f);
float F32_sqrt(float f);

bool F32_isnan(float f);
bool F32_isfinite(float f); 
bool F32_isinf(float f);

// Binary
SLANG_FORCE_INLINE float F32_min(float a, float b) { return a < b ? a : b; }
SLANG_FORCE_INLINE float F32_max(float a, float b) { return a > b ? a : b; }
float F32_pow(float a, float b);
float F32_fmod(float a, float b);
float F32_remainder(float a, float b);
float F32_atan2(float a, float b);

float F32_frexp(float x, float* e);
float F32_modf(float x, float* ip);

// Ternary
SLANG_FORCE_INLINE float F32_fma(float a, float b, float c) { return a * b + c; }

SLANG_PRELUDE_EXTERN_C_END

#else

// Unary 
SLANG_FORCE_INLINE float F32_ceil(float f) { return ::ceilf(f); }
SLANG_FORCE_INLINE float F32_floor(float f) { return ::floorf(f); }
SLANG_FORCE_INLINE float F32_round(float f) { return ::roundf(f); }
SLANG_FORCE_INLINE float F32_sin(float f) { return ::sinf(f); }
SLANG_FORCE_INLINE float F32_cos(float f) { return ::cosf(f); }
SLANG_FORCE_INLINE float F32_tan(float f) { return ::tanf(f); }
SLANG_FORCE_INLINE float F32_asin(float f) { return ::asinf(f); }
SLANG_FORCE_INLINE float F32_acos(float f) { return ::acosf(f); }
SLANG_FORCE_INLINE float F32_atan(float f) { return ::atanf(f); }
SLANG_FORCE_INLINE float F32_sinh(float f) { return ::sinhf(f); }
SLANG_FORCE_INLINE float F32_cosh(float f) { return ::coshf(f); }
SLANG_FORCE_INLINE float F32_tanh(float f) { return ::tanhf(f); }
SLANG_FORCE_INLINE float F32_log2(float f) { return ::log2f(f); }
SLANG_FORCE_INLINE float F32_log(float f) { return ::logf(f); }
SLANG_FORCE_INLINE float F32_log10(float f) { return ::log10f(f); }
SLANG_FORCE_INLINE float F32_exp2(float f) { return ::exp2f(f); }
SLANG_FORCE_INLINE float F32_exp(float f) { return ::expf(f); }
SLANG_FORCE_INLINE float F32_abs(float f) { return ::fabsf(f); }
SLANG_FORCE_INLINE float F32_trunc(float f) { return ::truncf(f); }
SLANG_FORCE_INLINE float F32_sqrt(float f) { return ::sqrtf(f); }

SLANG_FORCE_INLINE bool F32_isnan(float f) { return SLANG_PRELUDE_STD isnan(f); }
SLANG_FORCE_INLINE bool F32_isfinite(float f) { return SLANG_PRELUDE_STD isfinite(f); }
SLANG_FORCE_INLINE bool F32_isinf(float f) { return SLANG_PRELUDE_STD isinf(f); }

// Binary
SLANG_FORCE_INLINE float F32_min(float a, float b) { return ::fminf(a, b); }
SLANG_FORCE_INLINE float F32_max(float a, float b) { return ::fmaxf(a, b); }
SLANG_FORCE_INLINE float F32_pow(float a, float b) { return ::powf(a, b); }
SLANG_FORCE_INLINE float F32_fmod(float a, float b) { return ::fmodf(a, b); }
SLANG_FORCE_INLINE float F32_remainder(float a, float b) { return ::remainderf(a, b); }
SLANG_FORCE_INLINE float F32_atan2(float a, float b) { return float(::atan2(a, b)); }

SLANG_FORCE_INLINE float F32_frexp(float x, float* e)
{
    int ei;
    float m = ::frexpf(x, &ei);
    *e = float(ei);
    return m;
}
SLANG_FORCE_INLINE float F32_modf(float x, float* ip)
{
    return ::modff(x, ip);
}

// Ternary
SLANG_FORCE_INLINE float F32_fma(float a, float b, float c) { return ::fmaf(a, b, c); }

#endif

SLANG_FORCE_INLINE float F32_calcSafeRadians(float radians)
{
    // Put 0 to 2pi cycles to cycle around 0 to 1 
	float a = radians * (1.0f /  float(SLANG_PRELUDE_PI * 2));
    // Get truncated fraction, as value in  0 - 1 range
    a = a - F32_floor(a);
    // Convert back to 0 - 2pi range
	return (a * float(SLANG_PRELUDE_PI * 2));
}

SLANG_FORCE_INLINE float F32_rsqrt(float f) { return 1.0f / F32_sqrt(f); }
SLANG_FORCE_INLINE float F32_sign(float f) { return ( f == 0.0f) ? f : (( f < 0.0f) ? -1.0f : 1.0f); } 
SLANG_FORCE_INLINE float F32_frac(float f) { return f - F32_floor(f); }

SLANG_FORCE_INLINE uint32_t F32_asuint(float f) { Union32 u; u.f = f; return u.u; }
SLANG_FORCE_INLINE int32_t F32_asint(float f) { Union32 u; u.f = f; return u.i; }

// ----------------------------- F64 -----------------------------------------

SLANG_FORCE_INLINE double F64_calcSafeRadians(double radians);

#ifdef SLANG_LLVM

SLANG_PRELUDE_EXTERN_C_START

// Unary 
double F64_ceil(double f);
double F64_floor(double f);
double F64_round(double f);
double F64_sin(double f);
double F64_cos(double f);
double F64_tan(double f);
double F64_asin(double f);
double F64_acos(double f);
double F64_atan(double f);
double F64_sinh(double f);
double F64_cosh(double f);
double F64_tanh(double f);
double F64_log2(double f);
double F64_log(double f);
double F64_log10(float f);
double F64_exp2(double f);
double F64_exp(double f);
double F64_abs(double f);
double F64_trunc(double f);
double F64_sqrt(double f);

bool F64_isnan(double f);
bool F64_isfinite(double f);
bool F64_isinf(double f);

// Binary
SLANG_FORCE_INLINE double F64_min(double a, double b) { return a < b ? a : b; }
SLANG_FORCE_INLINE double F64_max(double a, double b) { return a > b ? a : b; }
double F64_pow(double a, double b);
double F64_fmod(double a, double b);
double F64_remainder(double a, double b);
double F64_atan2(double a, double b);

double F64_frexp(double x, double* e);

double F64_modf(double x, double* ip);

// Ternary
SLANG_FORCE_INLINE double F64_fma(double a, double b, double c) { return a * b + c; }

SLANG_PRELUDE_EXTERN_C_END

#else // SLANG_LLVM

// Unary 
SLANG_FORCE_INLINE double F64_ceil(double f) { return ::ceil(f); }
SLANG_FORCE_INLINE double F64_floor(double f) { return ::floor(f); }
SLANG_FORCE_INLINE double F64_round(double f) { return ::round(f); }
SLANG_FORCE_INLINE double F64_sin(double f) { return ::sin(f); }
SLANG_FORCE_INLINE double F64_cos(double f) { return ::cos(f); }
SLANG_FORCE_INLINE double F64_tan(double f) { return ::tan(f); }
SLANG_FORCE_INLINE double F64_asin(double f) { return ::asin(f); }
SLANG_FORCE_INLINE double F64_acos(double f) { return ::acos(f); }
SLANG_FORCE_INLINE double F64_atan(double f) { return ::atan(f); }
SLANG_FORCE_INLINE double F64_sinh(double f) { return ::sinh(f); }
SLANG_FORCE_INLINE double F64_cosh(double f) { return ::cosh(f); }
SLANG_FORCE_INLINE double F64_tanh(double f) { return ::tanh(f); }
SLANG_FORCE_INLINE double F64_log2(double f) { return ::log2(f); }
SLANG_FORCE_INLINE double F64_log(double f) { return ::log(f); }
SLANG_FORCE_INLINE double F64_log10(float f) { return ::log10(f); }
SLANG_FORCE_INLINE double F64_exp2(double f) { return ::exp2(f); }
SLANG_FORCE_INLINE double F64_exp(double f) { return ::exp(f); }
SLANG_FORCE_INLINE double F64_abs(double f) { return ::fabs(f); }
SLANG_FORCE_INLINE double F64_trunc(double f) { return ::trunc(f); }
SLANG_FORCE_INLINE double F64_sqrt(double f) { return ::sqrt(f); }


SLANG_FORCE_INLINE bool F64_isnan(double f) { return SLANG_PRELUDE_STD isnan(f); }
SLANG_FORCE_INLINE bool F64_isfinite(double f) { return SLANG_PRELUDE_STD isfinite(f); }
SLANG_FORCE_INLINE bool F64_isinf(double f) { return SLANG_PRELUDE_STD isinf(f); }

// Binary
SLANG_FORCE_INLINE double F64_min(double a, double b) { return ::fmin(a, b); }
SLANG_FORCE_INLINE double F64_max(double a, double b) { return ::fmax(a, b); }
SLANG_FORCE_INLINE double F64_pow(double a, double b) { return ::pow(a, b); }
SLANG_FORCE_INLINE double F64_fmod(double a, double b) { return ::fmod(a, b); }
SLANG_FORCE_INLINE double F64_remainder(double a, double b) { return ::remainder(a, b); }
SLANG_FORCE_INLINE double F64_atan2(double a, double b) { return ::atan2(a, b); }

SLANG_FORCE_INLINE double F64_frexp(double x, double* e)
{
    int ei;
    double m = ::frexp(x, &ei);
    *e = float(ei);
    return m;
}

SLANG_FORCE_INLINE double F64_modf(double x, double* ip)
{
    return ::modf(x, ip);
}

// Ternary
SLANG_FORCE_INLINE double F64_fma(double a, double b, double c) { return ::fma(a, b, c); }

#endif // SLANG_LLVM

SLANG_FORCE_INLINE double F64_rsqrt(double f) { return 1.0 / F64_sqrt(f); }
SLANG_FORCE_INLINE double F64_sign(double f) { return (f == 0.0) ? f : ((f < 0.0) ? -1.0 : 1.0); }
SLANG_FORCE_INLINE double F64_frac(double f) { return f - F64_floor(f); }

SLANG_FORCE_INLINE void F64_asuint(double d, uint32_t* low, uint32_t* hi)
{
    Union64 u;
    u.d = d;
    *low = uint32_t(u.u);
    *hi = uint32_t(u.u >> 32);
}

SLANG_FORCE_INLINE void F64_asint(double d, int32_t* low, int32_t* hi)
{
    Union64 u;
    u.d = d;
    *low = int32_t(u.u);
    *hi = int32_t(u.u >> 32);
}

SLANG_FORCE_INLINE double F64_calcSafeRadians(double radians)
{
    // Put 0 to 2pi cycles to cycle around 0 to 1 
	double a = radians * (1.0f /  (SLANG_PRELUDE_PI * 2));
    // Get truncated fraction, as value in  0 - 1 range
    a = a - F64_floor(a);
    // Convert back to 0 - 2pi range
	return (a * (SLANG_PRELUDE_PI * 2));
}

// ----------------------------- I32 -----------------------------------------

SLANG_FORCE_INLINE int32_t I32_abs(int32_t f) { return (f < 0) ? -f : f; }

SLANG_FORCE_INLINE int32_t I32_min(int32_t a, int32_t b) { return a < b ? a : b; }
SLANG_FORCE_INLINE int32_t I32_max(int32_t a, int32_t b) { return a > b ? a : b; }

SLANG_FORCE_INLINE float I32_asfloat(int32_t x) { Union32 u; u.i = x; return u.f; }
SLANG_FORCE_INLINE uint32_t I32_asuint(int32_t x) { return uint32_t(x); }
SLANG_FORCE_INLINE double I32_asdouble(int32_t low, int32_t hi )
{
    Union64 u;
    u.u = (uint64_t(hi) << 32) | uint32_t(low);
    return u.d;
}

// ----------------------------- U32 -----------------------------------------

SLANG_FORCE_INLINE uint32_t U32_abs(uint32_t f) { return f; }

SLANG_FORCE_INLINE uint32_t U32_min(uint32_t a, uint32_t b) { return a < b ? a : b; }
SLANG_FORCE_INLINE uint32_t U32_max(uint32_t a, uint32_t b) { return a > b ? a : b; }

SLANG_FORCE_INLINE float U32_asfloat(uint32_t x) { Union32 u; u.u = x; return u.f; }
SLANG_FORCE_INLINE uint32_t U32_asint(int32_t x) { return uint32_t(x); } 

SLANG_FORCE_INLINE double U32_asdouble(uint32_t low, uint32_t hi)
{
    Union64 u;
    u.u = (uint64_t(hi) << 32) | low;
    return u.d;
}


SLANG_FORCE_INLINE uint32_t U32_countbits(uint32_t v)
{
#if SLANG_GCC_FAMILY && !defined(SLANG_LLVM)
    return __builtin_popcount(v);
#elif SLANG_PROCESSOR_X86_64 && SLANG_VC
    return __popcnt(v);
#else     
    uint32_t c = 0;
    while (v)
    {
        c++;
        v &= v - 1;
    }
    return c;
#endif
}

// ----------------------------- U64 -----------------------------------------

SLANG_FORCE_INLINE uint64_t U64_abs(uint64_t f) { return f; }

SLANG_FORCE_INLINE uint64_t U64_min(uint64_t a, uint64_t b) { return a < b ? a : b; }
SLANG_FORCE_INLINE uint64_t U64_max(uint64_t a, uint64_t b) { return a > b ? a : b; }

// TODO(JS): We don't define countbits for 64bit in stdlib currently.
// It's not clear from documentation if it should return 32 or 64 bits, if it exists. 
// 32 bits can always hold the result, and will be implicitly promoted. 
SLANG_FORCE_INLINE uint32_t U64_countbits(uint64_t v)
{
#if SLANG_GCC_FAMILY && !defined(SLANG_LLVM)   
    return uint32_t(__builtin_popcountl(v));
#elif SLANG_PROCESSOR_X86_64 && SLANG_VC
    return uint32_t(__popcnt64(v));
#else     
    uint32_t c = 0;
    while (v)
    {
        c++;
        v &= v - 1;
    }
    return c;
#endif
}

// ----------------------------- I64 -----------------------------------------

SLANG_FORCE_INLINE int64_t I64_abs(int64_t f) { return (f < 0) ? -f : f; }

SLANG_FORCE_INLINE int64_t I64_min(int64_t a, int64_t b) { return a < b ? a : b; }
SLANG_FORCE_INLINE int64_t I64_max(int64_t a, int64_t b) { return a > b ? a : b; }


// ----------------------------- Interlocked ---------------------------------

#if SLANG_LLVM

#else // SLANG_LLVM

#   ifdef _WIN32
#       include <intrin.h>
#   endif

void InterlockedAdd(uint32_t* dest, uint32_t value, uint32_t* oldValue)
{
#   ifdef _WIN32
    *oldValue = _InterlockedExchangeAdd((long*)dest, (long)value);
#   else
    *oldValue = __sync_fetch_and_add(dest, value);
#   endif
}

#endif // SLANG_LLVM

#ifdef SLANG_PRELUDE_NAMESPACE
} 
#endif

#endif


================================================
FILE: Source/External/slang/prelude/slang-cpp-types.h
================================================
#ifndef SLANG_PRELUDE_CPP_TYPES_H
#define SLANG_PRELUDE_CPP_TYPES_H

#ifndef SLANG_PRELUDE_ASSERT
#   ifdef SLANG_PRELUDE_ENABLE_ASSERT
#       define SLANG_PRELUDE_ASSERT(VALUE) assert(VALUE)
#   else
#       define SLANG_PRELUDE_ASSERT(VALUE) 
#   endif
#endif

// Since we are using unsigned arithmatic care is need in this comparison.
// It is *assumed* that sizeInBytes >= elemSize. Which means (sizeInBytes >= elemSize) >= 0
// Which means only a single test is needed

// Asserts for bounds checking.
// It is assumed index/count are unsigned types.
#define SLANG_BOUND_ASSERT(index, count)  SLANG_PRELUDE_ASSERT(index < count); 
#define SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_PRELUDE_ASSERT(index <= (sizeInBytes - elemSize) && (index & 3) == 0);

// Macros to zero index if an access is out of range
#define SLANG_BOUND_ZERO_INDEX(index, count) index = (index < count) ? index : 0; 
#define SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes) index = (index <= (sizeInBytes - elemSize)) ? index : 0; 

// The 'FIX' macro define how the index is fixed. The default is to do nothing. If SLANG_ENABLE_BOUND_ZERO_INDEX
// the fix macro will zero the index, if out of range
#ifdef  SLANG_ENABLE_BOUND_ZERO_INDEX
#   define SLANG_BOUND_FIX(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
#   define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
#else
#   define SLANG_BOUND_FIX(index, count) 
#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) 
#   define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) 
#endif

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

#ifndef SLANG_BOUND_CHECK_BYTE_ADDRESS
#   define SLANG_BOUND_CHECK_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
#endif

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

#ifdef SLANG_PRELUDE_NAMESPACE
namespace SLANG_PRELUDE_NAMESPACE {
#endif

struct TypeInfo
{
    size_t typeSize;
};

template <typename T, size_t SIZE>
struct FixedArray
{
    const T& operator[](size_t index) const { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
    T& operator[](size_t index) { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }

    T m_data[SIZE];
};

// An array that has no specified size, becomes a 'Array'. This stores the size so it can potentially 
// do bounds checking.  
template <typename T>
struct Array
{
    const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    T& operator[](size_t index) { SLANG_BOUND_CHECK(index, count); return data[index]; }

    T* data;
    size_t count;
};

#if 0
template<size_t N>
struct AnyValue
{
    uint8_t data[N];
};
template<size_t N, typename T>
AnyValue<N> packAnyValue(const T& val)
{
    AnyValue<N> result;
    memcpy(&result, &val, sizeof(T));
    return result;
}
template<size_t N, typename T>
T unpackAnyValue(const AnyValue<N>& val)
{
    T result;
    memcpy(&result, &val, sizeof(T));
    return result;
}
#endif

/* Constant buffers become a pointer to the contained type, so ConstantBuffer<T> becomes T* in C++ code.
*/

template <typename T, int COUNT>
struct Vector;

template <typename T>
struct Vector<T, 1>
{
    T x;
};

template <typename T>
struct Vector<T, 2>
{
    T x, y;
};

template <typename T>
struct Vector<T, 3>
{
    T x, y, z;
};

template <typename T>
struct Vector<T, 4>
{
    T x, y, z, w;
};


typedef Vector<float, 2> float2;
typedef Vector<float, 3> float3;
typedef Vector<float, 4> float4;

typedef Vector<int32_t, 2> int2;
typedef Vector<int32_t, 3> int3;
typedef Vector<int32_t, 4> int4;

typedef Vector<uint32_t, 2> uint2;
typedef Vector<uint32_t, 3> uint3;
typedef Vector<uint32_t, 4> uint4;

template <typename T, int ROWS, int COLS>
struct Matrix
{
    Vector<T, COLS> rows[ROWS];
};

// We can just map `NonUniformResourceIndex` type directly to the index type on CPU, as CPU does not require
// any special handling around such accesses.
typedef size_t NonUniformResourceIndex;

// ----------------------------- ResourceType -----------------------------------------

// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-structuredbuffer-getdimensions
// Missing  Load(_In_  int  Location, _Out_ uint Status);

template <typename T>
struct RWStructuredBuffer
{
    SLANG_FORCE_INLINE T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }  
    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
  
    T* data;
    size_t count;
};

template <typename T>
struct StructuredBuffer
{
    SLANG_FORCE_INLINE const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
    
    T* data;
    size_t count;
};


template <typename T>
struct RWBuffer
{
    SLANG_FORCE_INLINE T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    void GetDimensions(uint32_t* outCount) { *outCount = uint32_t(count); }
    
    T* data;
    size_t count;
};

template <typename T>
struct Buffer
{
    SLANG_FORCE_INLINE const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    void GetDimensions(uint32_t* outCount) { *outCount = uint32_t(count); }
    
    T* data;
    size_t count;
};

// Missing  Load(_In_  int  Location, _Out_ uint Status);
struct ByteAddressBuffer
{
    void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
    uint32_t Load(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
        return data[index >> 2]; 
    }
    uint2 Load2(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint2{data[dataIdx], data[dataIdx + 1]}; 
    }
    uint3 Load3(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
    }
    uint4 Load4(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
    }
    template<typename T>
    T Load(size_t index) const
    {
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
        return *(const T*)(((const char*)data) + index);
    }
    
    const uint32_t* data;
    size_t sizeInBytes;  //< Must be multiple of 4
};

// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-rwbyteaddressbuffer
// Missing support for Atomic operations 
// Missing support for Load with status
struct RWByteAddressBuffer
{
    void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
    
    uint32_t Load(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
        return data[index >> 2]; 
    }
    uint2 Load2(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint2{data[dataIdx], data[dataIdx + 1]}; 
    }
    uint3 Load3(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
    }
    uint4 Load4(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
    }
    template<typename T>
    T Load(size_t index) const
    {
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
        return *(const T*)(((const char*)data) + index);
    }

    void Store(size_t index, uint32_t v) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
        data[index >> 2] = v; 
    }
    void Store2(size_t index, uint2 v) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        data[dataIdx + 0] = v.x;
        data[dataIdx + 1] = v.y;
    }
    void Store3(size_t index, uint3 v) const 
    {  
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        data[dataIdx + 0] = v.x;
        data[dataIdx + 1] = v.y;
        data[dataIdx + 2] = v.z;
    }
    void Store4(size_t index, uint4 v) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        data[dataIdx + 0] = v.x;
        data[dataIdx + 1] = v.y;
        data[dataIdx + 2] = v.z;
        data[dataIdx + 3] = v.w;
    }
    template<typename T>
    void Store(size_t index, T const& value) const
    {
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
        *(T*)(((char*)data) + index) = value;
    }

    uint32_t* data;
    size_t sizeInBytes; //< Must be multiple of 4 
};

struct ISamplerState;
struct ISamplerComparisonState;

struct SamplerState
{
    ISamplerState* state;
};

struct SamplerComparisonState
{
    ISamplerComparisonState* state;
};

#ifndef SLANG_RESOURCE_SHAPE
#    define SLANG_RESOURCE_SHAPE
typedef unsigned int SlangResourceShape;
enum
{
    SLANG_RESOURCE_BASE_SHAPE_MASK = 0x0F,

    SLANG_RESOURCE_NONE = 0x00,

    SLANG_TEXTURE_1D = 0x01,
    SLANG_TEXTURE_2D = 0x02,
    SLANG_TEXTURE_3D = 0x03,
    SLANG_TEXTURE_CUBE = 0x04,
    SLANG_TEXTURE_BUFFER = 0x05,

    SLANG_STRUCTURED_BUFFER = 0x06,
    SLANG_BYTE_ADDRESS_BUFFER = 0x07,
    SLANG_RESOURCE_UNKNOWN = 0x08,
    SLANG_ACCELERATION_STRUCTURE = 0x09,

    SLANG_RESOURCE_EXT_SHAPE_MASK = 0xF0,

    SLANG_TEXTURE_FEEDBACK_FLAG = 0x10,
    SLANG_TEXTURE_ARRAY_FLAG = 0x40,
    SLANG_TEXTURE_MULTISAMPLE_FLAG = 0x80,

    SLANG_TEXTURE_1D_ARRAY = SLANG_TEXTURE_1D | SLANG_TEXTURE_ARRAY_FLAG,
    SLANG_TEXTURE_2D_ARRAY = SLANG_TEXTURE_2D | SLANG_TEXTURE_ARRAY_FLAG,
    SLANG_TEXTURE_CUBE_ARRAY = SLANG_TEXTURE_CUBE | SLANG_TEXTURE_ARRAY_FLAG,

    SLANG_TEXTURE_2D_MULTISAMPLE = SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG,
    SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY =
        SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG | SLANG_TEXTURE_ARRAY_FLAG,
};
#endif

// 
struct TextureDimensions
{
    void reset()
    {
        shape = 0;
        width = height = depth = 0;
        numberOfLevels = 0;
        arrayElementCount = 0;
    }
    int getDimSizes(uint32_t outDims[4]) const
    {
        const auto baseShape = (shape & SLANG_RESOURCE_BASE_SHAPE_MASK);
        int count = 0;
        switch (baseShape)
        {
            case SLANG_TEXTURE_1D:
            {
                outDims[count++] = width;
                break;
            }
            case SLANG_TEXTURE_2D:
            {
                outDims[count++] = width;
                outDims[count++] = height;
                break;
            }
            case SLANG_TEXTURE_3D:
            {
                outDims[count++] = width;
                outDims[count++] = height;
                outDims[count++] = depth;
                break;
            }
            case SLANG_TEXTURE_CUBE:
            {
                outDims[count++] = width;
                outDims[count++] = height;
                outDims[count++] = 6;
                break;
            }
        }

        if (shape & SLANG_TEXTURE_ARRAY_FLAG)
        {
            outDims[count++] = arrayElementCount;
        }
        return count;
    }
    int getMIPDims(int outDims[3]) const
    {
        const auto baseShape = (shape & SLANG_RESOURCE_BASE_SHAPE_MASK);
        int count = 0;
        switch (baseShape)
        {
            case SLANG_TEXTURE_1D:
            {
                outDims[count++] = width;
                break;
            }
            case SLANG_TEXTURE_CUBE:
            case SLANG_TEXTURE_2D:
            {
                outDims[count++] = width;
                outDims[count++] = height;
                break;
            }
            case SLANG_TEXTURE_3D:
            {
                outDims[count++] = width;
                outDims[count++] = height;
                outDims[count++] = depth;
                break;
            }
        }
        return count;
    }
    int calcMaxMIPLevels() const
    {
        int dims[3];
        const int dimCount = getMIPDims(dims);
        for (int count = 1; true; count++)
        {
            bool allOne = true;
            for (int i = 0; i < dimCount; ++i)
            {
                if (dims[i] > 1)
                {
                    allOne = false;
                    dims[i] >>= 1;
                }
            }
            if (allOne)
            {
                return count;
            }
        }
    }

    uint32_t shape;
    uint32_t width, height, depth;
    uint32_t numberOfLevels;
    uint32_t arrayElementCount;                  ///< For array types, 0 otherwise
};





// Texture

struct ITexture
{
    virtual TextureDimensions GetDimensions(int mipLevel = -1) = 0;
    virtual void Load(const int32_t* v, void* outData, size_t dataSize) = 0;
    virtual void Sample(SamplerState samplerState, const float* loc, void* outData, size_t dataSize) = 0;
    virtual void SampleLevel(SamplerState samplerState, const float* loc, float level, void* outData, size_t dataSize) = 0;
};

template <typename T>
struct Texture1D
{
    void GetDimensions(uint32_t* outWidth) { *outWidth = texture->GetDimensions().width; }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels) 
    { 
        auto dims = texture->GetDimensions(mipLevel); 
        *outWidth = dims.width; 
        *outNumberOfLevels = dims.numberOfLevels; 
    }
    
    void GetDimensions(float* outWidth) { *outWidth = texture->GetDimensions().width; }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels) 
    { 
        auto dims = texture->GetDimensions(mipLevel); 
        *outWidth = dims.width; 
        *outNumberOfLevels = dims.numberOfLevels; 
    }
    
    T Load(const int2& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T Sample(SamplerState samplerState, float loc) const { T out; texture->Sample(samplerState, &loc, &out, sizeof(out)); return out; }
    T SampleLevel(SamplerState samplerState, float loc, float level) { T out; texture->SampleLevel(samplerState, &loc, level, &out, sizeof(out)); return out; }
    
    ITexture* texture;              
};

template <typename T>
struct Texture2D
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
    { 
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outHeight) 
    { 
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T Sample(SamplerState samplerState, const float2& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
    T SampleLevel(SamplerState samplerState, const float2& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
    
    ITexture* texture;              
};

template <typename T>
struct Texture3D
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth)
    {
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
        *outDepth = dims.depth;
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outDepth = dims.depth;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outHeight, float* outDepth)
    {
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
        *outDepth = dims.depth;
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outDepth, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outDepth = dims.depth;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Load(const int4& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
    
    ITexture* texture;              
};

template <typename T>
struct TextureCube
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
    { 
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outHeight) 
    { 
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
    
    ITexture* texture;              
};

template <typename T>
struct Texture1DArray
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outElements) { auto dims = texture->GetDimensions(); *outWidth = dims.width; *outElements = dims.arrayElementCount; }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outElements, uint32_t* outNumberOfLevels) 
    {
        auto dims = texture->GetDimensions(mipLevel); 
        *outWidth = dims.width; 
        *outNumberOfLevels = dims.numberOfLevels;
        *outElements = dims.arrayElementCount; 
    }        
    void GetDimensions(float* outWidth, float* outElements) { auto dims = texture->GetDimensions(); *outWidth = dims.width; *outElements = dims.arrayElementCount; }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outElements, float* outNumberOfLevels) 
    {
        auto dims = texture->GetDimensions(mipLevel); 
        *outWidth = dims.width; 
        *outNumberOfLevels = dims.numberOfLevels;
        *outElements = dims.arrayElementCount; 
    }
    
    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T Sample(SamplerState samplerState, const float2& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
    T SampleLevel(SamplerState samplerState, const float2& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
    
    ITexture* texture;              
};

template <typename T>
struct Texture2DArray
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
    {
        auto dims = texture->GetDimensions();
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
    {
        auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    void GetDimensions(uint32_t* outWidth, float* outHeight, float* outElements)
    {
        auto dims = texture->GetDimensions();
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
    {
        auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Load(const int4& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
    
    ITexture* texture;              
};

template <typename T>
struct TextureCubeArray
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
    {
        auto dims = texture->GetDimensions();
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
    {
        auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    void GetDimensions(uint32_t* outWidth, float* outHeight, float* outElements)
    {
        auto dims = texture->GetDimensions();
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
    {
        auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Sample(SamplerState samplerState, const float4& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
    T SampleLevel(SamplerState samplerState, const float4& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
    
    ITexture* texture;              
};

/* !!!!!!!!!!!!!!!!!!!!!!!!!!! RWTexture !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */

struct IRWTexture : ITexture
{
        /// Get the reference to the element at loc. 
    virtual void* refAt(const uint32_t* loc) = 0;
};

template <typename T>
struct RWTexture1D
{
    void GetDimensions(uint32_t* outWidth) { *outWidth = texture->GetDimensions().width; }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels) { auto dims = texture->GetDimensions(mipLevel); *outWidth = dims.width; *outNumberOfLevels = dims.numberOfLevels; }
    
    void GetDimensions(float* outWidth) { *outWidth = texture->GetDimensions().width; }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels) { auto dims = texture->GetDimensions(mipLevel); *outWidth = dims.width; *outNumberOfLevels = dims.numberOfLevels; }
    
    T Load(int32_t loc) const { T out; texture->Load(&loc, &out, sizeof(out)); return out; }
    T& operator[](uint32_t loc) { return *(T*)texture->refAt(&loc); }
    IRWTexture* texture;              
};

template <typename T>
struct RWTexture2D
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
    { 
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outHeight) 
    { 
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Load(const int2& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T& operator[](const uint2& loc) { return *(T*)texture->refAt(&loc.x); }
    IRWTexture* texture;
};

template <typename T>
struct RWTexture3D
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth)
    {
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
        *outDepth = dims.depth;
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outDepth = dims.depth;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outHeight, float* outDepth)
    {
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
        *outDepth = dims.depth;
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outDepth, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outDepth = dims.depth;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T& operator[](const uint3& loc) { return *(T*)texture->refAt(&loc.x); }
    IRWTexture* texture;
};


template <typename T>
struct RWTexture1DArray
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outElements) 
    { 
        auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outElements = dims.arrayElementCount; 
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outElements, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outElements) 
    { 
        auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outElements = dims.arrayElementCount; 
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outElements, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Load(int2 loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T& operator[](uint2 loc) { return *(T*)texture->refAt(&loc.x); }

    IRWTexture* texture;
};

template <typename T>
struct RWTexture2DArray
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
    {
        auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount; 
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outHeight, float* outElements)
    {
        auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount; 
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
    T& operator[](const uint3& loc) { return *(T*)texture->refAt(&loc.x); }

    IRWTexture* texture;
};

// FeedbackTexture

struct FeedbackType {};
struct SAMPLER_FEEDBACK_MIN_MIP : FeedbackType {};
struct SAMPLER_FEEDBACK_MIP_REGION_USED : FeedbackType {};

struct IFeedbackTexture
{
    virtual TextureDimensions GetDimensions(int mipLevel = -1) = 0;

    // Note here we pass the optional clamp parameter as a pointer. Passing nullptr means no clamp. 
    // This was preferred over having two function definitions, and having to differentiate their names
    virtual void WriteSamplerFeedback(ITexture* tex, SamplerState samp, const float* location, const float* clamp = nullptr) = 0;
    virtual void WriteSamplerFeedbackBias(ITexture* tex, SamplerState samp, const float* location, float bias, const float* clamp = nullptr) = 0;
    virtual void WriteSamplerFeedbackGrad(ITexture* tex, SamplerState samp, const float* location, const float* ddx, const float* ddy, const float* clamp = nullptr) = 0;
    
    virtual void WriteSamplerFeedbackLevel(ITexture* tex, SamplerState samp, const float* location, float lod) = 0;
};

template <typename T>
struct FeedbackTexture2D
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
    { 
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outHeight) 
    { 
        const auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height; 
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    template <typename S>
    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location, float clamp) { texture->WriteSamplerFeedback(tex.texture, samp, &location.x, &clamp); } 

    template <typename S>
    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias, float clamp) { texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias, &clamp); }

    template <typename S>
    void WriteSamplerFeedbackGrad(Texture2D<S> tex, SamplerState samp, float2 location, float2 ddx, float2 ddy, float clamp) { texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp); }

    // Level

    template <typename S> 
    void WriteSamplerFeedbackLevel(Texture2D<S> tex, SamplerState samp, float2 location, float lod) { texture->WriteSamplerFeedbackLevel(tex.texture, samp, &location.x, lod); }
    
    // Without Clamp
    template <typename S> 
    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location) { texture->WriteSamplerFeedback(tex.texture, samp, &location.x); }

    template <typename S> 
    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias) { texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias); }

    template <typename S> 
    void WriteSamplerFeedbackGrad(Texture2D<S> tex, SamplerState samp, float2 location, float2 ddx, float2 ddy) { texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x); }
    
    IFeedbackTexture* texture;
};

template <typename T>
struct FeedbackTexture2DArray
{
    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
    {
        auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount; 
    }
    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    void GetDimensions(float* outWidth, float* outHeight, float* outElements)
    {
        auto dims = texture->GetDimensions(); 
        *outWidth = dims.width; 
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount; 
    }
    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
    {
        const auto dims = texture->GetDimensions(mipLevel);
        *outWidth = dims.width;
        *outHeight = dims.height;
        *outElements = dims.arrayElementCount;
        *outNumberOfLevels = dims.numberOfLevels;
    }
    
    template <typename S>
    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location, float clamp) { texture->WriteSamplerFeedback(texArray.texture, samp, &location.x, &clamp); }

    template <typename S>
    void WriteSamplerFeedbackBias(Texture2DArray<S> texArray, SamplerState samp, float3 location, float bias, float clamp) { texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias, &clamp); }

    template <typename S>
    void WriteSamplerFeedbackGrad(Texture2DArray<S> texArray, SamplerState samp, float3 location, float3 ddx, float3 ddy, float clamp) { texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp); }

    // Level
    template <typename S>
    void WriteSamplerFeedbackLevel(Texture2DArray<S> texArray, SamplerState samp, float3 location, float lod) { texture->WriteSamplerFeedbackLevel(texArray.texture, samp, &location.x, lod); }

    // Without Clamp

    template <typename S>
    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location) { texture->WriteSamplerFeedback(texArray.texture, samp, &location.x); }

    template <typename S>
    void WriteSamplerFeedbackBias(Texture2DArray<S> texArray, SamplerState samp, float3 location, float bias) { texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias); }

    template <typename S>
    void WriteSamplerFeedbackGrad(Texture2DArray<S> texArray, SamplerState samp, float3 location, float3 ddx, float3 ddy) { texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x); }
    
    IFeedbackTexture* texture;
};

/* Varying input for Compute */

/* Used when running a single thread */
struct ComputeThreadVaryingInput
{
    uint3 groupID;
    uint3 groupThreadID;
};

struct ComputeVaryingInput
{
    uint3 startGroupID;     ///< start groupID
    uint3 endGroupID;       ///< Non inclusive end groupID
};

// The uniformEntryPointParams and uniformState must be set to structures that match layout that the kernel expects.
// This can be determined via reflection for example.

typedef void(*ComputeThreadFunc)(ComputeThreadVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
typedef void(*ComputeFunc)(ComputeVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);

template<typename TResult, typename TInput>
TResult slang_bit_cast(TInput val)
{
    return *(TResult*)(&val);
}

#ifdef SLANG_PRELUDE_NAMESPACE
}
#endif

#endif




================================================
FILE: Source/External/slang/prelude/slang-cuda-prelude.h
================================================
// Define SLANG_CUDA_ENABLE_HALF to use the cuda_fp16 include to add half support. 
// For this to work NVRTC needs to have the path to the CUDA SDK.
//
// As it stands the includes paths defined for Slang are passed down to NVRTC. Similarly defines defined for the Slang compile
// are passed down. 

#ifdef SLANG_CUDA_ENABLE_HALF
// We don't want half2 operators, because it will implement comparison operators that return a bool(!). We want to generate
// those functions. Doing so means that we will have to define all the other half2 operators.
#   define __CUDA_NO_HALF2_OPERATORS__
#   include <cuda_fp16.h>
#endif

#ifdef SLANG_CUDA_ENABLE_OPTIX
#include <optix.h>
#endif

// Define slang offsetof implementation 
#ifndef SLANG_OFFSET_OF
#   define SLANG_OFFSET_OF(type, member) (size_t)((char*)&(((type *)0)->member) - (char*)0)
#endif

#ifndef SLANG_ALIGN_OF
#   define SLANG_ALIGN_OF(type) __alignof__(type)
#endif

// Must be large enough to cause overflow and therefore infinity
#ifndef SLANG_INFINITY
#   define SLANG_INFINITY   ((float)(1e+300 * 1e+300))
#endif

// For now we'll disable any asserts in this prelude
#define SLANG_PRELUDE_ASSERT(x) 

#ifndef SLANG_CUDA_WARP_SIZE 
#   define SLANG_CUDA_WARP_SIZE 32
#endif

#define SLANG_CUDA_WARP_MASK (SLANG_CUDA_WARP_SIZE - 1)

//
#define SLANG_FORCE_INLINE inline

#define SLANG_CUDA_CALL __device__ 

#define SLANG_FORCE_INLINE inline
#define SLANG_INLINE inline


// Since we are using unsigned arithmatic care is need in this comparison.
// It is *assumed* that sizeInBytes >= elemSize. Which means (sizeInBytes >= elemSize) >= 0
// Which means only a single test is needed

// Asserts for bounds checking.
// It is assumed index/count are unsigned types.
#define SLANG_BOUND_ASSERT(index, count)  SLANG_PRELUDE_ASSERT(index < count); 
#define SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_PRELUDE_ASSERT(index <= (sizeInBytes - elemSize) && (index & 3) == 0);

// Macros to zero index if an access is out of range
#define SLANG_BOUND_ZERO_INDEX(index, count) index = (index < count) ? index : 0; 
#define SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes) index = (index <= (sizeInBytes - elemSize)) ? index : 0; 

// The 'FIX' macro define how the index is fixed. The default is to do nothing. If SLANG_ENABLE_BOUND_ZERO_INDEX
// the fix macro will zero the index, if out of range
#ifdef  SLANG_ENABLE_BOUND_ZERO_INDEX
#   define SLANG_BOUND_FIX(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
#   define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) SLANG_BOUND_ZERO_INDEX(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
#else
#   define SLANG_BOUND_FIX(index, count) 
#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) 
#   define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) 
#endif

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

#ifndef SLANG_BOUND_CHECK_BYTE_ADDRESS
#   define SLANG_BOUND_CHECK_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
#endif

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

 // This macro handles how out-of-range surface coordinates are handled; 
 // I can equal
 // cudaBoundaryModeClamp, in which case out-of-range coordinates are clamped to the valid range
 // cudaBoundaryModeZero, in which case out-of-range reads return zero and out-of-range writes are ignored
 // cudaBoundaryModeTrap, in which case out-of-range accesses cause the kernel execution to fail. 
 
#ifndef SLANG_CUDA_BOUNDARY_MODE
#   define SLANG_CUDA_BOUNDARY_MODE cudaBoundaryModeZero

// Can be one of SLANG_CUDA_PTX_BOUNDARY_MODE. Only applies *PTX* emitted CUDA operations
// which currently is just RWTextureRW format writes
// 
// .trap         causes an execution trap on out-of-bounds addresses
// .clamp        stores data at the nearest surface location (sized appropriately)
// .zero         drops stores to out-of-bounds addresses 

#   define SLANG_PTX_BOUNDARY_MODE "zero"
#endif

struct TypeInfo
{
    size_t typeSize;
};

template <typename T, size_t SIZE>
struct FixedArray
{
    SLANG_CUDA_CALL const T& operator[](size_t index) const { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
    SLANG_CUDA_CALL T& operator[](size_t index) { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
    
    T m_data[SIZE];
};

// An array that has no specified size, becomes a 'Array'. This stores the size so it can potentially 
// do bounds checking.  
template <typename T>
struct Array
{
    SLANG_CUDA_CALL const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
    SLANG_CUDA_CALL T& operator[](size_t index) { SLANG_BOUND_CHECK(index, count); return data[index]; }
    
    T* data;
    size_t count;
};

// Typically defined in cuda.h, but we can't ship/rely on that, so just define here
typedef unsigned long long CUtexObject;                   
typedef unsigned long long CUsurfObject;                  

// On CUDA sampler state is actually bound up with the texture object. We have a SamplerState type, 
// backed as a pointer, to simplify code generation, with the downside that such a binding will take up 
// uniform space, even though it will have no effect. 
// TODO(JS): Consider ways to strip use of variables of this type so have no binding,
struct SamplerStateUnused;
typedef SamplerStateUnused* SamplerState;


// TODO(JS): Not clear yet if this can be handled on CUDA, by just ignoring.
// For now, just map to the index type. 
typedef size_t NonUniformResourceIndex;

// Code generator will generate the specific type
template <typename T, int ROWS, int COLS>
struct Matrix;

typedef bool bool1;
typedef int2 bool2;
typedef int3 bool3;
typedef int4 bool4; 


typedef signed char int8_t;
typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;

typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;

typedef long long longlong;
typedef unsigned long long ulonglong;

typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;

union Union32 
{
    uint32_t u;
    int32_t i;
    float f;
};

union Union64
{
    uint64_t u;
    int64_t i;
    double d;
};

//
// Half support
// 

#if SLANG_CUDA_ENABLE_HALF

// Add the other vector half types
struct __half3 { __half2 xy; __half z; };
struct __half4 { __half2 xy; __half2 zw; };

// *** convert ***

// half -> other

// float
SLANG_FORCE_INLINE SLANG_CUDA_CALL float2 convert_float2(const __half2& v) { return __half22float2(v); } 
SLANG_FORCE_INLINE SLANG_CUDA_CALL float3 convert_float3(const __half3& v) { const float2 xy = __half22float2(v.xy); return float3{xy.x, xy.y, __half2float(v.z)}; } 
SLANG_FORCE_INLINE SLANG_CUDA_CALL float4 convert_float4(const __half4& v) { const float2 xy = __half22float2(v.xy); const float2 zw = __half22float2(v.zw); return float4{xy.x, xy.y, zw.x, zw.y}; }

// double
SLANG_FORCE_INLINE SLANG_CUDA_CALL double2 convert_double2(const __half2& v) { const float2 xy = __half22float2(v); return double2{ xy.x, xy.y }; } 
SLANG_FORCE_INLINE SLANG_CUDA_CALL double3 convert_double3(const __half3& v) { const float2 xy = __half22float2(v.xy); return double3{ xy.x, xy.y, __half2float(v.z)}; } 
SLANG_FORCE_INLINE SLANG_CUDA_CALL double4 convert_double4(const __half4& v) { const float2 xy = __half22float2(v.xy); const float2 zw = __half22float2(v.zw); return double4{xy.x, xy.y, zw.x, zw.y}; }

// int
SLANG_FORCE_INLINE SLANG_CUDA_CALL int2 convert_int2(const __half2& v) { return int2 { __half2int_rz(v.x), __half2int_rz(v.y) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL int3 convert_int3(const __half3& v) { return int3 { __half2int_rz(v.xy.x), __half2int_rz(v.xy.y), __half2int_rz(v.z) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL int4 convert_int4(const __half4& v) { return int4 { __half2int_rz(v.xy.x), __half2int_rz(v.xy.y), __half2int_rz(v.zw.x), __half2int_rz(v.zw.y)}; }

// uint
SLANG_FORCE_INLINE SLANG_CUDA_CALL uint2 convert_uint2(const __half2& v) { return uint2 { __half2uint_rz(v.x), __half2uint_rz(v.y) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL uint3 convert_uint3(const __half3& v) { return uint3 { __half2uint_rz(v.xy.x), __half2uint_rz(v.xy.y), __half2uint_rz(v.z) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL uint4 convert_uint4(const __half4& v) { return uint4 { __half2uint_rz(v.xy.x), __half2uint_rz(v.xy.y), __half2uint_rz(v.zw.x), __half2uint_rz(v.zw.y)}; }

// other -> half

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 convert___half2(const float2& v) { return __float22half2_rn(v); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 convert___half3(const float3& v) { return __half3{ __float22half2_rn(float2{v.x, v.y}), __float2half_rn(v.z) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 convert___half4(const float4& v) { return __half4{ __float22half2_rn(float2{v.x, v.y}), __float22half2_rn(float2{v.z, v.w}) }; }

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 convert___half2(const int2& v) { return __half2{ __int2half_rz(v.x), __int2half_rz(v.y) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 convert___half3(const int3& v) { return __half3{ __half2{__int2half_rz(v.x), __int2half_rz(v.y)}, __int2half_rz(v.z) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 convert___half4(const int4& v) { return __half4{ __half2{__int2half_rz(v.x), __int2half_rz(v.y)}, __half2{__int2half_rz(v.z),  __int2half_rz(v.w)} }; }

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 convert___half2(const uint2& v) { return __half2{ __uint2half_rz(v.x), __uint2half_rz(v.y) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 convert___half3(const uint3& v) { return __half3{ __half2{__uint2half_rz(v.x), __uint2half_rz(v.y)}, __uint2half_rz(v.z) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 convert___half4(const uint4& v) { return __half4{ __half2{__uint2half_rz(v.x), __uint2half_rz(v.y)}, __half2{__uint2half_rz(v.z),  __uint2half_rz(v.w)} }; }

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 convert___half2(const double2& v) { return __float22half2_rn(float2{v.x, v.y}); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 convert___half3(const double3& v) { return __half3{ __float22half2_rn(float2{v.x, v.y}), __float2half_rn(v.z) }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 convert___half4(const double4& v) { return __half4{ __float22half2_rn(float2{v.x, v.y}), __float22half2_rn(float2{v.z, v.w}) }; }

// *** make ***

// Mechanism to make half vectors
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 make___half2(__half x, __half y) { return __halves2half2(x, y); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 make___half3(__half x, __half y, __half z) { return __half3{ __halves2half2(x, y), z }; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 make___half4(__half x, __half y, __half z, __half w) { return __half4{ __halves2half2(x, y), __halves2half2(z, w)}; }

// *** constructFromScalar ***

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 constructFromScalar___half2(half x) { return __half2half2(x); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 constructFromScalar___half3(half x) { return __half3{__half2half2(x), x}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 constructFromScalar___half4(half x) { const __half2 v = __half2half2(x); return __half4{v, v}; }

// *** half2 ***

// half2 maths ops

// NOTE! That by default these are in cuda_fp16.hpp, but we disable them, because we need to define the comparison operators
// as we need versions that will return vector<bool>

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator+(const __half2& lh, const __half2& rh) { return __hadd2(lh, rh); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator-(const __half2& lh, const __half2& rh) { return __hsub2(lh, rh); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator*(const __half2& lh, const __half2& rh) { return __hmul2(lh, rh); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator/(const __half2& lh, const __half2& rh) { return __h2div(lh, rh); }

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2& operator+=(__half2& lh, const __half2& rh) { lh = __hadd2(lh, rh); return lh; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2& operator-=(__half2& lh, const __half2& rh) { lh = __hsub2(lh, rh); return lh; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2& operator*=(__half2& lh, const __half2& rh) { lh = __hmul2(lh, rh); return lh; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2& operator/=(__half2& lh, const __half2& rh) { lh = __h2div(lh, rh); return lh; }

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 &operator++(__half2 &h)      { __half2_raw one; one.x = 0x3C00; one.y = 0x3C00; h = __hadd2(h, one); return h; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 &operator--(__half2 &h)      { __half2_raw one; one.x = 0x3C00; one.y = 0x3C00; h = __hsub2(h, one); return h; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2  operator++(__half2 &h, int) { __half2 ret = h; __half2_raw one; one.x = 0x3C00; one.y = 0x3C00; h = __hadd2(h, one); return ret; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2  operator--(__half2 &h, int) { __half2 ret = h; __half2_raw one; one.x = 0x3C00; one.y = 0x3C00; h = __hsub2(h, one); return ret; }

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator+(const __half2 &h) { return h; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator-(const __half2 &h) { return __hneg2(h); }

// vec op scalar
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator+(const __half2& lh, __half rh) { return __hadd2(lh, __half2half2(rh)); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator-(const __half2& lh, __half rh) { return __hsub2(lh, __half2half2(rh)); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator*(const __half2& lh, __half rh) { return __hmul2(lh, __half2half2(rh)); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator/(const __half2& lh, __half rh) { return __h2div(lh, __half2half2(rh)); }

// scalar op vec
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator+(__half lh, const __half2& rh) { return __hadd2(__half2half2(lh), rh); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator-(__half lh, const __half2& rh) { return __hsub2(__half2half2(lh), rh); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator*(__half lh, const __half2& rh) { return __hmul2(__half2half2(lh), rh); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 operator/(__half lh, const __half2& rh) { return __h2div(__half2half2(lh), rh); }

// *** half3 ***

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator+(const __half3& lh, const __half3& rh) { return __half3{__hadd2(lh.xy, rh.xy), __hadd(lh.z, rh.z)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator-(const __half3& lh, const __half3& rh) { return __half3{__hsub2(lh.xy, rh.xy), __hsub(lh.z, rh.z)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator*(const __half3& lh, const __half3& rh) { return __half3{__hmul2(lh.xy, rh.xy), __hmul(lh.z, rh.z)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator/(const __half3& lh, const __half3& rh) { return __half3{__h2div(lh.xy, rh.xy), __hdiv(lh.z, rh.z)}; }

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator-(const __half3& h) { return __half3{__hneg2(h.xy), __hneg(h.z)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator+(const __half3& h) { return h; }

// vec op scalar
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator+(const __half3& lh, __half rh) { return __half3{__hadd2(lh.xy, __half2half2(rh)), __hadd(lh.z, rh)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator-(const __half3& lh, __half rh) { return __half3{__hsub2(lh.xy, __half2half2(rh)), __hsub(lh.z, rh)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator*(const __half3& lh, __half rh) { return __half3{__hmul2(lh.xy, __half2half2(rh)), __hmul(lh.z, rh)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator/(const __half3& lh, __half rh) { return __half3{__h2div(lh.xy, __half2half2(rh)), __hdiv(lh.z, rh)}; }

// scalar op vec
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator+(__half lh, const __half3& rh) { return __half3{__hadd2(__half2half2(lh), rh.xy), __hadd(lh, rh.z)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator-(__half lh, const __half3& rh) { return __half3{__hsub2(__half2half2(lh), rh.xy), __hsub(lh, rh.z)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator*(__half lh, const __half3& rh) { return __half3{__hmul2(__half2half2(lh), rh.xy), __hmul(lh, rh.z)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 operator/(__half lh, const __half3& rh) { return __half3{__h2div(__half2half2(lh), rh.xy), __hdiv(lh, rh.z)}; }

// *** half4 ***

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator+(const __half4& lh, const __half4& rh) { return __half4{__hadd2(lh.xy, rh.xy), __hadd2(lh.zw, rh.zw)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator-(const __half4& lh, const __half4& rh) { return __half4{__hsub2(lh.xy, rh.xy), __hsub2(lh.zw, rh.zw)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator*(const __half4& lh, const __half4& rh) { return __half4{__hmul2(lh.xy, rh.xy), __hmul2(lh.zw, rh.zw)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator/(const __half4& lh, const __half4& rh) { return __half4{__h2div(lh.xy, rh.xy), __h2div(lh.zw, rh.zw)}; }

// vec op scalar
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator+(const __half4& lh, __half rh) { const __half2 rhv = __half2half2(rh); return __half4{__hadd2(lh.xy, rhv), __hadd2(lh.zw, rhv)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator-(const __half4& lh, __half rh) { const __half2 rhv = __half2half2(rh); return __half4{__hsub2(lh.xy, rhv), __hsub2(lh.zw, rhv)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator*(const __half4& lh, __half rh) { const __half2 rhv = __half2half2(rh); return __half4{__hmul2(lh.xy, rhv), __hmul2(lh.zw, rhv)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator/(const __half4& lh, __half rh) { const __half2 rhv = __half2half2(rh); return __half4{__h2div(lh.xy, rhv), __h2div(lh.zw, rhv)}; }

// scalar op vec
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator+(__half lh, const __half4& rh) { const __half2 lhv = __half2half2(lh); return __half4{__hadd2(lhv, rh.xy), __hadd2(lhv, rh.zw)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator-(__half lh, const __half4& rh) { const __half2 lhv = __half2half2(lh); return __half4{__hsub2(lhv, rh.xy), __hsub2(lhv, rh.zw)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator*(__half lh, const __half4& rh) { const __half2 lhv = __half2half2(lh); return __half4{__hmul2(lhv, rh.xy), __hmul2(lhv, rh.zw)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator/(__half lh, const __half4& rh) { const __half2 lhv = __half2half2(lh); return __half4{__h2div(lhv, rh.xy), __h2div(lhv, rh.zw)}; }

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator-(const __half4& h) { return __half4{__hneg2(h.xy), __hneg2(h.zw)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 operator+(const __half4& h) { return h; }

// Convenience functions ushort -> half

SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 __ushort_as_half(const ushort2& i) { return __halves2half2(__ushort_as_half(i.x), __ushort_as_half(i.y)); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 __ushort_as_half(const ushort3& i) { return __half3{__halves2half2(__ushort_as_half(i.x), __ushort_as_half(i.y)), __ushort_as_half(i.z)}; }
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 __ushort_as_half(const ushort4& i) { return __half4{ __halves2half2(__ushort_as_half(i.x), __ushort_as_half(i.y)), __halves2half2(__ushort_as_half(i.z), __ushort_as_half(i.w)) }; }

// Convenience functions half -> ushort

SLANG_FORCE_INLINE SLANG_CUDA_CALL ushort2 __half_as_ushort(const __half2& i) { return make_ushort2(__half_as_ushort(i.x), __half_as_ushort(i.y)); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL ushort3 __half_as_ushort(const __half3& i) { return make_ushort3(__half_as_ushort(i.xy.x), __half_as_ushort(i.xy.y), __half_as_ushort(i.z)); }
SLANG_FORCE_INLINE SLANG_CUDA_CALL ushort4 __half_as_ushort(const __half4& i) { return make_ushort4(__half_as_ushort(i.xy.x), __half_as_ushort(i.xy.y), __half_as_ushort(i.zw.x), __half_as_ushort(i.zw.y)); }

// This is a little bit of a hack. Fortunately CUDA has the definitions of the templated types in 
// include/surface_indirect_functions.h
// Here we find the template definition requires a specialization of __nv_isurf_trait to allow 
// a specialization of the surface write functions. 
// This *isn't* a problem on the read functions as they don't have a return type that uses this mechanism 

template<> struct __nv_isurf_trait<__half> { typedef void type; };
template<> struct __nv_isurf_trait<__half2> { typedef void type; };
template<> struct __nv_isurf_trait<__half4> { typedef void type; };

#define SLANG_DROP_PARENS(...) __VA_ARGS__

#define SLANG_SURFACE_READ(FUNC_NAME, TYPE_ARGS, ARGS) \
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half FUNC_NAME<__half>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
{ \
    return __ushort_as_half(FUNC_NAME<ushort>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
} \
\
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 FUNC_NAME<__half2>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
{ \
    return __ushort_as_half(FUNC_NAME<ushort2>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
} \
\
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 FUNC_NAME<__half4>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
{ \
    return __ushort_as_half(FUNC_NAME<ushort4>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
}

SLANG_SURFACE_READ(surf1Dread, (int x), (x))
SLANG_SURFACE_READ(surf2Dread, (int x, int y), (x, y))
SLANG_SURFACE_READ(surf3Dread, (int x, int y, int z), (x, y, z))
SLANG_SURFACE_READ(surf1DLayeredread, (int x, int layer), (x, layer))
SLANG_SURFACE_READ(surf2DLayeredread, (int x, int y, int layer), (x, y, layer))
SLANG_SURFACE_READ(surfCubemapread, (int x, int y, int face), (x, y, face))
SLANG_SURFACE_READ(surfCubemapLayeredread, (int x, int y, int layerFace), (x, y, layerFace))

#define SLANG_SURFACE_WRITE(FUNC_NAME, TYPE_ARGS, ARGS) \
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL void FUNC_NAME<__half>(__half data, cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
{ \
    FUNC_NAME<ushort>(__half_as_ushort(data), surfObj, SLANG_DROP_PARENS ARGS, boundaryMode);  \
} \
\
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL void FUNC_NAME<__half2>(__half2 data, cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
{ \
    FUNC_NAME<ushort2>(__half_as_ushort(data), surfObj, SLANG_DROP_PARENS ARGS, boundaryMode);  \
} \
\
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL void FUNC_NAME<__half4>(__half4 data, cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
{ \
    FUNC_NAME<ushort4>(__half_as_ushort(data), surfObj, SLANG_DROP_PARENS ARGS, boundaryMode); \
}

SLANG_SURFACE_WRITE(surf1Dwrite, (int x), (x))
SLANG_SURFACE_WRITE(surf2Dwrite, (int x, int y), (x, y))
SLANG_SURFACE_WRITE(surf3Dwrite, (int x, int y, int z), (x, y, z))
SLANG_SURFACE_WRITE(surf1DLayeredwrite, (int x, int layer), (x, layer))
SLANG_SURFACE_WRITE(surf2DLayeredwrite, (int x, int y, int layer), (x, y, layer))
SLANG_SURFACE_WRITE(surfCubemapwrite, (int x, int y, int face), (x, y, face))
SLANG_SURFACE_WRITE(surfCubemapLayeredwrite, (int x, int y, int layerFace), (x, y, layerFace))

// ! Hack to test out reading !!!
// Only works converting *from* half 
 
//template <typename T> 
//SLANG_FORCE_INLINE SLANG_CUDA_CALL T surf2Dread_convert(cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode);

#define SLANG_SURFACE_READ_HALF_CONVERT(FUNC_NAME, TYPE_ARGS, ARGS) \
\
template <typename T>  \
SLANG_FORCE_INLINE SLANG_CUDA_CALL T FUNC_NAME##_convert(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode); \
\
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL float FUNC_NAME##_convert<float>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode)  \
{ \
    return __ushort_as_half(FUNC_NAME<uint16_t>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
} \
\
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL float2 FUNC_NAME##_convert<float2>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
{ \
    const __half2 v = __ushort_as_half(FUNC_NAME<ushort2>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
    return float2{v.x, v.y}; \
} \
\
template <> \
SLANG_FORCE_INLINE SLANG_CUDA_CALL float4 FUNC_NAME##_convert<float4>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
{ \
    const __half4 v = __ushort_as_half(FUNC_NAME<ushort4>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
    return float4{v.xy.x, v.xy.y, v.zw.x, v.zw.y}; \
}

SLANG_SURFACE_READ_HALF_CONVERT(surf1Dread, (int x), (x)) 
SLANG_SURFACE_READ_HALF_CONVERT(surf2Dread, (int x, int y), (x, y)) 
SLANG_SURFACE_READ_HALF_CONVERT(surf3Dread, (int x, int y, int z), (x, y, z))

#endif

// Support for doing format conversion when writing to a surface/RWTexture

// NOTE! For normal surface access x values are *byte* addressed.
// For the _convert versions they are *not*. They don't need to be because sust.p does not require it.

template <typename T>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf1Dwrite_convert(T, cudaSurfaceObject_t surfObj, int x, cudaSurfaceBoundaryMode boundaryMode);
template <typename T>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf2Dwrite_convert(T, cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode);
template <typename T>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf3Dwrite_convert(T, cudaSurfaceObject_t surfObj, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode);

// https://docs.nvidia.com/cuda/inline-ptx-assembly/index.html
// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#surface-instructions-sust

// Float

template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf1Dwrite_convert<float>(float v, cudaSurfaceObject_t surfObj, int x, cudaSurfaceBoundaryMode boundaryMode)
{
    asm volatile ( "{sust.p.1d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1}], {%2};}\n\t" :: "l"(surfObj),"r"(x),"f"(v));     
}
 
template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf2Dwrite_convert<float>(float v, cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode)
{
    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2}], {%3};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"f"(v));
}

template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf3Dwrite_convert<float>(float v, cudaSurfaceObject_t surfObj, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode)
{
    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2,%3}], {%4};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"r"(z),"f"(v));
}

// Float2

template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf1Dwrite_convert<float2>(float2 v, cudaSurfaceObject_t surfObj, int x, cudaSurfaceBoundaryMode boundaryMode)
{
    const float vx = v.x, vy = v.y;
    asm volatile ( "{sust.p.1d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1}], {%2,%3};}\n\t" :: "l"(surfObj),"r"(x),"f"(vx),"f"(vy));     
}
 
template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf2Dwrite_convert<float2>(float2 v, cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode)
{
    const float vx = v.x, vy = v.y;
    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2}], {%3,%4};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"f"(vx),"f"(vy));
}

template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf3Dwrite_convert<float2>(float2 v, cudaSurfaceObject_t surfObj, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode)
{
    const float vx = v.x, vy = v.y;
    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2,%3}], {%4,%5};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"r"(z),"f"(vx),"f"(vy));
}

// Float4
template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf1Dwrite_convert<float4>(float4 v, cudaSurfaceObject_t surfObj, int x, cudaSurfaceBoundaryMode boundaryMode)
{
    const float vx = v.x, vy = v.y, vz = v.z, vw = v.w;
    asm volatile ( "{sust.p.1d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1}], {%2,%3,%4,%5};}\n\t" :: "l"(surfObj),"r"(x),"f"(vx),"f"(vy),"f"(vz),"f"(vw));     
}
 
template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf2Dwrite_convert<float4>(float4 v, cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode)
{
    const float vx = v.x, vy = v.y, vz = v.z, vw = v.w;
    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2}], {%3,%4,%5,%6};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"f"(vx),"f"(vy),"f"(vz),"f"(vw));
}

template <>
SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf3Dwrite_convert<float4>(float4 v, cudaSurfaceObject_t surfObj, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode)
{
    const float vx = v.x, vy = v.y, vz = v.z, vw = v.w;
    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2,%3}], {%4,%5,%6,%7};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"r"(z),"f"(vx),"f"(vy),"f"(vz),"f"(vw));
}

// ----------------------------- F32 -----------------------------------------

// Unary 
SLANG_CUDA_CALL float F32_ceil(float f) { return ::ceilf(f); }
SLANG_CUDA_CALL float F32_floor(float f) { return ::floorf(f); }
SLANG_CUDA_CALL float F32_round(float f) { return ::roundf(f); }
SLANG_CUDA_CALL float F32_sin(float f) { return ::sinf(f); }
SLANG_CUDA_CALL float F32_cos(float f) { return ::cosf(f); }
SLANG_CUDA_CALL void F32_sincos(float f, float* s, float* c) { ::sincosf(f, s, c); }
SLANG_CUDA_CALL float F32_tan(float f) { return ::tanf(f); }
SLANG_CUDA_CALL float F32_asin(float f) { return ::asinf(f); }
SLANG_CUDA_CALL float F32_acos(float f) { return ::acosf(f); }
SLANG_CUDA_CALL float F32_atan(float f) { return ::atanf(f); }
SLANG_CUDA_CALL float F32_sinh(float f) { return ::sinhf(f); }
SLANG_CUDA_CALL float F32_cosh(float f) { return ::coshf(f); }
SLANG_CUDA_CALL float F32_tanh(float f) { return ::tanhf(f); }
SLANG_CUDA_CALL float F32_log2(float f) { return ::log2f(f); }
SLANG_CUDA_CALL float F32_log(float f) { return ::logf(f); }
SLANG_CUDA_CALL float F32_log10(float f) { return ::log10f(f); }
SLANG_CUDA_CALL float F32_exp2(float f) { return ::exp2f(f); }
SLANG_CUDA_CALL float F32_exp(float f) { return ::expf(f); }
SLANG_CUDA_CALL float F32_abs(float f) { return ::fabsf(f); }
SLANG_CUDA_CALL float F32_trunc(float f) { return ::truncf(f); }
SLANG_CUDA_CALL float F32_sqrt(float f) { return ::sqrtf(f); }
SLANG_CUDA_CALL float F32_rsqrt(float f) { return ::rsqrtf(f); }
SLANG_CUDA_CALL float F32_sign(float f) { return ( f == 0.0f) ? f : (( f < 0.0f) ? -1.0f : 1.0f); } 
SLANG_CUDA_CALL float F32_frac(float f) { return f - F32_floor(f); }

SLANG_CUDA_CALL bool F32_isnan(float f) { return isnan(f); }
SLANG_CUDA_CALL bool F32_isfinite(float f) { return isfinite(f); }
SLANG_CUDA_CALL bool F32_isinf(float f) { return isinf(f); }

// Binary
SLANG_CUDA_CALL float F32_min(float a, float b) { return ::fminf(a, b); }
SLANG_CUDA_CALL float F32_max(float a, float b) { return ::fmaxf(a, b); }
SLANG_CUDA_CALL float F32_pow(float a, float b) { return ::powf(a, b); }
SLANG_CUDA_CALL float F32_fmod(float a, float b) { return ::fmodf(a, b); }
SLANG_CUDA_CALL float F32_remainder(float a, float b) { return ::remainderf(a, b); }
SLANG_CUDA_CALL float F32_atan2(float a, float b) { return float(::atan2(a, b)); }

SLANG_CUDA_CALL float F32_frexp(float x, float* e)
{
    int ei;
    float m = ::frexpf(x, &ei);
    *e = ei;
    return m;
}
SLANG_CUDA_CALL float F32_modf(float x, float* ip)
{
    return ::modff(x, ip);
}

SLANG_CUDA_CALL uint32_t F32_asuint(float f) { Union32 u; u.f = f; return u.u; }
SLANG_CUDA_CALL int32_t F32_asint(float f) { Union32 u; u.f = f; return u.i; }

// Ternary
SLANG_CUDA_CALL float F32_fma(float a, float b, float c) { return ::fmaf(a, b, c); }


// ----------------------------- F64 -----------------------------------------

// Unary 
SLANG_CUDA_CALL double F64_ceil(double f) { return ::ceil(f); }
SLANG_CUDA_CALL double F64_floor(double f) { return ::floor(f); }
SLANG_CUDA_CALL double F64_round(double f) { return ::round(f); }
SLANG_CUDA_CALL double F64_sin(double f) { return ::sin(f); }
SLANG_CUDA_CALL double F64_cos(double f) { return ::cos(f); }
SLANG_CUDA_CALL void F64_sincos(double f, double* s, double* c) { ::sincos(f, s, c); }
SLANG_CUDA_CALL double F64_tan(double f) { return ::tan(f); }
SLANG_CUDA_CALL double F64_asin(double f) { return ::asin(f); }
SLANG_CUDA_CALL double F64_acos(double f) { return ::acos(f); }
SLANG_CUDA_CALL double F64_atan(double f) { return ::atan(f); }
SLANG_CUDA_CALL double F64_sinh(double f) { return ::sinh(f); }
SLANG_CUDA_CALL double F64_cosh(double f) { return ::cosh(f); }
SLANG_CUDA_CALL double F64_tanh(double f) { return ::tanh(f); }
SLANG_CUDA_CALL double F64_log2(double f) { return ::log2(f); }
SLANG_CUDA_CALL double F64_log(double f) { return ::log(f); }
SLANG_CUDA_CALL double F64_log10(float f) { return ::log10(f); }
SLANG_CUDA_CALL double F64_exp2(double f) { return ::exp2(f); }
SLANG_CUDA_CALL double F64_exp(double f) { return ::exp(f); }
SLANG_CUDA_CALL double F64_abs(double f) { return ::fabs(f); }
SLANG_CUDA_CALL double F64_trunc(double f) { return ::trunc(f); }
SLANG_CUDA_CALL double F64_sqrt(double f) { return ::sqrt(f); }
SLANG_CUDA_CALL double F64_rsqrt(double f) { return ::rsqrt(f); }
SLANG_CUDA_CALL double F64_sign(double f) { return (f == 0.0) ? f : ((f < 0.0) ? -1.0 : 1.0); }
SLANG_CUDA_CALL double F64_frac(double f) { return f - F64_floor(f); }

SLANG_CUDA_CALL bool F64_isnan(double f) { return isnan(f); }
SLANG_CUDA_CALL bool F64_isfinite(double f) { return isfinite(f); }
SLANG_CUDA_CALL bool F64_isinf(double f) { return isinf(f); }

// Binary
SLANG_CUDA_CALL double F64_min(double a, double b) { return ::fmin(a, b); }
SLANG_CUDA_CALL double F64_max(double a, double b) { return ::fmax(a, b); }
SLANG_CUDA_CALL double F64_pow(double a, double b) { return ::pow(a, b); }
SLANG_CUDA_CALL double F64_fmod(double a, double b) { return ::fmod(a, b); }
SLANG_CUDA_CALL double F64_remainder(double a, double b) { return ::remainder(a, b); }
SLANG_CUDA_CALL double F64_atan2(double a, double b) { return ::atan2(a, b); }

SLANG_CUDA_CALL double F64_frexp(double x, double* e)
{
    int ei;
    double m = ::frexp(x, &ei);
    *e = ei;
    return m;
}
SLANG_CUDA_CALL double F64_modf(double x, double* ip)
{
    return ::modf(x, ip);
}

SLANG_CUDA_CALL void F64_asuint(double d, uint32_t* low, uint32_t* hi)
{
    Union64 u;
    u.d = d;
    *low = uint32_t(u.u);
    *hi = uint32_t(u.u >> 32);
}

SLANG_CUDA_CALL void F64_asint(double d, int32_t* low, int32_t* hi)
{
    Union64 u;
    u.d = d;
    *low = int32_t(u.u);
    *hi = int32_t(u.u >> 32);
}

// Ternary
SLANG_CUDA_CALL double F64_fma(double a, double b, double c) { return ::fma(a, b, c); }

// ----------------------------- I32 -----------------------------------------

// Unary
SLANG_CUDA_CALL int32_t I32_abs(int32_t f) { return (f < 0) ? -f : f; }

// Binary
SLANG_CUDA_CALL int32_t I32_min(int32_t a, int32_t b) { return a < b ? a : b; }
SLANG_CUDA_CALL int32_t I32_max(int32_t a, int32_t b) { return a > b ? a : b; }

SLANG_CUDA_CALL float I32_asfloat(int32_t x) { Union32 u; u.i = x; return u.f; }
SLANG_CUDA_CALL uint32_t I32_asuint(int32_t x) { return uint32_t(x); }
SLANG_CUDA_CALL double I32_asdouble(int32_t low, int32_t hi )
{
    Union64 u;
    u.u = (uint64_t(hi) << 32) | uint32_t(low);
    return u.d;
}

// ----------------------------- U32 -----------------------------------------

// Unary 
SLANG_CUDA_CALL uint32_t U32_abs(uint32_t f) { return f; }

// Binary
SLANG_CUDA_CALL uint32_t U32_min(uint32_t a, uint32_t b) { return a < b ? a : b; }
SLANG_CUDA_CALL uint32_t U32_max(uint32_t a, uint32_t b) { return a > b ? a : b; }

SLANG_CUDA_CALL float U32_asfloat(uint32_t x) { Union32 u; u.u = x; return u.f; }
SLANG_CUDA_CALL uint32_t U32_asint(int32_t x) { return uint32_t(x); } 

SLANG_CUDA_CALL double U32_asdouble(uint32_t low, uint32_t hi)
{
    Union64 u;
    u.u = (uint64_t(hi) << 32) | low;
    return u.d;
}

SLANG_CUDA_CALL uint32_t U32_countbits(uint32_t v)
{
    // https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH__INTRINSIC__INT.html#group__CUDA__MATH__INTRINSIC__INT_1g43c9c7d2b9ebf202ff1ef5769989be46
    return __popc(v);
}


// ----------------------------- I64 -----------------------------------------

SLANG_CUDA_CALL int64_t I64_abs(int64_t f) { return (f < 0) ? -f : f; }

SLANG_CUDA_CALL int64_t I64_min(int64_t a, int64_t b) { return a < b ? a : b; }
SLANG_CUDA_CALL int64_t I64_max(int64_t a, int64_t b) { return a > b ? a : b; }

// ----------------------------- U64 -----------------------------------------

SLANG_CUDA_CALL int64_t U64_abs(uint64_t f) { return f; }

SLANG_CUDA_CALL int64_t U64_min(uint64_t a, uint64_t b) { return a < b ? a : b; }
SLANG_CUDA_CALL int64_t U64_max(uint64_t a, uint64_t b) { return a > b ? a : b; }

SLANG_CUDA_CALL uint32_t U64_countbits(uint64_t v)
{
    // https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH__INTRINSIC__INT.html#group__CUDA__MATH__INTRINSIC__INT_1g43c9c7d2b9ebf202ff1ef5769989be46
    return __popcll(v);
}


// ----------------------------- ResourceType -----------------------------------------


// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-structuredbuffer-getdimensions
// Missing  Load(_In_  int  Location, _Out_ uint Status);

template <typename T>
struct StructuredBuffer
{
    SLANG_CUDA_CALL const T& operator[](size_t index) const
    {
#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
        SLANG_BOUND_CHECK(index, count);
#endif
        return data[index];
    }

    SLANG_CUDA_CALL const T& Load(size_t index) const
    {
#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
        SLANG_BOUND_CHECK(index, count);
#endif
        return data[index];
    }

#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
    SLANG_CUDA_CALL void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
#endif

    T* data;
#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
    size_t count;
#endif
};

template <typename T>
struct RWStructuredBuffer : StructuredBuffer<T>
{
    SLANG_CUDA_CALL T& operator[](size_t index) const
    {
#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
        SLANG_BOUND_CHECK(index, this->count);
#endif
        return this->data[index];
    }
};

// Missing  Load(_In_  int  Location, _Out_ uint Status);
struct ByteAddressBuffer
{
    SLANG_CUDA_CALL void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
    SLANG_CUDA_CALL uint32_t Load(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
        return data[index >> 2]; 
    }
    SLANG_CUDA_CALL uint2 Load2(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes); 
        const size_t dataIdx = index >> 2; 
        return uint2{data[dataIdx], data[dataIdx + 1]}; 
    }
    SLANG_CUDA_CALL uint3 Load3(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
    }
    SLANG_CUDA_CALL uint4 Load4(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
    }
    template<typename T>
    SLANG_CUDA_CALL T Load(size_t index) const
    {
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
        return *(const T*)(((const char*)data) + index);
    }
    
    const uint32_t* data;
    size_t sizeInBytes;  //< Must be multiple of 4
};

// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-rwbyteaddressbuffer
// Missing support for Atomic operations 
// Missing support for Load with status
struct RWByteAddressBuffer
{
    SLANG_CUDA_CALL void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
    
    SLANG_CUDA_CALL uint32_t Load(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
        return data[index >> 2]; 
    }
    SLANG_CUDA_CALL uint2 Load2(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint2{data[dataIdx], data[dataIdx + 1]}; 
    }
    SLANG_CUDA_CALL uint3 Load3(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
    }
    SLANG_CUDA_CALL uint4 Load4(size_t index) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
    }
    template<typename T>
    SLANG_CUDA_CALL T Load(size_t index) const
    {
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
        return *(const T*)((const char*)data + index);
    }
    
    SLANG_CUDA_CALL void Store(size_t index, uint32_t v) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
        data[index >> 2] = v; 
    }
    SLANG_CUDA_CALL void Store2(size_t index, uint2 v) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        data[dataIdx + 0] = v.x;
        data[dataIdx + 1] = v.y;
    }
    SLANG_CUDA_CALL void Store3(size_t index, uint3 v) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        data[dataIdx + 0] = v.x;
        data[dataIdx + 1] = v.y;
        data[dataIdx + 2] = v.z;
    }
    SLANG_CUDA_CALL void Store4(size_t index, uint4 v) const 
    { 
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
        const size_t dataIdx = index >> 2; 
        data[dataIdx + 0] = v.x;
        data[dataIdx + 1] = v.y;
        data[dataIdx + 2] = v.z;
        data[dataIdx + 3] = v.w;
    }
    template<typename T>
    SLANG_CUDA_CALL void Store(size_t index, T const& value) const
    {
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
        *(T*)(((char*)data) + index) = value;
    }
    
        /// Can be used in stdlib to gain access
    template <typename T>
    SLANG_CUDA_CALL T* _getPtrAt(size_t index)
    {
        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
        return (T*)(((char*)data) + index);
    }
    
    uint32_t* data;
    size_t sizeInBytes; //< Must be multiple of 4 
};


// ---------------------- Wave --------------------------------------

// TODO(JS): It appears that cuda does not have a simple way to get a lane index. 
// 
// Another approach could be... 
// laneId = ((threadIdx.z * blockDim.y + threadIdx.y) * blockDim.x + threadIdx.x) & SLANG_CUDA_WARP_MASK
// If that is really true another way to do this, would be for code generator to add this function 
// with the [numthreads] baked in. 
// 
// For now I'll just assume you have a launch that makes the following correct if the kernel uses WaveGetLaneIndex()
#ifndef SLANG_USE_ASM_LANE_ID
 __forceinline__ __device__ uint32_t _getLaneId()
{
    // If the launch is (or I guess some multiple of the warp size) 
    // we try this mechanism, which is apparently faster. 
    return threadIdx.x & SLANG_CUDA_WARP_MASK;
}
#else
__forceinline__ __device__ uint32_t _getLaneId()
{
    // https://stackoverflow.com/questions/44337309/whats-the-most-efficient-way-to-calculate-the-warp-id-lane-id-in-a-1-d-grid#
    // This mechanism is not the fastest way to do it, and that is why the other mechanism 
    // is the default. But the other mechanism relies on a launch that makes the assumption 
    // true.
    unsigned ret; 
    asm volatile ("mov.u32 %0, %laneid;" : "=r"(ret));
    return ret;
}
#endif

typedef int WarpMask;

// It appears that the __activemask() cannot always be used because 
// threads need to be converged. 
// 
// For CUDA the article claims mask has to be used carefully
// https://devblogs.nvidia.com/using-cuda-warp-level-primitives/
// With the Warp intrinsics there is no mask, and it's just the 'active lanes'. 
// __activemask() though does not require there is convergence, so that doesn't work.
// 
// '__ballot_sync' produces a convergance. 
// 
// From the CUDA docs:
// ```For __all_sync, __any_sync, and __ballot_sync, a mask must be passed that specifies the threads 
// participating in the call. A bit, representing the thread's lane ID, must be set for each participating thread 
// to ensure they are properly converged before the intrinsic is executed by the hardware. All active threads named 
// in mask must execute the same intrinsic with the same mask, or the result is undefined.```
//
// Currently there isn't a mechanism to correctly get the mask without it being passed through.
// Doing so will most likely require some changes to slang code generation to track masks, for now then we use
// _getActiveMask. 

// Return mask of all the lanes less than the current lane
__forceinline__ __device__ WarpMask _getLaneLtMask()
{
    return (int(1) << _getLaneId()) - 1;
}    

// TODO(JS): 
// THIS IS NOT CORRECT! That determining the appropriate active mask requires appropriate
// mask tracking.
__forceinline__ __device__ WarpMask _getActiveMask()
{
    return __ballot_sync(__activemask(), true);
}

// Return a mask suitable for the 'MultiPrefix' style functions
__forceinline__ __device__ WarpMask _getMultiPrefixMask(int mask)
{
    return mask;
}

// Note! Note will return true if mask is 0, but thats okay, because there must be one
// lane active to execute anything
__inline__ __device__ bool _waveIsSingleLane(WarpMask mask)
{
    return (mask & (mask - 1)) == 0;
}

// Returns the power of 2 size of run of set bits. Returns 0 if not a suitable run.
__inline__ __device__ int _waveCalcPow2Offset(WarpMask mask)
{
    // This should be the most common case, so fast path it
    if (mask == SLANG_CUDA_WARP_MASK)
    {
        return SLANG_CUDA_WARP_SIZE;
    }
    // Is it a contiguous run of bits?
    if ((mask & (mask + 1)) == 0)
    {
        // const int offsetSize = __ffs(mask + 1) - 1;
        const int offset = 32 - __clz(mask);
        // Is it a power of 2 size
        if ((offset & (offset - 1)) == 0)
        {
            return offset;
        }
    }
    return 0;
}

__inline__ __device__ bool _waveIsFirstLane()
{
    const WarpMask mask = __activemask();
    // We special case bit 0, as that most warps are expected to be fully active. 
    
    // mask & -mask, isolates the lowest set bit.
    //return (mask & 1 ) || ((mask & -mask) == (1 << _getLaneId()));
    
    // This mechanism is most similar to what was in an nVidia post, so assume it is prefered. 
    return (mask & 1 ) || ((__ffs(mask) - 1) == _getLaneId());
}

template <typename T>
struct WaveOpOr
{
    __inline__ __device__ static T getInitial(T a) { return 0; }
    __inline__ __device__ static T doOp(T a, T b) { return a | b; }
};

template <typename T>
struct WaveOpAnd
{
    __inline__ __device__ static T getInitial(T a) { return ~T(0); }
    __inline__ __device__ static T doOp(T a, T b) { return a & b; }
};

template <typename T>
struct WaveOpXor
{
    __inline__ __device__ static T getInitial(T a) { return 0; }
    __inline__ __device__ static T doOp(T a, T b) { return a ^ b; }
    __inline__ __device__ static T doInverse(T a, T b) { return a ^ b; }
};

template <typename T>
struct WaveOpAdd
{
    __inline__ __device__ static T getInitial(T a) { return 0; }
    __inline__ __device__ static T doOp(T a, T b) { return a + b; }
    __inline__ __device__ static T doInverse(T a, T b) { return a - b; }
};

template <typename T>
struct WaveOpMul
{
    __inline__ __device__ static T getInitial(T a) { return T(1); }
    __inline__ __device__ static T doOp(T a, T b) { return a * b; }
    // Using this inverse for int is probably undesirable - because in general it requires T to have more precision
    // There is also a performance aspect to it, where divides are generally significantly slower
    __inline__ __device__ static T doInverse(T a, T b) { return a / b; }
};

template <typename T>
struct WaveOpMax
{
    __inline__ __device__ static T getInitial(T a) { return a; }
    __inline__ __device__ static T doOp(T a, T b) { return a > b ? a : b; }
};

template <typename T>
struct WaveOpMin
{
    __inline__  __device__ static T getInitial(T a) { return a; }
    __inline__ __device__ static T doOp(T a, T b) { return a < b ? a : b; }
};

template <typename T>
struct ElementTypeTrait;

// Scalar
template <> struct ElementTypeTrait<int> { typedef int Type; };
template <> struct ElementTypeTrait<uint> { typedef uint Type; };
template <> struct ElementTypeTrait<float> { typedef float Type; };
template <> struct ElementTypeTrait<double> { typedef double Type; };
template <> struct ElementTypeTrait<uint64_t> { typedef uint64_t Type; };
template <> struct ElementTypeTrait<int64_t> { typedef int64_t Type; };

// Vector
template <> struct ElementTypeTrait<int1> { typedef int Type; };
template <> struct ElementTypeTrait<int2> { typedef int Type; };
template <> struct ElementTypeTrait<int3> { typedef int Type; };
template <> struct ElementTypeTrait<int4> { typedef int Type; };

template <> struct ElementTypeTrait<uint1> { typedef uint Type; };
template <> struct ElementTypeTrait<uint2> { typedef uint Type; };
template <> struct ElementTypeTrait<uint3> { typedef uint Type; };
template <> struct ElementTypeTrait<uint4> { typedef uint Type; };

template <> struct ElementTypeTrait<float1> { typedef float Type; };
template <> struct ElementTypeTrait<float2> { typedef float Type; };
template <> struct ElementTypeTrait<float3> { typedef float Type; };
template <> struct ElementTypeTrait<float4> { typedef float Type; };

template <> struct ElementTypeTrait<double1> { typedef double Type; };
template <> struct ElementTypeTrait<double2> { typedef double Type; };
template <> struct ElementTypeTrait<double3> { typedef double Type; };
template <> struct ElementTypeTrait<double4> { typedef double Type; };

// Matrix
template <typename T, int ROWS, int COLS> 
struct ElementTypeTrait<Matrix<T, ROWS, COLS> >  
{ 
    typedef T Type; 
};

// Scalar 
template <typename INTF, typename T>
__device__ T _waveReduceScalar(WarpMask mask, T val)
{
    const int offsetSize = _waveCalcPow2Offset(mask);
    if (offsetSize > 0)
    {
        // Fast path O(log2(activeLanes)) 
        for (int offset = offsetSize >> 1; offset > 0; offset >>= 1)
        {
            val = INTF::doOp(val, __shfl_xor_sync(mask, val, offset));
        }
    }
    else if (!_waveIsSingleLane(mask))
    {
        T result = INTF::getInitial(val);
        int remaining = mask;
        while (remaining)
        {
            const int laneBit = remaining & -remaining;
            // Get the sourceLane 
            const int srcLane = __ffs(laneBit) - 1;
            // Broadcast (can also broadcast to self) 
            result = INTF::doOp(result, __shfl_sync(mask, val, srcLane));
            remaining &= ~laneBit;
        }
        return result;
    }
    return val;
}


// Multiple values
template <typename INTF, typename T, size_t COUNT>
__device__ void _waveReduceMultiple(WarpMask mask, T* val)
{
    const int offsetSize = _waveCalcPow2Offset(mask);
    if (offsetSize > 0)
    {
        // Fast path O(log2(activeLanes)) 
        for (int offset = offsetSize >> 1; offset > 0; offset >>= 1)
        {
            for (size_t i = 0; i < COUNT; ++i)
            {
                val[i] = INTF::doOp(val[i], __shfl_xor_sync(mask, val[i], offset));
            }
        }
    }
    else if (!_waveIsSingleLane(mask))
    {
        // Copy the original
        T originalVal[COUNT];
        for (size_t i = 0; i < COUNT; ++i)
        {
            const T v = val[i];
            originalVal[i] = v;
            val[i] = INTF::getInitial(v);
        }
        
        int remaining = mask;
        while (remaining)
        {
            const int laneBit = remaining & -remaining;
            // Get the sourceLane 
            const int srcLane = __ffs(laneBit) - 1;
            // Broadcast (can also broadcast to self) 
            for (size_t i = 0; i < COUNT; ++i)
            {
                val[i] = INTF::doOp(val[i], __shfl_sync(mask, originalVal[i], srcLane));
            }
            remaining &= ~laneBit;
        }
    }
}

template <typename INTF, typename T>
__device__ void _waveReduceMultiple(WarpMask mask, T* val)
{
    typedef typename ElementTypeTrait<T>::Type ElemType;    
    _waveReduceMultiple<INTF, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)val);
}

template <typename T>
__inline__ __device__  T _waveOr(WarpMask mask, T val) { return _waveReduceScalar<WaveOpOr<T>, T>(mask, val); }

template <typename T>
__inline__ __device__ T _waveAnd(WarpMask mask, T val) { return _waveReduceScalar<WaveOpAnd<T>, T>(mask, val); }

template <typename T>
__inline__ __device__ T _waveXor(WarpMask mask, T val) { return _waveReduceScalar<WaveOpXor<T>, T>(mask, val); }

template <typename T>
__inline__ __device__ T _waveProduct(WarpMask mask, T val) { return _waveReduceScalar<WaveOpMul<T>, T>(mask, val); }

template <typename T>
__inline__ __device__ T _waveSum(WarpMask mask, T val) { return _waveReduceScalar<WaveOpAdd<T>, T>(mask, val); }

template <typename T>
__inline__ __device__ T _waveMin(WarpMask mask, T val) { return _waveReduceScalar<WaveOpMin<T>, T>(mask, val); }

template <typename T>
__inline__ __device__ T _waveMax(WarpMask mask, T val) { return _waveReduceScalar<WaveOpMax<T>, T>(mask, val); }


// Multiple

template <typename T>
__inline__ __device__  T _waveOrMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpOr<ElemType> >(mask, &val); return val; }

template <typename T>
__inline__ __device__  T _waveAndMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpAnd<ElemType> >(mask, &val); return val; }

template <typename T>
__inline__ __device__  T _waveXorMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpXor<ElemType> >(mask, &val); return val; }

template <typename T>
__inline__ __device__  T _waveProductMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpMul<ElemType> >(mask, &val); return val; }

template <typename T>
__inline__ __device__  T _waveSumMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpAdd<ElemType> >(mask, &val); return val; }

template <typename T>
__inline__ __device__  T _waveMinMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpMin<ElemType> >(mask, &val); return val; }

template <typename T>
__inline__ __device__  T _waveMaxMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpMax<ElemType> >(mask, &val); return val; }


template <typename T>
__inline__ __device__ bool _waveAllEqual(WarpMask mask, T val) 
{
    int pred;
    __match_all_sync(mask, val, &pred);
    return pred != 0;
}

template <typename T>
__inline__ __device__ bool _waveAllEqualMultiple(WarpMask mask, T inVal) 
{
    typedef typename ElementTypeTrait<T>::Type ElemType;
    const size_t count = sizeof(T) / sizeof(ElemType);
    int pred;
    const ElemType* src = (const ElemType*)&inVal;
    for (size_t i = 0; i < count; ++i)
    {
        __match_all_sync(mask, src[i], &pred);
        if (pred == 0)
        {
            return false;
        }
    }
    return true;
}

template <typename T>
__inline__ __device__ T _waveReadFirst(WarpMask mask, T val) 
{
    const int lowestLaneId = __ffs(mask) - 1;
    return __shfl_sync(mask, val, lowestLaneId);   
}

template <typename T>
__inline__ __device__ T _waveReadFirstMultiple(WarpMask mask, T inVal) 
{
    typedef typename ElementTypeTrait<T>::Type ElemType;
    const size_t count = sizeof(T) / sizeof(ElemType);
    T outVal;
    const ElemType* src = (const ElemType*)&inVal;
    ElemType* dst = (ElemType*)&outVal;
    const int lowestLaneId = __ffs(mask) - 1;
    for (size_t i = 0; i < count; ++i)
    {
        dst[i] = __shfl_sync(mask, src[i], lowestLaneId);   
    }
    return outVal;
}

template <typename T>
__inline__ __device__ T _waveShuffleMultiple(WarpMask mask, T inVal, int lane)
{
    typedef typename ElementTypeTrait<T>::Type ElemType;
    const size_t count = sizeof(T) / sizeof(ElemType);
    T outVal;
    const ElemType* src = (const ElemType*)&inVal;
    ElemType* dst = (ElemType*)&outVal;
    for (size_t i = 0; i < count; ++i)
    {
        dst[i] = __shfl_sync(mask, src[i], lane);   
    }
    return outVal;
}

// Scalar 

// Invertable means that when we get to the end of the reduce, we can remove val (to make exclusive), using 
// the inverse of the op.
template <typename INTF, typename T>
__device__ T _wavePrefixInvertableScalar(WarpMask mask, T val)
{
    const int offsetSize = _waveCalcPow2Offset(mask);
    
    const int laneId = _getLaneId();
    T result;
    if (offsetSize > 0)
    {    
        // Sum is calculated inclusive of this lanes value
        result = val;
        for (int i = 1; i < offsetSize; i += i) 
        {
            const T readVal = __shfl_up_sync(mask, result, i, offsetSize);
            if (laneId >= i)
            {
                result = INTF::doOp(result, readVal);
            }
        }
        // Remove val from the result, by applyin inverse
        result = INTF::doInverse(result, val);
    }
    else 
    {
        result = INTF::getInitial(val);
        if (!_waveIsSingleLane(mask))
        {
            int remaining = mask;
            while (remaining)
            {
                const int laneBit = remaining & -remaining;
                // Get the sourceLane 
                const int srcLane = __ffs(laneBit) - 1;
                // Broadcast (can also broadcast to self) 
                const T readValue = __shfl_sync(mask, val, srcLane);
                // Only accumulate if srcLane is less than this lane
                if (srcLane < laneId)
                {
                    result = INTF::doOp(result, readValue);
                }
                remaining &= ~laneBit;
            }
        }   
    }
    return result;
}
 

// This implementation separately tracks the value to be propogated, and the value
// that is the final result 
template <typename INTF, typename T>
__device__ T _wavePrefixScalar(WarpMask mask, T val)
{
    const int offsetSize = _waveCalcPow2Offset(mask);
    
    const int laneId = _getLaneId();
    T result = INTF::getInitial(val);           
    if (offsetSize > 0)
    {    
        // For transmitted value we will do it inclusively with this lanes value
        // For the result we do not include the lanes value. This means an extra multiply for each iteration
        // but means we don't need to have a divide at the end and also removes overflow issues in that scenario.
        for (int i = 1; i < offsetSize; i += i) 
        {
            const T readVal = __shfl_up_sync(mask, val, i, offsetSize);
            if (laneId >= i)
            {
                result = INTF::doOp(result, readVal);
                val = INTF::doOp(val, readVal);
            }
        }
    }
    else 
    {
        if (!_waveIsSingleLane(mask))
        {
            int remaining = mask;
            while (remaining)
            {
                const int laneBit = remaining & -remaining;
                // Get the sourceLane 
                const int srcLane = __ffs(laneBit) - 1;
                // Broadcast (can also broadcast to self) 
                const T readValue = __shfl_sync(mask, val, srcLane);
                // Only accumulate if srcLane is less than this lane
                if (srcLane < laneId)
                {
                    result = INTF::doOp(result, readValue);
                }
                remaining &= ~laneBit;
            }
        }
    }
    return result;
}


template <typename INTF, typename T, size_t COUNT>
__device__ T _waveOpCopy(T* dst, const T* src)
{
    for (size_t j = 0; j < COUNT; ++j)
    {
        dst[j] = src[j];
    }
}    


template <typename INTF, typename T, size_t COUNT>
__device__ T _waveOpDoInverse(T* inOut, const T* val)
{
    for (size_t j = 0; j < COUNT; ++j)
    {
        inOut[j] = INTF::doInverse(inOut[j], val[j]);
    }
}    

template <typename INTF, typename T, size_t COUNT>
__device__ T _waveOpSetInitial(T* out, const T* val)
{
    for (size_t j = 0; j < COUNT; ++j)
    {
        out[j] = INTF::getInitial(val[j]);
    }
} 

template <typename INTF, typename T, size_t COUNT>
__device__ T _wavePrefixInvertableMultiple(WarpMask mask, T* val)
{
    const int offsetSize = _waveCalcPow2Offset(mask);
    
    const int laneId = _getLaneId();
    T originalVal[COUNT];
    _waveOpCopy<INTF, T, COUNT>(originalVal, val);
    
    if (offsetSize > 0)
    {    
        // Sum is calculated inclusive of this lanes value
        for (int i = 1; i < offsetSize; i += i) 
        {
            // TODO(JS): Note that here I don't split the laneId outside so it's only tested once.
            // This may be better but it would also mean that there would be shfl between lanes 
            // that are on different (albeit identical) instructions. So this seems more likely to 
            // work as expected with everything in lock step.
            for (size_t j = 0; j < COUNT; ++j)
            {
                const T readVal = __shfl_up_sync(mask, val[j], i, offsetSize);
                if (laneId >= i)
                {
                    val[j] = INTF::doOp(val[j], readVal);
                }
            }
        }
        // Remove originalVal from the result, by applyin inverse
        _waveOpDoInverse<INTF, T, COUNT>(val, originalVal);
    }
    else 
    {
        _waveOpSetInitial<INTF, T, COUNT>(val, val);
        if (!_waveIsSingleLane(mask))
        {
            int remaining = mask;
            while (remaining)
            {
                const int laneBit = remaining & -remaining;
                // Get the sourceLane 
                const int srcLane = __ffs(laneBit) - 1;
                
                for (size_t j = 0; j < COUNT; ++j)
                {
                    // Broadcast (can also broadcast to self) 
                    const T readValue = __shfl_sync(mask, originalVal[j], srcLane);
                    // Only accumulate if srcLane is less than this lane
                    if (srcLane < laneId)
                    {
                        val[j] = INTF::doOp(val[j], readValue);
                    }
                    remaining &= ~laneBit;
                }
            }
        }   
    }
}
 
template <typename INTF, typename T, size_t COUNT>
__device__ T _wavePrefixMultiple(WarpMask mask, T* val)
{
    const int offsetSize = _waveCalcPow2Offset(mask);
    
    const int laneId = _getLaneId();
    
    T work[COUNT];
    _waveOpCopy<INTF, T, COUNT>(work, val);
    _waveOpSetInitial<INTF, T, COUNT>(val, val);
    
    if (offsetSize > 0)
    {    
        // For transmitted value we will do it inclusively with this lanes value
        // For the result we do not include the lanes value. This means an extra op for each iteration
        // but means we don't need to have a divide at the end and also removes overflow issues in that scenario.
        for (int i = 1; i < offsetSize; i += i) 
        {
            for (size_t j = 0; j < COUNT; ++j)
            {
                const T readVal = __shfl_up_sync(mask, work[j], i, offsetSize);
                if (laneId >= i)
                {
                    work[j] = INTF::doOp(work[j], readVal);
                    val[j] = INTF::doOp(val[j], readVal);     
                }
            }
        }
    }
    else 
    {
        if (!_waveIsSingleLane(mask))
        {
            int remaining = mask;
            while (remaining)
            {
                const int laneBit = remaining & -remaining;
                // Get the sourceLane 
                const int srcLane = __ffs(laneBit) - 1;
                
                for (size_t j = 0; j < COUNT; ++j)
                {
                    // Broadcast (can also broadcast to self) 
                    const T readValue = __shfl_sync(mask, work[j], srcLane);
                    // Only accumulate if srcLane is less than this lane
                    if (srcLane < laneId)
                    {
                        val[j] = INTF::doOp(val[j], readValue);
                    }
                }
                remaining &= ~laneBit;
            }
        }
    }
}

template <typename T>
__inline__ __device__ T _wavePrefixProduct(WarpMask mask, T val) { return _wavePrefixScalar<WaveOpMul<T>, T>(mask, val); }

template <typename T>
__inline__ __device__ T _wavePrefixSum(WarpMask mask, T val) { return _wavePrefixInvertableScalar<WaveOpAdd<T>, T>(mask, val); }    

template <typename T>
__inline__ __device__ T _wavePrefixXor(WarpMask mask, T val) { return _wavePrefixInvertableScalar<WaveOpXor<T>, T>(mask, val); }    
    
template <typename T>
__inline__ __device__ T _wavePrefixOr(WarpMask mask, T val) { return _wavePrefixScalar<WaveOpOr<T>, T>(mask, val); }      
    
template <typename T>
__inline__ __device__ T _wavePrefixAnd(WarpMask mask, T val) { return _wavePrefixScalar<WaveOpAnd<T>, T>(mask, val); }      
    
    
template <typename T>
__inline__ __device__ T _wavePrefixProductMultiple(WarpMask mask, T val)  
{ 
    typedef typename ElementTypeTrait<T>::Type ElemType;    
    _wavePrefixInvertableMultiple<WaveOpMul<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
    return val;
}

template <typename T>
__inline__ __device__ T _wavePrefixSumMultiple(WarpMask mask, T val) 
{ 
    typedef typename ElementTypeTrait<T>::Type ElemType;    
    _wavePrefixInvertableMultiple<WaveOpAdd<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
    return val;
}

template <typename T>
__inline__ __device__ T _wavePrefixXorMultiple(WarpMask mask, T val)  
{ 
    typedef typename ElementTypeTrait<T>::Type ElemType;    
    _wavePrefixInvertableMultiple<WaveOpXor<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
    return val;
}

template <typename T>
__inline__ __device__ T _wavePrefixOrMultiple(WarpMask mask, T val) 
{ 
    typedef typename ElementTypeTrait<T>::Type ElemType;    
    _wavePrefixMultiple<WaveOpOr<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
    return val;
}

template <typename T>
__inline__ __device__ T _wavePrefixAndMultiple(WarpMask mask, T val)  
{ 
    typedef typename ElementTypeTrait<T>::Type ElemType;    
    _wavePrefixMultiple<WaveOpAnd<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
    return val;
}

template <typename T>
__inline__ __device__ uint4 _waveMatchScalar(WarpMask mask, T val) 
{
    int pred;
    return make_uint4(__match_all_sync(mask, val, &pred), 0, 0, 0);
}

template <typename T>
__inline__ __device__ uint4 _waveMatchMultiple(WarpMask mask, const T& inVal) 
{
    typedef typename ElementTypeTrait<T>::Type ElemType;
    const size_t count = sizeof(T) / sizeof(ElemType);
    int pred;
    const ElemType* src = (const ElemType*)&inVal;
    uint matchBits = 0xffffffff;
    for (size_t i = 0; i < count && matchBits; ++i)
    {
        matchBits = matchBits & __match_all_sync(mask, src[i], &pred);
    }
    return make_uint4(matchBits, 0, 0, 0);
}

__device__ uint getAt(dim3 a,  int b)
{
    SLANG_PRELUDE_ASSERT(b >= 0 && b < 3);
    return (&a.x)[b];
}
__device__ uint3 operator*(uint3 a, dim3 b)
{
    uint3 r;
    r.x = a.x * b.x;
    r.y = a.y * b.y;
    r.z = a.z * b.z;
    return r;
}

template<typename TResult, typename TInput>
__inline__ __device__ TResult slang_bit_cast(TInput val)
{
    return *(TResult*)(&val);
}

/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */


/* Type that defines the uniform entry point params. The actual content of this type is dependent on the entry point parameters, and can be
found via reflection or defined such that it matches the shader appropriately.
*/
struct UniformEntryPointParams;
struct UniformState;

// ---------------------- OptiX Ray Payload --------------------------------------
#ifdef SLANG_CUDA_ENABLE_OPTIX
struct RayDesc
{
    float3 Origin;
    float  TMin;
    float3 Direction;
    float  TMax;
};

static __forceinline__ __device__
void *unpackOptiXRayPayloadPointer(uint32_t i0, uint32_t i1)
{
    const uint64_t uptr = static_cast<uint64_t>(i0) << 32 | i1;
    void*           ptr = reinterpret_cast<void*>(uptr);
    return ptr;
}

static __forceinline__ __device__
void  packOptiXRayPayloadPointer(void* ptr, uint32_t& i0, uint32_t& i1)
{
    const uint64_t uptr = reinterpret_cast<uint64_t>(ptr);
    i0 = uptr >> 32;
    i1 = uptr & 0x00000000ffffffff;
}

static __forceinline__ __device__ void *getOptiXRayPayloadPtr()
{
    const uint32_t u0 = optixGetPayload_0();
    const uint32_t u1 = optixGetPayload_1();
    return unpackOptiXRayPayloadPointer(u0, u1);
}

template<typename T>
__forceinline__ __device__ void *traceOptiXRay(
    OptixTraversableHandle AccelerationStructure,
    uint32_t RayFlags,
    uint32_t InstanceInclusionMask,
    uint32_t RayContributionToHitGroupIndex,
    uint32_t MultiplierForGeometryContributionToHitGroupIndex,
    uint32_t MissShaderIndex,
    RayDesc Ray,
    T *Payload
) {
    uint32_t r0, r1;
    packOptiXRayPayloadPointer((void*)Payload, r0, r1);
    optixTrace(
        AccelerationStructure,
        Ray.Origin,
        Ray.Direction,
        Ray.TMin,
        Ray.TMax,
        0.f, /* Time for motion blur, currently unsupported in slang */
        InstanceInclusionMask,
        RayFlags,
        RayContributionToHitGroupIndex,
        MultiplierForGeometryContributionToHitGroupIndex,
        MissShaderIndex,
        r0, r1
    );
}
#endif


================================================
FILE: Source/External/slang/prelude/slang-hlsl-prelude.h
================================================
#ifdef SLANG_HLSL_ENABLE_NVAPI
#include "nvHLSLExtns.h"
#endif
#pragma warning(disable: 3557)


================================================
FILE: Source/External/slang/prelude/slang-llvm.h
================================================
#ifndef SLANG_LLVM_H
#define SLANG_LLVM_H

// TODO(JS): 
// Disable exception declspecs, as not supported on LLVM without some extra options.
// We could enable with `-fms-extensions`
#define SLANG_DISABLE_EXCEPTIONS 1

#ifndef SLANG_PRELUDE_ASSERT
#   ifdef SLANG_PRELUDE_ENABLE_ASSERT
extern "C" void assertFailure(const char* msg);
#       define SLANG_PRELUDE_EXPECT(VALUE, MSG) if(VALUE) {} else assertFailure("assertion failed: '" MSG "'")
#       define SLANG_PRELUDE_ASSERT(VALUE) SLANG_PRELUDE_EXPECT(VALUE, #VALUE)
#   else // SLANG_PRELUDE_ENABLE_ASSERT
#       define SLANG_PRELUDE_EXPECT(VALUE, MSG)
#       define SLANG_PRELUDE_ASSERT(x) 
#   endif // SLANG_PRELUDE_ENABLE_ASSERT
#endif

/*
Taken from stddef.h 
*/

typedef __PTRDIFF_TYPE__ ptrdiff_t;
typedef __SIZE_TYPE__ size_t;
typedef __SIZE_TYPE__ rsize_t;

//typedef __WCHAR_TYPE__ wchar_t;

#if defined(__need_NULL)
#undef NULL
#ifdef __cplusplus
#  if !defined(__MINGW32__) && !defined(_MSC_VER)
#    define NULL __null
#  else
#    define NULL 0
#  endif
#else
#  define NULL ((void*)0)
#endif
#ifdef __cplusplus
#if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED)
namespace std { typedef decltype(nullptr) nullptr_t; }
using ::std::nullptr_t;
#endif
#endif
#undef __need_NULL
#endif /* defined(__need_NULL) */


/*
The following are taken verbatim from stdint.h from Clang in LLVM. Only 8/16/32/64 types are needed. 
*/

// LLVM/Clang types such that we can use LLVM/Clang without headers for C++ output from Slang

#ifdef __INT64_TYPE__
# ifndef __int8_t_defined /* glibc sys/types.h also defines int64_t*/
typedef __INT64_TYPE__ int64_t;
# endif /* __int8_t_defined */
typedef __UINT64_TYPE__ uint64_t;
# define __int_least64_t int64_t
# define __uint_least64_t uint64_t
#endif /* __INT64_TYPE__ */

#ifdef __int_least64_t
typedef __int_least64_t int_least64_t;
typedef __uint_least64_t uint_least64_t;
typedef __int_least64_t int_fast64_t;
typedef __uint_least64_t uint_fast64_t;
#endif /* __int_least64_t */

#ifdef __INT32_TYPE__

# ifndef __int8_t_defined /* glibc sys/types.h also defines int32_t*/
typedef __INT32_TYPE__ int32_t;
# endif /* __int8_t_defined */

# ifndef __uint32_t_defined  /* more glibc compatibility */
# define __uint32_t_defined
typedef __UINT32_TYPE__ uint32_t;
# endif /* __uint32_t_defined */

# define __int_least32_t int32_t
# define __uint_least32_t uint32_t
#endif /* __INT32_TYPE__ */

#ifdef __int_least32_t
typedef __int_least32_t int_least32_t;
typedef __uint_least32_t uint_least32_t;
typedef __int_least32_t int_fast32_t;
typedef __uint_least32_t uint_fast32_t;
#endif /* __int_least32_t */

#ifdef __INT16_TYPE__
#ifndef __int8_t_defined /* glibc sys/types.h also defines int16_t*/
typedef __INT16_TYPE__ int16_t;
#endif /* __int8_t_defined */
typedef __UINT16_TYPE__ uint16_t;
# define __int_least16_t int16_t
# define __uint_least16_t uint16_t
#endif /* __INT16_TYPE__ */

#ifdef __int_least16_t
typedef __int_least16_t int_least16_t;
typedef __uint_least16_t uint_least16_t;
typedef __int_least16_t int_fast16_t;
typedef __uint_least16_t uint_fast16_t;
#endif /* __int_least16_t */

#ifdef __INT8_TYPE__
#ifndef __int8_t_defined  /* glibc sys/types.h also defines int8_t*/
typedef __INT8_TYPE__ int8_t;
#endif /* __int8_t_defined */
typedef __UINT8_TYPE__ uint8_t;
# define __int_least8_t int8_t
# define __uint_least8_t uint8_t
#endif /* __INT8_TYPE__ */

#ifdef __int_least8_t
typedef __int_least8_t int_least8_t;
typedef __uint_least8_t uint_least8_t;
typedef __int_least8_t int_fast8_t;
typedef __uint_least8_t uint_fast8_t;
#endif /* __int_least8_t */

/* prevent glibc sys/types.h from defining conflicting types */
#ifndef __int8_t_defined
# define __int8_t_defined
#endif /* __int8_t_defined */

/* C99 7.18.1.4 Integer types capable of holding object pointers.
 */
#define __stdint_join3(a,b,c) a ## b ## c

#ifndef _INTPTR_T
#ifndef __intptr_t_defined
typedef __INTPTR_TYPE__ intptr_t;
#define __intptr_t_defined
#define _INTPTR_T
#endif
#endif

#ifndef _UINTPTR_T
typedef __UINTPTR_TYPE__ uintptr_t;
#define _UINTPTR_T
#endif

/* C99 7.18.1.5 Greatest-width integer types.
 */
typedef __INTMAX_TYPE__  intmax_t;
typedef __UINTMAX_TYPE__ uintmax_t;

/* C99 7.18.4 Macros for minimum-width integer constants.
 *
 * The standard requires that integer constant macros be defined for all the
 * minimum-width types defined above. As 8-, 16-, 32-, and 64-bit minimum-width
 * types are required, the corresponding integer constant macros are defined
 * here. This implementation also defines minimum-width types for every other
 * integer width that the target implements, so corresponding macros are
 * defined below, too.
 *
 * These macros are defined using the same successive-shrinking approach as
 * the type definitions above. It is likewise important that macros are defined
 * in order of decending width.
 *
 * Note that C++ should not check __STDC_CONSTANT_MACROS here, contrary to the
 * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).
 */

#define __int_c_join(a, b) a ## b
#define __int_c(v, suffix) __int_c_join(v, suffix)
#define __uint_c(v, suffix) __int_c_join(v##U, suffix)

#ifdef __INT64_TYPE__
# ifdef __INT64_C_SUFFIX__
#  define __int64_c_suffix __INT64_C_SUFFIX__
# else
#  undef __int64_c_suffix
# endif /* __INT64_C_SUFFIX__ */
#endif /* __INT64_TYPE__ */

#ifdef __int_least64_t
# ifdef __int64_c_suffix
#  define INT64_C(v) __int_c(v, __int64_c_suffix)
#  define UINT64_C(v) __uint_c(v, __int64_c_suffix)
# else
#  define INT64_C(v) v
#  define UINT64_C(v) v ## U
# endif /* __int64_c_suffix */
#endif /* __int_least64_t */


#ifdef __INT32_TYPE__
# ifdef __INT32_C_SUFFIX__
#  define __int32_c_suffix __INT32_C_SUFFIX__
#else
#  undef __int32_c_suffix
# endif /* __INT32_C_SUFFIX__ */
#endif /* __INT32_TYPE__ */

#ifdef __int_least32_t
# ifdef __int32_c_suffix
#  define INT32_C(v) __int_c(v, __int32_c_suffix)
#  define UINT32_C(v) __uint_c(v, __int32_c_suffix)
# else
#  define INT32_C(v) v
#  define UINT32_C(v) v ## U
# endif /* __int32_c_suffix */
#endif /* __int_least32_t */

#ifdef __INT16_TYPE__
# ifdef __INT16_C_SUFFIX__
#  define __int16_c_suffix __INT16_C_SUFFIX__
#else
#  undef __int16_c_suffix
# endif /* __INT16_C_SUFFIX__ */
#endif /* __INT16_TYPE__ */

#ifdef __int_least16_t
# ifdef __int16_c_suffix
#  define INT16_C(v) __int_c(v, __int16_c_suffix)
#  define UINT16_C(v) __uint_c(v, __int16_c_suffix)
# else
#  define INT16_C(v) v
#  define UINT16_C(v) v ## U
# endif /* __int16_c_suffix */
#endif /* __int_least16_t */


#ifdef __INT8_TYPE__
# ifdef __INT8_C_SUFFIX__
#  define __int8_c_suffix __INT8_C_SUFFIX__
#else
#  undef  __int8_c_suffix
# endif /* __INT8_C_SUFFIX__ */
#endif /* __INT8_TYPE__ */

#ifdef __int_least8_t
# ifdef __int8_c_suffix
#  define INT8_C(v) __int_c(v, __int8_c_suffix)
#  define UINT8_C(v) __uint_c(v, __int8_c_suffix)
# else
#  define INT8_C(v) v
#  define UINT8_C(v) v ## U
# endif /* __int8_c_suffix */
#endif /* __int_least8_t */

/* C99 7.18.2.1 Limits of exact-width integer types.
 * C99 7.18.2.2 Limits of minimum-width integer types.
 * C99 7.18.2.3 Limits of fastest minimum-width integer types.
 *
 * The presence of limit macros are completely optional in C99.  This
 * implementation defines limits for all of the types (exact- and
 * minimum-width) that it defines above, using the limits of the minimum-width
 * type for any types that do not have exact-width representations.
 *
 * As in the type definitions, this section takes an approach of
 * successive-shrinking to determine which limits to use for the standard (8,
 * 16, 32, 64) bit widths when they don't have exact representations. It is
 * therefore important that the definitions be kept in order of decending
 * widths.
 *
 * Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the
 * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).
 */

#ifdef __INT64_TYPE__
# define INT64_MAX           INT64_C( 9223372036854775807)
# define INT64_MIN         (-INT64_C( 9223372036854775807)-1)
# define UINT64_MAX         UINT64_C(18446744073709551615)
# define __INT_LEAST64_MIN   INT64_MIN
# define __INT_LEAST64_MAX   INT64_MAX
# define __UINT_LEAST64_MAX UINT64_MAX
#endif /* __INT64_TYPE__ */

#ifdef __INT_LEAST64_MIN
# define INT_LEAST64_MIN   __INT_LEAST64_MIN
# define INT_LEAST64_MAX   __INT_LEAST64_MAX
# define UINT_LEAST64_MAX __UINT_LEAST64_MAX
# define INT_FAST64_MIN    __INT_LEAST64_MIN
# define INT_FAST64_MAX    __INT_LEAST64_MAX
# define UINT_FAST64_MAX  __UINT_LEAST64_MAX
#endif /* __INT_LEAST64_MIN */

#ifdef __INT32_TYPE__
# define INT32_MAX           INT32_C(2147483647)
# define INT32_MIN         (-INT32_C(2147483647)-1)
# define UINT32_MAX         UINT32_C(4294967295)
# define __INT_LEAST32_MIN   INT32_MIN
# define __INT_LEAST32_MAX   INT32_MAX
# define __UINT_LEAST32_MAX UINT32_MAX
#endif /* __INT32_TYPE__ */

#ifdef __INT_LEAST32_MIN
# define INT_LEAST32_MIN   __INT_LEAST32_MIN
# define INT_LEAST32_MAX   __INT_LEAST32_MAX
# define UINT_LEAST32_MAX __UINT_LEAST32_MAX
# define INT_FAST32_MIN    __INT_LEAST32_MIN
# define INT_FAST32_MAX    __INT_LEAST32_MAX
# define UINT_FAST32_MAX  __UINT_LEAST32_MAX
#endif /* __INT_LEAST32_MIN */

#ifdef __INT16_TYPE__
#define INT16_MAX            INT16_C(32767)
#define INT16_MIN          (-INT16_C(32767)-1)
#define UINT16_MAX          UINT16_C(65535)
# define __INT_LEAST16_MIN   INT16_MIN
# define __INT_LEAST16_MAX   INT16_MAX
# define __UINT_LEAST16_MAX UINT16_MAX
#endif /* __INT16_TYPE__ */

#ifdef __INT_LEAST16_MIN
# define INT_LEAST16_MIN   __INT_LEAST16_MIN
# define INT_LEAST16_MAX   __INT_LEAST16_MAX
# define UINT_LEAST16_MAX __UINT_LEAST16_MAX
# define INT_FAST16_MIN    __INT_LEAST16_MIN
# define INT_FAST16_MAX    __INT_LEAST16_MAX
# define UINT_FAST16_MAX  __UINT_LEAST16_MAX
#endif /* __INT_LEAST16_MIN */


#ifdef __INT8_TYPE__
# define INT8_MAX            INT8_C(127)
# define INT8_MIN          (-INT8_C(127)-1)
# define UINT8_MAX          UINT8_C(255)
# define __INT_LEAST8_MIN    INT8_MIN
# define __INT_LEAST8_MAX    INT8_MAX
# define __UINT_LEAST8_MAX  UINT8_MAX
#endif /* __INT8_TYPE__ */

#ifdef __INT_LEAST8_MIN
# define INT_LEAST8_MIN   __INT_LEAST8_MIN
# define INT_LEAST8_MAX   __INT_LEAST8_MAX
# define UINT_LEAST8_MAX __UINT_LEAST8_MAX
# define INT_FAST8_MIN    __INT_LEAST8_MIN
# define INT_FAST8_MAX    __INT_LEAST8_MAX
# define UINT_FAST8_MAX  __UINT_LEAST8_MAX
#endif /* __INT_LEAST8_MIN */

/* Some utility macros */
#define  __INTN_MIN(n)  __stdint_join3( INT, n, _MIN)
#define  __INTN_MAX(n)  __stdint_join3( INT, n, _MAX)
#define __UINTN_MAX(n)  __stdint_join3(UINT, n, _MAX)
#define  __INTN_C(n, v) __stdint_join3( INT, n, _C(v))
#define __UINTN_C(n, v) __stdint_join3(UINT, n, _C(v))

/* C99 7.18.2.4 Limits of integer types capable of holding object pointers. */
/* C99 7.18.3 Limits of other integer types. */

#define  INTPTR_MIN  (-__INTPTR_MAX__-1)
#define  INTPTR_MAX    __INTPTR_MAX__
#define UINTPTR_MAX   __UINTPTR_MAX__
#define PTRDIFF_MIN (-__PTRDIFF_MAX__-1)
#define PTRDIFF_MAX   __PTRDIFF_MAX__
#define    SIZE_MAX      __SIZE_MAX__

/* ISO9899:2011 7.20 (C11 Annex K): Define RSIZE_MAX if __STDC_WANT_LIB_EXT1__
 * is enabled. */
#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1
#define   RSIZE_MAX            (SIZE_MAX >> 1)
#endif

/* C99 7.18.2.5 Limits of greatest-width integer types. */
#define  INTMAX_MIN (-__INTMAX_MAX__-1)
#define  INTMAX_MAX   __INTMAX_MAX__
#define UINTMAX_MAX  __UINTMAX_MAX__

/* C99 7.18.3 Limits of other integer types. */
#define SIG_ATOMIC_MIN __INTN_MIN(__SIG_ATOMIC_WIDTH__)
#define SIG_ATOMIC_MAX __INTN_MAX(__SIG_ATOMIC_WIDTH__)
#ifdef __WINT_UNSIGNED__
# define WINT_MIN       __UINTN_C(__WINT_WIDTH__, 0)
# define WINT_MAX       __UINTN_MAX(__WINT_WIDTH__)
#else
# define WINT_MIN       __INTN_MIN(__WINT_WIDTH__)
# define WINT_MAX       __INTN_MAX(__WINT_WIDTH__)
#endif

#ifndef WCHAR_MAX
# define WCHAR_MAX __WCHAR_MAX__
#endif
#ifndef WCHAR_MIN
# if __WCHAR_MAX__ == __INTN_MAX(__WCHAR_WIDTH__)
#  define WCHAR_MIN __INTN_MIN(__WCHAR_WIDTH__)
# else
#  define WCHAR_MIN __UINTN_C(__WCHAR_WIDTH__, 0)
# endif
#endif

/* 7.18.4.2 Macros for greatest-width integer constants. */
#define  INTMAX_C(v) __int_c(v,  __INTMAX_C_SUFFIX__)
#define UINTMAX_C(v) __int_c(v, __UINTMAX_C_SUFFIX__)


#endif // SLANG_LLVM_H




================================================
FILE: Source/External/slang/slang-com-helper.h
================================================
#ifndef SLANG_COM_HELPER_H
#define SLANG_COM_HELPER_H

/** \file slang-com-helper.h
*/

#include "slang.h"
#include <atomic>

/* !!!!!!!!!!!!!!!!!!!!! Macros to help checking SlangResult !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/

/*! Set SLANG_HANDLE_RESULT_FAIL(x) to code to be executed whenever an error occurs, and is detected by one of the macros */
#ifndef SLANG_HANDLE_RESULT_FAIL
#	define SLANG_HANDLE_RESULT_FAIL(x)
#endif

//! Helper macro, that makes it easy to add result checking to calls in functions/methods that themselves return Result. 
#define SLANG_RETURN_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return _res; } }
//! Helper macro that can be used to test the return value from a call, and will return in a void method/function
#define SLANG_RETURN_VOID_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return; } }
//! Helper macro that will return false on failure.
#define SLANG_RETURN_FALSE_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return false; } }
//! Helper macro that will return nullptr on failure.
#define SLANG_RETURN_NULL_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return nullptr; } }

//! Helper macro that will assert if the return code from a call is failure, also returns the failure.
#define SLANG_ASSERT_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { assert(false); return _res; } }
//! Helper macro that will assert if the result from a call is a failure, also returns. 
#define SLANG_ASSERT_VOID_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { assert(false); return; } }

/* !!!!!!!!!!!!!!!!!!!!!!! C++ helpers !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/

#if defined(__cplusplus)
namespace Slang {

// Alias SlangResult to Slang::Result
typedef SlangResult Result;
// Alias SlangUUID to Slang::Guid
typedef SlangUUID Guid;

} // namespace Slang

// Operator == and != for Guid/SlangUUID

SLANG_FORCE_INLINE bool operator==(const Slang::Guid& aIn, const Slang::Guid& bIn)
{
    using namespace Slang;
    // Use the largest type the honors the alignment of Guid
    typedef uint32_t CmpType;
    union GuidCompare
    {
        Guid guid;
        CmpType data[sizeof(Guid) / sizeof(CmpType)];
    };
    // Type pun - so compiler can 'see' the pun and not break aliasing rules
    const CmpType* a = reinterpret_cast<const GuidCompare&>(aIn).data;
    const CmpType* b = reinterpret_cast<const GuidCompare&>(bIn).data;
    // Make the guid comparison a single branch, by not using short circuit
    return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2]) | (a[3] ^ b[3])) == 0;
}

SLANG_FORCE_INLINE bool operator!=(const Slang::Guid& a, const Slang::Guid& b)
{
    return !(a == b);
}

/* !!!!!!!! Macros to simplify implementing COM interfaces !!!!!!!!!!!!!!!!!!!!!!!!!!!! */

/* Assumes underlying implementation has a member m_refCount that is initialized to 0 and can have ++ and -- operate on it. 
For SLANG_IUNKNOWN_QUERY_INTERFACE to work - must have a method 'getInterface' that returns valid pointers for the Guid, or nullptr 
if not found. */

#define SLANG_IUNKNOWN_QUERY_INTERFACE \
SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) SLANG_OVERRIDE \
{ \
    ISlangUnknown* intf = getInterface(uuid); \
    if (intf) \
    { \
        addRef(); \
        *outObject = intf; \
        return SLANG_OK;\
    } \
    return SLANG_E_NO_INTERFACE;\
}

#define SLANG_IUNKNOWN_ADD_REF \
SLANG_NO_THROW uint32_t SLANG_MCALL addRef() \
{ \
    return ++m_refCount; \
}

#define SLANG_IUNKNOWN_RELEASE \
SLANG_NO_THROW uint32_t SLANG_MCALL release() \
{ \
    --m_refCount; \
    if (m_refCount == 0) \
    { \
        delete this; \
        return 0; \
    } \
    return m_refCount; \
} 

#define SLANG_IUNKNOWN_ALL \
    SLANG_IUNKNOWN_QUERY_INTERFACE \
    SLANG_IUNKNOWN_ADD_REF \
    SLANG_IUNKNOWN_RELEASE 

// ------------------------ RefObject IUnknown -----------------------------

#define SLANG_REF_OBJECT_IUNKNOWN_QUERY_INTERFACE \
SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) SLANG_OVERRIDE \
{ \
    void* intf = getInterface(uuid); \
    if (intf) \
    { \
        addReference(); \
        *outObject = intf; \
        return SLANG_OK;\
    } \
    return SLANG_E_NO_INTERFACE;\
}

#define SLANG_REF_OBJECT_IUNKNOWN_ADD_REF SLANG_NO_THROW uint32_t SLANG_MCALL addRef() SLANG_OVERRIDE { return (uint32_t)addReference(); }
#define SLANG_REF_OBJECT_IUNKNOWN_RELEASE SLANG_NO_THROW uint32_t SLANG_MCALL release() SLANG_OVERRIDE { return (uint32_t)releaseReference(); }

#    define SLANG_REF_OBJECT_IUNKNOWN_ALL         \
        SLANG_REF_OBJECT_IUNKNOWN_QUERY_INTERFACE \
        SLANG_REF_OBJECT_IUNKNOWN_ADD_REF         \
        SLANG_REF_OBJECT_IUNKNOWN_RELEASE

#endif // defined(__cplusplus)

#endif


================================================
FILE: Source/External/slang/slang-com-ptr.h
================================================
#ifndef SLANG_COM_PTR_H
#define SLANG_COM_PTR_H

#include "slang-com-helper.h"

#include <assert.h>
#include <cstddef>

namespace Slang {

/*! \brief ComPtr is a simple smart pointer that manages types which implement COM based interfaces.
\details A class that implements a COM, must derive from the IUnknown interface or a type that matches
it's layout exactly (such as ISlangUnknown). Trying to use this template with a class that doesn't follow
these rules, will lead to undefined behavior.
This is a 'strong' pointer type, and will AddRef when a non null pointer is set and Release when the pointer
leaves scope.
Using 'detach' allows a pointer to be removed from the management of the ComPtr.
To set the smart pointer to null, there is the method setNull, or alternatively just assign SLANG_NULL/nullptr.

One edge case using the template is that sometimes you want access as a pointer to a pointer. Sometimes this
is to write into the smart pointer, other times to pass as an array. To handle these different behaviors
there are the methods readRef and writeRef, which are used instead of the & (ref) operator. For example

\code
Void doSomething(ID3D12Resource** resources, IndexT numResources);
// ...
ComPtr<ID3D12Resource> resources[3];
doSomething(resources[0].readRef(), SLANG_COUNT_OF(resource));
\endcode

A more common scenario writing to the pointer

\code
IUnknown* unk = ...;

ComPtr<ID3D12Resource> resource;
Result res = unk->QueryInterface(resource.writeRef());
\endcode
*/

// Enum to force initializing as an attach (without adding a reference)
enum InitAttach
{
    INIT_ATTACH
};

template <class T>
class ComPtr
{
public:
	typedef T Type;
	typedef ComPtr ThisType;
	typedef ISlangUnknown* Ptr;

		/// Constructors
		/// Default Ctor. Sets to nullptr
	SLANG_FORCE_INLINE ComPtr() :m_ptr(nullptr) {}
    SLANG_FORCE_INLINE ComPtr(std::nullptr_t) : m_ptr(nullptr) {}
		/// Sets, and ref counts.
	SLANG_FORCE_INLINE explicit ComPtr(T* ptr) :m_ptr(ptr) { if (ptr) ((Ptr)ptr)->addRef(); }
		/// The copy ctor
	SLANG_FORCE_INLINE ComPtr(const ThisType& rhs) : m_ptr(rhs.m_ptr) { if (m_ptr) ((Ptr)m_ptr)->addRef(); }

        /// Ctor without adding to ref count.
    SLANG_FORCE_INLINE explicit ComPtr(InitAttach, T* ptr) :m_ptr(ptr) { }
        /// Ctor without adding to ref count
    SLANG_FORCE_INLINE ComPtr(InitAttach, const ThisType& rhs) : m_ptr(rhs.m_ptr) { }

#ifdef SLANG_HAS_MOVE_SEMANTICS
		/// Move Ctor
	SLANG_FORCE_INLINE ComPtr(ThisType&& rhs) : m_ptr(rhs.m_ptr) { rhs.m_ptr = nullptr; }
		/// Move assign
	SLANG_FORCE_INLINE ComPtr& operator=(ThisType&& rhs) { T* swap = m_ptr; m_ptr = rhs.m_ptr; rhs.m_ptr = swap; return *this; }
#endif

	/// Destructor releases the pointer, assuming it is set
	SLANG_FORCE_INLINE ~ComPtr() { if (m_ptr) ((Ptr)m_ptr)->release(); }

	// !!! Operators !!!

	  /// Returns the dumb pointer
	SLANG_FORCE_INLINE operator T *() const { return m_ptr; }

	SLANG_FORCE_INLINE T& operator*() { return *m_ptr; }
		/// For making method invocations through the smart pointer work through the dumb pointer
	SLANG_FORCE_INLINE T* operator->() const { return m_ptr; }

		/// Assign
	SLANG_FORCE_INLINE const ThisType &operator=(const ThisType& rhs);
		/// Assign from dumb ptr
	SLANG_FORCE_INLINE T* operator=(T* in);

		/// Get the pointer and don't ref
	SLANG_FORCE_INLINE T* get() const { return m_ptr; }
		/// Release a contained nullptr pointer if set
	SLANG_FORCE_INLINE void setNull();

		/// Detach
	SLANG_FORCE_INLINE T* detach() { T* ptr = m_ptr; m_ptr = nullptr; return ptr; }
		/// Set to a pointer without changing the ref count
	SLANG_FORCE_INLINE void attach(T* in) { m_ptr = in; }

		/// Get ready for writing (nulls contents)
	SLANG_FORCE_INLINE T** writeRef() { setNull(); return &m_ptr; }
		/// Get for read access
	SLANG_FORCE_INLINE T*const* readRef() const { return &m_ptr; }

		/// Swap
	void swap(ThisType& rhs);

protected:
	/// Gets the address of the dumb pointer.
    // Disabled: use writeRef and readRef to get a reference based on usage.
#ifndef SLANG_COM_PTR_ENABLE_REF_OPERATOR
	SLANG_FORCE_INLINE T** operator&() = delete;
#endif

	T* m_ptr;
};

//----------------------------------------------------------------------------
template <typename T>
void ComPtr<T>::setNull()
{
	if (m_ptr)
	{
		((Ptr)m_ptr)->release();
		m_ptr = nullptr;
	}
}
//----------------------------------------------------------------------------
template <typename T>
const ComPtr<T>& ComPtr<T>::operator=(const ThisType& rhs)
{
	if (rhs.m_ptr) ((Ptr)rhs.m_ptr)->addRef();
	if (m_ptr) ((Ptr)m_ptr)->release();
	m_ptr = rhs.m_ptr;
	return *this;
}
//----------------------------------------------------------------------------
template <typename T>
T* ComPtr<T>::operator=(T* ptr)
{
	if (ptr) ((Ptr)ptr)->addRef();
	if (m_ptr) ((Ptr)m_ptr)->release();
	m_ptr = ptr;
	return m_ptr;
}
//----------------------------------------------------------------------------
template <typename T>
void ComPtr<T>::swap(ThisType& rhs)
{
	T* tmp = m_ptr;
	m_ptr = rhs.m_ptr;
	rhs.m_ptr = tmp;
}

} // namespace Slang

#endif // SLANG_COM_PTR_H


================================================
FILE: Source/External/slang/slang-gfx.h
================================================
// render.h
#pragma once

#include <float.h>
#include <assert.h>

#include "slang.h"
#include "slang-com-ptr.h"


#if defined(SLANG_GFX_DYNAMIC)
#    if defined(_MSC_VER)
#        ifdef SLANG_GFX_DYNAMIC_EXPORT
#            define SLANG_GFX_API SLANG_DLL_EXPORT
#        else
#            define SLANG_GFX_API __declspec(dllimport)
#        endif
#    else
// TODO: need to consider compiler capabilities
//#     ifdef SLANG_DYNAMIC_EXPORT
#        define SLANG_GFX_API SLANG_DLL_EXPORT
//#     endif
#    endif
#endif

#ifndef SLANG_GFX_API
#    define SLANG_GFX_API
#endif

// Needed for building on cygwin with gcc
#undef Always
#undef None

// GLOBAL TODO: doc comments
// GLOBAL TODO: Rationalize integer types (not a smush of uint/int/Uint/Int/etc)
//    - need typedefs in gfx namespace for Count, Index, Size, Offset (ex. DeviceAddress)
//    - Index and Count are for arrays, and indexing into array - like things(XY coordinates of pixels, etc.)
//         - Count is also for anything where we need to measure how many of something there are. This includes things like extents.
//    - Offset and Size are almost always for bytes and things measured in bytes.
namespace gfx {

using Slang::ComPtr;

typedef SlangResult Result;

// Had to move here, because Options needs types defined here
typedef SlangInt Int;
typedef SlangUInt UInt;
typedef uint64_t DeviceAddress;
typedef int GfxIndex;
typedef int GfxCount;
typedef size_t Size;
typedef size_t Offset;

const uint64_t kTimeoutInfinite = 0xFFFFFFFFFFFFFFFF;

enum class StructType
{
    D3D12DeviceExtendedDesc, D3D12ExperimentalFeaturesDesc
};

// TODO: Rename to Stage
enum class StageType
{
    Unknown,
    Vertex,
    Hull,
    Domain,
    Geometry,
    Fragment,
    Compute,
    RayGeneration,
    Intersection,
    AnyHit,
    ClosestHit,
    Miss,
    Callable,
    Amplification,
    Mesh,
    CountOf,
};

// TODO: Implementation or backend or something else?
enum class DeviceType
{
    Unknown,
    Default,
    DirectX11,
    DirectX12,
    OpenGl,
    Vulkan,
    CPU,
    CUDA,
    CountOf,
};

// TODO: Why does this exist it should go poof
enum class ProjectionStyle
{
    Unknown,
    OpenGl,
    DirectX,
    Vulkan,
    CountOf,
};

// TODO: This should also go poof
/// The style of the binding
enum class BindingStyle
{
    Unknown,
    DirectX,
    OpenGl,
    Vulkan,
    CPU,
    CUDA,
    CountOf,
};

// TODO: Is this actually a flag when there are no bit fields?
enum class AccessFlag
{
    None,
    Read,
    Write,
};

// TODO: Needed? Shouldn't be hard-coded if so
const GfxCount kMaxRenderTargetCount = 8;

class ITransientResourceHeap;

enum class ShaderModuleSourceType
{
    SlangSource, // a slang source string in memory.
    SlangModuleBinary, // a slang module binary code in memory.
    SlangSourceFile, // a slang source from file.
    SlangModuleBinaryFile, // a slang module binary code from file.
};

class IShaderProgram: public ISlangUnknown
{
public:
    // Defines how linking should be performed for a shader program.
    enum class LinkingStyle
    {
        // Compose all entry-points in a single program, then compile all entry-points together with the same
        // set of root shader arguments.
        SingleProgram,

        // Link and compile each entry-point individually, potentially with different specializations.
        SeparateEntryPointCompilation
    };

    struct Desc
    {
        // TODO: Tess doesn't like this but doesn't know what to do about it
        // The linking style of this program.
        LinkingStyle linkingStyle = LinkingStyle::SingleProgram;

        // The global scope or a Slang composite component that represents the entire program.
        slang::IComponentType*  slangGlobalScope;

        // Number of separate entry point components in the `slangEntryPoints` array to link in.
        // If set to 0, then `slangGlobalScope` must contain Slang EntryPoint components.
        // If not 0, then `slangGlobalScope` must not contain any EntryPoint components.
        GfxCount entryPointCount = 0;

        // An array of Slang entry points. The size of the array must be `entryPointCount`.
        // Each element must define only 1 Slang EntryPoint.
        slang::IComponentType** slangEntryPoints = nullptr;
    };

    struct CreateDesc2
    {
        ShaderModuleSourceType sourceType;
        void* sourceData;
        Size sourceDataSize;

        // Number of entry points to include in the shader program. 0 means include all entry points
        // defined in the module.
        GfxCount entryPointCount = 0;
        // Names of entry points to include in the shader program. The size of the array must be
        // `entryPointCount`.
        const char** entryPointNames = nullptr;
    };

    virtual SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL findTypeByName(const char* name) = 0;
};
#define SLANG_UUID_IShaderProgram                                                       \
    {                                                                                  \
        0x9d32d0ad, 0x915c, 0x4ffd, { 0x91, 0xe2, 0x50, 0x85, 0x54, 0xa0, 0x4a, 0x76 } \
    }

// TODO: Confirm with Yong that we really want this naming convention
// TODO: Rename to what?
// Dont' change without keeping in sync with Format
#define GFX_FORMAT(x) \
    x( Unknown, 0, 0) \
    \
    x(R32G32B32A32_TYPELESS, 16, 1) \
    x(R32G32B32_TYPELESS, 12, 1) \
    x(R32G32_TYPELESS, 8, 1) \
    x(R32_TYPELESS, 4, 1) \
    \
    x(R16G16B16A16_TYPELESS, 8, 1) \
    x(R16G16_TYPELESS, 4, 1) \
    x(R16_TYPELESS, 2, 1) \
    \
    x(R8G8B8A8_TYPELESS, 4, 1) \
    x(R8G8_TYPELESS, 2, 1) \
    x(R8_TYPELESS, 1, 1) \
    x(B8G8R8A8_TYPELESS, 4, 1) \
    \
    x(R32G32B32A32_FLOAT, 16, 1) \
    x(R32G32B32_FLOAT, 12, 1) \
    x(R32G32_FLOAT, 8, 1) \
    x(R32_FLOAT, 4, 1) \
    \
    x(R16G16B16A16_FLOAT, 8, 1) \
    x(R16G16_FLOAT, 4, 1) \
    x(R16_FLOAT, 2, 1) \
    \
    x(R32G32B32A32_UINT, 16, 1) \
    x(R32G32B32_UINT, 12, 1) \
    x(R32G32_UINT, 8, 1) \
    x(R32_UINT, 4, 1) \
    \
    x(R16G16B16A16_UINT, 8, 1) \
    x(R16G16_UINT, 4, 1) \
    x(R16_UINT, 2, 1) \
    \
    x(R8G8B8A8_UINT, 4, 1) \
    x(R8G8_UINT, 2, 1) \
    x(R8_UINT, 1, 1) \
    \
    x(R32G32B32A32_SINT, 16, 1) \
    x(R32G32B32_SINT, 12, 1) \
    x(R32G32_SINT, 8, 1) \
    x(R32_SINT, 4, 1) \
    \
    x(R16G16B16A16_SINT, 8, 1) \
    x(R16G16_SINT, 4, 1) \
    x(R16_SINT, 2, 1) \
    \
    x(R8G8B8A8_SINT, 4, 1) \
    x(R8G8_SINT, 2, 1) \
    x(R8_SINT, 1, 1) \
    \
    x(R16G16B16A16_UNORM, 8, 1) \
    x(R16G16_UNORM, 4, 1) \
    x(R16_UNORM, 2, 1) \
    \
    x(R8G8B8A8_UNORM, 4, 1) \
    x(R8G8B8A8_UNORM_SRGB, 4, 1) \
    x(R8G8_UNORM, 2, 1) \
    x(R8_UNORM, 1, 1) \
    x(B8G8R8A8_UNORM, 4, 1) \
    x(B8G8R8A8_UNORM_SRGB, 4, 1) \
    x(B8G8R8X8_UNORM, 4, 1) \
    x(B8G8R8X8_UNORM_SRGB, 4, 1) \
    \
    x(R16G16B16A16_SNORM, 8, 1) \
    x(R16G16_SNORM, 4, 1) \
    x(R16_SNORM, 2, 1) \
    \
    x(R8G8B8A8_SNORM, 4, 1) \
    x(R8G8_SNORM, 2, 1) \
    x(R8_SNORM, 1, 1) \
    \
    x(D32_FLOAT, 4, 1) \
    x(D16_UNORM, 2, 1) \
    \
    x(B4G4R4A4_UNORM, 2, 1) \
    x(B5G6R5_UNORM, 2, 1) \
    x(B5G5R5A1_UNORM, 2, 1) \
    \
    x(R9G9B9E5_SHAREDEXP, 4, 1) \
    x(R10G10B10A2_TYPELESS, 4, 1) \
    x(R10G10B10A2_UNORM, 4, 1) \
    x(R10G10B10A2_UINT, 4, 1) \
    x(R11G11B10_FLOAT, 4, 1) \
    \
    x(BC1_UNORM, 8, 16) \
    x(BC1_UNORM_SRGB, 8, 16) \
    x(BC2_UNORM, 16, 16) \
    x(BC2_UNORM_SRGB, 16, 16) \
    x(BC3_UNORM, 16, 16) \
    x(BC3_UNORM_SRGB, 16, 16) \
    x(BC4_UNORM, 8, 16) \
    x(BC4_SNORM, 8, 16) \
    x(BC5_UNORM, 16, 16) \
    x(BC5_SNORM, 16, 16) \
    x(BC6H_UF16, 16, 16) \
    x(BC6H_SF16, 16, 16) \
    x(BC7_UNORM, 16, 16) \
    x(BC7_UNORM_SRGB, 16, 16)

// TODO: This should be generated from above
// TODO: enum class should be explicitly uint32_t or whatever's appropriate
/// Different formats of things like pixels or elements of vertices
/// NOTE! Any change to this type (adding, removing, changing order) - must also be reflected in changes GFX_FORMAT
enum class Format
{
    // D3D formats omitted: 19-22, 44-47, 65-66, 68-70, 73, 76, 79, 82, 88-89, 92-94, 97, 100-114
    // These formats are omitted due to lack of a corresponding Vulkan format. D24_UNORM_S8_UINT (DXGI_FORMAT 45)
    // has a matching Vulkan format but is also omitted as it is only supported by Nvidia.
    Unknown,

    R32G32B32A32_TYPELESS,
    R32G32B32_TYPELESS,
    R32G32_TYPELESS,
    R32_TYPELESS,

    R16G16B16A16_TYPELESS,
    R16G16_TYPELESS,
    R16_TYPELESS,

    R8G8B8A8_TYPELESS,
    R8G8_TYPELESS,
    R8_TYPELESS,
    B8G8R8A8_TYPELESS,

    R32G32B32A32_FLOAT,
    R32G32B32_FLOAT,
    R32G32_FLOAT,
    R32_FLOAT,

    R16G16B16A16_FLOAT,
    R16G16_FLOAT,
    R16_FLOAT,

    R32G32B32A32_UINT,
    R32G32B32_UINT,
    R32G32_UINT,
    R32_UINT,

    R16G16B16A16_UINT,
    R16G16_UINT,
    R16_UINT,

    R8G8B8A8_UINT,
    R8G8_UINT,
    R8_UINT,

    R32G32B32A32_SINT,
    R32G32B32_SINT,
    R32G32_SINT,
    R32_SINT,

    R16G16B16A16_SINT,
    R16G16_SINT,
    R16_SINT,

    R8G8B8A8_SINT,
    R8G8_SINT,
    R8_SINT,

    R16G16B16A16_UNORM,
    R16G16_UNORM,
    R16_UNORM,

    R8G8B8A8_UNORM,
    R8G8B8A8_UNORM_SRGB,
    R8G8_UNORM,
    R8_UNORM,
    B8G8R8A8_UNORM,
    B8G8R8A8_UNORM_SRGB,
    B8G8R8X8_UNORM,
    B8G8R8X8_UNORM_SRGB,

    R16G16B16A16_SNORM,
    R16G16_SNORM,
    R16_SNORM,

    R8G8B8A8_SNORM,
    R8G8_SNORM,
    R8_SNORM,

    D32_FLOAT,
    D16_UNORM,

    B4G4R4A4_UNORM,
    B5G6R5_UNORM,
    B5G5R5A1_UNORM,

    R9G9B9E5_SHAREDEXP,
    R10G10B10A2_TYPELESS,
    R10G10B10A2_UNORM,
    R10G10B10A2_UINT,
    R11G11B10_FLOAT,

    BC1_UNORM,
    BC1_UNORM_SRGB,
    BC2_UNORM,
    BC2_UNORM_SRGB,
    BC3_UNORM,
    BC3_UNORM_SRGB,
    BC4_UNORM,
    BC4_SNORM,
    BC5_UNORM,
    BC5_SNORM,
    BC6H_UF16,
    BC6H_SF16,
    BC7_UNORM,
    BC7_UNORM_SRGB,

    _Count,
};

// TODO: Aspect = Color, Depth, Stencil, etc.
// TODO: Channel = R, G, B, A, D, S, etc.
// TODO: Pick : pixel or texel
// TODO: Block is a good term for what it is
// TODO: Width/Height/Depth/whatever should not be used. We should use extentX, extentY, etc.
struct FormatInfo
{
    GfxCount channelCount;         ///< The amount of channels in the format. Only set if the channelType is set
    uint8_t channelType;           ///< One of SlangScalarType None if type isn't made up of elements of type. TODO: Change to uint32_t?

    Size blockSizeInBytes;         ///< The size of a block in bytes.
    GfxCount pixelsPerBlock;       ///< The number of pixels contained in a block.
    GfxCount blockWidth;           ///< The width of a block in pixels.
    GfxCount blockHeight;          ///< The height of a block in pixels.
};

enum class InputSlotClass
{
    PerVertex, PerInstance
};

struct InputElementDesc
{
    char const* semanticName;      ///< The name of the corresponding parameter in shader code.
    GfxIndex semanticIndex;        ///< The index of the corresponding parameter in shader code. Only needed if multiple parameters share a semantic name.
    Format format;                 ///< The format of the data being fetched for this element.
    Offset offset;                 ///< The offset in bytes of this element from the start of the corresponding chunk of vertex stream data.
    GfxIndex bufferSlotIndex;      ///< The index of the vertex stream to fetch this element's data from.
};

struct VertexStreamDesc
{
    Size stride;                   ///< The stride in bytes for this vertex stream.
    InputSlotClass slotClass;      ///< Whether the stream contains per-vertex or per-instance data.
    GfxCount instanceDataStepRate; ///< How many instances to draw per chunk of data.
};

enum class PrimitiveType
{
    Point, Line, Triangle, Patch
};

enum class PrimitiveTopology
{
    TriangleList, TriangleStrip, PointList, LineList, LineStrip
};

enum class ResourceState
{
    Undefined,
    General,
    PreInitialized,
    VertexBuffer,
    IndexBuffer,
    ConstantBuffer,
    StreamOutput,
    ShaderResource,
    UnorderedAccess,
    RenderTarget,
    DepthRead,
    DepthWrite,
    Present,
    IndirectArgument,
    CopySource,
    CopyDestination,
    ResolveSource,
    ResolveDestination,
    AccelerationStructure,
    AccelerationStructureBuildInput,
    PixelShaderResource,
    NonPixelShaderResource,
    _Count
};

struct ResourceStateSet
{
public:
    void add(ResourceState state) { m_bitFields |= (1LL << (uint32_t)state); }
    template <typename... TResourceState> void add(ResourceState s, TResourceState... states)
    {
        add(s);
        add(states...);
    }
    bool contains(ResourceState state) const { return (m_bitFields & (1LL << (uint32_t)state)) != 0; }
    ResourceStateSet()
        : m_bitFields(0)
    {}
    ResourceStateSet(const ResourceStateSet& other) = default;
    ResourceStateSet(ResourceState state) { add(state); }
    template <typename... TResourceState> ResourceStateSet(TResourceState... states)
    {
        add(states...);
    }

    ResourceStateSet operator&(const ResourceStateSet& that) const
    {
        ResourceStateSet result;
        result.m_bitFields = this->m_bitFields & that.m_bitFields;
        return result;
    }

private:
    uint64_t m_bitFields = 0;
    void add() {}
};


/// Describes how memory for the resource should be allocated for CPU access.
enum class MemoryType
{
    DeviceLocal,
    Upload,
    ReadBack,
};

enum class InteropHandleAPI
{
    Unknown,
    D3D12, // A D3D12 object pointer.
    Vulkan, // A general Vulkan object handle.
    CUDA, // A general CUDA object handle.
    Win32, // A general Win32 HANDLE.
    FileDescriptor, // A file descriptor.
    DeviceAddress, // A device address.
    D3D12CpuDescriptorHandle, // A D3D12_CPU_DESCRIPTOR_HANDLE value.
};

struct InteropHandle
{
    InteropHandleAPI api = InteropHandleAPI::Unknown;
    uint64_t handleValue = 0;
};

// Declare opaque type
class IInputLayout : public ISlangUnknown
{
public:
    struct Desc
    {
        InputElementDesc const* inputElements = nullptr;
        GfxCount inputElementCount = 0;
        VertexStreamDesc const* vertexStreams = nullptr;
        GfxCount vertexStreamCount = 0;
    };
};
#define SLANG_UUID_IInputLayout                                                         \
    {                                                                                  \
        0x45223711, 0xa84b, 0x455c, { 0xbe, 0xfa, 0x49, 0x37, 0x42, 0x1e, 0x8e, 0x2e } \
    }

class IResource: public ISlangUnknown
{
public:
        /// The type of resource.
        /// NOTE! The order needs to be such that all texture types are at or after Texture1D (otherwise isTexture won't work correctly)
    enum class Type
    {
        Unknown,            ///< Unknown
        Buffer,             ///< A buffer (like a constant/index/vertex buffer)
        Texture1D,          ///< A 1d texture
        Texture2D,          ///< A 2d texture
        Texture3D,          ///< A 3d texture
        TextureCube,        ///< A cubemap consists of 6 Texture2D like faces
        _Count,
    };

        /// Base class for Descs
    struct DescBase
    {
        Type type = Type::Unknown;
        ResourceState defaultState = ResourceState::Undefined;
        ResourceStateSet allowedStates = ResourceStateSet();
        MemoryType memoryType = MemoryType::DeviceLocal;
        InteropHandle existingHandle = {};
        bool isShared = false;
    };

    virtual SLANG_NO_THROW Type SLANG_MCALL getType() = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeResourceHandle(InteropHandle* outHandle) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL setDebugName(const char* name) = 0;
    virtual SLANG_NO_THROW const char* SLANG_MCALL getDebugName() = 0;

};
#define SLANG_UUID_IResource                                                           \
    {                                                                                  \
        0xa0e39f34, 0x8398, 0x4522, { 0x95, 0xc2, 0xeb, 0xc0, 0xf9, 0x84, 0xef, 0x3f } \
    }

struct MemoryRange
{
    // TODO: Change to Offset/Size?
    uint64_t offset;
    uint64_t size;
};

class IBufferResource: public IResource
{
public:
    struct Desc: public DescBase
    {
        Size sizeInBytes = 0;        ///< Total size in bytes
        Size elementSize = 0;        ///< Get the element stride. If > 0, this is a structured buffer
        Format format = Format::Unknown;
    };

    virtual SLANG_NO_THROW Desc* SLANG_MCALL getDesc() = 0;
    virtual SLANG_NO_THROW DeviceAddress SLANG_MCALL getDeviceAddress() = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL map(MemoryRange* rangeToRead, void** outPointer) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL unmap(MemoryRange* writtenRange) = 0;
};
#define SLANG_UUID_IBufferResource                                                     \
    {                                                                                  \
        0x1b274efe, 0x5e37, 0x492b, { 0x82, 0x6e, 0x7e, 0xe7, 0xe8, 0xf5, 0xa4, 0x9b } \
    }

struct DepthStencilClearValue
{
    float depth = 1.0f;
    uint32_t stencil = 0;
};
union ColorClearValue
{
    float floatValues[4];
    uint32_t uintValues[4];
};
struct ClearValue
{
    ColorClearValue color = {{0.0f, 0.0f, 0.0f, 0.0f}};
    DepthStencilClearValue depthStencil;
};

struct BufferRange
{
    // TODO: Change to Index and Count?
    uint64_t firstElement;
    uint64_t elementCount;
};

enum class TextureAspect : uint32_t
{
    Default = 0,
    Color = 0x00000001,
    Depth = 0x00000002,
    Stencil = 0x00000004,
    MetaData = 0x00000008,
    Plane0 = 0x00000010,
    Plane1 = 0x00000020,
    Plane2 = 0x00000040,

    DepthStencil = Depth | Stencil,
};

struct SubresourceRange
{
    TextureAspect aspectMask;
    GfxIndex mipLevel;
    GfxCount mipLevelCount;
    GfxIndex baseArrayLayer; // For Texture3D, this is WSlice.
    GfxCount layerCount; // For cube maps, this is a multiple of 6.
};

class ITextureResource: public IResource
{
public:
    static const Size kRemainingTextureSize = 0xFFFFFFFF;
    struct Offset3D
    {
        GfxIndex x = 0;
        GfxIndex y = 0;
        GfxIndex z = 0;
        Offset3D() = default;
        Offset3D(GfxIndex _x, GfxIndex _y, GfxIndex _z) :x(_x), y(_y), z(_z) {}
    };

    struct SampleDesc
    {
        GfxCount numSamples = 1;                ///< Number of samples per pixel
        int quality = 0;                        ///< The quality measure for the samples
    };

    struct Extents
    {
        GfxCount width = 0;              ///< Width in pixels
        GfxCount height = 0;             ///< Height in pixels (if 2d or 3d)
        GfxCount depth = 0;              ///< Depth (if 3d)
    };

    struct Desc: public DescBase
    {
        Extents size;

        GfxCount arraySize = 0;          ///< Array size

        GfxCount numMipLevels = 0;       ///< Number of mip levels - if 0 will create all mip levels
        Format format;                   ///< The resources format
        SampleDesc sampleDesc;           ///< How the resource is sampled
        ClearValue* optimalClearValue = nullptr;
    };

        /// Data for a single subresource of a texture.
        ///
        /// Each subresource is a tensor with `1 <= rank <= 3`,
        /// where the rank is deterined by the base shape of the
        /// texture (Buffer, 1D, 2D, 3D, or Cube). For the common
        /// case of a 2D texture, `rank == 2` and each subresource
        /// is a 2D image.
        ///
        /// Subresource tensors must be stored in a row-major layout,
        /// so that the X axis strides over texels, the Y axis strides
        /// over 1D rows of texels, and the Z axis strides over 2D
        /// "layers" of texels.
        ///
        /// For a texture with multiple mip levels or array elements,
        /// each mip level and array element is stores as a distinct
        /// subresource. When indexing into an array of subresources,
        /// the index of a subresoruce for mip level `m` and array
        /// index `a` is `m + a*mipLevelCount`.
        ///
    struct SubresourceData
    {
            /// Pointer to texel data for the subresource tensor.
        void const* data;

            /// Stride in bytes between rows of the subresource tensor.
            ///
            /// This is the number of bytes to add to a pointer to a texel
            /// at (X,Y,Z) to get to a texel at (X,Y+1,Z).
            ///
            /// Devices may not support all possible values for `strideY`.
            /// In particular, they may only support strictly positive strides.
            ///
        gfx::Size strideY;

            /// Stride in bytes between layers of the subresource tensor.
            ///
            /// This is the number of bytes to add to a pointer to a texel
            /// at (X,Y,Z) to get to a texel at (X,Y,Z+1).
            ///
            /// Devices may not support all possible values for `strideZ`.
            /// In particular, they may only support strictly positive strides.
            ///
        gfx::Size strideZ;
    };

    virtual SLANG_NO_THROW Desc* SLANG_MCALL getDesc() = 0;
};
#define SLANG_UUID_ITextureResource                                                    \
    {                                                                                  \
        0xcf88a31c, 0x6187, 0x46c5, { 0xa4, 0xb7, 0xeb, 0x58, 0xc7, 0x33, 0x40, 0x17 } \
    }


enum class ComparisonFunc : uint8_t
{
    Never           = 0x0,
    Less            = 0x1,
    Equal           = 0x2,
    LessEqual       = 0x3,
    Greater         = 0x4,
    NotEqual        = 0x5,
    GreaterEqual    = 0x6,
    Always          = 0x7,
};

enum class TextureFilteringMode
{
    Point,
    Linear,
};

enum class TextureAddressingMode
{
    Wrap,
    ClampToEdge,
    ClampToBorder,
    MirrorRepeat,
    MirrorOnce,
};

enum class TextureReductionOp
{
    Average,
    Comparison,
    Minimum,
    Maximum,
};

class ISamplerState : public ISlangUnknown
{
public:
    struct Desc
    {
        TextureFilteringMode    minFilter       = TextureFilteringMode::Linear;
        TextureFilteringMode    magFilter       = TextureFilteringMode::Linear;
        TextureFilteringMode    mipFilter       = TextureFilteringMode::Linear;
        TextureReductionOp      reductionOp     = TextureReductionOp::Average;
        TextureAddressingMode   addressU        = TextureAddressingMode::Wrap;
        TextureAddressingMode   addressV        = TextureAddressingMode::Wrap;
        TextureAddressingMode   addressW        = TextureAddressingMode::Wrap;
        float                   mipLODBias      = 0.0f;
        uint32_t                maxAnisotropy   = 1;
        ComparisonFunc          comparisonFunc  = ComparisonFunc::Never;
        float                   borderColor[4]  = { 1.0f, 1.0f, 1.0f, 1.0f };
        float                   minLOD          = -FLT_MAX;
        float                   maxLOD          = FLT_MAX;
    };

    /// Returns a native API handle representing this sampler state object.
    /// When using D3D12, this will be a D3D12_CPU_DESCRIPTOR_HANDLE.
    /// When using Vulkan, this will be a VkSampler.
    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outNativeHandle) = 0;
};
#define SLANG_UUID_ISamplerState                                                        \
    {                                                                                  \
        0x8b8055df, 0x9377, 0x401d, { 0x91, 0xff, 0x3f, 0xa3, 0xbf, 0x66, 0x64, 0xf4 } \
    }

class IResourceView : public ISlangUnknown
{
public:
    enum class Type
    {
        Unknown,

        RenderTarget,
        DepthStencil,
        ShaderResource,
        UnorderedAccess,
        AccelerationStructure,

        CountOf_,
    };

    struct RenderTargetDesc
    {
        // The resource shape of this render target view.
        IResource::Type shape;
    };

    struct Desc
    {
        Type    type;
        Format  format;

        // Required fields for `RenderTarget` and `DepthStencil` views.
        RenderTargetDesc renderTarget;
        // Specifies the range of a texture resource for a ShaderRsource/UnorderedAccess/RenderTarget/DepthStencil view.
        SubresourceRange subresourceRange;
        // Specifies the range of a buffer resource for a ShaderResource/UnorderedAccess view.
        BufferRange bufferRange;
        // Specifies the element size in bytes of a structured buffer. Pass 0 for a raw buffer view.
        Size bufferElementSize;
    };
    virtual SLANG_NO_THROW Desc* SLANG_MCALL getViewDesc() = 0;

    /// Returns a native API handle representing this resource view object.
    /// When using D3D12, this will be a D3D12_CPU_DESCRIPTOR_HANDLE or a buffer device address depending
    /// on the type of the resource view.
    /// When using Vulkan, this will be a VkImageView, VkBufferView, VkAccelerationStructure or a VkBuffer
    /// depending on the type of the resource view.
    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outNativeHandle) = 0;
};
#define SLANG_UUID_IResourceView                                                      \
    {                                                                                 \
        0x7b6c4926, 0x884, 0x408c, { 0xad, 0x8a, 0x50, 0x3a, 0x8e, 0x23, 0x98, 0xa4 } \
    }

class IAccelerationStructure : public IResourceView
{
public:
    enum class Kind
    {
        TopLevel,
        BottomLevel
    };

    struct BuildFlags
    {
        // The enum values are intentionally consistent with
        // D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.
        enum Enum
        {
            None,
            AllowUpdate = 1,
            AllowCompaction = 2,
            PreferFastTrace = 4,
            PreferFastBuild = 8,
            MinimizeMemory = 16,
            PerformUpdate = 32
        };
    };

    enum class GeometryType
    {
        Triangles, ProcedurePrimitives
    };

    struct GeometryFlags
    {
        // The enum values are intentionally consistent with
        // D3D12_RAYTRACING_GEOMETRY_FLAGS.
        enum Enum
        {
            None,
            Opaque = 1,
            NoDuplicateAnyHitInvocation = 2
        };
    };

    struct TriangleDesc
    {
        DeviceAddress transform3x4;
        Format indexFormat;
        Format vertexFormat;
        GfxCount indexCount;
        GfxCount vertexCount;
        DeviceAddress indexData;
        DeviceAddress vertexData;
        Size vertexStride;
    };

    struct ProceduralAABB
    {
        float minX;
        float minY;
        float minZ;
        float maxX;
        float maxY;
        float maxZ;
    };

    struct ProceduralAABBDesc
    {
        /// Number of AABBs.
        GfxCount count;

        /// Pointer to an array of `ProceduralAABB` values in device memory.
        DeviceAddress data;

        /// Stride in bytes of the AABB values array.
        Size stride;
    };

    struct GeometryDesc
    {
        GeometryType type;
        GeometryFlags::Enum flags;
        union
        {
            TriangleDesc triangles;
            ProceduralAABBDesc proceduralAABBs;
        } content;
    };

    struct GeometryInstanceFlags
    {
        // The enum values are kept consistent with D3D12_RAYTRACING_INSTANCE_FLAGS
        // and VkGeometryInstanceFlagBitsKHR.
        enum Enum : uint32_t
        {
            None = 0,
            TriangleFacingCullDisable = 0x00000001,
            TriangleFrontCounterClockwise = 0x00000002,
            ForceOpaque = 0x00000004,
            NoOpaque = 0x00000008
        };
    };

    // TODO: Should any of these be changed?
    // The layout of this struct is intentionally consistent with D3D12_RAYTRACING_INSTANCE_DESC
    // and VkAccelerationStructureInstanceKHR.
    struct InstanceDesc
    {
        float transform[3][4];
        uint32_t instanceID : 24;
        uint32_t instanceMask : 8;
        uint32_t instanceContributionToHitGroupIndex : 24;
        uint32_t flags : 8; // Combination of GeometryInstanceFlags::Enum values.
        DeviceAddress accelerationStructure;
    };

    struct PrebuildInfo
    {
        Size resultDataMaxSize;
        Size scratchDataSize;
        Size updateScratchDataSize;
    };

    struct BuildInputs
    {
        Kind kind;

        BuildFlags::Enum flags;

        GfxCount descCount;

        /// Array of `InstanceDesc` values in device memory.
        /// Used when `kind` is `TopLevel`.
        DeviceAddress instanceDescs;

        /// Array of `GeometryDesc` values.
        /// Used when `kind` is `BottomLevel`.
        const GeometryDesc* geometryDescs;
    };

    struct CreateDesc
    {
        Kind kind;
        IBufferResource* buffer;
        Offset offset;
        Size size;
    };

    struct BuildDesc
    {
        BuildInputs inputs;
        IAccelerationStructure* source;
        IAccelerationStructure* dest;
        DeviceAddress scratchData;
    };

    virtual SLANG_NO_THROW DeviceAddress SLANG_MCALL getDeviceAddress() = 0;
};
#define SLANG_UUID_IAccelerationStructure                                             \
    {                                                                                 \
        0xa5cdda3c, 0x1d4e, 0x4df7, { 0x8e, 0xf2, 0xb7, 0x3f, 0xce, 0x4, 0xde, 0x3b } \
    }

class IFence : public ISlangUnknown
{
public:
    struct Desc
    {
        uint64_t initialValue = 0;
        bool isShared = false;
    };

    /// Returns the currently signaled value on the device.
    virtual SLANG_NO_THROW Result SLANG_MCALL getCurrentValue(uint64_t* outValue) = 0;

    /// Signals the fence from the host with the specified value.
    virtual SLANG_NO_THROW Result SLANG_MCALL setCurrentValue(uint64_t value) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outNativeHandle) = 0;
};
#define SLANG_UUID_IFence                                                             \
    {                                                                                 \
        0x7fe1c283, 0xd3f4, 0x48ed, { 0xaa, 0xf3, 0x1, 0x51, 0x96, 0x4e, 0x7c, 0xb5 } \
    }

struct ShaderOffset
{
    SlangInt uniformOffset = 0; // TODO: Change to Offset?
    GfxIndex bindingRangeIndex = 0;
    GfxIndex bindingArrayIndex = 0;
    uint32_t getHashCode() const
    {
        return (uint32_t)(((bindingRangeIndex << 20) + bindingArrayIndex) ^ uniformOffset);
    }
    bool operator==(const ShaderOffset& other) const
    {
        return uniformOffset == other.uniformOffset
            && bindingRangeIndex == other.bindingRangeIndex
            && bindingArrayIndex == other.bindingArrayIndex;
    }
    bool operator!=(const ShaderOffset& other) const
    {
        return !this->operator==(other);
    }
    bool operator<(const ShaderOffset& other) const
    {
        if (bindingRangeIndex < other.bindingRangeIndex)
            return true;
        if (bindingRangeIndex > other.bindingRangeIndex)
            return false;
        if (bindingArrayIndex < other.bindingArrayIndex)
            return true;
        if (bindingArrayIndex > other.bindingArrayIndex)
            return false;
        return uniformOffset < other.uniformOffset;
    }
    bool operator<=(const ShaderOffset& other) const { return (*this == other) || (*this) < other; }
    bool operator>(const ShaderOffset& other) const { return other < *this; }
    bool operator>=(const ShaderOffset& other) const { return other <= *this; }
};

enum class ShaderObjectContainerType
{
    None, Array, StructuredBuffer
};

class IShaderObject : public ISlangUnknown
{
public:
    virtual SLANG_NO_THROW slang::TypeLayoutReflection* SLANG_MCALL getElementTypeLayout() = 0;
    virtual SLANG_NO_THROW ShaderObjectContainerType SLANG_MCALL getContainerType() = 0;
    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL
        getEntryPoint(GfxIndex index, IShaderObject** entryPoint) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL
        setData(ShaderOffset const& offset, void const* data, Size size) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL
        getObject(ShaderOffset const& offset, IShaderObject** object) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL
        setObject(ShaderOffset const& offset, IShaderObject* object) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL
        setResource(ShaderOffset const& offset, IResourceView* resourceView) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL
        setSampler(ShaderOffset const& offset, ISamplerState* sampler) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler(
        ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) = 0;

        /// Manually overrides the specialization argument for the sub-object binding at `offset`.
        /// Specialization arguments are passed to the shader compiler to specialize the type
        /// of interface-typed shader parameters.
    virtual SLANG_NO_THROW Result SLANG_MCALL setSpecializationArgs(
        ShaderOffset const& offset,
        const slang::SpecializationArg* args,
        GfxCount count) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL getCurrentVersion(
        ITransientResourceHeap* transientHeap,
        IShaderObject** outObject) = 0;

    virtual SLANG_NO_THROW const void* SLANG_MCALL getRawData() = 0;

    virtual SLANG_NO_THROW Size SLANG_MCALL getSize() = 0;

        /// Use the provided constant buffer instead of the internally created one.
    virtual SLANG_NO_THROW Result SLANG_MCALL setConstantBufferOverride(IBufferResource* constantBuffer) = 0;


    inline ComPtr<IShaderObject> getObject(ShaderOffset const& offset)
    {
        ComPtr<IShaderObject> object = nullptr;
        SLANG_RETURN_NULL_ON_FAIL(getObject(offset, object.writeRef()));
        return object;
    }
    inline ComPtr<IShaderObject> getEntryPoint(GfxIndex index)
    {
        ComPtr<IShaderObject> entryPoint = nullptr;
        SLANG_RETURN_NULL_ON_FAIL(getEntryPoint(index, entryPoint.writeRef()));
        return entryPoint;
    }
};
#define SLANG_UUID_IShaderObject                                                       \
    {                                                                                 \
        0xc1fa997e, 0x5ca2, 0x45ae, { 0x9b, 0xcb, 0xc4, 0x35, 0x9e, 0x85, 0x5, 0x85 } \
    }

enum class StencilOp : uint8_t
{
    Keep,
    Zero,
    Replace,
    IncrementSaturate,
    DecrementSaturate,
    Invert,
    IncrementWrap,
    DecrementWrap,
};

enum class FillMode : uint8_t
{
    Solid,
    Wireframe,
};

enum class CullMode : uint8_t
{
    None,
    Front,
    Back,
};

enum class FrontFaceMode : uint8_t
{
    CounterClockwise,
    Clockwise,
};

struct DepthStencilOpDesc
{
    StencilOp       stencilFailOp       = StencilOp::Keep;
    StencilOp       stencilDepthFailOp  = StencilOp::Keep;
    StencilOp       stencilPassOp       = StencilOp::Keep;
    ComparisonFunc  stencilFunc         = ComparisonFunc::Always;
};

struct DepthStencilDesc
{
    bool            depthTestEnable     = false;
    bool            depthWriteEnable    = true;
    ComparisonFunc  depthFunc           = ComparisonFunc::Less;

    bool                stencilEnable       = false;
    uint32_t            stencilReadMask     = 0xFFFFFFFF;
    uint32_t            stencilWriteMask    = 0xFFFFFFFF;
    DepthStencilOpDesc  frontFace;
    DepthStencilOpDesc  backFace;

    uint32_t stencilRef = 0;
};

struct RasterizerDesc
{
    FillMode fillMode = FillMode::Solid;
    CullMode cullMode = CullMode::None;
    FrontFaceMode frontFace = FrontFaceMode::CounterClockwise;
    int32_t depthBias = 0;
    float depthBiasClamp = 0.0f;
    float slopeScaledDepthBias = 0.0f;
    bool depthClipEnable = true;
    bool scissorEnable = false;
    bool multisampleEnable = false;
    bool antialiasedLineEnable = false;
    bool enableConservativeRasterization = false;
    uint32_t forcedSampleCount = 0;
};

enum class LogicOp
{
    NoOp,
};

enum class BlendOp
{
    Add,
    Subtract,
    ReverseSubtract,
    Min,
    Max,
};

enum class BlendFactor
{
    Zero,
    One,
    SrcColor,
    InvSrcColor,
    SrcAlpha,
    InvSrcAlpha,
    DestAlpha,
    InvDestAlpha,
    DestColor,
    InvDestColor,
    SrcAlphaSaturate,
    BlendColor,
    InvBlendColor,
    SecondarySrcColor,
    InvSecondarySrcColor,
    SecondarySrcAlpha,
    InvSecondarySrcAlpha,
};

namespace RenderTargetWriteMask
{
    typedef uint8_t Type;
    enum
    {
        EnableNone  = 0,
        EnableRed   = 0x01,
        EnableGreen = 0x02,
        EnableBlue  = 0x04,
        EnableAlpha = 0x08,
        EnableAll   = 0x0F,
    };
};
typedef RenderTargetWriteMask::Type RenderTargetWriteMaskT;

struct AspectBlendDesc
{
    BlendFactor     srcFactor   = BlendFactor::One;
    BlendFactor     dstFactor   = BlendFactor::Zero;
    BlendOp         op          = BlendOp::Add;
};

struct TargetBlendDesc
{
    AspectBlendDesc color;
    AspectBlendDesc alpha;
    bool enableBlend = false;
    LogicOp                 logicOp     = LogicOp::NoOp;
    RenderTargetWriteMaskT  writeMask   = RenderTargetWriteMask::EnableAll;
};

struct BlendDesc
{
    TargetBlendDesc         targets[kMaxRenderTargetCount];
    GfxCount                targetCount = 0;

    bool alphaToCoverageEnable  = false;
};

class IFramebufferLayout : public ISlangUnknown
{
public:
    struct TargetLayout
    {
        Format format;
        GfxCount sampleCount;
    };
    struct Desc
    {
        GfxCount renderTargetCount;
        TargetLayout* renderTargets = nullptr;
        TargetLayout* depthStencil = nullptr;
    };
};
#define SLANG_UUID_IFramebufferLayout                                                \
    {                                                                                \
        0xa838785, 0xc13a, 0x4832, { 0xad, 0x88, 0x64, 0x6, 0xb5, 0x4b, 0x5e, 0xba } \
    }

struct GraphicsPipelineStateDesc
{
    IShaderProgram*      program = nullptr;

    IInputLayout*       inputLayout = nullptr;
    IFramebufferLayout* framebufferLayout = nullptr;
    PrimitiveType       primitiveType = PrimitiveType::Triangle;
    DepthStencilDesc    depthStencil;
    RasterizerDesc      rasterizer;
    BlendDesc           blend;
};

struct ComputePipelineStateDesc
{
    IShaderProgram*  program = nullptr;
    void* d3d12RootSignatureOverride = nullptr;
};

struct RayTracingPipelineFlags
{
    enum Enum : uint32_t
    {
        None = 0,
        SkipTriangles = 1,
        SkipProcedurals = 2,
    };
};

struct HitGroupDesc
{
    const char* hitGroupName = nullptr;
    const char* closestHitEntryPoint = nullptr;
    const char* anyHitEntryPoint = nullptr;
    const char* intersectionEntryPoint = nullptr;
};

struct RayTracingPipelineStateDesc
{
    IShaderProgram* program = nullptr;
    GfxCount hitGroupCount = 0;
    const HitGroupDesc* hitGroups = nullptr;
    int maxRecursion = 0;
    Size maxRayPayloadSize = 0;
    Size maxAttributeSizeInBytes = 8;
    RayTracingPipelineFlags::Enum flags = RayTracingPipelineFlags::None;
};

class IShaderTable : public ISlangUnknown
{
public:
    // Specifies the bytes to overwrite into a record in the shader table.
    struct ShaderRecordOverwrite
    {
        Offset offset; // Offset within the shader record.
        Size size; // Number of bytes to overwrite.
        uint8_t data[8]; // Content to overwrite.
    };

    struct Desc
    {
        GfxCount rayGenShaderCount;
        const char** rayGenShaderEntryPointNames;
        const ShaderRecordOverwrite* rayGenShaderRecordOverwrites;

        GfxCount missShaderCount;
        const char** missShaderEntryPointNames;
        const ShaderRecordOverwrite* missShaderRecordOverwrites;

        GfxCount hitGroupCount;
        const char** hitGroupNames;
        const ShaderRecordOverwrite* hitGroupRecordOverwrites;

        IShaderProgram* program;
    };
};
#define SLANG_UUID_IShaderTable                                                        \
    {                                                                                  \
        0xa721522c, 0xdf31, 0x4c2f, { 0xa5, 0xe7, 0x3b, 0xe0, 0x12, 0x4b, 0x31, 0x78 } \
    }

class IPipelineState : public ISlangUnknown
{
public:
    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) = 0;
};
#define SLANG_UUID_IPipelineState                                                      \
    {                                                                                 \
        0xca7e57d, 0x8a90, 0x44f3, { 0xbd, 0xb1, 0xfe, 0x9b, 0x35, 0x3f, 0x5a, 0x72 } \
    }


struct ScissorRect
{
    int32_t minX;
    int32_t minY;
    int32_t maxX;
    int32_t maxY;
};

struct Viewport
{
    float originX = 0.0f;
    float originY = 0.0f;
    float extentX = 0.0f;
    float extentY = 0.0f;
    float minZ    = 0.0f;
    float maxZ    = 1.0f;
};

class IFramebuffer : public ISlangUnknown
{
public:
    struct Desc
    {
        GfxCount renderTargetCount;
        IResourceView* const* renderTargetViews;
        IResourceView* depthStencilView;
        IFramebufferLayout* layout;
    };
};
#define SLANG_UUID_IFrameBuffer                                                       \
    {                                                                                 \
        0xf0c0d9a, 0x4ef3, 0x4e18, { 0x9b, 0xa9, 0x34, 0x60, 0xea, 0x69, 0x87, 0x95 } \
    }

struct WindowHandle
{
    enum class Type
    {
        Unknown,
        Win32Handle,
        XLibHandle,
    };
    Type type;
    intptr_t handleValues[2];
    static WindowHandle FromHwnd(void* hwnd)
    {
        WindowHandle handle = {};
        handle.type = WindowHandle::Type::Win32Handle;
        handle.handleValues[0] = (intptr_t)(hwnd);
        return handle;
    }
    static WindowHandle FromXWindow(void* xdisplay, uint32_t xwindow)
    {
        WindowHandle handle = {};
        handle.type = WindowHandle::Type::XLibHandle;
        handle.handleValues[0] = (intptr_t)(xdisplay);
        handle.handleValues[1] = xwindow;
        return handle;
    }
};

struct FaceMask
{
    enum Enum
    {
        Front = 1, Back = 2
    };
};

class IRenderPassLayout : public ISlangUnknown
{
public:
    enum class TargetLoadOp
    {
        Load, Clear, DontCare
    };
    enum class TargetStoreOp
    {
        Store, DontCare
    };
    struct TargetAccessDesc
    {
        TargetLoadOp loadOp;
        TargetLoadOp stencilLoadOp;
        TargetStoreOp storeOp;
        TargetStoreOp stencilStoreOp;
        ResourceState initialState;
        ResourceState finalState;
    };
    struct Desc
    {
        IFramebufferLayout* framebufferLayout = nullptr;
        GfxCount renderTargetCount;
        TargetAccessDesc* renderTargetAccess = nullptr;
        TargetAccessDesc* depthStencilAccess = nullptr;
    };
};
#define SLANG_UUID_IRenderPassLayout                                                   \
    {                                                                                  \
        0xdaab0b1a, 0xf45d, 0x4ae9, { 0xbf, 0x2c, 0xe0, 0xbb, 0x76, 0x7d, 0xfa, 0xd1 } \
    }

enum class QueryType
{
    Timestamp,
    AccelerationStructureCompactedSize,
    AccelerationStructureSerializedSize,
    AccelerationStructureCurrentSize,
};

class IQueryPool : public ISlangUnknown
{
public:
    struct Desc
    {
        QueryType type;
        GfxCount count;
    };
public:
    virtual SLANG_NO_THROW Result SLANG_MCALL getResult(GfxIndex queryIndex, GfxCount count, uint64_t* data) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL reset() = 0;
};
#define SLANG_UUID_IQueryPool                                                         \
    { 0xc2cc3784, 0x12da, 0x480a, { 0xa8, 0x74, 0x8b, 0x31, 0x96, 0x1c, 0xa4, 0x36 } }


class ICommandEncoder : public ISlangUnknown
{
    SLANG_COM_INTERFACE( 0x77ea6383, 0xbe3d, 0x40aa, { 0x8b, 0x45, 0xfd, 0xf0, 0xd7, 0x5b, 0xfa, 0x34 });
public:
    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* queryPool, GfxIndex queryIndex) = 0;
};

struct IndirectDispatchArguments
{
    GfxCount ThreadGroupCountX;
    GfxCount ThreadGroupCountY;
    GfxCount ThreadGroupCountZ;
};

struct IndirectDrawArguments
{
    GfxCount VertexCountPerInstance;
    GfxCount InstanceCount;
    GfxIndex StartVertexLocation;
    GfxIndex StartInstanceLocation;
};

struct IndirectDrawIndexedArguments
{
    GfxCount IndexCountPerInstance;
    GfxCount InstanceCount;
    GfxIndex StartIndexLocation;
    GfxIndex BaseVertexLocation;
    GfxIndex StartInstanceLocation;
};

struct SamplePosition
{
    int8_t x;
    int8_t y;
};

struct ClearResourceViewFlags
{
    enum Enum : uint32_t
    {
        None = 0,
        ClearDepth = 1,
        ClearStencil = 2,
        FloatClearValues = 4
    };
};

class IResourceCommandEncoder : public ICommandEncoder
{
    // {F99A00E9-ED50-4088-8A0E-3B26755031EA}
    SLANG_COM_INTERFACE(0xf99a00e9, 0xed50, 0x4088, { 0x8a, 0xe, 0x3b, 0x26, 0x75, 0x50, 0x31, 0xea });

public:
    virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
        IBufferResource* dst,
        Offset dstOffset,
        IBufferResource* src,
        Offset srcOffset,
        Size size) = 0;

    /// Copies texture from src to dst. If dstSubresource and srcSubresource has mipLevelCount = 0
    /// and layerCount = 0, the entire resource is being copied and dstOffset, srcOffset and extent
    /// arguments are ignored.
    virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
        ITextureResource* dst,
        ResourceState dstState,
        SubresourceRange dstSubresource,
        ITextureResource::Offset3D dstOffset,
        ITextureResource* src,
        ResourceState srcState,
        SubresourceRange srcSubresource,
        ITextureResource::Offset3D srcOffset,
        ITextureResource::Extents extent) = 0;

    /// Copies texture to a buffer. Each row is aligned to kTexturePitchAlignment.
    virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
        IBufferResource* dst,
        Offset dstOffset,
        Size dstSize,
        Size dstRowStride,
        ITextureResource* src,
        ResourceState srcState,
        SubresourceRange srcSubresource,
        ITextureResource::Offset3D srcOffset,
        ITextureResource::Extents extent) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
        ITextureResource* dst,
        SubresourceRange subResourceRange,
        ITextureResource::Offset3D offset,
        ITextureResource::Extents extent,
        ITextureResource::SubresourceData* subResourceData,
        GfxCount subResourceDataCount) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL
        uploadBufferData(IBufferResource* dst, Offset offset, Size size, void* data) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
        GfxCount count, ITextureResource* const* textures, ResourceState src, ResourceState dst) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
        ITextureResource* texture,
        SubresourceRange subresourceRange,
        ResourceState src,
        ResourceState dst) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
        GfxCount count, IBufferResource* const* buffers, ResourceState src, ResourceState dst) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
        IResourceView* view, ClearValue* clearValue, ClearResourceViewFlags::Enum flags) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
        ITextureResource* source,
        ResourceState sourceState,
        SubresourceRange sourceRange,
        ITextureResource* dest,
        ResourceState destState,
        SubresourceRange destRange) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
        IQueryPool* queryPool,
        GfxIndex index,
        GfxCount count,
        IBufferResource* buffer,
        Offset offset) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL beginDebugEvent(const char* name, float rgbColor[3]) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent() = 0;
    inline void textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst)
    {
        textureBarrier(1, &texture, src, dst);
    }
    inline void bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst)
    {
        bufferBarrier(1, &buffer, src, dst);
    }
};

class IRenderCommandEncoder : public IResourceCommandEncoder
{
    // {7A8D56D0-53E6-4AD6-85F7-D14DC110FDCE}
    SLANG_COM_INTERFACE(0x7a8d56d0, 0x53e6, 0x4ad6, { 0x85, 0xf7, 0xd1, 0x4d, 0xc1, 0x10, 0xfd, 0xce })
public:
    // Sets the current pipeline state. This method returns a transient shader object for
    // writing shader parameters. This shader object will not retain any resources or
    // sub-shader-objects bound to it. The user must be responsible for ensuring that any
    // resources or shader objects that is set into `outRootShaderObject` stays alive during
    // the execution of the command buffer.
    virtual SLANG_NO_THROW Result SLANG_MCALL
        bindPipeline(IPipelineState* state, IShaderObject** outRootShaderObject) = 0;
    inline IShaderObject* bindPipeline(IPipelineState* state)
    {
        IShaderObject* rootObject = nullptr;
        SLANG_RETURN_NULL_ON_FAIL(bindPipeline(state, &rootObject));
        return rootObject;
    }

    // Sets the current pipeline state along with a pre-created mutable root shader object.
    virtual SLANG_NO_THROW Result SLANG_MCALL
        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) = 0;

    virtual SLANG_NO_THROW void
        SLANG_MCALL setViewports(GfxCount count, const Viewport* viewports) = 0;
    virtual SLANG_NO_THROW void
        SLANG_MCALL setScissorRects(GfxCount count, const ScissorRect* scissors) = 0;

    /// Sets the viewport, and sets the scissor rect to match the viewport.
    inline void setViewportAndScissor(Viewport const& viewport)
    {
        setViewports(1, &viewport);
        ScissorRect rect = {};
        rect.maxX = static_cast<gfx::Int>(viewport.extentX);
        rect.maxY = static_cast<gfx::Int>(viewport.extentY);
        setScissorRects(1, &rect);
    }

    virtual SLANG_NO_THROW void SLANG_MCALL setPrimitiveTopology(PrimitiveTopology topology) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
        GfxIndex startSlot,
        GfxCount slotCount,
        IBufferResource* const* buffers,
        const Offset* offsets) = 0;
    inline void setVertexBuffer(
        GfxIndex slot, IBufferResource* buffer, Offset offset = 0)
    {
        setVertexBuffers(slot, 1, &buffer, &offset);
    }

    virtual SLANG_NO_THROW void SLANG_MCALL
        setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL
        draw(GfxCount vertexCount, GfxIndex startVertex = 0) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL
        drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL drawIndirect(
        GfxCount maxDrawCount,
        IBufferResource* argBuffer,
        Offset argOffset,
        IBufferResource* countBuffer = nullptr,
        Offset countOffset = 0) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedIndirect(
        GfxCount maxDrawCount,
        IBufferResource* argBuffer,
        Offset argOffset,
        IBufferResource* countBuffer = nullptr,
        Offset countOffset = 0) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
        GfxCount samplesPerPixel, GfxCount pixelCount, const SamplePosition* samplePositions) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
        GfxCount vertexCount,
        GfxCount instanceCount,
        GfxIndex startVertex,
        GfxIndex startInstanceLocation) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
        GfxCount indexCount,
        GfxCount instanceCount,
        GfxIndex startIndexLocation,
        GfxIndex baseVertexLocation,
        GfxIndex startInstanceLocation) = 0;
};

class IComputeCommandEncoder : public IResourceCommandEncoder
{
    // {88AA9322-82F7-4FE6-A68A-29C7FE798737}
    SLANG_COM_INTERFACE(0x88aa9322, 0x82f7, 0x4fe6, { 0xa6, 0x8a, 0x29, 0xc7, 0xfe, 0x79, 0x87, 0x37 })

public:
    // Sets the current pipeline state. This method returns a transient shader object for
    // writing shader parameters. This shader object will not retain any resources or
    // sub-shader-objects bound to it. The user must be responsible for ensuring that any
    // resources or shader objects that is set into `outRooShaderObject` stays alive during
    // the execution of the command buffer.
    virtual SLANG_NO_THROW Result SLANG_MCALL
        bindPipeline(IPipelineState* state, IShaderObject** outRootShaderObject) = 0;
    inline IShaderObject* bindPipeline(IPipelineState* state)
    {
        IShaderObject* rootObject = nullptr;
        SLANG_RETURN_NULL_ON_FAIL(bindPipeline(state, &rootObject));
        return rootObject;
    }
    // Sets the current pipeline state along with a pre-created mutable root shader object.
    virtual SLANG_NO_THROW Result SLANG_MCALL
        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL dispatchComputeIndirect(IBufferResource* cmdBuffer, Offset offset) = 0;
};

enum class AccelerationStructureCopyMode
{
    Clone, Compact
};

struct AccelerationStructureQueryDesc
{
    QueryType queryType;

    IQueryPool* queryPool;

    GfxIndex firstQueryIndex;
};

class IRayTracingCommandEncoder : public IResourceCommandEncoder
{
    SLANG_COM_INTERFACE(0x9a672b87, 0x5035, 0x45e3, { 0x96, 0x7c, 0x1f, 0x85, 0xcd, 0xb3, 0x63, 0x4f })
public:
    virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
        const IAccelerationStructure::BuildDesc& desc,
        GfxCount propertyQueryCount,
        AccelerationStructureQueryDesc* queryDescs) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
        IAccelerationStructure* dest,
        IAccelerationStructure* src,
        AccelerationStructureCopyMode mode) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
        GfxCount accelerationStructureCount,
        IAccelerationStructure* const* accelerationStructures,
        GfxCount queryCount,
        AccelerationStructureQueryDesc* queryDescs) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL
        serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL
        deserializeAccelerationStructure(IAccelerationStructure* dest, DeviceAddress source) = 0;

    virtual SLANG_NO_THROW void SLANG_MCALL
        bindPipeline(IPipelineState* state, IShaderObject** outRootObject) = 0;
    // Sets the current pipeline state along with a pre-created mutable root shader object.
    virtual SLANG_NO_THROW Result SLANG_MCALL
        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) = 0;

    /// Issues a dispatch command to start ray tracing workload with a ray tracing pipeline.
    /// `rayGenShaderIndex` specifies the index into the shader table that identifies the ray generation shader.
    virtual SLANG_NO_THROW void SLANG_MCALL dispatchRays(
        GfxIndex rayGenShaderIndex,
        IShaderTable* shaderTable,
        GfxCount width,
        GfxCount height,
        GfxCount depth) = 0;
};

class ICommandBuffer : public ISlangUnknown
{
public:
    // Only one encoder may be open at a time. User must call `ICommandEncoder::endEncoding`
    // before calling other `encode*Commands` methods.
    // Once `endEncoding` is called, the `ICommandEncoder` object becomes obsolete and is
    // invalid for further use. To continue recording, the user must request a new encoder
    // object by calling one of the `encode*Commands` methods again.
    virtual SLANG_NO_THROW void SLANG_MCALL encodeRenderCommands(
        IRenderPassLayout* renderPass,
        IFramebuffer* framebuffer,
        IRenderCommandEncoder** outEncoder) = 0;
    inline IRenderCommandEncoder*
        encodeRenderCommands(IRenderPassLayout* renderPass, IFramebuffer* framebuffer)
    {
        IRenderCommandEncoder* result;
        encodeRenderCommands(renderPass, framebuffer, &result);
        return result;
    }

    virtual SLANG_NO_THROW void SLANG_MCALL
        encodeComputeCommands(IComputeCommandEncoder** outEncoder) = 0;
    inline IComputeCommandEncoder* encodeComputeCommands()
    {
        IComputeCommandEncoder* result;
        encodeComputeCommands(&result);
        return result;
    }

    virtual SLANG_NO_THROW void SLANG_MCALL
        encodeResourceCommands(IResourceCommandEncoder** outEncoder) = 0;
    inline IResourceCommandEncoder* encodeResourceCommands()
    {
        IResourceCommandEncoder* result;
        encodeResourceCommands(&result);
        return result;
    }

    virtual SLANG_NO_THROW void SLANG_MCALL
        encodeRayTracingCommands(IRayTracingCommandEncoder** outEncoder) = 0;
    inline IRayTracingCommandEncoder* encodeRayTracingCommands()
    {
        IRayTracingCommandEncoder* result;
        encodeRayTracingCommands(&result);
        return result;
    }

    virtual SLANG_NO_THROW void SLANG_MCALL close() = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) = 0;
};
#define SLANG_UUID_ICommandBuffer                                                      \
    {                                                                                  \
        0x5d56063f, 0x91d4, 0x4723, { 0xa7, 0xa7, 0x7a, 0x15, 0xaf, 0x93, 0xeb, 0x48 } \
    }

class ICommandBufferD3D12 : public ICommandBuffer
{
public:
    virtual SLANG_NO_THROW void SLANG_MCALL invalidateDescriptorHeapBinding() = 0;
    virtual SLANG_NO_THROW void SLANG_MCALL ensureInternalDescriptorHeapsBound() = 0;
};
#define SLANG_UUID_ICommandBufferD3D12                                                 \
    {                                                                                  \
        0xd56b7616, 0x6c14, 0x4841, { 0x9d, 0x9c, 0x7b, 0x7f, 0xdb, 0x9f, 0xd9, 0xb8 } \
    }

class ICommandQueue : public ISlangUnknown
{
public:
    enum class QueueType
    {
        Graphics
    };
    struct Desc
    {
        QueueType type;
    };

    // For D3D12, this is the pointer to the queue. For Vulkan, this is the queue itself.
    typedef uint64_t NativeHandle;

    virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() = 0;

    virtual SLANG_NO_THROW void SLANG_MCALL executeCommandBuffers(
        GfxCount count,
        ICommandBuffer* const* commandBuffers,
        IFence* fenceToSignal,
        uint64_t newFenceValue) = 0;
    inline void executeCommandBuffer(
        ICommandBuffer* commandBuffer, IFence* fenceToSignal = nullptr, uint64_t newFenceValue = 0)
    {
        executeCommandBuffers(1, &commandBuffer, fenceToSignal, newFenceValue);
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) = 0;

    virtual SLANG_NO_THROW void SLANG_MCALL waitOnHost() = 0;

    /// Queues a device side wait for the given fences.
    virtual SLANG_NO_THROW Result SLANG_MCALL
        waitForFenceValuesOnDevice(GfxCount fenceCount, IFence** fences, uint64_t* waitValues) = 0;
};
#define SLANG_UUID_ICommandQueue                                                    \
    {                                                                               \
        0x14e2bed0, 0xad0, 0x4dc8, { 0xb3, 0x41, 0x6, 0x3f, 0xe7, 0x2d, 0xbf, 0xe } \
    }

class ITransientResourceHeap : public ISlangUnknown
{
public:
    struct Flags
    {
        enum Enum
        {
            None = 0,
            AllowResizing = 0x1,
        };
    };
    struct Desc
    {
        Flags::Enum flags;
        Size constantBufferSize;
        GfxCount samplerDescriptorCount;
        GfxCount uavDescriptorCount;
        GfxCount srvDescriptorCount;
        GfxCount constantBufferDescriptorCount;
        GfxCount accelerationStructureDescriptorCount;
    };

    // Waits until GPU commands issued before last call to `finish()` has been completed, and resets
    // all transient resources holds by the heap.
    // This method must be called before using the transient heap to issue new GPU commands.
    // In most situations this method should be called at the beginning of each frame.
    virtual SLANG_NO_THROW Result SLANG_MCALL synchronizeAndReset() = 0;

    // Must be called when the application has done using this heap to issue commands. In most situations
    // this method should be called at the end of each frame.
    virtual SLANG_NO_THROW Result SLANG_MCALL finish() = 0;

    // Command buffers are one-time use. Once it is submitted to the queue via
    // `executeCommandBuffers` a command buffer is no longer valid to be used any more. Command
    // buffers must be closed before submission. The current D3D12 implementation has a limitation
    // that only one command buffer maybe recorded at a time. User must finish recording a command
    // buffer before creating another command buffer.
    virtual SLANG_NO_THROW Result SLANG_MCALL
        createCommandBuffer(ICommandBuffer** outCommandBuffer) = 0;
    inline ComPtr<ICommandBuffer> createCommandBuffer()
    {
        ComPtr<ICommandBuffer> result;
        SLANG_RETURN_NULL_ON_FAIL(createCommandBuffer(result.writeRef()));
        return result;
    }
};
#define SLANG_UUID_ITransientResourceHeap                                             \
    {                                                                                 \
        0xcd48bd29, 0xee72, 0x41b8, { 0xbc, 0xff, 0xa, 0x2b, 0x3a, 0xaa, 0x6d, 0xeb } \
    }

class ITransientResourceHeapD3D12 : public ISlangUnknown
{
public:
    enum class DescriptorType
    {
        ResourceView, Sampler
    };
    virtual SLANG_NO_THROW Result SLANG_MCALL allocateTransientDescriptorTable(
        DescriptorType type,
        GfxCount count,
        Offset& outDescriptorOffset,
        void** outD3DDescriptorHeapHandle) = 0;
};
#define SLANG_UUID_ITransientResourceHeapD3D12                                             \
    {                                                                                  \
        0x9bc6a8bc, 0x5f7a, 0x454a, { 0x93, 0xef, 0x3b, 0x10, 0x5b, 0xb7, 0x63, 0x7e } \
    }

class ISwapchain : public ISlangUnknown
{
public:
    struct Desc
    {
        Format format;
        GfxCount width, height;
        GfxCount imageCount;
        ICommandQueue* queue;
        bool enableVSync;
    };
    virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() = 0;

    /// Returns the back buffer image at `index`.
    virtual SLANG_NO_THROW Result SLANG_MCALL
        getImage(GfxIndex index, ITextureResource** outResource) = 0;

    /// Present the next image in the swapchain.
    virtual SLANG_NO_THROW Result SLANG_MCALL present() = 0;

    /// Returns the index of next back buffer image that will be presented in the next
    /// `present` call. If the swapchain is invalid/out-of-date, this method returns -1.
    virtual SLANG_NO_THROW int SLANG_MCALL acquireNextImage() = 0;

    /// Resizes the back buffers of this swapchain. All render target views and framebuffers
    /// referencing the back buffer images must be freed before calling this method.
    virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) = 0;

    // Check if the window is occluded.
    virtual SLANG_NO_THROW bool SLANG_MCALL isOccluded() = 0;

    // Toggle full screen mode.
    virtual SLANG_NO_THROW Result SLANG_MCALL setFullScreenMode(bool mode) = 0;
};
#define SLANG_UUID_ISwapchain                                                        \
    {                                                                                \
        0xbe91ba6c, 0x784, 0x4308, { 0xa1, 0x0, 0x19, 0xc3, 0x66, 0x83, 0x44, 0xb2 } \
    }

// These are exclusively used to track hit/miss counts for shader cache entries. Entry hit and
// miss counts specifically indicate if the file containing relevant shader code was found in
// the cache, while the general hit and miss counts indicate whether the file was both found and
// up-to-date.
class IShaderCacheStatistics : public ISlangUnknown
{
public:
    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getCacheMissCount() = 0;
    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getCacheHitCount() = 0;
    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getCacheEntryDirtyCount() = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL resetCacheStatistics() = 0;
};

#define SLANG_UUID_IShaderCacheStatistics                                                \
    {                                                                                    \
          0x8eccc8ec, 0x5c04, 0x4a51, { 0x99, 0x75, 0x13, 0xf8, 0xfe, 0xa1, 0x59, 0xf3 } \
    }

struct AdapterLUID
{
    uint8_t luid[16];

    bool operator==(const AdapterLUID& other) const
    {
        for (int i = 0; i < sizeof(AdapterLUID::luid); ++i)
            if (luid[i] != other.luid[i])
                return false;
        return true;
    }
    bool operator!=(const AdapterLUID& other) const
    {
        return !this->operator==(other);
    }
};

struct AdapterInfo
{
    // Descriptive name of the adapter.
    char name[128];

    // Unique identifier for the vendor (only available for D3D and Vulkan).
    uint32_t vendorID;

    // Unique identifier for the physical device among devices from the vendor (only available for D3D and Vulkan)
    uint32_t deviceID;

    // Logically unique identifier of the adapter.
    AdapterLUID luid;
};

class AdapterList
{
public:
    AdapterList(ISlangBlob* blob) : m_blob(blob) {}

    const AdapterInfo* getAdapters() const
    {
        return reinterpret_cast<const AdapterInfo*>(m_blob ? m_blob->getBufferPointer() : nullptr);
    }

    GfxCount getCount() const
    {
        return (GfxCount)(m_blob ? m_blob->getBufferSize() / sizeof(AdapterInfo) : 0);
    }

private:
    ComPtr<ISlangBlob> m_blob;
};

struct DeviceLimits
{
    /// Maximum dimension for 1D textures.
    uint32_t maxTextureDimension1D;
    /// Maximum dimensions for 2D textures.
    uint32_t maxTextureDimension2D;
    /// Maximum dimensions for 3D textures.
    uint32_t maxTextureDimension3D;
    /// Maximum dimensions for cube textures.
    uint32_t maxTextureDimensionCube;
    /// Maximum number of texture layers.
    uint32_t maxTextureArrayLayers;

    /// Maximum number of vertex input elements in a graphics pipeline.
    uint32_t maxVertexInputElements;
    /// Maximum offset of a vertex input element in the vertex stream.
    uint32_t maxVertexInputElementOffset;
    /// Maximum number of vertex streams in a graphics pipeline.
    uint32_t maxVertexStreams;
    /// Maximum stride of a vertex stream.
    uint32_t maxVertexStreamStride;

    /// Maximum number of threads per thread group.
    uint32_t maxComputeThreadsPerGroup;
    /// Maximum dimensions of a thread group.
    uint32_t maxComputeThreadGroupSize[3];
    /// Maximum number of thread groups per dimension in a single dispatch.
    uint32_t maxComputeDispatchThreadGroups[3];

    /// Maximum number of viewports per pipeline.
    uint32_t maxViewports;
    /// Maximum viewport dimensions.
    uint32_t maxViewportDimensions[2];
    /// Maximum framebuffer dimensions.
    uint32_t maxFramebufferDimensions[3];

    /// Maximum samplers visible in a shader stage.
    uint32_t maxShaderVisibleSamplers;
};

struct DeviceInfo
{
    DeviceType deviceType;

    DeviceLimits limits;

    BindingStyle bindingStyle;

    ProjectionStyle projectionStyle;

    /// An projection matrix that ensures x, y mapping to pixels
    /// is the same on all targets
    float identityProjectionMatrix[16];

    /// The name of the graphics API being used by this device.
    const char* apiName = nullptr;

    /// The name of the graphics adapter.
    const char* adapterName = nullptr;

    /// The clock frequency used in timestamp queries.
    uint64_t timestampFrequency = 0;
};

enum class DebugMessageType
{
    Info, Warning, Error
};
enum class DebugMessageSource
{
    Layer, Driver, Slang
};
class IDebugCallback
{
public:
    virtual SLANG_NO_THROW void SLANG_MCALL
        handleMessage(DebugMessageType type, DebugMessageSource source, const char* message) = 0;
};

class IDevice : public ISlangUnknown
{
public:
    struct SlangDesc
    {
        slang::IGlobalSession* slangGlobalSession = nullptr; // (optional) A slang global session object. If null will create automatically.

        SlangMatrixLayoutMode defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_ROW_MAJOR;

        char const* const* searchPaths = nullptr;
        GfxCount           searchPathCount = 0;

        slang::PreprocessorMacroDesc const* preprocessorMacros = nullptr;
        GfxCount                            preprocessorMacroCount = 0;

        const char* targetProfile = nullptr; // (optional) Target shader profile. If null this will be set to platform dependent default.
        SlangFloatingPointMode floatingPointMode = SLANG_FLOATING_POINT_MODE_DEFAULT;
        SlangOptimizationLevel optimizationLevel = SLANG_OPTIMIZATION_LEVEL_DEFAULT;
        SlangTargetFlags targetFlags = 0;
        SlangLineDirectiveMode lineDirectiveMode = SLANG_LINE_DIRECTIVE_MODE_DEFAULT;
    };

    struct ShaderCacheDesc
    {
        // The filename for the file the cache's state should be saved to or loaded from.
        const char* cacheFilename = "cache.txt";
        // The root directory for the shader cache.
        const char* shaderCachePath = nullptr;
        // The file system for loading cached shader kernels. The layer does not maintain a strong reference to the object,
        // instead the user is responsible for holding the object alive during the lifetime of an `IDevice`.
        ISlangFileSystem* shaderCacheFileSystem = nullptr;
        // The maximum number of entries stored in the cache. By default, there is no limit.
        GfxCount entryCountLimit = 0;
    };

    struct InteropHandles
    {
        InteropHandle handles[3] = {};
    };

    struct Desc
    {
        // The underlying API/Platform of the device.
        DeviceType deviceType = DeviceType::Default;
        // The device's handles (if they exist) and their associated API. For D3D12, this contains a single InteropHandle
        // for the ID3D12Device. For Vulkan, the first InteropHandle is the VkInstance, the second is the VkPhysicalDevice,
        // and the third is the VkDevice. For CUDA, this only contains a single value for the CUDADevice.
        InteropHandles existingDeviceHandles;
        // LUID of the adapter to use. Use getGfxAdapters() to get a list of available adapters.
        const AdapterLUID* adapterLUID = nullptr;
        // Number of required features.
        GfxCount requiredFeatureCount = 0;
        // Array of required feature names, whose size is `requiredFeatureCount`.
        const char** requiredFeatures = nullptr;
        // A command dispatcher object that intercepts and handles actual low-level API call.
        ISlangUnknown* apiCommandDispatcher = nullptr;
        // The slot (typically UAV) used to identify NVAPI intrinsics. If >=0 NVAPI is required.
        GfxIndex nvapiExtnSlot = -1;
        // Configurations for the shader cache.
        ShaderCacheDesc shaderCache = {};
        // Configurations for Slang compiler.
        SlangDesc slang = {};

        GfxCount extendedDescCount = 0;
        void** extendedDescs = nullptr;
    };

    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeDeviceHandles(InteropHandles* outHandles) = 0;

    virtual SLANG_NO_THROW bool SLANG_MCALL hasFeature(const char* feature) = 0;

        /// Returns a list of features supported by the renderer.
    virtual SLANG_NO_THROW Result SLANG_MCALL getFeatures(const char** outFeatures, Size bufferSize, GfxCount* outFeatureCount) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL getFormatSupportedResourceStates(Format format, ResourceStateSet* outStates) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL getSlangSession(slang::ISession** outSlangSession) = 0;

    inline ComPtr<slang::ISession> getSlangSession()
    {
        ComPtr<slang::ISession> result;
        getSlangSession(result.writeRef());
        return result;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createTransientResourceHeap(
        const ITransientResourceHeap::Desc& desc,
        ITransientResourceHeap** outHeap) = 0;
    inline ComPtr<ITransientResourceHeap> createTransientResourceHeap(
        const ITransientResourceHeap::Desc& desc)
    {
        ComPtr<ITransientResourceHeap> result;
        createTransientResourceHeap(desc, result.writeRef());
        return result;
    }

        /// Create a texture resource.
        ///
        /// If `initData` is non-null, then it must point to an array of
        /// `ITextureResource::SubresourceData` with one element for each
        /// subresource of the texture being created.
        ///
        /// The number of subresources in a texture is:
        ///
        ///     effectiveElementCount * mipLevelCount
        ///
        /// where the effective element count is computed as:
        ///
        ///     effectiveElementCount = (isArray ? arrayElementCount : 1) * (isCube ? 6 : 1);
        ///
    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
        const ITextureResource::Desc& desc,
        const ITextureResource::SubresourceData* initData,
        ITextureResource** outResource) = 0;

        /// Create a texture resource. initData holds the initialize data to set the contents of the texture when constructed.
    inline SLANG_NO_THROW ComPtr<ITextureResource> createTextureResource(
        const ITextureResource::Desc& desc,
        const ITextureResource::SubresourceData* initData = nullptr)
    {
        ComPtr<ITextureResource> resource;
        SLANG_RETURN_NULL_ON_FAIL(createTextureResource(desc, initData, resource.writeRef()));
        return resource;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureFromNativeHandle(
        InteropHandle handle,
        const ITextureResource::Desc& srcDesc,
        ITextureResource** outResource) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureFromSharedHandle(
        InteropHandle handle,
        const ITextureResource::Desc& srcDesc,
        const Size size,
        ITextureResource** outResource) = 0;

        /// Create a buffer resource
    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
        const IBufferResource::Desc& desc,
        const void* initData,
        IBufferResource** outResource) = 0;

    inline SLANG_NO_THROW ComPtr<IBufferResource> createBufferResource(
        const IBufferResource::Desc& desc,
        const void* initData = nullptr)
    {
        ComPtr<IBufferResource> resource;
        SLANG_RETURN_NULL_ON_FAIL(createBufferResource(desc, initData, resource.writeRef()));
        return resource;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferFromNativeHandle(
        InteropHandle handle,
        const IBufferResource::Desc& srcDesc,
        IBufferResource** outResource) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferFromSharedHandle(
        InteropHandle handle,
        const IBufferResource::Desc& srcDesc,
        IBufferResource** outResource) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL
        createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) = 0;

    inline ComPtr<ISamplerState> createSamplerState(ISamplerState::Desc const& desc)
    {
        ComPtr<ISamplerState> sampler;
        SLANG_RETURN_NULL_ON_FAIL(createSamplerState(desc, sampler.writeRef()));
        return sampler;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
        ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) = 0;

    inline ComPtr<IResourceView> createTextureView(ITextureResource* texture, IResourceView::Desc const& desc)
    {
        ComPtr<IResourceView> view;
        SLANG_RETURN_NULL_ON_FAIL(createTextureView(texture, desc, view.writeRef()));
        return view;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
        IBufferResource* buffer,
        IBufferResource* counterBuffer,
        IResourceView::Desc const& desc,
        IResourceView** outView) = 0;

    inline ComPtr<IResourceView> createBufferView(
        IBufferResource* buffer, IBufferResource* counterBuffer, IResourceView::Desc const& desc)
    {
        ComPtr<IResourceView> view;
        SLANG_RETURN_NULL_ON_FAIL(createBufferView(buffer, counterBuffer, desc, view.writeRef()));
        return view;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL
        createFramebufferLayout(IFramebufferLayout::Desc const& desc, IFramebufferLayout** outFrameBuffer) = 0;
    inline ComPtr<IFramebufferLayout> createFramebufferLayout(IFramebufferLayout::Desc const& desc)
    {
        ComPtr<IFramebufferLayout> fb;
        SLANG_RETURN_NULL_ON_FAIL(createFramebufferLayout(desc, fb.writeRef()));
        return fb;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL
        createFramebuffer(IFramebuffer::Desc const& desc, IFramebuffer** outFrameBuffer) = 0;
    inline ComPtr<IFramebuffer> createFramebuffer(IFramebuffer::Desc const& desc)
    {
        ComPtr<IFramebuffer> fb;
        SLANG_RETURN_NULL_ON_FAIL(createFramebuffer(desc, fb.writeRef()));
        return fb;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createRenderPassLayout(
        const IRenderPassLayout::Desc& desc,
        IRenderPassLayout** outRenderPassLayout) = 0;
    inline ComPtr<IRenderPassLayout> createRenderPassLayout(const IRenderPassLayout::Desc& desc)
    {
        ComPtr<IRenderPassLayout> rs;
        SLANG_RETURN_NULL_ON_FAIL(createRenderPassLayout(desc, rs.writeRef()));
        return rs;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createSwapchain(
        ISwapchain::Desc const& desc, WindowHandle window, ISwapchain** outSwapchain) = 0;
    inline ComPtr<ISwapchain> createSwapchain(ISwapchain::Desc const& desc, WindowHandle window)
    {
        ComPtr<ISwapchain> swapchain;
        SLANG_RETURN_NULL_ON_FAIL(createSwapchain(desc, window, swapchain.writeRef()));
        return swapchain;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
        IInputLayout::Desc const& desc, IInputLayout** outLayout) = 0;

    inline ComPtr<IInputLayout> createInputLayout(IInputLayout::Desc const& desc)
    {
        ComPtr<IInputLayout> layout;
        SLANG_RETURN_NULL_ON_FAIL(createInputLayout(desc, layout.writeRef()));
        return layout;
    }

    inline Result createInputLayout(Size vertexSize, InputElementDesc const* inputElements, GfxCount inputElementCount, IInputLayout** outLayout)
    {
        VertexStreamDesc streamDesc = { vertexSize, InputSlotClass::PerVertex, 0 };

        IInputLayout::Desc inputLayoutDesc = {};
        inputLayoutDesc.inputElementCount = inputElementCount;
        inputLayoutDesc.inputElements = inputElements;
        inputLayoutDesc.vertexStreamCount = 1;
        inputLayoutDesc.vertexStreams = &streamDesc;
        return createInputLayout(inputLayoutDesc, outLayout);
    }

    inline ComPtr<IInputLayout> createInputLayout(Size vertexSize, InputElementDesc const* inputElements, GfxCount inputElementCount)
    {
        ComPtr<IInputLayout> layout;
        SLANG_RETURN_NULL_ON_FAIL(createInputLayout(vertexSize, inputElements, inputElementCount, layout.writeRef()));
        return layout;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL
        createCommandQueue(const ICommandQueue::Desc& desc, ICommandQueue** outQueue) = 0;
    inline ComPtr<ICommandQueue> createCommandQueue(const ICommandQueue::Desc& desc)
    {
        ComPtr<ICommandQueue> queue;
        SLANG_RETURN_NULL_ON_FAIL(createCommandQueue(desc, queue.writeRef()));
        return queue;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject(
        slang::TypeReflection* type,
        ShaderObjectContainerType container,
        IShaderObject** outObject) = 0;

    inline ComPtr<IShaderObject> createShaderObject(slang::TypeReflection* type)
    {
        ComPtr<IShaderObject> object;
        SLANG_RETURN_NULL_ON_FAIL(createShaderObject(type, ShaderObjectContainerType::None, object.writeRef()));
        return object;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObject(
        slang::TypeReflection* type,
        ShaderObjectContainerType container,
        IShaderObject** outObject) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectFromTypeLayout(
        slang::TypeLayoutReflection* typeLayout, IShaderObject** outObject) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObjectFromTypeLayout(
        slang::TypeLayoutReflection* typeLayout, IShaderObject** outObject) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createMutableRootShaderObject(
        IShaderProgram* program,
        IShaderObject** outObject) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL
        createShaderTable(const IShaderTable::Desc& desc, IShaderTable** outTable) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createProgram(
        const IShaderProgram::Desc& desc,
        IShaderProgram** outProgram,
        ISlangBlob** outDiagnosticBlob = nullptr) = 0;

    inline ComPtr<IShaderProgram> createProgram(const IShaderProgram::Desc& desc)
    {
        ComPtr<IShaderProgram> program;
        SLANG_RETURN_NULL_ON_FAIL(createProgram(desc, program.writeRef()));
        return program;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createProgram2(
        const IShaderProgram::CreateDesc2& createDesc,
        IShaderProgram** outProgram,
        ISlangBlob** outDiagnosticBlob = nullptr) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
        const GraphicsPipelineStateDesc&    desc,
        IPipelineState**                    outState) = 0;

    inline ComPtr<IPipelineState> createGraphicsPipelineState(
        const GraphicsPipelineStateDesc& desc)
    {
        ComPtr<IPipelineState> state;
        SLANG_RETURN_NULL_ON_FAIL(createGraphicsPipelineState(desc, state.writeRef()));
        return state;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
        const ComputePipelineStateDesc&    desc,
        IPipelineState**                     outState) = 0;

    inline ComPtr<IPipelineState> createComputePipelineState(
        const ComputePipelineStateDesc& desc)
    {
        ComPtr<IPipelineState> state;
        SLANG_RETURN_NULL_ON_FAIL(createComputePipelineState(desc, state.writeRef()));
        return state;
    }

    virtual SLANG_NO_THROW Result SLANG_MCALL createRayTracingPipelineState(
        const RayTracingPipelineStateDesc& desc, IPipelineState** outState) = 0;

        /// Read back texture resource and stores the result in `outBlob`.
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL readTextureResource(
        ITextureResource* resource,
        ResourceState state,
        ISlangBlob** outBlob,
        Size* outRowPitch,
        Size* outPixelSize) = 0;

    virtual SLANG_NO_THROW SlangResult SLANG_MCALL readBufferResource(
        IBufferResource* buffer,
        Offset offset,
        Size size,
        ISlangBlob** outBlob) = 0;

        /// Get the type of this renderer
    virtual SLANG_NO_THROW const DeviceInfo& SLANG_MCALL getDeviceInfo() const = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createQueryPool(
        const IQueryPool::Desc& desc, IQueryPool** outPool) = 0;


    virtual SLANG_NO_THROW Result SLANG_MCALL getAccelerationStructurePrebuildInfo(
        const IAccelerationStructure::BuildInputs& buildInputs,
        IAccelerationStructure::PrebuildInfo* outPrebuildInfo) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL createAccelerationStructure(
        const IAccelerationStructure::CreateDesc& desc,
        IAccelerationStructure** outView) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL
        createFence(const IFence::Desc& desc, IFence** outFence) = 0;

    /// Wait on the host for the fences to signals.
    /// `timeout` is in nanoseconds, can be set to `kTimeoutInfinite`.
    virtual SLANG_NO_THROW Result SLANG_MCALL waitForFences(
        GfxCount fenceCount,
        IFence** fences,
        uint64_t* values,
        bool waitForAll,
        uint64_t timeout) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL getTextureAllocationInfo(
        const ITextureResource::Desc& desc, Size* outSize, Size* outAlignment) = 0;

    virtual SLANG_NO_THROW Result SLANG_MCALL getTextureRowAlignment(Size* outAlignment) = 0;
};

#define SLANG_UUID_IDevice                                                               \
    {                                                                                    \
          0x715bdf26, 0x5135, 0x11eb, { 0xAE, 0x93, 0x02, 0x42, 0xAC, 0x13, 0x00, 0x02 } \
    }

class IPipelineCreationAPIDispatcher : public ISlangUnknown
{
public:
    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
        IDevice* device,
        slang::IComponentType* program,
        void* pipelineDesc,
        void** outPipelineState) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
        IDevice* device,
        slang::IComponentType* program,
        void* pipelineDesc,
        void** outPipelineState) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL
        beforeCreateRayTracingState(IDevice* device, slang::IComponentType* program) = 0;
    virtual SLANG_NO_THROW Result SLANG_MCALL
        afterCreateRayTracingState(IDevice* device, slang::IComponentType* program) = 0;
};
#define SLANG_UUID_IPipelineCreationAPIDispatcher                                     \
    {                                                                                 \
        0xc3d5f782, 0xeae1, 0x4da6, { 0xab, 0x40, 0x75, 0x32, 0x31, 0x2, 0xb7, 0xdc } \
    }


// Global public functions

extern "C"
{
    /// Checks if format is compressed
    SLANG_GFX_API bool SLANG_MCALL gfxIsCompressedFormat(Format format);

    /// Checks if format is typeless
    SLANG_GFX_API bool SLANG_MCALL gfxIsTypelessFormat(Format format);

    /// Gets information about the format
    SLANG_GFX_API SlangResult SLANG_MCALL gfxGetFormatInfo(Format format, FormatInfo* outInfo);

    /// Gets a list of available adapters for a given device type
    SLANG_GFX_API SlangResult SLANG_MCALL gfxGetAdapters(DeviceType type, ISlangBlob** outAdaptersBlob);

    /// Given a type returns a function that can construct it, or nullptr if there isn't one
    SLANG_GFX_API SlangResult SLANG_MCALL
        gfxCreateDevice(const IDevice::Desc* desc, IDevice** outDevice);

    /// Sets a callback for receiving debug messages.
    /// The layer does not hold a strong reference to the callback object.
    /// The user is responsible for holding the callback object alive.
    SLANG_GFX_API SlangResult SLANG_MCALL
        gfxSetDebugCallback(IDebugCallback* callback);

    /// Enables debug layer. The debug layer will check all `gfx` calls and verify that uses are valid.
    SLANG_GFX_API void SLANG_MCALL gfxEnableDebugLayer();

    SLANG_GFX_API const char* SLANG_MCALL gfxGetDeviceTypeName(DeviceType type);
}

/// Gets a list of available adapters for a given device type
inline AdapterList gfxGetAdapters(DeviceType type)
{
    ComPtr<ISlangBlob> blob;
    gfxGetAdapters(type, blob.writeRef());
    return AdapterList(blob);
}

// Extended descs.
struct D3D12ExperimentalFeaturesDesc
{
    StructType structType = StructType::D3D12ExperimentalFeaturesDesc;
    uint32_t numFeatures;
    const void* featureIIDs;
    void* configurationStructs;
    uint32_t* configurationStructSizes;
};

struct D3D12DeviceExtendedDesc
{
    StructType structType = StructType::D3D12DeviceExtendedDesc;
    const char* rootParameterShaderAttributeName = nullptr;
    bool debugBreakOnD3D12Error = false;
    uint32_t highestShaderModel = 0;
};

}


================================================
FILE: Source/External/slang/slang-tag-version.h
================================================
#define SLANG_TAG_VERSION "v0.24.45" 


================================================
FILE: Source/External/slang/slang.h
================================================
#ifndef SLANG_H
#define SLANG_H

/** \file slang.h

The Slang API provides services to compile, reflect, and specialize code
written in the Slang shading language.
*/

/*
The following section attempts to detect the compiler and version in use.

If an application defines `SLANG_COMPILER` before including this header,
they take responsibility for setting any compiler-dependent macros
used later in the file.

Most applications should not need to touch this section.
*/
#ifndef SLANG_COMPILER
#    define SLANG_COMPILER

/*
Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/
NOTE that SLANG_VC holds the compiler version - not just 1 or 0
*/
#    if defined(_MSC_VER)
#        if _MSC_VER >= 1900
#            define SLANG_VC 14
#        elif _MSC_VER >= 1800
#            define SLANG_VC 12
#        elif _MSC_VER >= 1700
#            define SLANG_VC 11
#        elif _MSC_VER >= 1600
#            define SLANG_VC 10
#        elif _MSC_VER >= 1500
#            define SLANG_VC 9
#        else
#            error "unknown version of Visual C++ compiler"
#        endif
#    elif defined(__clang__)
#        define SLANG_CLANG 1
#    elif defined(__SNC__)
#        define SLANG_SNC 1
#    elif defined(__ghs__)
#        define SLANG_GHS 1
#    elif defined(__GNUC__) /* note: __clang__, __SNC__, or __ghs__ imply __GNUC__ */
#        define SLANG_GCC 1
#    else
#        error "unknown compiler"
#    endif
/*
Any compilers not detected by the above logic are now now explicitly zeroed out.
*/
#    ifndef SLANG_VC
#        define SLANG_VC 0
#    endif
#    ifndef SLANG_CLANG
#        define SLANG_CLANG 0
#    endif
#    ifndef SLANG_SNC
#        define SLANG_SNC 0
#    endif
#    ifndef SLANG_GHS
#        define SLANG_GHS 0
#    endif
#    ifndef SLANG_GCC
#        define SLANG_GCC 0
#    endif
#endif /* SLANG_COMPILER */

/*
The following section attempts to detect the target platform being compiled for.

If an application defines `SLANG_PLATFORM` before including this header,
they take responsibility for setting any compiler-dependent macros
used later in the file.

Most applications should not need to touch this section.
*/
#ifndef SLANG_PLATFORM
#    define SLANG_PLATFORM
/**
Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/
*/
#    if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP
#        define SLANG_WINRT 1 /* Windows Runtime, either on Windows RT or Windows 8 */
#    elif defined(XBOXONE)
#        define SLANG_XBOXONE 1
#    elif defined(_WIN64) /* note: XBOXONE implies _WIN64 */
#        define SLANG_WIN64 1
#    elif defined(_M_PPC)
#        define SLANG_X360 1
#    elif defined(_WIN32) /* note: _M_PPC implies _WIN32 */
#        define SLANG_WIN32 1
#    elif defined(__ANDROID__)
#        define SLANG_ANDROID 1
#    elif defined(__linux__) || defined(__CYGWIN__) /* note: __ANDROID__ implies __linux__ */
#        define SLANG_LINUX 1
#    elif defined(__APPLE__)
#        include "TargetConditionals.h"
#        if TARGET_OS_MAC
#            define SLANG_OSX 1
#        else
#            define SLANG_IOS 1
#        endif
#    elif defined(__CELLOS_LV2__)
#        define SLANG_PS3 1
#    elif defined(__ORBIS__)
#        define SLANG_PS4 1
#    elif defined(__SNC__) && defined(__arm__)
#        define SLANG_PSP2 1
#    elif defined(__ghs__)
#        define SLANG_WIIU 1
#    else
#        error "unknown target platform"
#    endif
/*
Any platforms not detected by the above logic are now now explicitly zeroed out.
*/
#    ifndef SLANG_WINRT
#        define SLANG_WINRT 0
#    endif
#    ifndef SLANG_XBOXONE
#        define SLANG_XBOXONE 0
#    endif
#    ifndef SLANG_WIN64
#        define SLANG_WIN64 0
#    endif
#    ifndef SLANG_X360
#        define SLANG_X360 0
#    endif
#    ifndef SLANG_WIN32
#        define SLANG_WIN32 0
#    endif
#    ifndef SLANG_ANDROID
#        define SLANG_ANDROID 0
#    endif
#    ifndef SLANG_LINUX
#        define SLANG_LINUX 0
#    endif
#    ifndef SLANG_IOS
#        define SLANG_IOS 0
#    endif
#    ifndef SLANG_OSX
#        define SLANG_OSX 0
#    endif
#    ifndef SLANG_PS3
#        define SLANG_PS3 0
#    endif
#    ifndef SLANG_PS4
#        define SLANG_PS4 0
#    endif
#    ifndef SLANG_PSP2
#        define SLANG_PSP2 0
#    endif
#    ifndef SLANG_WIIU
#        define SLANG_WIIU 0
#    endif
#endif /* SLANG_PLATFORM */

/* Shorthands for "families" of compilers/platforms */
#define SLANG_GCC_FAMILY (SLANG_CLANG || SLANG_SNC || SLANG_GHS || SLANG_GCC)
#define SLANG_WINDOWS_FAMILY (SLANG_WINRT || SLANG_WIN32 || SLANG_WIN64)
#define SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE || SLANG_X360 || SLANG_WINDOWS_FAMILY)
#define SLANG_LINUX_FAMILY (SLANG_LINUX || SLANG_ANDROID)
#define SLANG_APPLE_FAMILY (SLANG_IOS || SLANG_OSX)                  /* equivalent to #if __APPLE__ */
#define SLANG_UNIX_FAMILY (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */

/* Macro for declaring if a method is no throw. Should be set before the return parameter. */
#ifndef SLANG_NO_THROW
#   if SLANG_WINDOWS_FAMILY && !defined(SLANG_DISABLE_EXCEPTIONS)
#       define SLANG_NO_THROW __declspec(nothrow)
#   endif
#endif
#ifndef SLANG_NO_THROW
#   define SLANG_NO_THROW
#endif

/* The `SLANG_STDCALL` and `SLANG_MCALL` defines are used to set the calling
convention for interface methods.
*/
#ifndef SLANG_STDCALL
#   if SLANG_MICROSOFT_FAMILY
#       define SLANG_STDCALL __stdcall
#   else
#       define SLANG_STDCALL
#   endif
#endif
#ifndef SLANG_MCALL
#   define SLANG_MCALL SLANG_STDCALL
#endif


#if !defined(SLANG_STATIC) && !defined(SLANG_STATIC)
    #define SLANG_DYNAMIC
#endif

#if defined(_MSC_VER)
#   define SLANG_DLL_EXPORT __declspec(dllexport)
#else
#   if 0 && __GNUC__ >= 4
// Didn't work on latest gcc on linux.. so disable for now
// https://gcc.gnu.org/wiki/Visibility
#       define SLANG_DLL_EXPORT __attribute__ ((dllexport))
#   else
#       define SLANG_DLL_EXPORT __attribute__((__visibility__("default")))
#   endif
#endif

#if defined(SLANG_DYNAMIC)
#   if defined(_MSC_VER)
#       ifdef SLANG_DYNAMIC_EXPORT
#           define SLANG_API SLANG_DLL_EXPORT
#       else
#           define SLANG_API __declspec(dllimport)
#       endif
#   else
        // TODO: need to consider compiler capabilities
//#     ifdef SLANG_DYNAMIC_EXPORT
#       define SLANG_API SLANG_DLL_EXPORT 
//#     endif
#   endif
#endif

#ifndef SLANG_API
#   define SLANG_API
#endif

// GCC Specific
#if SLANG_GCC_FAMILY
// This doesn't work on clang - because the typedef is seen as multiply defined, use the line numbered version defined later
#	if !defined(__clang__) && (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) || defined(__ORBIS__))
#		define SLANG_COMPILE_TIME_ASSERT(exp) typedef char SlangCompileTimeAssert_Dummy[(exp) ? 1 : -1] __attribute__((unused))
#	endif

#	define SLANG_NO_INLINE __attribute__((noinline))
#	define SLANG_FORCE_INLINE inline __attribute__((always_inline))
#   define SLANG_BREAKPOINT(id) __builtin_trap();
#	define SLANG_ALIGN_OF(T)	__alignof__(T)

// Use this macro instead of offsetof, because gcc produces warning if offsetof is used on a 
// non POD type, even though it produces the correct result
#   define SLANG_OFFSET_OF(T, ELEMENT) (size_t(&((T*)1)->ELEMENT) - 1)
#endif // SLANG_GCC_FAMILY

// Microsoft VC specific
#if SLANG_MICROSOFT_FAMILY
#	define SLANG_NO_INLINE __declspec(noinline)
#	define SLANG_FORCE_INLINE __forceinline
#	define SLANG_BREAKPOINT(id) __debugbreak();
#	define SLANG_ALIGN_OF(T) __alignof(T)

#   define SLANG_INT64(x) (x##i64)
#   define SLANG_UINT64(x) (x##ui64)
#endif // SLANG_MICROSOFT_FAMILY

#ifndef SLANG_FORCE_INLINE
#	define SLANG_FORCE_INLINE inline
#endif
#ifndef SLANG_NO_INLINE
#	define SLANG_NO_INLINE
#endif

#ifndef SLANG_COMPILE_TIME_ASSERT
#	define SLANG_COMPILE_TIME_ASSERT(exp) typedef char SLANG_CONCAT(SlangCompileTimeAssert,__LINE__)[(exp) ? 1 : -1]
#endif

#ifndef SLANG_OFFSET_OF
#	define SLANG_OFFSET_OF(X, Y) offsetof(X, Y)
#endif

#ifndef SLANG_BREAKPOINT
// Make it crash with a write to 0!
#   define SLANG_BREAKPOINT(id) (*((int*)0) = int(id));
#endif

// Use for getting the amount of members of a standard C array.
#define SLANG_COUNT_OF(x) (sizeof(x)/sizeof(x[0]))
/// SLANG_INLINE exists to have a way to inline consistent with SLANG_ALWAYS_INLINE
#define SLANG_INLINE inline

// If explicilty disabled and not set, set to not available
#if !defined(SLANG_HAS_EXCEPTIONS) && defined(SLANG_DISABLE_EXCEPTIONS)
#   define SLANG_HAS_EXCEPTIONS 0
#endif

// If not set, the default is exceptions are available
#ifndef SLANG_HAS_EXCEPTIONS
#   define SLANG_HAS_EXCEPTIONS 1
#endif

// Other defines
#define SLANG_STRINGIZE_HELPER(X) #X
#define SLANG_STRINGIZE(X) SLANG_STRINGIZE_HELPER(X)

#define SLANG_CONCAT_HELPER(X, Y) X##Y
#define SLANG_CONCAT(X, Y) SLANG_CONCAT_HELPER(X, Y)

#ifndef SLANG_UNUSED
#	define SLANG_UNUSED(v) (void)v;
#endif

// Used for doing constant literals
#ifndef SLANG_INT64
#	define SLANG_INT64(x) (x##ll)
#endif
#ifndef SLANG_UINT64
#	define SLANG_UINT64(x) (x##ull)
#endif


#ifdef __cplusplus
#   define SLANG_EXTERN_C extern "C"
#else
#   define SLANG_EXTERN_C
#endif

#ifdef __cplusplus
// C++ specific macros
// Clang
#if SLANG_CLANG
#    if (__clang_major__*10 + __clang_minor__) >= 33
#       define SLANG_HAS_MOVE_SEMANTICS 1
#       define SLANG_HAS_ENUM_CLASS 1
#       define SLANG_OVERRIDE override
#    endif

// Gcc
#elif SLANG_GCC_FAMILY
// Check for C++11
#		if (__cplusplus >= 201103L)
#			if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405
#				define SLANG_HAS_MOVE_SEMANTICS 1
#			endif
#			if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
#				define SLANG_HAS_ENUM_CLASS 1
#			endif
#			if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407
#				define SLANG_OVERRIDE override
#			endif
#		endif

// TODO(JS): Not used in previous code. Left here as may be useful on some other version. 
// #define SLANG_RETURN_NEVER __attribute__((__noreturn__))

#       define SLANG_RETURN_NEVER [[noreturn]]

#	endif // SLANG_GCC_FAMILY

// Visual Studio

#	if SLANG_VC
// C4481: nonstandard extension used: override specifier 'override'
#		if _MSC_VER < 1700
#			pragma warning(disable : 4481)
#		endif
#		define SLANG_OVERRIDE	override
#		if _MSC_VER >= 1600
#			define SLANG_HAS_MOVE_SEMANTICS 1
#		endif
#	    if _MSC_VER >= 1700
#		    define SLANG_HAS_ENUM_CLASS 1
#       endif

#   define SLANG_RETURN_NEVER __declspec(noreturn)

#   endif // SLANG_VC

// Set non set
#   ifndef SLANG_OVERRIDE
#	    define SLANG_OVERRIDE
#   endif
#   ifndef SLANG_HAS_ENUM_CLASS
#	    define SLANG_HAS_ENUM_CLASS 0
#   endif
#   ifndef SLANG_HAS_MOVE_SEMANTICS
#	    define SLANG_HAS_MOVE_SEMANTICS 0
#   endif

#endif // __cplusplus

#ifndef SLANG_RETURN_NEVER
#   define SLANG_RETURN_NEVER [[noreturn]]
#endif // SLANG_RETURN_NEVER

/* Macros for detecting processor */
#if defined(_M_ARM) || defined(__ARM_EABI__)
// This is special case for nVidia tegra
#   define SLANG_PROCESSOR_ARM 1
#elif defined(__i386__) || defined(_M_IX86)
#   define SLANG_PROCESSOR_X86 1
#elif defined(_M_AMD64) || defined(_M_X64) || defined(__amd64) || defined(__x86_64)
#   define SLANG_PROCESSOR_X86_64 1
#elif defined(_PPC_) || defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC)
#   if defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || defined(__64BIT__) || defined(_LP64) || defined(__LP64__)
#       define SLANG_PROCESSOR_POWER_PC_64 1
#   else
#       define SLANG_PROCESSOR_POWER_PC 1
#   endif
#elif defined(__arm__)
#   define SLANG_PROCESSOR_ARM 1
#elif defined(_M_ARM64) || defined(__aarch64__)
#   define SLANG_PROCESSOR_ARM_64 1
#endif 

#ifndef SLANG_PROCESSOR_ARM
#   define SLANG_PROCESSOR_ARM 0
#endif

#ifndef SLANG_PROCESSOR_ARM_64
#   define SLANG_PROCESSOR_ARM_64 0
#endif

#ifndef SLANG_PROCESSOR_X86
#   define SLANG_PROCESSOR_X86 0
#endif

#ifndef SLANG_PROCESSOR_X86_64
#   define SLANG_PROCESSOR_X86_64 0
#endif

#ifndef SLANG_PROCESSOR_POWER_PC
#   define SLANG_PROCESSOR_POWER_PC 0
#endif

#ifndef SLANG_PROCESSOR_POWER_PC_64
#   define SLANG_PROCESSOR_POWER_PC_64 0
#endif

// Processor families

#define SLANG_PROCESSOR_FAMILY_X86 (SLANG_PROCESSOR_X86_64 | SLANG_PROCESSOR_X86)
#define SLANG_PROCESSOR_FAMILY_ARM (SLANG_PROCESSOR_ARM | SLANG_PROCESSOR_ARM_64)
#define SLANG_PROCESSOR_FAMILY_POWER_PC (SLANG_PROCESSOR_POWER_PC_64 | SLANG_PROCESSOR_POWER_PC)

// Pointer size
#define SLANG_PTR_IS_64 (SLANG_PROCESSOR_ARM_64 | SLANG_PROCESSOR_X86_64 | SLANG_PROCESSOR_POWER_PC_64)
#define SLANG_PTR_IS_32 (SLANG_PTR_IS_64 ^ 1)

// Processor features
#if SLANG_PROCESSOR_FAMILY_X86
#   define SLANG_LITTLE_ENDIAN 1
#   define SLANG_UNALIGNED_ACCESS 1
#elif SLANG_PROCESSOR_FAMILY_ARM
#   if defined(__ARMEB__)
#       define SLANG_BIG_ENDIAN 1
#   else
#       define SLANG_LITTLE_ENDIAN 1
#   endif
#elif SLANG_PROCESSOR_FAMILY_POWER_PC
#       define SLANG_BIG_ENDIAN 1
#endif

#ifndef SLANG_LITTLE_ENDIAN
#   define SLANG_LITTLE_ENDIAN 0
#endif

#ifndef SLANG_BIG_ENDIAN
#   define SLANG_BIG_ENDIAN 0
#endif

#ifndef SLANG_UNALIGNED_ACCESS
#   define SLANG_UNALIGNED_ACCESS 0
#endif

// One endianess must be set
#if ((SLANG_BIG_ENDIAN | SLANG_LITTLE_ENDIAN) == 0)
#   error "Couldn't determine endianess"
#endif

#ifndef  SLANG_NO_INTTYPES
#include <inttypes.h>
#endif // ! SLANG_NO_INTTYPES

#ifndef  SLANG_NO_STDDEF
#include <stddef.h>
#endif // ! SLANG_NO_STDDEF

#ifdef __cplusplus
extern "C"
{
#endif
    /*!
    @mainpage Introduction

    API Reference: slang.h

    @file slang.h
    */

    typedef uint32_t    SlangUInt32;
    typedef int32_t     SlangInt32;

    // Use SLANG_PTR_ macros to determine SlangInt/SlangUInt types.
    // This is used over say using size_t/ptrdiff_t/intptr_t/uintptr_t, because on some targets, these types are distinct from
    // their uint_t/int_t equivalents and so produce ambiguity with function overloading.
    //
    // SlangSizeT is helpful as on some compilers size_t is distinct from a regular integer type and so overloading doesn't work.
    // Casting to SlangSizeT works around this.
#if SLANG_PTR_IS_64
    typedef int64_t    SlangInt;
    typedef uint64_t   SlangUInt;

    typedef uint64_t   SlangSizeT;
#else
    typedef int32_t    SlangInt;
    typedef uint32_t   SlangUInt;

    typedef uint32_t   SlangSizeT;
#endif

    typedef bool SlangBool;

    
    /*!
    @brief Severity of a diagnostic generated by the compiler.
    Values come from the enum below, with higher values representing more severe
    conditions, and all values >= SLANG_SEVERITY_ERROR indicating compilation
    failure.
    */
    typedef int SlangSeverityIntegral;
    enum SlangSeverity : SlangSeverityIntegral
    {
        SLANG_SEVERITY_DISABLED = 0, /**< A message that is disabled, filtered out. */
        SLANG_SEVERITY_NOTE,         /**< An informative message. */
        SLANG_SEVERITY_WARNING,      /**< A warning, which indicates a possible proble. */
        SLANG_SEVERITY_ERROR,        /**< An error, indicating that compilation failed. */
        SLANG_SEVERITY_FATAL,        /**< An unrecoverable error, which forced compilation to abort. */
        SLANG_SEVERITY_INTERNAL,     /**< An internal error, indicating a logic error in the compiler. */
    };

    typedef int SlangDiagnosticFlags;
    enum
    {
        SLANG_DIAGNOSTIC_FLAG_VERBOSE_PATHS = 0x01,
        SLANG_DIAGNOSTIC_FLAG_TREAT_WARNINGS_AS_ERRORS = 0x02
    };

    typedef int SlangBindableResourceIntegral;
    enum SlangBindableResourceType : SlangBindableResourceIntegral
    {
        SLANG_NON_BINDABLE = 0,
        SLANG_TEXTURE,
        SLANG_SAMPLER,
        SLANG_UNIFORM_BUFFER,
        SLANG_STORAGE_BUFFER,
    };

    typedef int SlangCompileTargetIntegral;
    enum SlangCompileTarget : SlangCompileTargetIntegral
    {
        SLANG_TARGET_UNKNOWN,
        SLANG_TARGET_NONE,
        SLANG_GLSL,
        SLANG_GLSL_VULKAN,          //< deprecated: just use `SLANG_GLSL`
        SLANG_GLSL_VULKAN_ONE_DESC, //< deprecated
        SLANG_HLSL,
        SLANG_SPIRV,
        SLANG_SPIRV_ASM,
        SLANG_DXBC,
        SLANG_DXBC_ASM,
        SLANG_DXIL,
        SLANG_DXIL_ASM,
        SLANG_C_SOURCE,             ///< The C language
        SLANG_CPP_SOURCE,           ///< C++ code for shader kernels.
        SLANG_HOST_EXECUTABLE,           ///<  Standalone binary executable (for hosting CPU/OS)
        SLANG_SHADER_SHARED_LIBRARY,     ///< A shared library/Dll for shader kernels (for hosting CPU/OS)
        SLANG_SHADER_HOST_CALLABLE,      ///< A CPU target that makes the compiled shader code available to be run immediately
        SLANG_CUDA_SOURCE,          ///< Cuda source
        SLANG_PTX,                  ///< PTX
        SLANG_OBJECT_CODE,          ///< Object code that can be used for later linking
        SLANG_HOST_CPP_SOURCE,      ///< C++ code for host library or executable.
        SLANG_HOST_HOST_CALLABLE,   ///< 
        SLANG_TARGET_COUNT_OF,
    };

    /* A "container format" describes the way that the outputs
    for multiple files, entry points, targets, etc. should be
    combined into a single artifact for output. */
    typedef int SlangContainerFormatIntegral;
    enum SlangContainerFormat : SlangContainerFormatIntegral
    {
        /* Don't generate a container. */
        SLANG_CONTAINER_FORMAT_NONE,

        /* Generate a container in the `.slang-module` format,
        which includes reflection information, compiled kernels, etc. */
        SLANG_CONTAINER_FORMAT_SLANG_MODULE,
    };

    typedef int SlangPassThroughIntegral;
    enum SlangPassThrough : SlangPassThroughIntegral
    {
        SLANG_PASS_THROUGH_NONE,
        SLANG_PASS_THROUGH_FXC,
        SLANG_PASS_THROUGH_DXC,
        SLANG_PASS_THROUGH_GLSLANG,
        SLANG_PASS_THROUGH_CLANG,                   ///< Clang C/C++ compiler 
        SLANG_PASS_THROUGH_VISUAL_STUDIO,           ///< Visual studio C/C++ compiler
        SLANG_PASS_THROUGH_GCC,                     ///< GCC C/C++ compiler
        SLANG_PASS_THROUGH_GENERIC_C_CPP,           ///< Generic C or C++ compiler, which is decided by the source type
        SLANG_PASS_THROUGH_NVRTC,                   ///< NVRTC Cuda compiler
        SLANG_PASS_THROUGH_LLVM,                    ///< LLVM 'compiler' - includes LLVM and Clang
        SLANG_PASS_THROUGH_COUNT_OF,
    };

    /* Defines an archive type used to holds a 'file system' type structure. */
    typedef int SlangArchiveTypeIntegral;
    enum SlangArchiveType : SlangArchiveTypeIntegral
    {
        SLANG_ARCHIVE_TYPE_UNDEFINED,
        SLANG_ARCHIVE_TYPE_ZIP,
        SLANG_ARCHIVE_TYPE_RIFF,                ///< Riff container with no compression
        SLANG_ARCHIVE_TYPE_RIFF_DEFLATE,
        SLANG_ARCHIVE_TYPE_RIFF_LZ4,
        SLANG_ARCHIVE_TYPE_COUNT_OF,
    };

    /*!
    Flags to control compilation behavior.
    */
    typedef unsigned int SlangCompileFlags;
    enum
    {
        /* Do as little mangling of names as possible, to try to preserve original names */
        SLANG_COMPILE_FLAG_NO_MANGLING          = 1 << 3,

        /* Skip code generation step, just check the code and generate layout */
        SLANG_COMPILE_FLAG_NO_CODEGEN           = 1 << 4,

        /* Obfuscate shader names on release products */
        SLANG_COMPILE_FLAG_OBFUSCATE = 1 << 5,

        /* Deprecated flags: kept around to allow existing applications to
        compile. Note that the relevant features will still be left in
        their default state. */
        SLANG_COMPILE_FLAG_NO_CHECKING          = 0,
        SLANG_COMPILE_FLAG_SPLIT_MIXED_TYPES    = 0,
    };

    /*!
    @brief Flags to control code generation behavior of a compilation target */
    typedef unsigned int SlangTargetFlags;
    enum 
    {
        /* When compiling for a D3D Shader Model 5.1 or higher target, allocate
           distinct register spaces for parameter blocks.

           @deprecated This behavior is now enabled unconditionally.
        */
        SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES = 1 << 4,

        /* When set, will generate target code that contains all entrypoints defined
           in the input source or specified via the `spAddEntryPoint` function in a
           single output module (library/source file).
        */
        SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM = 1 << 8,

        /* When set, will dump out the IR between intermediate compilation steps.*/
        SLANG_TARGET_FLAG_DUMP_IR = 1 << 9,

        /* When set, will generate SPIRV directly instead of going through glslang. */
        SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY = 1 << 10,
    };

    /*!
    @brief Options to control floating-point precision guarantees for a target.
    */
    typedef unsigned int SlangFloatingPointModeIntegral;
    enum SlangFloatingPointMode : SlangFloatingPointModeIntegral
    {
        SLANG_FLOATING_POINT_MODE_DEFAULT = 0,
        SLANG_FLOATING_POINT_MODE_FAST,
        SLANG_FLOATING_POINT_MODE_PRECISE,
    };

    /*!
    @brief Options to control emission of `#line` directives
    */
    typedef unsigned int SlangLineDirectiveModeIntegral;
    enum SlangLineDirectiveMode : SlangLineDirectiveModeIntegral
    {
        SLANG_LINE_DIRECTIVE_MODE_DEFAULT = 0,  /**< Default behavior: pick behavior base on target. */
        SLANG_LINE_DIRECTIVE_MODE_NONE,         /**< Don't emit line directives at all. */
        SLANG_LINE_DIRECTIVE_MODE_STANDARD,     /**< Emit standard C-style `#line` directives. */
        SLANG_LINE_DIRECTIVE_MODE_GLSL,         /**< Emit GLSL-style directives with file *number* instead of name */
    };

    typedef int SlangSourceLanguageIntegral;
    enum SlangSourceLanguage : SlangSourceLanguageIntegral
    {
        SLANG_SOURCE_LANGUAGE_UNKNOWN,
        SLANG_SOURCE_LANGUAGE_SLANG,
        SLANG_SOURCE_LANGUAGE_HLSL,
        SLANG_SOURCE_LANGUAGE_GLSL,
        SLANG_SOURCE_LANGUAGE_C,
        SLANG_SOURCE_LANGUAGE_CPP,
        SLANG_SOURCE_LANGUAGE_CUDA,
        SLANG_SOURCE_LANGUAGE_COUNT_OF,
    };

    typedef unsigned int SlangProfileIDIntegral;
    enum SlangProfileID : SlangProfileIDIntegral
    {
        SLANG_PROFILE_UNKNOWN,
    };


    typedef SlangInt32 SlangCapabilityIDIntegral;
    enum SlangCapabilityID : SlangCapabilityIDIntegral
    {
        SLANG_CAPABILITY_UNKNOWN = 0,
    };

    typedef unsigned int SlangMatrixLayoutModeIntegral;
    enum SlangMatrixLayoutMode : SlangMatrixLayoutModeIntegral
    {
        SLANG_MATRIX_LAYOUT_MODE_UNKNOWN = 0,
        SLANG_MATRIX_LAYOUT_ROW_MAJOR,
        SLANG_MATRIX_LAYOUT_COLUMN_MAJOR,
    };

    typedef SlangUInt32 SlangStageIntegral;
    enum SlangStage : SlangStageIntegral
    {
        SLANG_STAGE_NONE,
        SLANG_STAGE_VERTEX,
        SLANG_STAGE_HULL,
        SLANG_STAGE_DOMAIN,
        SLANG_STAGE_GEOMETRY,
        SLANG_STAGE_FRAGMENT,
        SLANG_STAGE_COMPUTE,
        SLANG_STAGE_RAY_GENERATION,
        SLANG_STAGE_INTERSECTION,
        SLANG_STAGE_ANY_HIT,
        SLANG_STAGE_CLOSEST_HIT,
        SLANG_STAGE_MISS,
        SLANG_STAGE_CALLABLE,
        SLANG_STAGE_MESH,
        SLANG_STAGE_AMPLIFICATION,

        // alias:
        SLANG_STAGE_PIXEL = SLANG_STAGE_FRAGMENT,
    };

    typedef SlangUInt32 SlangDebugInfoLevelIntegral;
    enum SlangDebugInfoLevel : SlangDebugInfoLevelIntegral
    {
        SLANG_DEBUG_INFO_LEVEL_NONE = 0,    /**< Don't emit debug information at all. */
        SLANG_DEBUG_INFO_LEVEL_MINIMAL,     /**< Emit as little debug information as possible, while still supporting stack trackes. */
        SLANG_DEBUG_INFO_LEVEL_STANDARD,    /**< Emit whatever is the standard level of debug information for each target. */
        SLANG_DEBUG_INFO_LEVEL_MAXIMAL,     /**< Emit as much debug infromation as possible for each target. */
        
    };

    typedef SlangUInt32 SlangOptimizationLevelIntegral;
    enum SlangOptimizationLevel : SlangOptimizationLevelIntegral
    {
        SLANG_OPTIMIZATION_LEVEL_NONE = 0,  /**< Don't optimize at all. */
        SLANG_OPTIMIZATION_LEVEL_DEFAULT,   /**< Default optimization level: balance code quality and compilation time. */
        SLANG_OPTIMIZATION_LEVEL_HIGH,      /**< Optimize aggressively. */
        SLANG_OPTIMIZATION_LEVEL_MAXIMAL,   /**< Include optimizations that may take a very long time, or may involve severe space-vs-speed tradeoffs */
    };

    /** A result code for a Slang API operation.

    This type is generally compatible with the Windows API `HRESULT` type. In particular, negative values indicate
    failure results, while zero or positive results indicate success.

    In general, Slang APIs always return a zero result on success, unless documented otherwise. Strictly speaking
    a negative value indicates an error, a positive (or 0) value indicates success. This can be tested for with the macros
    SLANG_SUCCEEDED(x) or SLANG_FAILED(x).

    It can represent if the call was successful or not. It can also specify in an extensible manner what facility
    produced the result (as the integral 'facility') as well as what caused it (as an integral 'code').
    Under the covers SlangResult is represented as a int32_t.

    SlangResult is designed to be compatible with COM HRESULT.

    It's layout in bits is as follows

    Severity | Facility | Code
    ---------|----------|-----
    31       |    30-16 | 15-0

    Severity - 1 fail, 0 is success - as SlangResult is signed 32 bits, means negative number indicates failure.
    Facility is where the error originated from. Code is the code specific to the facility.

    Result codes have the following styles,
    1) SLANG_name
    2) SLANG_s_f_name
    3) SLANG_s_name

    where s is S for success, E for error
    f is the short version of the facility name

    Style 1 is reserved for SLANG_OK and SLANG_FAIL as they are so commonly used.

    It is acceptable to expand 'f' to a longer name to differentiate a name or drop if unique without it.
    ie for a facility 'DRIVER' it might make sense to have an error of the form SLANG_E_DRIVER_OUT_OF_MEMORY
    */

    typedef int32_t SlangResult;

    //! Use to test if a result was failure. Never use result != SLANG_OK to test for failure, as there may be successful codes != SLANG_OK.
#define SLANG_FAILED(status) ((status) < 0)
    //! Use to test if a result succeeded. Never use result == SLANG_OK to test for success, as will detect other successful codes as a failure.
#define SLANG_SUCCEEDED(status) ((status) >= 0)

    //! Get the facility the result is associated with
#define SLANG_GET_RESULT_FACILITY(r)    ((int32_t)(((r) >> 16) & 0x7fff))
    //! Get the result code for the facility
#define SLANG_GET_RESULT_CODE(r)        ((int32_t)((r) & 0xffff))

#define SLANG_MAKE_ERROR(fac, code)        ((((int32_t)(fac)) << 16) | ((int32_t)(code)) | int32_t(0x80000000))
#define SLANG_MAKE_SUCCESS(fac, code)    ((((int32_t)(fac)) << 16) | ((int32_t)(code)))

    /*************************** Facilities ************************************/

    //! Facilities compatible with windows COM - only use if known code is compatible
#define SLANG_FACILITY_WIN_GENERAL      0
#define SLANG_FACILITY_WIN_INTERFACE    4
#define SLANG_FACILITY_WIN_API          7

    //! Base facility -> so as to not clash with HRESULT values (values in 0x200 range do not appear used)
#define SLANG_FACILITY_BASE         0x200

    /*! Facilities numbers must be unique across a project to make the resulting result a unique number.
    It can be useful to have a consistent short name for a facility, as used in the name prefix */
#define SLANG_FACILITY_CORE             SLANG_FACILITY_BASE
    /* Facility for codes, that are not uniquely defined/protected. Can be used to pass back a specific error without requiring system wide facility uniqueness. Codes
    should never be part of a public API. */
#define SLANG_FACILITY_INTERNAL         SLANG_FACILITY_BASE + 1

    /// Base for external facilities. Facilities should be unique across modules.
#define SLANG_FACILITY_EXTERNAL_BASE 0x210

    /* ************************ Win COM compatible Results ******************************/
    // https://msdn.microsoft.com/en-us/library/windows/desktop/aa378137(v=vs.85).aspx

    //! SLANG_OK indicates success, and is equivalent to SLANG_MAKE_SUCCESS(SLANG_FACILITY_WIN_GENERAL, 0)
#define SLANG_OK                          0
    //! SLANG_FAIL is the generic failure code - meaning a serious error occurred and the call couldn't complete
#define SLANG_FAIL                          SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, 0x4005)

#define SLANG_MAKE_WIN_GENERAL_ERROR(code)  SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, code)

    //! Functionality is not implemented
#define SLANG_E_NOT_IMPLEMENTED             SLANG_MAKE_WIN_GENERAL_ERROR(0x4001)
    //! Interface not be found
#define SLANG_E_NO_INTERFACE                SLANG_MAKE_WIN_GENERAL_ERROR(0x4002)
    //! Operation was aborted (did not correctly complete)
#define SLANG_E_ABORT                       SLANG_MAKE_WIN_GENERAL_ERROR(0x4004) 

    //! Indicates that a handle passed in as parameter to a method is invalid.
#define SLANG_E_INVALID_HANDLE              SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 6)
    //! Indicates that an argument passed in as parameter to a method is invalid.
#define SLANG_E_INVALID_ARG                 SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0x57)
    //! Operation could not complete - ran out of memory
#define SLANG_E_OUT_OF_MEMORY               SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0xe)

    /* *************************** other Results **************************************/

#define SLANG_MAKE_CORE_ERROR(code)         SLANG_MAKE_ERROR(SLANG_FACILITY_CORE, code)

    // Supplied buffer is too small to be able to complete
#define SLANG_E_BUFFER_TOO_SMALL            SLANG_MAKE_CORE_ERROR(1)
    //! Used to identify a Result that has yet to be initialized.
    //! It defaults to failure such that if used incorrectly will fail, as similar in concept to using an uninitialized variable.
#define SLANG_E_UNINITIALIZED               SLANG_MAKE_CORE_ERROR(2)
    //! Returned from an async method meaning the output is invalid (thus an error), but a result for the request is pending, and will be returned on a subsequent call with the async handle.
#define SLANG_E_PENDING                     SLANG_MAKE_CORE_ERROR(3)
    //! Indicates a file/resource could not be opened
#define SLANG_E_CANNOT_OPEN                 SLANG_MAKE_CORE_ERROR(4)
    //! Indicates a file/resource could not be found
#define SLANG_E_NOT_FOUND                   SLANG_MAKE_CORE_ERROR(5)
    //! An unhandled internal failure (typically from unhandled exception)
#define SLANG_E_INTERNAL_FAIL               SLANG_MAKE_CORE_ERROR(6)
    //! Could not complete because some underlying feature (hardware or software) was not available 
#define SLANG_E_NOT_AVAILABLE               SLANG_MAKE_CORE_ERROR(7)
        //! Could not complete because the operation times out. 
#define SLANG_E_TIME_OUT                    SLANG_MAKE_CORE_ERROR(8)

    /** A "Universally Unique Identifier" (UUID)

    The Slang API uses UUIDs to identify interfaces when
    using `queryInterface`.

    This type is compatible with the `GUID` type defined
    by the Component Object Model (COM), but Slang is
    not dependent on COM.
    */
    struct SlangUUID
    {
        uint32_t data1;
        uint16_t data2;
        uint16_t data3;
        uint8_t  data4[8];
    };

// Place at the start of an interface with the guid.
// Guid should be specified as SLANG_COM_INTERFACE(0x00000000, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 })
// NOTE: it's the typical guid struct definition, without the surrounding {}
// It is not necessary to use the multiple parameters (we can wrap in parens), but this is simple.
#define SLANG_COM_INTERFACE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
    public: \
    SLANG_FORCE_INLINE static const SlangUUID& getTypeGuid() \
    { \
        static const SlangUUID guid = { a, b, c, d0, d1, d2, d3, d4, d5, d6, d7 }; \
        return guid; \
    }

// Sometimes it's useful to associate a guid with a class to identify it. This macro can used for this,
// and the guid extracted via the getTypeGuid() function defined in the type
#define SLANG_CLASS_GUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
    SLANG_FORCE_INLINE static const SlangUUID& getTypeGuid() \
    { \
        static const SlangUUID guid = { a, b, c, d0, d1, d2, d3, d4, d5, d6, d7 }; \
        return guid; \
    }

    /** Base interface for components exchanged through the API.

    This interface definition is compatible with the COM `IUnknown`,
    and uses the same UUID, but Slang does not require applications
    to use or initialize COM.
    */
    struct ISlangUnknown
    {
        SLANG_COM_INTERFACE(0x00000000, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 })

        virtual SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) = 0;
        virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() = 0;
        virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() = 0;

        /*
        Inline methods are provided to allow the above operations to be called
        using their traditional COM names/signatures:
        */
        SlangResult QueryInterface(struct _GUID const& uuid, void** outObject) { return queryInterface(*(SlangUUID const*)&uuid, outObject); }
        uint32_t AddRef() { return addRef(); }
        uint32_t Release() { return release(); }
    };
    #define SLANG_UUID_ISlangUnknown ISlangUnknown::getTypeGuid()


    /* An interface to provide a mechanism to cast, that doesn't require ref counting
    and doesn't have to return a pointer to a ISlangUnknown derived class */
    class ISlangCastable : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(0x87ede0e1, 0x4852, 0x44b0, { 0x8b, 0xf2, 0xcb, 0x31, 0x87, 0x4d, 0xe2, 0x39 });

            /// Can be used to cast to interfaces without reference counting. 
            /// Also provides access to internal implementations, when they provide a guid
            /// Can simulate a 'generated' interface as long as kept in scope by cast from. 
        virtual SLANG_NO_THROW void* SLANG_MCALL castAs(const SlangUUID& guid) = 0;
    };

    class ISlangClonable : public ISlangCastable
    {
        SLANG_COM_INTERFACE(0x1ec36168, 0xe9f4, 0x430d, { 0xbb, 0x17, 0x4, 0x8a, 0x80, 0x46, 0xb3, 0x1f });

            /// Note the use of guid is for the desired interface/object.
            /// The object is returned *not* ref counted. Any type that can implements the interface, 
            /// derives from ICastable, and so (not withstanding some other issue) will always return
            /// an ICastable interface which other interfaces/types are accessible from via castAs
        SLANG_NO_THROW virtual void* SLANG_MCALL clone(const SlangUUID& guid) = 0;
    };

    /** A "blob" of binary data.

    This interface definition is compatible with the `ID3DBlob` and `ID3D10Blob` interfaces.
    */
    struct ISlangBlob : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(0x8BA5FB08, 0x5195, 0x40e2, { 0xAC, 0x58, 0x0D, 0x98, 0x9C, 0x3A, 0x01, 0x02 })

        virtual SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() = 0;
        virtual SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() = 0;
    };
    #define SLANG_UUID_ISlangBlob ISlangBlob::getTypeGuid()

    /* Can be requested from ISlangCastable cast to indicate the contained chars are null terminated.  
    */
    struct SlangTerminatedChars
    {
        SLANG_CLASS_GUID(0xbe0db1a8, 0x3594, 0x4603, { 0xa7, 0x8b, 0xc4, 0x86, 0x84, 0x30, 0xdf, 0xbb });
        operator const char*() const { return chars; }
        char chars[1];
    };

    /** A (real or virtual) file system.

    Slang can make use of this interface whenever it would otherwise try to load files
    from disk, allowing applications to hook and/or override filesystem access from
    the compiler.

    It is the responsibility of 
    the caller of any method that returns a ISlangBlob to release the blob when it is no 
    longer used (using 'release').
    */

    struct ISlangFileSystem : public ISlangCastable
    {
        SLANG_COM_INTERFACE(0x003A09FC, 0x3A4D, 0x4BA0, { 0xAD, 0x60, 0x1F, 0xD8, 0x63, 0xA9, 0x15, 0xAB })

        /** Load a file from `path` and return a blob of its contents
        @param path The path to load from, as a null-terminated UTF-8 string.
        @param outBlob A destination pointer to receive the blob of the file contents.
        @returns A `SlangResult` to indicate success or failure in loading the file.

        NOTE! This is a *binary* load - the blob should contain the exact same bytes
        as are found in the backing file. 

        If load is successful, the implementation should create a blob to hold
        the file's content, store it to `outBlob`, and return 0.
        If the load fails, the implementation should return a failure status
        (any negative value will do).
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadFile(
            char const*     path,
            ISlangBlob** outBlob) = 0;
    };
    #define SLANG_UUID_ISlangFileSystem ISlangFileSystem::getTypeGuid()


    typedef void(*SlangFuncPtr)(void);

    /** 
    (DEPRECIATED) ISlangSharedLibrary
    */
    struct ISlangSharedLibrary_Dep1: public ISlangUnknown
    {
        SLANG_COM_INTERFACE( 0x9c9d5bc5, 0xeb61, 0x496f,{ 0x80, 0xd7, 0xd1, 0x47, 0xc4, 0xa2, 0x37, 0x30 })

        virtual SLANG_NO_THROW void* SLANG_MCALL findSymbolAddressByName(char const* name) = 0;
    };
    #define SLANG_UUID_ISlangSharedLibrary_Dep1 ISlangSharedLibrary_Dep1::getTypeGuid()

    /** An interface that can be used to encapsulate access to a shared library. An implementation
    does not have to implement the library as a shared library
    */
    struct ISlangSharedLibrary : public ISlangCastable
    {
        SLANG_COM_INTERFACE(0x70dbc7c4, 0xdc3b, 0x4a07, { 0xae, 0x7e, 0x75, 0x2a, 0xf6, 0xa8, 0x15, 0x55 })

        /** Get a function by name. If the library is unloaded will only return nullptr.
        @param name The name of the function
        @return The function pointer related to the name or nullptr if not found
        */
        SLANG_FORCE_INLINE SlangFuncPtr findFuncByName(char const* name) { return (SlangFuncPtr)findSymbolAddressByName(name); }

        /** Get a symbol by name. If the library is unloaded will only return nullptr.
        @param name The name of the symbol
        @return The pointer related to the name or nullptr if not found
        */
        virtual SLANG_NO_THROW void* SLANG_MCALL findSymbolAddressByName(char const* name) = 0;
    };
    #define SLANG_UUID_ISlangSharedLibrary ISlangSharedLibrary::getTypeGuid()

    struct ISlangSharedLibraryLoader: public ISlangUnknown
    {
        SLANG_COM_INTERFACE(0x6264ab2b, 0xa3e8, 0x4a06, { 0x97, 0xf1, 0x49, 0xbc, 0x2d, 0x2a, 0xb1, 0x4d })

            /** Load a shared library. In typical usage the library name should *not* contain any platform
            specific elements. For example on windows a dll name should *not* be passed with a '.dll' extension,
            and similarly on linux a shared library should *not* be passed with the 'lib' prefix and '.so' extension
            @path path The unadorned filename and/or path for the shared library
            @ param sharedLibraryOut Holds the shared library if successfully loaded */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadSharedLibrary(
            const char*     path,
            ISlangSharedLibrary** sharedLibraryOut) = 0;
    };
    #define SLANG_UUID_ISlangSharedLibraryLoader ISlangSharedLibraryLoader::getTypeGuid()
    
    /* Type that identifies how a path should be interpreted */
    typedef unsigned int SlangPathTypeIntegral;
    enum SlangPathType : SlangPathTypeIntegral
    {
        SLANG_PATH_TYPE_DIRECTORY,      /**< Path specified specifies a directory. */
        SLANG_PATH_TYPE_FILE,           /**< Path specified is to a file. */
    };

    /* Callback to enumerate the contents of of a directory in a ISlangFileSystemExt.
    The name is the name of a file system object (directory/file) in the specified path (ie it is without a path) */
    typedef void (*FileSystemContentsCallBack)(SlangPathType pathType, const char* name, void* userData);

    /* Determines how paths map to files on the OS file system */
    enum class OSPathKind : uint8_t
    {
        None,                ///< Paths do not map to the file system
        Direct,              ///< Paths map directly to the file system
        OperatingSystem,     ///< Only paths gained via PathKind::OperatingSystem map to the operating system file system
    };

    /* Used to determine what kind of path is required from an input path */
    enum class PathKind
    {
            /// Given a path, returns a simplified version of that path.  
            /// This typically means removing '..' and/or '.' from the path.
            /// A simplified path must point to the same object as the original.
        Simplified,             

            /// Given a path, returns a 'canonical path' to the item. 
            /// This may be the operating system 'canonical path' that is the unique path to the item.
            /// 
            /// If the item exists the returned canonical path should always be usable to access the item.
            /// 
            /// If the item the path specifies doesn't exist, the canonical path may not be returnable
            /// or be a path simplification.             
            /// Not all file systems support canonical paths.
        Canonical,

            /// Given a path returns a path such that it is suitable to be displayed to the user.
            /// 
            /// For example if the file system is a zip file - it might include the path to the zip
            /// container as well as the path to the specific file.
            /// 
            /// NOTE! The display path won't necessarily work on the file system to access the item
        Display,

            /// Get the path to the item on the *operating system* file system, if available.
        OperatingSystem,

        CountOf,
    };

    /** An extended file system abstraction.
    
    Implementing and using this interface over ISlangFileSystem gives much more control over how paths
    are managed, as well as how it is determined if two files 'are the same'.

    All paths as input char*, or output as ISlangBlobs are always encoded as UTF-8 strings.
    Blobs that contain strings are always zero terminated.
    */
    struct ISlangFileSystemExt : public ISlangFileSystem
    {
        SLANG_COM_INTERFACE(0x5fb632d2, 0x979d, 0x4481, { 0x9f, 0xee, 0x66, 0x3c, 0x3f, 0x14, 0x49, 0xe1 })

        /** Get a uniqueIdentity which uniquely identifies an object of the file system.
           
        Given a path, returns a 'uniqueIdentity' which ideally is the same value for the same object on the file system.

        The uniqueIdentity is used to compare if two paths are the same - which amongst other things allows Slang to
        cache source contents internally. It is also used for #pragma once functionality.

        A *requirement* is for any implementation is that two paths can only return the same uniqueIdentity if the
        contents of the two files are *identical*. If an implementation breaks this constraint it can produce incorrect compilation.
        If an implementation cannot *strictly* identify *the same* files, this will only have an effect on #pragma once behavior.

        The string for the uniqueIdentity is held zero terminated in the ISlangBlob of outUniqueIdentity.
   
        Note that there are many ways a uniqueIdentity may be generated for a file. For example it could be the
        'canonical path' - assuming it is available and unambiguous for a file system. Another possible mechanism
        could be to store the filename combined with the file date time to uniquely identify it.
     
        The client must ensure the blob be released when no longer used, otherwise memory will leak.

        NOTE! Ideally this method would be called 'getPathUniqueIdentity' but for historical reasons and
        backward compatibility it's name remains with 'File' even though an implementation should be made to work
        with directories too.

        @param path
        @param outUniqueIdentity
        @returns A `SlangResult` to indicate success or failure getting the uniqueIdentity.
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getFileUniqueIdentity(
            const char* path,
            ISlangBlob** outUniqueIdentity) = 0;

        /** Calculate a path combining the 'fromPath' with 'path'

        The client must ensure the blob be released when no longer used, otherwise memory will leak.

        @param fromPathType How to interpret the from path - as a file or a directory.
        @param fromPath The from path. 
        @param path Path to be determined relative to the fromPath
        @param pathOut Holds the string which is the relative path. The string is held in the blob zero terminated.  
        @returns A `SlangResult` to indicate success or failure in loading the file.
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL calcCombinedPath(
            SlangPathType fromPathType,
            const char* fromPath,
            const char* path,
            ISlangBlob** pathOut) = 0;          
            
        /** Gets the type of path that path is on the file system. 
        @param path
        @param pathTypeOut
        @returns SLANG_OK if located and type is known, else an error. SLANG_E_NOT_FOUND if not found.
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getPathType(
            const char* path, 
            SlangPathType* pathTypeOut) = 0;

        /** Get a path based on the kind.

        @param kind The kind of path wanted
        @param path The input path
        @param outPath The output path held in a blob
        @returns SLANG_OK if successfully simplified the path (SLANG_E_NOT_IMPLEMENTED if not implemented, or some other error code)
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getPath(
            PathKind kind,
            const char* path,
            ISlangBlob** outPath) = 0;

        /** Clears any cached information */
        virtual SLANG_NO_THROW void SLANG_MCALL clearCache() = 0;

        /** Enumerate the contents of the path
        
        Note that for normal Slang operation it isn't necessary to enumerate contents this can return SLANG_E_NOT_IMPLEMENTED.
        
        @param The path to enumerate
        @param callback This callback is called for each entry in the path. 
        @param userData This is passed to the callback
        @returns SLANG_OK if successful 
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL enumeratePathContents(
            const char* path,
            FileSystemContentsCallBack callback,
            void* userData) = 0;

        /** Returns how paths map to the OS file system
        
        @returns OSPathKind that describes how paths map to the Operating System file system
        */
        virtual SLANG_NO_THROW OSPathKind SLANG_MCALL getOSPathKind() = 0;
    };

    #define SLANG_UUID_ISlangFileSystemExt ISlangFileSystemExt::getTypeGuid()

    struct ISlangMutableFileSystem : public ISlangFileSystemExt
    {
        SLANG_COM_INTERFACE(0xa058675c, 0x1d65, 0x452a, { 0x84, 0x58, 0xcc, 0xde, 0xd1, 0x42, 0x71, 0x5 })

        /** Write data to the specified path.

        @param path The path for data to be saved to
        @param data The data to be saved
        @param size The size of the data in bytes
        @returns SLANG_OK if successful (SLANG_E_NOT_IMPLEMENTED if not implemented, or some other error code)
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveFile(
            const char* path,
            const void* data,
            size_t size) = 0;

        /** Write data in the form of a blob to the specified path.

        Depending on the implementation writing a blob might be faster/use less memory. It is assumed the 
        blob is *immutable* and that an implementation can reference count it.

        It is not guaranteed loading the same file will return the *same* blob - just a blob with same 
        contents.

        @param path The path for data to be saved to
        @param dataBlob The data to be saved
        @returns SLANG_OK if successful (SLANG_E_NOT_IMPLEMENTED if not implemented, or some other error code)
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveFileBlob(
            const char* path,
            ISlangBlob* dataBlob) = 0;

        /** Remove the entry in the path (directory of file). Will only delete an empty directory, if not empty
        will return an error.

        @param path The path to remove 
        @returns SLANG_OK if successful 
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL remove(
            const char* path) = 0;

        /** Create a directory.

        The path to the directory must exist

        @param path To the directory to create. The parent path *must* exist otherwise will return an error.
        @returns SLANG_OK if successful 
        */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createDirectory(
            const char* path) = 0;
    };

    #define SLANG_UUID_ISlangMutableFileSystem ISlangMutableFileSystem::getTypeGuid()

    /* Identifies different types of writer target*/
    typedef unsigned int SlangWriterChannelIntegral;
    enum SlangWriterChannel : SlangWriterChannelIntegral
    {
        SLANG_WRITER_CHANNEL_DIAGNOSTIC,
        SLANG_WRITER_CHANNEL_STD_OUTPUT,
        SLANG_WRITER_CHANNEL_STD_ERROR,
        SLANG_WRITER_CHANNEL_COUNT_OF,
    };

    typedef unsigned int SlangWriterModeIntegral;
    enum SlangWriterMode : SlangWriterModeIntegral
    {
        SLANG_WRITER_MODE_TEXT,
        SLANG_WRITER_MODE_BINARY,
    };

    /** A stream typically of text, used for outputting diagnostic as well as other information.
    */
    struct ISlangWriter : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(0xec457f0e, 0x9add, 0x4e6b,{ 0x85, 0x1c, 0xd7, 0xfa, 0x71, 0x6d, 0x15, 0xfd })

            /** Begin an append buffer.
            NOTE! Only one append buffer can be active at any time.
            @param maxNumChars The maximum of chars that will be appended
            @returns The start of the buffer for appending to. */    
        virtual SLANG_NO_THROW char* SLANG_MCALL beginAppendBuffer(size_t maxNumChars) = 0;
            /** Ends the append buffer, and is equivalent to a write of the append buffer.
            NOTE! That an endAppendBuffer is not necessary if there are no characters to write.
            @param buffer is the start of the data to append and must be identical to last value returned from beginAppendBuffer
            @param numChars must be a value less than or equal to what was returned from last call to beginAppendBuffer
            @returns Result, will be SLANG_OK on success */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL endAppendBuffer(char* buffer, size_t numChars) = 0;
            /** Write text to the writer
            @param chars The characters to write out
            @param numChars The amount of characters
            @returns SLANG_OK on success */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL write(const char* chars, size_t numChars) = 0;
            /** Flushes any content to the output */
        virtual SLANG_NO_THROW void SLANG_MCALL flush() = 0;
            /** Determines if the writer stream is to the console, and can be used to alter the output 
            @returns Returns true if is a console writer */
        virtual SLANG_NO_THROW SlangBool SLANG_MCALL isConsole() = 0;
            /** Set the mode for the writer to use
            @param mode The mode to use
            @returns SLANG_OK on success */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setMode(SlangWriterMode mode) = 0;
    };
    
    #define SLANG_UUID_ISlangWriter ISlangWriter::getTypeGuid()

    namespace slang {
    struct IGlobalSession;
    struct ICompileRequest;

    } // namespace slang

    /*!
    @brief An instance of the Slang library.
    */
    typedef slang::IGlobalSession SlangSession;
    

    typedef struct SlangProgramLayout SlangProgramLayout;

    /*!
    @brief A request for one or more compilation actions to be performed.
    */
    typedef struct slang::ICompileRequest SlangCompileRequest;


    /*!
    @brief Initialize an instance of the Slang library.
    */
    SLANG_API SlangSession* spCreateSession(const char* deprecated = 0);

    /*!
    @brief Clean up after an instance of the Slang library.
    */
    SLANG_API void spDestroySession(
        SlangSession*   session);

    /** @see slang::IGlobalSession::setSharedLibraryLoader
    */
    SLANG_API void spSessionSetSharedLibraryLoader(
        SlangSession*               session,
        ISlangSharedLibraryLoader*  loader);

    /** @see slang::IGlobalSession::getSharedLibraryLoader
    */
    SLANG_API ISlangSharedLibraryLoader* spSessionGetSharedLibraryLoader(
        SlangSession*   session);

    /** @see slang::IGlobalSession::checkCompileTargetSupport
    */
    SLANG_API SlangResult spSessionCheckCompileTargetSupport(
        SlangSession*       session,
        SlangCompileTarget  target);

    /** @see slang::IGlobalSession::checkPassThroughSupport
    */
    SLANG_API SlangResult spSessionCheckPassThroughSupport(
        SlangSession*       session,
        SlangPassThrough    passThrough
    );

    /** @see slang::IGlobalSession::addBuiltins
    */
    SLANG_API void spAddBuiltins(
        SlangSession*   session,
        char const*     sourcePath,
        char const*     sourceString);

        /*!
    @brief Callback type used for diagnostic output. 
    */
    typedef void(*SlangDiagnosticCallback)(
        char const* message,
        void*       userData);

    /*!
    @brief Get the build version 'tag' string. The string is the same as produced via `git describe --tags`
    for the project. If Slang is built separately from the automated build scripts
    the contents will by default be 'unknown'. Any string can be set by changing the
    contents of 'slang-tag-version.h' file and recompiling the project.

    This function will return exactly the same result as the method getBuildTag string on IGlobalSession.

    An advantage of using this function over the method is that doing so does not require the creation of
    a session, which can be a fairly costly operation.

    @return The build tag string
    */
    SLANG_API const char* spGetBuildTagString();

    /* @see slang::IGlobalSession::createCompileRequest
    */
    SLANG_API SlangCompileRequest* spCreateCompileRequest(
        SlangSession* session);

    /*!
    @brief Destroy a compile request.
    Note a request is a COM object and can be destroyed via 'Release'.
    */
    SLANG_API void spDestroyCompileRequest(
        SlangCompileRequest*    request);

    /*! @see slang::ICompileRequest::setFileSystem */
    SLANG_API void spSetFileSystem(
        SlangCompileRequest*    request,
        ISlangFileSystem*       fileSystem);

    /*! @see slang::ICompileRequest::setCompileFlags */
    SLANG_API void spSetCompileFlags(
        SlangCompileRequest*    request,
        SlangCompileFlags       flags);

    /*! @see slang::ICompileRequest::getCompileFlags */
    SLANG_API SlangCompileFlags spGetCompileFlags(
        SlangCompileRequest*    request);

    /*! @see slang::ICompileRequest::setDumpIntermediates */
    SLANG_API void spSetDumpIntermediates(
        SlangCompileRequest*    request,
        int                     enable);

    /*! @see slang::ICompileRequest::setDumpIntermediatePrefix */
    SLANG_API void spSetDumpIntermediatePrefix(
        SlangCompileRequest*    request,
        const char* prefix);

    /*! DEPRECATED: use `spSetTargetLineDirectiveMode` instead.
        @see slang::ICompileRequest::setLineDirectiveMode */
    SLANG_API void spSetLineDirectiveMode(
        SlangCompileRequest*    request,
        SlangLineDirectiveMode  mode);
        
    /*! @see slang::ICompileRequest::setTargetLineDirectiveMode */
    SLANG_API void spSetTargetLineDirectiveMode(
        SlangCompileRequest*    request,
        int targetIndex,
        SlangLineDirectiveMode  mode);

    /*! @see slang::ICompileRequest::setTargetLineDirectiveMode */
    SLANG_API void spSetTargetForceGLSLScalarBufferLayout(
        SlangCompileRequest*    request,
        int targetIndex,
        bool forceScalarLayout);

    /*! @see slang::ICompileRequest::setCodeGenTarget */
    SLANG_API void spSetCodeGenTarget(
        SlangCompileRequest*    request,
        SlangCompileTarget target);

    /*! @see slang::ICompileRequest::addCodeGenTarget */
    SLANG_API int spAddCodeGenTarget(
        SlangCompileRequest*    request,
        SlangCompileTarget      target);

    /*! @see slang::ICompileRequest::setTargetProfile */
    SLANG_API void spSetTargetProfile(
        SlangCompileRequest*    request,
        int                     targetIndex,
        SlangProfileID          profile);

    /*! @see slang::ICompileRequest::setTargetFlags */
    SLANG_API void spSetTargetFlags(
        SlangCompileRequest*    request,
        int                     targetIndex,
        SlangTargetFlags        flags);



    /*! @see slang::ICompileRequest::setTargetFloatingPointMode */
    SLANG_API void spSetTargetFloatingPointMode(
        SlangCompileRequest*    request,
        int                     targetIndex,
        SlangFloatingPointMode  mode);

    /*! @see slang::ICompileRequest::addTargetCapability */
    SLANG_API void spAddTargetCapability(
        slang::ICompileRequest* request,
        int                     targetIndex,
        SlangCapabilityID       capability);

    /* DEPRECATED: use `spSetMatrixLayoutMode` instead. */
    SLANG_API void spSetTargetMatrixLayoutMode(
        SlangCompileRequest*    request,
        int                     targetIndex,
        SlangMatrixLayoutMode   mode);

    /*! @see slang::ICompileRequest::setMatrixLayoutMode */
    SLANG_API void spSetMatrixLayoutMode(
        SlangCompileRequest*    request,
        SlangMatrixLayoutMode   mode);

    /*! @see slang::ICompileRequest::setDebugInfoLevel */
    SLANG_API void spSetDebugInfoLevel(
        SlangCompileRequest*    request,
        SlangDebugInfoLevel     level);

    /*! @see slang::ICompileRequest::setOptimizationLevel */
    SLANG_API void spSetOptimizationLevel(
        SlangCompileRequest*    request,
        SlangOptimizationLevel  level);


    
    /*! @see slang::ICompileRequest::setOutputContainerFormat */
    SLANG_API void spSetOutputContainerFormat(
        SlangCompileRequest*    request,
        SlangContainerFormat    format);

    /*! @see slang::ICompileRequest::setPassThrough */
    SLANG_API void spSetPassThrough(
        SlangCompileRequest*    request,
        SlangPassThrough        passThrough);

     /*! @see slang::ICompileRequest::setDiagnosticCallback */
    SLANG_API void spSetDiagnosticCallback(
        SlangCompileRequest*    request,
        SlangDiagnosticCallback callback,
        void const*             userData);

    /*! @see slang::ICompileRequest::setWriter */
    SLANG_API void spSetWriter(
        SlangCompileRequest*    request,
        SlangWriterChannel      channel, 
        ISlangWriter*           writer);

    /*! @see slang::ICompileRequest::getWriter */
    SLANG_API ISlangWriter* spGetWriter(
        SlangCompileRequest*    request,
        SlangWriterChannel      channel);

    /*! @see slang::ICompileRequest::addSearchPath */
    SLANG_API void spAddSearchPath(
        SlangCompileRequest*    request,
        const char*             searchDir);

   /*! @see slang::ICompileRequest::addPreprocessorDefine */
    SLANG_API void spAddPreprocessorDefine(
        SlangCompileRequest*    request,
        const char*             key,
        const char*             value);

    /*! @see slang::ICompileRequest::processCommandLineArguments */
    SLANG_API SlangResult spProcessCommandLineArguments(
        SlangCompileRequest*    request,
        char const* const*      args,
        int                     argCount);

    /*! @see slang::ICompileRequest::addTranslationUnit */
    SLANG_API int spAddTranslationUnit(
        SlangCompileRequest*    request,
        SlangSourceLanguage     language,
        char const*             name);

    
    /*! @see slang::ICompileRequest::setDefaultModuleName */
    SLANG_API void spSetDefaultModuleName(
        SlangCompileRequest*    request,
        const char* defaultModuleName);

    /*! @see slang::ICompileRequest::addPreprocessorDefine */
    SLANG_API void spTranslationUnit_addPreprocessorDefine(
        SlangCompileRequest*    request,
        int                     translationUnitIndex,
        const char*             key,
        const char*             value);


    /*! @see slang::ICompileRequest::addTranslationUnitSourceFile */
    SLANG_API void spAddTranslationUnitSourceFile(
        SlangCompileRequest*    request,
        int                     translationUnitIndex,
        char const*             path);

    /*! @see slang::ICompileRequest::addTranslationUnitSourceString */
    SLANG_API void spAddTranslationUnitSourceString(
        SlangCompileRequest*    request,
        int                     translationUnitIndex,
        char const*             path,
        char const*             source);


    /*! @see slang::ICompileRequest::addLibraryReference */
    SLANG_API SlangResult spAddLibraryReference(
        SlangCompileRequest*    request,
        const void* libData,
        size_t libDataSize);

    /*! @see slang::ICompileRequest::addTranslationUnitSourceStringSpan */
    SLANG_API void spAddTranslationUnitSourceStringSpan(
        SlangCompileRequest*    request,
        int                     translationUnitIndex,
        char const*             path,
        char const*             sourceBegin,
        char const*             sourceEnd);

    /*! @see slang::ICompileRequest::addTranslationUnitSourceBlob */
    SLANG_API void spAddTranslationUnitSourceBlob(
        SlangCompileRequest*    request,
        int                     translationUnitIndex,
        char const*             path,
        ISlangBlob*             sourceBlob);

    /*! @see slang::IGlobalSession::findProfile */
    SLANG_API SlangProfileID spFindProfile(
        SlangSession*   session,
        char const*     name);

    /*! @see slang::IGlobalSession::findCapability */
    SLANG_API SlangCapabilityID spFindCapability(
        SlangSession*   session,
        char const*     name);

    /*! @see slang::ICompileRequest::addEntryPoint */
    SLANG_API int spAddEntryPoint(
        SlangCompileRequest*    request,
        int                     translationUnitIndex,
        char const*             name,
        SlangStage              stage);

    /*! @see slang::ICompileRequest::addEntryPointEx */
    SLANG_API int spAddEntryPointEx(
        SlangCompileRequest*    request,
        int                     translationUnitIndex,
        char const*             name,
        SlangStage              stage,
        int                     genericArgCount,
        char const**            genericArgs);

    /*! @see slang::ICompileRequest::setGlobalGenericArgs */
    SLANG_API SlangResult spSetGlobalGenericArgs(
        SlangCompileRequest*    request,
        int                     genericArgCount,
        char const**            genericArgs);

    /*! @see slang::ICompileRequest::setTypeNameForGlobalExistentialTypeParam */
    SLANG_API SlangResult spSetTypeNameForGlobalExistentialTypeParam(
        SlangCompileRequest*    request,
        int                     slotIndex,
        char const*             typeName);

    /*! @see slang::ICompileRequest::setTypeNameForEntryPointExistentialTypeParam */
    SLANG_API SlangResult spSetTypeNameForEntryPointExistentialTypeParam(
        SlangCompileRequest*    request,
        int                     entryPointIndex,
        int                     slotIndex,
        char const*             typeName);

    /*! @see slang::ICompileRequest::compile */
    SLANG_API SlangResult spCompile(
        SlangCompileRequest*    request);


    /*! @see slang::ICompileRequest::getDiagnosticOutput */
    SLANG_API char const* spGetDiagnosticOutput(
        SlangCompileRequest*    request);

    /*! @see slang::ICompileRequest::getDiagnosticOutputBlob */
    SLANG_API SlangResult spGetDiagnosticOutputBlob(
        SlangCompileRequest*    request,
        ISlangBlob**            outBlob);


    /*! @see slang::ICompileRequest::getDependencyFileCount */
    SLANG_API int
    spGetDependencyFileCount(
        SlangCompileRequest*    request);

    /*! @see slang::ICompileRequest::getDependencyFilePath */
    SLANG_API char const*
    spGetDependencyFilePath(
        SlangCompileRequest*    request,
        int                     index);

    /*! @see slang::ICompileRequest::getTranslationUnitCount */
    SLANG_API int
    spGetTranslationUnitCount(
        SlangCompileRequest*    request);

    /*! @see slang::ICompileRequest::getEntryPointSource */
    SLANG_API char const* spGetEntryPointSource(
        SlangCompileRequest*    request,
        int                     entryPointIndex);

    /*! @see slang::ICompileRequest::getEntryPointCode */
    SLANG_API void const* spGetEntryPointCode(
        SlangCompileRequest*    request,
        int                     entryPointIndex,
        size_t*                 outSize);

    /*! @see slang::ICompileRequest::getEntryPointCodeBlob */
    SLANG_API SlangResult spGetEntryPointCodeBlob(
        SlangCompileRequest*    request,
        int                     entryPointIndex,
        int                     targetIndex,
        ISlangBlob**            outBlob);

    /*! @see slang::ICompileRequest::getEntryPointHostCallable */
    SLANG_API SlangResult spGetEntryPointHostCallable(
        SlangCompileRequest*    request,
        int                     entryPointIndex,
        int                     targetIndex,
        ISlangSharedLibrary**   outSharedLibrary);

    /*! @see slang::ICompileRequest::getTargetCodeBlob */
    SLANG_API SlangResult spGetTargetCodeBlob(
        SlangCompileRequest*    request,
        int                     targetIndex,
        ISlangBlob**            outBlob);

    /*! @see slang::ICompileRequest::getTargetHostCallable */
    SLANG_API SlangResult spGetTargetHostCallable(
        SlangCompileRequest*    request,
        int                     targetIndex,
        ISlangSharedLibrary**   outSharedLibrary);

    /*! @see slang::ICompileRequest::getCompileRequestCode */
    SLANG_API void const* spGetCompileRequestCode(
        SlangCompileRequest*    request,
        size_t*                 outSize);

    /*! @see slang::ICompileRequest::getContainerCode */
    SLANG_API SlangResult spGetContainerCode(
        SlangCompileRequest*    request,
        ISlangBlob**            outBlob);

    /*! @see slang::ICompileRequest::loadRepro */
    SLANG_API SlangResult spLoadRepro(
        SlangCompileRequest* request,
        ISlangFileSystem* fileSystem,
        const void* data,
        size_t size);

    /*! @see slang::ICompileRequest::saveRepro */
    SLANG_API SlangResult spSaveRepro(
        SlangCompileRequest* request,
        ISlangBlob** outBlob
    );

    /*! @see slang::ICompileRequest::enableReproCapture */
    SLANG_API SlangResult spEnableReproCapture(
        SlangCompileRequest* request);


    /** Extract contents of a repro.

    Writes the contained files and manifest with their 'unique' names into fileSystem. For more details read the
    docs/repro.md documentation. 

    @param session          The slang session
    @param reproData        Holds the repro data
    @param reproDataSize    The size of the repro data
    @param fileSystem       File system that the contents of the repro will be written to
    @returns                A `SlangResult` to indicate success or failure.
    */
    SLANG_API SlangResult spExtractRepro(
        SlangSession* session,
        const void* reproData,
        size_t reproDataSize,
        ISlangMutableFileSystem* fileSystem);

    /* Turns a repro into a file system.

    Makes the contents of the repro available as a file system - that is able to access the files with the same
    paths as were used on the original repro file system. 

    @param session          The slang session
    @param reproData        The repro data
    @param reproDataSize    The size of the repro data
    @param replaceFileSystem  Will attempt to load by unique names from this file system before using contents of the repro. Optional.
    @param outFileSystem    The file system that can be used to access contents
    @returns                A `SlangResult` to indicate success or failure.
    */
    SLANG_API SlangResult spLoadReproAsFileSystem(
        SlangSession* session,
        const void* reproData,
        size_t reproDataSize,
        ISlangFileSystem* replaceFileSystem,
        ISlangFileSystemExt** outFileSystem);

    /*! @see slang::ICompileRequest::overrideDiagnosticSeverity */
    SLANG_API void spOverrideDiagnosticSeverity(
        SlangCompileRequest* request,
        SlangInt messageID,
        SlangSeverity overrideSeverity);

    /*! @see slang::ICompileRequest::getDiagnosticFlags */
    SLANG_API SlangDiagnosticFlags spGetDiagnosticFlags(SlangCompileRequest* request);

    /*! @see slang::ICompileRequest::setDiagnosticFlags */
    SLANG_API void spSetDiagnosticFlags(SlangCompileRequest* request, SlangDiagnosticFlags flags);

    /*
    Forward declarations of types used in the reflection interface;
    */

    typedef struct SlangProgramLayout SlangProgramLayout;
    typedef struct SlangEntryPoint SlangEntryPoint;
    typedef struct SlangEntryPointLayout SlangEntryPointLayout;

    typedef struct SlangReflectionModifier          SlangReflectionModifier;
    typedef struct SlangReflectionType              SlangReflectionType;
    typedef struct SlangReflectionTypeLayout        SlangReflectionTypeLayout;
    typedef struct SlangReflectionVariable          SlangReflectionVariable;
    typedef struct SlangReflectionVariableLayout    SlangReflectionVariableLayout;
    typedef struct SlangReflectionTypeParameter     SlangReflectionTypeParameter;
    typedef struct SlangReflectionUserAttribute     SlangReflectionUserAttribute;

    /*
    Type aliases to maintain backward compatibility.
    */
    typedef SlangProgramLayout SlangReflection;
    typedef SlangEntryPointLayout SlangReflectionEntryPoint;

    // get reflection data from a compilation request
    SLANG_API SlangReflection* spGetReflection(
        SlangCompileRequest*    request);

    // type reflection

    typedef unsigned int SlangTypeKindIntegral;
    enum SlangTypeKind : SlangTypeKindIntegral
    {
        SLANG_TYPE_KIND_NONE,
        SLANG_TYPE_KIND_STRUCT,
        SLANG_TYPE_KIND_ARRAY,
        SLANG_TYPE_KIND_MATRIX,
        SLANG_TYPE_KIND_VECTOR,
        SLANG_TYPE_KIND_SCALAR,
        SLANG_TYPE_KIND_CONSTANT_BUFFER,
        SLANG_TYPE_KIND_RESOURCE,
        SLANG_TYPE_KIND_SAMPLER_STATE,
        SLANG_TYPE_KIND_TEXTURE_BUFFER,
        SLANG_TYPE_KIND_SHADER_STORAGE_BUFFER,
        SLANG_TYPE_KIND_PARAMETER_BLOCK,
        SLANG_TYPE_KIND_GENERIC_TYPE_PARAMETER,
        SLANG_TYPE_KIND_INTERFACE,
        SLANG_TYPE_KIND_OUTPUT_STREAM,
        SLANG_TYPE_KIND_MESH_OUTPUT,
        SLANG_TYPE_KIND_SPECIALIZED,
        SLANG_TYPE_KIND_FEEDBACK,
        SLANG_TYPE_KIND_COUNT,
    };

    typedef unsigned int SlangScalarTypeIntegral;
    enum SlangScalarType : SlangScalarTypeIntegral
    {
        SLANG_SCALAR_TYPE_NONE,
        SLANG_SCALAR_TYPE_VOID,
        SLANG_SCALAR_TYPE_BOOL,
        SLANG_SCALAR_TYPE_INT32,
        SLANG_SCALAR_TYPE_UINT32,
        SLANG_SCALAR_TYPE_INT64,
        SLANG_SCALAR_TYPE_UINT64,
        SLANG_SCALAR_TYPE_FLOAT16,
        SLANG_SCALAR_TYPE_FLOAT32,
        SLANG_SCALAR_TYPE_FLOAT64,
        SLANG_SCALAR_TYPE_INT8,
        SLANG_SCALAR_TYPE_UINT8,
        SLANG_SCALAR_TYPE_INT16,
        SLANG_SCALAR_TYPE_UINT16,
        SLANG_SCALAR_TYPE_INTPTR,
        SLANG_SCALAR_TYPE_UINTPTR
    };

#ifndef SLANG_RESOURCE_SHAPE
#    define SLANG_RESOURCE_SHAPE
    typedef unsigned int SlangResourceShapeIntegral;
    enum SlangResourceShape : SlangResourceShapeIntegral
    {
        SLANG_RESOURCE_BASE_SHAPE_MASK      = 0x0F,

        SLANG_RESOURCE_NONE                 = 0x00,

        SLANG_TEXTURE_1D                    = 0x01,
        SLANG_TEXTURE_2D                    = 0x02,
        SLANG_TEXTURE_3D                    = 0x03,
        SLANG_TEXTURE_CUBE                  = 0x04,
        SLANG_TEXTURE_BUFFER                = 0x05,

        SLANG_STRUCTURED_BUFFER             = 0x06,
        SLANG_BYTE_ADDRESS_BUFFER           = 0x07,
        SLANG_RESOURCE_UNKNOWN              = 0x08,
        SLANG_ACCELERATION_STRUCTURE        = 0x09,

        SLANG_RESOURCE_EXT_SHAPE_MASK       = 0xF0,

        SLANG_TEXTURE_FEEDBACK_FLAG         = 0x10,
        SLANG_TEXTURE_ARRAY_FLAG            = 0x40,
        SLANG_TEXTURE_MULTISAMPLE_FLAG      = 0x80,

        SLANG_TEXTURE_1D_ARRAY              = SLANG_TEXTURE_1D   | SLANG_TEXTURE_ARRAY_FLAG,
        SLANG_TEXTURE_2D_ARRAY              = SLANG_TEXTURE_2D   | SLANG_TEXTURE_ARRAY_FLAG,
        SLANG_TEXTURE_CUBE_ARRAY            = SLANG_TEXTURE_CUBE | SLANG_TEXTURE_ARRAY_FLAG,

        SLANG_TEXTURE_2D_MULTISAMPLE        = SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG,
        SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY  = SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG | SLANG_TEXTURE_ARRAY_FLAG,
    };
#endif
    typedef unsigned int SlangResourceAccessIntegral;
    enum SlangResourceAccess : SlangResourceAccessIntegral
    {
        SLANG_RESOURCE_ACCESS_NONE,
        SLANG_RESOURCE_ACCESS_READ,
        SLANG_RESOURCE_ACCESS_READ_WRITE,
        SLANG_RESOURCE_ACCESS_RASTER_ORDERED,
        SLANG_RESOURCE_ACCESS_APPEND,
        SLANG_RESOURCE_ACCESS_CONSUME,
        SLANG_RESOURCE_ACCESS_WRITE,
    };

    typedef unsigned int SlangParameterCategoryIntegral;
    enum SlangParameterCategory : SlangParameterCategoryIntegral
    {
        SLANG_PARAMETER_CATEGORY_NONE,
        SLANG_PARAMETER_CATEGORY_MIXED,
        SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
        SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
        SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS,
        SLANG_PARAMETER_CATEGORY_VARYING_INPUT,
        SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT,
        SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
        SLANG_PARAMETER_CATEGORY_UNIFORM,
        SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT,
        SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT,
        SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER,

        // HLSL register `space`, Vulkan GLSL `set`
        SLANG_PARAMETER_CATEGORY_REGISTER_SPACE,

        // TODO: Ellie, Both APIs treat mesh outputs as more or less varying output,
        // Does it deserve to be represented here??

        // A parameter whose type is to be specialized by a global generic type argument
        SLANG_PARAMETER_CATEGORY_GENERIC,

        SLANG_PARAMETER_CATEGORY_RAY_PAYLOAD,
        SLANG_PARAMETER_CATEGORY_HIT_ATTRIBUTES,
        SLANG_PARAMETER_CATEGORY_CALLABLE_PAYLOAD,
        SLANG_PARAMETER_CATEGORY_SHADER_RECORD,

        // An existential type parameter represents a "hole" that
        // needs to be filled with a concrete type to enable
        // generation of specialized code.
        //
        // Consider this example:
        //
        //      struct MyParams
        //      {
        //          IMaterial material;
        //          ILight lights[3];
        //      };
        //
        // This `MyParams` type introduces two existential type parameters:
        // one for `material` and one for `lights`. Even though `lights`
        // is an array, it only introduces one type parameter, because
        // we need to hae a *single* concrete type for all the array
        // elements to be able to generate specialized code.
        //
        SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM,

        // An existential object parameter represents a value
        // that needs to be passed in to provide data for some
        // interface-type shader paameter.
        //
        // Consider this example:
        //
        //      struct MyParams
        //      {
        //          IMaterial material;
        //          ILight lights[3];
        //      };
        //
        // This `MyParams` type introduces four existential object parameters:
        // one for `material` and three for `lights` (one for each array
        // element). This is consistent with the number of interface-type
        // "objects" that are being passed through to the shader.
        //
        SLANG_PARAMETER_CATEGORY_EXISTENTIAL_OBJECT_PARAM,

        //
        SLANG_PARAMETER_CATEGORY_COUNT,


        // DEPRECATED:
        SLANG_PARAMETER_CATEGORY_VERTEX_INPUT = SLANG_PARAMETER_CATEGORY_VARYING_INPUT,
        SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT = SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT,
    };

    /** Types of API-managed bindings that a parameter might use.
    
    `SlangBindingType` represents the distinct types of binding ranges that might be
    understood by an underlying graphics API or cross-API abstraction layer.
    Several of the enumeration cases here correspond to cases of `VkDescriptorType`
    defined by the Vulkan API. Note however that the values of this enumeration
    are not the same as those of any particular API.

    The `SlangBindingType` enumeration is distinct from `SlangParameterCategory`
    because `SlangParameterCategory` differentiates the types of parameters for
    the purposes of layout, where the layout rules of some targets will treat
    parameters of different types as occupying the same binding space for layout
    (e.g., in SPIR-V both a `Texture2D` and `SamplerState` use the same space of
    `binding` indices, and are not allowed to overlap), while those same types
    map to different types of bindingsin the API (e.g., both textures and samplers
    use different `VkDescriptorType` values).

    When you want to answer "what register/binding did this parameter use?" you
    should use `SlangParameterCategory`.

    When you wnat to answer "what type of descriptor range should this parameter use?"
    you should use `SlangBindingType`.
    */
    typedef SlangUInt32 SlangBindingTypeIntegral;
    enum SlangBindingType : SlangBindingTypeIntegral
    {
        SLANG_BINDING_TYPE_UNKNOWN = 0,

        SLANG_BINDING_TYPE_SAMPLER,
        SLANG_BINDING_TYPE_TEXTURE,
        SLANG_BINDING_TYPE_CONSTANT_BUFFER,
        SLANG_BINDING_TYPE_PARAMETER_BLOCK,
        SLANG_BINDING_TYPE_TYPED_BUFFER,
        SLANG_BINDING_TYPE_RAW_BUFFER,
        SLANG_BINDING_TYPE_COMBINED_TEXTURE_SAMPLER,
        SLANG_BINDING_TYPE_INPUT_RENDER_TARGET,
        SLANG_BINDING_TYPE_INLINE_UNIFORM_DATA,
        SLANG_BINDING_TYPE_RAY_TRACTING_ACCELERATION_STRUCTURE,

        SLANG_BINDING_TYPE_VARYING_INPUT,
        SLANG_BINDING_TYPE_VARYING_OUTPUT,

        SLANG_BINDING_TYPE_EXISTENTIAL_VALUE,
        SLANG_BINDING_TYPE_PUSH_CONSTANT,

        SLANG_BINDING_TYPE_MUTABLE_FLAG = 0x100,

        SLANG_BINDING_TYPE_MUTABLE_TETURE = SLANG_BINDING_TYPE_TEXTURE | SLANG_BINDING_TYPE_MUTABLE_FLAG,
        SLANG_BINDING_TYPE_MUTABLE_TYPED_BUFFER = SLANG_BINDING_TYPE_TYPED_BUFFER | SLANG_BINDING_TYPE_MUTABLE_FLAG,
        SLANG_BINDING_TYPE_MUTABLE_RAW_BUFFER = SLANG_BINDING_TYPE_RAW_BUFFER | SLANG_BINDING_TYPE_MUTABLE_FLAG,

        SLANG_BINDING_TYPE_BASE_MASK = 0x00FF,
        SLANG_BINDING_TYPE_EXT_MASK  = 0xFF00,
    };

    typedef SlangUInt32 SlangLayoutRulesIntegral;
    enum SlangLayoutRules : SlangLayoutRulesIntegral
    {
        SLANG_LAYOUT_RULES_DEFAULT,
    };

    typedef SlangUInt32 SlangModifierIDIntegral;
    enum SlangModifierID : SlangModifierIDIntegral
    {
        SLANG_MODIFIER_SHARED,
    };

    // User Attribute
    SLANG_API char const* spReflectionUserAttribute_GetName(SlangReflectionUserAttribute* attrib);
    SLANG_API unsigned int spReflectionUserAttribute_GetArgumentCount(SlangReflectionUserAttribute* attrib);
    SLANG_API SlangReflectionType* spReflectionUserAttribute_GetArgumentType(SlangReflectionUserAttribute* attrib, unsigned int index);
    SLANG_API SlangResult spReflectionUserAttribute_GetArgumentValueInt(SlangReflectionUserAttribute* attrib, unsigned int index, int * rs);
    SLANG_API SlangResult spReflectionUserAttribute_GetArgumentValueFloat(SlangReflectionUserAttribute* attrib, unsigned int index, float * rs);

    /** Returns the string-typed value of a user attribute argument
        The string returned is not null-terminated. The length of the string is returned via `outSize`.
        If index of out of range, or if the specified argument is not a string, the function will return nullptr.
    */
    SLANG_API const char* spReflectionUserAttribute_GetArgumentValueString(SlangReflectionUserAttribute* attrib, unsigned int index, size_t * outSize);

    // Type Reflection

    SLANG_API SlangTypeKind spReflectionType_GetKind(SlangReflectionType* type);
    SLANG_API unsigned int spReflectionType_GetUserAttributeCount(SlangReflectionType* type);
    SLANG_API SlangReflectionUserAttribute* spReflectionType_GetUserAttribute(SlangReflectionType* type, unsigned int index);
    SLANG_API SlangReflectionUserAttribute* spReflectionType_FindUserAttributeByName(SlangReflectionType* type, char const* name);

    SLANG_API unsigned int spReflectionType_GetFieldCount(SlangReflectionType* type);
    SLANG_API SlangReflectionVariable* spReflectionType_GetFieldByIndex(SlangReflectionType* type, unsigned index);

        /** Returns the number of elements in the given type.

        This operation is valid for vector and array types. For other types it returns zero.

        When invoked on an unbounded-size array it will return `SLANG_UNBOUNDED_SIZE`,
        which is defined to be `~size_t(0)`.

        If the size of a type cannot be statically computed, perhaps because it depends on
        a generic parameter that has not been bound to a specific value, this function returns zero.
        */
    SLANG_API size_t spReflectionType_GetElementCount(SlangReflectionType* type);

    #define SLANG_UNBOUNDED_SIZE (~size_t(0))

    SLANG_API SlangReflectionType* spReflectionType_GetElementType(SlangReflectionType* type);

    SLANG_API unsigned int spReflectionType_GetRowCount(SlangReflectionType* type);
    SLANG_API unsigned int spReflectionType_GetColumnCount(SlangReflectionType* type);
    SLANG_API SlangScalarType spReflectionType_GetScalarType(SlangReflectionType* type);

    SLANG_API SlangResourceShape spReflectionType_GetResourceShape(SlangReflectionType* type);
    SLANG_API SlangResourceAccess spReflectionType_GetResourceAccess(SlangReflectionType* type);
    SLANG_API SlangReflectionType* spReflectionType_GetResourceResultType(SlangReflectionType* type);

    SLANG_API char const* spReflectionType_GetName(SlangReflectionType* type);

    // Type Layout Reflection

    SLANG_API SlangReflectionType* spReflectionTypeLayout_GetType(SlangReflectionTypeLayout* type);
    SLANG_API SlangTypeKind spReflectionTypeLayout_getKind(SlangReflectionTypeLayout* type);
    SLANG_API size_t spReflectionTypeLayout_GetSize(SlangReflectionTypeLayout* type, SlangParameterCategory category);
    SLANG_API size_t spReflectionTypeLayout_GetStride(SlangReflectionTypeLayout* type, SlangParameterCategory category);
    SLANG_API int32_t spReflectionTypeLayout_getAlignment(SlangReflectionTypeLayout* type, SlangParameterCategory category);

    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_GetFieldByIndex(SlangReflectionTypeLayout* type, unsigned index);

    SLANG_API SlangInt spReflectionTypeLayout_findFieldIndexByName(SlangReflectionTypeLayout* typeLayout, const char* nameBegin, const char* nameEnd);

    SLANG_API size_t spReflectionTypeLayout_GetElementStride(SlangReflectionTypeLayout* type, SlangParameterCategory category);
    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_GetElementTypeLayout(SlangReflectionTypeLayout* type);
    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_GetElementVarLayout(SlangReflectionTypeLayout* type);
    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_getContainerVarLayout(SlangReflectionTypeLayout* type);

    SLANG_API SlangParameterCategory spReflectionTypeLayout_GetParameterCategory(SlangReflectionTypeLayout* type);

    SLANG_API unsigned spReflectionTypeLayout_GetCategoryCount(SlangReflectionTypeLayout* type);
    SLANG_API SlangParameterCategory spReflectionTypeLayout_GetCategoryByIndex(SlangReflectionTypeLayout* type, unsigned index);

    SLANG_API SlangMatrixLayoutMode spReflectionTypeLayout_GetMatrixLayoutMode(SlangReflectionTypeLayout* type);

    SLANG_API int spReflectionTypeLayout_getGenericParamIndex(SlangReflectionTypeLayout* type);

    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_getPendingDataTypeLayout(SlangReflectionTypeLayout* type);

    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_getSpecializedTypePendingDataVarLayout(SlangReflectionTypeLayout* type);
    SLANG_API SlangInt spReflectionType_getSpecializedTypeArgCount(SlangReflectionType* type);
    SLANG_API SlangReflectionType* spReflectionType_getSpecializedTypeArgType(SlangReflectionType* type, SlangInt index);

    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeCount(SlangReflectionTypeLayout* typeLayout);
    SLANG_API SlangBindingType spReflectionTypeLayout_getBindingRangeType(SlangReflectionTypeLayout* typeLayout, SlangInt index);
    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeBindingCount(SlangReflectionTypeLayout* typeLayout, SlangInt index);
    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_getBindingRangeLeafTypeLayout(SlangReflectionTypeLayout* typeLayout, SlangInt index);
    SLANG_API SlangReflectionVariable* spReflectionTypeLayout_getBindingRangeLeafVariable(SlangReflectionTypeLayout* typeLayout, SlangInt index);
    SLANG_API SlangInt spReflectionTypeLayout_getFieldBindingRangeOffset(SlangReflectionTypeLayout* typeLayout, SlangInt fieldIndex);

    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeDescriptorSetIndex(SlangReflectionTypeLayout* typeLayout, SlangInt index);
    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeFirstDescriptorRangeIndex(SlangReflectionTypeLayout* typeLayout, SlangInt index);
    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeDescriptorRangeCount(SlangReflectionTypeLayout* typeLayout, SlangInt index);

    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetCount(SlangReflectionTypeLayout* typeLayout);
    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetSpaceOffset(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex);
    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetDescriptorRangeCount(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex);
    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetDescriptorRangeIndexOffset(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex, SlangInt rangeIndex);
    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetDescriptorRangeDescriptorCount(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex, SlangInt rangeIndex);
    SLANG_API SlangBindingType spReflectionTypeLayout_getDescriptorSetDescriptorRangeType(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex, SlangInt rangeIndex);
    SLANG_API SlangParameterCategory spReflectionTypeLayout_getDescriptorSetDescriptorRangeCategory(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex, SlangInt rangeIndex);

    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeCount(SlangReflectionTypeLayout* typeLayout);
    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeBindingRangeIndex(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex);
    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeSpaceOffset(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex);
    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_getSubObjectRangeOffset(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex);

#if 0
    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeCount(SlangReflectionTypeLayout* typeLayout);
    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeObjectCount(SlangReflectionTypeLayout* typeLayout, SlangInt index);
    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeBindingRangeIndex(SlangReflectionTypeLayout* typeLayout, SlangInt index);
    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_getSubObjectRangeTypeLayout(SlangReflectionTypeLayout* typeLayout, SlangInt index);

    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeDescriptorRangeCount(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex);
    SLANG_API SlangBindingType spReflectionTypeLayout_getSubObjectRangeDescriptorRangeBindingType(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex, SlangInt bindingRangeIndexInSubObject);
    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeDescriptorRangeBindingCount(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex, SlangInt bindingRangeIndexInSubObject);
    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeDescriptorRangeIndexOffset(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex, SlangInt bindingRangeIndexInSubObject);
    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeDescriptorRangeSpaceOffset(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex, SlangInt bindingRangeIndexInSubObject);
#endif

    // Variable Reflection

    SLANG_API char const* spReflectionVariable_GetName(SlangReflectionVariable* var);
    SLANG_API SlangReflectionType* spReflectionVariable_GetType(SlangReflectionVariable* var);
    SLANG_API SlangReflectionModifier* spReflectionVariable_FindModifier(SlangReflectionVariable* var, SlangModifierID modifierID);
    SLANG_API unsigned int spReflectionVariable_GetUserAttributeCount(SlangReflectionVariable* var);
    SLANG_API SlangReflectionUserAttribute* spReflectionVariable_GetUserAttribute(SlangReflectionVariable* var, unsigned int index);
    SLANG_API SlangReflectionUserAttribute* spReflectionVariable_FindUserAttributeByName(SlangReflectionVariable* var, SlangSession * session, char const* name);

    // Variable Layout Reflection

    SLANG_API SlangReflectionVariable* spReflectionVariableLayout_GetVariable(SlangReflectionVariableLayout* var);

    SLANG_API SlangReflectionTypeLayout* spReflectionVariableLayout_GetTypeLayout(SlangReflectionVariableLayout* var);

    SLANG_API size_t spReflectionVariableLayout_GetOffset(SlangReflectionVariableLayout* var, SlangParameterCategory category);
    SLANG_API size_t spReflectionVariableLayout_GetSpace(SlangReflectionVariableLayout* var, SlangParameterCategory category);

    SLANG_API char const* spReflectionVariableLayout_GetSemanticName(SlangReflectionVariableLayout* var);
    SLANG_API size_t spReflectionVariableLayout_GetSemanticIndex(SlangReflectionVariableLayout* var);

    /** Get the stage that a variable belongs to (if any).

    A variable "belongs" to a specific stage when it is a varying input/output
    parameter either defined as part of the parameter list for an entry
    point *or* at the global scope of a stage-specific GLSL code file (e.g.,
    an `in` parameter in a GLSL `.vs` file belongs to the vertex stage).
    */
    SLANG_API SlangStage spReflectionVariableLayout_getStage(
        SlangReflectionVariableLayout* var);


    SLANG_API SlangReflectionVariableLayout* spReflectionVariableLayout_getPendingDataLayout(SlangReflectionVariableLayout* var);

    // Shader Parameter Reflection

    typedef SlangReflectionVariableLayout SlangReflectionParameter;

    SLANG_API unsigned spReflectionParameter_GetBindingIndex(SlangReflectionParameter* parameter);
    SLANG_API unsigned spReflectionParameter_GetBindingSpace(SlangReflectionParameter* parameter);

    SLANG_API SlangResult spIsParameterLocationUsed(
        SlangCompileRequest* request,
        SlangInt entryPointIndex,
        SlangInt targetIndex,
        SlangParameterCategory category, // is this a `t` register? `s` register?
        SlangUInt spaceIndex,      // `space` for D3D12, `set` for Vulkan
        SlangUInt registerIndex,   // `register` for D3D12, `binding` for Vulkan
        bool& outUsed);

    // Entry Point Reflection

    SLANG_API char const* spReflectionEntryPoint_getName(
        SlangReflectionEntryPoint* entryPoint);

    SLANG_API char const* spReflectionEntryPoint_getNameOverride(
        SlangReflectionEntryPoint* entryPoint);

    SLANG_API unsigned spReflectionEntryPoint_getParameterCount(
        SlangReflectionEntryPoint* entryPoint);

    SLANG_API SlangReflectionVariableLayout* spReflectionEntryPoint_getParameterByIndex(
        SlangReflectionEntryPoint*  entryPoint,
        unsigned                    index);

    SLANG_API SlangStage spReflectionEntryPoint_getStage(SlangReflectionEntryPoint* entryPoint);

    SLANG_API void spReflectionEntryPoint_getComputeThreadGroupSize(
        SlangReflectionEntryPoint*  entryPoint,
        SlangUInt                   axisCount,
        SlangUInt*                  outSizeAlongAxis);

    SLANG_API int spReflectionEntryPoint_usesAnySampleRateInput(
        SlangReflectionEntryPoint* entryPoint);

    SLANG_API SlangReflectionVariableLayout* spReflectionEntryPoint_getVarLayout(
        SlangReflectionEntryPoint* entryPoint);

    SLANG_API SlangReflectionVariableLayout* spReflectionEntryPoint_getResultVarLayout(
        SlangReflectionEntryPoint* entryPoint);

    SLANG_API int spReflectionEntryPoint_hasDefaultConstantBuffer(
        SlangReflectionEntryPoint* entryPoint);

    // SlangReflectionTypeParameter
    SLANG_API char const* spReflectionTypeParameter_GetName(SlangReflectionTypeParameter* typeParam);
    SLANG_API unsigned spReflectionTypeParameter_GetIndex(SlangReflectionTypeParameter* typeParam);
    SLANG_API unsigned spReflectionTypeParameter_GetConstraintCount(SlangReflectionTypeParameter* typeParam);
    SLANG_API SlangReflectionType* spReflectionTypeParameter_GetConstraintByIndex(SlangReflectionTypeParameter* typeParam, unsigned int index);

    // Shader Reflection

    SLANG_API unsigned spReflection_GetParameterCount(SlangReflection* reflection);
    SLANG_API SlangReflectionParameter* spReflection_GetParameterByIndex(SlangReflection* reflection, unsigned index);

    SLANG_API unsigned int spReflection_GetTypeParameterCount(SlangReflection* reflection);
    SLANG_API SlangReflectionTypeParameter* spReflection_GetTypeParameterByIndex(SlangReflection* reflection, unsigned int index);
    SLANG_API SlangReflectionTypeParameter* spReflection_FindTypeParameter(SlangReflection* reflection, char const* name);

    SLANG_API SlangReflectionType* spReflection_FindTypeByName(SlangReflection* reflection, char const* name);
    SLANG_API SlangReflectionTypeLayout* spReflection_GetTypeLayout(SlangReflection* reflection, SlangReflectionType* reflectionType, SlangLayoutRules rules);

    SLANG_API SlangUInt spReflection_getEntryPointCount(SlangReflection* reflection);
    SLANG_API SlangReflectionEntryPoint* spReflection_getEntryPointByIndex(SlangReflection* reflection, SlangUInt index);
    SLANG_API SlangReflectionEntryPoint* spReflection_findEntryPointByName(SlangReflection* reflection, char const* name);

    SLANG_API SlangUInt spReflection_getGlobalConstantBufferBinding(SlangReflection* reflection);
    SLANG_API size_t spReflection_getGlobalConstantBufferSize(SlangReflection* reflection);

    SLANG_API  SlangReflectionType* spReflection_specializeType(
        SlangReflection*            reflection,
        SlangReflectionType*        type,
        SlangInt                    specializationArgCount,
        SlangReflectionType* const* specializationArgs,
        ISlangBlob**                outDiagnostics);

        /// Get the number of hashed strings
    SLANG_API SlangUInt spReflection_getHashedStringCount(
        SlangReflection*  reflection);

        /// Get a hashed string. The number of chars is written in outCount.
        /// The count does *NOT* including terminating 0. The returned string will be 0 terminated. 
    SLANG_API const char* spReflection_getHashedString(
        SlangReflection*  reflection,
        SlangUInt index,
        size_t* outCount);

        /// Compute a string hash.
        /// Count should *NOT* include terminating zero.
    SLANG_API int spComputeStringHash(const char* chars, size_t count);

        /// Get a type layout representing reflection information for the global-scope prameters.
    SLANG_API SlangReflectionTypeLayout* spReflection_getGlobalParamsTypeLayout(
        SlangReflection* reflection);

        /// Get a variable layout representing reflection information for the global-scope prameters.
    SLANG_API SlangReflectionVariableLayout* spReflection_getGlobalParamsVarLayout(
        SlangReflection* reflection);

#ifdef __cplusplus
}

/* Helper interfaces for C++ users */
namespace slang
{
    struct BufferReflection;
    struct TypeLayoutReflection;
    struct TypeReflection;
    struct VariableLayoutReflection;
    struct VariableReflection;
    
    struct UserAttribute
    {
        char const* getName()
        {
            return spReflectionUserAttribute_GetName((SlangReflectionUserAttribute*)this);
        }
        uint32_t getArgumentCount()
        {
            return (uint32_t)spReflectionUserAttribute_GetArgumentCount((SlangReflectionUserAttribute*)this);
        }
        TypeReflection* getArgumentType(uint32_t index)
        {
            return (TypeReflection*)spReflectionUserAttribute_GetArgumentType((SlangReflectionUserAttribute*)this, index);
        }
        SlangResult getArgumentValueInt(uint32_t index, int * value)
        {
            return spReflectionUserAttribute_GetArgumentValueInt((SlangReflectionUserAttribute*)this, index, value);
        }
        SlangResult getArgumentValueFloat(uint32_t index, float * value)
        {
            return spReflectionUserAttribute_GetArgumentValueFloat((SlangReflectionUserAttribute*)this, index, value);
        }
        const char* getArgumentValueString(uint32_t index, size_t * outSize)
        {
            return spReflectionUserAttribute_GetArgumentValueString((SlangReflectionUserAttribute*)this, index, outSize);
        }
    };

    struct TypeReflection
    {
        enum class Kind
        {
            None    = SLANG_TYPE_KIND_NONE,
            Struct  = SLANG_TYPE_KIND_STRUCT,
            Array   = SLANG_TYPE_KIND_ARRAY,
            Matrix  = SLANG_TYPE_KIND_MATRIX,
            Vector  = SLANG_TYPE_KIND_VECTOR,
            Scalar  = SLANG_TYPE_KIND_SCALAR,
            ConstantBuffer = SLANG_TYPE_KIND_CONSTANT_BUFFER,
            Resource = SLANG_TYPE_KIND_RESOURCE,
            SamplerState = SLANG_TYPE_KIND_SAMPLER_STATE,
            TextureBuffer = SLANG_TYPE_KIND_TEXTURE_BUFFER,
            ShaderStorageBuffer = SLANG_TYPE_KIND_SHADER_STORAGE_BUFFER,
            ParameterBlock = SLANG_TYPE_KIND_PARAMETER_BLOCK,
            GenericTypeParameter = SLANG_TYPE_KIND_GENERIC_TYPE_PARAMETER,
            Interface = SLANG_TYPE_KIND_INTERFACE,
            OutputStream = SLANG_TYPE_KIND_OUTPUT_STREAM,
            Specialized = SLANG_TYPE_KIND_SPECIALIZED,
            Feedback = SLANG_TYPE_KIND_FEEDBACK,
        };

        enum ScalarType : SlangScalarTypeIntegral
        {
            None    = SLANG_SCALAR_TYPE_NONE,
            Void    = SLANG_SCALAR_TYPE_VOID,
            Bool    = SLANG_SCALAR_TYPE_BOOL,
            Int32   = SLANG_SCALAR_TYPE_INT32,
            UInt32  = SLANG_SCALAR_TYPE_UINT32,
            Int64   = SLANG_SCALAR_TYPE_INT64,
            UInt64  = SLANG_SCALAR_TYPE_UINT64,
            Float16 = SLANG_SCALAR_TYPE_FLOAT16,
            Float32 = SLANG_SCALAR_TYPE_FLOAT32,
            Float64 = SLANG_SCALAR_TYPE_FLOAT64,
            Int8    = SLANG_SCALAR_TYPE_INT8,
            UInt8   = SLANG_SCALAR_TYPE_UINT8,
            Int16   = SLANG_SCALAR_TYPE_INT16,
            UInt16  = SLANG_SCALAR_TYPE_UINT16,
        };

        Kind getKind()
        {
            return (Kind) spReflectionType_GetKind((SlangReflectionType*) this);
        }

        // only useful if `getKind() == Kind::Struct`
        unsigned int getFieldCount()
        {
            return spReflectionType_GetFieldCount((SlangReflectionType*) this);
        }

        VariableReflection* getFieldByIndex(unsigned int index)
        {
            return (VariableReflection*) spReflectionType_GetFieldByIndex((SlangReflectionType*) this, index);
        }

        bool isArray() { return getKind() == TypeReflection::Kind::Array; }

        TypeReflection* unwrapArray()
        {
            TypeReflection* type = this;
            while( type->isArray() )
            {
                type = type->getElementType();
            }
            return type;
        }

        // only useful if `getKind() == Kind::Array`
        size_t getElementCount()
        {
            return spReflectionType_GetElementCount((SlangReflectionType*) this);
        }

        size_t getTotalArrayElementCount()
        {
            if(!isArray()) return 0;
            size_t result = 1;
            TypeReflection* type = this;
            for(;;)
            {
                if(!type->isArray())
                    return result;

                result *= type->getElementCount();
                type = type->getElementType();
            }
        }

        TypeReflection* getElementType()
        {
            return (TypeReflection*) spReflectionType_GetElementType((SlangReflectionType*) this);
        }

        unsigned getRowCount()
        {
            return spReflectionType_GetRowCount((SlangReflectionType*) this);
        }

        unsigned getColumnCount()
        {
            return spReflectionType_GetColumnCount((SlangReflectionType*) this);
        }

        ScalarType getScalarType()
        {
            return (ScalarType) spReflectionType_GetScalarType((SlangReflectionType*) this);
        }

        TypeReflection* getResourceResultType()
        {
            return (TypeReflection*) spReflectionType_GetResourceResultType((SlangReflectionType*) this);
        }

        SlangResourceShape getResourceShape()
        {
            return spReflectionType_GetResourceShape((SlangReflectionType*) this);
        }

        SlangResourceAccess getResourceAccess()
        {
            return spReflectionType_GetResourceAccess((SlangReflectionType*) this);
        }

        char const* getName()
        {
            return spReflectionType_GetName((SlangReflectionType*) this);
        }

        unsigned int getUserAttributeCount()
        {
            return spReflectionType_GetUserAttributeCount((SlangReflectionType*)this);
        }
        UserAttribute* getUserAttributeByIndex(unsigned int index)
        {
            return (UserAttribute*)spReflectionType_GetUserAttribute((SlangReflectionType*)this, index);
        }
        UserAttribute* findUserAttributeByName(char const* name)
        {
            return (UserAttribute*)spReflectionType_FindUserAttributeByName((SlangReflectionType*)this, name);
        }
    };

    enum ParameterCategory : SlangParameterCategoryIntegral
    {
        // TODO: these aren't scoped...
        None = SLANG_PARAMETER_CATEGORY_NONE,
        Mixed = SLANG_PARAMETER_CATEGORY_MIXED,
        ConstantBuffer = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
        ShaderResource = SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
        UnorderedAccess = SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS,
        VaryingInput = SLANG_PARAMETER_CATEGORY_VARYING_INPUT,
        VaryingOutput = SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT,
        SamplerState = SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
        Uniform = SLANG_PARAMETER_CATEGORY_UNIFORM,
        DescriptorTableSlot = SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT,
        SpecializationConstant = SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT,
        PushConstantBuffer = SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER,
        RegisterSpace = SLANG_PARAMETER_CATEGORY_REGISTER_SPACE,
        GenericResource = SLANG_PARAMETER_CATEGORY_GENERIC,

        RayPayload = SLANG_PARAMETER_CATEGORY_RAY_PAYLOAD,
        HitAttributes = SLANG_PARAMETER_CATEGORY_HIT_ATTRIBUTES,
        CallablePayload = SLANG_PARAMETER_CATEGORY_CALLABLE_PAYLOAD,

        ShaderRecord = SLANG_PARAMETER_CATEGORY_SHADER_RECORD,

        ExistentialTypeParam = SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM,
        ExistentialObjectParam = SLANG_PARAMETER_CATEGORY_EXISTENTIAL_OBJECT_PARAM,

        // DEPRECATED:
        VertexInput = SLANG_PARAMETER_CATEGORY_VERTEX_INPUT,
        FragmentOutput = SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT,
    };

    enum class BindingType : SlangBindingTypeIntegral
    {
        Unknown                             = SLANG_BINDING_TYPE_UNKNOWN,

        Sampler                             = SLANG_BINDING_TYPE_SAMPLER,
        Texture                             = SLANG_BINDING_TYPE_TEXTURE,
        ConstantBuffer                      = SLANG_BINDING_TYPE_CONSTANT_BUFFER,
        ParameterBlock                      = SLANG_BINDING_TYPE_PARAMETER_BLOCK,
        TypedBuffer                         = SLANG_BINDING_TYPE_TYPED_BUFFER,
        RawBuffer                           = SLANG_BINDING_TYPE_RAW_BUFFER,
        CombinedTextureSampler              = SLANG_BINDING_TYPE_COMBINED_TEXTURE_SAMPLER,
        InputRenderTarget                   = SLANG_BINDING_TYPE_INPUT_RENDER_TARGET,
        InlineUniformData                   = SLANG_BINDING_TYPE_INLINE_UNIFORM_DATA,
        RayTracingAccelerationStructure     = SLANG_BINDING_TYPE_RAY_TRACTING_ACCELERATION_STRUCTURE,
        VaryingInput                        = SLANG_BINDING_TYPE_VARYING_INPUT,
        VaryingOutput                       = SLANG_BINDING_TYPE_VARYING_OUTPUT,
        ExistentialValue                    = SLANG_BINDING_TYPE_EXISTENTIAL_VALUE,
        PushConstant                        = SLANG_BINDING_TYPE_PUSH_CONSTANT,

        MutableFlag                         = SLANG_BINDING_TYPE_MUTABLE_FLAG,

        MutableTexture                      = SLANG_BINDING_TYPE_MUTABLE_TETURE,
        MutableTypedBuffer                  = SLANG_BINDING_TYPE_MUTABLE_TYPED_BUFFER,
        MutableRawBuffer                    = SLANG_BINDING_TYPE_MUTABLE_RAW_BUFFER,

        BaseMask                            = SLANG_BINDING_TYPE_BASE_MASK,
        ExtMask                             = SLANG_BINDING_TYPE_EXT_MASK,
    };

    struct TypeLayoutReflection
    {
        TypeReflection* getType()
        {
            return (TypeReflection*) spReflectionTypeLayout_GetType((SlangReflectionTypeLayout*) this);
        }

        TypeReflection::Kind getKind()
        {
            return (TypeReflection::Kind) spReflectionTypeLayout_getKind((SlangReflectionTypeLayout*) this);
        }

        size_t getSize(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
        {
            return spReflectionTypeLayout_GetSize((SlangReflectionTypeLayout*) this, category);
        }

        size_t getStride(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
        {
            return spReflectionTypeLayout_GetStride((SlangReflectionTypeLayout*) this, category);
        }

        int32_t getAlignment(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
        {
            return spReflectionTypeLayout_getAlignment((SlangReflectionTypeLayout*) this, category);
        }

        unsigned int getFieldCount()
        {
            return getType()->getFieldCount();
        }

        VariableLayoutReflection* getFieldByIndex(unsigned int index)
        {
            return (VariableLayoutReflection*) spReflectionTypeLayout_GetFieldByIndex((SlangReflectionTypeLayout*) this, index);
        }

        SlangInt findFieldIndexByName(char const* nameBegin, char const* nameEnd = nullptr)
        {
            return spReflectionTypeLayout_findFieldIndexByName((SlangReflectionTypeLayout*) this, nameBegin, nameEnd);
        }

        bool isArray() { return getType()->isArray(); }

        TypeLayoutReflection* unwrapArray()
        {
            TypeLayoutReflection* typeLayout = this;
            while( typeLayout->isArray() )
            {
                typeLayout = typeLayout->getElementTypeLayout();
            }
            return typeLayout;
        }

        // only useful if `getKind() == Kind::Array`
        size_t getElementCount()
        {
            return getType()->getElementCount();
        }

        size_t getTotalArrayElementCount()
        {
            return getType()->getTotalArrayElementCount();
        }

        size_t getElementStride(SlangParameterCategory category)
        {
            return spReflectionTypeLayout_GetElementStride((SlangReflectionTypeLayout*) this, category);
        }

        TypeLayoutReflection* getElementTypeLayout()
        {
            return (TypeLayoutReflection*) spReflectionTypeLayout_GetElementTypeLayout((SlangReflectionTypeLayout*) this);
        }

        VariableLayoutReflection* getElementVarLayout()
        {
            return (VariableLayoutReflection*)spReflectionTypeLayout_GetElementVarLayout((SlangReflectionTypeLayout*) this);
        }

        VariableLayoutReflection* getContainerVarLayout()
        {
            return (VariableLayoutReflection*)spReflectionTypeLayout_getContainerVarLayout((SlangReflectionTypeLayout*) this);
        }

        // How is this type supposed to be bound?
        ParameterCategory getParameterCategory()
        {
            return (ParameterCategory) spReflectionTypeLayout_GetParameterCategory((SlangReflectionTypeLayout*) this);
        }

        unsigned int getCategoryCount()
        {
            return spReflectionTypeLayout_GetCategoryCount((SlangReflectionTypeLayout*) this);
        }

        ParameterCategory getCategoryByIndex(unsigned int index)
        {
            return (ParameterCategory) spReflectionTypeLayout_GetCategoryByIndex((SlangReflectionTypeLayout*) this, index);
        }

        unsigned getRowCount()
        {
            return getType()->getRowCount();
        }

        unsigned getColumnCount()
        {
            return getType()->getColumnCount();
        }

        TypeReflection::ScalarType getScalarType()
        {
            return getType()->getScalarType();
        }

        TypeReflection* getResourceResultType()
        {
            return getType()->getResourceResultType();
        }

        SlangResourceShape getResourceShape()
        {
            return getType()->getResourceShape();
        }

        SlangResourceAccess getResourceAccess()
        {
            return getType()->getResourceAccess();
        }

        char const* getName()
        {
            return getType()->getName();
        }

        SlangMatrixLayoutMode getMatrixLayoutMode()
        {
            return spReflectionTypeLayout_GetMatrixLayoutMode((SlangReflectionTypeLayout*) this);
        }

        int getGenericParamIndex()
        {
            return spReflectionTypeLayout_getGenericParamIndex(
                (SlangReflectionTypeLayout*) this);
        }

        TypeLayoutReflection* getPendingDataTypeLayout()
        {
            return (TypeLayoutReflection*) spReflectionTypeLayout_getPendingDataTypeLayout(
                (SlangReflectionTypeLayout*) this);
        }

        VariableLayoutReflection* getSpecializedTypePendingDataVarLayout()
        {
            return (VariableLayoutReflection*) spReflectionTypeLayout_getSpecializedTypePendingDataVarLayout(
                (SlangReflectionTypeLayout*) this);
        }

        SlangInt getBindingRangeCount()
        {
            return spReflectionTypeLayout_getBindingRangeCount(
                (SlangReflectionTypeLayout*) this);
        }

        BindingType getBindingRangeType(SlangInt index)
        {
            return (BindingType) spReflectionTypeLayout_getBindingRangeType(
                (SlangReflectionTypeLayout*) this,
                index);
        }

        SlangInt getBindingRangeBindingCount(SlangInt index)
        {
            return spReflectionTypeLayout_getBindingRangeBindingCount(
                (SlangReflectionTypeLayout*) this,
                index);
        }

        /*
        SlangInt getBindingRangeIndexOffset(SlangInt index)
        {
            return spReflectionTypeLayout_getBindingRangeIndexOffset(
                (SlangReflectionTypeLayout*) this,
                index);
        }

        SlangInt getBindingRangeSpaceOffset(SlangInt index)
        {
            return spReflectionTypeLayout_getBindingRangeSpaceOffset(
                (SlangReflectionTypeLayout*) this,
                index);
        }
        */

        SlangInt getFieldBindingRangeOffset(SlangInt fieldIndex)
        {
            return spReflectionTypeLayout_getFieldBindingRangeOffset(
                (SlangReflectionTypeLayout*) this,
                fieldIndex);
        }

        TypeLayoutReflection* getBindingRangeLeafTypeLayout(SlangInt index)
        {
            return (TypeLayoutReflection*) spReflectionTypeLayout_getBindingRangeLeafTypeLayout(
                (SlangReflectionTypeLayout*) this,
                index);
        }

        VariableReflection* getBindingRangeLeafVariable(SlangInt index)
        {
            return (VariableReflection*)spReflectionTypeLayout_getBindingRangeLeafVariable(
                (SlangReflectionTypeLayout*)this, index);
        }

        SlangInt getBindingRangeDescriptorSetIndex(SlangInt index)
        {
            return spReflectionTypeLayout_getBindingRangeDescriptorSetIndex(
                (SlangReflectionTypeLayout*) this,
                index);
        }

        SlangInt getBindingRangeFirstDescriptorRangeIndex(SlangInt index)
        {
            return spReflectionTypeLayout_getBindingRangeFirstDescriptorRangeIndex(
                (SlangReflectionTypeLayout*) this,
                index);
        }

        SlangInt getBindingRangeDescriptorRangeCount(SlangInt index)
        {
            return spReflectionTypeLayout_getBindingRangeDescriptorRangeCount(
                (SlangReflectionTypeLayout*) this,
                index);
        }

        SlangInt getDescriptorSetCount()
        {
            return spReflectionTypeLayout_getDescriptorSetCount(
                (SlangReflectionTypeLayout*) this);
        }

        SlangInt getDescriptorSetSpaceOffset(SlangInt setIndex)
        {
            return spReflectionTypeLayout_getDescriptorSetSpaceOffset(
                (SlangReflectionTypeLayout*) this,
                setIndex);
        }

        SlangInt getDescriptorSetDescriptorRangeCount(SlangInt setIndex)
        {
            return spReflectionTypeLayout_getDescriptorSetDescriptorRangeCount(
                (SlangReflectionTypeLayout*) this,
                setIndex);
        }

        SlangInt getDescriptorSetDescriptorRangeIndexOffset(SlangInt setIndex, SlangInt rangeIndex)
        {
            return spReflectionTypeLayout_getDescriptorSetDescriptorRangeIndexOffset(
                (SlangReflectionTypeLayout*) this,
                setIndex,
                rangeIndex);
        }

        SlangInt getDescriptorSetDescriptorRangeDescriptorCount(SlangInt setIndex, SlangInt rangeIndex)
        {
            return spReflectionTypeLayout_getDescriptorSetDescriptorRangeDescriptorCount(
                (SlangReflectionTypeLayout*) this,
                setIndex,
                rangeIndex);
        }

        BindingType getDescriptorSetDescriptorRangeType(SlangInt setIndex, SlangInt rangeIndex)
        {
            return (BindingType) spReflectionTypeLayout_getDescriptorSetDescriptorRangeType(
                (SlangReflectionTypeLayout*) this,
                setIndex,
                rangeIndex);
        }

        ParameterCategory getDescriptorSetDescriptorRangeCategory(SlangInt setIndex, SlangInt rangeIndex)
        {
            return (ParameterCategory) spReflectionTypeLayout_getDescriptorSetDescriptorRangeCategory(
                (SlangReflectionTypeLayout*) this,
                setIndex,
                rangeIndex);
        }

        SlangInt getSubObjectRangeCount()
        {
            return spReflectionTypeLayout_getSubObjectRangeCount(
                (SlangReflectionTypeLayout*) this);
        }

        SlangInt getSubObjectRangeBindingRangeIndex(SlangInt subObjectRangeIndex)
        {
            return spReflectionTypeLayout_getSubObjectRangeBindingRangeIndex(
                (SlangReflectionTypeLayout*) this,
                subObjectRangeIndex);
        }

        SlangInt getSubObjectRangeSpaceOffset(SlangInt subObjectRangeIndex)
        {
            return spReflectionTypeLayout_getSubObjectRangeSpaceOffset(
                (SlangReflectionTypeLayout*) this,
                subObjectRangeIndex);
        }

        VariableLayoutReflection* getSubObjectRangeOffset(SlangInt subObjectRangeIndex)
        {
            return (VariableLayoutReflection*) spReflectionTypeLayout_getSubObjectRangeOffset(
                (SlangReflectionTypeLayout*) this,
                subObjectRangeIndex);
        }
    };

    struct Modifier
    {
        enum ID : SlangModifierIDIntegral
        {
            Shared = SLANG_MODIFIER_SHARED,
        };
    };

    struct VariableReflection
    {
        char const* getName()
        {
            return spReflectionVariable_GetName((SlangReflectionVariable*) this);
        }

        TypeReflection* getType()
        {
            return (TypeReflection*) spReflectionVariable_GetType((SlangReflectionVariable*) this);
        }

        Modifier* findModifier(Modifier::ID id)
        {
            return (Modifier*) spReflectionVariable_FindModifier((SlangReflectionVariable*) this, (SlangModifierID) id);
        }

        unsigned int getUserAttributeCount()
        {
            return spReflectionVariable_GetUserAttributeCount((SlangReflectionVariable*)this);
        }
        UserAttribute* getUserAttributeByIndex(unsigned int index)
        {
            return (UserAttribute*)spReflectionVariable_GetUserAttribute((SlangReflectionVariable*)this, index);
        }
        UserAttribute* findUserAttributeByName(SlangSession* session, char const* name)
        {
            return (UserAttribute*)spReflectionVariable_FindUserAttributeByName((SlangReflectionVariable*)this, session, name);
        }
    };

    struct VariableLayoutReflection
    {
        VariableReflection* getVariable()
        {
            return (VariableReflection*) spReflectionVariableLayout_GetVariable((SlangReflectionVariableLayout*) this);
        }

        char const* getName()
        {
            return getVariable()->getName();
        }

        Modifier* findModifier(Modifier::ID id)
        {
            return getVariable()->findModifier(id);
        }

        TypeLayoutReflection* getTypeLayout()
        {
            return (TypeLayoutReflection*) spReflectionVariableLayout_GetTypeLayout((SlangReflectionVariableLayout*) this);
        }

        ParameterCategory getCategory()
        {
            return getTypeLayout()->getParameterCategory();
        }

        unsigned int getCategoryCount()
        {
            return getTypeLayout()->getCategoryCount();
        }

        ParameterCategory getCategoryByIndex(unsigned int index)
        {
            return getTypeLayout()->getCategoryByIndex(index);
        }


        size_t getOffset(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
        {
            return spReflectionVariableLayout_GetOffset((SlangReflectionVariableLayout*) this, category);
        }

        TypeReflection* getType()
        {
            return getVariable()->getType();
        }

        unsigned getBindingIndex()
        {
            return spReflectionParameter_GetBindingIndex((SlangReflectionVariableLayout*) this);
        }

        unsigned getBindingSpace()
        {
            return spReflectionParameter_GetBindingSpace((SlangReflectionVariableLayout*) this);
        }

        size_t getBindingSpace(SlangParameterCategory category)
        {
            return spReflectionVariableLayout_GetSpace((SlangReflectionVariableLayout*) this, category);
        }

        char const* getSemanticName()
        {
            return spReflectionVariableLayout_GetSemanticName((SlangReflectionVariableLayout*) this);
        }

        size_t getSemanticIndex()
        {
            return spReflectionVariableLayout_GetSemanticIndex((SlangReflectionVariableLayout*) this);
        }

        SlangStage getStage()
        {
            return spReflectionVariableLayout_getStage((SlangReflectionVariableLayout*) this);
        }

        VariableLayoutReflection* getPendingDataLayout()
        {
            return (VariableLayoutReflection*) spReflectionVariableLayout_getPendingDataLayout((SlangReflectionVariableLayout*) this);
        }
    };

    struct EntryPointReflection
    {
        char const* getName()
        {
            return spReflectionEntryPoint_getName((SlangReflectionEntryPoint*) this);
        }

        char const* getNameOverride()
        {
            return spReflectionEntryPoint_getNameOverride((SlangReflectionEntryPoint*)this);
        }

        unsigned getParameterCount()
        {
            return spReflectionEntryPoint_getParameterCount((SlangReflectionEntryPoint*) this);
        }

        VariableLayoutReflection* getParameterByIndex(unsigned index)
        {
            return (VariableLayoutReflection*) spReflectionEntryPoint_getParameterByIndex((SlangReflectionEntryPoint*) this, index);
        }

        SlangStage getStage()
        {
            return spReflectionEntryPoint_getStage((SlangReflectionEntryPoint*) this);
        }

        void getComputeThreadGroupSize(
            SlangUInt   axisCount,
            SlangUInt*  outSizeAlongAxis)
        {
            return spReflectionEntryPoint_getComputeThreadGroupSize((SlangReflectionEntryPoint*) this, axisCount, outSizeAlongAxis);
        }

        bool usesAnySampleRateInput()
        {
            return 0 != spReflectionEntryPoint_usesAnySampleRateInput((SlangReflectionEntryPoint*) this);
        }

        VariableLayoutReflection* getVarLayout()
        {
            return (VariableLayoutReflection*) spReflectionEntryPoint_getVarLayout((SlangReflectionEntryPoint*) this);
        }

        TypeLayoutReflection* getTypeLayout()
        {
            return getVarLayout()->getTypeLayout();
        }

        VariableLayoutReflection* getResultVarLayout()
        {
            return (VariableLayoutReflection*) spReflectionEntryPoint_getResultVarLayout((SlangReflectionEntryPoint*) this);
        }

        bool hasDefaultConstantBuffer()
        {
            return spReflectionEntryPoint_hasDefaultConstantBuffer((SlangReflectionEntryPoint*) this) != 0;
        }
    };
    typedef EntryPointReflection EntryPointLayout;

    struct TypeParameterReflection
    {
        char const* getName()
        {
            return spReflectionTypeParameter_GetName((SlangReflectionTypeParameter*) this);
        }
        unsigned getIndex()
        {
            return spReflectionTypeParameter_GetIndex((SlangReflectionTypeParameter*) this);
        }
        unsigned getConstraintCount()
        {
            return spReflectionTypeParameter_GetConstraintCount((SlangReflectionTypeParameter*) this);
        }
        TypeReflection* getConstraintByIndex(int index)
        {
            return (TypeReflection*)spReflectionTypeParameter_GetConstraintByIndex((SlangReflectionTypeParameter*) this, index);
        }
    };

    enum class LayoutRules : SlangLayoutRulesIntegral
    {
        Default = SLANG_LAYOUT_RULES_DEFAULT,
    };

    typedef struct ShaderReflection ProgramLayout;

    struct ShaderReflection
    {
        unsigned getParameterCount()
        {
            return spReflection_GetParameterCount((SlangReflection*) this);
        }

        unsigned getTypeParameterCount()
        {
            return spReflection_GetTypeParameterCount((SlangReflection*) this);
        }

        TypeParameterReflection* getTypeParameterByIndex(unsigned index)
        {
            return (TypeParameterReflection*)spReflection_GetTypeParameterByIndex((SlangReflection*) this, index);
        }

        TypeParameterReflection* findTypeParameter(char const* name)
        {
            return (TypeParameterReflection*)spReflection_FindTypeParameter((SlangReflection*)this, name);
        }

        VariableLayoutReflection* getParameterByIndex(unsigned index)
        {
            return (VariableLayoutReflection*) spReflection_GetParameterByIndex((SlangReflection*) this, index);
        }

        static ProgramLayout* get(SlangCompileRequest* request)
        {
            return (ProgramLayout*) spGetReflection(request);
        }

        SlangUInt getEntryPointCount()
        {
            return spReflection_getEntryPointCount((SlangReflection*) this);
        }

        EntryPointReflection* getEntryPointByIndex(SlangUInt index)
        {
            return (EntryPointReflection*) spReflection_getEntryPointByIndex((SlangReflection*) this, index);
        }

        SlangUInt getGlobalConstantBufferBinding()
        {
            return spReflection_getGlobalConstantBufferBinding((SlangReflection*)this);
        }

        size_t getGlobalConstantBufferSize()
        {
            return spReflection_getGlobalConstantBufferSize((SlangReflection*)this);
        }

        TypeReflection* findTypeByName(const char* name)
        {
            return (TypeReflection*)spReflection_FindTypeByName(
                (SlangReflection*) this,
                name);
        }

        TypeLayoutReflection* getTypeLayout(
            TypeReflection* type,
            LayoutRules     rules = LayoutRules::Default)
        {
            return (TypeLayoutReflection*)spReflection_GetTypeLayout(
                (SlangReflection*) this,
                (SlangReflectionType*)type,
                SlangLayoutRules(rules));
        }

        EntryPointReflection* findEntryPointByName(const char* name)
        {
            return (EntryPointReflection*)spReflection_findEntryPointByName(
                (SlangReflection*) this,
                name);
        }

        TypeReflection* specializeType(
            TypeReflection*         type,
            SlangInt                specializationArgCount,
            TypeReflection* const*  specializationArgs,
            ISlangBlob**            outDiagnostics)
        {
            return (TypeReflection*) spReflection_specializeType(
                (SlangReflection*) this,
                (SlangReflectionType*) type,
                specializationArgCount,
                (SlangReflectionType* const*) specializationArgs,
                outDiagnostics);
        }

        SlangUInt getHashedStringCount() const { return spReflection_getHashedStringCount((SlangReflection*)this); }

        const char* getHashedString(SlangUInt index, size_t* outCount) const
        {
            return spReflection_getHashedString((SlangReflection*)this, index, outCount);
        }

        TypeLayoutReflection* getGlobalParamsTypeLayout()
        {
            return (TypeLayoutReflection*) spReflection_getGlobalParamsTypeLayout((SlangReflection*) this);
        }

        VariableLayoutReflection* getGlobalParamsVarLayout()
        {
            return (VariableLayoutReflection*) spReflection_getGlobalParamsVarLayout((SlangReflection*) this);
        }
    };

    typedef uint32_t CompileStdLibFlags;
    struct CompileStdLibFlag
    {
        enum Enum : CompileStdLibFlags
        {
            WriteDocumentation = 0x1,
        };
    };

    typedef ISlangBlob IBlob;

    struct IComponentType;
    struct ITypeConformance;
    struct IGlobalSession;
    struct IModule;
    struct ISession;

    struct SessionDesc;
    struct SpecializationArg;
    struct TargetDesc;

        /** A global session for interaction with the Slang library.

        An application may create and re-use a single global session across
        multiple sessions, in order to amortize startups costs (in current
        Slang this is mostly the cost of loading the Slang standard library).

        The global session is currently *not* thread-safe and objects created from
        a single global session should only be used from a single thread at
        a time.
        */
    struct IGlobalSession : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(0xc140b5fd, 0xc78, 0x452e, { 0xba, 0x7c, 0x1a, 0x1e, 0x70, 0xc7, 0xf7, 0x1c })

            /** Create a new session for loading and compiling code.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createSession(
            SessionDesc const&  desc,
            ISession**          outSession) = 0;

            /** Look up the internal ID of a profile by its `name`.

            Profile IDs are *not* guaranteed to be stable across versions
            of the Slang library, so clients are expected to look up
            profiles by name at runtime.
            */
        virtual SLANG_NO_THROW SlangProfileID SLANG_MCALL findProfile(
            char const*     name) = 0;

            /** Set the path that downstream compilers (aka back end compilers) will
            be looked from.
            @param passThrough Identifies the downstream compiler
            @param path The path to find the downstream compiler (shared library/dll/executable)

            For back ends that are dlls/shared libraries, it will mean the path will
            be prefixed with the path when calls are made out to ISlangSharedLibraryLoader.
            For executables - it will look for executables along the path */
        virtual SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerPath(
            SlangPassThrough passThrough,
            char const* path) = 0;

            /** DEPRECIATED: Use setLanguagePrelude

            Set the 'prelude' for generated code for a 'downstream compiler'.
            @param passThrough The downstream compiler for generated code that will have the prelude applied to it. 
            @param preludeText The text added pre-pended verbatim before the generated source

            That for pass-through usage, prelude is not pre-pended, preludes are for code generation only. 
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerPrelude(
            SlangPassThrough passThrough,
            const char* preludeText) = 0;

            /** DEPRECIATED: Use getLanguagePrelude

            Get the 'prelude' for generated code for a 'downstream compiler'.
            @param passThrough The downstream compiler for generated code that will have the prelude applied to it. 
            @param outPrelude  On exit holds a blob that holds the string of the prelude.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL getDownstreamCompilerPrelude(
            SlangPassThrough passThrough,
            ISlangBlob** outPrelude) = 0;

            /** Get the build version 'tag' string. The string is the same as produced via `git describe --tags`
            for the project. If Slang is built separately from the automated build scripts
            the contents will by default be 'unknown'. Any string can be set by changing the
            contents of 'slang-tag-version.h' file and recompiling the project.

            This method will return exactly the same result as the free function spGetBuildTagString.

            @return The build tag string
            */
        virtual SLANG_NO_THROW const char* SLANG_MCALL getBuildTagString() = 0;

            /* For a given source language set the default compiler.
            If a default cannot be chosen (for example the target cannot be achieved by the default),
            the default will not be used. 

            @param sourceLanguage the source language 
            @param defaultCompiler the default compiler for that language
            @return 
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setDefaultDownstreamCompiler(
            SlangSourceLanguage sourceLanguage,
            SlangPassThrough defaultCompiler) = 0;

            /* For a source type get the default compiler 

            @param sourceLanguage the source language 
            @return The downstream compiler for that source language */
        virtual SlangPassThrough SLANG_MCALL getDefaultDownstreamCompiler(
            SlangSourceLanguage sourceLanguage) = 0;

            /* Set the 'prelude' placed before generated code for a specific language type.
            
            @param sourceLanguage The language the prelude should be inserted on.
            @param preludeText The text added pre-pended verbatim before the generated source

            Note! That for pass-through usage, prelude is not pre-pended, preludes are for code generation only. 
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setLanguagePrelude(
            SlangSourceLanguage sourceLanguage,
            const char* preludeText) = 0;

            /** Get the 'prelude' associated with a specific source language. 
            @param sourceLanguage The language the prelude should be inserted on.
            @param outPrelude  On exit holds a blob that holds the string of the prelude.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL getLanguagePrelude(
            SlangSourceLanguage sourceLanguage,
            ISlangBlob** outPrelude) = 0;

            /** Create a compile request.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCompileRequest(
            slang::ICompileRequest** outCompileRequest) = 0;

            /** Add new builtin declarations to be used in subsequent compiles.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL addBuiltins(
            char const*     sourcePath,
            char const*     sourceString) = 0;

            /** Set the session shared library loader. If this changes the loader, it may cause shared libraries to be unloaded
            @param loader The loader to set. Setting nullptr sets the default loader. 
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setSharedLibraryLoader(
            ISlangSharedLibraryLoader* loader) = 0;

            /** Gets the currently set shared library loader
            @return Gets the currently set loader. If returns nullptr, it's the default loader
            */
        virtual SLANG_NO_THROW ISlangSharedLibraryLoader* SLANG_MCALL getSharedLibraryLoader() = 0;

            /** Returns SLANG_OK if a the compilation target is supported for this session
            
            @param target The compilation target to test
            @return SLANG_OK if the target is available
            SLANG_E_NOT_IMPLEMENTED if not implemented in this build
            SLANG_E_NOT_FOUND if other resources (such as shared libraries) required to make target work could not be found
            SLANG_FAIL other kinds of failures */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL checkCompileTargetSupport(
            SlangCompileTarget  target) = 0;

            /** Returns SLANG_OK if a the pass through support is supported for this session
            @param session Session
            @param target The compilation target to test
            @return SLANG_OK if the target is available
            SLANG_E_NOT_IMPLEMENTED if not implemented in this build
            SLANG_E_NOT_FOUND if other resources (such as shared libraries) required to make target work could not be found
            SLANG_FAIL other kinds of failures */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL checkPassThroughSupport(
            SlangPassThrough    passThrough) = 0;

            /** Compile from (embedded source) the StdLib on the session.
            Will return a failure if there is already a StdLib available
            NOTE! API is experimental and not ready for production code
            @param flags to control compilation
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL compileStdLib(CompileStdLibFlags flags) = 0;

            /** Load the StdLib. Currently loads modules from the file system. 
            @param stdLib Start address of the serialized stdlib
            @param stdLibSizeInBytes The size in bytes of the serialized stdlib

            NOTE! API is experimental and not ready for production code
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadStdLib(const void* stdLib, size_t stdLibSizeInBytes) = 0;

            /** Save the StdLib modules to the file system
            @param archiveType The type of archive used to hold the stdlib
            @param outBlob The serialized blob containing the standard library

            NOTE! API is experimental and not ready for production code  */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveStdLib(SlangArchiveType archiveType, ISlangBlob** outBlob) = 0;

            /** Look up the internal ID of a capability by its `name`.

            Capability IDs are *not* guaranteed to be stable across versions
            of the Slang library, so clients are expected to look up
            capabilities by name at runtime.
            */
        virtual SLANG_NO_THROW SlangCapabilityID SLANG_MCALL findCapability(
            char const*     name) = 0;

            /** Set the downstream/pass through compiler to be used for a transition from the source type to the target type
            @param source The source 'code gen target'
            @param target The target 'code gen target'
            @param compiler The compiler/pass through to use for the transition from source to target
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerForTransition(SlangCompileTarget source, SlangCompileTarget target, SlangPassThrough compiler) = 0;

            /** Get the downstream/pass through compiler for a transition specified by source and target
            @param source The source 'code gen target'
            @param target The target 'code gen target'
            @return The compiler that is used for the transition. Returns SLANG_PASS_THROUGH_NONE it is not defined
            */
        virtual SLANG_NO_THROW SlangPassThrough SLANG_MCALL getDownstreamCompilerForTransition(SlangCompileTarget source, SlangCompileTarget target) = 0;

            /** Get the time in seconds spent in the downstream compiler.
            @return The time spent in the downstream compiler in the current global session.
            */
        virtual SLANG_NO_THROW double SLANG_MCALL getDownstreamCompilerElapsedTime() = 0;
    };

    #define SLANG_UUID_IGlobalSession IGlobalSession::getTypeGuid()

    /*!
    @brief A request for one or more compilation actions to be performed.
    */
    struct ICompileRequest : public ISlangUnknown
    {
        SLANG_COM_INTERFACE( 0x96d33993, 0x317c, 0x4db5, { 0xaf, 0xd8, 0x66, 0x6e, 0xe7, 0x72, 0x48, 0xe2 } )
   
            /** Set the filesystem hook to use for a compile request

            The provided `fileSystem` will be used to load any files that
            need to be loaded during processing of the compile `request`.
            This includes:

              - Source files loaded via `spAddTranslationUnitSourceFile`
              - Files referenced via `#include`
              - Files loaded to resolve `#import` operations
                */
        virtual SLANG_NO_THROW void SLANG_MCALL setFileSystem(
            ISlangFileSystem*       fileSystem) = 0;

            /*!
            @brief Set flags to be used for compilation.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setCompileFlags(
            SlangCompileFlags       flags) = 0;

            /*!
            @brief Returns the compilation flags previously set with `setCompileFlags`
            */
        virtual SLANG_NO_THROW SlangCompileFlags SLANG_MCALL getCompileFlags() = 0;

            /*!
            @brief Set whether to dump intermediate results (for debugging) or not.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setDumpIntermediates(
            int                     enable) = 0;

        virtual SLANG_NO_THROW void SLANG_MCALL setDumpIntermediatePrefix(
            const char* prefix) = 0;

            /*!
            @brief Set whether (and how) `#line` directives should be output.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setLineDirectiveMode(
            SlangLineDirectiveMode  mode) = 0;

            /*!
            @brief Sets the target for code generation.
            @param target The code generation target. Possible values are:
            - SLANG_GLSL. Generates GLSL code.
            - SLANG_HLSL. Generates HLSL code.
            - SLANG_SPIRV. Generates SPIR-V code.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setCodeGenTarget(
            SlangCompileTarget target) = 0;

            /*!
            @brief Add a code-generation target to be used.
            */
        virtual SLANG_NO_THROW int SLANG_MCALL addCodeGenTarget(
            SlangCompileTarget      target) = 0;

        virtual SLANG_NO_THROW void SLANG_MCALL setTargetProfile(
            int                     targetIndex,
            SlangProfileID          profile) = 0;

        virtual SLANG_NO_THROW void SLANG_MCALL setTargetFlags(
            int                     targetIndex,
            SlangTargetFlags        flags) = 0;


            /*!
            @brief Set the floating point mode (e.g., precise or fast) to use a target.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setTargetFloatingPointMode(
            int                     targetIndex,
            SlangFloatingPointMode  mode) = 0;

            /* DEPRECATED: use `spSetMatrixLayoutMode` instead. */
        virtual SLANG_NO_THROW void SLANG_MCALL setTargetMatrixLayoutMode(
            int                     targetIndex,
            SlangMatrixLayoutMode   mode) = 0;

        virtual SLANG_NO_THROW void SLANG_MCALL setMatrixLayoutMode(
            SlangMatrixLayoutMode   mode) = 0;

            /*!
            @brief Set the level of debug information to produce.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setDebugInfoLevel(
            SlangDebugInfoLevel     level) = 0;

            /*!
            @brief Set the level of optimization to perform.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setOptimizationLevel(
            SlangOptimizationLevel  level) = 0;


    
            /*!
            @brief Set the container format to be used for binary output.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setOutputContainerFormat(
            SlangContainerFormat    format) = 0;

        virtual SLANG_NO_THROW void SLANG_MCALL setPassThrough(
            SlangPassThrough        passThrough) = 0;

    
        virtual SLANG_NO_THROW void SLANG_MCALL setDiagnosticCallback(
            SlangDiagnosticCallback callback,
            void const*             userData) = 0;

        virtual SLANG_NO_THROW void SLANG_MCALL setWriter(
            SlangWriterChannel      channel, 
            ISlangWriter*           writer) = 0;

        virtual SLANG_NO_THROW ISlangWriter* SLANG_MCALL getWriter(
            SlangWriterChannel      channel) = 0;

            /*!
            @brief Add a path to use when searching for referenced files.
            This will be used for both `#include` directives and also for explicit `__import` declarations.
            @param ctx The compilation context.
            @param searchDir The additional search directory.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL addSearchPath(
            const char*             searchDir) = 0;

            /*!
            @brief Add a macro definition to be used during preprocessing.
            @param key The name of the macro to define.
            @param value The value of the macro to define.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL addPreprocessorDefine(
            const char*             key,
            const char*             value) = 0;

            /*!
            @brief Set options using arguments as if specified via command line.
            @return Returns SlangResult. On success SLANG_SUCCEEDED(result) is true.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL processCommandLineArguments(
            char const* const*      args,
            int                     argCount) = 0;

            /** Add a distinct translation unit to the compilation request

            `name` is optional. 
            Returns the zero-based index of the translation unit created.
            */
        virtual SLANG_NO_THROW int SLANG_MCALL addTranslationUnit(
            SlangSourceLanguage     language,
            char const*             name) = 0;

    
            /** Set a default module name. Translation units will default to this module name if one is not
            passed. If not set each translation unit will get a unique name. 
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setDefaultModuleName(
            const char* defaultModuleName) = 0;

            /** Add a preprocessor definition that is scoped to a single translation unit.

            @param translationUnitIndex The index of the translation unit to get the definition.
            @param key The name of the macro to define.
            @param value The value of the macro to define.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitPreprocessorDefine(
            int                     translationUnitIndex,
            const char*             key,
            const char*             value) = 0;


            /** Add a source file to the given translation unit.

            If a user-defined file system has been specified via
            `spSetFileSystem`, then it will be used to load the
            file at `path`. Otherwise, Slang will use the OS
            file system.

            This function does *not* search for a file using
            the registered search paths (`spAddSearchPath`),
            and instead using the given `path` as-is.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitSourceFile(
            int                     translationUnitIndex,
            char const*             path) = 0;

            /** Add a source string to the given translation unit.

            @param translationUnitIndex The index of the translation unit to add source to.
            @param path The file-system path that should be assumed for the source code.
            @param source A null-terminated UTF-8 encoded string of source code.

            The implementation will make a copy of the source code data.
            An application may free the buffer immediately after this call returns.

            The `path` will be used in any diagnostic output, as well
            as to determine the base path when resolving relative
            `#include`s.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitSourceString(
            int                     translationUnitIndex,
            char const*             path,
            char const*             source) = 0;


            /** Add a slang library - such that its contents can be referenced during linking.
            This is equivalent to the -r command line option.

            @param libData The library data
            @param libDataSize The size of the library data
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL addLibraryReference(
            const void* libData,
            size_t libDataSize) = 0;

            /** Add a source string to the given translation unit.

            @param translationUnitIndex The index of the translation unit to add source to.
            @param path The file-system path that should be assumed for the source code.
            @param sourceBegin A pointer to a buffer of UTF-8 encoded source code.
            @param sourceEnd A pointer to to the end of the buffer specified in `sourceBegin`

            The implementation will make a copy of the source code data.
            An application may free the buffer immediately after this call returns.

            The `path` will be used in any diagnostic output, as well
            as to determine the base path when resolving relative
            `#include`s.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitSourceStringSpan(
            int                     translationUnitIndex,
            char const*             path,
            char const*             sourceBegin,
            char const*             sourceEnd) = 0;

            /** Add a blob of source code to the given translation unit.

            @param translationUnitIndex The index of the translation unit to add source to.
            @param path The file-system path that should be assumed for the source code.
            @param sourceBlob A blob containing UTF-8 encoded source code.
            @param sourceEnd A pointer to to the end of the buffer specified in `sourceBegin`

            The compile request will retain a reference to the blob.

            The `path` will be used in any diagnostic output, as well
            as to determine the base path when resolving relative
            `#include`s.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitSourceBlob(
            int                     translationUnitIndex,
            char const*             path,
            ISlangBlob*             sourceBlob) = 0;

            /** Add an entry point in a particular translation unit
            */
        virtual SLANG_NO_THROW int SLANG_MCALL addEntryPoint(
            int                     translationUnitIndex,
            char const*             name,
            SlangStage              stage) = 0;

            /** Add an entry point in a particular translation unit,
                with additional arguments that specify the concrete
                type names for entry-point generic type parameters.
            */
        virtual SLANG_NO_THROW int SLANG_MCALL addEntryPointEx(
            int                     translationUnitIndex,
            char const*             name,
            SlangStage              stage,
            int                     genericArgCount,
            char const**            genericArgs) = 0;

            /** Specify the arguments to use for global generic parameters.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setGlobalGenericArgs(
            int                     genericArgCount,
            char const**            genericArgs) = 0;

            /** Specify the concrete type to be used for a global "existential slot."

            Every shader parameter (or leaf field of a `struct`-type shader parameter)
            that has an interface or array-of-interface type introduces an existential
            slot. The number of slots consumed by a shader parameter, and the starting
            slot of each parameter can be queried via the reflection API using
            `SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM`.

            In order to generate specialized code, a concrete type needs to be specified
            for each existential slot. This function specifies the name of the type
            (or in general a type *expression*) to use for a specific slot at the
            global scope.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setTypeNameForGlobalExistentialTypeParam(
            int                     slotIndex,
            char const*             typeName) = 0;

            /** Specify the concrete type to be used for an entry-point "existential slot."

            Every shader parameter (or leaf field of a `struct`-type shader parameter)
            that has an interface or array-of-interface type introduces an existential
            slot. The number of slots consumed by a shader parameter, and the starting
            slot of each parameter can be queried via the reflection API using
            `SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM`.

            In order to generate specialized code, a concrete type needs to be specified
            for each existential slot. This function specifies the name of the type
            (or in general a type *expression*) to use for a specific slot at the
            entry-point scope.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setTypeNameForEntryPointExistentialTypeParam(
            int                     entryPointIndex,
            int                     slotIndex,
            char const*             typeName) = 0;

            /** Execute the compilation request.

            @returns  SlangResult, SLANG_OK on success. Use SLANG_SUCCEEDED() and SLANG_FAILED() to test SlangResult.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile() = 0;


            /** Get any diagnostic messages reported by the compiler.

            @returns A null-terminated UTF-8 encoded string of diagnostic messages.

            The returned pointer is only guaranteed to be valid
            until `request` is destroyed. Applications that wish to
            hold on to the diagnostic output for longer should use
            `getDiagnosticOutputBlob`.
            */
        virtual SLANG_NO_THROW char const* SLANG_MCALL getDiagnosticOutput() = 0;

            /** Get diagnostic messages reported by the compiler.

            @param outBlob A pointer to receive a blob holding a nul-terminated UTF-8 encoded string of diagnostic messages.
            @returns A `SlangResult` indicating success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getDiagnosticOutputBlob(
            ISlangBlob**            outBlob) = 0;


            /** Get the number of files that this compilation depended on.

            This includes both the explicit source files, as well as any
            additional files that were transitively referenced (e.g., via
            a `#include` directive).
            */
        virtual SLANG_NO_THROW int SLANG_MCALL getDependencyFileCount() = 0;

            /** Get the path to a file this compilation depended on.
            */
        virtual SLANG_NO_THROW char const* SLANG_MCALL getDependencyFilePath(
            int                     index) = 0;

            /** Get the number of translation units associated with the compilation request
            */
        virtual SLANG_NO_THROW int SLANG_MCALL getTranslationUnitCount() = 0;

            /** Get the output source code associated with a specific entry point.

            The lifetime of the output pointer is the same as `request`.
            */
        virtual SLANG_NO_THROW char const* SLANG_MCALL getEntryPointSource(
            int                     entryPointIndex) = 0;

            /** Get the output bytecode associated with a specific entry point.

            The lifetime of the output pointer is the same as `request`.
            */
        virtual SLANG_NO_THROW void const* SLANG_MCALL getEntryPointCode(
            int                     entryPointIndex,
            size_t*                 outSize) = 0;

            /** Get the output code associated with a specific entry point.

            @param entryPointIndex The index of the entry point to get code for.
            @param targetIndex The index of the target to get code for (default: zero).
            @param outBlob A pointer that will receive the blob of code
            @returns A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointCodeBlob(
            int                     entryPointIndex,
            int                     targetIndex,
            ISlangBlob**            outBlob) = 0;

            /** Get entry point 'callable' functions accessible through the ISlangSharedLibrary interface.

            That the functions remain in scope as long as the ISlangSharedLibrary interface is in scope.

            NOTE! Requires a compilation target of SLANG_HOST_CALLABLE.
    
            @param entryPointIndex  The index of the entry point to get code for.
            @param targetIndex      The index of the target to get code for (default: zero).
            @param outSharedLibrary A pointer to a ISharedLibrary interface which functions can be queried on.
            @returns                A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable(
            int                     entryPointIndex,
            int                     targetIndex,
            ISlangSharedLibrary**   outSharedLibrary) = 0;

            /** Get the output code associated with a specific target.

            @param targetIndex The index of the target to get code for (default: zero).
            @param outBlob A pointer that will receive the blob of code
            @returns A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTargetCodeBlob(
            int                     targetIndex,
            ISlangBlob**            outBlob) = 0;

            /** Get 'callable' functions for a target accessible through the ISlangSharedLibrary interface.

            That the functions remain in scope as long as the ISlangSharedLibrary interface is in scope.

            NOTE! Requires a compilation target of SLANG_HOST_CALLABLE.
    
            @param targetIndex      The index of the target to get code for (default: zero).
            @param outSharedLibrary A pointer to a ISharedLibrary interface which functions can be queried on.
            @returns                A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTargetHostCallable(
            int                     targetIndex,
            ISlangSharedLibrary**   outSharedLibrary) = 0;

            /** Get the output bytecode associated with an entire compile request.

            The lifetime of the output pointer is the same as `request` and the last spCompile.

            @param outSize          The size of the containers contents in bytes. Will be zero if there is no code available.
            @returns                Pointer to start of the contained data, or nullptr if there is no code available.
            */
        virtual SLANG_NO_THROW void const* SLANG_MCALL getCompileRequestCode(
            size_t*                 outSize) = 0;

            /** Return the container code as a blob. The container blob is created as part of a compilation (with spCompile),
            and a container is produced with a suitable ContainerFormat. 

            @param outSize          The blob containing the container data. 
            @returns                A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getContainerCode(
            ISlangBlob**            outBlob) = 0;

            /** Load repro from memory specified.

            Should only be performed on a newly created request.

            NOTE! When using the fileSystem, files will be loaded via their `unique names` as if they are part of the flat file system. This
            mechanism is described more fully in docs/repro.md.

            @param fileSystem       An (optional) filesystem. Pass nullptr to just use contents of repro held in data.
            @param data             The data to load from.
            @param size             The size of the data to load from. 
            @returns                A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadRepro(
            ISlangFileSystem* fileSystem,
            const void* data,
            size_t size) = 0;

            /** Save repro state. Should *typically* be performed after spCompile, so that everything
            that is needed for a compilation is available. 

            @param outBlob          Blob that will hold the serialized state
            @returns                A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveRepro(
            ISlangBlob** outBlob) = 0;

            /** Enable repro capture.

            Should be set after any ISlangFileSystem has been set, but before any compilation. It ensures that everything
            that the ISlangFileSystem accesses will be correctly recorded.
            Note that if a ISlangFileSystem/ISlangFileSystemExt isn't explicitly set (ie the default is used), then the
            request will automatically be set up to record everything appropriate. 

            @returns                A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL enableReproCapture() = 0;

            /** Get the (linked) program for a compile request.

            The linked program will include all of the global-scope modules for the
            translation units in the program, plus any modules that they `import`
            (transitively), specialized to any global specialization arguments that
            were provided via the API.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getProgram(
            slang::IComponentType** outProgram) = 0;

            /** Get the (partially linked) component type for an entry point.

            The returned component type will include the entry point at the
            given index, and will be specialized using any specialization arguments
            that were provided for it via the API.

            The returned component will *not* include the modules representing
            the global scope and its dependencies/specialization, so a client
            program will typically want to compose this component type with
            the one returned by `spCompileRequest_getProgram` to get a complete
            and usable component type from which kernel code can be requested.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPoint(
            SlangInt                entryPointIndex,
            slang::IComponentType** outEntryPoint) = 0;

            /** Get the (un-linked) module for a translation unit.

            The returned module will not be linked against any dependencies,
            nor against any entry points (even entry points declared inside
            the module). Similarly, the module will not be specialized
            to the arguments that might have been provided via the API.

            This function provides an atomic unit of loaded code that
            is suitable for looking up types and entry points in the
            given module, and for linking together to produce a composite
            program that matches the needs of an application.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getModule(
            SlangInt                translationUnitIndex,
            slang::IModule**        outModule) = 0;

            /** Get the `ISession` handle behind the `SlangCompileRequest`.
            TODO(JS): Arguably this should just return the session pointer.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getSession(
            slang::ISession** outSession) = 0;

            /** get reflection data from a compilation request */
        virtual SLANG_NO_THROW SlangReflection* SLANG_MCALL getReflection() = 0;

            /** Make output specially handled for command line output */
        virtual SLANG_NO_THROW void SLANG_MCALL setCommandLineCompilerMode() = 0;

            /** Add a defined capability that should be assumed available on the target */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL addTargetCapability(
            SlangInt            targetIndex,
            SlangCapabilityID   capability) = 0;

            /** Get the (linked) program for a compile request, including all entry points.

            The resulting program will include all of the global-scope modules for the
            translation units in the program, plus any modules that they `import`
            (transitively), specialized to any global specialization arguments that
            were provided via the API, as well as all entry points specified for compilation,
            specialized to their entry-point specialization arguments.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getProgramWithEntryPoints(
            slang::IComponentType** outProgram) = 0;

        virtual SLANG_NO_THROW SlangResult SLANG_MCALL isParameterLocationUsed(
            SlangInt entryPointIndex,
            SlangInt targetIndex,
            SlangParameterCategory category,
            SlangUInt spaceIndex,
            SlangUInt registerIndex,
            bool& outUsed) = 0;

            /** Set the line directive mode for a target.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setTargetLineDirectiveMode(
            SlangInt targetIndex,
            SlangLineDirectiveMode mode) = 0;

            /** Set whether to use scalar buffer layouts for GLSL/Vulkan targets.
                If true, the generated GLSL/Vulkan code will use `scalar` layout for storage buffers.
                If false, the resulting code will std430 for storage buffers.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL setTargetForceGLSLScalarBufferLayout(int targetIndex, bool forceScalarLayout) = 0;

            /** Overrides the severity of a specific diagnostic message.

            @param messageID            Numeric identifier of the message to override,
                                        as defined in the 1st parameter of the DIAGNOSTIC macro.
            @param overrideSeverity     New severity of the message. If the message is originally Error or Fatal,
                                        the new severity cannot be lower than that.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL overrideDiagnosticSeverity(
            SlangInt messageID,
            SlangSeverity overrideSeverity) = 0;

            /** Returns the currently active flags of the request's diagnostic sink. */
        virtual SLANG_NO_THROW SlangDiagnosticFlags SLANG_MCALL getDiagnosticFlags() = 0;

            /** Sets the flags of the request's diagnostic sink.
                The previously specified flags are discarded. */
        virtual SLANG_NO_THROW void SLANG_MCALL setDiagnosticFlags(SlangDiagnosticFlags flags) = 0;
    };

    #define SLANG_UUID_ICompileRequest ICompileRequest::getTypeGuid()

        /** Description of a code generation target.
        */
    struct TargetDesc
    {
            /** The size of this structure, in bytes.
            */
        size_t structureSize = sizeof(TargetDesc);

            /** The target format to generate code for (e.g., SPIR-V, DXIL, etc.)
            */
        SlangCompileTarget      format = SLANG_TARGET_UNKNOWN;

            /** The compilation profile supported by the target (e.g., "Shader Model 5.1")
            */
        SlangProfileID          profile = SLANG_PROFILE_UNKNOWN;

            /** Flags for the code generation target. Currently unused. */
        SlangTargetFlags        flags = 0;

            /** Default mode to use for floating-point operations on the target.
            */
        SlangFloatingPointMode  floatingPointMode = SLANG_FLOATING_POINT_MODE_DEFAULT;

            /** Optimization level to use for the target.
            */
        SlangOptimizationLevel optimizationLevel = SLANG_OPTIMIZATION_LEVEL_DEFAULT;

            /** The line directive mode for output source code.
            */
        SlangLineDirectiveMode lineDirectiveMode = SLANG_LINE_DIRECTIVE_MODE_DEFAULT;

            /** Whether to force `scalar` layout for glsl shader storage buffers.
            */
        bool forceGLSLScalarBufferLayout = false;
    };

    typedef uint32_t SessionFlags;
    enum
    {
        kSessionFlags_None = 0,

        /** Use application-specific policy for semantics of the `shared` keyword.
        
        This is a legacy/compatibility flag to help an existing Slang client
        migrate to new language features, and should *not* be used by other
        clients. This feature may be removed in a future release without a
        deprecation warning, and this bit may be re-used for another feature.
        You have been warned.
        */
        kSessionFlag_FalcorCustomSharedKeywordSemantics = 1 << 0,
    };

    struct PreprocessorMacroDesc
    {
        const char* name;
        const char* value;
    };

    struct SessionDesc
    {
            /** The size of this structure, in bytes.
             */
        size_t structureSize = sizeof(SessionDesc);

            /** Code generation targets to include in the session.
            */
        TargetDesc const*   targets = nullptr;
        SlangInt            targetCount = 0;

            /** Flags to configure the session.
            */
        SessionFlags flags = kSessionFlags_None;

            /** Default layout to assume for variables with matrix types.
            */
        SlangMatrixLayoutMode defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_ROW_MAJOR;

            /** Paths to use when searching for `#include`d or `import`ed files.
            */
        char const* const*  searchPaths = nullptr;
        SlangInt            searchPathCount = 0;

        PreprocessorMacroDesc const*    preprocessorMacros = nullptr;
        SlangInt                        preprocessorMacroCount = 0;

        ISlangFileSystem* fileSystem = nullptr;
    };

    enum class ContainerType
    {
        None, UnsizedArray, StructuredBuffer, ConstantBuffer, ParameterBlock
    };

    // A struct storing a single hash represented as a four element uint32_t array.
    // This is intended to be used with the current MD5 hashing implementation.
    struct Digest
    {
        uint32_t values[4] = { 0 };

        bool operator==(const Digest& rhs)
        {
            return values[0] == rhs.values[0]
                && values[1] == rhs.values[1]
                && values[2] == rhs.values[2]
                && values[3] == rhs.values[3];
        }

        uint32_t getHashCode()
        {
            return values[0];
        }
    };

        /** A session provides a scope for code that is loaded.

        A session can be used to load modules of Slang source code,
        and to request target-specific compiled binaries and layout
        information.

        In order to be able to load code, the session owns a set
        of active "search paths" for resolving `#include` directives
        and `import` declrations, as well as a set of global
        preprocessor definitions that will be used for all code
        that gets `import`ed in the session.

        If multiple user shaders are loaded in the same session,
        and import the same module (e.g., two source files do `import X`)
        then there will only be one copy of `X` loaded within the session.

        In order to be able to generate target code, the session
        owns a list of available compilation targets, which specify
        code generation options.

        Code loaded and compiled within a session is owned by the session
        and will remain resident in memory until the session is released.
        Applications wishing to control the memory usage for compiled
        and loaded code should use multiple sessions.
        */
    struct ISession : public ISlangUnknown
    {
        SLANG_COM_INTERFACE( 0x67618701, 0xd116, 0x468f, { 0xab, 0x3b, 0x47, 0x4b, 0xed, 0xce, 0xe, 0x3d } )

            /** Get the global session thas was used to create this session.
            */
        virtual SLANG_NO_THROW IGlobalSession* SLANG_MCALL getGlobalSession() = 0;

            /** Load a module as it would be by code using `import`.
            */
        virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModule(
            const char* moduleName,
            IBlob**     outDiagnostics = nullptr) = 0;

            /** Load a module from Slang source code.
            */
        virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModuleFromSource(
            const char* moduleName,
            const char* path,
            slang::IBlob* source,
            slang::IBlob** outDiagnostics = nullptr) = 0;

            /** Combine multiple component types to create a composite component type.

            The `componentTypes` array must contain `componentTypeCount` pointers
            to component types that were loaded or created using the same session.

            The shader parameters and specialization parameters of the composite will
            be the union of those in `componentTypes`. The relative order of child
            component types is significant, and will affect the order in which
            parameters are reflected and laid out.

            The entry-point functions of the composite will be the union of those in
            `componentTypes`, and will follow the ordering of `componentTypes`.

            The requirements of the composite component type will be a subset of
            those in `componentTypes`. If an entry in `componentTypes` has a requirement
            that can be satisfied by another entry, then the composition will
            satisfy the requirement and it will not appear as a requirement of
            the composite. If multiple entries in `componentTypes` have a requirement
            for the same type, then only the first such requirement will be retained
            on the composite. The relative ordering of requirements on the composite
            will otherwise match that of `componentTypes`.

            If any diagnostics are generated during creation of the composite, they
            will be written to `outDiagnostics`. If an error is encountered, the
            function will return null.

            It is an error to create a composite component type that recursively
            aggregates the a single module more than once.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCompositeComponentType(
            IComponentType* const*  componentTypes,
            SlangInt                componentTypeCount,
            IComponentType**        outCompositeComponentType,
            ISlangBlob**            outDiagnostics = nullptr) = 0;

            /** Specialize a type based on type arguments.
            */
        virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL specializeType(
            TypeReflection*             type,
            SpecializationArg const*    specializationArgs,
            SlangInt                    specializationArgCount,
            ISlangBlob**                outDiagnostics = nullptr) = 0;


            /** Get the layout `type` on the chosen `target`.
            */
        virtual SLANG_NO_THROW TypeLayoutReflection* SLANG_MCALL getTypeLayout(
            TypeReflection* type,
            SlangInt        targetIndex = 0,
            LayoutRules     rules = LayoutRules::Default,
            ISlangBlob**    outDiagnostics = nullptr) = 0;

            /** Get a container type from `elementType`. For example, given type `T`, returns
                a type that represents `StructuredBuffer<T>`.

                @param `elementType`: the element type to wrap around.
                @param `containerType`: the type of the container to wrap `elementType` in.
                @param `outDiagnostics`: a blob to receive diagnostic messages.
            */
        virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL getContainerType(
            TypeReflection* elementType,
            ContainerType containerType,
            ISlangBlob** outDiagnostics = nullptr) = 0;

            /** Return a `TypeReflection` that represents the `__Dynamic` type.
                This type can be used as a specialization argument to indicate using
                dynamic dispatch.
            */
        virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL getDynamicType() = 0;

            /** Get the mangled name for a type RTTI object.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTypeRTTIMangledName(
            TypeReflection* type,
            ISlangBlob** outNameBlob) = 0;

            /** Get the mangled name for a type witness.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTypeConformanceWitnessMangledName(
            TypeReflection* type,
            TypeReflection* interfaceType,
            ISlangBlob** outNameBlob) = 0;

            /** Get the sequential ID used to identify a type witness in a dynamic object.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTypeConformanceWitnessSequentialID(
            slang::TypeReflection* type,
            slang::TypeReflection* interfaceType,
            uint32_t*              outId) = 0;

            /** Create a request to load/compile front-end code.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCompileRequest(
            SlangCompileRequest**   outCompileRequest) = 0;

        
            /** Creates a `IComponentType` that represents a type's conformance to an interface.
                The retrieved `ITypeConformance` objects can be included in a composite `IComponentType`
                to explicitly specify which implementation types should be included in the final compiled
                code. For example, if an module defines `IMaterial` interface and `AMaterial`,
                `BMaterial`, `CMaterial` types that implements the interface, the user can exclude
                `CMaterial` implementation from the resulting shader code by explcitly adding
                `AMaterial:IMaterial` and `BMaterial:IMaterial` conformances to a composite
                `IComponentType` and get entry point code from it. The resulting code will not have
                anything related to `CMaterial` in the dynamic dispatch logic. If the user does not
                explicitly include any `TypeConformances` to an interface type, all implementations to
                that interface will be included by default. By linking a `ITypeConformance`, the user is
                also given the opportunity to specify the dispatch ID of the implementation type. If
                `conformanceIdOverride` is -1, there will be no override behavior and Slang will
                automatically assign IDs to implementation types. The automatically assigned IDs can be
                queried via `ISession::getTypeConformanceWitnessSequentialID`.

                Returns SLANG_OK if succeeds, or SLANG_FAIL if `type` does not conform to `interfaceType`.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createTypeConformanceComponentType(
            slang::TypeReflection* type,
            slang::TypeReflection* interfaceType,
            ITypeConformance** outConformance,
            SlangInt conformanceIdOverride,
            ISlangBlob** outDiagnostics) = 0;
    };

    #define SLANG_UUID_ISession ISession::getTypeGuid()

        /** A component type is a unit of shader code layout, reflection, and linking.

        A component type is a unit of shader code that can be included into
        a linked and compiled shader program. Each component type may have:

        * Zero or more uniform shader parameters, representing textures,
          buffers, etc. that the code in the component depends on.

        * Zero or more *specialization* parameters, which are type or
          value parameters that can be used to synthesize specialized
          versions of the component type.

        * Zero or more entry points, which are the individually invocable
          kernels that can have final code generated.

        * Zero or more *requirements*, which are other component
          types on which the component type depends.

        One example of a component type is a module of Slang code:

        * The global-scope shader parameters declared in the module are
          the parameters when considered as a component type.

        * Any global-scope generic or interface type parameters introduce
          specialization parameters for the module.

        * A module does not by default include any entry points when
          considered as a component type (although the code of the
          module might *declare* some entry points).

        * Any other modules that are `import`ed in the source code
          become requirements of the module, when considered as a
          component type.

        An entry point is another example of a component type:

        * The `uniform` parameters of the entry point function are
          its shader parameters when considered as a component type.

        * Any generic or interface-type parameters of the entry point
          introduce specialization parameters.

        * An entry point component type exposes a single entry point (itself).

        * An entry point has one requirement for the module in which
          it was defined.

        Component types can be manipulated in a few ways:

        * Multiple component types can be combined into a composite, which
          combines all of their code, parameters, etc.

        * A component type can be specialized, by "plugging in" types and
          values for its specialization parameters.

        * A component type can be laid out for a particular target, giving
          offsets/bindings to the shader parameters it contains.

        * Generated kernel code can be requested for entry points.

        */
    struct IComponentType : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(0x5bc42be8, 0x5c50, 0x4929, { 0x9e, 0x5e, 0xd1, 0x5e, 0x7c, 0x24, 0x1, 0x5f })

            /** Get the runtime session that this component type belongs to.
            */
        virtual SLANG_NO_THROW ISession* SLANG_MCALL getSession() = 0;

            /** Get the layout for this program for the chosen `targetIndex`.

            The resulting layout will establish offsets/bindings for all
            of the global and entry-point shader parameters in the
            component type.

            If this component type has specialization parameters (that is,
            it is not fully specialized), then the resulting layout may
            be incomplete, and plugging in arguments for generic specialization
            parameters may result in a component type that doesn't have
            a compatible layout. If the component type only uses
            interface-type specialization parameters, then the layout
            for a specialization should be compatible with an unspecialized
            layout (all parameters in the unspecialized layout will have
            the same offset/binding in the specialized layout).

            If this component type is combined into a composite, then
            the absolute offsets/bindings of parameters may not stay the same.
            If the shader parameters in a component type don't make
            use of explicit binding annotations (e.g., `register(...)`),
            then the *relative* offset of shader parameters will stay
            the same when it is used in a composition.
            */
        virtual SLANG_NO_THROW ProgramLayout* SLANG_MCALL getLayout(
            SlangInt    targetIndex = 0,
            IBlob**     outDiagnostics = nullptr) = 0;

            /** Get the number of (unspecialized) specialization parameters for the component type.
            */
        virtual SLANG_NO_THROW SlangInt SLANG_MCALL getSpecializationParamCount() = 0;

            /** Get the compiled code for the entry point at `entryPointIndex` for the chosen `targetIndex`

            Entry point code can only be computed for a component type that
            has no specialization parameters (it must be fully specialized)
            and that has no requirements (it must be fully linked).

            If code has not already been generated for the given entry point and target,
            then a compilation error may be detected, in which case `outDiagnostics`
            (if non-null) will be filled in with a blob of messages diagnosing the error.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointCode(
            SlangInt    entryPointIndex,
            SlangInt    targetIndex,
            IBlob**     outCode,
            IBlob**     outDiagnostics = nullptr) = 0;

            /** Compute the hash code of all dependencies for this component type. This generally means file path
                dependencies but can also include the component's name or sub-components. The dependency-based
                hash effectively represents all the files that may be included/imported by a component type along with
                any non-code-specific that helps define a component. This can be useful to simply check for a component
                type without needing to inspect the code. For example, a shader cache might key its entries using the
                dependency-based hash in order to determine at a glance if a particular shader is present, with no
                regard for the shader's contents.

                This function should only have a meaningful implementation in ComponentType. All other types derived from
                ComponentType that also inherit from IComponentType should do nothing.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash(
            SlangInt entryPointIndex,
            SlangInt targetIndex,
            Digest* outHash) = 0;

            /** Compute the hash code of this component type's contents as indicated by the file dependencies.
                This hash is ideal when we need to confirm whether shader code changes have occurred. For example,
                a shader cache needs to be able to check when a cache entry contains out-of-date code, which can be
                easily detected by comparing the contents-based hashes since they will directly reflect any change
                to the shader's code.

                This function should only have a meaningful implementation in ComponentType. All other types derived
                from ComponentType that also inherit from IComponentType should do nothing. However, the only component
                type that should ever be hashing its contents is Module as it represents all the code in a given
                translation unit.
            */
        virtual SLANG_NO_THROW void SLANG_MCALL computeContentsBasedHash(Digest* outHash) = 0;

            /** Specialize the component by binding its specialization parameters to concrete arguments.

            The `specializationArgs` array must have `specializationArgCount` entries, and
            this must match the number of specialization parameters on this component type.

            If any diagnostics (error or warnings) are produced, they will be written to `outDiagnostics`.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL specialize(
            SpecializationArg const*    specializationArgs,
            SlangInt                    specializationArgCount,
            IComponentType**            outSpecializedComponentType,
            ISlangBlob**                outDiagnostics = nullptr) = 0;

            /** Link this component type against all of its unsatisifed dependencies.
            
            A component type may have unsatisfied dependencies. For example, a module
            depends on any other modules it `import`s, and an entry point depends
            on the module that defined it.

            A user can manually satisfy dependencies by creating a composite
            component type, and when doing so they retain full control over
            the relative ordering of shader parameters in the resulting layout.

            It is an error to try to generate/access compiled kernel code for
            a component type with unresolved dependencies, so if dependencies
            remain after whatever manual composition steps an application
            cares to peform, the `link()` function can be used to automatically
            compose in any remaining dependencies. The order of parameters
            (and hence the global layout) that results will be deterministic,
            but is not currently documented.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL link(
            IComponentType**            outLinkedComponentType,
            ISlangBlob**                outDiagnostics = nullptr) = 0;

            /** Get entry point 'callable' functions accessible through the ISlangSharedLibrary interface.

            The functions remain in scope as long as the ISlangSharedLibrary interface is in scope.

            NOTE! Requires a compilation target of SLANG_HOST_CALLABLE.
    
            @param entryPointIndex  The index of the entry point to get code for.
            @param targetIndex      The index of the target to get code for (default: zero).
            @param outSharedLibrary A pointer to a ISharedLibrary interface which functions can be queried on.
            @returns                A `SlangResult` to indicate success or failure.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable(
            int                     entryPointIndex,
            int                     targetIndex,
            ISlangSharedLibrary**   outSharedLibrary,
            slang::IBlob**          outDiagnostics = 0) = 0;

            /** Get a new ComponentType object that represents a renamed entry point.

            The current object must be a single EntryPoint, or a CompositeComponentType or
            SpecializedComponentType that contains one EntryPoint component.
            */
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL renameEntryPoint(
            const char* newName, IComponentType** outEntryPoint) = 0;
    };
    #define SLANG_UUID_IComponentType IComponentType::getTypeGuid()

    struct IEntryPoint : public IComponentType
    {
        SLANG_COM_INTERFACE(0x8f241361, 0xf5bd, 0x4ca0, { 0xa3, 0xac, 0x2, 0xf7, 0xfa, 0x24, 0x2, 0xb8 })
    };

    #define SLANG_UUID_IEntryPoint IEntryPoint::getTypeGuid()

    struct ITypeConformance : public IComponentType
    {
        SLANG_COM_INTERFACE(0x73eb3147, 0xe544, 0x41b5, { 0xb8, 0xf0, 0xa2, 0x44, 0xdf, 0x21, 0x94, 0xb })
    };
    #define SLANG_UUID_ITypeConformance ITypeConformance::getTypeGuid()

        /** A module is the granularity of shader code compilation and loading.

        In most cases a module corresponds to a single compile "translation unit."
        This will often be a single `.slang` or `.hlsl` file and everything it
        `#include`s.

        Notably, a module `M` does *not* include the things it `import`s, as these
        as distinct modules that `M` depends on. There is a directed graph of
        module dependencies, and all modules in the graph must belong to the
        same session (`ISession`).

        A module establishes a namespace for looking up types, functions, etc.
        */
    struct IModule : public IComponentType
    {
        SLANG_COM_INTERFACE(0xc720e64, 0x8722, 0x4d31, { 0x89, 0x90, 0x63, 0x8a, 0x98, 0xb1, 0xc2, 0x79 })

        virtual SLANG_NO_THROW SlangResult SLANG_MCALL findEntryPointByName(
            char const*     name,
            IEntryPoint**   outEntryPoint) = 0;

        /// Get number of entry points defined in the module. An entry point defined in a module
        /// is by default not included in the linkage, so calls to `IComponentType::getEntryPointCount`
        /// on an `IModule` instance will always return 0. However `IModule::getDefinedEntryPointCount`
        /// will return the number of defined entry points.
        virtual SLANG_NO_THROW SlangInt32 SLANG_MCALL getDefinedEntryPointCount() = 0;
        /// Get the name of an entry point defined in the module.
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
            getDefinedEntryPoint(SlangInt32 index, IEntryPoint** outEntryPoint) = 0;
    };
    
    #define SLANG_UUID_IModule IModule::getTypeGuid()

        /** Argument used for specialization to types/values.
        */
    struct SpecializationArg
    {
        enum class Kind : int32_t
        {
            Unknown,    /**< An invalid specialization argument. */
            Type,       /**< Specialize to a type. */
        };

        /** The kind of specialization argument. */
        Kind kind;
        union
        {
            /** A type specialization argument, used for `Kind::Type`. */
            TypeReflection* type;
        };

        static SpecializationArg fromType(TypeReflection* inType)
        {
            SpecializationArg rs;
            rs.kind = Kind::Type;
            rs.type = inType;
            return rs;
        }
    };
}

// Passed into functions to create globalSession to identify the API version client code is
// using. 
#define SLANG_API_VERSION 0

/* Create a global session, with built in StdLib.

@param apiVersion Pass in SLANG_API_VERSION
@param outGlobalSession (out)The created global session. 
*/
SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSession(
    SlangInt                apiVersion,
    slang::IGlobalSession** outGlobalSession);

/* Create a global session, but do not set up the stdlib. The stdlib can
then be loaded via loadStdLib or compileStdLib

@param apiVersion Pass in SLANG_API_VERSION
@param outGlobalSession (out)The created global session that doesn't have a StdLib setup.

NOTE! API is experimental and not ready for production code 
*/
SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSessionWithoutStdLib(
    SlangInt                apiVersion,
    slang::IGlobalSession** outGlobalSession);

/* Returns a blob that contains the serialized stdlib.
Returns nullptr if there isn't an embedded stdlib.
*/
SLANG_API ISlangBlob* slang_getEmbeddedStdLib();

namespace slang
{
    inline SlangResult createGlobalSession(
        slang::IGlobalSession** outGlobalSession)
    {
        return slang_createGlobalSession(SLANG_API_VERSION, outGlobalSession);
    }
}

/** @see slang::ICompileRequest::getProgram
*/
SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getProgram(
    SlangCompileRequest*    request,
    slang::IComponentType** outProgram);

/** @see slang::ICompileRequest::getProgramWithEntryPoints
*/
SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getProgramWithEntryPoints(
    SlangCompileRequest*    request,
    slang::IComponentType** outProgram);

/** @see slang::ICompileRequest::getEntryPoint
*/
SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getEntryPoint(
    SlangCompileRequest*    request,
    SlangInt                entryPointIndex,
    slang::IComponentType** outEntryPoint);

/** @see slang::ICompileRequest::getModule
*/
SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getModule(
    SlangCompileRequest*    request,
    SlangInt                translationUnitIndex,
    slang::IModule**        outModule);

/** @see slang::ICompileRequest::getSession
*/
SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getSession(
    SlangCompileRequest* request,
    slang::ISession** outSession);
#endif

/* DEPRECATED DEFINITIONS

Everything below this point represents deprecated APIs/definition that are only
being kept around for source/binary compatibility with old client code. New
code should not use any of these declarations, and the Slang API will drop these
declarations over time.
*/

#ifdef __cplusplus
extern "C" {
#endif

#define SLANG_ERROR_INSUFFICIENT_BUFFER SLANG_E_BUFFER_TOO_SMALL
#define SLANG_ERROR_INVALID_PARAMETER SLANG_E_INVALID_ARG

SLANG_API char const* spGetTranslationUnitSource(
    SlangCompileRequest*    request,
    int                     translationUnitIndex);

#ifdef __cplusplus
}
#endif

#endif


================================================
FILE: Source/External/xmake.lua
================================================
add_requires("cereal")
add_requires("glfw", {configs = {shared = true}})
add_requires("spdlog")
add_requires("stb")
add_requires("glm")
add_requires("glslang sdk-1.3.250.1")
add_requires("spirv-cross")
add_requires("spirv-reflect sdk-1.3.250.1")
add_requires("directxshadercompiler")
add_requires("assimp", {configs = {shared = true}})
add_requires("imgui docking")
add_requires("nativefiledialog")
add_requires("meshoptimizer")
add_requires("mustache")
add_requires("slang")
add_requires("volk", {configs = {header_only = true}})
add_requires("vulkan-headers")
add_requires("vulkan-memory-allocator v3.0.0")

-- option("CUDA_ENABLE")
--     on_check(function (option)
--         import("detect.sdks.find_cuda")
--         local cuda = find_cuda()
--         if cuda then
--             option:enable(true)
--             option:add("defines", "CUDA_ENABLE")
--         else
--             option:enable(false)
--         end
--     end)
-- option_end()

-- if has_config("CUDA_ENABLE") then
--     add_requires("cuda")
-- end

target("ImGui-Tools")
    set_kind("static")

    add_files("imgui_tools/**.cpp")
    add_headerfiles("imgui_tools/**.h")
    add_includedirs("imgui_tools/", {public  = true})
    add_packages("glfw", "imgui")

    set_group("External")
target_end()

package("mustache")
    on_load(function (package)
        package:set("installdir", path.join(os.scriptdir(), "mustache"))
    end)

    on_fetch(function (package)
        local result = {}
        result.includedirs = package:installdir()
        return result
    end)
package_end()

package("slang")
    on_load(function (package)
        package:set("installdir", path.join(os.scriptdir(), "slang"))
    end)

    on_fetch(function (package)
        package:addenv("PATH", package:installdir("bin/windows-x64/release"))

        local result = {}
        result.links = "slang"
        result.includedirs = package:installdir()
        result.linkdirs = package:installdir("bin/windows-x64/release")
        return result
    end)
package_end()



================================================
FILE: Source/Plugin/Editor/AnimationEditor.cpp
================================================
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <Renderer/Renderer.hpp>
#include <Resource/Resource/Animation.hpp>
#include <Resource/Resource/SkinnedMesh.hpp>
#include <Resource/ResourceManager.hpp>

#include <imgui.h>
#include <imgui_internal.h>

using namespace Ilum;

class AnimationEditor : public Widget
{
  public:
	struct UniformBlock
	{
		glm::mat4 transform;
	};

	struct BoneVertex
	{
		alignas(16) glm::vec3 position;
		uint32_t bone_id;
	};

  public:
	AnimationEditor(Editor *editor) :
	    Widget("Animation Editor", editor)
	{
		m_uniform_buffer = p_editor->GetRHIContext()->CreateBuffer<UniformBlock>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
		m_pipeline_state = p_editor->GetRHIContext()->CreatePipelineState();
		m_render_target  = p_editor->GetRHIContext()->CreateRenderTarget();

		VertexInputState vertex_input_state = {};
		vertex_input_state.input_bindings   = {
            VertexInputState::InputBinding{0, sizeof(BoneVertex), RHIVertexInputRate::Vertex}};
		vertex_input_state.input_attributes = {
		    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Indices, 0, 0, RHIFormat::R32_UINT, offsetof(BoneVertex, bone_id)},
		};

		BlendState blend_state = {};
		blend_state.attachment_states.resize(1);

		InputAssemblyState input_assembly_state = {};
		input_assembly_state.topology           = RHIPrimitiveTopology::Triangle;

		DepthStencilState depth_stencil_state  = {};
		depth_stencil_state.depth_test_enable  = true;
		depth_stencil_state.depth_write_enable = true;

		m_pipeline_state->SetVertexInputState(vertex_input_state);
		m_pipeline_state->SetBlendState(blend_state);
		m_pipeline_state->SetDepthStencilState(depth_stencil_state);
		m_pipeline_state->SetInputAssemblyState(input_assembly_state);
	}

	virtual ~AnimationEditor() override = default;

	virtual void Tick() override
	{
		if (!ImGui::Begin(m_name.c_str()))
		{
			ImGui::End();
			return;
		}

		auto *resource = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Animation>(m_animation_name);

		ImGui::Columns(2);

		// Inspector
		{
			ImGui::BeginChild("Animation Editor Inspector", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);

			ImGui::Text("Animation Editor Inspector");

			if (ImGui::TreeNode("Animation"))
			{
				if (ImGui::Button(m_animation_name.c_str(), ImVec2(150.f, 20.f)))
				{
					m_animation_name = "";
					m_root.children.clear();
					m_root.name = "";
				}

				if (ImGui::BeginDragDropTarget())
				{
					if (const auto *pay_load = ImGui::AcceptDragDropPayload("Animation"))
					{
						m_animation_name = static_cast<const char *>(pay_load->Data);
						resource         = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Animation>(m_animation_name);
						if (resource)
						{
							m_root = resource->GetHierarchyNode();

							glm::vec3 min_bound = glm::vec3(std::numeric_limits<float>::max());
							glm::vec3 max_bound = glm::vec3(-std::numeric_limits<float>::max());

							CalculateBound(resource, m_root, min_bound, max_bound);

							// Update skinned buffer
							UpdateBuffer(m_time);

							// Update vertex buffer
							std::vector<BoneVertex> bone_vertices;
							UpdateVertexBuffer(bone_vertices, m_root, resource);

							m_vertex_buffer = p_editor->GetRHIContext()->CreateBuffer<BoneVertex>(bone_vertices.size(), RHIBufferUsage::Vertex | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
							m_vertex_buffer->CopyToDevice(bone_vertices.data(), bone_vertices.size() * sizeof(BoneVertex));

							m_view.center  = 0.5f * (min_bound + max_bound);
							m_view.radius  = glm::length(max_bound - min_bound);
							m_scale_factor = m_view.radius;
						}
					}
					ImGui::EndDragDropTarget();
				}

				ImGui::SameLine();

				if (ImGui::Button(m_start ? "Stop" : "Start", ImVec2(150.f, 20.f)))
				{
					m_start = !m_start;
				}

				if (m_start)
				{
					m_time += ImGui::GetIO().DeltaTime;
					if (m_time > (resource ? resource->GetMaxTimeStamp() : 1000.f))
					{
						m_time -= resource ? resource->GetMaxTimeStamp() : 1000.f;
					}
					UpdateBuffer(m_time);
				}

				if (ImGui::SliderFloat("Time", &m_time, 0.f, resource ? resource->GetMaxTimeStamp() : 1000.f))
				{
					UpdateBuffer(m_time);
				}

				// Draw hierarchy
				if (!m_animation_name.empty())
				{
					DrawHierarchy(resource, m_root);
				}

				ImGui::TreePop();
			}

			if (ImGui::TreeNode("Skinned Meshes"))
			{
				for (auto &skinned_mesh : m_skinned_meshes)
				{
					ImGui::PushID(skinned_mesh.c_str());

					if (ImGui::Button(skinned_mesh.c_str(), ImVec2(ImGui::GetContentRegionAvail().x * 0.8f, 30.f)))
					{
						skinned_mesh = "";
					}

					if (ImGui::BeginDragDropTarget())
					{
						if (const auto *pay_load = ImGui::AcceptDragDropPayload("SkinnedMesh"))
						{
							skinned_mesh = static_cast<const char *>(pay_load->Data);
						}
					}

					ImGui::PopID();
				}

				if (ImGui::Button("+"))
				{
					m_skinned_meshes.emplace_back("");
				}

				ImGui::SameLine();

				if (ImGui::Button("-"))
				{
					m_skinned_meshes.pop_back();
				}
				ImGui::TreePop();
			}

			ImGui::EndChild();
		}

		ImGui::NextColumn();

		UpdateCamera(ImGui::GetColumnWidth(1), ImGui::GetContentRegionAvail().y);

		// Model Viewer
		if (resource)
		{
			Render(static_cast<uint32_t>(ImGui::GetColumnWidth(1)), static_cast<uint32_t>(ImGui::GetContentRegionAvail().y));
			if (m_render_texture)
			{
				ImGui::Image(m_render_texture.get(), ImVec2{ImGui::GetColumnWidth(1), ImGui::GetContentRegionAvail().y});
			}
		}

		ImGui::End();
	}

	void UpdateVertexBuffer(std::vector<BoneVertex> &vertices, const HierarchyNode &node, Resource<ResourceType::Animation> *resource, Bone *parent = nullptr, glm::mat4 parent_transform = glm::mat4(1.f))
	{
		auto *bone = resource->GetBone(node.name);

		if (bone)
		{
			uint32_t current_id = bone->GetBoneID();
			if (parent)
			{
				BoneVertex p0 = {}, p1 = {};
				p0.bone_id  = parent->GetBoneID();
				p1.bone_id  = current_id;
				p0.position = glm::vec3(parent_transform * glm::vec4(0.f, 0.f, 0.f, 1.f));
				p1.position = glm::vec3(parent_transform * node.transform * glm::vec4(0.f, 0.f, 0.f, 1.f));

				vertices.push_back(p0);
				vertices.push_back(p1);
			}
		}

		for (auto &child : node.children)
		{
			UpdateVertexBuffer(vertices, child, resource, bone, parent_transform * node.transform);
		}
	}

	void DrawHierarchy(Resource<ResourceType::Animation> *resource, const HierarchyNode &node)
	{
		Bone *bone = resource->GetBone(node.name);

		bool open = false;
		if (bone)
		{
			open = ImGui::TreeNodeEx(node.name.c_str(), node.children.empty() ? ImGuiTreeNodeFlags_Leaf : ImGuiTreeNodeFlags_None);
		}

		if (!bone || open)
		{
			for (auto &child : node.children)
			{
				DrawHierarchy(resource, child);
			}
		}

		if (open)
		{
			ImGui::TreePop();
		}
	}

	void CalculateBound(Resource<ResourceType::Animation> *resource, const HierarchyNode &node, glm::vec3 &min_bound, glm::vec3 &max_bound, glm::mat4 parent = glm::mat4(1.f))
	{
		Bone *bone = resource->GetBone(node.name);

		glm::mat4 global_transformation = parent * node.transform;

		if (bone)
		{
			global_transformation = parent * bone->GetLocalTransform(0.f);

			glm::vec3 position = glm::vec3(global_transformation * bone->GetBoneOffset() * glm::vec4(0.f, 0.f, 0.f, 1.f));

			min_bound = glm::min(min_bound, position);
			max_bound = glm::max(max_bound, position);
		}

		for (auto &child : node.children)
		{
			CalculateBound(resource, child, min_bound, max_bound, global_transformation);
		}
	}

	void CalculateBoneTransform(float time, Resource<ResourceType::Animation> *resource, const HierarchyNode &node, glm::mat4 *&skinned_matrices, glm::mat4 parent = glm::mat4(1.f))
	{
		Bone *bone = resource->GetBone(node.name);

		glm::mat4 global_transformation = parent * node.transform;

		if (bone)
		{
			global_transformation = parent * bone->GetLocalTransform(time);
			if (skinned_matrices)
			{
				uint32_t  bone_id = bone->GetBoneID();
				glm::mat4 offset  = bone->GetBoneOffset();

				skinned_matrices[bone_id] = global_transformation * offset;
			}
		}

		for (auto &child : node.children)
		{
			CalculateBoneTransform(time, resource, child, skinned_matrices, global_transformation);
		}
	}

	void UpdateBuffer(float time)
	{
		auto *resource    = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Animation>(m_animation_name);
		auto *rhi_context = p_editor->GetRHIContext();
		if (resource)
		{
			if (!m_skinned_buffer || m_skinned_buffer->GetDesc().size != resource->GetBoneCount() * sizeof(glm::mat4))
			{
				m_skinned_buffer = rhi_context->CreateBuffer<glm::mat4>((size_t) resource->GetMaxBoneIndex() + 1U, RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
			}

			glm::mat4 *skinned_matrices = static_cast<glm::mat4 *>(m_skinned_buffer->Map());

			CalculateBoneTransform(time, resource, m_root, skinned_matrices);

			m_skinned_buffer->Unmap();
		}
	}

	void UpdateCamera(float width, float height)
	{
		float delta_time = ImGui::GetIO().DeltaTime;

		if (ImGui::IsWindowHovered())
		{
			if (ImGui::IsMouseDragging(ImGuiMouseButton_Right))
			{
				ImVec2 delta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Right);
				ImGui::ResetMouseDragDelta(ImGuiMouseButton_Right);
				m_view.phi -= delta.y * delta_time * 5.f;
				m_view.theta -= delta.x * delta_time * 5.f;
			}
			m_view.radius += m_scale_factor * ImGui::GetIO().MouseWheel * delta_time;
		}

		glm::vec3 position = m_view.center + m_view.radius * glm::vec3(glm::sin(glm::radians(m_view.phi)) * glm::sin(glm::radians(m_view.theta)), glm::cos(glm::radians(m_view.phi)), glm::sin(glm::radians(m_view.phi)) * glm::cos(glm::radians(m_view.theta)));

		UniformBlock block = {};

		glm::vec3 forward = glm::normalize(m_view.center - position);
		glm::vec3 right   = glm::normalize(glm::cross(forward, glm::vec3{0.f, 1.f, 0.f}));
		glm::vec3 up      = glm::normalize(glm::cross(right, forward));
		block.transform   = glm::perspective(glm::radians(45.f), width / height, 0.01f, 1000.f) * glm::lookAt(position, m_view.center, up);

		m_uniform_buffer->CopyToDevice(&block, sizeof(block));
	}

	void Render(uint32_t width, uint32_t height)
	{
		auto *rhi_context = p_editor->GetRHIContext();
		auto *resource    = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Animation>(m_animation_name);

		auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
		cmd_buffer->Begin();

		if (!m_render_texture)
		{
			m_render_texture = rhi_context->CreateTexture2D(1000, 1000, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::RenderTarget | RHITextureUsage::ShaderResource, false);
			m_depth_texture  = rhi_context->CreateTexture2D(1000, 1000, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget, false);
			cmd_buffer->ResourceStateTransition(
			    {TextureStateTransition{m_render_texture.get(), RHIResourceState::Undefined, RHIResourceState::RenderTarget, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
			     TextureStateTransition{m_depth_texture.get(), RHIResourceState::Undefined, RHIResourceState::DepthWrite, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
			    {});
		}
		else
		{
			cmd_buffer->ResourceStateTransition({TextureStateTransition{m_render_texture.get(), RHIResourceState::ShaderResource, RHIResourceState::RenderTarget, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}}, {});
		}

		{
			VertexInputState vertex_input_state = {};
			vertex_input_state.input_bindings   = {
                VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex), RHIVertexInputRate::Vertex}};
			vertex_input_state.input_attributes = {
			    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, position)},
			    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Indices, 1, 0, RHIFormat::R32G32B32A32_SINT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, bones[0])},
			    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Indices, 2, 0, RHIFormat::R32G32B32A32_SINT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, bones[4])},
			    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Weights, 3, 0, RHIFormat::R32G32B32A32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, weights[0])},
			    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Weights, 4, 0, RHIFormat::R32G32B32A32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, weights[4])},
			};

			InputAssemblyState input_assembly_state = {};
			input_assembly_state.topology           = RHIPrimitiveTopology::Triangle;

			RasterizationState rasterization_state = {};
			rasterization_state.polygon_mode       = RHIPolygonMode::Solid;
			rasterization_state.line_width         = 1.f;

			m_pipeline_state->SetVertexInputState(vertex_input_state);
			m_pipeline_state->SetInputAssemblyState(input_assembly_state);
			m_pipeline_state->SetRasterizationState(rasterization_state);

			auto *vertex_shader   = p_editor->GetRenderer()->RequireShader("./Source/Shaders/Editor/AnimationEditor.hlsl", "VSmain", RHIShaderStage::Vertex);
			auto *fragment_shader = p_editor->GetRenderer()->RequireShader("./Source/Shaders/Editor/AnimationEditor.hlsl", "PSmain", RHIShaderStage::Fragment);

			m_pipeline_state->ClearShader();
			m_pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader);
			m_pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader);

			ShaderMeta meta = p_editor->GetRenderer()->RequireShaderMeta(vertex_shader);
			meta += p_editor->GetRenderer()->RequireShaderMeta(fragment_shader);

			m_render_target->Clear();
			m_render_target->Set(0, m_render_texture.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, ColorAttachment{RHILoadAction::Clear, RHIStoreAction::Store});
			m_render_target->Set(m_depth_texture.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, DepthStencilAttachment{});

			auto *descriptor = rhi_context->CreateDescriptor(meta);
			descriptor->BindBuffer("UniformBuffer", m_uniform_buffer.get())
			    .BindBuffer("BoneMatrices", m_skinned_buffer.get());

			cmd_buffer->BeginRenderPass(m_render_target.get());
			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(m_pipeline_state.get());
			cmd_buffer->SetViewport((float) m_render_target->GetWidth(), (float) m_render_target->GetHeight());
			cmd_buffer->SetScissor(m_render_target->GetWidth(), m_render_target->GetHeight());

			for (auto &skinned_mesh_name : m_skinned_meshes)
			{
				auto *skinned_mesh = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::SkinnedMesh>(skinned_mesh_name);
				if (skinned_mesh)
				{
					cmd_buffer->BindVertexBuffer(0, skinned_mesh->GetVertexBuffer());
					cmd_buffer->BindIndexBuffer(skinned_mesh->GetIndexBuffer());
					cmd_buffer->DrawIndexed(static_cast<uint32_t>(skinned_mesh->GetIndexCount()));
				}
			}

			cmd_buffer->EndRenderPass();
		}

		cmd_buffer->ResourceStateTransition({TextureStateTransition{m_render_texture.get(), RHIResourceState::RenderTarget, RHIResourceState::ShaderResource, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}}, {});
		cmd_buffer->End();
		rhi_context->Submit({cmd_buffer});
	}

  private:
	std::string m_animation_name = "";

	std::vector<std::string> m_skinned_meshes;

	HierarchyNode m_root;

	std::unique_ptr<RHIPipelineState> m_pipeline_state = nullptr;
	std::unique_ptr<RHIRenderTarget>  m_render_target  = nullptr;

	std::unique_ptr<RHITexture> m_render_texture = nullptr;
	std::unique_ptr<RHITexture> m_depth_texture  = nullptr;

	bool m_wireframe = false;

	bool m_start = false;

	std::unique_ptr<RHIBuffer> m_uniform_buffer = nullptr;
	std::unique_ptr<RHIBuffer> m_skinned_buffer = nullptr;
	std::unique_ptr<RHIBuffer> m_vertex_buffer  = nullptr;

	float m_scale_factor = 1.f;

	float m_time = 0.f;

	struct
	{
		glm::vec3 center = glm::vec3(0.f);
		float     radius = 0.f;
		float     theta  = 0.f;
		float     phi    = 90.f;
	} m_view;
};

extern "C"
{
	EXPORT_API AnimationEditor *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		return new AnimationEditor(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/Console.cpp
================================================


================================================
FILE: Source/Plugin/Editor/Hierarchy.cpp
================================================
#include <Scene/Components/AllComponents.hpp>
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <Renderer/Renderer.hpp>
#include <Scene/Node.hpp>
#include <Scene/Scene.hpp>

#include <imgui.h>

using namespace Ilum;

class Hierarchy : public Widget
{
  public:
	Hierarchy(Editor *editor) :
	    Widget("Hierarchy", editor)
	{
	}

	virtual ~Hierarchy() override = default;

	virtual void Tick() override
	{
		if (!ImGui::Begin(m_name.c_str()))
		{
			ImGui::End();
			return;
		}

		if (ImGui::BeginDragDropTarget())
		{
			if (const auto *pay_load = ImGui::AcceptDragDropPayload("Node"))
			{
				if (pay_load->DataSize == sizeof(Node *))
				{
					(*static_cast<Node **>(pay_load->Data))->SetParent(nullptr);
				}
			}
		}

		auto roots = p_editor->GetRenderer()->GetScene()->GetRoots();

		for (auto *root : roots)
		{
			DrawNode(root);
		}

		if (ImGui::IsMouseDown(ImGuiMouseButton_Left) && ImGui::IsWindowHovered())
		{
			p_editor->SelectNode();
		}

		ImGui::End();
	}

	void DrawNode(Node *node)
	{
		bool has_child = !node->GetChildren().empty();

		bool update = false;

		// Setting up
		ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(5, 5));
		ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_FramePadding | (p_editor->GetSelectedNode() == node ? ImGuiTreeNodeFlags_Selected : 0) | (has_child ? 0 : ImGuiTreeNodeFlags_Leaf);

		ImGui::PushID(static_cast<int32_t>((uint64_t) node));
		bool open = ImGui::TreeNodeEx(std::to_string((uint64_t) node).c_str(), flags, "%s", node->GetName().empty() ? " " : node->GetName().c_str());

		ImGui::PopStyleVar();

		// Delete node
		bool node_deleted = false;
		if (ImGui::BeginPopupContextItem(std::to_string((uint64_t) node).c_str()))
		{
			if (ImGui::MenuItem("Delete Entity"))
			{
				node_deleted = true;
				update       = true;
			}
			ImGui::EndPopup();
		}
		ImGui::PopID();

		// Select entity
		if (ImGui::IsItemClicked())
		{
			p_editor->SelectNode(node);
		}

		// Drag and drop
		if (ImGui::BeginDragDropSource())
		{
			ImGui::SetDragDropPayload("Node", &node, sizeof(Node *));
			ImGui::EndDragDropSource();
		}

		if (ImGui::BeginDragDropTarget())
		{
			if (const auto *pay_load = ImGui::AcceptDragDropPayload("Node"))
			{
				if (pay_load->DataSize == sizeof(Node *))
				{
					Node *new_son = *static_cast<Node **>(pay_load->Data);
					if (node->GetParent() != new_son)
					{
						new_son->SetParent(node);
						new_son->GetComponent<Cmpt::Transform>()->SetDirty();
						update = true;
					}
				}
			}
			ImGui::EndDragDropTarget();
		}

		// Recursively open children nodes
		if (open)
		{
			for (auto *child : node->GetChildren())
			{
				DrawNode(child);
			}
			ImGui::TreePop();
		}

		// Delete callback
		if (node_deleted)
		{
			auto *scene = p_editor->GetRenderer()->GetScene();

			if ((node->HasComponent<Cmpt::OrthographicCamera>() &&node->GetComponent<Cmpt::OrthographicCamera>()==p_editor->GetMainCamera())||
			    (node->HasComponent<Cmpt::PerspectiveCamera>() && node->GetComponent<Cmpt::PerspectiveCamera>() == p_editor->GetMainCamera()))
			{
				p_editor->SetMainCamera();
			}

			if (p_editor->GetSelectedNode() == node)
			{
				p_editor->SelectNode();
			}

			scene->EraseNode(node);
		}
	}
};

extern "C"
{
	__declspec(dllexport) Hierarchy *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		return new Hierarchy(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/Inspector.cpp
================================================
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <RHI/RHIContext.hpp>
#include <RenderGraph/RenderGraph.hpp>
#include <Renderer/Renderer.hpp>
#include <Scene/Components/AllComponents.hpp>
#include <Scene/Node.hpp>

#include <imgui.h>
#include <imgui_internal.h>

using namespace Ilum;

class Inspector : public Widget
{
  public:
	Inspector(Editor *editor) :
	    Widget("Inspector", editor)
	{
	}

	virtual ~Inspector() override = default;

	virtual void Tick() override
	{
		auto *select = p_editor->GetSelectedNode();

		if (!ImGui::Begin(m_name.c_str()))
		{
			ImGui::End();
			return;
		}

		// Draw node components
		if (select)
		{
			DrawNodeInspector(select);
		}
		else
		{
			DrawRendererInspector();
		}

		ImGui::End();
	}

	void DrawNodeInspector(Node *node)
	{
		{
			// Name
			char buf[64] = {0};
			std::memcpy(buf, node->GetName().data(), sizeof(buf));
			ImGui::PushItemWidth(150.f);
			if (ImGui::InputText("Tag", buf, sizeof(buf)))
			{
				node->SetName(buf);
			}
			ImGui::PopItemWidth();
		}

		for (auto &[type, cmpt] : node->GetComponents())
		{
			const ImGuiTreeNodeFlags tree_node_flags = ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_AllowItemOverlap | ImGuiTreeNodeFlags_FramePadding;

			ImVec2 content_region_available = ImGui::GetContentRegionAvail();

			ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2{4, 4});
			float line_height = GImGui->Font->FontSize + GImGui->Style.FramePadding.y * 2.0f;
			bool  open        = ImGui::TreeNodeEx((void *) type.hash_code(), tree_node_flags, cmpt->GetName());
			ImGui::PopStyleVar();

			bool update = false;

			if (open)
			{
				cmpt->OnImGui();
				ImGui::TreePop();
			}
		}
	}

	void DrawRendererInspector()
	{
		const ImGuiTreeNodeFlags tree_node_flags = ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_AllowItemOverlap | ImGuiTreeNodeFlags_FramePadding;

		auto *rhi_context  = p_editor->GetRHIContext();
		auto *renderer     = p_editor->GetRenderer();
		auto *render_graph = renderer->GetRenderGraph();

		if (ImGui::TreeNodeEx("Hardware Info", tree_node_flags, "Hardware Info"))
		{
			ImGui::Text("GPU: %s", rhi_context->GetDeviceName().c_str());
			ImGui::Text("Backend: %s", rhi_context->GetBackend().c_str());
			ImGui::Text("CUDA: %s", rhi_context->HasCUDA() ? "Enable" : "Disable");
			ImGui::TreePop();
		}

		if (render_graph && ImGui::TreeNodeEx("Profiler", tree_node_flags, "Profiler"))
		{
			{
				static float t = 0;
				t += ImGui::GetIO().DeltaTime;
				if (t > 0.1f)
				{
					t = 0;
					if (ImGui::GetIO().Framerate != 0.0)
					{
						if (m_frame_times.size() < 50)
						{
							m_frame_times.push_back(1000.0f / ImGui::GetIO().Framerate);
						}
						else
						{
							std::rotate(m_frame_times.begin(), m_frame_times.begin() + 1, m_frame_times.end());
							m_frame_times.back() = 1000.0f / ImGui::GetIO().Framerate;
						}
					}
				}

				float min_frame_time = 0.f, max_frame_time = 0.f;
				float max_cpu_time = 0.f, max_gpu_time = 0.f;

				if (!m_frame_times.empty())
				{
					min_frame_time = *std::min_element(m_frame_times.begin(), m_frame_times.end());
					max_frame_time = *std::max_element(m_frame_times.begin(), m_frame_times.end());
				}

				std::vector<float>        cpu_times;
				std::vector<float>        gpu_times;
				std::vector<const char *> pass_names;

				if (ImGui::BeginTable("CPU&GPU Time", 4, ImGuiTableFlags_RowBg | ImGuiTableFlags_Borders))
				{
					ImGui::TableSetupColumn("Pass");
					ImGui::TableSetupColumn("CPU (ms)");
					ImGui::TableSetupColumn("GPU (ms)");
					ImGui::TableSetupColumn("Thread");
					ImGui::TableHeadersRow();

					uint32_t idx = 0;
					for (const auto &pass : render_graph->GetRenderPasses())
					{
						const auto &profiler_state = pass.profiler->GetProfileState();

						cpu_times.push_back(profiler_state.cpu_time);
						gpu_times.push_back(profiler_state.gpu_time);
						pass_names.push_back(pass.name.c_str());

						ImGui::TableNextRow();

						ImGui::TableSetColumnIndex(0);
						ImGui::Text("%s", (std::to_string(idx++) + " - " + pass.name).c_str());
						ImGui::TableSetColumnIndex(1);
						ImGui::Text("%f", cpu_times.back());
						ImGui::TableSetColumnIndex(2);
						ImGui::Text("%f", gpu_times.back());
						ImGui::TableSetColumnIndex(3);
						ImGui::Text("%zu", profiler_state.thread_id);
					}
					ImGui::EndTable();
				}

				if (!cpu_times.empty())
				{
					max_cpu_time = *std::max_element(cpu_times.begin(), cpu_times.end());
					max_gpu_time = *std::max_element(gpu_times.begin(), gpu_times.end());
				}

				ImGui::PlotLines(("Frame Time (" + std::to_string(static_cast<uint32_t>(ImGui::GetIO().Framerate)) + "fps)").c_str(), m_frame_times.data(), static_cast<int>(m_frame_times.size()), 0, nullptr, min_frame_time * 0.8f, max_frame_time * 1.2f, ImVec2{0, 80});
				ImGui::PlotHistogram("CPU Time", cpu_times.data(), static_cast<int>(cpu_times.size()), 0, nullptr, 0.f, max_cpu_time * 1.2f, ImVec2(0, 80.0f));
				ImGui::PlotHistogram("GPU Time", gpu_times.data(), static_cast<int>(gpu_times.size()), 0, nullptr, 0.f, max_gpu_time * 1.2f, ImVec2(0, 80.0f));
			}

			ImGui::TreePop();
		}

		if (render_graph && ImGui::TreeNodeEx("Render Info", tree_node_flags, "Render Info"))
		{
			for (const auto &pass : render_graph->GetRenderPasses())
			{
				ImGui::PushID(&pass.config);
				if (!pass.config.Empty() && ImGui::TreeNodeEx(&pass, tree_node_flags, pass.name.c_str()))
				{
					PluginManager::GetInstance().Call<bool>(fmt::format("shared/RenderPass/RenderPass.{}.{}.dll", pass.category, pass.name), "OnImGui", &pass.config, ImGui::GetCurrentContext());
					ImGui::TreePop();
				}
				ImGui::PopID();
			}
			ImGui::TreePop();
		}
	}

  private:
	std::vector<float> m_frame_times;
};

extern "C"
{
	EXPORT_API Inspector *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		Ilum::Cmpt::SetImGuiContext(context);
		return new Inspector(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/MainMenu.cpp
================================================
#include <Scene/Components/AllComponents.hpp>
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <Renderer/Renderer.hpp>
#include <Scene/Node.hpp>
#include <Scene/Scene.hpp>

#include <imgui.h>
#include <imgui_internal.h>

#include <nfd.h>

using namespace Ilum;

class MainMenu : public Widget
{
  public:
	MainMenu(Editor *editor) :
	    Widget("Main Menu", editor)
	{
	}

	virtual ~MainMenu() override = default;

	virtual void Tick() override
	{
		if (ImGui::BeginMainMenuBar())
		{
			if (ImGui::BeginMenu("Component"))
			{
				if (ImGui::BeginMenu("Add Light"))
				{
					if (ImGui::MenuItem("Spot Light"))
					{
						auto *node = p_editor->GetRenderer()->GetScene()->CreateNode("Spot Light");
						node->AddComponent(std::make_unique<Cmpt::Transform>(node));
						node->AddComponent(std::make_unique<Cmpt::SpotLight>(node));
					}

					if (ImGui::MenuItem("Point Light"))
					{
						auto *node = p_editor->GetRenderer()->GetScene()->CreateNode("Point Light");
						node->AddComponent(std::make_unique<Cmpt::Transform>(node));
						node->AddComponent(std::make_unique<Cmpt::PointLight>(node));
					}

					if (ImGui::MenuItem("Directional Light"))
					{
						auto *node = p_editor->GetRenderer()->GetScene()->CreateNode("Directional Light");
						node->AddComponent(std::make_unique<Cmpt::Transform>(node));
						node->AddComponent(std::make_unique<Cmpt::DirectionalLight>(node));
					}

					if (ImGui::MenuItem("Rectangle Light"))
					{
						auto *node = p_editor->GetRenderer()->GetScene()->CreateNode("Rectangle Light");
						node->AddComponent(std::make_unique<Cmpt::Transform>(node));
						node->AddComponent(std::make_unique<Cmpt::RectLight>(node));
					}

					if (ImGui::MenuItem("Environment Light"))
					{
						auto *node = p_editor->GetRenderer()->GetScene()->CreateNode("Environment Light");
						node->AddComponent(std::make_unique<Cmpt::Transform>(node));
						node->AddComponent(std::make_unique<Cmpt::EnvironmentLight>(node));
					}

					ImGui::EndMenu();
				}

				if (ImGui::BeginMenu("Add Camera"))
				{
					if (ImGui::MenuItem("Perspective Camera"))
					{
						auto *node = p_editor->GetRenderer()->GetScene()->CreateNode("Perspective Camera");
						node->AddComponent(std::make_unique<Cmpt::Transform>(node));
						auto *camera = node->AddComponent(std::make_unique<Cmpt::PerspectiveCamera>(node));

						if (!p_editor->GetMainCamera())
						{
							p_editor->SetMainCamera(camera);
						}
					}

					if (ImGui::MenuItem("Orthographic Camera"))
					{
						auto *node = p_editor->GetRenderer()->GetScene()->CreateNode("Orthographic Camera");
						node->AddComponent(std::make_unique<Cmpt::Transform>(node));
						node->AddComponent(std::make_unique<Cmpt::OrthographicCamera>(node));
					}

					ImGui::EndMenu();
				}

				ImGui::EndMenu();
			}

			ImGui::EndMainMenuBar();
		}
	}
};

extern "C"
{
	EXPORT_API MainMenu *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		Ilum::Cmpt::SetImGuiContext(context);
		return new MainMenu(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/MaterialGraphEditor.cpp
================================================
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <Material/MaterialData.hpp>
#include <Material/MaterialGraph.hpp>
#include <RenderGraph/RenderGraphBlackboard.hpp>
#include <Renderer/RenderData.hpp>
#include <Renderer/Renderer.hpp>
#include <Resource/Resource/Material.hpp>
#include <Resource/Resource/Mesh.hpp>
#include <Resource/ResourceManager.hpp>

#include <imgui.h>
#include <imgui_internal.h>
#include <imnodes/imnodes.h>

#include <nfd.h>

using namespace Ilum;

class MaterialGraphEditor : public Widget
{
  public:
	MaterialGraphEditor(Editor *editor) :
	    Widget("Material Editor", editor)
	{
		ImNodes::CreateContext();
		m_context = ImNodes::EditorContextCreate();

		std::vector<Resource<ResourceType::Mesh>::Vertex> vertices;

		std::vector<uint32_t> indices;

		DESERIALIZE("Asset/BuildIn/MaterialBall.asset", vertices, indices);

		auto *rhi_context = editor->GetRenderer()->GetRHIContext();
		auto *renderer    = editor->GetRenderer();

		m_view.buffer = rhi_context->CreateBuffer(sizeof(m_view.uniform_block), RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
		m_view.Reset();
		m_view.Update();

		{
			m_view.uniform_block.model = glm::mat4_cast(glm::qua<float>(glm::radians(glm::vec3(135.f, 0.f, 180.f))));
		}

		m_material_ball.vertex_buffer = rhi_context->CreateBuffer<Resource<ResourceType::Mesh>::Vertex>(vertices.size(), RHIBufferUsage::Vertex | RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
		m_material_ball.index_buffer  = rhi_context->CreateBuffer<uint32_t>(indices.size(), RHIBufferUsage::Index | RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);

		m_material_ball.indices_count = static_cast<uint32_t>(indices.size());
		m_material_ball.vertex_buffer->CopyToDevice(vertices.data(), vertices.size() * sizeof(Resource<ResourceType::Mesh>::Vertex));
		m_material_ball.index_buffer->CopyToDevice(indices.data(), indices.size() * sizeof(uint32_t));

		m_preview.pipeline = rhi_context->CreatePipelineState();

		BlendState blend_state;
		blend_state.attachment_states.resize(1);
		m_preview.pipeline->SetBlendState(blend_state);

		RasterizationState rasterization_state;
		rasterization_state.cull_mode  = RHICullMode::None;
		rasterization_state.front_face = RHIFrontFace::Clockwise;
		m_preview.pipeline->SetRasterizationState(rasterization_state);

		DepthStencilState depth_stencil_state  = {};
		depth_stencil_state.depth_write_enable = true;
		depth_stencil_state.depth_test_enable  = true;
		m_preview.pipeline->SetDepthStencilState(depth_stencil_state);

		VertexInputState vertex_input_state = {};
		vertex_input_state.input_bindings   = {
            VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::Mesh>::Vertex), RHIVertexInputRate::Vertex}};
		vertex_input_state.input_attributes = {
		    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, position)},
		    VertexInputState::InputAttribute{RHIVertexSemantics::Normal, 1, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, normal)},
		    VertexInputState::InputAttribute{RHIVertexSemantics::Tangent, 2, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, tangent)},
		    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 3, 0, RHIFormat::R32G32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, texcoord0)},
		};
		m_preview.pipeline->SetVertexInputState(vertex_input_state);

		m_preview.render_target_texture = rhi_context->CreateTexture2D(500, 500, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::RenderTarget | RHITextureUsage::ShaderResource, false);
		m_preview.depth_stencil_texture = rhi_context->CreateTexture2D(500, 500, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget | RHITextureUsage::ShaderResource, false);
		m_preview.render_target         = rhi_context->CreateRenderTarget();
		m_preview.render_target->Set(0, m_preview.render_target_texture.get(), RHITextureDimension::Texture2D, ColorAttachment{});
		m_preview.render_target->Set(m_preview.depth_stencil_texture.get(), RHITextureDimension::Texture2D, DepthStencilAttachment{});

		{
			auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
			cmd_buffer->Begin();
			cmd_buffer->ResourceStateTransition({TextureStateTransition{m_preview.render_target_texture.get(), RHIResourceState::Undefined, RHIResourceState::ShaderResource, TextureRange{}}}, {});
			cmd_buffer->End();
			rhi_context->Execute({cmd_buffer});
		}
	}

	virtual ~MaterialGraphEditor() override
	{
		ImNodes::DestroyContext();
		ImNodes::EditorContextFree(m_context);
	}

	virtual void Tick() override
	{
		if (!ImGui::Begin(m_name.c_str()))
		{
			ImGui::End();
			return;
		}

		auto *resource_manager = p_editor->GetRenderer()->GetResourceManager();

		auto *resource = resource_manager->Get<ResourceType::Material>(m_material_name);

		ImGui::Columns(2);

		// Inspector
		{
			ImGui::BeginChild("Material Editor Inspector", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);

			ImGui::Text("Material Editor Inspector");

			if (resource)
			{
				Render(resource);
				float width = glm::min(ImGui::GetColumnWidth(), 300.f);
				ImGui::Image(m_preview.render_target_texture.get(), ImVec2(width, width));
				UpdateCamera();
			}

			SetMaterial(resource, resource_manager);

			if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
			{
				ImGui::SetScrollHereY(1.0f);
			}

			ImGui::EndChild();
		}

		ImGui::NextColumn();

		ImGui::BeginChild("Material Graph Editor", ImVec2(0, 0), false, ImGuiWindowFlags_MenuBar);

		MenuBar();

		HandleSelection();

		ImNodes::BeginNodeEditor();

		if (resource)
		{
			for (auto &new_node : m_new_nodes)
			{
				ImNodes::SetNodeScreenSpacePos(new_node, ImVec2(ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y));
			}
			m_new_nodes.clear();

			PopupWindow(resource);
			DrawNodes(resource);
			DrawEdges(resource);
		}

		ImNodes::MiniMap(0.1f);
		ImNodes::EndNodeEditor();

		DragDropResource();

		if (resource)
		{
			AddEdge(resource);
		}

		ImGui::EndChild();

		ImGui::End();
	}

	void SetMaterial(Resource<ResourceType::Material> *resource, ResourceManager *manager)
	{
		ImGui::PushItemWidth(100.f);
		char buf[128] = {0};
		std::memcpy(buf, m_material_name.data(), sizeof(buf));
		if (ImGui::InputText("##NewMaterial", buf, sizeof(buf)))
		{
			m_material_name = buf;
		}
		ImGui::PopItemWidth();

		ImGui::SameLine();

		if (!m_material_name.empty() && !resource)
		{
			if (ImGui::Button("New Material"))
			{
				MaterialGraphDesc desc;
				desc.SetName(m_material_name);
				manager->Add<ResourceType::Material>(p_editor->GetRHIContext(), m_material_name, std::move(desc));
				resource = manager->Get<ResourceType::Material>(m_material_name);
			}
		}
		else
		{
			ImGui::Text("Material Name");
		}
	}

	void DragDropResource()
	{
		if (ImGui::BeginDragDropTarget())
		{
			if (const auto *pay_load = ImGui::AcceptDragDropPayload("Material"))
			{
				m_material_name = static_cast<const char *>(pay_load->Data);
				auto *resource  = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Material>(m_material_name);
				if (resource)
				{
					ImNodes::LoadCurrentEditorStateFromIniString(resource->GetLayout().data(), resource->GetLayout().length());
					auto &desc = resource->GetDesc();
					for (auto &[node_handle, node] : desc.GetNodes())
					{
						m_current_handle = glm::max(m_current_handle, node_handle + 1);
						for (auto &[pin_handle, pin] : node.GetPins())
						{
							m_current_handle = glm::max(m_current_handle, pin_handle + 1);
						}
					}
					m_view.uniform_block.material_id = static_cast<uint32_t>(p_editor->GetRenderer()->GetResourceManager()->Index<ResourceType::Material>(m_material_name));
				}
			}
		}
	}

	void MenuBar()
	{
		auto *resource = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Material>(m_material_name);

		if (!resource)
		{
			return;
		}

		if (ImGui::BeginMenuBar())
		{
			if (ImGui::BeginMenu("Node"))
			{
				for (const auto &file : std::filesystem::directory_iterator("shared/Material/"))
				{
					std::string filename = file.path().filename().string();
					{
						size_t pos1 = filename.find_first_of('.');
						size_t pos2 = filename.find_first_of('.', pos1 + 1);
						size_t pos3 = filename.find_first_of('.', pos2 + 1);

						std::string category  = filename.substr(pos1 + 1, pos2 - pos1 - 1);
						std::string node_name = filename.substr(pos2 + 1, pos3 - pos2 - 1);

						if (ImGui::BeginMenu(category.c_str()))
						{
							if (ImGui::MenuItem(node_name.c_str()))
							{
								MaterialNodeDesc desc;
								PluginManager::GetInstance().Call(file.path().string(), "Create", &desc, &m_current_handle);
								resource->GetDesc().AddNode(m_current_handle++, std::move(desc));
							}
							ImGui::EndMenu();
						}
					}
				}
				ImGui::EndMenu();
			}

			if (ImGui::MenuItem("Clear"))
			{
				resource->GetDesc().Clear();
			}

			if (ImGui::MenuItem("Compile"))
			{
				DummyTexture *dummy_texture = p_editor->GetRenderer()->GetRenderGraphBlackboard().Get<DummyTexture>();
				GPUScene     *gpu_scene     = p_editor->GetRenderer()->GetRenderGraphBlackboard().Get<GPUScene>();

				resource->Compile(
				    p_editor->GetRenderer()->GetRHIContext(),
				    p_editor->GetRenderer()->GetResourceManager(),
				    dummy_texture->black_opaque.get(),
				    ImNodes::SaveCurrentEditorStateToIniString());
			}

			ImGui::EndMenuBar();
		}
	}

	void PopupWindow(Resource<ResourceType::Material> *resource)
	{
		if (ImGui::BeginPopupContextWindow(0, ImGuiPopupFlags_MouseButtonRight))
		{
			if (ImGui::MenuItem("Remove"))
			{
				if (!m_select_links.empty() || !m_select_nodes.empty())
				{
					for (auto &link : m_select_links)
					{
						for (auto &[dst, src] : resource->GetDesc().GetEdges())
						{
							if (link == static_cast<int32_t>(Hash(src, dst)))
							{
								resource->GetDesc().EraseLink(static_cast<size_t>(src), static_cast<size_t>(dst));
								break;
							}
						}
					}
					for (auto &node : m_select_nodes)
					{
						resource->GetDesc().EraseNode(node);
					}
				}
			}
			ImGui::EndPopup();
		}
	}

	void EditMaterialNodePin(const MaterialNodePin &pin)
	{
		switch (pin.type)
		{
			case MaterialNodePin::Type::Float:
				ImGui::DragFloat("", pin.variant.Convert<float>(), 0.001f, 0.f, 0.f, "%.2f");
				break;
			case MaterialNodePin::Type::Float3:
				ImGui::DragFloat3("", glm::value_ptr(*pin.variant.Convert<glm::vec3>()), 0.001f, 0.f, 0.f, "%.2f");
				break;
			case MaterialNodePin::Type::RGB:
				ImGui::ColorEdit3("", glm::value_ptr(*pin.variant.Convert<glm::vec3>()), ImGuiColorEditFlags_NoInputs);
				break;
			case MaterialNodePin::Type::Bool:
				ImGui::Checkbox("", pin.variant.Convert<bool>());
				break;
			default:
				break;
		}
	}

	void DrawNodes(Resource<ResourceType::Material> *resource)
	{
		for (auto &[node_handle, node_desc] : resource->GetDesc().GetNodes())
		{
			const float node_width = glm::max(ImGui::CalcTextSize(node_desc.GetName().c_str()).x, 120.f);
			ImGui::PushItemWidth(node_width);

			ImNodes::BeginNode(static_cast<int32_t>(node_handle));
			ImNodes::BeginNodeTitleBar();
			ImGui::Text(node_desc.GetName().c_str());
			ImNodes::EndNodeTitleBar();
			PluginManager::GetInstance().Call(fmt::format("shared/Material/Material.{}.{}.dll", node_desc.GetCategory(), node_desc.GetName()), "OnImGui", &node_desc, p_editor, ImGui::GetCurrentContext());
			for (auto &[pin_handle, pin] : node_desc.GetPins())
			{
				if (!pin.enable)
				{
					continue;
				}

				if (pin.attribute == MaterialNodePin::Attribute::Input)
				{
					ImNodes::PushColorStyle(ImNodesCol_Pin, m_pin_color[pin.type]);
					ImNodes::BeginInputAttribute(static_cast<int32_t>(pin_handle));
					ImGui::TextUnformatted(pin.name.c_str());
					if (!resource->GetDesc().HasLink(pin_handle) && !pin.variant.Empty())
					{
						ImGui::SameLine();
						ImGui::PushItemWidth(node_width - ImGui::CalcTextSize(pin.name.c_str()).x);
						EditMaterialNodePin(pin);
						ImGui::PopItemWidth();
					}
					ImNodes::EndInputAttribute();
					ImNodes::PopColorStyle();
				}
				else
				{
					ImNodes::PushColorStyle(ImNodesCol_Pin, m_pin_color[pin.type]);
					ImNodes::BeginOutputAttribute(static_cast<int32_t>(pin_handle));
					const float label_width = ImGui::CalcTextSize(pin.name.c_str()).x;
					ImGui::Indent(node_width - label_width);
					if (!pin.variant.Empty())
					{
						ImGui::PushItemWidth(node_width - ImGui::CalcTextSize(pin.name.c_str()).x);
						EditMaterialNodePin(pin);
						ImGui::PopItemWidth();
						ImGui::SameLine();
					}
					ImGui::TextUnformatted(pin.name.c_str());
					ImNodes::EndOutputAttribute();
					ImNodes::PopColorStyle();
				}
			}
			ImNodes::EndNode();
			ImGui::PopItemWidth();
		}
	}

	void HandleSelection()
	{
		m_select_links.clear();
		m_select_nodes.clear();

		if (ImNodes::NumSelectedLinks() > 0)
		{
			m_select_links.resize(ImNodes::NumSelectedLinks());
			ImNodes::GetSelectedLinks(m_select_links.data());
		}

		if (ImNodes::NumSelectedNodes() > 0)
		{
			m_select_nodes.resize(ImNodes::NumSelectedNodes());
			ImNodes::GetSelectedNodes(m_select_nodes.data());
		}
	}

	void DrawEdges(Resource<ResourceType::Material> *resource)
	{
		for (auto &[dst, src] : resource->GetDesc().GetEdges())
		{
			const auto &src_node = resource->GetDesc().GetNode(src);
			const auto &dst_node = resource->GetDesc().GetNode(dst);

			auto type = src_node.GetPin(src).type;

			ImNodes::PushColorStyle(ImNodesCol_Link, m_pin_color[type]);
			ImNodes::Link(static_cast<int32_t>(Hash(src, dst)), static_cast<int32_t>(src), static_cast<int32_t>(dst));
			ImNodes::PopColorStyle();
		}
	}

	void AddEdge(Resource<ResourceType::Material> *resource)
	{
		int32_t src = 0, dst = 0;
		if (ImNodes::IsLinkCreated(&src, &dst))
		{
			resource->GetDesc().Link(src, dst);
		}
	}

	void UpdateCamera()
	{
		float delta_time = ImGui::GetIO().DeltaTime;

		if (ImGui::IsItemHovered())
		{
			if (ImGui::IsMouseDragging(ImGuiMouseButton_Right))
			{
				ImVec2 delta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Right);
				ImGui::ResetMouseDragDelta(ImGuiMouseButton_Right);
				m_view.phi -= delta.y * delta_time * 50.f;
				m_view.theta -= delta.x * delta_time * 50.f;
			}
			m_view.radius += ImGui::GetIO().MouseWheel * delta_time * 10.f;
		}

		m_view.Update();
	}

	void Render(Resource<ResourceType::Material> *resource)
	{
		auto *renderer    = p_editor->GetRenderer();
		auto *rhi_context = p_editor->GetRHIContext();
		auto *gpu_scene   = renderer->GetRenderGraphBlackboard().Get<GPUScene>();

		auto &material_data = resource->GetMaterialData();

		ShaderMeta meta;

		{
			auto *vertex_shader = renderer->RequireShader("Source/Shaders/Editor/MaterialEditor.hlsl", "VSmain", RHIShaderStage::Vertex, {"USE_MATERIAL", material_data.signature}, {material_data.shader});
			auto *frag_shader   = renderer->RequireShader("Source/Shaders/Editor/MaterialEditor.hlsl", "PSmain", RHIShaderStage::Fragment, {"USE_MATERIAL", material_data.signature}, {material_data.shader});

			m_preview.pipeline->ClearShader();
			m_preview.pipeline->SetShader(RHIShaderStage::Vertex, vertex_shader);
			m_preview.pipeline->SetShader(RHIShaderStage::Fragment, frag_shader);

			meta = renderer->RequireShaderMeta(vertex_shader);
			meta += renderer->RequireShaderMeta(frag_shader);
		}

		auto *descriptor = rhi_context->CreateDescriptor(meta);
		descriptor->BindBuffer("UniformBuffer", m_view.buffer.get())
		    .BindTexture("Textures", gpu_scene->texture.texture_2d, RHITextureDimension::Texture2D)
		    .BindSampler("Samplers", gpu_scene->samplers)
		    .BindBuffer("MaterialOffsets", gpu_scene->material.material_offset.get())
		    .BindBuffer("MaterialBuffer", gpu_scene->material.material_buffer.get());

		auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
		cmd_buffer->Begin();
		cmd_buffer->ResourceStateTransition({TextureStateTransition{m_preview.render_target_texture.get(), RHIResourceState::ShaderResource, RHIResourceState::RenderTarget, TextureRange{}}}, {});
		cmd_buffer->BeginRenderPass(m_preview.render_target.get());
		cmd_buffer->SetViewport(static_cast<float>(m_preview.render_target->GetWidth()), static_cast<float>(m_preview.render_target->GetHeight()));
		cmd_buffer->SetScissor(m_preview.render_target->GetWidth(), m_preview.render_target->GetHeight());
		cmd_buffer->BindDescriptor(descriptor);
		cmd_buffer->BindPipelineState(m_preview.pipeline.get());
		cmd_buffer->BindVertexBuffer(0, m_material_ball.vertex_buffer.get());
		cmd_buffer->BindIndexBuffer(m_material_ball.index_buffer.get());
		cmd_buffer->DrawIndexed(m_material_ball.indices_count);
		cmd_buffer->EndRenderPass();
		cmd_buffer->ResourceStateTransition({TextureStateTransition{m_preview.render_target_texture.get(), RHIResourceState::RenderTarget, RHIResourceState::ShaderResource, TextureRange{}}}, {});
		cmd_buffer->End();

		rhi_context->Submit({cmd_buffer});
	}

  private:
	ImNodesEditorContext *m_context = nullptr;

	std::string m_material_name = "";

	size_t m_current_handle = 0;

	std::vector<int32_t> m_select_nodes;
	std::vector<int32_t> m_select_links;
	std::vector<int32_t> m_new_nodes;

	struct
	{
		glm::vec3 center = glm::vec3(0.f);

		float radius = 4.f;
		float theta  = 0.f;
		float phi    = 60.f;

		void Reset()
		{
			center = glm::vec3(0.f);
			radius = 4.f;
			theta  = 0.f;
			phi    = 60.f;

			Update();
		}

		void Update()
		{
			glm::vec3 position  = center + radius * glm::vec3(glm::sin(glm::radians(phi)) * glm::sin(glm::radians(theta)), glm::cos(glm::radians(phi)), glm::sin(glm::radians(phi)) * glm::cos(glm::radians(theta)));
			glm::vec3 direction = glm::normalize(center - position);
			glm::vec3 right     = glm::normalize(glm::cross(direction, glm::vec3{0.f, 1.f, 0.f}));
			glm::vec3 up        = glm::normalize(glm::cross(right, direction));
			glm::mat4 transform = glm::perspective(glm::radians(45.f), 1.f, 0.01f, 1000.f) * glm::lookAt(position, center, up);

			uniform_block.transform  = transform;
			uniform_block.camera_pos = position;
			buffer->CopyToDevice(&uniform_block, sizeof(uniform_block));
		}

		struct
		{
			glm::mat4 transform;
			glm::mat4 model;
			glm::vec3 camera_pos;
			uint32_t  material_id;
		} uniform_block;

		std::unique_ptr<RHIBuffer> buffer = nullptr;
	} m_view;

	struct
	{
		std::unique_ptr<RHIBuffer> vertex_buffer = nullptr;
		std::unique_ptr<RHIBuffer> index_buffer  = nullptr;

		uint32_t indices_count = 0;
	} m_material_ball;

	struct
	{
		std::unique_ptr<RHIPipelineState> pipeline              = nullptr;
		std::unique_ptr<RHITexture>       render_target_texture = nullptr;
		std::unique_ptr<RHITexture>       depth_stencil_texture = nullptr;
		std::unique_ptr<RHIRenderTarget>  render_target         = nullptr;
	} m_preview;

	std::map<MaterialNodePin::Type, uint32_t> m_pin_color = {
	    {MaterialNodePin::Type::BSDF, IM_COL32(0, 128, 0, 255)},
	    {MaterialNodePin::Type::Media, IM_COL32(0, 0, 128, 255)},
	    {MaterialNodePin::Type::Float, IM_COL32(0, 128, 128, 255)},
	    {MaterialNodePin::Type::Float3, IM_COL32(128, 128, 0, 255)},
	    {MaterialNodePin::Type::RGB, IM_COL32(128, 128, 0, 255)},
	};
};

extern "C"
{
	EXPORT_API MaterialGraphEditor *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		return new MaterialGraphEditor(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/MeshEditor.cpp
================================================
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <Geometry/Mesh/Mesh.hpp>
#include <Geometry/MeshProcess.hpp>
#include <Renderer/Renderer.hpp>
#include <Resource/Importer.hpp>
#include <Resource/Resource/Mesh.hpp>
#include <Resource/ResourceManager.hpp>

#include <imgui.h>
#include <imgui_internal.h>

#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>

using namespace Ilum;

class MeshEditor : public Widget
{
  private:
	struct UniformBlock
	{
		glm::mat4 transform;
		alignas(16) glm::vec3 color;
		alignas(16) glm::vec3 direction;
	};

	enum class ShadingMode
	{
		None,
		Shading,
		Normal,
		UV,
		Texture
	};

  public:
	MeshEditor(Editor *editor) :
	    Widget("Mesh Editor", editor)
	{
		m_pipeline_state = p_editor->GetRHIContext()->CreatePipelineState();
		m_render_target  = p_editor->GetRHIContext()->CreateRenderTarget();
		m_uniform_buffer = p_editor->GetRHIContext()->CreateBuffer<UniformBlock>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);

		VertexInputState vertex_input_state = {};
		vertex_input_state.input_bindings   = {
            VertexInputState::InputBinding{0, sizeof(VertexData), RHIVertexInputRate::Vertex}};

		BlendState blend_state = {};
		blend_state.attachment_states.resize(1);

		DepthStencilState depth_stencil_state  = {};
		depth_stencil_state.depth_test_enable  = true;
		depth_stencil_state.depth_write_enable = true;

		m_pipeline_state->SetVertexInputState(vertex_input_state);
		m_pipeline_state->SetBlendState(blend_state);
		m_pipeline_state->SetDepthStencilState(depth_stencil_state);
	}

	virtual ~MeshEditor() override = default;

	virtual void Tick() override
	{
		if (!ImGui::Begin(m_name.c_str()))
		{
			ImGui::End();
			return;
		}

		ImGui::Columns(2);

		// Inspector
		{
			ImGui::BeginChild("Mesh Editor Inspector", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);

			ImGui::Text("Mesh Editor Inspector");

			if (ImGui::TreeNode("Mesh"))
			{
				ImGui::Text("Vertices Count: %ld", m_mesh.vertices.size());
				ImGui::Text("Triangle Count: %ld", m_mesh.indices.size() / 3);

				if (ImGui::Button("Clear", ImVec2(150.f, 20.f)))
				{
					m_mesh.vertices.clear();
					m_mesh.indices.clear();
				}

				if (ImGui::BeginDragDropTarget())
				{
					if (const auto *pay_load = ImGui::AcceptDragDropPayload("Mesh"))
					{
						std::string mesh_name = static_cast<const char *>(pay_load->Data);
						auto       *resource  = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Mesh>(mesh_name);

						m_mesh.indices.resize(resource->GetIndexCount());
						m_mesh.vertices.resize(resource->GetVertexCount());

						std::vector<Resource<ResourceType::Mesh>::Vertex> vertices(resource->GetVertexCount());

						resource->GetVertexBuffer()->CopyToHost(vertices.data(), vertices.size() * sizeof(Resource<ResourceType::Mesh>::Vertex));
						resource->GetIndexBuffer()->CopyToHost(m_mesh.indices.data(), m_mesh.indices.size() * sizeof(uint32_t));

						glm::vec3 min_bound = glm::vec3(std::numeric_limits<float>::max());
						glm::vec3 max_bound = glm::vec3(-std::numeric_limits<float>::max());

						for (uint32_t i = 0; i < m_mesh.vertices.size(); i++)
						{
							VertexData data = {};
							data.position   = vertices[i].position;
							data.normal     = vertices[i].normal;
							data.uv         = vertices[i].texcoord0;

							min_bound = glm::min(min_bound, data.position);
							max_bound = glm::max(max_bound, data.position);

							m_mesh.vertices[i] = data;
						}

						m_view.center  = (max_bound + min_bound) * 0.5f;
						m_view.radius  = glm::length(max_bound - min_bound);
						m_scale_factor = m_view.radius;

						UpdateBuffer();
					}
					ImGui::EndDragDropTarget();
				}

				ImGui::TreePop();
			}

			if (ImGui::TreeNode("Rendering"))
			{
				ImGui::Checkbox("Wireframe", &m_wireframe);

				const char *shading_mode[] = {"None", "Shading", "Normal", "UV", "Texture"};
				ImGui::PushItemWidth(90);
				ImGui::Combo("Mode", reinterpret_cast<int32_t *>(&m_shading_mode), shading_mode, 5);
				ImGui::PopItemWidth();
				if (m_shading_mode == ShadingMode::Shading)
				{
					ImGui::ColorEdit3("Color", glm::value_ptr(m_color));
				}
				ImGui::ColorEdit3("Background Color", glm::value_ptr(m_bg_color));
				ImGui::TreePop();
			}

			if (ImGui::TreeNode("Process"))
			{
				for (const auto &file : std::filesystem::directory_iterator("shared/Geometry/"))
				{
					std::string filename = file.path().filename().string();
					{
						if (ImGui::TreeNode("Subdivision"))
						{
							size_t begin = std::string("Geometry.Subdivision.").length();
							size_t end   = filename.find_first_of('.', begin);

							if (ImGui::Button(filename.substr(begin, end - begin).c_str()))
							{
								m_mesh = Subdivision::GetInstance(filename)->Execute(m_mesh);
								UpdateBuffer();
							}
							ImGui::TreePop();
						}
					}
				}

				ImGui::TreePop();
			}

			if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
			{
				ImGui::SetScrollHereY(1.0f);
			}

			ImGui::EndChild();
		}

		ImGui::NextColumn();

		UpdateCamera(ImGui::GetColumnWidth(1), ImGui::GetContentRegionAvail().y);

		// Model Viewer
		if (m_vertex_buffer && m_index_buffer)
		{
			Render(static_cast<uint32_t>(ImGui::GetColumnWidth(1)), static_cast<uint32_t>(ImGui::GetContentRegionAvail().y));
			if (m_render_texture)
			{
				ImGui::Image(m_render_texture.get(), ImVec2{ImGui::GetColumnWidth(1), ImGui::GetContentRegionAvail().y});
			}
		}

		ImGui::End();
	}

	void UpdateBuffer()
	{
		if (!m_mesh.vertices.empty() && !m_mesh.indices.empty())
		{
			if (!m_vertex_buffer || m_mesh.vertices.size() * sizeof(VertexData) > m_vertex_buffer->GetDesc().size)
			{
				m_vertex_buffer = p_editor->GetRHIContext()->CreateBuffer<VertexData>(m_mesh.vertices.size(), RHIBufferUsage::Vertex | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
			}
			if (!m_index_buffer || m_mesh.indices.size() * sizeof(uint32_t) > m_index_buffer->GetDesc().size)
			{
				m_index_buffer = p_editor->GetRHIContext()->CreateBuffer<uint32_t>(m_mesh.indices.size(), RHIBufferUsage::Index | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
			}
			m_vertex_buffer->CopyToDevice(m_mesh.vertices.data(), m_mesh.vertices.size() * sizeof(VertexData));
			m_index_buffer->CopyToDevice(m_mesh.indices.data(), m_mesh.indices.size() * sizeof(uint32_t));
		}
	}

	void Render(uint32_t width, uint32_t height)
	{
		auto *rhi_context = p_editor->GetRHIContext();

		auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
		cmd_buffer->Begin();

		if (!m_uv_texture)
		{
			m_uv_texture = rhi_context->CreateTexture2D(500, 500, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::ShaderResource | RHITextureUsage::Transfer, false);
			std::vector<uint8_t> data(500 * 500 * 4);
			for (size_t i = 0; i < 500; i++)
			{
				for (size_t j = 0; j < 500; j++)
				{
					if (((i / 50) % 2 == 0 && (j / 50) % 2 == 1) ||
					    ((i / 50) % 2 == 1 && (j / 50) % 2 == 0))
					{
						data[500U * 4U * i + 4U * j]     = 0;
						data[500U * 4U * i + 4U * j + 1] = 125;
						data[500U * 4U * i + 4U * j + 2] = 0;
						data[500U * 4U * i + 4U * j + 3] = 255;
					}
					else
					{
						data[500U * 4U * i + 4U * j]     = 255;
						data[500U * 4U * i + 4U * j + 1] = 255;
						data[500U * 4U * i + 4U * j + 2] = 255;
						data[500U * 4U * i + 4U * j + 3] = 255;
					}
				}
			}

			{
				auto *copy_cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
				copy_cmd_buffer->Begin();
				copy_cmd_buffer->ResourceStateTransition({TextureStateTransition{m_uv_texture.get(), RHIResourceState::Undefined, RHIResourceState::TransferDest, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}}, {});
				auto staging_buffer = rhi_context->CreateBuffer(data.size(), RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
				staging_buffer->CopyToDevice(data.data(), data.size());
				copy_cmd_buffer->CopyBufferToTexture(staging_buffer.get(), m_uv_texture.get(), 0, 0, 1);
				copy_cmd_buffer->End();
				rhi_context->Execute(copy_cmd_buffer);
			}

			cmd_buffer->ResourceStateTransition({TextureStateTransition{m_uv_texture.get(), RHIResourceState::TransferDest, RHIResourceState::ShaderResource, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}}, {});
		}

		if (!m_render_texture)
		{
			m_render_texture = rhi_context->CreateTexture2D(1000, 1000, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::RenderTarget | RHITextureUsage::ShaderResource, false);
			m_depth_texture  = rhi_context->CreateTexture2D(1000, 1000, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget, false);
			cmd_buffer->ResourceStateTransition(
			    {TextureStateTransition{m_render_texture.get(), RHIResourceState::Undefined, RHIResourceState::RenderTarget, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
			     TextureStateTransition{m_depth_texture.get(), RHIResourceState::Undefined, RHIResourceState::DepthWrite, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
			    {});
		}
		else
		{
			cmd_buffer->ResourceStateTransition({TextureStateTransition{m_render_texture.get(), RHIResourceState::ShaderResource, RHIResourceState::RenderTarget, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}}, {});
		}

		// Shading
		if (m_shading_mode != ShadingMode::None)
		{
			const char *shading_macros[] = {"NONE", "SHADING", "DRAW_NORMAL", "DRAW_UV", "DRAW_TEXTURE"};

			auto *vertex_shader   = p_editor->GetRenderer()->RequireShader("./Source/Shaders/Editor/MeshEditor.hlsl", "VSmain", RHIShaderStage::Vertex, {shading_macros[(size_t) m_shading_mode]});
			auto *fragment_shader = p_editor->GetRenderer()->RequireShader("./Source/Shaders/Editor/MeshEditor.hlsl", "PSmain", RHIShaderStage::Fragment, {shading_macros[(size_t) m_shading_mode]});

			m_pipeline_state->ClearShader();
			m_pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader);
			m_pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader);

			ShaderMeta meta = p_editor->GetRenderer()->RequireShaderMeta(vertex_shader);
			meta += p_editor->GetRenderer()->RequireShaderMeta(fragment_shader);

			RasterizationState rasterization_state = {};
			rasterization_state.polygon_mode       = RHIPolygonMode::Solid;
			rasterization_state.cull_mode          = RHICullMode::None;
			m_pipeline_state->SetRasterizationState(rasterization_state);

			VertexInputState vertex_input_state = m_pipeline_state->GetVertexInputState();
			if (m_shading_mode == ShadingMode::Shading ||
			    m_shading_mode == ShadingMode::Normal)
			{
				vertex_input_state.input_attributes = {
				    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(VertexData, position)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Normal, 1, 0, RHIFormat::R32G32B32_FLOAT, offsetof(VertexData, normal)},
				};
			}
			else if (m_shading_mode == ShadingMode::UV)
			{
				vertex_input_state.input_attributes = {
				    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(VertexData, position)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 1, 0, RHIFormat::R32G32_FLOAT, offsetof(VertexData, uv)},
				};
			}
			else if (m_shading_mode == ShadingMode::Texture)
			{
				vertex_input_state.input_attributes = {
				    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(VertexData, position)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Normal, 1, 0, RHIFormat::R32G32B32_FLOAT, offsetof(VertexData, normal)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 2, 0, RHIFormat::R32G32_FLOAT, offsetof(VertexData, uv)},
				};
			}
			m_pipeline_state->SetVertexInputState(vertex_input_state);

			m_render_target->Clear();
			m_render_target->Set(0, m_render_texture.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, ColorAttachment{RHILoadAction::Clear, RHIStoreAction::Store, {m_bg_color.x, m_bg_color.y, m_bg_color.z, 1.f}});
			m_render_target->Set(m_depth_texture.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, DepthStencilAttachment{});

			auto *descriptor = rhi_context->CreateDescriptor(meta);
			descriptor->BindTexture("UVTexture", m_uv_texture.get(), RHITextureDimension::Texture2D)
			    .BindSampler("UVSampler", rhi_context->CreateSampler(SamplerDesc::LinearWarp()))
			    .BindBuffer("UniformBuffer", m_uniform_buffer.get());

			cmd_buffer->BeginRenderPass(m_render_target.get());
			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(m_pipeline_state.get());
			cmd_buffer->BindVertexBuffer(0, m_vertex_buffer.get());
			cmd_buffer->BindIndexBuffer(m_index_buffer.get());
			cmd_buffer->SetViewport((float) m_render_target->GetWidth(), (float) m_render_target->GetHeight());
			cmd_buffer->SetScissor(m_render_target->GetWidth(), m_render_target->GetHeight());
			cmd_buffer->DrawIndexed(static_cast<uint32_t>(m_mesh.indices.size()));
			cmd_buffer->EndRenderPass();
		}

		if (m_wireframe)
		{
			auto *vertex_shader   = p_editor->GetRenderer()->RequireShader("./Source/Shaders/Editor/MeshEditor.hlsl", "VSmain", RHIShaderStage::Vertex, {"WIREFRAME"});
			auto *fragment_shader = p_editor->GetRenderer()->RequireShader("./Source/Shaders/Editor/MeshEditor.hlsl", "PSmain", RHIShaderStage::Fragment, {"WIREFRAME"});

			m_pipeline_state->ClearShader();
			m_pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader);
			m_pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader);

			ShaderMeta meta = p_editor->GetRenderer()->RequireShaderMeta(vertex_shader);
			meta += p_editor->GetRenderer()->RequireShaderMeta(fragment_shader);

			RasterizationState rasterization_state = {};
			rasterization_state.polygon_mode       = RHIPolygonMode::Wireframe;
			rasterization_state.cull_mode          = RHICullMode::None;
			m_pipeline_state->SetRasterizationState(rasterization_state);

			VertexInputState vertex_input_state = m_pipeline_state->GetVertexInputState();
			vertex_input_state.input_attributes = {
			    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(VertexData, position)},
			};
			m_pipeline_state->SetVertexInputState(vertex_input_state);

			m_render_target->Clear();
			m_render_target->Set(0, m_render_texture.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, ColorAttachment{m_shading_mode != ShadingMode::None ? RHILoadAction::Load : RHILoadAction::Clear, RHIStoreAction::Store, {0.2f, 0.3f, 0.3f, 1.f}});
			m_render_target->Set(m_depth_texture.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, DepthStencilAttachment{m_shading_mode != ShadingMode::None ? RHILoadAction::Load : RHILoadAction::Clear});

			auto *descriptor = rhi_context->CreateDescriptor(meta);
			descriptor->BindTexture("UVTexture", m_uv_texture.get(), RHITextureDimension::Texture2D)
			    .BindSampler("UVSampler", rhi_context->CreateSampler(SamplerDesc::LinearWarp()))
			    .BindBuffer("UniformBuffer", m_uniform_buffer.get());

			cmd_buffer->BeginRenderPass(m_render_target.get());
			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(m_pipeline_state.get());
			cmd_buffer->BindVertexBuffer(0, m_vertex_buffer.get());
			cmd_buffer->BindIndexBuffer(m_index_buffer.get());
			cmd_buffer->SetViewport((float) m_render_target->GetWidth(), (float) m_render_target->GetHeight());
			cmd_buffer->SetScissor(m_render_target->GetWidth(), m_render_target->GetHeight());
			cmd_buffer->DrawIndexed(static_cast<uint32_t>(m_mesh.indices.size()));
			cmd_buffer->EndRenderPass();
		}

		cmd_buffer->ResourceStateTransition({TextureStateTransition{m_render_texture.get(), RHIResourceState::RenderTarget, RHIResourceState::ShaderResource, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}}, {});
		cmd_buffer->End();
		rhi_context->Submit({cmd_buffer});
	}

	void UpdateCamera(float width, float height)
	{
		float delta_time = ImGui::GetIO().DeltaTime;

		if (ImGui::IsWindowHovered())
		{
			if (ImGui::IsMouseDragging(ImGuiMouseButton_Right))
			{
				ImVec2 delta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Right);
				ImGui::ResetMouseDragDelta(ImGuiMouseButton_Right);
				m_view.phi -= delta.y * delta_time * 50.f;
				m_view.theta -= delta.x * delta_time * 50.f;
			}
			m_view.radius += m_scale_factor * ImGui::GetIO().MouseWheel * delta_time * 10.f;
		}

		glm::vec3 position = m_view.center + m_view.radius * glm::vec3(glm::sin(glm::radians(m_view.phi)) * glm::sin(glm::radians(m_view.theta)), glm::cos(glm::radians(m_view.phi)), glm::sin(glm::radians(m_view.phi)) * glm::cos(glm::radians(m_view.theta)));

		UniformBlock block = {};

		block.color     = m_color;
		block.direction = glm::normalize(m_view.center - position);
		glm::vec3 right = glm::normalize(glm::cross(block.direction, glm::vec3{0.f, 1.f, 0.f}));
		glm::vec3 up    = glm::normalize(glm::cross(right, block.direction));
		block.transform = glm::perspective(glm::radians(45.f), width / height, 0.01f, 1000.f) * glm::lookAt(position, m_view.center, up);

		m_uniform_buffer->CopyToDevice(&block, sizeof(block));
	}

  private:
	TriMesh m_mesh;

	std::string m_mesh_name;

	struct
	{
		glm::vec3 center = glm::vec3(0.f);
		float     radius = 0.f;
		float     theta  = 0.f;
		float     phi    = 90.f;
	} m_view;

	std::unique_ptr<RHIPipelineState> m_pipeline_state = nullptr;
	std::unique_ptr<RHIRenderTarget>  m_render_target  = nullptr;

	std::unique_ptr<RHIBuffer> m_vertex_buffer = nullptr;
	std::unique_ptr<RHIBuffer> m_index_buffer  = nullptr;

	std::unique_ptr<RHIBuffer> m_uniform_buffer = nullptr;

	std::unique_ptr<RHITexture> m_uv_texture     = nullptr;
	std::unique_ptr<RHITexture> m_render_texture = nullptr;
	std::unique_ptr<RHITexture> m_depth_texture  = nullptr;

	glm::vec3 m_color    = glm::vec3(1.f);
	glm::vec3 m_bg_color = glm::vec3(0.2f, 0.3f, 0.3f);

	float m_scale_factor = 1.f;

	bool m_wireframe = false;

	ShadingMode m_shading_mode = ShadingMode::Shading;
};

extern "C"
{
	EXPORT_API MeshEditor *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		return new MeshEditor(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/RenderGraphEditor.cpp
================================================
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <RenderGraph/RenderGraph.hpp>
#include <RenderGraph/RenderGraphBlackboard.hpp>
#include <RenderGraph/RenderGraphBuilder.hpp>
#include <RenderGraph/RenderPass.hpp>
#include <Renderer/RenderData.hpp>
#include <Renderer/Renderer.hpp>
#include <Resource/Resource/RenderPipeline.hpp>
#include <Resource/ResourceManager.hpp>

#include <imgui.h>
#include <imgui_internal.h>
#include <imnodes/imnodes.h>

#include <nfd.h>

using namespace Ilum;

class RenderGraphEditor : public Widget
{
  public:
	RenderGraphEditor(Editor *editor) :
	    Widget("Render Graph Editor", editor)
	{
		ImNodes::CreateContext();
		m_context = ImNodes::EditorContextCreate();
	}

	virtual ~RenderGraphEditor() override
	{
		ImNodes::DestroyContext();
		ImNodes::EditorContextFree(m_context);
	}

	virtual void Tick() override
	{
		if (!ImGui::Begin(m_name.c_str(), nullptr))
		{
			ImGui::End();
			return;
		}

		auto *resource_manager = p_editor->GetRenderer()->GetResourceManager();
		auto *resource         = resource_manager->Get<ResourceType::RenderPipeline>(m_pipeline_name);

		ImGui::Columns(2);

		{
			ImGui::BeginChild("Render Pipeline Editor Inspector", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);

			ImGui::Text("Render Pipeline Editor Inspector");

			SetRenderPipeline(resource, resource_manager);

			if (resource)
			{
				for (auto &node : m_select_nodes)
				{
					if (resource->GetDesc().HasPass(node))
					{
						auto &pass = resource->GetDesc().GetPass(static_cast<size_t>(node));
						if (!pass.GetConfig().Empty())
						{
							ImGui::Separator();
							PluginManager::GetInstance().Call<bool>(fmt::format("shared/RenderPass/RenderPass.{}.{}.dll", pass.GetCategory(), pass.GetName()), "OnImGui", &pass.GetConfig(), ImGui::GetCurrentContext());
						}
					}
				}
			}

			if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
			{
				ImGui::SetScrollHereY(1.0f);
			}

			ImGui::EndChild();
		}

		ImGui::NextColumn();

		{
			ImGui::BeginChild("Render Graph Editor", ImVec2(0, 0), false, ImGuiWindowFlags_MenuBar);

			if (resource)
			{
				MainMenuBar(resource);
			}

			HandleSelection();

			ImNodes::BeginNodeEditor();

			if (resource)
			{
				for (auto &new_node : m_new_nodes)
				{
					ImNodes::SetNodeScreenSpacePos(new_node, ImGui::GetMousePos());
				}
				m_new_nodes.clear();

				PopupWindow(resource);
				DrawNodes(resource);
				DrawEdges(resource);
			}

			ImNodes::MiniMap(0.1f);
			ImNodes::EndNodeEditor();

			DragDropResource();

			if (resource)
			{
				AddEdge(resource);
			}

			ImGui::EndChild();
		}

		ImGui::End();
	}

  private:
	void HandleSelection()
	{
		m_select_links.clear();
		m_select_nodes.clear();

		if (ImNodes::NumSelectedLinks() > 0)
		{
			m_select_links.resize(ImNodes::NumSelectedLinks());
			ImNodes::GetSelectedLinks(m_select_links.data());
		}

		if (ImNodes::NumSelectedNodes() > 0)
		{
			m_select_nodes.resize(ImNodes::NumSelectedNodes());
			ImNodes::GetSelectedNodes(m_select_nodes.data());
		}
	}

	void AddEdge(Resource<ResourceType::RenderPipeline> *resource)
	{
		int32_t src = 0, dst = 0;
		if (ImNodes::IsLinkCreated(&src, &dst))
		{
			resource->GetDesc().Link(static_cast<size_t>(glm::abs(src)), static_cast<size_t>(glm::abs(dst)));
		}
	}

	void PopupWindow(Resource<ResourceType::RenderPipeline> *resource)
	{
		if (ImGui::BeginPopupContextWindow(0, ImGuiPopupFlags_MouseButtonRight))
		{
			if (!m_select_links.empty() || !m_select_nodes.empty())
			{
				if (ImGui::MenuItem("Remove"))
				{
					for (auto &link : m_select_links)
					{
						for (auto &[dst, src] : resource->GetDesc().GetEdges())
						{
							if (link == static_cast<int32_t>(Hash(src, dst)))
							{
								resource->GetDesc().EraseLink(static_cast<size_t>(src), static_cast<size_t>(dst));
								break;
							}
						}
					}
					for (auto &node : m_select_nodes)
					{
						resource->GetDesc().ErasePass(node);
					}
				}

				m_select_nodes.clear();
				m_select_links.clear();
			}

			ImGui::EndPopup();
		}
	}

	void MainMenuBar(Resource<ResourceType::RenderPipeline> *resource)
	{
		if (ImGui::BeginMenuBar())
		{
			if (ImGui::BeginMenu("Pass"))
			{
				for (const auto &file : std::filesystem::directory_iterator("shared/RenderPass/"))
				{
					std::string filename = file.path().filename().string();
					{
						size_t pos1 = filename.find_first_of('.');
						size_t pos2 = filename.find_first_of('.', pos1 + 1);
						size_t pos3 = filename.find_first_of('.', pos2 + 1);

						std::string category  = filename.substr(pos1 + 1, pos2 - pos1 - 1);
						std::string node_name = filename.substr(pos2 + 1, pos3 - pos2 - 1);

						if (ImGui::BeginMenu(category.c_str()))
						{
							if (ImGui::MenuItem(node_name.c_str()))
							{
								RenderPassDesc desc;
								PluginManager::GetInstance().Call(file.path().string(), "Create", &desc, &m_current_handle);
								m_new_nodes.push_back(static_cast<int32_t>(m_current_handle));
								resource->GetDesc().AddPass(m_current_handle++, std::move(desc));
							}
							ImGui::EndMenu();
						}
					}
				}
				ImGui::EndMenu();
			}

			if (ImGui::MenuItem("Compile"))
			{
				auto *rhi_context = p_editor->GetRHIContext();
				auto *renderer    = p_editor->GetRenderer();
				auto render_graph = resource->Compile(rhi_context, renderer, renderer->GetViewport(), ImNodes::SaveCurrentEditorStateToIniString());

				if (render_graph)
				{
					renderer->SetRenderGraph(std::move(render_graph));
				}
				else
				{
					LOG_INFO("Render Graph Compile Failed!");
				}
			}

			if (!resource->GetDesc().GetPasses().empty())
			{
				if (ImGui::MenuItem("Clear"))
				{
					resource->GetDesc().Clear();
				}
			}

			ImGui::EndMenuBar();
		}
	}

	void DrawNodes(Resource<ResourceType::RenderPipeline> *resource)
	{
		for (auto &[node_handle, node_desc] : resource->GetDesc().GetPasses())
		{
			const float node_width = glm::max(ImGui::CalcTextSize(node_desc.GetName().c_str()).x, 150.f);

			ImNodes::BeginNode(static_cast<int32_t>(node_handle));
			ImNodes::BeginNodeTitleBar();
			ImGui::Text(node_desc.GetName().c_str());
			ImNodes::EndNodeTitleBar();

			// Draw exec pin
			{
				ImNodes::PushColorStyle(ImNodesCol_Pin, IM_COL32(255, 255, 255, 255));
				ImNodes::PushColorStyle(ImNodesCol_PinHovered, IM_COL32(255, 255, 255, 255));
				ImNodes::PushColorStyle(ImNodesCol_Link, IM_COL32(255, 255, 255, 255));

				// In attribute
				ImNodes::BeginInputAttribute(static_cast<int32_t>(node_handle));
				ImGui::TextUnformatted("In");
				ImNodes::EndInputAttribute();

				ImGui::SameLine();

				// Out attribute
				ImNodes::BeginOutputAttribute(-static_cast<int32_t>(node_handle));
				const float label_width = ImGui::CalcTextSize("OutIn ").x;
				ImGui::Indent(node_width - label_width);
				ImGui::TextUnformatted("Out");
				ImNodes::EndOutputAttribute();

				ImNodes::PopColorStyle();
				ImNodes::PopColorStyle();
				ImNodes::PopColorStyle();
			}

			for (auto &[pin_handle, pin] : node_desc.GetPins())
			{
				if (pin.attribute == RenderPassPin::Attribute::Input)
				{
					ImNodes::PushColorStyle(ImNodesCol_Pin, m_color[pin.type]);
					ImNodes::BeginInputAttribute(static_cast<int32_t>(pin_handle));
					ImGui::TextUnformatted(pin.name.c_str());
					if (!resource->GetDesc().HasLink(pin_handle))
					{
						ImGui::SameLine();
						ImGui::PushItemWidth(node_width - ImGui::CalcTextSize(pin.name.c_str()).x);
						ImGui::PopItemWidth();
					}
					ImNodes::EndInputAttribute();
					ImNodes::PopColorStyle();
				}
				else
				{
					ImNodes::PushColorStyle(ImNodesCol_Pin, m_color[pin.type]);
					ImNodes::BeginOutputAttribute(static_cast<int32_t>(pin_handle));
					const float label_width = ImGui::CalcTextSize(pin.name.c_str()).x;
					ImGui::Indent(node_width - label_width);
					ImGui::TextUnformatted(pin.name.c_str());
					ImNodes::EndOutputAttribute();
					ImNodes::PopColorStyle();
				}
			}
			ImNodes::EndNode();
		}
	}

	void DrawEdges(Resource<ResourceType::RenderPipeline> *resource)
	{
		for (auto &[dst, src] : resource->GetDesc().GetEdges())
		{
			const auto &src_node = resource->GetDesc().GetPass(src);
			const auto &dst_node = resource->GetDesc().GetPass(dst);

			if ((src == src_node.GetHandle()) &&
			    (dst == dst_node.GetHandle()))
			{
				ImNodes::PushColorStyle(ImNodesCol_Link, m_color[RenderPassPin::Type::Unknown]);
				ImNodes::Link(static_cast<int32_t>(Hash(src, dst)), -static_cast<int32_t>(src), static_cast<int32_t>(dst));
				ImNodes::PopColorStyle();
			}
			else if ((src != src_node.GetHandle()) &&
			         (dst != dst_node.GetHandle()))
			{
				auto type = src_node.GetPin(src).type;
				ImNodes::PushColorStyle(ImNodesCol_Link, m_color[type]);
				ImNodes::Link(static_cast<int32_t>(Hash(src, dst)), static_cast<int32_t>(src), static_cast<int32_t>(dst));
				ImNodes::PopColorStyle();
			}
		}
	}

	void SetRenderPipeline(Resource<ResourceType::RenderPipeline> *resource, ResourceManager *manager)
	{
		ImGui::PushItemWidth(100.f);
		char buf[128] = {0};
		std::memcpy(buf, m_pipeline_name.data(), sizeof(buf));
		if (ImGui::InputText("##NewRenderPipeline", buf, sizeof(buf)))
		{
			m_pipeline_name = buf;
		}
		ImGui::PopItemWidth();

		ImGui::SameLine();

		if (!m_pipeline_name.empty() && !resource)
		{
			if (ImGui::Button("New Render Pipeline"))
			{
				RenderGraphDesc desc;
				desc.SetName(m_pipeline_name);
				manager->Add<ResourceType::RenderPipeline>(p_editor->GetRHIContext(), m_pipeline_name, std::move(desc));
				resource = manager->Get<ResourceType::RenderPipeline>(m_pipeline_name);
			}
		}
		else
		{
			ImGui::Text("Render Pipeline Name");
		}
	}

	void DragDropResource()
	{
		if (ImGui::BeginDragDropTarget())
		{
			if (const auto *pay_load = ImGui::AcceptDragDropPayload("RenderPipeline"))
			{
				m_pipeline_name = static_cast<const char *>(pay_load->Data);
				auto *resource  = p_editor->GetRenderer()->GetResourceManager()->Get<ResourceType::RenderPipeline>(m_pipeline_name);
				if (resource)
				{
					ImNodes::LoadCurrentEditorStateFromIniString(resource->GetLayout().data(), resource->GetLayout().length());
					auto &desc = resource->GetDesc();
					for (auto &[node_handle, node] : desc.GetPasses())
					{
						m_current_handle = glm::max(m_current_handle, node_handle + 1);
						for (auto &[pin_handle, pin] : node.GetPins())
						{
							m_current_handle = glm::max(m_current_handle, pin_handle + 1);
						}
					}
				}
			}
		}
	}

	void DrawInspector()
	{
		ImGui::BeginChild("Render Graph Inspector", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);

		if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
		{
			ImGui::SetScrollHereY(1.0f);
		}

		ImGui::EndChild();
	}

  private:
	ImNodesEditorContext *m_context = nullptr;

	std::string m_pipeline_name = "";

	size_t m_current_handle = 0;

	std::vector<int32_t> m_select_nodes;
	std::vector<int32_t> m_select_links;

	std::vector<int32_t> m_new_nodes;

	std::vector<std::tuple<int32_t, int32_t, uint32_t>> m_edges;

	std::map<RenderPassPin::Type, uint32_t> m_color = {
	    {RenderPassPin::Type::Buffer, IM_COL32(0, 128, 0, 255)},
	    {RenderPassPin::Type::Texture, IM_COL32(128, 0, 0, 255)},
	    {RenderPassPin::Type::Unknown, IM_COL32(255, 255, 255, 255)},
	};
};

extern "C"
{
	EXPORT_API RenderGraphEditor *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		return new RenderGraphEditor(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/ResourceBrowser.cpp
================================================
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <Renderer/Renderer.hpp>
#include <Resource/Resource.hpp>
#include <Resource/ResourceManager.hpp>

#include <imgui.h>
#include <imgui_internal.h>

#include <nfd.h>

using namespace Ilum;

class ResourceBrowser : public Widget
{
  public:
	ResourceBrowser(Editor *editor) :
	    Widget("Resource Browser", editor)
	{
	}

	virtual ~ResourceBrowser() = default;

	virtual void Tick() override
	{
		if (!ImGui::Begin(m_name.c_str()))
		{
			ImGui::End();
			return;
		}

		auto *resource_manager = p_editor->GetRenderer()->GetResourceManager();

		ImGui::Columns(2);
		ImGui::SetColumnWidth(0, 200.f);

		ImGui::BeginChild("Resource Browser Category", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);

		if (ImGui::Button("Import"))
		{
			char *path = nullptr;
			if (NFD_OpenDialog("jpg,png,bmp,jpeg,dds,hdr,gltf,obj,glb,fbx,ply,blend,dae,mat", Path::GetInstance().GetCurrent(false).c_str(), &path) == NFD_OKAY)
			{
				ResourceType type = m_resource_map.at(Path::GetInstance().GetFileExtension(path));
				switch (type)
				{
					case ResourceType::Prefab:
						resource_manager->Import<ResourceType::Prefab>(path);
						break;
					case ResourceType::Texture2D:
						resource_manager->Import<ResourceType::Texture2D>(path);
						break;
					case ResourceType::TextureCube:
						resource_manager->Import<ResourceType::TextureCube>(path);
						break;
					default:
						break;
				}
			}
		}

		for (auto &[type, name] : m_resource_types)
		{
			bool open = ImGui::TreeNodeEx(name, ImGuiTreeNodeFlags_FramePadding | ImGuiTreeNodeFlags_DefaultOpen | (m_current_type == type ? ImGuiTreeNodeFlags_Selected : 0) | ImGuiTreeNodeFlags_Leaf);
			if (ImGui::IsItemClicked())
			{
				m_current_type = type;
			}

			if (open)
			{
				ImGui::TreePop();
			}
		}

		if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
		{
			ImGui::SetScrollHereY(1.0f);
		}

		ImGui::EndChild();

		ImGui::NextColumn();

		ImGui::BeginChild("Resource Browser Viewer", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);

		std::unordered_map<ResourceType, std::function<void(void)>> draw_resources = {
#define DRAW_RESOURCE(TYPE)                                          \
	{                                                                \
		TYPE, [&]() { DrawResource<TYPE>(resource_manager, 100.f); } \
	}

		    DRAW_RESOURCE(ResourceType::Prefab),
		    DRAW_RESOURCE(ResourceType::Mesh),
		    DRAW_RESOURCE(ResourceType::SkinnedMesh),
		    DRAW_RESOURCE(ResourceType::Texture2D),
		    DRAW_RESOURCE(ResourceType::TextureCube),
		    DRAW_RESOURCE(ResourceType::Material),
		    DRAW_RESOURCE(ResourceType::Animation),
		    DRAW_RESOURCE(ResourceType::RenderPipeline),
		    DRAW_RESOURCE(ResourceType::Scene),
		};

		draw_resources.at(m_current_type)();

		if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
		{
			ImGui::SetScrollHereY(1.0f);
		}

		ImGui::EndChild();

		ImGui::End();
	}

  private:
	template <ResourceType _Ty>
	inline void DrawResource(ResourceManager *manager, float button_size)
	{
		float width = 0.f;

		ImGuiStyle &style    = ImGui::GetStyle();
		style.ItemSpacing    = ImVec2(10.f, 10.f);
		float window_visible = ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMax().x;

		const std::vector<std::string> resources = manager->GetResources<_Ty>(false);

		for (const auto &resource_name : resources)
		{
			auto *thumbnail = manager->GetThumbnail<_Ty>(resource_name);

			ImGui::PushID(resource_name.c_str());
			ImGui::ImageButton(thumbnail ? thumbnail : ImGui::GetIO().Fonts->TexID, ImVec2{button_size, button_size});

			// Drag&Drop source
			if (ImGui::BeginDragDropSource())
			{
				ImGui::SetDragDropPayload(m_resource_types.at(_Ty), resource_name.c_str(), resource_name.length() + 1);
				ImGui::EndDragDropSource();
			}

			if (ImGui::BeginPopupContextItem(resource_name.c_str()))
			{
				if (ImGui::MenuItem("Delete"))
				{
					manager->Erase<_Ty>(resource_name);
					ImGui::EndPopup();
					ImGui::PopID();
					return;
				}
				ImGui::EndPopup();
			}
			else if (ImGui::IsItemHovered() && ImGui::IsWindowFocused())
			{
				ImVec2 pos = ImGui::GetIO().MousePos;
				ImGui::SetNextWindowPos(ImVec2(pos.x + 10.f, pos.y + 10.f));
				ImGui::Begin(resource_name.c_str(), NULL, ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar);
				ImGui::Text(resource_name.c_str());
				ImGui::End();
			}

			float last_button = ImGui::GetItemRectMax().x;
			float next_button = last_button + style.ItemSpacing.x + button_size;
			if (next_button < window_visible)
			{
				ImGui::SameLine();
			}

			ImGui::PopID();
		}
	}

  private:
	ResourceType m_current_type = ResourceType::Prefab;

	std::unordered_map<ResourceType, const char *const> m_resource_types = {
	    {ResourceType::Mesh, "Mesh"},
	    {ResourceType::SkinnedMesh, "SkinnedMesh"},
	    {ResourceType::Prefab, "Prefab"},
	    {ResourceType::Texture2D, "Texture2D"},
	    {ResourceType::TextureCube, "TextureCube"},
	    {ResourceType::Animation, "Animation"},
	    {ResourceType::Material, "Material"},
	    {ResourceType::RenderPipeline, "RenderPipeline"},
	    {ResourceType::Scene, "Scene"},
	};

	std::unordered_map<std::string, ResourceType> m_resource_map = {
	    {".jpg", ResourceType::Texture2D},
	    {".png", ResourceType::Texture2D},
	    {".bmp", ResourceType::Texture2D},
	    {".jpeg", ResourceType::Texture2D},
	    {".dds", ResourceType::Texture2D},
	    {".hdr", ResourceType::TextureCube},
	    {".gltf", ResourceType::Prefab},
	    {".obj", ResourceType::Prefab},
	    {".glb", ResourceType::Prefab},
	    {".fbx", ResourceType::Prefab},
	    {".ply", ResourceType::Prefab},
	    {".dae", ResourceType::Prefab},
	};
};

extern "C"
{
	EXPORT_API ResourceBrowser *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		return new ResourceBrowser(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/SceneView.cpp
================================================
#pragma once

#include <Core/Window.hpp>
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <RenderGraph/RenderGraph.hpp>
#include <Renderer/Renderer.hpp>
#include <Resource/Resource/Animation.hpp>
#include <Resource/Resource/Prefab.hpp>
#include <Resource/Resource/RenderPipeline.hpp>
#include <Resource/Resource/Scene.hpp>
#include <Resource/ResourceManager.hpp>
#include <Scene/Components/AllComponents.hpp>
#include <Scene/Node.hpp>
#include <Scene/Scene.hpp>

#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <imgui.h>
#include <imgui_internal.h>

#include <IconsFontAwesome/IconsFontAwesome5.h>

#include <ImGuizmo/ImGuizmo.h>

#include <GLFW/glfw3.h>

#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <stb/stb_image_write.h>

#include <nfd.h>

using namespace Ilum;

inline glm::vec3 SmoothStep(const glm::vec3 &v1, const glm::vec3 &v2, float t)
{
	t = glm::clamp(t, 0.f, 1.f);
	t = t * t * (3.f - 2.f * t);

	glm::vec3 v = glm::mix(v1, v2, t);

	return v;
}

class SceneView : public Widget
{
  private:
	struct
	{
		float speed     = 1.f;
		float sensitity = 3.f;

		glm::vec3 velocity = glm::vec3(0.f);
		glm::vec2 viewport = glm::vec2(0.f);
	} m_camera_config;

	glm::vec2 m_cursor_position = glm::vec2(0.f);

	bool m_hide_cursor = false;

  public:
	SceneView(Editor *editor) :
	    Widget("Scene View", editor)
	{
		glfwInit();
	}

	virtual ~SceneView() override
	{
		glfwTerminate();
	}

	virtual void Tick() override
	{
		if (!p_editor->GetMainCamera())
		{
			auto perspectives = p_editor->GetRenderer()->GetScene()->GetComponents<Cmpt::PerspectiveCamera>();
			if (!perspectives.empty())
			{
				p_editor->SetMainCamera(perspectives[0]);
			}
			else
			{
				auto orthographics = p_editor->GetRenderer()->GetScene()->GetComponents<Cmpt::OrthographicCamera>();
				if (!orthographics.empty())
				{
					p_editor->SetMainCamera(orthographics[0]);
				}
			}
		}

		if (!ImGui::Begin(m_name.c_str()))
		{
			ImGui::End();
			return;
		}

		UpdateAnimation();

		ShowToolBar();

		auto *camera = p_editor->GetMainCamera();

		ImGuizmo::SetDrawlist();

		ImVec2 offset              = ImGui::GetCursorPos();
		ImVec2 scene_view_size     = ImVec2(ImGui::GetWindowContentRegionMax().x - ImGui::GetWindowContentRegionMin().x, ImGui::GetWindowContentRegionMax().y - ImGui::GetWindowContentRegionMin().y);
		ImVec2 scene_view_position = ImVec2(ImGui::GetWindowPos().x + offset.x, ImGui::GetWindowPos().y + offset.y);

		m_camera_config.viewport.x = scene_view_size.x - (static_cast<uint32_t>(scene_view_size.x) % 2 != 0 ? 1.0f : 0.0f);
		m_camera_config.viewport.y = scene_view_size.y - (static_cast<uint32_t>(scene_view_size.y) % 2 != 0 ? 1.0f : 0.0f);

		if (camera)
		{
			UpdateCamera();
		}

		ImGuizmo::SetRect(scene_view_position.x, scene_view_position.y, m_camera_config.viewport.x, m_camera_config.viewport.y);

		if (camera)
		{
			ImGuizmo::DrawGrid(glm::value_ptr(camera->GetViewMatrix()), glm::value_ptr(camera->GetProjectionMatrix()), glm::value_ptr(glm::mat4(1.0)), 1000.f);
		}

		DisplayPresent();

		MoveEntity();

		ImGui::End();
	}

  private:
	template <ResourceType _Ty>
	void DropTarget(Editor *editor, const std::string &name)
	{
	}

	template <>
	void DropTarget<ResourceType::Mesh>(Editor *editor, const std::string &name)
	{
		auto *resource = editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Mesh>(name);
		if (resource)
		{
			auto *node = p_editor->GetRenderer()->GetScene()->CreateNode(resource->GetName());
			node->AddComponent<Cmpt::Transform>(std::make_unique<Cmpt::Transform>(node));
			auto *mesh_renderer = node->AddComponent<Cmpt::MeshRenderer>(std::make_unique<Cmpt::MeshRenderer>(node));
			mesh_renderer->AddSubmesh(resource->GetName());
		}
	}

	template <>
	void DropTarget<ResourceType::Prefab>(Editor *editor, const std::string &name)
	{
		auto *prefab = editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Prefab>(name);

		if (prefab)
		{
			auto &root  = prefab->GetRoot();
			auto *scene = editor->GetRenderer()->GetScene();

			std::function<Node *(decltype(root) &)> create_node = [&](decltype(root) &prefab_node) {
				Node *node = scene->CreateNode(prefab_node.name);

				Cmpt::Transform *transform   = node->AddComponent<Cmpt::Transform>(std::make_unique<Cmpt::Transform>(node));
				glm::vec3        translation = glm::vec3(0.f);
				glm::vec3        rotation    = glm::vec3(0.f);
				glm::vec3        scale       = glm::vec3(0.f);
				ImGuizmo::DecomposeMatrixToComponents(
				    glm::value_ptr(prefab_node.transform),
				    glm::value_ptr(translation),
				    glm::value_ptr(rotation),
				    glm::value_ptr(scale));
				transform->SetTranslation(translation);
				transform->SetRotation(rotation);
				transform->SetScale(scale);

				std::vector<std::string> materials;
				std::vector<std::string> animations;
				Cmpt::Renderable        *renderable = nullptr;
				for (auto &[type, uuid] : prefab_node.resources)
				{
					switch (type)
					{
						case ResourceType::Mesh: {
							Cmpt::MeshRenderer *mesh_renderer = node->HasComponent<Cmpt::MeshRenderer>() ?
							                                        node->GetComponent<Cmpt::MeshRenderer>() :
							                                        node->AddComponent<Cmpt::MeshRenderer>(std::make_unique<Cmpt::MeshRenderer>(node));
							mesh_renderer->AddSubmesh(uuid);
							renderable = mesh_renderer;
						}
						break;
						case ResourceType::SkinnedMesh: {
							Cmpt::SkinnedMeshRenderer *skinned_mesh_renderer = node->HasComponent<Cmpt::SkinnedMeshRenderer>() ?
							                                                       node->GetComponent<Cmpt::SkinnedMeshRenderer>() :
							                                                       node->AddComponent<Cmpt::SkinnedMeshRenderer>(std::make_unique<Cmpt::SkinnedMeshRenderer>(node));
							skinned_mesh_renderer->AddSubmesh(uuid);
							renderable = skinned_mesh_renderer;
						}
						break;
						case ResourceType::Material: {
							materials.push_back(uuid);
						}
						break;
						case ResourceType::Animation: {
							animations.push_back(uuid);
						}
						break;
						default:
							break;
					}
				}

				if (renderable)
				{
					for (auto &uuid : materials)
					{
						renderable->AddMaterial(uuid);
					}
					for (auto &uuid : animations)
					{
						renderable->AddAnimation(uuid);
					}
				}

				for (auto &prefab_child : prefab_node.children)
				{
					Node *child = create_node(prefab_child);
					child->SetParent(node);
				}

				return node;
			};

			create_node(root);
		}
	}

	template <>
	void DropTarget<ResourceType::RenderPipeline>(Editor *editor, const std::string &name)
	{
		auto *resource = editor->GetRenderer()->GetResourceManager()->Get<ResourceType::RenderPipeline>(name);

		if (resource)
		{
			auto *rhi_context  = editor->GetRHIContext();
			auto *renderer     = editor->GetRenderer();
			auto  render_graph = resource->Compile(rhi_context, renderer, m_camera_config.viewport);

			if (render_graph)
			{
				renderer->SetRenderGraph(std::move(render_graph));
			}
		}
	}

	template <>
	void DropTarget<ResourceType::Scene>(Editor *editor, const std::string &name)
	{
		auto *resource = editor->GetRenderer()->GetResourceManager()->Get<ResourceType::Scene>(name);
		auto *scene    = editor->GetRenderer()->GetScene();
		editor->SelectNode();

		if (resource)
		{
			editor->SetMainCamera();
			auto *rhi_context = editor->GetRHIContext();
			resource->Update(scene);
			m_scene_name = name;
			scene->SetName(m_scene_name);
		}
	}

	void DropTarget(Editor *editor)
	{
#define DROP_TARGET(TYPE)                                                                  \
	if (const auto *pay_load = ImGui::AcceptDragDropPayload(#TYPE))                        \
	{                                                                                      \
		DropTarget<ResourceType::TYPE>(editor, static_cast<const char *>(pay_load->Data)); \
	}

		DROP_TARGET(Prefab)
		DROP_TARGET(RenderPipeline)
		DROP_TARGET(Scene)
		DROP_TARGET(Mesh)
	}

	void DisplayPresent()
	{
		auto *renderer = p_editor->GetRenderer();
		renderer->SetViewport(m_camera_config.viewport.x, m_camera_config.viewport.y);

		auto *present_texture = renderer->GetPresentTexture();

		if (present_texture)
		{
			ImGui::Image(present_texture, ImGui::GetContentRegionAvail());
		}

		if (ImGui::BeginDragDropTarget())
		{
			DropTarget(p_editor);
		}
	}

	void UpdateCamera()
	{
		auto *camera    = p_editor->GetMainCamera();
		auto *transform = camera->GetNode()->GetComponent<Cmpt::Transform>();

		glm::mat4 view_matrix = camera->GetViewMatrix();

		camera->SetAspect(m_camera_config.viewport.x / m_camera_config.viewport.y);

		if (!ImGui::IsWindowFocused() || !ImGui::IsWindowHovered())
		{
			return;
		}

		if (ImGui::IsMouseDown(ImGuiMouseButton_Right))
		{
			if (!m_hide_cursor)
			{
				m_hide_cursor     = true;
				m_cursor_position = p_editor->GetWindow()->GetMousePosition();
			}

			auto delta_time = ImGui::GetIO().DeltaTime;
			auto delta_pos  = p_editor->GetWindow()->GetMousePosition() - m_cursor_position;
			p_editor->GetWindow()->SetCursorPosition(m_cursor_position);
			ImGui::SetMouseCursor(ImGuiMouseCursor_None);

			float yaw   = std::atan2f(-view_matrix[2][2], -view_matrix[0][2]);
			float pitch = std::asinf(-glm::clamp(view_matrix[1][2], -0.99f, 0.99f));

			if (delta_pos.x != 0.f)
			{
				yaw += m_camera_config.sensitity * delta_time * delta_pos.x * 0.1f;
				glm::vec3 rotation = transform->GetRotation();
				rotation.y         = -glm::degrees(yaw) - 90.f;
				transform->SetRotation(rotation);
			}

			if (delta_pos.y != 0.f)
			{
				pitch -= m_camera_config.sensitity * delta_time * delta_pos.y * 0.1f;
				glm::vec3 rotation = transform->GetRotation();
				rotation.x         = glm::degrees(pitch);
				transform->SetRotation(rotation);
			}

			glm::vec3 forward = {};

			forward.x = glm::cos(yaw) * glm::cos(pitch);
			forward.y = glm::sin(pitch);
			forward.z = glm::sin(yaw) * glm::cos(pitch);

			forward = glm::normalize(forward);

			glm::vec3 right = glm::normalize(glm::cross(forward, glm::vec3{0.f, 1.f, 0.f}));
			glm::vec3 up    = glm::normalize(glm::cross(right, forward));

			glm::vec3 direction = glm::vec3(0.f);

			m_camera_config.speed = glm::clamp(m_camera_config.speed + 0.5f * ImGui::GetIO().MouseWheel, 0.f, 30.f);

			if (p_editor->GetWindow()->IsKeyPressed(KeyCode::W))
			{
				direction += forward;
			}
			if (p_editor->GetWindow()->IsKeyPressed(KeyCode::S))
			{
				direction -= forward;
			}
			if (p_editor->GetWindow()->IsKeyPressed(KeyCode::D))
			{
				direction += right;
			}
			if (p_editor->GetWindow()->IsKeyPressed(KeyCode::A))
			{
				direction -= right;
			}
			if (p_editor->GetWindow()->IsKeyPressed(KeyCode::Q))
			{
				direction += up;
			}
			if (p_editor->GetWindow()->IsKeyPressed(KeyCode::E))
			{
				direction -= up;
			}

			m_camera_config.velocity = SmoothStep(m_camera_config.velocity, direction * m_camera_config.speed, 0.2f);

			transform->SetTranslation(transform->GetTranslation() + delta_time * m_camera_config.velocity);
		}
		else if (m_hide_cursor)
		{
			m_hide_cursor            = false;
			m_camera_config.velocity = glm::vec3(0.f);
		}

		p_editor->GetRenderer()->UpdateView(camera);
	}

	void MoveEntity()
	{
		Node *node   = p_editor->GetSelectedNode();
		auto *camera = p_editor->GetMainCamera();

		if (!node || !camera)
		{
			return;
		}

		auto *transform = node->GetComponent<Cmpt::Transform>();

		glm::mat4 local_transform = transform->GetLocalTransform();

		if (ImGuizmo::Manipulate(
		        glm::value_ptr(camera->GetViewMatrix()),
		        glm::value_ptr(camera->GetProjectionMatrix()),
		        ImGuizmo::OPERATION::UNIVERSAL,
		        ImGuizmo::WORLD, glm::value_ptr(local_transform), NULL, NULL, NULL, NULL))
		{
			glm::vec3 translation = glm::vec3(0.f);
			glm::vec3 rotation    = glm::vec3(0.f);
			glm::vec3 scale       = glm::vec3(0.f);

			ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(local_transform),
			                                      glm::value_ptr(translation),
			                                      glm::value_ptr(rotation),
			                                      glm::value_ptr(scale));
			transform->SetTranslation(translation);
			transform->SetRotation(rotation);
			transform->SetScale(scale);
		}
	}

	void ShowToolBar()
	{
#define SHOW_TIPS(str)               \
	if (ImGui::IsItemHovered())      \
	{                                \
		ImGui::BeginTooltip();       \
		ImGui::TextUnformatted(str); \
		ImGui::EndTooltip();         \
	}

		ImGui::Indent();
		ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
		ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.f);
		ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.f, 0.f));
		ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(5.f, 5.f));

		ImGui::SameLine();

		if (ImGui::Button("Scene", ImVec2(60.f, 20.f)))
		{
			ImGui::OpenPopup("ScenePopup");
		}

		SHOW_TIPS("Scene");

		ImGui::SameLine();

		if (ImGui::Button(ICON_FA_CAMERA, ImVec2(20.f, 20.f)))
		{
			ImGui::OpenPopup("CameraPopup");
		}

		SHOW_TIPS("Camera");

		ImGui::SameLine();

		if (ImGui::Button(ICON_FA_SAVE, ImVec2(20.f, 20.f)))
		{
			auto *present_texture = p_editor->GetRenderer()->GetPresentTexture();
			auto *rhi_context     = p_editor->GetRHIContext();
			 char *path            = nullptr;

			if (present_texture && NFD_SaveDialog("png", Path::GetInstance().GetCurrent(false).c_str(), &path) == NFD_OKAY)
			{
				auto  staging_texture = rhi_context->CreateTexture2D(present_texture->GetDesc().width, present_texture->GetDesc().height, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::Transfer, false);
				auto  staging_buffer  = rhi_context->CreateBuffer(GetFormatStride(staging_texture->GetDesc().format) * staging_texture->GetDesc().width * staging_texture->GetDesc().height, RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_TO_CPU);
				auto *cmd_buffer      = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
				cmd_buffer->Begin();
				cmd_buffer->ResourceStateTransition(
				    {TextureStateTransition{present_texture, RHIResourceState::ShaderResource, RHIResourceState::TransferSource},
				     TextureStateTransition{staging_texture.get(), RHIResourceState::Undefined, RHIResourceState::TransferDest}},
				    {});
				cmd_buffer->BlitTexture(present_texture, {}, RHIResourceState::TransferSource, staging_texture.get(), {}, RHIResourceState::TransferDest);
				cmd_buffer->ResourceStateTransition(
				    {TextureStateTransition{staging_texture.get(), RHIResourceState::TransferDest, RHIResourceState::TransferSource}},
				    {});
				cmd_buffer->CopyTextureToBuffer(staging_texture.get(), staging_buffer.get(), 0, 0, 1);
				cmd_buffer->ResourceStateTransition(
				    {TextureStateTransition{present_texture, RHIResourceState::TransferSource, RHIResourceState::ShaderResource}}, {});
				cmd_buffer->End();
				rhi_context->Execute(cmd_buffer);

				std::vector<uint8_t> staging_data(staging_buffer->GetDesc().size);
				staging_buffer->CopyToHost(staging_data.data(), staging_buffer->GetDesc().size);


				stbi_write_png(
				    (Path::GetInstance().GetFileName(path, false) + ".png").c_str(),
				    static_cast<int32_t>(staging_texture->GetDesc().width),
				    static_cast<int32_t>(staging_texture->GetDesc().height),
				    4, staging_data.data(), static_cast<int32_t>(staging_texture->GetDesc().width) * 4);
			}
		}

		SHOW_TIPS("Save");

		ImGui::SameLine();

		if (ImGui::Button(m_play_animation ? ICON_FA_PAUSE : ICON_FA_PLAY, ImVec2(20.f, 20.f)))
		{
			m_play_animation = !m_play_animation;
		}

		if (m_play_animation)
		{
			m_animation_time += ImGui::GetIO().DeltaTime * 0.5f;
			if (m_animation_time > p_editor->GetRenderer()->GetMaxAnimationTime())
			{
				m_animation_time = 0.f;
			}
		}

		ImGui::SameLine();

		ImGui::PushItemWidth(200.f);
		if (ImGui::SliderFloat("Animation Time", &m_animation_time, 0.f, p_editor->GetRenderer()->GetMaxAnimationTime()) || m_play_animation)
		{
			p_editor->GetRenderer()->SetAnimationTime(m_animation_time);
		}
		ImGui::PopItemWidth();

		SHOW_TIPS("Play Animation");

		if (ImGui::BeginPopup("CameraPopup"))
		{
			auto perspective_cameras  = p_editor->GetRenderer()->GetScene()->GetComponents<Cmpt::PerspectiveCamera>();
			auto orthographic_cameras = p_editor->GetRenderer()->GetScene()->GetComponents<Cmpt::OrthographicCamera>();

			ImGui::PushItemWidth(80.f);
			ImGui::Text("Camera Properties");
			if ((!perspective_cameras.empty() || !orthographic_cameras.empty()) && ImGui::BeginMenu("Main Camera"))
			{
				for (auto &perspective_camera : perspective_cameras)
				{
					bool selected = perspective_camera == p_editor->GetMainCamera();
					if (ImGui::MenuItem(perspective_camera->GetNode()->GetName().c_str(), nullptr, &selected))
					{
						p_editor->SetMainCamera(perspective_camera);
					}
				}
				for (auto &orthographic_camera : orthographic_cameras)
				{
					bool selected = orthographic_camera == p_editor->GetMainCamera();
					if (ImGui::MenuItem(orthographic_camera->GetNode()->GetName().c_str(), nullptr, &selected))
					{
						p_editor->SetMainCamera(orthographic_camera);
					}
				}
				ImGui::EndMenu();
			}
			ImGui::DragFloat("Speed", &m_camera_config.speed, 0.01f, 0.f, std::numeric_limits<float>::max());
			ImGui::DragFloat("Sensitity", &m_camera_config.sensitity, 0.01f, 0.f, std::numeric_limits<float>::max());
			ImGui::PopItemWidth();
			ImGui::EndPopup();
		}

		if (ImGui::BeginPopup("ScenePopup"))
		{
			auto *manager = p_editor->GetRenderer()->GetResourceManager();
			auto *scene   = p_editor->GetRenderer()->GetScene();

			ImGui::PushItemWidth(80.f);
			char buf[128] = {0};
			std::memcpy(buf, m_scene_name.data(), sizeof(buf));
			if (ImGui::InputText("##NewScene", buf, sizeof(buf)))
			{
				m_scene_name = buf;
			}

			auto *resource = manager->Get<ResourceType::Scene>(m_scene_name);

			if (!m_scene_name.empty() && !resource)
			{
				if (ImGui::Button("New Scene"))
				{
					manager->Add<ResourceType::Scene>(p_editor->GetRHIContext(), m_scene_name, scene);
					resource = manager->Get<ResourceType::Scene>(m_scene_name);
				}
			}
			else
			{
				if (ImGui::Button("Save Scene"))
				{
					resource->Save(p_editor->GetRHIContext(), scene);
				}
			}

			ImGui::PopItemWidth();
			ImGui::EndPopup();
		}

		ImGui::PopStyleVar();
		ImGui::PopStyleVar();
		ImGui::PopStyleVar();
		ImGui::PopStyleColor();

		ImGui::Unindent();
	}

	void UpdateAnimation()
	{
		if (m_play_animation)
		{
			m_animation_time += ImGui::GetIO().DeltaTime;

			auto *resource_manager = p_editor->GetRenderer()->GetResourceManager();
			auto  animation_names  = resource_manager->GetResources<ResourceType::Animation>();
			for (auto &animation_name : animation_names)
			{
				auto *animation = resource_manager->Get<ResourceType::Animation>(animation_name);
			}
		}
	}

  private:
	std::map<std::string, std::unique_ptr<RHITexture>> m_icons;

	std::string m_scene_name = "";

	float m_animation_time = 0.f;
	bool  m_play_animation = false;
};

extern "C"
{
	EXPORT_API SceneView *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		return new SceneView(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/ShaderToy.cpp
================================================
#include <Editor/Editor.hpp>
#include <Editor/Widget.hpp>
#include <Renderer/Renderer.hpp>

#include <imgui.h>
#include <imgui_internal.h>

using namespace Ilum;

class ShaderToy : public Widget
{
  public:
	ShaderToy(Editor *editor) :
	    Widget("Shader Toy", editor)
	{
	}

	virtual ~ShaderToy() override = default;

	virtual void Tick() override
	{
		if (!ImGui::Begin(m_name.c_str(), nullptr, ImGuiWindowFlags_MenuBar))
		{
			ImGui::End();
			return;
		}

		if (ImGui::BeginMenuBar())
		{
			if (ImGui::MenuItem("Load"))
			{

			}

			ImGui::EndMenuBar();
		}


		ImGui::End();
	}
};

extern "C"
{
	EXPORT_API ShaderToy *Create(Editor *editor, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);
		return new ShaderToy(editor);
	}
}

================================================
FILE: Source/Plugin/Editor/xmake.lua
================================================
function add_editor_plugin(name, deps, pkgs)
    target(string.format("Editor.%s", name))

    set_kind("shared")
    set_group("Plugin/Editor")

    add_rules("plugin")
    add_files(string.format("%s.cpp", name))
    add_deps("Core", "RHI", "Renderer", "Editor", deps)
    add_packages("imgui", pkgs)

    target("Plugin")
        add_deps(string.format("Editor.%s", name))
    target_end()

    target_end()
end

add_editor_plugin("SceneView", {"Resource", "Scene", "RenderGraph"}, {"stb", "nativefiledialog"})
add_editor_plugin("Hierarchy", {"Scene"}, {})
add_editor_plugin("Inspector", {"Scene", "RenderGraph"}, {})
add_editor_plugin("MainMenu", {"Scene"}, {"nativefiledialog"})
add_editor_plugin("MeshEditor", {"Resource", "Geometry"}, {})
add_editor_plugin("AnimationEditor", {"Resource", "Geometry"}, {"nativefiledialog"})
add_editor_plugin("ResourceBrowser", {"Resource"}, {"nativefiledialog"})
add_editor_plugin("RenderGraphEditor", {"Resource", "RenderGraph"}, {"nativefiledialog"})
add_editor_plugin("MaterialGraphEditor", {"Resource", "Material", "Geometry", "RenderGraph"}, {"nativefiledialog"})


================================================
FILE: Source/Plugin/Geometry/Parameterization/MinimumSurface.cpp
================================================


================================================
FILE: Source/Plugin/Geometry/Parameterization/Tutte.cpp
================================================


================================================
FILE: Source/Plugin/Geometry/Subdivision/Loop.cpp
================================================
#include <Geometry/MeshProcess.hpp>

using namespace Ilum;

class LoopSubdivision : public Subdivision
{
  public:
	virtual TriMesh Execute(const TriMesh &mesh) override
	{
		std::vector<VertexData> vertices = mesh.vertices;
		std::vector<uint32_t>   indices  = mesh.indices;

		uint32_t old_vertices_count = static_cast<uint32_t>(vertices.size());
		uint32_t old_triangle_count = static_cast<uint32_t>(indices.size() / 3);

		std::map<uint32_t, std::unordered_set<uint32_t>>                      vertex_connect_map;
		std::map<uint32_t, std::vector<uint32_t>>                             triangle_connect_map;
		std::unordered_map<std::pair<uint32_t, uint32_t>, uint32_t, PairHash> new_vertex_map;

		for (uint32_t i = 0; i < indices.size(); i += 3)
		{
			for (uint32_t j = 0; j < 3; j++)
			{
				// Adding vertex connection
				vertex_connect_map[indices[i + j]].insert(indices[i + (j + 1) % 3]);
				vertex_connect_map[indices[i + (j + 1) % 3]].insert(indices[i + j]);

				// Add triangle connection
				triangle_connect_map[indices[i + j]].push_back(i / 3);

				// Adding new vertices
				uint32_t nv = 0;
				if (new_vertex_map.find(std::make_pair(indices[i + j], indices[i + (j + 1) % 3])) == new_vertex_map.end())
				{
					VertexData v;
					v.position = (vertices[indices[i + j]].position + vertices[indices[i + (j + 1) % 3]].position) * 0.5f;
					v.uv       = (vertices[indices[i + j]].uv + vertices[indices[i + (j + 1) % 3]].uv) * 0.5f;
					vertices.push_back(v);

					new_vertex_map[std::make_pair(indices[i + j], indices[i + (j + 1) % 3])] = static_cast<uint32_t>(vertices.size() - 1);
					new_vertex_map[std::make_pair(indices[i + (j + 1) % 3], indices[i + j])] = static_cast<uint32_t>(vertices.size() - 1);

					nv = static_cast<uint32_t>(vertices.size() - 1);
				}
				else
				{
					nv = new_vertex_map[std::make_pair(indices[i + j], indices[i + (j + 1) % 3])];
				}

				vertex_connect_map[nv].insert(indices[i + j]);
				vertex_connect_map[nv].insert(indices[i + (j + 1) % 3]);
				triangle_connect_map[nv].push_back(i / 3);
			}
		}

		// Reconstruct mesh
		std::vector<uint32_t> new_indices;
		for (uint32_t i = 0; i < indices.size(); i += 3)
		{
			uint32_t v0 = indices[i];
			uint32_t v1 = indices[i + 1];
			uint32_t v2 = indices[i + 2];

			uint32_t nv0 = new_vertex_map[std::make_pair(v0, v1)];
			uint32_t nv1 = new_vertex_map[std::make_pair(v1, v2)];
			uint32_t nv2 = new_vertex_map[std::make_pair(v2, v0)];

			std::vector<uint32_t> triangle_indices = {
			    v0, nv0, nv2,
			    nv0, v1, nv1,
			    nv2, nv1, v2,
			    nv1, nv2, nv0};

			new_indices.insert(new_indices.end(), triangle_indices.begin(), triangle_indices.end());
		}

		// auto boundary_points = find_boundary(vertices, new_indices);
		std::unordered_set<uint32_t> boundary_points;

		// Update new vertex position
		// 3/8 *(A+B)+1/8*(C+D)
		//				D
		//           /   \
		//         A-n-B
		//			 \    /
		//            C
		std::vector<VertexData> new_vertices(vertices.size());

		boundary_points.reserve(vertices.size());
		for (uint32_t i = old_vertices_count; i < vertices.size(); i++)
		{
			VertexData new_vertex = {};

			// Check boundary
			if (triangle_connect_map[i].size() == 1)
			{
				for (auto v : vertex_connect_map[i])
				{
					boundary_points.insert(v);
					new_vertex.position += 0.5f * vertices[v].position;
					new_vertex.uv += 0.5f * vertices[v].uv;
				}
			}
			else
			{
				for (auto t : triangle_connect_map[i])
				{
					for (uint32_t j = 0; j < 3; j++)
					{
						new_vertex.position += 0.125f * vertices[indices[3 * t + j]].position;
						new_vertex.uv += 0.125f * vertices[indices[3 * t + j]].uv;
					}
				}

				for (auto v : vertex_connect_map[i])
				{
					new_vertex.position += 0.125f * vertices[v].position;
					new_vertex.uv += 0.125f * vertices[v].uv;
				}
			}

			new_vertices[i] = new_vertex;
		}

		// Update old vertex position
		for (uint32_t i = 0; i < old_vertices_count; i++)
		{
			VertexData new_v = {};

			if (boundary_points.find(i) == boundary_points.end())
			{
				uint32_t degree = static_cast<uint32_t>(vertex_connect_map[i].size());
				float    u      = 0.f;
				if (degree == 3)
				{
					u = 3.f / 16.f;
				}
				else
				{
					u = 3.f / (8.f * static_cast<float>(degree));
				}

				for (auto v : vertex_connect_map[i])
				{
					new_v.position += u * vertices[v].position;
					new_v.uv += u * vertices[v].uv;
				}
				new_v.position += (1 - static_cast<float>(degree) * u) * vertices[i].position;
				new_v.uv += (1 - static_cast<float>(degree) * u) * vertices[i].uv;
			}
			else
			{
				new_v.position = vertices[i].position;
				new_v.uv       = vertices[i].uv;
			}

			new_vertices[i] = new_v;
		}

		TriMesh result;
		result.vertices = std::move(new_vertices);
		result.indices  = std::move(new_indices);
		result.GenerateNormal();
		return result;
	}
};

extern "C"
{
	EXPORT_API LoopSubdivision *Create()
	{
		return new LoopSubdivision;
	}
}

================================================
FILE: Source/Plugin/Geometry/xmake.lua
================================================
function add_geometry_plugin(category, name)
    target(string.format("Geometry.%s.%s", category, name))

    set_kind("shared")
    set_group("Plugin/Geometry")

    add_rules("plugin")
    add_files(string.format("%s/%s.cpp", category, name))
    add_deps("Core", "Geometry")

    target("Plugin")
        add_deps(string.format("Geometry.%s.%s", category, name))
    target_end()

    target_end()
end

add_geometry_plugin("Subdivision", "Loop")

================================================
FILE: Source/Plugin/Importer/Assimp.cpp
================================================
#include <Resource/Importer.hpp>
#include <Resource/Resource/Animation.hpp>
#include <Resource/Resource/Material.hpp>
#include <Resource/Resource/Mesh.hpp>
#include <Resource/Resource/Prefab.hpp>
#include <Resource/Resource/SkinnedMesh.hpp>
#include <Resource/Resource/Texture2D.hpp>
#include <Resource/ResourceManager.hpp>

#include <Material/MaterialGraph.hpp>

#include <Geometry/Meshlet.hpp>

#include <assimp/DefaultLogger.hpp>
#include <assimp/Importer.hpp>
#include <assimp/material.h>
#include <assimp/postprocess.h>
#include <assimp/scene.h>

#include <meshoptimizer.h>

#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>

#include <stb_image.h>

using namespace Ilum;

using Vertex        = Resource<ResourceType::Mesh>::Vertex;
using SkinnedVertex = Resource<ResourceType::SkinnedMesh>::SkinnedVertex;
using Node          = Resource<ResourceType::Prefab>::Node;

inline glm::mat4 ToMatrix(const aiMatrix4x4 &matrix)
{
	return glm::mat4(
	    matrix.a1, matrix.b1, matrix.c1, matrix.d1,
	    matrix.a2, matrix.b2, matrix.c2, matrix.d2,
	    matrix.a3, matrix.b3, matrix.c3, matrix.d3,
	    matrix.a4, matrix.b4, matrix.c4, matrix.d4);
}

inline glm::mat3 ToMatrix(const aiMatrix3x3 &matrix)
{
	return glm::mat3(
	    matrix.a1, matrix.b1, matrix.c1,
	    matrix.a2, matrix.b2, matrix.c2,
	    matrix.a3, matrix.b3, matrix.c3);
}

inline glm::vec2 ToVector(const aiVector2D &vec)
{
	return glm::vec2(vec.x, vec.y);
}

inline glm::vec3 ToVector(const aiVector3D &vec)
{
	return glm::vec3(vec.x, vec.y, vec.z);
}

inline glm::vec3 ToVector(const aiColor3D &color)
{
	return glm::vec3(color.r, color.g, color.b);
}

inline glm::vec4 ToVector(const aiColor4D &color)
{
	return glm::vec4(color.r, color.g, color.b, color.a);
}

inline glm::quat ToQuaternion(const aiQuaternion &quat)
{
	return glm::quat(quat.w, quat.x, quat.y, quat.z);
}

class AssimpImporter : public Importer<ResourceType::Prefab>
{
  public:
	struct BoneInfo
	{
		uint32_t  id;
		glm::mat4 offset;
	};

	struct ModelInfo
	{
		std::map<std::string, BoneInfo> bones;

		std::vector<std::string> animations;

		Node root;

		std::map<std::string, std::unordered_set<uint32_t>> skinned_mesh_bones;
	};

	struct MeshletInfo
	{
		std::vector<Meshlet>  meshlets;
		std::vector<uint32_t> meshletdata;
	};

	void ProcessAnimation(ResourceManager *manager, RHIContext *rhi_context, const std::string &path, uint32_t animation_id, const aiScene *assimp_scene, ModelInfo &data)
	{
		std::vector<Bone> bones;

		std::string animation_name   = fmt::format("{}.animation.{}", Path::GetInstance().ValidFileName(path), animation_id);
		const auto *assimp_animation = assimp_scene->mAnimations[animation_id];

		for (uint32_t j = 0; j < assimp_animation->mNumChannels; j++)
		{
			auto        channel   = assimp_animation->mChannels[j];
			std::string bone_name = channel->mNodeName.data;
			if (data.bones.find(bone_name) == data.bones.end())
			{
				data.bones[bone_name].id = static_cast<uint32_t>(data.bones.size());
			}

			// Parsing bone key frame data
			uint32_t bone_id = data.bones[bone_name].id;

			std::vector<Bone::KeyPosition> key_positions;
			std::vector<Bone::KeyRotation> key_rotations;
			std::vector<Bone::KeyScale>    key_scales;

			for (uint32_t position_idx = 0; position_idx < channel->mNumPositionKeys; position_idx++)
			{
				Bone::KeyPosition data = {};

				data.position   = ToVector(channel->mPositionKeys[position_idx].mValue);
				data.time_stamp = static_cast<float>(channel->mPositionKeys[position_idx].mTime / assimp_animation->mTicksPerSecond);
				key_positions.push_back(data);
			}

			for (uint32_t rotation_idx = 0; rotation_idx < channel->mNumRotationKeys; rotation_idx++)
			{
				Bone::KeyRotation data = {};

				data.orientation = ToQuaternion(channel->mRotationKeys[rotation_idx].mValue);
				data.time_stamp  = static_cast<float>(channel->mRotationKeys[rotation_idx].mTime / assimp_animation->mTicksPerSecond);
				key_rotations.push_back(data);
			}

			for (uint32_t scale_idx = 0; scale_idx < channel->mNumScalingKeys; scale_idx++)
			{
				Bone::KeyScale data = {};

				data.scale      = ToVector(channel->mScalingKeys[scale_idx].mValue);
				data.time_stamp = static_cast<float>(channel->mScalingKeys[scale_idx].mTime / assimp_animation->mTicksPerSecond);
				key_scales.push_back(data);
			}

			bones.emplace_back(bone_name, bone_id, data.bones.at(bone_name).offset, std::move(key_positions), std::move(key_rotations), std::move(key_scales));
		}

		if (bones.size() < data.bones.size())
		{
			for (auto &[name, bone] : data.bones)
			{
				bool found = false;
				for (auto &anim_bone : bones)
				{
					if (anim_bone.GetBoneName() == name)
					{
						found = true;
						break;
					}
				}
				if (!found)
				{
					bones.emplace_back(name, bone.id, data.bones.at(name).offset, std::vector<Bone::KeyPosition>{}, std::vector<Bone::KeyRotation>{}, std::vector<Bone::KeyScale>{});
				}
			}
		}

		std::function<void(HierarchyNode &, Node &)> build_skeleton =
		    [&](HierarchyNode &hierarchy, Node &node) {
			    uint32_t skinned_mesh_count = 0;
			    uint32_t animation_count    = 0;

			    std::vector<std::pair<ResourceType, std::string>> animations;
			    for (auto &[type, uuid] : node.resources)
			    {
				    if (type == ResourceType::SkinnedMesh)
				    {
					    skinned_mesh_count++;
					    if (skinned_mesh_count > animation_count)
					    {
						    for (auto &bone : bones)
						    {
							    if (data.skinned_mesh_bones[uuid].find(bone.GetBoneID()) != data.skinned_mesh_bones[uuid].end())
							    {
								    animations.push_back(std::make_pair(ResourceType::Animation, animation_name));
								    animation_count++;
								    break;
							    }
						    }
					    }
				    }
			    }
			    node.resources.insert(node.resources.end(), animations.begin(), animations.end());

			    hierarchy.name      = node.name;
			    hierarchy.transform = node.transform;
			    for (auto &child : node.children)
			    {
				    HierarchyNode node;
				    build_skeleton(node, child);
				    hierarchy.children.push_back(node);
			    }
		    };

		HierarchyNode hierarchy;
		build_skeleton(hierarchy, data.root);

		data.animations.push_back(animation_name);
		manager->Add<ResourceType::Animation>(rhi_context, animation_name, std::move(bones), std::move(hierarchy));
	}

	template <typename T>
	MeshletInfo ProcessMeshlet(std::vector<T> &vertices, std::vector<uint32_t> &indices)
	{
		MeshletInfo meshlet_info;

		const size_t max_vertices  = 64;
		const size_t max_triangles = 124;
		const float  cone_weight   = 0.5f;

		std::vector<meshopt_Meshlet> meshlets(meshopt_buildMeshletsBound(indices.size(), max_vertices, max_triangles));

		std::vector<uint32_t> meshlet_vertices(meshlets.size() * max_vertices);
		std::vector<uint8_t>  meshlet_triangles(meshlets.size() * max_triangles * 3);

		meshlets.resize(meshopt_buildMeshlets(meshlets.data(), meshlet_vertices.data(), meshlet_triangles.data(), indices.data(), indices.size(), &vertices[0].position.x, vertices.size(), sizeof(T), max_vertices, max_triangles, cone_weight));

		std::unordered_map<size_t, uint32_t> primitive_map;
		for (size_t i = 0; i < indices.size() / 3; i++)
		{
			size_t hash         = Hash(indices[3 * i], indices[3 * i + 1], indices[3 * i + 2]);
			primitive_map[hash] = static_cast<uint32_t>(i);
		}

		for (auto &meshlet : meshlets)
		{
			size_t data_offset = meshlet_info.meshletdata.size();

			for (uint32_t i = 0; i < meshlet.vertex_count; i++)
			{
				meshlet_info.meshletdata.push_back(meshlet_vertices[meshlet.vertex_offset + i]);
			}

			const uint8_t *index_group = &meshlet_triangles[0] + meshlet.triangle_offset;

			for (uint32_t i = 0; i < meshlet.triangle_count; i++)
			{
				size_t hash = Hash(meshlet_vertices[(uint32_t) index_group[3 * i] + meshlet.vertex_offset], meshlet_vertices[(uint32_t) index_group[3 * i + 1] + meshlet.vertex_offset], meshlet_vertices[(uint32_t) index_group[3 * i + 2] + meshlet.vertex_offset]);
				meshlet_info.meshletdata.push_back(primitive_map.at(hash));
			}

			for (uint32_t i = 0; i < meshlet.triangle_count; i++)
			{
				uint32_t triangle = 0;
				triangle += (uint32_t) index_group[3 * i];
				triangle += (uint32_t) index_group[3 * i + 1] << 8;
				triangle += (uint32_t) index_group[3 * i + 2] << 16;
				meshlet_info.meshletdata.push_back(triangle);
			}

			meshopt_Bounds bounds = meshopt_computeMeshletBounds(&meshlet_vertices[meshlet.vertex_offset], &meshlet_triangles[meshlet.triangle_offset], meshlet.triangle_count, &vertices[0].position.x, vertices.size(), sizeof(T));

			Meshlet tmp_meshlet = {};

			tmp_meshlet.data_offset    = uint32_t(data_offset);
			tmp_meshlet.triangle_count = meshlet.triangle_count;
			tmp_meshlet.vertex_count   = meshlet.vertex_count;
			tmp_meshlet.vertex_offset  = meshlet.vertex_offset;
			tmp_meshlet.center         = glm::vec3(bounds.center[0], bounds.center[1], bounds.center[2]);
			tmp_meshlet.radius         = bounds.radius;
			tmp_meshlet.cone_cutoff    = bounds.cone_cutoff;

			std::memcpy(&tmp_meshlet.cone_axis, bounds.cone_axis, sizeof(glm::vec3));
			std::memcpy(&tmp_meshlet.cone_apex, bounds.cone_apex, sizeof(glm::vec3));

			meshlet_info.meshlets.push_back(tmp_meshlet);
		}

		return meshlet_info;
	}

	void ProcessMesh(ResourceManager *manager, RHIContext *rhi_context, const std::string &path, uint32_t mesh_id, const aiScene *assimp_scene, ModelInfo &data)
	{
		std::string mesh_name   = fmt::format("{}.mesh.{}", Path::GetInstance().ValidFileName(path), mesh_id);
		aiMesh     *assimp_mesh = assimp_scene->mMeshes[mesh_id];

		if (manager->Has<ResourceType::Mesh>(mesh_name))
		{
			return;
		}

		std::vector<Vertex>   vertices;
		std::vector<uint32_t> indices;

		// Parsing vertices
		for (uint32_t j = 0; j < assimp_mesh->mNumVertices; j++)
		{
			Vertex vertex    = {};
			vertex.position  = glm::vec3(assimp_mesh->mVertices[j].x, assimp_mesh->mVertices[j].y, assimp_mesh->mVertices[j].z);
			vertex.normal    = assimp_mesh->mNormals ? glm::vec3(assimp_mesh->mNormals[j].x, assimp_mesh->mNormals[j].y, assimp_mesh->mNormals[j].z) : glm::vec3(0.f);
			vertex.tangent   = assimp_mesh->mTangents ? glm::vec3(assimp_mesh->mTangents[j].x, assimp_mesh->mTangents[j].y, assimp_mesh->mTangents[j].z) : glm::vec3(0.f);
			vertex.texcoord0 = assimp_mesh->mTextureCoords[0] ? glm::vec2(assimp_mesh->mTextureCoords[0][j].x, assimp_mesh->mTextureCoords[0][j].y) : glm::vec2(0.f);
			vertex.texcoord1 = assimp_mesh->mTextureCoords[1] ? glm::vec2(assimp_mesh->mTextureCoords[1][j].x, assimp_mesh->mTextureCoords[1][j].y) : glm::vec2(0.f);
			vertices.emplace_back(std::move(vertex));
		}

		// Parsing indices
		for (uint32_t j = 0; j < assimp_mesh->mNumFaces; j++)
		{
			for (uint32_t k = 0; k < 3; k++)
			{
				indices.push_back(assimp_mesh->mFaces[j].mIndices[k]);
			}
		}

		MeshletInfo meshlet_info = ProcessMeshlet(vertices, indices);
		manager->Add<ResourceType::Mesh>(rhi_context, mesh_name, std::move(vertices), std::move(indices), std::move(meshlet_info.meshlets), std::move(meshlet_info.meshletdata));
	}

	void ProcessSkinnedMesh(ResourceManager *manager, RHIContext *rhi_context, const std::string &path, uint32_t mesh_id, const aiScene *assimp_scene, ModelInfo &data)
	{
		std::string mesh_name   = fmt::format("{}.mesh.{}", Path::GetInstance().ValidFileName(path), mesh_id);
		aiMesh     *assimp_mesh = assimp_scene->mMeshes[mesh_id];

		if (manager->Has<ResourceType::SkinnedMesh>(mesh_name))
		{
			return;
		}

		std::vector<SkinnedVertex>   vertices;
		std::vector<uint32_t>        indices;
		std::unordered_set<uint32_t> bones;

		// Parsing vertices
		for (uint32_t j = 0; j < assimp_mesh->mNumVertices; j++)
		{
			SkinnedVertex vertex = {};
			vertex.position      = glm::vec3(assimp_mesh->mVertices[j].x, assimp_mesh->mVertices[j].y, assimp_mesh->mVertices[j].z);
			vertex.normal        = glm::vec3(assimp_mesh->mNormals[j].x, assimp_mesh->mNormals[j].y, assimp_mesh->mNormals[j].z);
			vertex.tangent       = assimp_mesh->mTangents ? glm::vec3(assimp_mesh->mTangents[j].x, assimp_mesh->mTangents[j].y, assimp_mesh->mTangents[j].z) : glm::vec3(0.f);
			vertex.texcoord0     = assimp_mesh->mTextureCoords[0] ? glm::vec2(assimp_mesh->mTextureCoords[0][j].x, assimp_mesh->mTextureCoords[0][j].y) : glm::vec2(0.f);
			vertex.texcoord1     = assimp_mesh->mTextureCoords[1] ? glm::vec2(assimp_mesh->mTextureCoords[1][j].x, assimp_mesh->mTextureCoords[1][j].y) : glm::vec2(0.f);
			vertices.emplace_back(std::move(vertex));
		}

		// Parsing indices
		for (uint32_t j = 0; j < assimp_mesh->mNumFaces; j++)
		{
			for (uint32_t k = 0; k < 3; k++)
			{
				indices.push_back(assimp_mesh->mFaces[j].mIndices[k]);
			}
		}

		// Parsing bones
		for (uint32_t bone_index = 0; bone_index < assimp_mesh->mNumBones; bone_index++)
		{
			int32_t     bone_id   = -1;
			std::string bone_name = assimp_mesh->mBones[bone_index]->mName.C_Str();

			if (data.bones.find(bone_name) == data.bones.end())
			{
				BoneInfo bone = {};
				bone.id       = static_cast<uint32_t>(data.bones.size());
				bone.offset   = ToMatrix(assimp_mesh->mBones[bone_index]->mOffsetMatrix);

				data.bones[bone_name] = bone;

				bone_id = bone.id;
			}
			else
			{
				bone_id = data.bones.at(bone_name).id;
			}

			bones.insert(bone_id);

			data.bones[bone_name] = data.bones.at(bone_name);

			auto     weights    = assimp_mesh->mBones[bone_index]->mWeights;
			uint32_t weight_num = assimp_mesh->mBones[bone_index]->mNumWeights;

			for (uint32_t weight_index = 0; weight_index < weight_num; weight_index++)
			{
				int32_t vertex_id = weights[weight_index].mVertexId;
				float   weight    = weights[weight_index].mWeight;

				for (int i = 0; i < MAX_BONE_INFLUENCE; ++i)
				{
					if (vertices[vertex_id].bones[i] < 0 && weight > 0.f)
					{
						vertices[vertex_id].weights[i] = weight;
						vertices[vertex_id].bones[i]   = bone_id;
						break;
					}
				}
			}
		}

		MeshletInfo meshlet_info = ProcessMeshlet(vertices, indices);

		data.skinned_mesh_bones[mesh_name] = bones;

		manager->Add<ResourceType::SkinnedMesh>(rhi_context, mesh_name, std::move(vertices), std::move(indices), std::move(meshlet_info.meshlets), std::move(meshlet_info.meshletdata));
	}

	Node ProcessNode(ResourceManager *manager, RHIContext *rhi_context, const std::string &path, const aiScene *assimp_scene, aiNode *assimp_node, ModelInfo &data, aiMatrix4x4 transform = aiMatrix4x4())
	{
		Node node = {};

		node.transform = ToMatrix(assimp_node->mTransformation);
		node.name      = assimp_node->mName.C_Str();

		for (uint32_t i = 0; i < assimp_node->mNumMeshes; i++)
		{
			aiMesh     *assimp_mesh   = assimp_scene->mMeshes[assimp_node->mMeshes[i]];
			std::string mesh_name     = fmt::format("{}.mesh.{}", Path::GetInstance().ValidFileName(path), assimp_node->mMeshes[i]);
			std::string material_name = fmt::format("{}.material.{}", Path::GetInstance().ValidFileName(path), assimp_mesh->mMaterialIndex);

			if (assimp_mesh->HasBones())
			{
				node.resources.emplace_back(std::make_pair(ResourceType::SkinnedMesh, mesh_name));
			}
			else
			{
				node.resources.emplace_back(std::make_pair(ResourceType::Mesh, mesh_name));
			}

			node.resources.emplace_back(std::make_pair(ResourceType::Material, material_name));
		}

		for (uint32_t i = 0; i < assimp_node->mNumChildren; i++)
		{
			Node child = ProcessNode(manager, rhi_context, path, assimp_scene, assimp_node->mChildren[i], data, transform);
			node.children.emplace_back(std::move(child));
		}

		return node;
	}

	void ProcessMaterial(ResourceManager *manager, RHIContext *rhi_context, const std::string &path, uint32_t material_id, const aiScene *assimp_scene)
	{
		std::string material_name = fmt::format("{}.material.{}", Path::GetInstance().ValidFileName(path), material_id);

		if (manager->Has<ResourceType::Material>(material_name))
		{
			return;
		}

		aiMaterial *assimp_material = assimp_scene->mMaterials[material_id];

		MaterialGraphDesc desc;
		desc.SetName(material_name);

		struct ImageConfig
		{
			SamplerDesc sampler;
			char        filename[200];
		};

		auto create_material_node = [](size_t &handle, const std::string &category, const std::string &name) {
			MaterialNodeDesc desc;
			PluginManager::GetInstance().Call(fmt::format("shared/Material/Material.{}.{}.dll", category, name), "Create", &desc, &handle);
			return desc;
		};

		size_t current_handle = 0;

		MaterialNodeDesc &principled_bsdf_node     = desc.AddNode(current_handle++, create_material_node(current_handle, "BSDF", "DisneyMaterial"));
		MaterialNodeDesc &output_node              = desc.AddNode(current_handle++, create_material_node(current_handle, "Output", "MaterialOutput"));
		MaterialNodeDesc *surface_interaction_node = nullptr;

		auto set_image_texture = [&](MaterialNodeDesc &texture_node, const std::string &name) {
			if (!surface_interaction_node)
			{
				surface_interaction_node = &desc.AddNode(current_handle++, create_material_node(current_handle, "Input", "SurfaceInteraction"));
			}
			Variant      variant  = texture_node.GetVariant();
			std::string  filename = Path::GetInstance().ValidFileName(name);
			ImageConfig *config   = variant.Convert<ImageConfig>();
			std::memset(config->filename, '\0', 200);
			std::memcpy(config->filename, filename.data(), filename.length());
			desc.Link(surface_interaction_node->GetPin("UV").handle, texture_node.GetPin("UV").handle);
			desc.Link(surface_interaction_node->GetPin("dUVdx").handle, texture_node.GetPin("dUVdx").handle);
			desc.Link(surface_interaction_node->GetPin("dUVdy").handle, texture_node.GetPin("dUVdy").handle);
		};

		desc.Link(principled_bsdf_node.GetPin("Out").handle, output_node.GetPin("Surface").handle);

		// Base Color
		{
			glm::vec3 base_color = glm::vec3(0.f);
			aiString  color_texture;

			assimp_material->Get(AI_MATKEY_BASE_COLOR, base_color.x);
			assimp_material->GetTexture(AI_MATKEY_BASE_COLOR_TEXTURE, &color_texture);

			std::string color_texture_name = ProcessTexture(manager, rhi_context, path, assimp_scene, color_texture.C_Str());
			if (!color_texture_name.empty())
			{
				MaterialNodeDesc &texture_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Texture", "ImageTexture"));
				set_image_texture(texture_node, color_texture_name);

				if (base_color != glm::vec3(1.f))
				{
					MaterialNodeDesc &multiply_node   = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "VectorCalculate"));
					multiply_node.GetPin("X").variant = base_color;
					multiply_node.SetVariant(7);
					desc.Link(texture_node.GetPin("Color").handle, multiply_node.GetPin("Y").handle);

					MaterialNodeDesc &srgb2linear_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "SRGBToLinear"));
					desc.Link(multiply_node.GetPin("Out").handle, srgb2linear_node.GetPin("In").handle);
					desc.Link(srgb2linear_node.GetPin("Out").handle, principled_bsdf_node.GetPin("BaseColor").handle);
				}
				else
				{
					MaterialNodeDesc &srgb2linear_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "SRGBToLinear"));
					desc.Link(texture_node.GetPin("Color").handle, srgb2linear_node.GetPin("In").handle);
					desc.Link(srgb2linear_node.GetPin("Out").handle, principled_bsdf_node.GetPin("BaseColor").handle);
				}
			}
			else
			{
				principled_bsdf_node.GetPin("BaseColor").variant = base_color;
			}
		}

		// Metallic & Roughness & Occlusion
		{
			float    metallic  = 0.f;
			float    roughness = 0.f;
			aiString metallic_texture;
			aiString roughness_texture;
			aiString occlusion_texture;

			assimp_material->Get(AI_MATKEY_METALLIC_FACTOR, metallic);
			assimp_material->GetTexture(AI_MATKEY_METALLIC_TEXTURE, &metallic_texture);
			assimp_material->Get(AI_MATKEY_ROUGHNESS_FACTOR, roughness);
			assimp_material->GetTexture(AI_MATKEY_ROUGHNESS_TEXTURE, &roughness_texture);
			assimp_material->GetTexture(aiTextureType_LIGHTMAP, 0, &occlusion_texture);

			bool pack_metallic_roughness = (metallic_texture == roughness_texture);
			bool pack_occlusion          = (occlusion_texture.length == 0 || metallic_texture == occlusion_texture);

			if (pack_metallic_roughness)
			{
				// Pack Texture: Occlusion (R) [optional] + Roughness G + Metallic B
				std::string texture_name = ProcessTexture(manager, rhi_context, path, assimp_scene, metallic_texture.C_Str());
				if (!texture_name.empty())
				{
					MaterialNodeDesc &texture_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Texture", "ImageTexture"));
					set_image_texture(texture_node, texture_name);

					MaterialNodeDesc &split_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "VectorSplit"));

					desc.Link(texture_node.GetPin("Color").handle, split_node.GetPin("In").handle);

					if (metallic == 1.f && roughness == 1.f)
					{
						// TODO : AO Map
						desc.Link(split_node.GetPin("Y").handle, principled_bsdf_node.GetPin("Roughness").handle);
						desc.Link(split_node.GetPin("Z").handle, principled_bsdf_node.GetPin("Metallic").handle);
					}
					else
					{
						MaterialNodeDesc &metallic_scale_node   = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "Calculate"));
						metallic_scale_node.GetPin("X").variant = metallic;
						metallic_scale_node.SetVariant(2);

						MaterialNodeDesc &roughness_scale_node   = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "Calculate"));
						roughness_scale_node.GetPin("X").variant = roughness;
						roughness_scale_node.SetVariant(2);

						desc.Link(split_node.GetPin("Y").handle, roughness_scale_node.GetPin("Y").handle);
						desc.Link(roughness_scale_node.GetPin("Out").handle, principled_bsdf_node.GetPin("Roughness").handle);

						desc.Link(split_node.GetPin("Z").handle, metallic_scale_node.GetPin("Y").handle);
						desc.Link(metallic_scale_node.GetPin("Out").handle, principled_bsdf_node.GetPin("Metallic").handle);
					}
				}
				else
				{
					principled_bsdf_node.GetPin("Metallic").variant = metallic;
					principled_bsdf_node.GetPin("Roughness").variant = roughness;
				}
			}
			else
			{
				// Separated Texture
				// Metallic
				std::string metallic_texture_name = ProcessTexture(manager, rhi_context, path, assimp_scene, metallic_texture.C_Str());
				if (!metallic_texture_name.empty())
				{
					MaterialNodeDesc &texture_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Texture", "ImageTexture"));
					set_image_texture(texture_node, metallic_texture_name);

					if (metallic == 1.f)
					{
						desc.Link(texture_node.GetPin("Color").handle, principled_bsdf_node.GetPin("Metallic").handle);
					}
					else
					{
						MaterialNodeDesc &scale_node   = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "Calculate"));
						scale_node.GetPin("X").variant = metallic;
						scale_node.SetVariant(2);
						desc.Link(texture_node.GetPin("Color").handle, scale_node.GetPin("Y").handle);
						desc.Link(scale_node.GetPin("Out").handle, principled_bsdf_node.GetPin("Metallic").handle);
					}
				}
				else
				{
					principled_bsdf_node.GetPin("Metallic").variant = metallic;
				}

				// Roughness
				std::string roughness_texture_name = ProcessTexture(manager, rhi_context, path, assimp_scene, roughness_texture.C_Str());
				if (!roughness_texture_name.empty())
				{
					MaterialNodeDesc &texture_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Texture", "ImageTexture"));
					set_image_texture(texture_node, roughness_texture_name);

					if (roughness == 1.f)
					{
						desc.Link(texture_node.GetPin("Color").handle, principled_bsdf_node.GetPin("Roughness").handle);
					}
					else
					{
						MaterialNodeDesc &scale_node   = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "Calculate"));
						scale_node.GetPin("X").variant = roughness;
						scale_node.SetVariant(2);
						desc.Link(texture_node.GetPin("Color").handle, scale_node.GetPin("Y").handle);
						desc.Link(scale_node.GetPin("Out").handle, principled_bsdf_node.GetPin("Roughness").handle);
					}
				}
				else
				{
					principled_bsdf_node.GetPin("Roughness").variant = roughness;
				}
			}

			if (!pack_occlusion)
			{
				// TODO: AO Map
			}
		}

		// Normal
		{
			aiString normal_texture;
			assimp_material->GetTexture(aiTextureType_NORMALS, 0, &normal_texture);

			std::string normal_texture_name = ProcessTexture(manager, rhi_context, path, assimp_scene, normal_texture.C_Str());
			if (!normal_texture_name.empty())
			{
				MaterialNodeDesc &texture_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Texture", "ImageTexture"));
				set_image_texture(texture_node, normal_texture_name);
				desc.Link(texture_node.GetPin("Color").handle, principled_bsdf_node.GetPin("Normal").handle);
			}
		}

		// Emissive
		{
			glm::vec3 emissive_color = glm::vec3(0.f);
			aiString  emissive_texture;

			assimp_material->Get(AI_MATKEY_COLOR_EMISSIVE, emissive_color.x);
			assimp_material->GetTexture(aiTextureType_EMISSIVE, 0, &emissive_texture);

			std::string emissive_texture_name = ProcessTexture(manager, rhi_context, path, assimp_scene, emissive_texture.C_Str());
			if (!emissive_texture_name.empty())
			{
				MaterialNodeDesc &texture_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Texture", "ImageTexture"));
				set_image_texture(texture_node, emissive_texture_name);

				if (emissive_color == glm::vec3(1.f))
				{
					MaterialNodeDesc &srgb2linear_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "SRGBToLinear"));
					desc.Link(texture_node.GetPin("Color").handle, srgb2linear_node.GetPin("In").handle);
					desc.Link(srgb2linear_node.GetPin("Out").handle, principled_bsdf_node.GetPin("Emissive").handle);
				}
				else
				{
					MaterialNodeDesc &multiply_node   = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "VectorCalculate"));
					multiply_node.GetPin("X").variant = emissive_color;
					multiply_node.SetVariant(7);
					desc.Link(texture_node.GetPin("Color").handle, multiply_node.GetPin("Y").handle);

					MaterialNodeDesc &srgb2linear_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "SRGBToLinear"));
					desc.Link(texture_node.GetPin("Color").handle, srgb2linear_node.GetPin("In").handle);
					desc.Link(srgb2linear_node.GetPin("Out").handle, principled_bsdf_node.GetPin("Emissive").handle);
				}
			}
			else
			{
				principled_bsdf_node.GetPin("Emissive").variant = emissive_color;
			}
		}

		// Anisotropic
		{
			float anisotropic = 0.f;
			assimp_material->Get(AI_MATKEY_ANISOTROPY_FACTOR, anisotropic);
			principled_bsdf_node.GetPin("Anisotropic").variant = anisotropic;
		}

		// Sheen
		{
			glm::vec3 sheen_color     = glm::vec3(0.f);
			float     sheen_roughness = 0.f;
			aiString  sheen_color_texture;
			aiString  sheen_roughness_texture;
			assimp_material->Get(AI_MATKEY_SHEEN_COLOR_FACTOR, sheen_color.x);
			assimp_material->Get(AI_MATKEY_SHEEN_ROUGHNESS_FACTOR, sheen_roughness);
			assimp_material->GetTexture(AI_MATKEY_SHEEN_COLOR_TEXTURE, &sheen_color_texture);
			assimp_material->GetTexture(AI_MATKEY_SHEEN_ROUGHNESS_TEXTURE, &sheen_roughness_texture);
			ProcessTexture(manager, rhi_context, path, assimp_scene, sheen_color_texture.C_Str());
			ProcessTexture(manager, rhi_context, path, assimp_scene, sheen_roughness_texture.C_Str());
		}

		// Clearcoat
		{
			float    clearcoat_factor    = 0.f;
			float    clearcoat_roughness = 0.f;
			aiString clearcoat_texture;
			aiString clearcoat_roughness_texture;
			aiString clearcoat_normal_texture;

			assimp_material->Get(AI_MATKEY_CLEARCOAT_FACTOR, clearcoat_factor);
			assimp_material->Get(AI_MATKEY_CLEARCOAT_FACTOR, clearcoat_roughness);
			assimp_material->GetTexture(AI_MATKEY_SHEEN_COLOR_TEXTURE, &clearcoat_texture);
			assimp_material->GetTexture(AI_MATKEY_SHEEN_COLOR_TEXTURE, &clearcoat_roughness_texture);
			assimp_material->GetTexture(AI_MATKEY_SHEEN_COLOR_TEXTURE, &clearcoat_normal_texture);
			ProcessTexture(manager, rhi_context, path, assimp_scene, clearcoat_texture.C_Str());
			ProcessTexture(manager, rhi_context, path, assimp_scene, clearcoat_roughness_texture.C_Str());
			ProcessTexture(manager, rhi_context, path, assimp_scene, clearcoat_normal_texture.C_Str());
		}

		// Transmission
		{
			float    transmission_factor = 0.f;
			aiString transmission_texture;
			assimp_material->Get(AI_MATKEY_TRANSMISSION_FACTOR, transmission_factor);
			assimp_material->GetTexture(AI_MATKEY_TRANSMISSION_TEXTURE, &transmission_texture);

			std::string transmission_texture_name = ProcessTexture(manager, rhi_context, path, assimp_scene, transmission_texture.C_Str());
			if (!transmission_texture_name.empty())
			{
				MaterialNodeDesc &texture_node = desc.AddNode(current_handle++, create_material_node(current_handle, "Texture", "ImageTexture"));
				set_image_texture(texture_node, transmission_texture_name);

				if (transmission_factor == 1.f)
				{
					desc.Link(texture_node.GetPin("Color").handle, principled_bsdf_node.GetPin("SpecTrans").handle);
				}
				else
				{
					MaterialNodeDesc &scale_node   = desc.AddNode(current_handle++, create_material_node(current_handle, "Converter", "Calculate"));
					scale_node.GetPin("X").variant = transmission_factor;
					scale_node.SetVariant(2);
					desc.Link(texture_node.GetPin("Color").handle, scale_node.GetPin("Y").handle);
					desc.Link(scale_node.GetPin("Out").handle, principled_bsdf_node.GetPin("SpecTrans").handle);
				}
			}
			else
			{
				principled_bsdf_node.GetPin("SpecTrans").variant = transmission_factor;
			}
		}

		// Volume
		{
		    // TODO
		}

		// Displacement
		{
			aiString displacement_texture;
			assimp_material->GetTexture(aiTextureType_DISPLACEMENT, 0, &displacement_texture);
			ProcessTexture(manager, rhi_context, path, assimp_scene, displacement_texture.C_Str());
		}

		manager->Add<ResourceType::Material>(rhi_context, material_name, std::move(desc));
	}

	std::string ProcessTexture(ResourceManager *manager, RHIContext *rhi_context, const std::string &path, const aiScene *assimp_scene, const std::string &filename)
	{
		auto [assimp_texture, texture_id] = assimp_scene->GetEmbeddedTextureAndIndex(filename.c_str());
		if (texture_id < 0 && filename.empty())
		{
			return "";
		}

		if (texture_id < 0)
		{
			// External texture
			auto &importer = Importer<ResourceType::Texture2D>::GetInstance("STB");
			if (importer)
			{
				std::string file_path = Path::GetInstance().GetFileDirectory(path) + filename;
				importer->Import(manager, file_path, rhi_context);
				return Path::GetInstance().ValidFileName(file_path);
			}
		}
		else
		{
			std::string texture_name = fmt::format("{}.texture.{}", Path::GetInstance().ValidFileName(path), texture_id);
			if (manager->Has<ResourceType::Texture2D>(texture_name))
			{
				return "";
			}

			TextureDesc desc = {};
			desc.name        = texture_name;
			desc.width       = 1;
			desc.height      = 1;
			desc.depth       = 1;
			desc.mips        = 1;
			desc.layers      = 1;
			desc.samples     = 1;

			void   *raw_data = nullptr;
			size_t  size     = 0;
			int32_t width = 0, height = 0, channel = 0;

			const int32_t req_channel = 4;

			stbi_uc *assimp_texture_data     = reinterpret_cast<stbi_uc *>(assimp_texture->pcData);
			int32_t  assimp_texture_data_len = static_cast<int32_t>(assimp_texture->mWidth * glm::max(1u, assimp_texture->mHeight) * 4);

			if (stbi_is_hdr_from_memory(assimp_texture_data, assimp_texture_data_len))
			{
				raw_data    = stbi_loadf_from_memory(assimp_texture_data, assimp_texture_data_len, &width, &height, &channel, req_channel);
				size        = static_cast<size_t>(width) * static_cast<size_t>(height) * static_cast<size_t>(req_channel) * sizeof(float);
				desc.format = RHIFormat::R32G32B32A32_FLOAT;
			}
			else if (stbi_is_16_bit_from_memory(assimp_texture_data, assimp_texture_data_len))
			{
				raw_data    = stbi_load_16_from_memory(assimp_texture_data, assimp_texture_data_len, &width, &height, &channel, req_channel);
				size        = static_cast<size_t>(width) * static_cast<size_t>(height) * static_cast<size_t>(req_channel) * sizeof(uint16_t);
				desc.format = RHIFormat::R16G16B16A16_FLOAT;
			}
			else
			{
				raw_data    = stbi_load_from_memory(assimp_texture_data, assimp_texture_data_len, &width, &height, &channel, req_channel);
				size        = static_cast<size_t>(width) * static_cast<size_t>(height) * static_cast<size_t>(req_channel) * sizeof(uint8_t);
				desc.format = RHIFormat::R8G8B8A8_UNORM;
			}

			desc.width  = static_cast<uint32_t>(width);
			desc.height = static_cast<uint32_t>(height);
			desc.mips   = static_cast<uint32_t>(std::floor(std::log2(std::max(width, height))) + 1);
			desc.usage  = RHITextureUsage::ShaderResource | RHITextureUsage::Transfer;

			std::vector<uint8_t> data;

			data.resize(size);
			std::memcpy(data.data(), raw_data, size);

			stbi_image_free(raw_data);

			manager->Add<ResourceType::Texture2D>(rhi_context, std::move(data), desc);

			return desc.name;
		}

		return "";
	}

  protected:
	virtual void Import_(ResourceManager *manager, const std::string &path, RHIContext *rhi_context) override
	{
		std::string prefab_name = Path::GetInstance().ValidFileName(path);

		Assimp::Importer importer;

		if (const aiScene *assimp_scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace))
		{
			ModelInfo data;

			for (uint32_t i = 0; i < assimp_scene->mNumMeshes; i++)
			{
				aiMesh *assimp_mesh = assimp_scene->mMeshes[i];
				if (assimp_mesh->HasBones())
				{
					ProcessSkinnedMesh(manager, rhi_context, path, i, assimp_scene, data);
				}
				else
				{
					ProcessMesh(manager, rhi_context, path, i, assimp_scene, data);
				}

				ProcessMaterial(manager, rhi_context, path, assimp_mesh->mMaterialIndex, assimp_scene);
			}

			aiMatrix4x4 identity;
			data.root = ProcessNode(manager, rhi_context, path, assimp_scene, assimp_scene->mRootNode, data, identity);

			for (uint32_t i = 0; i < assimp_scene->mNumAnimations; i++)
			{
				ProcessAnimation(manager, rhi_context, path, i, assimp_scene, data);
			}

			if (!manager->Has<ResourceType::Prefab>(prefab_name))
			{
				manager->Add<ResourceType::Prefab>(rhi_context, prefab_name, std::move(data.root));
			}
		}
	}
};

extern "C"
{
	EXPORT_API AssimpImporter *Create()
	{
		return new AssimpImporter;
	}
}

================================================
FILE: Source/Plugin/Importer/DDS.cpp
================================================
#include <RHI/RHITexture.hpp>
#include <Resource/Importer.hpp>
#include <Resource/Resource/Texture2D.hpp>
#include <Resource/ResourceManager.hpp>

#include <dxgiformat.h>

using namespace Ilum;

// reference: https://github.com/microsoft/DirectX-Graphics-Samples/blob/master/MiniEngine/Core/dds.h
const uint32_t DDS_MAGIC = 0x20534444;        // "DDS "

inline static std::unordered_map<DXGI_FORMAT, RHIFormat> FormatMap = {
    {DXGI_FORMAT_UNKNOWN, RHIFormat::Undefined},
    {DXGI_FORMAT_R8G8B8A8_UNORM, RHIFormat::R8G8B8A8_UNORM},
    {DXGI_FORMAT_R16_UINT, RHIFormat::R16_UINT},
    {DXGI_FORMAT_R16_SINT, RHIFormat::R16_SINT},
    {DXGI_FORMAT_R16_FLOAT, RHIFormat::R16_FLOAT},
    {DXGI_FORMAT_R16G16_UINT, RHIFormat::R16G16_UINT},
    {DXGI_FORMAT_R16G16_SINT, RHIFormat::R16G16_SINT},
    {DXGI_FORMAT_R16G16_FLOAT, RHIFormat::R16G16_FLOAT},
    {DXGI_FORMAT_R16G16B16A16_UINT, RHIFormat::R16G16B16A16_UINT},
    {DXGI_FORMAT_R16G16B16A16_SINT, RHIFormat::R16G16B16A16_SINT},
    {DXGI_FORMAT_R16G16B16A16_FLOAT, RHIFormat::R16G16B16A16_FLOAT},
    {DXGI_FORMAT_R10G10B10A2_UNORM, RHIFormat::R10G10B10A2_UNORM},
    {DXGI_FORMAT_R10G10B10A2_UINT, RHIFormat::R10G10B10A2_UINT},
    {DXGI_FORMAT_R11G11B10_FLOAT, RHIFormat::R11G11B10_FLOAT},
    {DXGI_FORMAT_R32_UINT, RHIFormat::R32_UINT},
    {DXGI_FORMAT_R32_SINT, RHIFormat::R32_SINT},
    {DXGI_FORMAT_R32_FLOAT, RHIFormat::R32_FLOAT},
    {DXGI_FORMAT_R32G32_UINT, RHIFormat::R32G32_UINT},
    {DXGI_FORMAT_R32G32_SINT, RHIFormat::R32G32_SINT},
    {DXGI_FORMAT_R32G32_FLOAT, RHIFormat::R32G32_FLOAT},
    {DXGI_FORMAT_R32G32B32_UINT, RHIFormat::R32G32B32_UINT},
    {DXGI_FORMAT_R32G32B32_SINT, RHIFormat::R32G32B32_SINT},
    {DXGI_FORMAT_R32G32B32_FLOAT, RHIFormat::R32G32B32_FLOAT},
    {DXGI_FORMAT_R32G32B32A32_UINT, RHIFormat::R32G32B32A32_UINT},
    {DXGI_FORMAT_R32G32B32A32_SINT, RHIFormat::R32G32B32A32_SINT},
    {DXGI_FORMAT_R32G32B32A32_FLOAT, RHIFormat::R32G32B32A32_FLOAT},
    {DXGI_FORMAT_D32_FLOAT, RHIFormat::D32_FLOAT},
    {DXGI_FORMAT_D24_UNORM_S8_UINT, RHIFormat::D24_UNORM_S8_UINT},
};

struct DDS_PIXELFORMAT
{
	uint32_t size;
	uint32_t flags;
	uint32_t fourCC;
	uint32_t RGBBitCount;
	uint32_t RBitMask;
	uint32_t GBitMask;
	uint32_t BBitMask;
	uint32_t ABitMask;
};

#define DDS_FOURCC 0x00000004            // DDPF_FOURCC
#define DDS_RGB 0x00000040               // DDPF_RGB
#define DDS_RGBA 0x00000041              // DDPF_RGB | DDPF_ALPHAPIXELS
#define DDS_LUMINANCE 0x00020000         // DDPF_LUMINANCE
#define DDS_LUMINANCEA 0x00020001        // DDPF_LUMINANCE | DDPF_ALPHAPIXELS
#define DDS_ALPHA 0x00000002             // DDPF_ALPHA
#define DDS_PAL8 0x00000020              // DDPF_PALETTEINDEXED8

#ifndef MAKEFOURCC
#	define MAKEFOURCC(ch0, ch1, ch2, ch3)                                \
		((uint32_t) (uint8_t) (ch0) | ((uint32_t) (uint8_t) (ch1) << 8) | \
		 ((uint32_t) (uint8_t) (ch2) << 16) | ((uint32_t) (uint8_t) (ch3) << 24))
#endif /* defined(MAKEFOURCC) */

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_DXT1 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D', 'X', 'T', '1'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_DXT2 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D', 'X', 'T', '2'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_DXT3 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D', 'X', 'T', '3'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_DXT4 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D', 'X', 'T', '4'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_DXT5 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D', 'X', 'T', '5'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_BC4_UNORM =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B', 'C', '4', 'U'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_BC4_SNORM =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B', 'C', '4', 'S'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_BC5_UNORM =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B', 'C', '5', 'U'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_BC5_SNORM =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B', 'C', '5', 'S'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_R8G8_B8G8 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('R', 'G', 'B', 'G'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_G8R8_G8B8 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('G', 'R', 'G', 'B'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_YUY2 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('Y', 'U', 'Y', '2'), 0, 0, 0, 0, 0};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_A8R8G8B8 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_X8R8G8B8 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_A8B8G8R8 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_X8B8G8R8 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_G16R16 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x0000ffff, 0xffff0000, 0x00000000, 0x00000000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_R5G6B5 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_A1R5G5B5 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00007c00, 0x000003e0, 0x0000001f, 0x00008000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_A4R4G4B4 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00000f00, 0x000000f0, 0x0000000f, 0x0000f000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_R8G8B8 =
    {sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_L8 =
    {sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 8, 0xff, 0x00, 0x00, 0x00};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_L16 =
    {sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 16, 0xffff, 0x0000, 0x0000, 0x0000};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_A8L8 =
    {sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 16, 0x00ff, 0x0000, 0x0000, 0xff00};

extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_A8 =
    {sizeof(DDS_PIXELFORMAT), DDS_ALPHA, 0, 8, 0x00, 0x00, 0x00, 0xff};

// D3DFMT_A2R10G10B10/D3DFMT_A2B10G10R10 should be written using DX10 extension to avoid D3DX 10:10:10:2 reversal issue

// This indicates the DDS_HEADER_DXT10 extension is present (the format is in dxgiFormat)
extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_DX10 =
    {sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D', 'X', '1', '0'), 0, 0, 0, 0, 0};

#define DDS_HEADER_FLAGS_TEXTURE 0x00001007           // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
#define DDS_HEADER_FLAGS_MIPMAP 0x00020000            // DDSD_MIPMAPCOUNT
#define DDS_HEADER_FLAGS_VOLUME 0x00800000            // DDSD_DEPTH
#define DDS_HEADER_FLAGS_PITCH 0x00000008             // DDSD_PITCH
#define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000        // DDSD_LINEARSIZE

#define DDS_HEIGHT 0x00000002        // DDSD_HEIGHT
#define DDS_WIDTH 0x00000004         // DDSD_WIDTH

#define DDS_SURFACE_FLAGS_TEXTURE 0x00001000        // DDSCAPS_TEXTURE
#define DDS_SURFACE_FLAGS_MIPMAP 0x00400008         // DDSCAPS_COMPLEX | DDSCAPS_MIPMAP
#define DDS_SURFACE_FLAGS_CUBEMAP 0x00000008        // DDSCAPS_COMPLEX

#define DDS_CUBEMAP_POSITIVEX 0x00000600        // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX
#define DDS_CUBEMAP_NEGATIVEX 0x00000a00        // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX
#define DDS_CUBEMAP_POSITIVEY 0x00001200        // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY
#define DDS_CUBEMAP_NEGATIVEY 0x00002200        // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY
#define DDS_CUBEMAP_POSITIVEZ 0x00004200        // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ
#define DDS_CUBEMAP_NEGATIVEZ 0x00008200        // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ

#define DDS_CUBEMAP_ALLFACES (DDS_CUBEMAP_POSITIVEX | DDS_CUBEMAP_NEGATIVEX | \
	                          DDS_CUBEMAP_POSITIVEY | DDS_CUBEMAP_NEGATIVEY | \
	                          DDS_CUBEMAP_POSITIVEZ | DDS_CUBEMAP_NEGATIVEZ)

#define DDS_CUBEMAP 0x00000200        // DDSCAPS2_CUBEMAP

#define DDS_FLAGS_VOLUME 0x00200000        // DDSCAPS2_VOLUME

// Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
enum DDS_RESOURCE_DIMENSION
{
	DDS_DIMENSION_TEXTURE1D = 2,
	DDS_DIMENSION_TEXTURE2D = 3,
	DDS_DIMENSION_TEXTURE3D = 4,
};

// Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
enum DDS_RESOURCE_MISC_FLAG
{
	DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L,
};

enum DDS_MISC_FLAGS2
{
	DDS_MISC_FLAGS2_ALPHA_MODE_MASK = 0x7L,
};

struct DDS_HEADER
{
	uint32_t        size;
	uint32_t        flags;
	uint32_t        height;
	uint32_t        width;
	uint32_t        pitchOrLinearSize;
	uint32_t        depth;        // only if DDS_HEADER_FLAGS_VOLUME is set in flags
	uint32_t        mipMapCount;
	uint32_t        reserved1[11];
	DDS_PIXELFORMAT ddspf;
	uint32_t        caps;
	uint32_t        caps2;
	uint32_t        caps3;
	uint32_t        caps4;
	uint32_t        reserved2;
};

struct DDS_HEADER_DXT10
{
	DXGI_FORMAT dxgiFormat;
	uint32_t    resourceDimension;
	uint32_t    miscFlag;        // see D3D11_RESOURCE_MISC_FLAG
	uint32_t    arraySize;
	uint32_t    miscFlags2;        // see DDS_MISC_FLAGS2
};

static_assert(sizeof(DDS_HEADER) == 124, "DDS Header size mismatch");
static_assert(sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch");

#define ISBITMASK(r, g, b, a) (ddpf.RBitMask == r && ddpf.GBitMask == g && ddpf.BBitMask == b && ddpf.ABitMask == a)

static DXGI_FORMAT GetDXGIFormat(const DDS_PIXELFORMAT &ddpf)
{
	if (ddpf.flags & DDS_RGB)
	{
		// Note that sRGB formats are written using the "DX10" extended header

		switch (ddpf.RGBBitCount)
		{
			case 32:
				if (ISBITMASK(0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000))
				{
					return DXGI_FORMAT_R8G8B8A8_UNORM;
				}

				if (ISBITMASK(0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000))
				{
					return DXGI_FORMAT_B8G8R8A8_UNORM;
				}

				if (ISBITMASK(0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000))
				{
					return DXGI_FORMAT_B8G8R8X8_UNORM;
				}

				// No DXGI format maps to ISBITMASK(0x000000ff,0x0000ff00,0x00ff0000,0x00000000) aka D3DFMT_X8B8G8R8

				// Note that many common DDS reader/writers (including D3DX) swap the
				// the RED/BLUE masks for 10:10:10:2 formats. We assumme
				// below that the 'backwards' header mask is being used since it is most
				// likely written by D3DX. The more robust solution is to use the 'DX10'
				// header extension and specify the DXGI_FORMAT_R10G10B10A2_UNORM format directly

				// For 'correct' writers, this should be 0x000003ff,0x000ffc00,0x3ff00000 for RGB data
				if (ISBITMASK(0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000))
				{
					return DXGI_FORMAT_R10G10B10A2_UNORM;
				}

				// No DXGI format maps to ISBITMASK(0x000003ff,0x000ffc00,0x3ff00000,0xc0000000) aka D3DFMT_A2R10G10B10

				if (ISBITMASK(0x0000ffff, 0xffff0000, 0x00000000, 0x00000000))
				{
					return DXGI_FORMAT_R16G16_UNORM;
				}

				if (ISBITMASK(0xffffffff, 0x00000000, 0x00000000, 0x00000000))
				{
					// Only 32-bit color channel format in D3D9 was R32F
					return DXGI_FORMAT_R32_FLOAT;        // D3DX writes this out as a FourCC of 114
				}
				break;

			case 24:
				// No 24bpp DXGI formats aka D3DFMT_R8G8B8
				break;

			case 16:
				if (ISBITMASK(0x7c00, 0x03e0, 0x001f, 0x8000))
				{
					return DXGI_FORMAT_B5G5R5A1_UNORM;
				}
				if (ISBITMASK(0xf800, 0x07e0, 0x001f, 0x0000))
				{
					return DXGI_FORMAT_B5G6R5_UNORM;
				}

				// No DXGI format maps to ISBITMASK(0x7c00,0x03e0,0x001f,0x0000) aka D3DFMT_X1R5G5B5

				if (ISBITMASK(0x0f00, 0x00f0, 0x000f, 0xf000))
				{
					return DXGI_FORMAT_B4G4R4A4_UNORM;
				}

				// No DXGI format maps to ISBITMASK(0x0f00,0x00f0,0x000f,0x0000) aka D3DFMT_X4R4G4B4

				// No 3:3:2, 3:3:2:8, or paletted DXGI formats aka D3DFMT_A8R3G3B2, D3DFMT_R3G3B2, D3DFMT_P8, D3DFMT_A8P8, etc.
				break;
		}
	}
	else if (ddpf.flags & DDS_LUMINANCE)
	{
		if (8 == ddpf.RGBBitCount)
		{
			if (ISBITMASK(0x000000ff, 0x00000000, 0x00000000, 0x00000000))
			{
				return DXGI_FORMAT_R8_UNORM;        // D3DX10/11 writes this out as DX10 extension
			}

			// No DXGI format maps to ISBITMASK(0x0f,0x00,0x00,0xf0) aka D3DFMT_A4L4
		}

		if (16 == ddpf.RGBBitCount)
		{
			if (ISBITMASK(0x0000ffff, 0x00000000, 0x00000000, 0x00000000))
			{
				return DXGI_FORMAT_R16_UNORM;        // D3DX10/11 writes this out as DX10 extension
			}
			if (ISBITMASK(0x000000ff, 0x00000000, 0x00000000, 0x0000ff00))
			{
				return DXGI_FORMAT_R8G8_UNORM;        // D3DX10/11 writes this out as DX10 extension
			}
		}
	}
	else if (ddpf.flags & DDS_ALPHA)
	{
		if (8 == ddpf.RGBBitCount)
		{
			return DXGI_FORMAT_A8_UNORM;
		}
	}
	else if (ddpf.flags & DDS_FOURCC)
	{
		if (MAKEFOURCC('D', 'X', 'T', '1') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC1_UNORM;
		}
		if (MAKEFOURCC('D', 'X', 'T', '3') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC2_UNORM;
		}
		if (MAKEFOURCC('D', 'X', 'T', '5') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC3_UNORM;
		}

		// While pre-mulitplied alpha isn't directly supported by the DXGI formats,
		// they are basically the same as these BC formats so they can be mapped
		if (MAKEFOURCC('D', 'X', 'T', '2') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC2_UNORM;
		}
		if (MAKEFOURCC('D', 'X', 'T', '4') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC3_UNORM;
		}

		if (MAKEFOURCC('A', 'T', 'I', '1') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC4_UNORM;
		}
		if (MAKEFOURCC('B', 'C', '4', 'U') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC4_UNORM;
		}
		if (MAKEFOURCC('B', 'C', '4', 'S') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC4_SNORM;
		}

		if (MAKEFOURCC('A', 'T', 'I', '2') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC5_UNORM;
		}
		if (MAKEFOURCC('B', 'C', '5', 'U') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC5_UNORM;
		}
		if (MAKEFOURCC('B', 'C', '5', 'S') == ddpf.fourCC)
		{
			return DXGI_FORMAT_BC5_SNORM;
		}

		// BC6H and BC7 are written using the "DX10" extended header

		if (MAKEFOURCC('R', 'G', 'B', 'G') == ddpf.fourCC)
		{
			return DXGI_FORMAT_R8G8_B8G8_UNORM;
		}
		if (MAKEFOURCC('G', 'R', 'G', 'B') == ddpf.fourCC)
		{
			return DXGI_FORMAT_G8R8_G8B8_UNORM;
		}

		if (MAKEFOURCC('Y', 'U', 'Y', '2') == ddpf.fourCC)
		{
			return DXGI_FORMAT_YUY2;
		}

		// Check for D3DFORMAT enums being set here
		switch (ddpf.fourCC)
		{
			case 36:        // D3DFMT_A16B16G16R16
				return DXGI_FORMAT_R16G16B16A16_UNORM;

			case 110:        // D3DFMT_Q16W16V16U16
				return DXGI_FORMAT_R16G16B16A16_SNORM;

			case 111:        // D3DFMT_R16F
				return DXGI_FORMAT_R16_FLOAT;

			case 112:        // D3DFMT_G16R16F
				return DXGI_FORMAT_R16G16_FLOAT;

			case 113:        // D3DFMT_A16B16G16R16F
				return DXGI_FORMAT_R16G16B16A16_FLOAT;

			case 114:        // D3DFMT_R32F
				return DXGI_FORMAT_R32_FLOAT;

			case 115:        // D3DFMT_G32R32F
				return DXGI_FORMAT_R32G32_FLOAT;

			case 116:        // D3DFMT_A32B32G32R32F
				return DXGI_FORMAT_R32G32B32A32_FLOAT;
		}
	}

	return DXGI_FORMAT_UNKNOWN;
}

class DDSImporter : public Importer<ResourceType::Texture2D>
{
  protected:
	virtual void Import_(ResourceManager *manager, const std::string &path, RHIContext *rhi_context) override

	{
		TextureDesc desc;
		desc.name    = Path::GetInstance().GetFileName(path, false);
		desc.width   = 1;
		desc.height  = 1;
		desc.depth   = 1;
		desc.mips    = 1;
		desc.layers  = 1;
		desc.samples = 1;

		std::vector<uint8_t> raw_data;
		Path::GetInstance().Read(path, raw_data, true);

		size_t   data_size = raw_data.size();
		uint8_t *data      = raw_data.data();

		uint32_t dwMagicNumber = *(const uint32_t *) (data);
		if (dwMagicNumber != DDS_MAGIC)
		{
			return;
		}

		auto header = reinterpret_cast<const DDS_HEADER *>(data + sizeof(uint32_t));
		if (header->size != sizeof(DDS_HEADER) ||
		    header->ddspf.size != sizeof(DDS_PIXELFORMAT))
		{
			return;
		}

		size_t offset = sizeof(DDS_HEADER) + sizeof(uint32_t);

		// Check for extensions
		if (header->ddspf.flags & DDS_FOURCC)
		{
			if (MAKEFOURCC('D', 'X', '1', '0') == header->ddspf.fourCC)
			{
				offset += sizeof(DDS_HEADER_DXT10);
			}
		}

		if (data_size < offset)
		{
			return;
		}

		desc.width  = header->width;
		desc.height = header->height;
		desc.depth  = header->depth;

		if ((header->ddspf.flags & DDS_FOURCC) && (MAKEFOURCC('D', 'X', '1', '0') == header->ddspf.fourCC))
		{
			auto d3d10ext = reinterpret_cast<const DDS_HEADER_DXT10 *>((const char *) header + sizeof(DDS_HEADER));

			desc.layers = d3d10ext->arraySize;
			if (desc.layers == 0)
			{
				return;
			}

			if (FormatMap.find(d3d10ext->dxgiFormat) != FormatMap.end())
			{
				desc.format = FormatMap[d3d10ext->dxgiFormat];
			}
			else
			{
				return;
			}
		}
		else
		{
			auto dxgi_format = GetDXGIFormat(header->ddspf);
			if (FormatMap.find(dxgi_format) != FormatMap.end())
			{
				desc.format = FormatMap[dxgi_format];
			}
			else
			{
				return;
			}

			if (header->flags & DDS_HEADER_FLAGS_VOLUME)
			{
				// So it's a 3D texture
			}
			else
			{
				desc.depth  = 1;
				desc.layers = 1;

				if (header->caps2 & DDS_CUBEMAP)
				{
					// Require all six faces to be defined
					if ((header->caps2 & DDS_CUBEMAP_ALLFACES) != DDS_CUBEMAP_ALLFACES)
					{
						return;
					}

					desc.layers = 6;
				}
			}
		}

		if (desc.depth > 1)
		{
			LOG_WARN("Texture is not 2D Texture!");
			return;
		}

		if (desc.layers > 1)
		{
			LOG_WARN("Texture is not 2D Texture!");
			return;
		}

		uint8_t *tex_data = data + offset;
		data_size -= offset;

		std::vector<uint8_t> final_data;

		final_data.resize(data_size);
		std::memcpy(final_data.data(), tex_data, data_size);

		desc.mips  = static_cast<uint32_t>(std::floor(std::log2(std::max(desc.width, desc.height))) + 1);
		desc.usage = RHITextureUsage::ShaderResource | RHITextureUsage::Transfer;

		manager->Add<ResourceType::Texture2D>(rhi_context, std::move(final_data), desc);
	}
};

extern "C"
{
	EXPORT_API DDSImporter *Create()
	{
		return new DDSImporter;
	}
}

================================================
FILE: Source/Plugin/Importer/STB.cpp
================================================
#include <RHI/RHITexture.hpp>
#include <Resource/Importer.hpp>
#include <Resource/Resource/Texture2D.hpp>
#include <Resource/Resource/TextureCube.hpp>
#include <Resource/ResourceManager.hpp>

#include <stb_image.h>

using namespace Ilum;

class STBImporter : public Importer<ResourceType::Texture2D>
{
  protected:
	virtual void Import_(ResourceManager *manager, const std::string &path, RHIContext *rhi_context) override
	{
		std::string texture_name = Path::GetInstance().ValidFileName(path);

		if (manager->Has<ResourceType::Texture2D>(texture_name))
		{
			return;
		}

		TextureDesc desc = {};
		desc.name        = texture_name;
		desc.width       = 1;
		desc.height      = 1;
		desc.depth       = 1;
		desc.mips        = 1;
		desc.layers      = 1;
		desc.samples     = 1;

		int32_t width = 0, height = 0, channel = 0;

		const int32_t req_channel = 4;

		void  *raw_data = nullptr;
		size_t size     = 0;

		if (stbi_is_hdr(path.c_str()))
		{
			raw_data    = stbi_loadf(path.c_str(), &width, &height, &channel, req_channel);
			size        = static_cast<size_t>(width) * static_cast<size_t>(height) * static_cast<size_t>(req_channel) * sizeof(float);
			desc.format = RHIFormat::R32G32B32A32_FLOAT;
		}
		else if (stbi_is_16_bit(path.c_str()))
		{
			raw_data    = stbi_load_16(path.c_str(), &width, &height, &channel, req_channel);
			size        = static_cast<size_t>(width) * static_cast<size_t>(height) * static_cast<size_t>(req_channel) * sizeof(uint16_t);
			desc.format = RHIFormat::R16G16B16A16_FLOAT;
		}
		else
		{
			raw_data    = stbi_load(path.c_str(), &width, &height, &channel, req_channel);
			size        = static_cast<size_t>(width) * static_cast<size_t>(height) * static_cast<size_t>(req_channel) * sizeof(uint8_t);
			desc.format = RHIFormat::R8G8B8A8_UNORM;
		}

		desc.width  = static_cast<uint32_t>(width);
		desc.height = static_cast<uint32_t>(height);
		desc.usage  = RHITextureUsage::ShaderResource | RHITextureUsage::Transfer;

		std::vector<uint8_t> data;

		data.resize(size);
		std::memcpy(data.data(), raw_data, size);

		stbi_image_free(raw_data);

		if (Path::GetInstance().GetFileExtension(path) == ".hdr")
		{
			desc.mips = 1;
			manager->Add<ResourceType::TextureCube>(rhi_context, std::move(data), desc);
		}
		else
		{
			desc.mips = static_cast<uint32_t>(std::floor(std::log2(std::max(width, height))) + 1);
			manager->Add<ResourceType::Texture2D>(rhi_context, std::move(data), desc);
		}
	}
};

extern "C"
{
	EXPORT_API STBImporter *Create()
	{
		return new STBImporter;
	}
}

================================================
FILE: Source/Plugin/Importer/xmake.lua
================================================
function add_importer_plugin(name, deps, pkgs)
    target(string.format("Importer.%s", name))

    set_kind("shared")
    set_group("Plugin/Importer")

    add_rules("plugin")
    add_files(string.format("%s.cpp", name))
    add_deps("Core", "RHI", "Resource", deps)
    add_packages(pkgs)

    target("Plugin")
        add_deps(string.format("Importer.%s", name))
    target_end()

    target_end()
end

add_importer_plugin("STB", {}, {"stb"})
add_importer_plugin("DDS", {}, {})
add_importer_plugin("Assimp", {"Geometry"}, {"assimp", "stb", "meshoptimizer"})

================================================
FILE: Source/Plugin/MaterialNode/BSDF/ConductorMaterial.cpp
================================================
#include "IMaterialNode.hpp"
#include "Utils/SPDLoader.hpp"

using namespace Ilum;

class ConductorMaterial : public MaterialNode<ConductorMaterial>
{
	const std::vector<const char *> m_materials = {
	    "a-C", "Ag", "Al", "AlAs", "AlSb", "a-SiH", "Au", "Be", "Cr", "Csl", "Cu",
	    "Cu2O", "CuO", "d-C", "Hg", "HgTe", "Ir", "K", "KBr", "KCl", "Li", "MgO", "Mo",
	    "NaCl", "Nb", "Rh", "Se", "Se-e", "SiC", "SiO", "SnTe", "Ta", "Te", "Te-e", "ThF4",
	    "TiC", "TiN", "TiO2", "TiO2-e", "VC", "VN", "W"};

  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("ConductorMaterial")
		    .SetCategory("BSDF")
		    .SetVariant(int32_t(1))
		    .Input(handle++, "Reflectance", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(1.f))
		    .Input(handle++, "Roughness", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.1f))
		    .Input(handle++, "Normal", MaterialNodePin::Type::Float3, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3)
		    .Output(handle++, "Out", MaterialNodePin::Type::BSDF);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
		int32_t &material_type = *node_desc.GetVariant().Convert<int32_t>();

		ImGui::PushID("material type");
		if (ImGui::BeginCombo("", "Type"))
		{
			for (size_t i = 0; i < m_materials.size(); i++)
			{
				const bool is_selected = (i == material_type);
				if (ImGui::Selectable(m_materials[i], i == material_type))
				{
					material_type = static_cast<int32_t>(i);
				}
				if (is_selected)
				{
					ImGui::SetItemDefaultFocus();
				}
			}
			ImGui::EndCombo();
		}
		ImGui::PopID();
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		int32_t material_type = *node_desc.GetVariant().Convert<int32_t>();

		std::map<std::string, std::string> parameters;

		if (!context->HasParameter<glm::vec3>(parameters, node_desc.GetPin("Normal"), graph_desc, manager, context))
		{
			parameters["Normal"] = "surface_interaction.isect.n";
		}
		else
		{
			parameters["Normal"] = fmt::format("ExtractNormalMap(surface_interaction, {})", parameters["Normal"]);
		}

		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("Reflectance"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Roughness"), graph_desc, manager, context);

		glm::vec3 eta = SPDLoader::Load(fmt::format("Asset/SPD/metals/{}.eta.spd", m_materials[material_type]));
		glm::vec3 k   = SPDLoader::Load(fmt::format("Asset/SPD/metals/{}.k.spd", m_materials[material_type]));

		context->bsdfs.emplace_back(MaterialCompilationContext::BSDF{
		    fmt::format("S_{}", node_desc.GetPin("Out").handle),
		    "ConductorMaterial",
		    fmt::format("S_{}.Init({}, {}, float3({}, {}, {}),  float3({}, {}, {}), {});", node_desc.GetPin("Out").handle,
		                parameters["Reflectance"],
		                parameters["Roughness"],
		                eta.x, eta.y, eta.z,
		                k.x, k.y, k.z,
		                parameters["Normal"])});
	}
};

CONFIGURATION_MATERIAL_NODE(ConductorMaterial)

================================================
FILE: Source/Plugin/MaterialNode/BSDF/DielectricMaterial.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class DielectricMaterial : public MaterialNode<DielectricMaterial>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("DielectricMaterial")
		    .SetCategory("BSDF")
		    .Input(handle++, "Reflectance", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(1.f))
		    .Input(handle++, "Transmittance", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(1.f))
		    .Input(handle++, "Roughness", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.1f))
		    .Input(handle++, "IOR", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(1.45f))
		    .Input(handle++, "Normal", MaterialNodePin::Type::Float3, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3)
		    .Output(handle++, "Out", MaterialNodePin::Type::BSDF);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;

		if (!context->HasParameter<glm::vec3>(parameters, node_desc.GetPin("Normal"), graph_desc, manager, context))
		{
			parameters["Normal"] = "surface_interaction.isect.n";
		}
		else
		{
			parameters["Normal"] = fmt::format("ExtractNormalMap(surface_interaction, {})", parameters["Normal"]);
		}

		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("Reflectance"), graph_desc, manager, context);
		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("Transmittance"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Roughness"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("IOR"), graph_desc, manager, context);

		context->bsdfs.emplace_back(MaterialCompilationContext::BSDF{
		    fmt::format("S_{}", node_desc.GetPin("Out").handle),
		    "DielectricMaterial",
		    fmt::format("S_{}.Init({}, {}, {}, {}, {});", node_desc.GetPin("Out").handle,
		                parameters["Reflectance"],
		                parameters["Transmittance"],
		                parameters["IOR"],
		                parameters["Roughness"],
		                parameters["Normal"])});
	}
};

CONFIGURATION_MATERIAL_NODE(DielectricMaterial)

================================================
FILE: Source/Plugin/MaterialNode/BSDF/DiffuseMaterial.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class DiffuseMaterial : public MaterialNode<DiffuseMaterial>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("DiffuseMaterial")
		    .SetCategory("BSDF")
		    .Input(handle++, "Normal", MaterialNodePin::Type::Float3, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3)
		    .Input(handle++, "Reflectance", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(1.f))
		    .Output(handle++, "Out", MaterialNodePin::Type::BSDF);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;

		if (!context->HasParameter<glm::vec3>(parameters, node_desc.GetPin("Normal"), graph_desc, manager, context))
		{
			parameters["Normal"] = "surface_interaction.isect.n";
		}
		else
		{
			parameters["Normal"] = fmt::format("ExtractNormalMap(surface_interaction, {})", parameters["Normal"]);
		}

		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("Reflectance"), graph_desc, manager, context);

		context->bsdfs.emplace_back(MaterialCompilationContext::BSDF{
		    fmt::format("S_{}", node_desc.GetPin("Out").handle),
		    "DiffuseMaterial",
		    fmt::format("S_{}.Init({}, {});", node_desc.GetPin("Out").handle, parameters["Reflectance"], parameters["Normal"])});
	}
};

CONFIGURATION_MATERIAL_NODE(DiffuseMaterial)

================================================
FILE: Source/Plugin/MaterialNode/BSDF/DisneyMaterial.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class DisneyMaterial : public MaterialNode<DisneyMaterial>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("DisneyMaterial")
		    .SetCategory("BSDF")
		    .Input(handle++, "BaseColor", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(1.f))
		    .Input(handle++, "Metallic", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.5f))
		    .Input(handle++, "Roughness", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.5f))
		    .Input(handle++, "Anisotropic", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Sheen", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "SheenTint", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Specular", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "SpecTint", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Clearcoat", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "ClearcoatGloss", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Flatness", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "SpecTrans", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "IOR", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(1.45f))
		    .Input(handle++, "Emissive", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Input(handle++, "TwoSide", MaterialNodePin::Type::Bool, MaterialNodePin::Type::Bool, true)
			.Input(handle++, "Normal", MaterialNodePin::Type::Float3, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3)
		    .Output(handle++, "Out", MaterialNodePin::Type::BSDF);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;

		if (!context->HasParameter<glm::vec3>(parameters, node_desc.GetPin("Normal"), graph_desc, manager, context))
		{
			parameters["Normal"] = "surface_interaction.isect.n";
		}
		else
		{
			parameters["Normal"] = fmt::format("ExtractNormalMap(surface_interaction, {})", parameters["Normal"]);
		}

		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("BaseColor"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Metallic"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Roughness"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Anisotropic"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Sheen"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("SheenTint"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Specular"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("SpecTint"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Clearcoat"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("ClearcoatGloss"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Flatness"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("SpecTrans"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("IOR"), graph_desc, manager, context);
		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("Emissive"), graph_desc, manager, context);
		context->SetParameter<bool>(parameters, node_desc.GetPin("TwoSide"), graph_desc, manager, context);

		context->bsdfs.emplace_back(MaterialCompilationContext::BSDF{
		    fmt::format("S_{}", node_desc.GetPin("Out").handle),
		    "DisneyMaterial",
		    fmt::format("S_{}.Init({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {});", node_desc.GetPin("Out").handle,
		                parameters["BaseColor"],
		                parameters["Metallic"],
		                parameters["Roughness"],
		                parameters["Anisotropic"],
		                parameters["Sheen"],
		                parameters["SheenTint"],
		                parameters["Specular"],
		                parameters["SpecTint"],
		                parameters["Clearcoat"],
		                parameters["ClearcoatGloss"],
		                parameters["Flatness"],
		                parameters["SpecTrans"],
		                parameters["IOR"],
		                parameters["Emissive"],
		                parameters["TwoSide"],
		                parameters["Normal"])});
	}
};

CONFIGURATION_MATERIAL_NODE(DisneyMaterial)

================================================
FILE: Source/Plugin/MaterialNode/BSDF/MaskedMaterial.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class MaskedMaterial : public MaterialNode<MaskedMaterial>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("MaskedMaterial")
		    .SetCategory("BSDF")
		    .Input(handle++, "BSDF", MaterialNodePin::Type::BSDF, MaterialNodePin::Type::BSDF)
		    .Input(handle++, "Opacity", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::Float3 | MaterialNodePin::Type::RGB, float(0.f))
		    .Input(handle++, "Threshold", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::Float3 | MaterialNodePin::Type::RGB, float(0.f))
		    .Output(handle++, "Out", MaterialNodePin::Type::BSDF);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;

		context->SetParameter<float>(parameters, node_desc.GetPin("Opacity"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Threshold"), graph_desc, manager, context);

		auto &bsdf_node = node_desc.GetPin("BSDF");

		if (graph_desc.HasLink(bsdf_node.handle))
		{
			size_t bsdf = 0;

			{
				auto &src_node = graph_desc.GetNode(graph_desc.LinkFrom(bsdf_node.handle));
				src_node.EmitHLSL(graph_desc, manager, context);
				auto &src_pin = src_node.GetPin(graph_desc.LinkFrom(bsdf_node.handle));

				bsdf = src_pin.handle;
			}

			{
				std::string bsdf_type = "";

				std::string bsdf_name = fmt::format("S_{}", bsdf);

				for (auto &bsdf : context->bsdfs)
				{
					if (bsdf.name == bsdf_name)
					{
						bsdf_type = bsdf.type;
						break;
					}
				}

				context->bsdfs.emplace_back(MaterialCompilationContext::BSDF{
				    fmt::format("S_{}", node_desc.GetPin("Out").handle),
				    fmt::format("MaskedMaterial< {} >", bsdf_type),
				    fmt::format("S_{}.Init(S_{}, {}, {});", node_desc.GetPin("Out").handle,
				                bsdf,
				                parameters["Opacity"],
				                parameters["Threshold"])});
			}
		}
	}
};

CONFIGURATION_MATERIAL_NODE(MaskedMaterial)

================================================
FILE: Source/Plugin/MaterialNode/BSDF/MixMaterial.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class MixMaterial : public MaterialNode<MixMaterial>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("MixMaterial")
		    .SetCategory("BSDF")
		    .Input(handle++, "X", MaterialNodePin::Type::BSDF, MaterialNodePin::Type::BSDF)
		    .Input(handle++, "Y", MaterialNodePin::Type::BSDF, MaterialNodePin::Type::BSDF)
		    .Input(handle++, "Weight", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::Float3 | MaterialNodePin::Type::RGB, float(0.f))
		    .Output(handle++, "Out", MaterialNodePin::Type::BSDF);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;

		context->SetParameter<float>(parameters, node_desc.GetPin("Weight"), graph_desc, manager, context);

		auto &bsdf1_node = node_desc.GetPin("X");
		auto &bsdf2_node = node_desc.GetPin("Y");

		if (graph_desc.HasLink(bsdf1_node.handle) && graph_desc.HasLink(bsdf2_node.handle))
		{
			size_t bsdf1 = 0;
			size_t bsdf2 = 0;

			{
				auto &src_node = graph_desc.GetNode(graph_desc.LinkFrom(bsdf1_node.handle));
				src_node.EmitHLSL(graph_desc, manager, context);
				auto &src_pin = src_node.GetPin(graph_desc.LinkFrom(bsdf1_node.handle));

				bsdf1 = src_pin.handle;
			}

			{
				auto &src_node = graph_desc.GetNode(graph_desc.LinkFrom(bsdf2_node.handle));
				src_node.EmitHLSL(graph_desc, manager, context);
				auto &src_pin = src_node.GetPin(graph_desc.LinkFrom(bsdf2_node.handle));

				bsdf2 = src_pin.handle;
			}

			{
				std::string bsdf1_type = "";
				std::string bsdf2_type = "";

				std::string bsdf1_name = fmt::format("S_{}", bsdf1);
				std::string bsdf2_name = fmt::format("S_{}", bsdf2);

				for (auto &bsdf : context->bsdfs)
				{
					if (bsdf.name == bsdf1_name)
					{
						bsdf1_type = bsdf.type;
					}
					if (bsdf.name == bsdf2_name)
					{
						bsdf2_type = bsdf.type;
					}
					if (!bsdf1_type.empty() && !bsdf2_type.empty())
					{
						break;
					}
				}

				context->bsdfs.emplace_back(MaterialCompilationContext::BSDF{
				    fmt::format("S_{}", node_desc.GetPin("Out").handle),
				    fmt::format("MixMaterial< {}, {} >", bsdf1_type, bsdf2_type),
				    fmt::format("S_{}.Init(S_{}, S_{}, {});", node_desc.GetPin("Out").handle, bsdf1, bsdf2, parameters["Weight"])});
			}
		}
	}
};

CONFIGURATION_MATERIAL_NODE(MixMaterial)

================================================
FILE: Source/Plugin/MaterialNode/BSDF/PrincipledMaterial.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class PrincipledMaterial : public MaterialNode<PrincipledMaterial>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("PrincipledMaterial")
		    .SetCategory("BSDF")
		    .Input(handle++, "BaseColor", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(1.f))
		    .Input(handle++, "Metallic", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.5f))
		    .Input(handle++, "Roughness", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.5f))
		    .Input(handle++, "Anisotropic", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Sheen", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "SheenTint", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Specular", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "SpecTint", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Clearcoat", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "ClearcoatGloss", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Flatness", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "SpecTrans", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "IOR", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(1.45f))
		    .Input(handle++, "Emissive", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Input(handle++, "TwoSide", MaterialNodePin::Type::Bool, MaterialNodePin::Type::Bool, true)
			.Input(handle++, "Normal", MaterialNodePin::Type::Float3, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3)
		    .Output(handle++, "Out", MaterialNodePin::Type::BSDF);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;

		if (!context->HasParameter<glm::vec3>(parameters, node_desc.GetPin("Normal"), graph_desc, manager, context))
		{
			parameters["Normal"] = "surface_interaction.isect.n";
		}
		else
		{
			parameters["Normal"] = fmt::format("ExtractNormalMap(surface_interaction, {})", parameters["Normal"]);
		}

		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("BaseColor"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Metallic"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Roughness"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Anisotropic"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Sheen"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("SheenTint"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Specular"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("SpecTint"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Clearcoat"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("ClearcoatGloss"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Flatness"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("SpecTrans"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("IOR"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Emissive"), graph_desc, manager, context);
		context->SetParameter<bool>(parameters, node_desc.GetPin("TwoSide"), graph_desc, manager, context);

		context->bsdfs.emplace_back(MaterialCompilationContext::BSDF{
		    fmt::format("S_{}", node_desc.GetPin("Out").handle),
		    "PrincipledMaterial",
		    fmt::format("S_{}.Init({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {});", node_desc.GetPin("Out").handle,
		                parameters["BaseColor"],
		                parameters["Metallic"],
		                parameters["Roughness"],
		                parameters["Anisotropic"],
		                parameters["Sheen"],
		                parameters["SheenTint"],
		                parameters["Specular"],
		                parameters["SpecTint"],
		                parameters["Clearcoat"],
		                parameters["ClearcoatGloss"],
		                parameters["Flatness"],
		                parameters["SpecTrans"],
		                parameters["IOR"],
		                parameters["Emissive"],
		                parameters["TwoSide"],
		                parameters["Normal"])});
	}
};

CONFIGURATION_MATERIAL_NODE(PrincipledMaterial)

================================================
FILE: Source/Plugin/MaterialNode/BSDF/ThinDielectricMaterial.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class ThinDielectricMaterial : public MaterialNode<ThinDielectricMaterial>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("ThinDielectricMaterial")
		    .SetCategory("BSDF")
		    .Input(handle++, "Reflectance", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(1.f))
		    .Input(handle++, "Transmittance", MaterialNodePin::Type::RGB, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(1.f))
		    .Input(handle++, "IOR", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(1.45f))
		    .Input(handle++, "Normal", MaterialNodePin::Type::Float3, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3)
		    .Output(handle++, "Out", MaterialNodePin::Type::BSDF);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;

		if (!context->HasParameter<glm::vec3>(parameters, node_desc.GetPin("Normal"), graph_desc, manager, context))
		{
			parameters["Normal"] = "surface_interaction.isect.n";
		}
		else
		{
			parameters["Normal"] = fmt::format("ExtractNormalMap(surface_interaction, {})", parameters["Normal"]);
		}

		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("Reflectance"), graph_desc, manager, context);
		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("Transmittance"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("IOR"), graph_desc, manager, context);

		context->bsdfs.emplace_back(MaterialCompilationContext::BSDF{
		    fmt::format("S_{}", node_desc.GetPin("Out").handle),
		    "ThinDielectricMaterial",
		    fmt::format("S_{}.Init({}, {}, {}, {});", node_desc.GetPin("Out").handle,
		                parameters["Reflectance"],
		                parameters["Transmittance"],
		                parameters["IOR"],
		                parameters["Normal"])});
	}
};

CONFIGURATION_MATERIAL_NODE(ThinDielectricMaterial)

================================================
FILE: Source/Plugin/MaterialNode/BSDF/Utils/SPDLoader.hpp
================================================
#pragma once

#include <Material/Spectrum.hpp>

#include <glm/glm.hpp>

#include <fstream>

namespace Ilum
{
// Loading *.spd spectrum data
class SPDLoader
{
  public:
	inline static glm::vec3 Load(const std::string &path)
	{
		std::fstream fs;
		fs.open(path.c_str(), std::ios::in);

		std::vector<float> vals;

		std::string line;
		while (std::getline(fs, line))
		{
			if (!line.empty() && line[0] != '#')
			{
				auto line_data = Path::GetInstance().Split(line, ' ');
				for (auto &x : line_data)
				{
					vals.push_back(std::stof(x));
				}
			}
		}

		std::vector<float> wls, v;
		for (size_t j = 0; j < vals.size() / 2; ++j)
		{
			wls.push_back(vals[2 * j]);
			v.push_back(vals[2 * j + 1]);
		}
		glm::vec3 result = FromSampled(&wls[0], &v[0], static_cast<int32_t>(wls.size()));

		fs.close();

		return result;
	}
};
}        // namespace Ilum

================================================
FILE: Source/Plugin/MaterialNode/Converter/Calculate.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class Calculate : public MaterialNode<Calculate>
{
	enum class CalculationType
	{
		Addition,
		Substrate,
		Multiplication,
		Division,

		Maximum,
		Minimum,

		Greater,
		Less,

		Square,
		Log,
		Exp,
		Sqrt,
		Rcp,
		Abs,
		Sign,

		Sin,
		Cos,
		Tan,

		Asin,
		Acos,
		Atan,
		Atan2,

		Sinh,
		Cosh,
		Tanh,
	};

	const std::vector<const char *> calculation_types = {
	    "Addition",
	    "Substrate",
	    "Multiplication",
	    "Division",
	    "Maximum",
	    "Minimum",
	    "Greater",
	    "Less",
	    "Square",
	    "Log",
	    "Exp",
	    "Sqrt",
	    "Rcp",
	    "Abs",
	    "Sign",
	    "Sin",
	    "Cos",
	    "Tan",
	    "Asin",
	    "Acos",
	    "Atan",
	    "Atan2",
	    "Sinh",
	    "Cosh",
	    "Tanh",
	};

	const std::unordered_set<CalculationType> binary_op = {
	    CalculationType::Addition,
	    CalculationType::Substrate,
	    CalculationType::Multiplication,
	    CalculationType::Division,
	    CalculationType::Maximum,
	    CalculationType::Minimum,
	    CalculationType::Greater,
	    CalculationType::Less,
	    CalculationType::Square,
	    CalculationType::Atan2,
	};

  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("Calculate")
		    .SetCategory("Converter")
		    .SetVariant(CalculationType::Addition)
		    .Input(handle++, "X", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Y", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Output(handle++, "Out", MaterialNodePin::Type::Float);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
		CalculationType &type = *node_desc.GetVariant().Convert<CalculationType>();
		if (ImGui::Combo("", (int32_t *) (&type), calculation_types.data(), static_cast<int32_t>(calculation_types.size())))
		{
			node_desc.GetPin("Y").enable = binary_op.find(type) != binary_op.end();
		}
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;
		context->SetParameter<float>(parameters, node_desc.GetPin("X"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Y"), graph_desc, manager, context);

		CalculationType type = *node_desc.GetVariant().Convert<CalculationType>();

		switch (type)
		{
			case CalculationType::Addition:
				context->variables.emplace_back(fmt::format("float S_{} = {} + {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Substrate:
				context->variables.emplace_back(fmt::format("float S_{} = {} - {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Multiplication:
				context->variables.emplace_back(fmt::format("float S_{} = {} * {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Division:
				context->variables.emplace_back(fmt::format("float S_{} = {} / {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Maximum:
				context->variables.emplace_back(fmt::format("float S_{} = max({}, {});", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Minimum:
				context->variables.emplace_back(fmt::format("float S_{} = min({}, {});", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Greater:
				context->variables.emplace_back(fmt::format("float S_{} = {} > {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Less:
				context->variables.emplace_back(fmt::format("float S_{} = {} < {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Square:
				context->variables.emplace_back(fmt::format("float S_{} = {} * {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["X"]));
				break;
			case CalculationType::Log:
				context->variables.emplace_back(fmt::format("float S_{} = log({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Exp:
				context->variables.emplace_back(fmt::format("float S_{} = exp({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Sqrt:
				context->variables.emplace_back(fmt::format("float S_{} = sqrt({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Rcp:
				context->variables.emplace_back(fmt::format("float S_{} = rcp({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Abs:
				context->variables.emplace_back(fmt::format("float S_{} = abs({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Sign:
				context->variables.emplace_back(fmt::format("float S_{} = sign({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Sin:
				context->variables.emplace_back(fmt::format("float S_{} = sin({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Cos:
				context->variables.emplace_back(fmt::format("float S_{} = cos({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Tan:
				context->variables.emplace_back(fmt::format("float S_{} = tan({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Asin:
				context->variables.emplace_back(fmt::format("float S_{} = asin({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Acos:
				context->variables.emplace_back(fmt::format("float S_{} = acos({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Atan:
				context->variables.emplace_back(fmt::format("float S_{} = atan({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Atan2:
				context->variables.emplace_back(fmt::format("float S_{} = atan2({}, {});", node_desc.GetPin("Out").handle, parameters["Y"], parameters["X"]));
				break;
			case CalculationType::Sinh:
				context->variables.emplace_back(fmt::format("float S_{} = sinh({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Cosh:
				context->variables.emplace_back(fmt::format("float S_{} = cosh({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Tanh:
				context->variables.emplace_back(fmt::format("float S_{} = tanh({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			default:
				break;
		}
	}
};

CONFIGURATION_MATERIAL_NODE(Calculate)

================================================
FILE: Source/Plugin/MaterialNode/Converter/SRGBToLinear.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class SRGBToLinear : public MaterialNode<SRGBToLinear>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("SRGBToLinear")
		    .SetCategory("Converter")
		    .Input(handle++, "In", MaterialNodePin::Type::RGB, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Output(handle++, "Out", MaterialNodePin::Type::Float3);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;
		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("In"), graph_desc, manager, context);
		context->variables.emplace_back(fmt::format("float3 S_{} = SRGBtoLINEAR({});", node_desc.GetPin("Out").handle, parameters["In"]));
	}
};

CONFIGURATION_MATERIAL_NODE(SRGBToLinear)

================================================
FILE: Source/Plugin/MaterialNode/Converter/VectorCalculate.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class VectorCalculate : public MaterialNode<VectorCalculate>
{
	enum class CalculationType
	{
		Scale,
		Length,
		Distance,

		Dot,
		Cross,

		Addition,
		Substrate,
		Multiplication,
		Division,

		Sin,
		Cos,
		Tan,

		Maximum,
		Minimum,

		Abs,

		Normalize,
	};

	const std::vector<const char *> calculation_types = {
	    "Scale",
	    "Length",
	    "Distance",
	    "Dot",
	    "Cross",
	    "Addition",
	    "Substrate",
	    "Multiplication",
	    "Division",
	    "Sin",
	    "Cos",
	    "Tan",
	    "Maximum",
	    "Minimum",
	    "Abs",
	    "Normalize",
	};

	const std::unordered_set<CalculationType> binary_op = {
	    CalculationType::Addition,
	    CalculationType::Substrate,
	    CalculationType::Multiplication,
	    CalculationType::Division,
	    CalculationType::Maximum,
	    CalculationType::Minimum,
	    CalculationType::Dot,
	    CalculationType::Cross,
	    CalculationType::Distance,
	    CalculationType::Scale,
	};

	const std::unordered_set<CalculationType> scale_output = {
	    CalculationType::Length,
	    CalculationType::Distance,
	    CalculationType::Dot,
	};

  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("VectorCalculate")
		    .SetCategory("Converter")
		    .SetVariant(CalculationType::Addition)
		    .Input(handle++, "X", MaterialNodePin::Type::Float3, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Input(handle++, "Y", MaterialNodePin::Type::Float3, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Output(handle++, "Out", MaterialNodePin::Type::Float3);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
		CalculationType &type = *node_desc.GetVariant().Convert<CalculationType>();
		if (ImGui::Combo("", (int32_t *) (&type), calculation_types.data(), static_cast<int32_t>(calculation_types.size())))
		{
			node_desc.GetPin("Y").enable  = binary_op.find(type) != binary_op.end();
			node_desc.GetPin("Y").type    = type == CalculationType::Scale ? MaterialNodePin::Type::Float : MaterialNodePin::Type::Float3;
			node_desc.GetPin("Y").variant = type == CalculationType::Scale ? Variant(float(0.f)) : Variant(glm::vec3(0.f));
			node_desc.GetPin("Out").type  = scale_output.find(type) != scale_output.end() ? MaterialNodePin::Type::Float : MaterialNodePin::Type::Float3;
		}
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		CalculationType type = *node_desc.GetVariant().Convert<CalculationType>();

		std::map<std::string, std::string> parameters;
		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("X"), graph_desc, manager, context);
		if (type == CalculationType::Scale)
		{
			context->SetParameter<float>(parameters, node_desc.GetPin("Y"), graph_desc, manager, context);
		}
		else
		{
			context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("Y"), graph_desc, manager, context);
		}

		switch (type)
		{
			case CalculationType::Scale:
				context->variables.emplace_back(fmt::format("float3 S_{} = {} * {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Length:
				context->variables.emplace_back(fmt::format("float S_{} = length({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Distance:
				context->variables.emplace_back(fmt::format("float S_{} = length({} - {});", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Dot:
				context->variables.emplace_back(fmt::format("float S_{} = dot({}, {});", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Cross:
				context->variables.emplace_back(fmt::format("float S_{} = cross({}, {});", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Addition:
				context->variables.emplace_back(fmt::format("float3 S_{} = {} + {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Substrate:
				context->variables.emplace_back(fmt::format("float3 S_{} = {} - {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Multiplication:
				context->variables.emplace_back(fmt::format("float3 S_{} = {} * {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Division:
				context->variables.emplace_back(fmt::format("float3 S_{} = {} / {};", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Sin:
				context->variables.emplace_back(fmt::format("float3 S_{} = sin({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Cos:
				context->variables.emplace_back(fmt::format("float3 S_{} = cos({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Tan:
				context->variables.emplace_back(fmt::format("float3 S_{} = tan({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Maximum:
				context->variables.emplace_back(fmt::format("float3 S_{} = max({}, {});", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Minimum:
				context->variables.emplace_back(fmt::format("float3 S_{} = min({}, {});", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"]));
				break;
			case CalculationType::Abs:
				context->variables.emplace_back(fmt::format("float3 S_{} = abs({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			case CalculationType::Normalize:
				context->variables.emplace_back(fmt::format("float S_{} = normalize({});", node_desc.GetPin("Out").handle, parameters["X"]));
				break;
			default:
				break;
		}
	}
};

CONFIGURATION_MATERIAL_NODE(VectorCalculate)

================================================
FILE: Source/Plugin/MaterialNode/Converter/VectorMerge.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class VectorMerge : public MaterialNode<VectorMerge>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("VectorMerge")
		    .SetCategory("Converter")
		    .Input(handle++, "X", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Y", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Input(handle++, "Z", MaterialNodePin::Type::Float, MaterialNodePin::Type::Float | MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, float(0.f))
		    .Output(handle++, "Out", MaterialNodePin::Type::Float3);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;
		context->SetParameter<float>(parameters, node_desc.GetPin("X"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Y"), graph_desc, manager, context);
		context->SetParameter<float>(parameters, node_desc.GetPin("Z"), graph_desc, manager, context);
		context->variables.emplace_back(fmt::format("float3 S_{} = float3({}, {}, {});", node_desc.GetPin("Out").handle, parameters["X"], parameters["Y"], parameters["Z"]));
	}
};

CONFIGURATION_MATERIAL_NODE(VectorMerge)

================================================
FILE: Source/Plugin/MaterialNode/Converter/VectorSplit.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class VectorSplit : public MaterialNode<VectorSplit>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("VectorSplit")
		    .SetCategory("Converter")
		    .Input(handle++, "In", MaterialNodePin::Type::Float3, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Output(handle++, "X", MaterialNodePin::Type::Float)
		    .Output(handle++, "Y", MaterialNodePin::Type::Float)
		    .Output(handle++, "Z", MaterialNodePin::Type::Float);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		std::map<std::string, std::string> parameters;
		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("In"), graph_desc, manager, context);
		context->variables.emplace_back(fmt::format("float S_{} = {}.x;", node_desc.GetPin("X").handle, parameters["In"]));
		context->variables.emplace_back(fmt::format("float S_{} = {}.y;", node_desc.GetPin("Y").handle, parameters["In"]));
		context->variables.emplace_back(fmt::format("float S_{} = {}.z;", node_desc.GetPin("Z").handle, parameters["In"]));
	}
};

CONFIGURATION_MATERIAL_NODE(VectorSplit)

================================================
FILE: Source/Plugin/MaterialNode/IMaterialNode.hpp
================================================
#pragma once

#include <Editor/Editor.hpp>
#include <Material/MaterialCompiler.hpp>
#include <Material/MaterialGraph.hpp>
#include <Material/MaterialNode.hpp>
#include <Renderer/Renderer.hpp>
#include <Resource/ResourceManager.hpp>

#include <imgui.h>

using namespace Ilum;

template <typename _Ty>
class MaterialNode
{
  public:
	static _Ty &GetInstance()
	{
		static _Ty node;
		return node;
	}

	virtual MaterialNodeDesc Create(size_t &handle) = 0;

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) = 0;

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) = 0;
};

#define CONFIGURATION_MATERIAL_NODE(NODE)                                                                                                                         \
	extern "C"                                                                                                                                                    \
	{                                                                                                                                                             \
		EXPORT_API void Create(MaterialNodeDesc *desc, size_t *handle)                                                                                            \
		{                                                                                                                                                         \
			*desc = NODE::GetInstance().Create(*handle);                                                                                                          \
		}                                                                                                                                                         \
		EXPORT_API void OnImGui(MaterialNodeDesc *desc, Editor *editor, ImGuiContext *context)                                                                    \
		{                                                                                                                                                         \
			ImGui::SetCurrentContext(context);                                                                                                                    \
			NODE::GetInstance().OnImGui(*desc, editor);                                                                                                           \
		}                                                                                                                                                         \
		EXPORT_API void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) \
		{                                                                                                                                                         \
			NODE::GetInstance().EmitHLSL(node_desc, graph_desc, manager, context);                                                                               \
		}                                                                                                                                                         \
	}


================================================
FILE: Source/Plugin/MaterialNode/Input/RGB.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class RGB : public MaterialNode<RGB>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("RGB")
		    .SetCategory("Input")
		    .Output(handle++, "Color", MaterialNodePin::Type::RGB, glm::vec3(0.f));
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		glm::vec3 color = *node_desc.GetPin("Color").variant.Convert<glm::vec3>();
		context->variables.emplace_back(fmt::format("float3 S_{} = float3({}, {}, {});", node_desc.GetPin("Color").handle, color.x, color.y, color.z));
	}
};

CONFIGURATION_MATERIAL_NODE(RGB)

================================================
FILE: Source/Plugin/MaterialNode/Input/SurfaceInteraction.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class SurfaceInteraction : public MaterialNode<SurfaceInteraction>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("SurfaceInteraction")
		    .SetCategory("Input")
		    .Output(handle++, "Position", MaterialNodePin::Type::Float3)
		    .Output(handle++, "Normal", MaterialNodePin::Type::Float3)
		    .Output(handle++, "UV", MaterialNodePin::Type::Float3)
		    .Output(handle++, "dUVdx", MaterialNodePin::Type::Float3)
		    .Output(handle++, "dUVdy", MaterialNodePin::Type::Float3);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		context->variables.emplace_back(fmt::format("float3 S_{} = surface_interaction.isect.p;", node_desc.GetPin("Position").handle));
		context->variables.emplace_back(fmt::format("float3 S_{} = surface_interaction.isect.n;", node_desc.GetPin("Normal").handle));
		context->variables.emplace_back(fmt::format("float3 S_{} = float3(surface_interaction.isect.uv, 0.f);", node_desc.GetPin("UV").handle));
		context->variables.emplace_back(fmt::format("float3 S_{} = float3(surface_interaction.duvdx, 0.f);", node_desc.GetPin("dUVdx").handle));
		context->variables.emplace_back(fmt::format("float3 S_{} = float3(surface_interaction.duvdy, 0.f);", node_desc.GetPin("dUVdy").handle));
	}
};

CONFIGURATION_MATERIAL_NODE(SurfaceInteraction)

================================================
FILE: Source/Plugin/MaterialNode/Output/MaterialOutput.cpp
================================================
#include "IMaterialNode.hpp"

using namespace Ilum;

class MaterialOutput : public MaterialNode<MaterialOutput>
{
  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("MaterialOutput")
		    .SetCategory("Output")
		    .Input(handle++, "Surface", MaterialNodePin::Type::BSDF)
		    .Input(handle++, "Volume", MaterialNodePin::Type::Media);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		auto &surface_bsdf_pin = node_desc.GetPin("Surface");
		auto &volume_bsdf_pin  = node_desc.GetPin("Volume");

		// Surface BSDF
		if (graph_desc.HasLink(surface_bsdf_pin.handle))
		{
			auto &surface_bsdf_node = graph_desc.GetNode(graph_desc.LinkFrom(surface_bsdf_pin.handle));
			surface_bsdf_node.EmitHLSL(graph_desc, manager, context);
			context->output.bsdf = fmt::format("S_{}", surface_bsdf_node.GetPin(graph_desc.LinkFrom(surface_bsdf_pin.handle)).handle);
		}

		// Volume BSDF
		if (graph_desc.HasLink(volume_bsdf_pin.handle))
		{
		}
	}
};

CONFIGURATION_MATERIAL_NODE(MaterialOutput)

================================================
FILE: Source/Plugin/MaterialNode/Texture/ImageTexture.cpp
================================================
#include "IMaterialNode.hpp"

#include <Resource/Resource/Texture2D.hpp>

using namespace Ilum;

class ImageTexture : public MaterialNode<ImageTexture>
{
	std::vector<const char *> filters = {
	    "Nearest",
	    "Linear",
	};

	std::vector<const char *> address_modes = {
	    "Repeat",
	    "Mirror Repeat",
	    "Clamp Edge",
	    "Clamp Border",
	    "Mirror Clamp",
	};

	struct ImageConfig
	{
		SamplerDesc sampler;
		char        filename[200];
	};

  public:
	virtual MaterialNodeDesc Create(size_t &handle) override
	{
		MaterialNodeDesc desc;
		return desc
		    .SetHandle(handle++)
		    .SetName("ImageTexture")
		    .SetCategory("Texture")
		    .SetVariant(ImageConfig{})
		    .Input(handle++, "UV", MaterialNodePin::Type::RGB, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Input(handle++, "dUVdx", MaterialNodePin::Type::RGB, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Input(handle++, "dUVdy", MaterialNodePin::Type::RGB, MaterialNodePin::Type::RGB | MaterialNodePin::Type::Float3, glm::vec3(0.f))
		    .Output(handle++, "Color", MaterialNodePin::Type::RGB)
		    .Output(handle++, "Alpha", MaterialNodePin::Type::Float);
	}

	virtual void OnImGui(MaterialNodeDesc &node_desc, Editor *editor) override
	{
		ImageConfig &config = *node_desc.GetVariant().Convert<ImageConfig>();

		auto edit_filter = [&](const std::string &name, size_t *filter) {
			ImGui::PushID(name.c_str());
			bool update = false;
			if (ImGui::BeginCombo("", name.c_str()))
			{
				for (size_t i = 0; i < filters.size(); i++)
				{
					const bool is_selected = i == *filter;
					if (ImGui::Selectable(filters[i], is_selected))
					{
						*filter = i;
						update  = true;
					}
					if (is_selected)
					{
						ImGui::SetItemDefaultFocus();
					}
				}
				ImGui::EndCombo();
			}
			ImGui::PopID();
			return update;
		};

		auto edit_address_mode = [&](const std::string &name, size_t *address_mode) {
			ImGui::PushID(name.c_str());
			bool update = false;
			if (ImGui::BeginCombo("", name.c_str()))
			{
				for (size_t i = 0; i < address_modes.size(); i++)
				{
					const bool is_selected = i == *address_mode;
					if (ImGui::Selectable(address_modes[i], is_selected))
					{
						*address_mode = i;
						update        = true;
					}
					if (is_selected)
					{
						ImGui::SetItemDefaultFocus();
					}
				}
				ImGui::EndCombo();
			}
			ImGui::PopID();
			return update;
		};

		RHIFilter filter = config.sampler.min_filter;
		RHIAddressMode address_mode = config.sampler.address_mode_u;

		if (edit_filter("Filter", (size_t*)(&filter)))
		{
			config.sampler.min_filter = filter;
			config.sampler.mag_filter = filter;
			config.sampler.mipmap_mode = static_cast<RHIMipmapMode>(filter);
		}

		if (edit_address_mode("Address", (size_t *) (&address_mode)))
		{
			config.sampler.address_mode_u = address_mode;
			config.sampler.address_mode_v = address_mode;
			config.sampler.address_mode_w = address_mode;
		}

		auto *resource_manager = editor->GetRenderer()->GetResourceManager();
		if (resource_manager->Has<ResourceType::Texture2D>(config.filename))
		{
			if (ImGui::ImageButton(resource_manager->Get<ResourceType::Texture2D>(config.filename)->GetTexture(), ImVec2(100, 100)))
			{
				std::memset(config.filename, '\0', 200);
			}
		}
		else
		{
			ImGui::Button(config.filename, ImVec2(100.f, 100.f));
		}

		if (ImGui::BeginDragDropTarget())
		{
			if (const auto *pay_load = ImGui::AcceptDragDropPayload("Texture2D"))
			{
				std::memset(config.filename, '\0', 200);
				std::memcpy(config.filename, pay_load->Data, std::strlen(static_cast<const char *>(pay_load->Data)));
			}
			ImGui::EndDragDropTarget();
		}
	}

	virtual void EmitHLSL(const MaterialNodeDesc &node_desc, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) override
	{
		if (context->IsCompiled(node_desc))
		{
			return;
		}

		auto *config = node_desc.GetVariant().Convert<ImageConfig>();

		context->samplers[fmt::format("sampler_{}", node_desc.GetHandle())] = config->sampler;
		context->textures[fmt::format("texture_{}", node_desc.GetHandle())] = std::string(config->filename);

		std::map<std::string, std::string> parameters;

		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("UV"), graph_desc, manager, context);
		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("dUVdx"), graph_desc, manager, context);
		context->SetParameter<glm::vec3>(parameters, node_desc.GetPin("dUVdy"), graph_desc, manager, context);

		context->variables.emplace_back(fmt::format("float4 S_{} = SampleTexture2D(material_data.texture_{}, material_data.sampler_{}, {}.xy, {}.xy, {}.xy);", node_desc.GetHandle(), node_desc.GetHandle(), node_desc.GetHandle(), parameters["UV"], parameters["dUVdx"], parameters["dUVdy"]));
		context->variables.emplace_back(fmt::format("float3 S_{} = S_{}.xyz;", node_desc.GetPin("Color").handle, node_desc.GetHandle()));
		context->variables.emplace_back(fmt::format("float S_{} = S_{}.w;", node_desc.GetPin("Alpha").handle, node_desc.GetHandle()));
	}
};

CONFIGURATION_MATERIAL_NODE(ImageTexture)

================================================
FILE: Source/Plugin/MaterialNode/xmake.lua
================================================
function add_material_node_plugin(category, name)
    target(string.format("Material.%s.%s", category, name))

    set_kind("shared")
    set_group(string.format("Plugin/MaterialNode/%s", category))

    add_rules("plugin")
    add_files(string.format("%s/%s.cpp", category, name))
    add_headerfiles("IMaterialNode.hpp")
    add_includedirs("./")
    add_deps("Core", "RHI", "Material", "Renderer", "Editor", "Resource")
    add_packages("imgui")

    target("Plugin")
        add_deps(string.format("Material.%s.%s", category, name))
    target_end()

    target_end()
end

add_material_node_plugin("Output", "MaterialOutput")
add_material_node_plugin("Texture", "ImageTexture")
add_material_node_plugin("Input", "RGB")
add_material_node_plugin("Input", "SurfaceInteraction")
add_material_node_plugin("Converter", "Calculate")
add_material_node_plugin("Converter", "VectorCalculate")
add_material_node_plugin("Converter", "VectorMerge")
add_material_node_plugin("Converter", "VectorSplit")
add_material_node_plugin("Converter", "SRGBToLinear")
add_material_node_plugin("BSDF", "DiffuseMaterial")
add_material_node_plugin("BSDF", "DielectricMaterial")
add_material_node_plugin("BSDF", "ConductorMaterial")
add_material_node_plugin("BSDF", "ThinDielectricMaterial")
add_material_node_plugin("BSDF", "DisneyMaterial")
add_material_node_plugin("BSDF", "MixMaterial")
add_material_node_plugin("BSDF", "MaskedMaterial")

================================================
FILE: Source/Plugin/RHI/CUDA/Buffer.cpp
================================================
#include "Buffer.hpp"

namespace Ilum::CUDA
{
Buffer::Buffer(RHIDevice *device, const BufferDesc &desc, HANDLE mem_handle) :
    RHIBuffer(device, desc)
{
	cudaExternalMemoryHandleDesc cuda_external_memory_handle_desc = {};

#ifdef _WIN64
	cuda_external_memory_handle_desc.type                = cudaExternalMemoryHandleTypeOpaqueWin32;
	cuda_external_memory_handle_desc.handle.win32.handle = mem_handle;
#else
	cuda_external_memory_handle_desc.type      = cudaExternalMemoryHandleTypeOpaqueFd;
	cuda_external_memory_handle_desc.handle.fd = mem_handle;
#endif
	cuda_external_memory_handle_desc.size = desc.size;

	cudaImportExternalMemory(&m_memory, &cuda_external_memory_handle_desc);

	cudaExternalMemoryBufferDesc cuda_desc = {};

	cuda_desc.size = desc.size;
	cuda_desc.offset = 0;
	cuda_desc.flags  = 0;

	cudaExternalMemoryGetMappedBuffer((void **) &m_handle, m_memory, &cuda_desc);
}

Buffer::~Buffer()
{
	cudaFree(m_handle);
}

void Buffer::CopyToDevice(const void *data, size_t size, size_t offset)
{
	cudaMemcpy(m_handle, data, size, cudaMemcpyHostToDevice);
}

void Buffer::CopyToHost(void *data, size_t size, size_t offset)
{
	cudaMemcpy(data, m_handle, size, cudaMemcpyDeviceToHost);
}

void *Buffer::Map()
{
	if (m_desc.memory != RHIMemoryUsage::GPU_Only)
	{
		return m_handle;
	}
	return nullptr;
}

void Buffer::Unmap()
{
}

void Buffer::Flush(size_t offset, size_t size)
{
}

void *Buffer::GetHandle() const
{
	return m_handle;
}

uint64_t Buffer::GetDeviceAddress() const
{
	return (uint64_t) m_handle;
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Buffer.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Buffer : public RHIBuffer
{
  public:
	Buffer(RHIDevice *device, const BufferDesc &desc, HANDLE mem_handle);

	virtual ~Buffer() override;

	virtual void CopyToDevice(const void *data, size_t size, size_t offset = 0) override;

	virtual void CopyToHost(void *data, size_t size, size_t offset) override;

	virtual void *Map() override;

	virtual void Unmap() override;

	virtual void Flush(size_t offset, size_t size) override;

	void *GetHandle() const;

	uint64_t GetDeviceAddress() const;

  private:
	void *m_handle = nullptr;
	cudaExternalMemory_t m_memory = nullptr;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/CUDA.cpp
================================================
#include "Fwd.hpp"

#include "Buffer.hpp"
#include "Command.hpp"
#include "Descriptor.hpp"
#include "Device.hpp"
#include "Frame.hpp"
#include "PipelineState.hpp"
#include "Profiler.hpp"
#include "Queue.hpp"
#include "Sampler.hpp"
#include "Shader.hpp"
#include "Synchronization.hpp"
#include "Texture.hpp"

using namespace Ilum;
using namespace Ilum::CUDA;

#undef CreateSemaphore

extern "C"
{
	EXPORT_API RHIDevice *CreateDevice()
	{
		return new Device;
	}

	EXPORT_API RHIFrame *CreateFrame(Device *device)
	{
		return new Frame(device);
	}

	EXPORT_API RHIQueue *CreateQueue(Device *device)
	{
		return new Queue(device);
	}

	EXPORT_API RHITexture *MapTextureVulkanToCUDA(Device *device, const TextureDesc &desc, HANDLE mem_handle, size_t memory_size)
	{
		return new Texture(device, desc, mem_handle, memory_size);
	}

	EXPORT_API RHIBuffer *MapBufferVulkanToCUDA(Device *device, const BufferDesc &desc, HANDLE mem_handle)
	{
		return new Buffer(device, desc, mem_handle);
	}

	EXPORT_API RHISemaphore *MapSemaphoreVulkanToCUDA(Device *device, HANDLE handle)
	{
		return new Semaphore(device, handle);
	}

	EXPORT_API RHIDescriptor *CreateDescriptor(Device *device, const ShaderMeta &meta)
	{
		return new Descriptor(device, meta);
	}
}

================================================
FILE: Source/Plugin/RHI/CUDA/Command.cpp
================================================
#include "Command.hpp"
#include "Descriptor.hpp"
#include "Device.hpp"
#include "PipelineState.hpp"
#include "Shader.hpp"
#include "Texture.hpp"

namespace Ilum::CUDA
{
Command::Command(RHIDevice *device, RHIQueueFamily family) :
    RHICommand(device, family)
{
}

Command::~Command()
{
	m_calls.clear();
	p_descriptor     = nullptr;
	p_pipeline_state = nullptr;
}

void Command::SetName(const std::string &name)
{
}

void Command::Begin()
{
	m_state = CommandState::Recording;
	m_calls.clear();
}

void Command::End()
{
	m_state = CommandState::Executable;
}

void Command::BeginMarker(const std::string &name, float r, float g, float b, float a)
{
}

void Command::EndMarker()
{
}

void Command::BeginRenderPass(RHIRenderTarget *render_target)
{
}

void Command::EndRenderPass()
{
}

void Command::BindVertexBuffer(uint32_t binding, RHIBuffer *vertex_buffer)
{
}

void Command::BindIndexBuffer(RHIBuffer *index_buffer, bool is_short)
{
}

void Command::BindDescriptor(RHIDescriptor *descriptor)
{
	p_descriptor = descriptor;
}

void Command::BindPipelineState(RHIPipelineState *pipeline_state)
{
	p_pipeline_state = pipeline_state;
}

void Command::SetViewport(float width, float height, float x, float y)
{
}

void Command::SetScissor(uint32_t width, uint32_t height, int32_t offset_x, int32_t offset_y)
{
}

void Command::Dispatch(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z)
{
	assert(p_descriptor != nullptr && p_pipeline_state != nullptr);

	m_calls.emplace_back([=]() {
		for (auto &[stage, shader] : p_pipeline_state->GetShaders())
		{
			if (stage & RHIShaderStage::Compute)
			{
				auto &param_data = static_cast<Descriptor *>(p_descriptor)->GetParamData();
				if (shader)
				{
					auto *cuda_kernal     = static_cast<const Shader *>(shader);
					auto  kernal_function = cuda_kernal->GetFunction();
					auto  global_param    = cuda_kernal->GetGlobalParam();

					cuMemcpyHtoD(global_param, param_data.data(), param_data.size());

					cuLaunchKernel(
					    kernal_function,
					    (thread_x + block_x - 1) / block_x,
					    (thread_y + block_y - 1) / block_y,
					    (thread_z + block_z - 1) / block_z,
					    block_x, block_y, block_z, 0,
					    static_cast<Device *>(p_device)->GetSteam(), nullptr, nullptr);

					cuMemcpyDtoH(param_data.data(), global_param, param_data.size());

					cudaDeviceSynchronize();
				}
			}
		}
	});
}

void Command::DispatchIndirect(RHIBuffer *buffer, size_t offset)
{
}

void Command::Draw(uint32_t vertex_count, uint32_t instance_count, uint32_t first_vertex, uint32_t first_instance)
{
}

void Command::DrawIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)
{
}

void Command::DrawIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride)
{
}

void Command::DrawIndexed(uint32_t index_count, uint32_t instance_count, uint32_t first_index, uint32_t vertex_offset, uint32_t first_instance)
{
}

void Command::DrawIndexedIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)
{
}

void Command::DrawIndexedIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride)
{
}

void Command::DrawMeshTask(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z)
{
}

void Command::DrawMeshTasksIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)
{
}

void Command::DrawMeshTasksIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride)
{
}

void Command::TraceRay(uint32_t width, uint32_t height, uint32_t depth)
{
}

void Command::CopyBufferToTexture(RHIBuffer *src_buffer, RHITexture *dst_texture, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count)
{
}

void Command::CopyTextureToBuffer(RHITexture *src_texture, RHIBuffer *dst_buffer, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count)
{
}

void Command::CopyBufferToBuffer(RHIBuffer *src_buffer, RHIBuffer *dst_buffer, size_t size, size_t src_offset, size_t dst_offset)
{
}

void Command::GenerateMipmaps(RHITexture *texture, RHIResourceState initial_state, RHIFilter filter)
{
}

void Command::BlitTexture(RHITexture *src_texture, const TextureRange &src_range, const RHIResourceState &src_state, RHITexture *dst_texture, const TextureRange &dst_range, const RHIResourceState &dst_state, RHIFilter filter)
{
}

void Command::FillBuffer(RHIBuffer *buffer, RHIResourceState state, size_t size, size_t offset, uint32_t data)
{
}

void Command::FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, const glm::vec4 &color)
{
}

void Command::FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, float depth)
{
}

void Command::ResourceStateTransition(const std::vector<TextureStateTransition> &texture_transitions, const std::vector<BufferStateTransition> &buffer_transitions)
{
}

void Command::Execute()
{
	for (auto &task : m_calls)
	{
		task();
	}
}

void Command::Execute(std::function<void(void)> &&task)
{
	m_calls.emplace_back(std::move(task));
}

void Command::EventRecord(cudaEvent_t &cuda_event)
{
	m_calls.emplace_back([&]() {
		cudaEventRecord(cuda_event, static_cast<Device *>(p_device)->GetSteam());
	});
}

void Command::EventElapsedTime(cudaEvent_t begin, cudaEvent_t end, float &time)
{
	m_calls.emplace_back([&]() {
		cudaEventSynchronize(end);
		auto error = cudaEventElapsedTime(&time, begin, end);
	});
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Command.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Command : public RHICommand
{
  public:
	Command(RHIDevice *device, RHIQueueFamily family);

	virtual ~Command();

	virtual void SetName(const std::string &name);

	virtual void Begin() override;
	virtual void End() override;

	virtual void BeginMarker(const std::string &name, float r = 1.f, float g = 1.f, float b = 1.f, float a = 1.f) override;
	virtual void EndMarker() override;

	virtual void BeginRenderPass(RHIRenderTarget *render_target) override;
	virtual void EndRenderPass() override;

	virtual void BindVertexBuffer(uint32_t binding, RHIBuffer *vertex_buffer) override;
	virtual void BindIndexBuffer(RHIBuffer *index_buffer, bool is_short = false) override;

	virtual void BindDescriptor(RHIDescriptor *descriptor) override;
	virtual void BindPipelineState(RHIPipelineState *pipeline_state) override;

	virtual void SetViewport(float width, float height, float x = 0.f, float y = 0.f) override;
	virtual void SetScissor(uint32_t width, uint32_t height, int32_t offset_x = 0, int32_t offset_y = 0) override;

	// Drawcall
	virtual void Dispatch(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z) override;
	virtual void DispatchIndirect(RHIBuffer *buffer, size_t offset) override;

	virtual void Draw(uint32_t vertex_count, uint32_t instance_count, uint32_t first_vertex, uint32_t first_instance) override;
	virtual void DrawIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride) override;
	virtual void DrawIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) override;

	virtual void DrawIndexed(uint32_t index_count, uint32_t instance_count, uint32_t first_index, uint32_t vertex_offset, uint32_t first_instance) override;
	virtual void DrawIndexedIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride) override;
	virtual void DrawIndexedIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) override;

	virtual void DrawMeshTask(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z) override;
	virtual void DrawMeshTasksIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride) override;
	virtual void DrawMeshTasksIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) override;

	virtual void TraceRay(uint32_t width, uint32_t height, uint32_t depth) override;

	// Resource Copy
	virtual void CopyBufferToTexture(RHIBuffer *src_buffer, RHITexture *dst_texture, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count) override;
	virtual void CopyTextureToBuffer(RHITexture *src_texture, RHIBuffer *dst_buffer, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count) override;
	virtual void CopyBufferToBuffer(RHIBuffer *src_buffer, RHIBuffer *dst_buffer, size_t size, size_t src_offset, size_t dst_offset) override;

	virtual void GenerateMipmaps(RHITexture *texture, RHIResourceState initial_state, RHIFilter filter) override;
	virtual void BlitTexture(RHITexture *src_texture, const TextureRange &src_range, const RHIResourceState &src_state, RHITexture *dst_texture, const TextureRange &dst_range, const RHIResourceState &dst_state, RHIFilter filter = RHIFilter::Linear) override;

	virtual void FillBuffer(RHIBuffer *buffer, RHIResourceState state, size_t size, size_t offset, uint32_t data) override;
	virtual void FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, const glm::vec4 &color) override;
	virtual void FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, float depth) override;

	// Resource Barrier
	virtual void ResourceStateTransition(const std::vector<TextureStateTransition> &texture_transitions, const std::vector<BufferStateTransition> &buffer_transitions) override;

	void Execute();

	void Execute(std::function<void(void)> &&task);

	void EventRecord(cudaEvent_t &cuda_event);

	void EventElapsedTime(cudaEvent_t begin, cudaEvent_t end, float &time);

  private:
	RHIDescriptor    *p_descriptor     = nullptr;
	RHIPipelineState *p_pipeline_state = nullptr;

	std::vector<std::function<void()>> m_calls;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Descriptor.cpp
================================================
#include "Descriptor.hpp"
#include "Buffer.hpp"
#include "Texture.hpp"

namespace Ilum::CUDA
{
Descriptor::Descriptor(RHIDevice *device, const ShaderMeta &meta) :
    RHIDescriptor(device, meta)
{
	std::map<size_t, std::string> resource_orders;

	for (auto &constant : meta.constants)
	{
		resource_orders[constant.spirv_id] = constant.name;
		m_resource_sizes[constant.name]    = constant.size;
	}
	for (auto &descriptor : meta.descriptors)
	{
		resource_orders[descriptor.spirv_id] = descriptor.name;
		m_resource_sizes[descriptor.name]    = sizeof(void *);
		if (descriptor.type == DescriptorType::StructuredBuffer)
		{
			m_resource_sizes[descriptor.name] += sizeof(size_t);
		}
		m_resource_type[descriptor.name] = (size_t) descriptor.type;
	}

	size_t offset = 0;
	for (auto &[spirv_id, name] : resource_orders)
	{
		m_resource_offsets[name] = offset;
		offset += m_resource_sizes[name];
	}

	m_param_data.resize(offset);
}

RHIDescriptor &Descriptor::BindTexture(const std::string &name, RHITexture *texture, RHITextureDimension dimension)
{
	if (m_resource_offsets.find(name) == m_resource_offsets.end())
	{
		return *this;
	}

	size_t   offset         = m_resource_offsets[name];
	const uint64_t* texture_handle = nullptr;
	if (m_resource_type[name] == (size_t) DescriptorType::TextureUAV)
	{
		texture_handle = static_cast<Texture *>(texture)->GetSurfaceHostHandle().data();
	}
	else if (m_resource_type[name] == (size_t) DescriptorType::TextureSRV)
	{
		texture_handle = static_cast<Texture *>(texture)->GetTextureHandle();
	}

	std::memcpy(m_param_data.data() + offset, texture_handle, sizeof(uint64_t));
	return *this;
}

RHIDescriptor &Descriptor::BindTexture(const std::string &name, RHITexture *texture, const TextureRange &range)
{
	return *this;
}

RHIDescriptor &Descriptor::BindTexture(const std::string &name, const std::vector<RHITexture *> &textures, RHITextureDimension dimension)
{
	return *this;
}

RHIDescriptor &Descriptor::BindSampler(const std::string &name, RHISampler *sampler)
{
	return *this;
}

RHIDescriptor &Descriptor::BindSampler(const std::string &name, const std::vector<RHISampler *> &samplers)
{
	return *this;
}

RHIDescriptor &Descriptor::BindBuffer(const std::string &name, RHIBuffer *buffer)
{
	if (m_resource_offsets.find(name) == m_resource_offsets.end())
	{
		return *this;
	}

	size_t offset        = m_resource_offsets[name];
	size_t stride        = static_cast<Buffer *>(buffer)->GetDesc().stride;
	void  *buffer_handle = static_cast<Buffer *>(buffer)->GetHandle();
	std::memcpy(m_param_data.data() + offset, &buffer_handle, sizeof(buffer_handle));
	if (m_resource_type[name] == (size_t) DescriptorType::StructuredBuffer)
	{
		std::memcpy(m_param_data.data() + offset + sizeof(buffer_handle), &stride, sizeof(stride));
	}
	return *this;
}

RHIDescriptor &Descriptor::BindBuffer(const std::string &name, RHIBuffer *buffer, size_t offset, size_t range)
{
	return *this;
}

RHIDescriptor &Descriptor::BindBuffer(const std::string &name, const std::vector<RHIBuffer *> &buffers)
{
	return *this;
}

RHIDescriptor &Descriptor::BindConstant(const std::string &name, const void *constant)
{
	return *this;
}

RHIDescriptor &Descriptor::BindAccelerationStructure(const std::string &name, RHIAccelerationStructure *acceleration_structure)
{
	return *this;
}

std::vector<uint8_t> &Descriptor::GetParamData()
{
	return m_param_data;
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Descriptor.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Descriptor : public RHIDescriptor
{
  public:
	Descriptor(RHIDevice *device, const ShaderMeta &meta);

	virtual RHIDescriptor &BindTexture(const std::string &name, RHITexture *texture, RHITextureDimension dimension) override;
	virtual RHIDescriptor &BindTexture(const std::string &name, RHITexture *texture, const TextureRange &range) override;
	virtual RHIDescriptor &BindTexture(const std::string &name, const std::vector<RHITexture *> &textures, RHITextureDimension dimension) override;

	virtual RHIDescriptor &BindSampler(const std::string &name, RHISampler *sampler) override;
	virtual RHIDescriptor &BindSampler(const std::string &name, const std::vector<RHISampler *> &samplers) override;

	virtual RHIDescriptor &BindBuffer(const std::string &name, RHIBuffer *buffer) override;
	virtual RHIDescriptor &BindBuffer(const std::string &name, RHIBuffer *buffer, size_t offset, size_t range) override;
	virtual RHIDescriptor &BindBuffer(const std::string &name, const std::vector<RHIBuffer *> &buffers) override;

	virtual RHIDescriptor &BindConstant(const std::string &name, const void *constant) override;

	virtual RHIDescriptor &BindAccelerationStructure(const std::string &name, RHIAccelerationStructure *acceleration_structure) override;

	std::vector<uint8_t> &GetParamData();

  private:
	std::map<std::string, size_t> m_resource_type;
	std::map<std::string, size_t> m_resource_offsets;
	std::map<std::string, size_t> m_resource_sizes;
	std::vector<uint8_t>          m_param_data;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Device.cpp
================================================
#include "Device.hpp"

#include <cuda_runtime.h>

namespace Ilum::CUDA
{
Device::Device() :
    RHIDevice("CUDA")
{
	LOG_INFO("Initializing RHI backend CUDA...");

	cudaDeviceProp prop;
	cudaGetDeviceProperties(&prop, 0);
	m_name = prop.name;

	cuInit(0);
	cuDeviceGet(&m_device, 0);
	cuCtxCreate(&m_context, 0, m_device);
	cudaStreamCreate(&m_steam);
}

Device::~Device()
{
	cuCtxDestroy(m_context);
}

void Device::WaitIdle()
{
	cudaStreamSynchronize(m_steam);
}

bool Device::IsFeatureSupport(RHIFeature feature)
{
	return false;
}

cudaStream_t Device::GetSteam() const
{
	return m_steam;
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Device.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Device : public RHIDevice
{
  public:
	Device();

	~Device();

	virtual void WaitIdle() override;

	virtual bool IsFeatureSupport(RHIFeature feature) override;

	cudaStream_t GetSteam() const;

  private:
	CUcontext m_context;
	CUdevice  m_device;
	cudaStream_t m_steam;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Frame.cpp
================================================
#include "Frame.hpp"
#include "Command.hpp"

namespace Ilum::CUDA
{
Frame::Frame(RHIDevice *device):
    RHIFrame(device)
{
}

RHIFence *Frame::AllocateFence()
{
	return nullptr;
}

RHISemaphore *Frame::AllocateSemaphore()
{
	return nullptr;
}

RHICommand *Frame::AllocateCommand(RHIQueueFamily family)
{
	while (m_current_cmd >= m_cmds.size())
	{
		m_cmds.emplace_back(std::make_unique<Command>(p_device, family));
	}

	return m_cmds[m_current_cmd++].get();
}

void Frame::Reset()
{
	m_current_cmd = 0;
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Frame.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Command;

class Frame : public RHIFrame
{
  public:
	Frame(RHIDevice *device);

	~Frame() = default;

	virtual RHIFence *AllocateFence() override;

	virtual RHISemaphore *AllocateSemaphore() override;

	virtual RHICommand *AllocateCommand(RHIQueueFamily family) override;

	virtual RHIDescriptor* AllocateDescriptor(const ShaderMeta& meta) override
	{
		return nullptr;
	}

	void Reset();

  private:
	std::vector<std::unique_ptr<Command>> m_cmds;
	uint32_t                              m_current_cmd = 0;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Fwd.hpp
================================================
#pragma once

#include <array>
#include <map>
#include <memory>
#include <optional>
#include <vector>

#include <volk.h>

#include <cuda.h>
#include <cuda_runtime.h>

#include <Core/Core.hpp>

#include <RHI/RHIAccelerationStructure.hpp>
#include <RHI/RHIBuffer.hpp>
#include <RHI/RHICommand.hpp>
#include <RHI/RHIDefinitions.hpp>
#include <RHI/RHIDescriptor.hpp>
#include <RHI/RHIDevice.hpp>
#include <RHI/RHIFrame.hpp>
#include <RHI/RHIPipelineState.hpp>
#include <RHI/RHIProfiler.hpp>
#include <RHI/RHIQueue.hpp>
#include <RHI/RHIRenderTarget.hpp>
#include <RHI/RHISampler.hpp>
#include <RHI/RHIShader.hpp>
#include <RHI/RHISwapchain.hpp>
#include <RHI/RHISynchronization.hpp>
#include <RHI/RHITexture.hpp>

#ifdef _WIN64
#	include <Windows.h>
#endif        // _WIN64

namespace Ilum
{
namespace CUDA
{
class Buffer;
class Command;
class Descriptor;
class Device;
class Frame;
class PipelineState;
class Profiler;
class Queue;
class Sampler;
class Shader;
class Fence;
class Semaphore;
class Texture;
}        // namespace CUDA
}        // namespace Ilum

================================================
FILE: Source/Plugin/RHI/CUDA/PipelineState.cpp
================================================
#include "PipelineState.hpp"

namespace Ilum::CUDA
{
PipelineState::PipelineState(RHIDevice *device) :
    RHIPipelineState(device)
{
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/PipelineState.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class PipelineState : public RHIPipelineState
{
  public:
	PipelineState(RHIDevice *device);

	~PipelineState() = default;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Profiler.cpp
================================================
#include "Profiler.hpp"
#include "Device.hpp"
#include "Command.hpp"

namespace Ilum::CUDA
{
Profiler::Profiler(RHIDevice *device, uint32_t frame_count) :
    RHIProfiler(device, frame_count)
{
	m_start_events.resize(frame_count);
	m_end_events.resize(frame_count);

	for (uint32_t i = 0; i < frame_count; i++)
	{
		cudaEventCreate(&m_start_events[i]);
		cudaEventCreate(&m_end_events[i]);
	}
}

Profiler::~Profiler()
{
	for (uint32_t i = 0; i < m_frame_count; i++)
	{
		cudaEventDestroy(m_start_events[i]);
		cudaEventDestroy(m_end_events[i]);
	}
}

void Profiler::Begin(RHICommand *cmd_buffer, uint32_t frame_index)
{
	m_current_index = frame_index;

	m_state.thread_id = std::this_thread::get_id();

	cudaEventSynchronize(m_end_events[m_current_index]);
	cudaEventElapsedTime(&m_state.gpu_time, m_start_events[m_current_index], m_end_events[m_current_index]);

	static_cast<Command *>(cmd_buffer)->EventRecord(m_start_events[m_current_index]);
	m_state.cpu_time = std::chrono::duration<float, std::milli>(m_state.cpu_end - m_state.cpu_start).count();

	m_state.cpu_start = std::chrono::high_resolution_clock::now();
}

void Profiler::End(RHICommand *cmd_buffer)
{
	static_cast<Command *>(cmd_buffer)->EventRecord(m_end_events[m_current_index]);

	m_state.cpu_end = std::chrono::high_resolution_clock::now();
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Profiler.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Profiler : public RHIProfiler
{
  public:
	Profiler(RHIDevice *device, uint32_t frame_count);

	virtual ~Profiler() override;

	virtual void Begin(RHICommand *cmd_buffer, uint32_t frame_index) override;

	virtual void End(RHICommand *cmd_buffer) override;

  private:
	std::vector<cudaEvent_t> m_start_events;
	std::vector<cudaEvent_t> m_end_events;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Queue.cpp
================================================
#include "Queue.hpp"
#include "Command.hpp"
#include "Synchronization.hpp"

namespace Ilum::CUDA
{
Queue::Queue(RHIDevice *device) :
    RHIQueue(device)
{
}

void Queue::Wait()
{
	cudaDeviceSynchronize();
}

void Queue::Execute(RHIQueueFamily family, const std::vector<SubmitInfo> &submit_infos, RHIFence *fence)
{
	for (auto &submit_info : submit_infos)
	{
		for (auto &wait_semaphore : submit_info.wait_semaphores)
		{
			static_cast<Semaphore *>(wait_semaphore)->Wait();
		}
		for (auto &cmd_buffer : submit_info.cmd_buffers)
		{
			static_cast<Command *>(cmd_buffer)->Execute();
		}
		for (auto &signal_semaphore : submit_info.signal_semaphores)
		{
			static_cast<Semaphore *>(signal_semaphore)->Signal();
		}
	}
}

void Queue::Execute(RHICommand *cmd_buffer)
{
	static_cast<Command *>(cmd_buffer)->Execute();
	cudaDeviceSynchronize();
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Queue.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Queue : public RHIQueue
{
  public:
	Queue(RHIDevice *device);

	~Queue() = default;

	virtual void Execute(RHIQueueFamily family, const std::vector<SubmitInfo> &submit_infos, RHIFence *fence) override;

	// Immediate execution
	virtual void Execute(RHICommand *cmd_buffer) override;

	virtual void Wait() override;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Sampler.cpp
================================================
#include "Sampler.hpp"

namespace Ilum::CUDA
{
Sampler::Sampler(RHIDevice *device, const SamplerDesc &desc):
    RHISampler(device, desc)
{
}

void *Sampler::GetHandle() const
{
	return nullptr;
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Sampler.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Sampler : public RHISampler
{
  public:
	Sampler(RHIDevice *device, const SamplerDesc &desc);

	virtual ~Sampler() = default;

	void *GetHandle() const;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Shader.cpp
================================================
#include "Shader.hpp"

namespace Ilum::CUDA
{
Shader::Shader(RHIDevice *device, const std::string &entry_point, const std::vector<uint8_t> &source):
    RHIShader(device, entry_point, source)
{
	std::string ptx;
	ptx.resize(source.size());
	std::memcpy(ptx.data(), source.data(), source.size());

	cuModuleLoadData(&m_module, ptx.c_str());
	cuModuleGetFunction(&m_function, m_module, entry_point.c_str());
	cuModuleGetGlobal(&m_global_param, NULL, m_module, "SLANG_globalParams");
}

Shader::~Shader()
{
	cuModuleUnload(m_module);
}

CUfunction Shader::GetFunction() const
{
	return m_function;
}

CUdeviceptr Shader::GetGlobalParam() const
{
	return m_global_param;
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Shader.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Shader: public RHIShader
{
  public:
	Shader(RHIDevice *device, const std::string &entry_point, const std::vector<uint8_t> &source);

	~Shader();

	CUfunction GetFunction() const;

	CUdeviceptr GetGlobalParam() const;

  private:
	CUmodule    m_module       = {};
	CUfunction  m_function     = {};
	CUdeviceptr m_global_param = {};
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Synchronization.cpp
================================================
#include "Synchronization.hpp"
#include "Device.hpp"

namespace Ilum::CUDA
{

Semaphore::Semaphore(RHIDevice *device, HANDLE handle) :
    RHISemaphore(device)
{
	cudaExternalSemaphoreHandleDesc external_semaphore_handle_desc = {};

#ifdef _WIN64
	external_semaphore_handle_desc.type = cudaExternalSemaphoreHandleTypeOpaqueWin32;

	external_semaphore_handle_desc.handle.win32.handle = handle;
#else
	external_semaphore_handle_desc.type      = cudaExternalSemaphoreHandleTypeOpaqueFd;
	external_semaphore_handle_desc.handle.fd = handle;
#endif
	external_semaphore_handle_desc.flags = 0;

	cudaImportExternalSemaphore(&m_handle, &external_semaphore_handle_desc);
}

Semaphore::~Semaphore()
{
	cudaDestroyExternalSemaphore(m_handle);
}

void Semaphore::SetName(const std::string &name)
{
}

void Semaphore::Signal()
{
	cudaExternalSemaphoreSignalParams params = {};

	params.params.fence.value = 0;
	params.flags              = 0;

	cudaSignalExternalSemaphoresAsync(&m_handle, &params, 1, static_cast<Device*>(p_device)->GetSteam());
}

void Semaphore::Wait()
{
	cudaExternalSemaphoreWaitParams params = {};

	params.params.fence.value = 0;
	params.flags              = 0;

	cudaWaitExternalSemaphoresAsync(&m_handle, &params, 1, static_cast<Device *>(p_device)->GetSteam());
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Synchronization.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Semaphore : public RHISemaphore
{
  public:
	Semaphore(RHIDevice *device, HANDLE handle);

	~Semaphore();

	virtual void SetName(const std::string &name) override;

	void Signal();

	void Wait();

  private:
	cudaExternalSemaphore_t m_handle = nullptr;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Texture.cpp
================================================
#include "Texture.hpp"

namespace Ilum::CUDA
{
cudaChannelFormatDesc GetCUDAChannelFormatDesc(RHIFormat format)
{
	cudaChannelFormatDesc desc = {};

	switch (format)
	{
		case RHIFormat::Undefined:
			desc = cudaChannelFormatDesc{0, 0, 0, 0, cudaChannelFormatKindNone};
			break;
		case RHIFormat::R16_UINT:
			desc = cudaChannelFormatDesc{16, 0, 0, 0, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::R16_SINT:
			desc = cudaChannelFormatDesc{16, 0, 0, 0, cudaChannelFormatKindSigned};
			break;
		case RHIFormat::R16_FLOAT:
			desc = cudaChannelFormatDesc{16, 0, 0, 0, cudaChannelFormatKindFloat};
			break;
		case RHIFormat::R8G8B8A8_UNORM:
			desc = cudaChannelFormatDesc{8, 8, 8, 8, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::B8G8R8A8_UNORM:
			desc = cudaChannelFormatDesc{8, 8, 8, 8, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::R32_UINT:
			desc = cudaChannelFormatDesc{32, 0, 0, 0, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::R32_SINT:
			desc = cudaChannelFormatDesc{32, 0, 0, 0, cudaChannelFormatKindSigned};
			break;
		case RHIFormat::R32_FLOAT:
			desc = cudaChannelFormatDesc{32, 0, 0, 0, cudaChannelFormatKindFloat};
			break;
		case RHIFormat::D32_FLOAT:
			desc = cudaChannelFormatDesc{32, 0, 0, 0, cudaChannelFormatKindFloat};
			break;
		case RHIFormat::R16G16_UINT:
			desc = cudaChannelFormatDesc{16, 16, 0, 0, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::R16G16_SINT:
			desc = cudaChannelFormatDesc{16, 16, 0, 0, cudaChannelFormatKindSigned};
			break;
		case RHIFormat::R16G16_FLOAT:
			desc = cudaChannelFormatDesc{16, 16, 0, 0, cudaChannelFormatKindFloat};
			break;
		case RHIFormat::R16G16B16A16_UINT:
			desc = cudaChannelFormatDesc{16, 16, 16, 16, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::R16G16B16A16_SINT:
			desc = cudaChannelFormatDesc{16, 16, 16, 16, cudaChannelFormatKindSigned};
			break;
		case RHIFormat::R16G16B16A16_FLOAT:
			desc = cudaChannelFormatDesc{16, 16, 16, 16, cudaChannelFormatKindFloat};
			break;
		case RHIFormat::R32G32_UINT:
			desc = cudaChannelFormatDesc{32, 32, 0, 0, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::R32G32_SINT:
			desc = cudaChannelFormatDesc{32, 32, 0, 0, cudaChannelFormatKindSigned};
			break;
		case RHIFormat::R32G32_FLOAT:
			desc = cudaChannelFormatDesc{32, 32, 0, 0, cudaChannelFormatKindFloat};
			break;
		case RHIFormat::R32G32B32_UINT:
			desc = cudaChannelFormatDesc{32, 32, 32, 0, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::R32G32B32_SINT:
			desc = cudaChannelFormatDesc{32, 32, 32, 0, cudaChannelFormatKindSigned};
			break;
		case RHIFormat::R32G32B32_FLOAT:
			desc = cudaChannelFormatDesc{32, 32, 32, 0, cudaChannelFormatKindFloat};
			break;
		case RHIFormat::R32G32B32A32_UINT:
			desc = cudaChannelFormatDesc{32, 32, 32, 32, cudaChannelFormatKindUnsigned};
			break;
		case RHIFormat::R32G32B32A32_SINT:
			desc = cudaChannelFormatDesc{32, 32, 32, 32, cudaChannelFormatKindSigned};
			break;
		case RHIFormat::R32G32B32A32_FLOAT:
			desc = cudaChannelFormatDesc{32, 32, 32, 32, cudaChannelFormatKindFloat};
			break;
		default:
			break;
	}
	return desc;
}

Texture::Texture(RHIDevice *device, const TextureDesc &desc, HANDLE mem_handle, size_t memory_size) :
    RHITexture(device, desc), m_memory_size(memory_size)
{
	cudaExternalMemoryHandleDesc cuda_external_memory_handle_desc = {};

#ifdef _WIN64
	cuda_external_memory_handle_desc.type                = cudaExternalMemoryHandleTypeOpaqueWin32;
	cuda_external_memory_handle_desc.handle.win32.handle = mem_handle;
#else
	cuda_external_memory_handle_desc.type      = cudaExternalMemoryHandleTypeOpaqueFd;
	cuda_external_memory_handle_desc.handle.fd = mem_handle;
#endif
	cuda_external_memory_handle_desc.size = memory_size;

	cudaImportExternalMemory(&m_external_memory, &cuda_external_memory_handle_desc);

	cudaExtent            extent = {desc.width, desc.height, desc.depth - 1};
	cudaChannelFormatDesc format = GetCUDAChannelFormatDesc(desc.format);

	cudaExternalMemoryMipmappedArrayDesc cuda_external_memory_mipmapped_array_desc = {};

	cuda_external_memory_mipmapped_array_desc.offset     = 0;
	cuda_external_memory_mipmapped_array_desc.formatDesc = format;
	cuda_external_memory_mipmapped_array_desc.extent     = extent;
	cuda_external_memory_mipmapped_array_desc.flags      = 0;
	cuda_external_memory_mipmapped_array_desc.numLevels  = desc.mips;

	cudaExternalMemoryGetMappedMipmappedArray(&m_mipmapped_array, m_external_memory, &cuda_external_memory_mipmapped_array_desc);

	for (uint32_t mip_level = 0; mip_level < desc.mips; mip_level++)
	{
		cudaArray_t cuda_mip_level_array = {}, cuda_mip_level_array_orig = {};

		cudaResourceDesc resource_desc = {};

		cudaGetMipmappedArrayLevel(&cuda_mip_level_array, m_mipmapped_array, mip_level);

		uint32_t width  = (desc.width >> mip_level) ? (desc.width >> mip_level) : 1;
		uint32_t height = (desc.height >> mip_level) ? (desc.height >> mip_level) : 1;
		cudaMemcpy2DArrayToArray(cuda_mip_level_array_orig, 0, 0, cuda_mip_level_array, 0, 0, width * static_cast<size_t>(format.x + format.y + format.z + format.w) / 8ull, height, cudaMemcpyDeviceToDevice);

		resource_desc.resType         = cudaResourceTypeArray;
		resource_desc.res.array.array = cuda_mip_level_array;

		cudaSurfaceObject_t surface = {};
		cudaCreateSurfaceObject(&surface, &resource_desc);

		m_surfaces.push_back(surface);
	}

	cudaResourceDesc cuda_resource_desc = {};

	cuda_resource_desc.resType           = cudaResourceTypeMipmappedArray;
	cuda_resource_desc.res.mipmap.mipmap = m_mipmapped_array;

	cudaTextureDesc cuda_texture_desc = {};

	cuda_texture_desc.normalizedCoords    = true;
	cuda_texture_desc.filterMode          = cudaFilterModeLinear;
	cuda_texture_desc.mipmapFilterMode    = cudaFilterModeLinear;
	cuda_texture_desc.addressMode[0]      = cudaAddressModeClamp;
	cuda_texture_desc.addressMode[1]      = cudaAddressModeClamp;
	cuda_texture_desc.maxMipmapLevelClamp = static_cast<float>(m_desc.mips) - 1.f;
	cuda_texture_desc.readMode            = cudaReadModeElementType;

	cudaCreateTextureObject(&m_texture_handle, &cuda_resource_desc, &cuda_texture_desc, nullptr);

	cudaMalloc((void **) &m_surface_list, sizeof(cudaSurfaceObject_t) * m_desc.mips);
	cudaMemcpy(m_surface_list, m_surfaces.data(), sizeof(cudaSurfaceObject_t) * m_desc.mips, cudaMemcpyHostToDevice);
}

Texture::~Texture()
{
	p_device->WaitIdle();

	cudaDestroyTextureObject(m_texture_handle);

	for (auto &surface : m_surfaces)
	{
		cudaDestroySurfaceObject(surface);
	}
	m_surfaces.clear();

	if (m_surface_list)
	{
		cudaFree(m_surface_list);
	}

	if (m_external_memory)
	{
		cudaFreeMipmappedArray(m_mipmapped_array);
		cudaDestroyExternalMemory(m_external_memory);
	}
}

 size_t Texture::GetMemorySize() const
{
	 return m_memory_size;
 }

const cudaSurfaceObject_t *Texture::GetSurfaceDeviceHandle() const
{
	return m_surface_list;
}

const std::vector<cudaSurfaceObject_t> &Texture::GetSurfaceHostHandle() const
{
	return m_surfaces;
}

const cudaTextureObject_t *Texture::GetTextureHandle() const
{
	return &m_texture_handle;
}
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/CUDA/Texture.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::CUDA
{
class Texture : public RHITexture
{
  public:
	Texture(RHIDevice *device, const TextureDesc &desc, HANDLE mem_handle, size_t memory_size);

	virtual ~Texture() override;

	virtual size_t GetMemorySize() const override;

	const cudaSurfaceObject_t *GetSurfaceDeviceHandle() const;

	const std::vector<cudaSurfaceObject_t> &GetSurfaceHostHandle() const;

	const cudaTextureObject_t *GetTextureHandle() const;

  private:
	cudaTextureObject_t m_texture_handle;

	std::vector<cudaSurfaceObject_t> m_surfaces;
	cudaSurfaceObject_t             *m_surface_list = nullptr;

	cudaExternalMemory_t m_external_memory      = nullptr;
	cudaMipmappedArray_t m_mipmapped_array      = nullptr;

	size_t m_memory_size = 0;

	bool m_is_backbuffer = false;
};
}        // namespace Ilum::CUDA

================================================
FILE: Source/Plugin/RHI/Vulkan/AccelerationStructure.cpp
================================================
#include "AccelerationStructure.hpp"
#include "Buffer.hpp"
#include "Command.hpp"
#include "Device.hpp"

namespace Ilum::Vulkan
{
static inline size_t Align(size_t x, size_t alignment)
{
	return (x + (alignment - 1)) & ~(alignment - 1);
}

AccelerationStructure::AccelerationStructure(RHIDevice *device) :
    RHIAccelerationStructure(device)
{
}

AccelerationStructure ::~AccelerationStructure()
{
	if (m_handle)
	{
		p_device->WaitIdle();
		vkDestroyAccelerationStructureKHR(static_cast<Device *>(p_device)->GetDevice(), m_handle, nullptr);
		m_handle = VK_NULL_HANDLE;
	}
}

void AccelerationStructure::Update(RHICommand *cmd_buffer, const TLASDesc &desc)
{
	std::vector<VkAccelerationStructureInstanceKHR> instances;
	instances.reserve(desc.instances.size());

	for (auto &instance : desc.instances)
	{
		VkAccelerationStructureInstanceKHR vk_instance = {};

		auto transform = glm::mat3x4(glm::transpose(instance.transform));

		std::memcpy(&vk_instance.transform, &transform, sizeof(VkTransformMatrixKHR));
		vk_instance.instanceCustomIndex                    = 0;
		vk_instance.mask                                   = 0xFF;
		vk_instance.instanceShaderBindingTableRecordOffset = instance.material_id;
		vk_instance.flags                                  = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR;
		vk_instance.accelerationStructureReference         = static_cast<AccelerationStructure *>(instance.blas)->GetDeviceAddress();

		instances.emplace_back(std::move(vk_instance));
	}

	if (!m_instance_buffer || m_instance_buffer->GetDesc().size < instances.size() * sizeof(VkAccelerationStructureInstanceKHR))
	{
		m_instance_buffer = std::make_unique<Buffer>(
		    p_device,
		    BufferDesc{
		        "TLAS Instance Buffer",
		        RHIBufferUsage::AccelerationStructure | RHIBufferUsage::Transfer,
		        RHIMemoryUsage::CPU_TO_GPU,
		        instances.size() * sizeof(VkAccelerationStructureInstanceKHR)});
	}

	m_instance_buffer->CopyToDevice(instances.data(), instances.size() * sizeof(VkAccelerationStructureInstanceKHR), 0);

	VkAccelerationStructureGeometryKHR as_geometry    = {};
	as_geometry.sType                                 = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
	as_geometry.geometryType                          = VK_GEOMETRY_TYPE_INSTANCES_KHR;
	as_geometry.flags                                 = VK_GEOMETRY_OPAQUE_BIT_KHR;
	as_geometry.geometry.instances.sType              = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR;
	as_geometry.geometry.instances.arrayOfPointers    = VK_FALSE;
	as_geometry.geometry.instances.data.deviceAddress = m_instance_buffer->GetDeviceAddress();

	VkAccelerationStructureBuildRangeInfoKHR range_info = {};
	range_info.primitiveCount                           = static_cast<uint32_t>(desc.instances.size());

	Update(cmd_buffer, as_geometry, range_info, VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR);

	if (!desc.name.empty())
	{
		VkDebugUtilsObjectNameInfoEXT info = {};
		info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
		info.pObjectName                   = desc.name.c_str();
		info.objectHandle                  = (uint64_t) m_handle;
		info.objectType                    = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR;
		static_cast<Device *>(p_device)->SetVulkanObjectName(info);
	}
}

void AccelerationStructure::Update(RHICommand *cmd_buffer, const BLASDesc &desc)
{
	VkAccelerationStructureGeometryKHR as_geometry             = {};
	as_geometry.sType                                          = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
	as_geometry.flags                                          = VK_GEOMETRY_OPAQUE_BIT_KHR;
	as_geometry.geometryType                                   = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
	as_geometry.geometry.triangles.sType                       = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR;
	as_geometry.geometry.triangles.vertexFormat                = VK_FORMAT_R32G32B32_SFLOAT;
	as_geometry.geometry.triangles.vertexData.deviceAddress    = static_cast<Buffer *>(desc.vertex_buffer)->GetDeviceAddress();
	as_geometry.geometry.triangles.maxVertex                   = desc.vertices_count;
	as_geometry.geometry.triangles.vertexStride                = 64;        // 4 x vec4
	as_geometry.geometry.triangles.indexType                   = VK_INDEX_TYPE_UINT32;
	as_geometry.geometry.triangles.indexData.deviceAddress     = static_cast<Buffer *>(desc.index_buffer)->GetDeviceAddress();
	as_geometry.geometry.triangles.transformData.deviceAddress = 0;
	as_geometry.geometry.triangles.transformData.hostAddress   = nullptr;

	VkAccelerationStructureBuildRangeInfoKHR range_info = {};

	range_info.primitiveCount  = desc.indices_count / 3;
	range_info.primitiveOffset = desc.indices_offset * sizeof(uint32_t);
	range_info.firstVertex     = desc.vertices_offset;
	range_info.transformOffset = 0;

	Update(cmd_buffer, as_geometry, range_info, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR);

	if (!desc.name.empty())
	{
		VkDebugUtilsObjectNameInfoEXT info = {};
		info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
		info.pObjectName                   = desc.name.c_str();
		info.objectHandle                  = (uint64_t) m_handle;
		info.objectType                    = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR;
		static_cast<Device *>(p_device)->SetVulkanObjectName(info);
	}
}

VkAccelerationStructureKHR AccelerationStructure::GetHandle() const
{
	return m_handle;
}

uint64_t AccelerationStructure::GetDeviceAddress() const
{
	return m_device_address;
}

void AccelerationStructure::Update(RHICommand *cmd_buffer, const VkAccelerationStructureGeometryKHR &geometry, const VkAccelerationStructureBuildRangeInfoKHR &range_info, VkAccelerationStructureTypeKHR type)
{
	VkAccelerationStructureBuildGeometryInfoKHR build_geometry_info = {};

	build_geometry_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
	build_geometry_info.type  = type;
	build_geometry_info.flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR | VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR;

	if (m_handle)
	{
		build_geometry_info.mode                     = VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR;
		build_geometry_info.srcAccelerationStructure = m_handle;
	}
	else
	{
		build_geometry_info.mode = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR;
	}

	build_geometry_info.geometryCount = 1;
	build_geometry_info.pGeometries   = &geometry;

	// Get required build sizes
	VkAccelerationStructureBuildSizesInfoKHR build_sizes_info = {};
	build_sizes_info.sType                                    = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR;
	vkGetAccelerationStructureBuildSizesKHR(
	    static_cast<Device *>(p_device)->GetDevice(),
	    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR,
	    &build_geometry_info,
	    &range_info.primitiveCount,
	    &build_sizes_info);

	// Create a buffer for the acceleration structure
	if (!m_buffer || m_buffer->GetDesc().size != build_sizes_info.accelerationStructureSize)
	{
		m_buffer = std::make_unique<Buffer>(
		    p_device,
		    BufferDesc{
		        "AS Buffer",
		        RHIBufferUsage::AccelerationStructure,
		        RHIMemoryUsage::GPU_Only,
		        build_sizes_info.accelerationStructureSize});

		if (m_handle)
		{
			p_device->WaitIdle();
			vkDestroyAccelerationStructureKHR(static_cast<Device *>(p_device)->GetDevice(), m_handle, nullptr);
		}

		VkAccelerationStructureCreateInfoKHR acceleration_structure_create_info = {};
		acceleration_structure_create_info.sType                                = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR;
		acceleration_structure_create_info.buffer                               = m_buffer->GetHandle();
		acceleration_structure_create_info.size                                 = build_sizes_info.accelerationStructureSize;
		acceleration_structure_create_info.type                                 = type;
		vkCreateAccelerationStructureKHR(static_cast<Device *>(p_device)->GetDevice(), &acceleration_structure_create_info, nullptr, &m_handle);

		build_geometry_info.mode                     = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR;
		build_geometry_info.srcAccelerationStructure = VK_NULL_HANDLE;
	}

	// Get the acceleration structure's handle
	VkAccelerationStructureDeviceAddressInfoKHR acceleration_device_address_info = {};
	acceleration_device_address_info.sType                                       = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR;
	acceleration_device_address_info.accelerationStructure                       = m_handle;
	m_device_address                                                             = vkGetAccelerationStructureDeviceAddressKHR(static_cast<Device *>(p_device)->GetDevice(), &acceleration_device_address_info);

	if (!m_scratch_buffer || m_scratch_buffer->GetDesc().size != build_sizes_info.buildScratchSize)
	{
		m_scratch_buffer = std::make_unique<Buffer>(
		    p_device,
		    BufferDesc{
		        "AS Scratch Buffer",
		        RHIBufferUsage::UnorderedAccess,
		        RHIMemoryUsage::GPU_Only,
		        build_sizes_info.buildScratchSize});
	}

	VkPhysicalDeviceAccelerationStructurePropertiesKHR properties = {};

	properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
	properties.pNext = NULL;

	VkPhysicalDeviceProperties2 dev_props2 = {};

	dev_props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
	dev_props2.pNext = &properties;

	vkGetPhysicalDeviceProperties2(static_cast<Device *>(p_device)->GetPhysicalDevice(), &dev_props2);

	build_geometry_info.scratchData.deviceAddress = Align(m_scratch_buffer->GetDeviceAddress(), properties.minAccelerationStructureScratchOffsetAlignment);
	build_geometry_info.dstAccelerationStructure  = m_handle;

	VkAccelerationStructureBuildRangeInfoKHR *as_build_range_infos = const_cast<VkAccelerationStructureBuildRangeInfoKHR *>(&range_info);

	// Submit build task
	vkCmdBuildAccelerationStructuresKHR(
	    static_cast<Command *>(cmd_buffer)->GetHandle(),
	    1,
	    &build_geometry_info,
	    &as_build_range_infos);
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/AccelerationStructure.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Buffer;

class AccelerationStructure : public RHIAccelerationStructure
{
  public:
	AccelerationStructure(RHIDevice *device);

	virtual ~AccelerationStructure() override;

	virtual void Update(RHICommand *cmd_buffer, const TLASDesc &desc) override;

	virtual void Update(RHICommand *cmd_buffer, const BLASDesc &desc) override;

	VkAccelerationStructureKHR GetHandle() const;

	uint64_t GetDeviceAddress() const;

  private:
	void Update(RHICommand *cmd_buffer, const VkAccelerationStructureGeometryKHR &geometry, const VkAccelerationStructureBuildRangeInfoKHR &range_info, VkAccelerationStructureTypeKHR type);
  private:
	VkAccelerationStructureKHR m_handle = VK_NULL_HANDLE;

	// TLAS & BLAS
	std::unique_ptr<Buffer> m_buffer         = nullptr;
	std::unique_ptr<Buffer> m_scratch_buffer = nullptr;

	// Only TLAS
	std::unique_ptr<Buffer> m_instance_buffer = nullptr;

	uint64_t m_device_address = 0;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Buffer.cpp
================================================
#include "Buffer.hpp"
#include "Command.hpp"
#include "Device.hpp"
#include "Queue.hpp"
#include "Synchronization.hpp"

#include <dxgi1_2.h>

namespace Ilum::Vulkan
{
BufferState BufferState::Create(RHIResourceState state)
{
	BufferState vk_state = {};

	switch (state)
	{
		case RHIResourceState::VertexBuffer:
			vk_state.access_mask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
			break;
		case RHIResourceState::IndexBuffer:
			vk_state.access_mask = VK_ACCESS_INDEX_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
			break;
		case RHIResourceState::IndirectBuffer:
			vk_state.access_mask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
			break;
		case RHIResourceState::TransferSource:
			vk_state.access_mask = VK_ACCESS_TRANSFER_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_TRANSFER_BIT;
			break;
		case RHIResourceState::TransferDest:
			vk_state.access_mask = VK_ACCESS_TRANSFER_WRITE_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_TRANSFER_BIT;
			break;
		case RHIResourceState::AccelerationStructure:
			vk_state.access_mask = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
			vk_state.stage       = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
			break;
		case RHIResourceState::ShaderResource:
			vk_state.access_mask = VK_ACCESS_SHADER_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
			break;
		case RHIResourceState::UnorderedAccess:
			vk_state.access_mask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
			break;
		case RHIResourceState::ConstantBuffer:
			vk_state.access_mask = VK_ACCESS_SHADER_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
			break;
		default:
			vk_state.access_mask = VK_ACCESS_FLAG_BITS_MAX_ENUM;
			vk_state.stage       = VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM;
			break;
	}
	return vk_state;
}

Buffer::Buffer(RHIDevice *device, const BufferDesc &desc) :
    RHIBuffer(device, desc)
{
	m_desc.size = m_desc.size == 0 ? m_desc.stride * m_desc.count : m_desc.size;

	VkBufferCreateInfo buffer_create_info = {};
	buffer_create_info.sType              = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
	buffer_create_info.size               = desc.size;
	buffer_create_info.usage              = ToVulkanBufferUsage(desc.usage);
	buffer_create_info.sharingMode        = VK_SHARING_MODE_EXCLUSIVE;

	if (static_cast<Device *>(p_device)->IsFeatureSupport(RHIFeature::BufferDeviceAddress))
	{
		buffer_create_info.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
	}

#ifdef CUDA_ENABLE
	// External memory
	VkExternalMemoryBufferCreateInfo external_create_info = {};

	external_create_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
	external_create_info.pNext = nullptr;
#	ifdef _WIN64
	external_create_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
#	else
	external_create_info.handleTypes        = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
#	endif
	buffer_create_info.pNext = &external_create_info;

	vkCreateBuffer(static_cast<Device *>(p_device)->GetDevice(), &buffer_create_info, nullptr, &m_handle);

	VkMemoryRequirements memory_req = {};
	vkGetBufferMemoryRequirements(static_cast<Device *>(p_device)->GetDevice(), m_handle, &memory_req);

#	ifdef _WIN64
	WindowsSecurityAttributes winSecurityAttributes;

	VkExportMemoryWin32HandleInfoKHR vulkanExportMemoryWin32HandleInfoKHR = {};
	vulkanExportMemoryWin32HandleInfoKHR.sType =
	    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
	vulkanExportMemoryWin32HandleInfoKHR.pNext       = NULL;
	vulkanExportMemoryWin32HandleInfoKHR.pAttributes = &winSecurityAttributes;
	vulkanExportMemoryWin32HandleInfoKHR.dwAccess =
	    DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE;
	vulkanExportMemoryWin32HandleInfoKHR.name = (LPCWSTR) NULL;
#	endif
	VkExportMemoryAllocateInfoKHR export_memory_allocate_info = {};
	export_memory_allocate_info.sType =
	    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR;
#	ifdef _WIN64
	export_memory_allocate_info.pNext       = &vulkanExportMemoryWin32HandleInfoKHR;
	export_memory_allocate_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
#	else
	export_memory_allocate_info.pNext       = NULL;
	export_memory_allocate_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
#	endif

	VkMemoryAllocateFlagsInfo allocate_flags_info = {};
	allocate_flags_info.sType                     = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
	if (static_cast<Device *>(p_device)->IsFeatureSupport(RHIFeature::BufferDeviceAddress))
	{
		allocate_flags_info.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
	}

	VkMemoryAllocateInfo allocate_info{};
	allocate_info.sType          = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	allocate_info.allocationSize = memory_req.size;
	allocate_info.pNext          = &allocate_flags_info;
	allocate_flags_info.pNext    = &export_memory_allocate_info;

	VkPhysicalDeviceMemoryProperties physical_device_properties = {};
	vkGetPhysicalDeviceMemoryProperties(static_cast<Device *>(p_device)->GetPhysicalDevice(), &physical_device_properties);

	VkMemoryPropertyFlags properties = {};
	switch (desc.memory)
	{
		case RHIMemoryUsage::CPU_TO_GPU:
			properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
			break;
		case RHIMemoryUsage::GPU_Only:
			properties = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
			break;
		case RHIMemoryUsage::GPU_TO_CPU:
			properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
			break;
		default:
			break;
	}

	for (uint32_t i = 0; i < physical_device_properties.memoryTypeCount; i++)
	{
		if ((memory_req.memoryTypeBits & (1 << i)) &&
		    (physical_device_properties.memoryTypes[i].propertyFlags & properties))
		{
			allocate_info.memoryTypeIndex = i;
			break;
		}
	}
	vkAllocateMemory(static_cast<Device *>(p_device)->GetDevice(), &allocate_info, nullptr, &m_memory);
	vkBindBufferMemory(static_cast<Device *>(p_device)->GetDevice(), m_handle, m_memory, 0);
#else
	VmaAllocationCreateInfo allocation_create_info = {};
	allocation_create_info.usage                   = ToVmaMemoryUsage[desc.memory];

	VmaAllocationInfo allocation_info = {};
	vmaCreateBuffer(static_cast<Device *>(p_device)->GetAllocator(), &buffer_create_info, &allocation_create_info, &m_handle, &m_allocation, &allocation_info);
#endif

	if (static_cast<Device *>(p_device)->IsFeatureSupport(RHIFeature::BufferDeviceAddress))
	{
		VkBufferDeviceAddressInfoKHR buffer_device_address_info = {};
		buffer_device_address_info.sType                        = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
		buffer_device_address_info.buffer                       = m_handle;
		m_device_address                                        = vkGetBufferDeviceAddress(static_cast<Device *>(p_device)->GetDevice(), &buffer_device_address_info);
	}

	if (!m_desc.name.empty())
	{
		VkDebugUtilsObjectNameInfoEXT info = {};
		info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
		info.pObjectName                   = m_desc.name.c_str();
		info.objectHandle                  = (uint64_t) m_handle;
		info.objectType                    = VK_OBJECT_TYPE_BUFFER;
		static_cast<Device *>(p_device)->SetVulkanObjectName(info);
	}
}

Buffer::~Buffer()
{
	vkDeviceWaitIdle(static_cast<Device *>(p_device)->GetDevice());

	Unmap();

	if (m_allocation)
	{
		vmaFreeMemory(static_cast<Device *>(p_device)->GetAllocator(), m_allocation);
		m_allocation = VK_NULL_HANDLE;
	}

	if (m_handle)
	{
		vkDestroyBuffer(static_cast<Device *>(p_device)->GetDevice(), m_handle, nullptr);
		m_handle = nullptr;
	}

	if (m_memory)
	{
		vkFreeMemory(static_cast<Device *>(p_device)->GetDevice(), m_memory, nullptr);
		m_memory = VK_NULL_HANDLE;
	}
}

void Buffer::CopyToDevice(const void *data, size_t size, size_t offset)
{
	if (m_desc.memory == RHIMemoryUsage::CPU_TO_GPU)
	{
		void *mapped = Map();
		std::memcpy((uint8_t *) mapped + offset, data, size);
		Flush(offset, size);
		Unmap();
	}
	else
	{
		auto    fence = std::make_unique<Fence>(p_device);
		VkQueue queue = VK_NULL_HANDLE;
		vkGetDeviceQueue(static_cast<Device *>(p_device)->GetDevice(), static_cast<Device *>(p_device)->GetQueueFamily(RHIQueueFamily::Transfer), 0, &queue);
		auto staging_buffer = std::make_unique<Buffer>(p_device, BufferDesc{"", RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU, size});

		{
			std::memcpy((uint8_t *) staging_buffer->Map(), data, size);
			auto cmd_buffer = std::make_unique<Command>(p_device, RHIQueueFamily::Transfer);
			cmd_buffer->Init();
			cmd_buffer->Begin();
			cmd_buffer->CopyBufferToBuffer(staging_buffer.get(), this, size, 0, offset);
			cmd_buffer->End();

			auto vk_cmd_buffer = cmd_buffer->GetHandle();

			VkSubmitInfo submit_info         = {};
			submit_info.sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO;
			submit_info.commandBufferCount   = 1;
			submit_info.pCommandBuffers      = &vk_cmd_buffer;
			submit_info.signalSemaphoreCount = 0;
			submit_info.pSignalSemaphores    = nullptr;
			submit_info.waitSemaphoreCount   = 0;
			submit_info.pWaitSemaphores      = nullptr;
			submit_info.pWaitDstStageMask    = nullptr;

			vkQueueSubmit(queue, 1, &submit_info, fence ? fence->GetHandle() : nullptr);
			fence->Wait();
		}
	}
}

void Buffer::CopyToHost(void *data, size_t size, size_t offset)
{
	if (m_desc.memory == RHIMemoryUsage::GPU_TO_CPU)
	{
		void *mapped = Map();
		std::memcpy(data, (uint8_t *) mapped + offset, size);
		Flush(offset, size);
		Unmap();
	}
	else
	{
		auto    fence = std::make_unique<Fence>(p_device);
		VkQueue queue = VK_NULL_HANDLE;
		vkGetDeviceQueue(static_cast<Device *>(p_device)->GetDevice(), static_cast<Device *>(p_device)->GetQueueFamily(RHIQueueFamily::Transfer), 0, &queue);
		auto staging_buffer = std::make_unique<Buffer>(p_device, BufferDesc{"", RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_TO_CPU, size});

		{
			auto cmd_buffer = std::make_unique<Command>(p_device, RHIQueueFamily::Transfer);
			cmd_buffer->Init();
			cmd_buffer->Begin();
			cmd_buffer->CopyBufferToBuffer(this, staging_buffer.get(), size, 0, offset);
			cmd_buffer->End();

			auto vk_cmd_buffer = cmd_buffer->GetHandle();

			VkSubmitInfo submit_info         = {};
			submit_info.sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO;
			submit_info.commandBufferCount   = 1;
			submit_info.pCommandBuffers      = &vk_cmd_buffer;
			submit_info.signalSemaphoreCount = 0;
			submit_info.pSignalSemaphores    = nullptr;
			submit_info.waitSemaphoreCount   = 0;
			submit_info.pWaitSemaphores      = nullptr;
			submit_info.pWaitDstStageMask    = nullptr;

			vkQueueSubmit(queue, 1, &submit_info, fence->GetHandle());
			fence->Wait();

			std::memcpy(data, (uint8_t *) staging_buffer->Map(), size);
		}
	}
}

void *Buffer::Map()
{
	if (!m_mapped)
	{
		if (m_allocation)
		{
			vmaMapMemory(static_cast<Device *>(p_device)->GetAllocator(), m_allocation, reinterpret_cast<void **>(&m_mapped));
		}
		else
		{
			vkMapMemory(static_cast<Device *>(p_device)->GetDevice(), m_memory, 0, VK_WHOLE_SIZE, 0, &m_mapped);
		}
	}
	return m_mapped;
}

void Buffer::Unmap()
{
	if (m_mapped)
	{
		if (m_allocation)
		{
			vmaUnmapMemory(static_cast<Device *>(p_device)->GetAllocator(), m_allocation);
		}
		else
		{
			vkUnmapMemory(static_cast<Device *>(p_device)->GetDevice(), m_memory);
		}

		m_mapped = nullptr;
	}
}

void Buffer::Flush(size_t offset, size_t size)
{
	if (m_allocation)
	{
		vmaFlushAllocation(static_cast<Device *>(p_device)->GetAllocator(), m_allocation, 0, m_desc.size);
	}
	else
	{
		VkMappedMemoryRange range = {};

		range.memory = m_memory;
		range.sType  = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
		range.offset = 0;
		range.size   = VK_WHOLE_SIZE;
		range.pNext  = nullptr;

		vkFlushMappedMemoryRanges(static_cast<Device *>(p_device)->GetDevice(), 1, &range);
	}
}

VkBuffer Buffer::GetHandle() const
{
	return m_handle;
}

VkDeviceMemory Buffer::GetMemory() const
{
	if (m_memory)
	{
		return m_memory;
	}

	VmaAllocationInfo info = {};
	vmaGetAllocationInfo(static_cast<Device *>(p_device)->GetAllocator(), m_allocation, &info);
	return info.deviceMemory;
}

uint64_t Buffer::GetDeviceAddress() const
{
	return m_device_address;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Buffer.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
struct BufferState
{
	VkAccessFlags        access_mask = VK_ACCESS_NONE;
	VkPipelineStageFlags stage       = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;

	inline bool operator==(const BufferState &other)
	{
		return access_mask == other.access_mask &&
		       stage == other.stage;
	}

	static BufferState Create(RHIResourceState state);
};

class Buffer : public RHIBuffer
{
  public:
	Buffer(RHIDevice *device, const BufferDesc &desc);

	virtual ~Buffer() override;

	virtual void CopyToDevice(const void *data, size_t size, size_t offset = 0) override;

	virtual void CopyToHost(void *data, size_t size, size_t offset) override;

	virtual void *Map() override;

	virtual void Unmap() override;

	virtual void Flush(size_t offset, size_t size) override;

	VkBuffer GetHandle() const;

	VkDeviceMemory GetMemory() const;

	uint64_t GetDeviceAddress() const;

  private:
	VkBuffer      m_handle     = VK_NULL_HANDLE;
	VmaAllocation m_allocation = VK_NULL_HANDLE;
	VkDeviceMemory m_memory     = VK_NULL_HANDLE;

	uint64_t m_device_address = 0;

	void *m_mapped = nullptr;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Command.cpp
================================================
#include "Command.hpp"
#include "Buffer.hpp"
#include "Descriptor.hpp"
#include "Device.hpp"
#include "PipelineState.hpp"
#include "RenderTarget.hpp"
#include "Texture.hpp"

namespace Ilum::Vulkan
{
static std::unordered_map<size_t, VkCommandPool>          CommandPools;
static std::unordered_map<size_t, std::vector<Command *>> CommandBuffers;

static std::atomic<uint32_t> CommandCount = 0;

Command::Command(RHIDevice *device, RHIQueueFamily family) :
    RHICommand(device, family)
{
	std::lock_guard<std::mutex> lock(m_mutex);
	CommandCount.fetch_add(1);

	// Register Command Buffer
	size_t hash = 0;
	HashCombine(hash, family, std::this_thread::get_id());
	CommandBuffers[hash].push_back(this);

	// Check Command Pool
	if (CommandPools.find(hash) == CommandPools.end())
	{
		VkCommandPoolCreateInfo create_info = {};
		create_info.sType                   = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
		create_info.flags                   = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
		create_info.queueFamilyIndex        = static_cast<Device *>(p_device)->GetQueueFamily(family);

		VkCommandPool pool = VK_NULL_HANDLE;
		vkCreateCommandPool(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &pool);
		CommandPools[hash] = pool;
	}
	m_pool = CommandPools[hash];

	// Create Command Buffer
	VkCommandBufferAllocateInfo allocate_info = {};
	allocate_info.sType                       = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
	allocate_info.commandPool                 = m_pool;
	allocate_info.level                       = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
	allocate_info.commandBufferCount          = 1;
	vkAllocateCommandBuffers(static_cast<Device *>(p_device)->GetDevice(), &allocate_info, &m_handle);
}

Command::Command(RHIDevice *device, VkCommandPool pool, RHIQueueFamily family) :
    RHICommand(device, family), m_pool(pool)
{
	CommandCount.fetch_add(1);

	VkCommandBufferAllocateInfo allocate_info = {};
	allocate_info.sType                       = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
	allocate_info.commandPool                 = pool;
	allocate_info.level                       = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
	allocate_info.commandBufferCount          = 1;
	vkAllocateCommandBuffers(static_cast<Device *>(p_device)->GetDevice(), &allocate_info, &m_handle);
}

Command::~Command()
{
	std::lock_guard<std::mutex> lock(m_mutex);

	CommandCount.fetch_sub(1);

	if (m_handle)
	{
		vkFreeCommandBuffers(static_cast<Device *>(p_device)->GetDevice(), m_pool, 1, &m_handle);
	}

	if (CommandCount == 0)
	{
		for (auto &[hash, pool] : CommandPools)
		{
			vkDestroyCommandPool(static_cast<Device *>(p_device)->GetDevice(), pool, nullptr);
		}
		CommandPools.clear();
	}

	for (auto &[hash, cmds] : CommandBuffers)
	{
		for (auto iter = cmds.begin(); iter != cmds.end(); iter++)
		{
			if (*iter == this)
			{
				cmds.erase(iter);
				return;
			}
		}
	}
}

void Command::SetState(CommandState state)
{
	m_state = state;
}

VkCommandBuffer Command::GetHandle() const
{
	return m_handle;
}

void Command::SetName(const std::string &name)
{
	VkDebugUtilsObjectNameInfoEXT info = {};
	info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
	info.pObjectName                   = name.c_str();
	info.objectHandle                  = (uint64_t) m_handle;
	info.objectType                    = VK_OBJECT_TYPE_COMMAND_BUFFER;
	static_cast<Device *>(p_device)->SetVulkanObjectName(info);
}

void Command::Begin()
{
	assert(m_state == CommandState::Initial);

	VkCommandBufferBeginInfo begin_info = {};
	begin_info.sType                    = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
	begin_info.flags                    = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
	begin_info.pInheritanceInfo         = nullptr;

	vkBeginCommandBuffer(m_handle, &begin_info);

	m_state = CommandState::Recording;
}

void Command::End()
{
	assert(m_state == CommandState::Recording);
	vkEndCommandBuffer(m_handle);
	m_state = CommandState::Executable;

	p_descriptor = nullptr;
}

void Command::BeginMarker(const std::string &name, float r, float g, float b, float a)
{
	VkDebugUtilsLabelEXT label = {};
	label.sType                = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
	label.pLabelName           = name.c_str();
	label.color[0]             = r;
	label.color[1]             = g;
	label.color[2]             = b;
	label.color[3]             = a;

	static_cast<Device *>(p_device)->BeginDebugUtilsLabel(m_handle, label);
}

void Command::EndMarker()
{
	static_cast<Device *>(p_device)->EndDebugUtilsLabel(m_handle);
}

void Command::BeginRenderPass(RHIRenderTarget *render_target)
{
	if (static_cast<Device *>(p_device)->IsFeatureSupport(VulkanFeature::DynamicRendering))
	{
		VkRenderingInfo rendering_info = {};
		rendering_info.sType           = VK_STRUCTURE_TYPE_RENDERING_INFO;
		rendering_info.renderArea      = {0, 0, render_target->GetWidth(), render_target->GetHeight()};
		rendering_info.layerCount      = render_target->GetLayers();

		RenderTarget *vk_render_target = static_cast<RenderTarget *>(render_target);

		rendering_info.colorAttachmentCount = static_cast<uint32_t>(vk_render_target->GetColorAttachments().size());
		rendering_info.pColorAttachments    = vk_render_target->GetColorAttachments().data();
		rendering_info.pDepthAttachment     = vk_render_target->GetDepthAttachment().has_value() ? &vk_render_target->GetDepthAttachment().value() : nullptr;
		rendering_info.pStencilAttachment   = vk_render_target->GetStencilAttachment().has_value() ? &vk_render_target->GetStencilAttachment().value() : nullptr;

		vkCmdBeginRendering(m_handle, &rendering_info);
	}
	else
	{
		RenderTarget *vk_render_target = static_cast<RenderTarget *>(render_target);

		auto clear_values = vk_render_target->GetClearValue();

		VkRenderPassBeginInfo begin_info = {};
		begin_info.sType                 = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
		begin_info.framebuffer           = vk_render_target->GetFramebuffer();
		begin_info.pClearValues          = clear_values.data();
		begin_info.clearValueCount       = static_cast<uint32_t>(clear_values.size());
		begin_info.renderPass            = vk_render_target->GetRenderPass();
		begin_info.renderArea            = vk_render_target->GetRenderArea();

		vkCmdBeginRenderPass(m_handle, &begin_info, VK_SUBPASS_CONTENTS_INLINE);
	}

	p_render_target = static_cast<RenderTarget *>(render_target);
}

void Command::EndRenderPass()
{
	if (static_cast<Device *>(p_device)->IsFeatureSupport(VulkanFeature::DynamicRendering))
	{
		vkCmdEndRendering(m_handle);
	}
	else
	{
		vkCmdEndRenderPass(m_handle);
	}

	p_render_target = nullptr;
}

void Command::BindVertexBuffer(uint32_t binding, RHIBuffer *vertex_buffer)
{
	Buffer  *vk_vertex_buffer = static_cast<Buffer *>(vertex_buffer);
	size_t   offset           = 0;
	VkBuffer handle           = vk_vertex_buffer->GetHandle();
	vkCmdBindVertexBuffers(m_handle, binding, 1, &handle, &offset);
}

void Command::BindIndexBuffer(RHIBuffer *index_buffer, bool is_short)
{
	vkCmdBindIndexBuffer(m_handle, static_cast<Buffer *>(index_buffer)->GetHandle(), 0, is_short ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32);
}

void Command::BindDescriptor(RHIDescriptor *descriptor)
{
	p_descriptor = static_cast<Descriptor *>(descriptor);
}

void Command::BindPipelineState(RHIPipelineState *pipeline_state)
{
	assert(p_descriptor != nullptr);
	p_pipeline_state = static_cast<PipelineState *>(pipeline_state);
	vkCmdBindPipeline(m_handle, p_pipeline_state->GetPipelineBindPoint(), p_pipeline_state->GetPipeline(p_descriptor, p_render_target));
	for (auto &[set, descriptor_set] : p_descriptor->GetDescriptorSet())
	{
		vkCmdBindDescriptorSets(m_handle, p_pipeline_state->GetPipelineBindPoint(), p_pipeline_state->GetPipelineLayout(p_descriptor), set, 1, &descriptor_set, 0, nullptr);
	}
	for (auto &[name, constant] : static_cast<Descriptor *>(p_descriptor)->GetConstantResolve())
	{
		vkCmdPushConstants(m_handle, p_pipeline_state->GetPipelineLayout(p_descriptor), constant.stage, static_cast<uint32_t>(constant.offset), static_cast<uint32_t>(constant.data.size()), constant.data.data());
	}
}

void Command::SetViewport(float width, float height, float x, float y)
{
	// Flip y
	VkViewport viewport = {x, y + height, width, -height, 0.f, 1.f};
	vkCmdSetViewport(m_handle, 0, 1, &viewport);
}

void Command::SetScissor(uint32_t width, uint32_t height, int32_t offset_x, int32_t offset_y)
{
	VkRect2D rect = {VkOffset2D{offset_x, offset_y}, VkExtent2D{width, height}};
	vkCmdSetScissor(m_handle, 0, 1, &rect);
}

void Command::Dispatch(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z)
{
	vkCmdDispatch(m_handle, (thread_x + block_x - 1) / block_x, (thread_y + block_y - 1) / block_y, (thread_z + block_z - 1) / block_z);
}

void Command::DispatchIndirect(RHIBuffer *buffer, size_t offset)
{
	vkCmdDispatchIndirect(m_handle, static_cast<Buffer *>(buffer)->GetHandle(), offset);
}

void Command::Draw(uint32_t vertex_count, uint32_t instance_count, uint32_t first_vertex, uint32_t first_instance)
{
	vkCmdDraw(m_handle, vertex_count, instance_count, first_vertex, first_instance);
}

void Command::DrawIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)
{
	vkCmdDrawIndirect(m_handle, static_cast<Buffer *>(buffer)->GetHandle(), offset, draw_count, stride);
}

void Command::DrawIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride)
{
	vkCmdDrawIndirectCount(m_handle, static_cast<Buffer *>(buffer)->GetHandle(), offset, static_cast<Buffer *>(count_buffer)->GetHandle(), count_buffer_offset, max_draw_count, stride);
}

void Command::DrawIndexed(uint32_t index_count, uint32_t instance_count, uint32_t first_index, uint32_t vertex_offset, uint32_t first_instance)
{
	vkCmdDrawIndexed(m_handle, index_count, instance_count, first_index, vertex_offset, first_instance);
}

void Command::DrawIndexedIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)
{
	vkCmdDrawIndexedIndirect(m_handle, static_cast<Buffer *>(buffer)->GetHandle(), offset, draw_count, stride);
}

void Command::DrawIndexedIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride)
{
	vkCmdDrawIndexedIndirectCount(m_handle, static_cast<Buffer *>(buffer)->GetHandle(), offset, static_cast<Buffer *>(count_buffer)->GetHandle(), count_buffer_offset, max_draw_count, stride);
}

void Command::DrawMeshTask(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z)
{
	vkCmdDrawMeshTasksEXT(m_handle, (thread_x + block_x - 1) / block_x, (thread_y + block_y - 1) / block_y, (thread_z + block_z - 1) / block_z);
}

void Command::DrawMeshTasksIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)
{
	vkCmdDrawMeshTasksIndirectEXT(m_handle, static_cast<Buffer *>(buffer)->GetHandle(), offset, draw_count, stride);
}

void Command::DrawMeshTasksIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride)
{
	vkCmdDrawMeshTasksIndirectCountEXT(m_handle, static_cast<Buffer *>(buffer)->GetHandle(), offset, static_cast<Buffer *>(count_buffer)->GetHandle(), count_buffer_offset, max_draw_count, stride);
}

void Command::TraceRay(uint32_t width, uint32_t height, uint32_t depth)
{
	auto sbt = p_pipeline_state->GetShaderBindingTable(p_pipeline_state->GetPipeline(p_descriptor, p_render_target));
	vkCmdTraceRaysKHR(
	    m_handle,
	    sbt.raygen, sbt.miss, sbt.hit, sbt.callable,
	    width, height, depth);
}

void Command::CopyBufferToTexture(RHIBuffer *src_buffer, RHITexture *dst_texture, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count)
{
	VkImageSubresourceLayers subresource = {};
	subresource.aspectMask               = IsDepthFormat(dst_texture->GetDesc().format) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
	subresource.baseArrayLayer           = base_layer;
	subresource.mipLevel                 = mip_level;
	subresource.layerCount               = layer_count;

	uint32_t width  = std::max(dst_texture->GetDesc().width, 1u << mip_level) >> mip_level;
	uint32_t height = std::max(dst_texture->GetDesc().height, 1u << mip_level) >> mip_level;

	VkBufferImageCopy copy_info = {};
	copy_info.bufferOffset      = 0;
	copy_info.bufferImageHeight = 0;
	copy_info.bufferRowLength   = 0;
	copy_info.imageSubresource  = subresource;
	copy_info.imageOffset       = {0, 0, 0};
	copy_info.imageExtent       = {width, height, 1};

	vkCmdCopyBufferToImage(m_handle, static_cast<Buffer *>(src_buffer)->GetHandle(), static_cast<Texture *>(dst_texture)->GetHandle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy_info);
}

void Command::CopyTextureToBuffer(RHITexture *src_texture, RHIBuffer *dst_buffer, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count)
{
	VkImageSubresourceLayers subresource = {};
	subresource.aspectMask               = IsDepthFormat(src_texture->GetDesc().format) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
	subresource.baseArrayLayer           = base_layer;
	subresource.mipLevel                 = mip_level;
	subresource.layerCount               = layer_count;

	uint32_t width  = std::max(src_texture->GetDesc().width, 1u << mip_level) >> mip_level;
	uint32_t height = std::max(src_texture->GetDesc().height, 1u << mip_level) >> mip_level;

	VkBufferImageCopy copy_info = {};
	copy_info.bufferOffset      = 0;
	copy_info.imageSubresource  = subresource;
	copy_info.imageOffset       = {0, 0, 0};
	copy_info.imageExtent       = {width, height, 1};

	vkCmdCopyImageToBuffer(m_handle, static_cast<Texture *>(src_texture)->GetHandle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, static_cast<Buffer *>(dst_buffer)->GetHandle(), 1, &copy_info);
}

void Command::CopyBufferToBuffer(RHIBuffer *src_buffer, RHIBuffer *dst_buffer, size_t size, size_t src_offset, size_t dst_offset)
{
	VkBufferCopy buffer_copy = {};
	buffer_copy.size         = size;
	buffer_copy.srcOffset    = src_offset;
	buffer_copy.dstOffset    = dst_offset;

	vkCmdCopyBuffer(m_handle, static_cast<Buffer *>(src_buffer)->GetHandle(), static_cast<Buffer *>(dst_buffer)->GetHandle(), 1, &buffer_copy);
}

void Command::GenerateMipmaps(RHITexture *texture, RHIResourceState initial_state, RHIFilter filter)
{
	if (initial_state != RHIResourceState::TransferDest)
	{
		ResourceStateTransition({TextureStateTransition{texture, initial_state, RHIResourceState::TransferDest, TextureRange{RHITextureDimension::Texture2D, 0, texture->GetDesc().mips, 0, texture->GetDesc().layers}}}, {});
	}

	if (texture->GetDesc().mips == 1)
	{
		return;
	}

	TextureRange             src_range  = {RHITextureDimension::Texture2D, 0, texture->GetDesc().mips, 0, texture->GetDesc().layers};
	TextureRange             dst_range  = {RHITextureDimension::Texture2D, 0, texture->GetDesc().mips, 0, texture->GetDesc().layers};
	VkImageSubresourceLayers src_layers = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, texture->GetDesc().layers};
	VkImageSubresourceLayers dst_layers = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, texture->GetDesc().layers};
	RHIResourceState         src_state  = RHIResourceState::TransferDest;

	uint32_t src_width  = texture->GetDesc().width;
	uint32_t src_height = texture->GetDesc().height;
	uint32_t dst_width  = texture->GetDesc().width;
	uint32_t dst_height = texture->GetDesc().height;

	for (uint32_t i = 1; i < texture->GetDesc().mips; i++)
	{
		src_width  = dst_width;
		src_height = dst_height;

		dst_width  = std::max(src_width / 2, 1u);
		dst_height = std::max(src_height / 2, 1u);

		src_layers.mipLevel = i - 1;
		src_range.base_mip  = i - 1;
		src_range.mip_count = 1;

		dst_layers.mipLevel = i;
		dst_range.base_mip  = i;
		dst_range.mip_count = 1;

		std::vector<TextureStateTransition> transitions(2);
		transitions[0].texture = texture;
		transitions[0].src     = src_state;
		transitions[0].dst     = RHIResourceState::TransferSource;
		transitions[0].range   = src_range;
		transitions[1].texture = texture;
		transitions[1].src     = RHIResourceState::Undefined;
		transitions[1].dst     = RHIResourceState::TransferDest;
		transitions[1].range   = dst_range;
		ResourceStateTransition(transitions, {});

		src_state = RHIResourceState::TransferDest;

		VkImageBlit blit_info    = {};
		blit_info.srcOffsets[0]  = {0, 0, 0};
		blit_info.srcOffsets[1]  = {static_cast<int32_t>(src_width), static_cast<int32_t>(src_height), 1};
		blit_info.dstOffsets[0]  = {0, 0, 0};
		blit_info.dstOffsets[1]  = {static_cast<int32_t>(dst_width), static_cast<int32_t>(dst_height), 1};
		blit_info.srcSubresource = src_layers;
		blit_info.dstSubresource = dst_layers;

		vkCmdBlitImage(m_handle, static_cast<Texture *>(texture)->GetHandle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, static_cast<Texture *>(texture)->GetHandle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit_info, ToVulkanFilter[filter]);
	}

	TextureRange mip_level_range = {RHITextureDimension::Texture2D, 0, texture->GetDesc().mips, 0, texture->GetDesc().layers};

	mip_level_range.mip_count = mip_level_range.mip_count - 1;
	ResourceStateTransition({TextureStateTransition{texture, RHIResourceState::TransferSource, RHIResourceState::TransferDest, mip_level_range}}, {});
}

void Command::BlitTexture(RHITexture *src_texture, const TextureRange &src_range, const RHIResourceState &src_state, RHITexture *dst_texture, const TextureRange &dst_range, const RHIResourceState &dst_state, RHIFilter filter)
{
	if (src_state != RHIResourceState::TransferSource)
	{
		ResourceStateTransition({TextureStateTransition{src_texture, src_state, RHIResourceState::TransferSource, src_range}}, {});
	}

	if (dst_state != RHIResourceState::TransferDest)
	{
		ResourceStateTransition({TextureStateTransition{dst_texture, dst_state, RHIResourceState::TransferDest, dst_range}}, {});
	}

	VkImage       src_image  = static_cast<Texture *>(src_texture)->GetHandle();
	VkImage       dst_image  = static_cast<Texture *>(dst_texture)->GetHandle();
	VkImageLayout src_layout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
	VkImageLayout dst_layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;

	VkImageBlit region = {};

	region.srcSubresource.aspectMask     = IsDepthFormat(src_texture->GetDesc().format) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
	region.srcSubresource.baseArrayLayer = src_range.base_layer;
	region.srcSubresource.layerCount     = src_range.layer_count;
	region.srcSubresource.mipLevel       = src_range.base_mip;

	region.dstSubresource.aspectMask     = IsDepthFormat(dst_texture->GetDesc().format) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
	region.dstSubresource.baseArrayLayer = dst_range.base_layer;
	region.dstSubresource.layerCount     = dst_range.layer_count;
	region.dstSubresource.mipLevel       = dst_range.base_mip;

	region.srcOffsets[1].x = src_texture->GetDesc().width;
	region.srcOffsets[1].y = src_texture->GetDesc().height;
	region.srcOffsets[1].z = 1;

	region.dstOffsets[1].x = dst_texture->GetDesc().width;
	region.dstOffsets[1].y = dst_texture->GetDesc().height;
	region.dstOffsets[1].z = 1;

	vkCmdBlitImage(m_handle, src_image, src_layout, dst_image, dst_layout, 1, &region, ToVulkanFilter[filter]);

	if (src_state != RHIResourceState::TransferSource && src_state != RHIResourceState::Undefined)
	{
		ResourceStateTransition({TextureStateTransition{src_texture, RHIResourceState::TransferSource, src_state, src_range}}, {});
	}

	if (dst_state != RHIResourceState::TransferDest && dst_state != RHIResourceState::Undefined)
	{
		ResourceStateTransition({TextureStateTransition{dst_texture, RHIResourceState::TransferDest, dst_state, dst_range}}, {});
	}
}

void Command::FillBuffer(RHIBuffer *buffer, RHIResourceState state, size_t size, size_t offset, uint32_t data)
{
	if (state != RHIResourceState::TransferDest)
	{
		ResourceStateTransition(
		    {},
		    {BufferStateTransition{
		        buffer,
		        RHIResourceState::UnorderedAccess,
		        RHIResourceState::TransferDest}});
	}

	vkCmdFillBuffer(m_handle, static_cast<Buffer *>(buffer)->GetHandle(), offset, size, data);

	if (state != RHIResourceState::TransferDest)
	{
		ResourceStateTransition(
		    {},
		    {BufferStateTransition{
		        buffer,
		        RHIResourceState::TransferDest,
		        RHIResourceState::UnorderedAccess}});
	}
}

void Command::FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, const glm::vec4 &color)
{
	auto vk_state = TextureState::Create(state);

	VkClearColorValue clear_color = {};
	std::memcpy(clear_color.float32, &color.x, sizeof(float) * 4);

	VkImageSubresourceRange vk_range = {};
	vk_range.aspectMask              = VK_IMAGE_ASPECT_COLOR_BIT;
	vk_range.baseArrayLayer          = range.base_layer;
	vk_range.baseMipLevel            = range.base_mip;
	vk_range.layerCount              = range.layer_count;
	vk_range.levelCount              = range.mip_count;

	if (state != RHIResourceState::TransferDest)
	{
		ResourceStateTransition({TextureStateTransition{
		                            texture,
		                            state,
		                            RHIResourceState::TransferDest}},
		                        {});
	}

	vkCmdClearColorImage(m_handle, static_cast<Texture *>(texture)->GetHandle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &vk_range);

	if (state != RHIResourceState::TransferDest)
	{
		ResourceStateTransition({TextureStateTransition{
		                            texture,
		                            RHIResourceState::TransferDest,
		                            state}},
		                        {});
	}
}

void Command::FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, float depth)
{
}

void Command::ResourceStateTransition(const std::vector<TextureStateTransition> &texture_transitions, const std::vector<BufferStateTransition> &buffer_transitions)
{
	// TODO:
	// + Pipeline Stage Mask
	// + Queue ownership transfer
	if (texture_transitions.empty() && buffer_transitions.empty())
	{
		return;
	}

	std::vector<VkBufferMemoryBarrier> buffer_barriers;
	buffer_barriers.reserve(buffer_transitions.size());

	std::vector<VkImageMemoryBarrier> image_barriers;
	image_barriers.reserve(texture_transitions.size());

	VkPipelineStageFlags src_stage = 0;
	VkPipelineStageFlags dst_stage = 0;

	for (uint32_t i = 0; i < buffer_transitions.size(); i++)
	{
		BufferState vk_buffer_state_src = BufferState::Create(buffer_transitions[i].src);
		BufferState vk_buffer_state_dst = BufferState::Create(buffer_transitions[i].dst);

		VkBufferMemoryBarrier buffer_barrier = {};

		buffer_barrier.sType               = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
		buffer_barrier.srcAccessMask       = vk_buffer_state_src.access_mask;
		buffer_barrier.dstAccessMask       = vk_buffer_state_dst.access_mask;
		buffer_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
		buffer_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
		buffer_barrier.buffer              = static_cast<Buffer *>(buffer_transitions[i].buffer)->GetHandle();
		buffer_barrier.offset              = 0;
		buffer_barrier.size                = buffer_transitions[i].buffer->GetDesc().size;
		buffer_barriers.push_back(buffer_barrier);
		src_stage |= vk_buffer_state_src.stage;
		dst_stage |= vk_buffer_state_dst.stage;
	}

	for (uint32_t i = 0; i < texture_transitions.size(); i++)
	{
		TextureState vk_texture_state_src = TextureState::Create(texture_transitions[i].src);
		TextureState vk_texture_state_dst = TextureState::Create(texture_transitions[i].dst);

		VkImageMemoryBarrier image_barrier = {};

		VkImageSubresourceRange range = {};
		range.aspectMask              = IsDepthFormat(texture_transitions[i].texture->GetDesc().format) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
		range.baseArrayLayer          = texture_transitions[i].range.base_layer;
		range.baseMipLevel            = texture_transitions[i].range.base_mip;
		range.layerCount              = texture_transitions[i].range.layer_count;
		range.levelCount              = texture_transitions[i].range.mip_count;

		image_barrier.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
		image_barrier.srcAccessMask = vk_texture_state_src.access_mask;
		image_barrier.dstAccessMask = vk_texture_state_dst.access_mask;
		image_barrier.oldLayout     = vk_texture_state_src.layout;
		image_barrier.newLayout     = vk_texture_state_dst.layout;

		/*RHIQueueFamily src_family = RHIQueueFamily::Graphics;
		RHIQueueFamily dst_family = RHIQueueFamily::Graphics;

		switch (texture_transitions[i].src)
		{
		    case RHIResourceState::TransferSource:
		    case RHIResourceState::TransferDest:

		    case RHIResourceState::ShaderResource:
		    case RHIResourceState::RenderTarget:
		    case RHIResourceState::DepthWrite:
		    case RHIResourceState::DepthRead:
		    case RHIResourceState::Present:
		        src_family = RHIQueueFamily::Graphics;
		        break;
		    case RHIResourceState::UnorderedAccess:
		        src_family = RHIQueueFamily::Compute;
		        break;
		    default:
		        break;
		}

		switch (texture_transitions[i].dst)
		{
		    case RHIResourceState::TransferSource:
		    case RHIResourceState::TransferDest:
		    case RHIResourceState::ShaderResource:
		    case RHIResourceState::RenderTarget:
		    case RHIResourceState::DepthWrite:
		    case RHIResourceState::DepthRead:
		    case RHIResourceState::Present:
		        dst_family = RHIQueueFamily::Graphics;
		        break;
		    case RHIResourceState::UnorderedAccess:
		        dst_family = RHIQueueFamily::Compute;
		        break;
		    default:
		        break;
		}*/
		// if (texture_transitions[i].src_family == texture_transitions[i].dst_family)
		{
			image_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
			image_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
		}
		// else
		{
			// image_barrier.srcQueueFamilyIndex = static_cast<Device *>(p_device)->GetQueueFamily(texture_transitions[i].src_family);
			// image_barrier.dstQueueFamilyIndex = static_cast<Device *>(p_device)->GetQueueFamily(texture_transitions[i].dst_family);
		}

		image_barrier.image            = static_cast<Texture *>(texture_transitions[i].texture)->GetHandle();
		image_barrier.subresourceRange = range;
		image_barriers.push_back(image_barrier);
		src_stage |= vk_texture_state_src.stage;
		dst_stage |= vk_texture_state_dst.stage;
	}

	vkCmdPipelineBarrier(m_handle, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, static_cast<uint32_t>(buffer_barriers.size()), buffer_barriers.data(), static_cast<uint32_t>(image_barriers.size()), image_barriers.data());
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Command.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Descriptor;
class RenderTarget;
class PipelineState;

class Command : public RHICommand
{
  public:
	Command(RHIDevice *device, RHIQueueFamily family);

	Command(RHIDevice *device, VkCommandPool pool, RHIQueueFamily family);

	virtual ~Command() override;

	void SetState(CommandState state);

	VkCommandBuffer GetHandle() const;

	virtual void SetName(const std::string &name) override;

	virtual void Begin() override;
	virtual void End() override;

	virtual void BeginMarker(const std::string &name, float r, float g, float b, float a) override;
	virtual void EndMarker() override;

	virtual void BeginRenderPass(RHIRenderTarget *render_target) override;
	virtual void EndRenderPass() override;

	virtual void BindVertexBuffer(uint32_t binding, RHIBuffer *vertex_buffer) override;
	virtual void BindIndexBuffer(RHIBuffer *index_buffer, bool is_short = false) override;

	virtual void BindDescriptor(RHIDescriptor *descriptor) override;
	virtual void BindPipelineState(RHIPipelineState *pipeline_state) override;

	virtual void SetViewport(float width, float height, float x = 0.f, float y = 0.f) override;
	virtual void SetScissor(uint32_t width, uint32_t height, int32_t offset_x = 0, int32_t offset_y = 0) override;

	virtual void Dispatch(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z) override;
	virtual void DispatchIndirect(RHIBuffer *buffer, size_t offset) override;

	virtual void Draw(uint32_t vertex_count, uint32_t instance_count, uint32_t first_vertex, uint32_t first_instance) override;
	virtual void DrawIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride) override;
	virtual void DrawIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) override;

	virtual void DrawIndexed(uint32_t index_count, uint32_t instance_count, uint32_t first_index, uint32_t vertex_offset, uint32_t first_instance) override;
	virtual void DrawIndexedIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride) override;
	virtual void DrawIndexedIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) override;

	virtual void DrawMeshTask(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z) override;
	virtual void DrawMeshTasksIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride) override;
	virtual void DrawMeshTasksIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) override;

	virtual void TraceRay(uint32_t width, uint32_t height, uint32_t depth) override;

	virtual void CopyBufferToTexture(RHIBuffer *src_buffer, RHITexture *dst_texture, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count) override;
	virtual void CopyTextureToBuffer(RHITexture *src_texture, RHIBuffer *dst_buffer, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count) override;
	virtual void CopyBufferToBuffer(RHIBuffer *src_buffer, RHIBuffer *dst_buffer, size_t size, size_t src_offset, size_t dst_offset) override;

	virtual void GenerateMipmaps(RHITexture *texture, RHIResourceState initial_state, RHIFilter filter) override;
	virtual void BlitTexture(RHITexture *src_texture, const TextureRange &src_range, const RHIResourceState &src_state, RHITexture *dst_texture, const TextureRange &dst_range, const RHIResourceState &dst_state, RHIFilter filter) override;

	virtual void FillBuffer(RHIBuffer *buffer, RHIResourceState state, size_t size, size_t offset, uint32_t data) override;
	virtual void FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, const glm::vec4 &color) override;
	virtual void FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, float depth) override;

	virtual void ResourceStateTransition(const std::vector<TextureStateTransition> &texture_transitions, const std::vector<BufferStateTransition> &buffer_transitions) override;

  private:
	VkCommandBuffer m_handle = VK_NULL_HANDLE;
	VkCommandPool   m_pool   = VK_NULL_HANDLE;

	Descriptor    *p_descriptor     = nullptr;
	PipelineState *p_pipeline_state = nullptr;
	RenderTarget  *p_render_target  = nullptr;

	std::mutex m_mutex;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Definitions.cpp
================================================
#include "Definitions.hpp"

#ifdef _WIN64
#	include <aclapi.h>
#	include <dxgi1_6.h>
#	include <windows.h>
#	include <securitybaseapi.h>
#endif

namespace Ilum::Vulkan
{
#ifdef CUDA_ENABLE
WindowsSecurityAttributes::WindowsSecurityAttributes()
{
	m_winPSecurityDescriptor = (PSECURITY_DESCRIPTOR) calloc(1, SECURITY_DESCRIPTOR_MIN_LENGTH + 2 * sizeof(void **));

	PSID *ppSID = (PSID *) ((PBYTE) m_winPSecurityDescriptor + SECURITY_DESCRIPTOR_MIN_LENGTH);
	PACL *ppACL = (PACL *) ((PBYTE) ppSID + sizeof(PSID *));

	InitializeSecurityDescriptor(m_winPSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);

	SID_IDENTIFIER_AUTHORITY sidIdentifierAuthority = SECURITY_WORLD_SID_AUTHORITY;
	AllocateAndInitializeSid(&sidIdentifierAuthority, 1, SECURITY_WORLD_RID, 0, 0,
	                         0, 0, 0, 0, 0, ppSID);

	EXPLICIT_ACCESS explicitAccess;
	ZeroMemory(&explicitAccess, sizeof(EXPLICIT_ACCESS));
	explicitAccess.grfAccessPermissions = STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL;
	explicitAccess.grfAccessMode        = SET_ACCESS;
	explicitAccess.grfInheritance       = INHERIT_ONLY;
	explicitAccess.Trustee.TrusteeForm  = TRUSTEE_IS_SID;
	explicitAccess.Trustee.TrusteeType  = TRUSTEE_IS_WELL_KNOWN_GROUP;
	explicitAccess.Trustee.ptstrName    = (LPTSTR) *ppSID;

	SetEntriesInAcl(1, &explicitAccess, NULL, ppACL);

	SetSecurityDescriptorDacl(m_winPSecurityDescriptor, TRUE, *ppACL, FALSE);

	m_winSecurityAttributes.nLength              = sizeof(m_winSecurityAttributes);
	m_winSecurityAttributes.lpSecurityDescriptor = m_winPSecurityDescriptor;
}

SECURITY_ATTRIBUTES *WindowsSecurityAttributes::operator&()
{
	return &m_winSecurityAttributes;
}

WindowsSecurityAttributes::~WindowsSecurityAttributes()
{
	PSID *ppSID =
	    (PSID *) ((PBYTE) m_winPSecurityDescriptor + SECURITY_DESCRIPTOR_MIN_LENGTH);
	PACL *ppACL = (PACL *) ((PBYTE) ppSID + sizeof(PSID *));

	if (*ppSID)
	{
		FreeSid(*ppSID);
	}
	if (*ppACL)
	{
		LocalFree(*ppACL);
	}
	free(m_winPSecurityDescriptor);
}
#endif
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Definitions.hpp
================================================
#pragma once

#include "RHI/RHIDefinitions.hpp"

#include <volk.h>

#include "vk_mem_alloc.h"

#include <unordered_map>

#ifdef _WIN64
#	include <Windows.h>
#endif        // _WIN64

namespace Ilum::Vulkan
{
enum class VulkanFeature
{
	DynamicRendering
};

inline static std::unordered_map<RHIFormat, VkFormat> ToVulkanFormat = {
    {RHIFormat::Undefined, VK_FORMAT_UNDEFINED},
    {RHIFormat::R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM},
    {RHIFormat::B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM},
    {RHIFormat::R16_UINT, VK_FORMAT_R16_UINT},
    {RHIFormat::R16_SINT, VK_FORMAT_R16_SINT},
    {RHIFormat::R16_FLOAT, VK_FORMAT_R16_SFLOAT},
    {RHIFormat::R16G16_UINT, VK_FORMAT_R16G16_UINT},
    {RHIFormat::R16G16_SINT, VK_FORMAT_R16G16_SINT},
    {RHIFormat::R16G16_FLOAT, VK_FORMAT_R16G16_SFLOAT},
    {RHIFormat::R10G10B10A2_UNORM, VK_FORMAT_A2B10G10R10_UNORM_PACK32},
    {RHIFormat::R10G10B10A2_UINT, VK_FORMAT_A2B10G10R10_UINT_PACK32},
    {RHIFormat::R11G11B10_FLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32},
    {RHIFormat::R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_UINT},
    {RHIFormat::R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SINT},
    {RHIFormat::R16G16B16A16_FLOAT, VK_FORMAT_R16G16B16A16_SFLOAT},
    {RHIFormat::R32_UINT, VK_FORMAT_R32_UINT},
    {RHIFormat::R32_SINT, VK_FORMAT_R32_SINT},
    {RHIFormat::R32_FLOAT, VK_FORMAT_R32_SFLOAT},
    {RHIFormat::R32G32_UINT, VK_FORMAT_R32G32_UINT},
    {RHIFormat::R32G32_SINT, VK_FORMAT_R32G32_SINT},
    {RHIFormat::R32G32_FLOAT, VK_FORMAT_R32G32_SFLOAT},
    {RHIFormat::R32G32B32_UINT, VK_FORMAT_R32G32B32_UINT},
    {RHIFormat::R32G32B32_SINT, VK_FORMAT_R32G32B32_SINT},
    {RHIFormat::R32G32B32_FLOAT, VK_FORMAT_R32G32B32_SFLOAT},
    {RHIFormat::R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_UINT},
    {RHIFormat::R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SINT},
    {RHIFormat::R32G32B32A32_FLOAT, VK_FORMAT_R32G32B32A32_SFLOAT},
    {RHIFormat::D32_FLOAT, VK_FORMAT_D32_SFLOAT},
    {RHIFormat::D24_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT},
};

inline static std::unordered_map<uint32_t, VkSampleCountFlagBits> ToVulkanSampleCountFlag = {
    {1, VK_SAMPLE_COUNT_1_BIT},
    {2, VK_SAMPLE_COUNT_2_BIT},
    {4, VK_SAMPLE_COUNT_4_BIT},
    {8, VK_SAMPLE_COUNT_8_BIT},
    {16, VK_SAMPLE_COUNT_16_BIT},
    {32, VK_SAMPLE_COUNT_32_BIT},
    {64, VK_SAMPLE_COUNT_64_BIT},
};

inline static std::unordered_map<RHITextureDimension, VkImageViewType> ToVulkanImageViewType = {
    {RHITextureDimension::Texture1D, VK_IMAGE_VIEW_TYPE_1D},
    {RHITextureDimension::Texture2D, VK_IMAGE_VIEW_TYPE_2D},
    {RHITextureDimension::Texture3D, VK_IMAGE_VIEW_TYPE_3D},
    {RHITextureDimension::TextureCube, VK_IMAGE_VIEW_TYPE_CUBE},
    {RHITextureDimension::Texture1DArray, VK_IMAGE_VIEW_TYPE_1D_ARRAY},
    {RHITextureDimension::Texture2DArray, VK_IMAGE_VIEW_TYPE_2D_ARRAY},
    {RHITextureDimension::TextureCubeArray, VK_IMAGE_VIEW_TYPE_CUBE_ARRAY},
};

inline static std::unordered_map<RHIMemoryUsage, VmaMemoryUsage> ToVmaMemoryUsage = {
    {RHIMemoryUsage::GPU_Only, VMA_MEMORY_USAGE_GPU_ONLY},
    {RHIMemoryUsage::CPU_TO_GPU, VMA_MEMORY_USAGE_CPU_TO_GPU},
    {RHIMemoryUsage::GPU_TO_CPU, VMA_MEMORY_USAGE_GPU_TO_CPU},
};

inline static std::unordered_map<RHIFilter, VkFilter> ToVulkanFilter = {
    {RHIFilter::Linear, VK_FILTER_LINEAR},
    {RHIFilter::Nearest, VK_FILTER_NEAREST},
};

inline static std::unordered_map<RHIMipmapMode, VkSamplerMipmapMode> ToVulkanMipmapMode = {
    {RHIMipmapMode::Linear, VK_SAMPLER_MIPMAP_MODE_LINEAR},
    {RHIMipmapMode::Nearest, VK_SAMPLER_MIPMAP_MODE_NEAREST},
};

inline static std::unordered_map<RHIAddressMode, VkSamplerAddressMode> ToVulkanAddressMode = {
    {RHIAddressMode::Repeat, VK_SAMPLER_ADDRESS_MODE_REPEAT},
    {RHIAddressMode::Mirrored_Repeat, VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT},
    {RHIAddressMode::Clamp_To_Edge, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE},
    {RHIAddressMode::Clamp_To_Border, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER},
    {RHIAddressMode::Mirror_Clamp_To_Edge, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE},
};

inline static std::unordered_map<RHISamplerBorderColor, VkBorderColor> ToVulkanBorderColor = {
    {RHISamplerBorderColor::Float_Transparent_Black, VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK},
    {RHISamplerBorderColor::Int_Transparent_Black, VK_BORDER_COLOR_INT_TRANSPARENT_BLACK},
    {RHISamplerBorderColor::Float_Opaque_Black, VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK},
    {RHISamplerBorderColor::Int_Opaque_Black, VK_BORDER_COLOR_INT_OPAQUE_BLACK},
    {RHISamplerBorderColor::Float_Opaque_White, VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE},
    {RHISamplerBorderColor::Int_Opaque_White, VK_BORDER_COLOR_INT_OPAQUE_WHITE},
};

inline static std::unordered_map<RHIPrimitiveTopology, VkPrimitiveTopology> ToVulkanPrimitiveTopology = {
    {RHIPrimitiveTopology::Point, VK_PRIMITIVE_TOPOLOGY_POINT_LIST},
    {RHIPrimitiveTopology::Line, VK_PRIMITIVE_TOPOLOGY_LINE_LIST},
    {RHIPrimitiveTopology::Triangle, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST},
    {RHIPrimitiveTopology::Patch, VK_PRIMITIVE_TOPOLOGY_PATCH_LIST},
};

inline static std::unordered_map<RHIPolygonMode, VkPolygonMode> ToVulkanPolygonMode = {
    {RHIPolygonMode::Solid, VK_POLYGON_MODE_FILL},
    {RHIPolygonMode::Wireframe, VK_POLYGON_MODE_LINE},
};

inline static std::unordered_map<RHIBlendFactor, VkBlendFactor> ToVulkanBlendFactor = {
    {RHIBlendFactor::Zero, VK_BLEND_FACTOR_ZERO},
    {RHIBlendFactor::One, VK_BLEND_FACTOR_ONE},
    {RHIBlendFactor::Src_Color, VK_BLEND_FACTOR_SRC_COLOR},
    {RHIBlendFactor::One_Minus_Src_Color, VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR},
    {RHIBlendFactor::Dst_Color, VK_BLEND_FACTOR_DST_COLOR},
    {RHIBlendFactor::One_Minus_Dst_Color, VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR},
    {RHIBlendFactor::Src_Alpha, VK_BLEND_FACTOR_SRC_ALPHA},
    {RHIBlendFactor::One_Minus_Src_Alpha, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA},
    {RHIBlendFactor::Dst_Alpha, VK_BLEND_FACTOR_DST_ALPHA},
    {RHIBlendFactor::One_Minus_Dst_Alpha, VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA},
    {RHIBlendFactor::Constant_Color, VK_BLEND_FACTOR_CONSTANT_COLOR},
    {RHIBlendFactor::One_Minus_Constant_Color, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR},
    {RHIBlendFactor::Constant_Alpha, VK_BLEND_FACTOR_CONSTANT_ALPHA},
    {RHIBlendFactor::One_Minus_Constant_Alpha, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA},
    {RHIBlendFactor::Src_Alpha_Saturate, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE},
    {RHIBlendFactor::Src1_Color, VK_BLEND_FACTOR_SRC1_COLOR},
    {RHIBlendFactor::One_Minus_Src1_Color, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR},
    {RHIBlendFactor::Src1_Alpha, VK_BLEND_FACTOR_SRC1_ALPHA},
    {RHIBlendFactor::One_Minus_Src1_Alpha, VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA},
};

inline static std::unordered_map<RHIBlendOp, VkBlendOp> ToVulkanBlendOp = {
    {RHIBlendOp::Add, VK_BLEND_OP_ADD},
    {RHIBlendOp::Subtract, VK_BLEND_OP_SUBTRACT},
    {RHIBlendOp::Reverse_Subtract, VK_BLEND_OP_REVERSE_SUBTRACT},
    {RHIBlendOp::Min, VK_BLEND_OP_MIN},
    {RHIBlendOp::Max, VK_BLEND_OP_MAX},
};

inline static std::unordered_map<RHILogicOp, VkLogicOp> ToVulkanLogicOp = {
    {RHILogicOp::Clear, VK_LOGIC_OP_CLEAR},
    {RHILogicOp::And, VK_LOGIC_OP_AND},
    {RHILogicOp::And_Reverse, VK_LOGIC_OP_AND_REVERSE},
    {RHILogicOp::Copy, VK_LOGIC_OP_COPY},
    {RHILogicOp::And_Inverted, VK_LOGIC_OP_AND_INVERTED},
    {RHILogicOp::No_Op, VK_LOGIC_OP_NO_OP},
    {RHILogicOp::XOR, VK_LOGIC_OP_XOR},
    {RHILogicOp::Or, VK_LOGIC_OP_OR},
    {RHILogicOp::Nor, VK_LOGIC_OP_NOR},
    {RHILogicOp::Equivalent, VK_LOGIC_OP_EQUIVALENT},
    {RHILogicOp::Invert, VK_LOGIC_OP_INVERT},
    {RHILogicOp::Or_Reverse, VK_LOGIC_OP_OR_REVERSE},
    {RHILogicOp::Copy_Inverted, VK_LOGIC_OP_COPY_INVERTED},
    {RHILogicOp::Or_Inverted, VK_LOGIC_OP_OR_INVERTED},
    {RHILogicOp::Nand, VK_LOGIC_OP_NAND},
    {RHILogicOp::Set, VK_LOGIC_OP_SET},
};

inline static std::unordered_map<RHICompareOp, VkCompareOp> ToVulkanCompareOp = {
    {RHICompareOp::Never, VK_COMPARE_OP_NEVER},
    {RHICompareOp::Less, VK_COMPARE_OP_LESS},
    {RHICompareOp::Equal, VK_COMPARE_OP_EQUAL},
    {RHICompareOp::Less_Or_Equal, VK_COMPARE_OP_LESS_OR_EQUAL},
    {RHICompareOp::Greater, VK_COMPARE_OP_GREATER},
    {RHICompareOp::Not_Equal, VK_COMPARE_OP_NOT_EQUAL},
    {RHICompareOp::Greater_Or_Equal, VK_COMPARE_OP_GREATER_OR_EQUAL},
    {RHICompareOp::Always, VK_COMPARE_OP_ALWAYS},
};

inline static std::unordered_map<RHICullMode, VkCullModeFlagBits> ToVulkanCullMode = {
    {RHICullMode::None, VK_CULL_MODE_NONE},
    {RHICullMode::Front, VK_CULL_MODE_FRONT_BIT},
    {RHICullMode::Back, VK_CULL_MODE_BACK_BIT},
};

inline static std::unordered_map<RHIFrontFace, VkFrontFace> ToVulkanFrontFace = {
    {RHIFrontFace::Clockwise, VK_FRONT_FACE_CLOCKWISE},
    {RHIFrontFace::Clockwise, VK_FRONT_FACE_COUNTER_CLOCKWISE},
};

inline static std::unordered_map<uint32_t, VkSampleCountFlagBits> ToVulkanSampleCount = {
    {1, VK_SAMPLE_COUNT_1_BIT},
    {2, VK_SAMPLE_COUNT_2_BIT},
    {4, VK_SAMPLE_COUNT_4_BIT},
    {8, VK_SAMPLE_COUNT_8_BIT},
    {16, VK_SAMPLE_COUNT_16_BIT},
    {32, VK_SAMPLE_COUNT_32_BIT},
    {64, VK_SAMPLE_COUNT_64_BIT},
};

inline static std::unordered_map<RHIShaderStage, VkShaderStageFlagBits> ToVulkanShaderStage = {
    {RHIShaderStage::Vertex, VK_SHADER_STAGE_VERTEX_BIT},
    {RHIShaderStage::TessellationControl, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT},
    {RHIShaderStage::TessellationEvaluation, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT},
    {RHIShaderStage::Geometry, VK_SHADER_STAGE_GEOMETRY_BIT},
    {RHIShaderStage::Fragment, VK_SHADER_STAGE_FRAGMENT_BIT},
    {RHIShaderStage::Compute, VK_SHADER_STAGE_COMPUTE_BIT},
    {RHIShaderStage::RayGen, VK_SHADER_STAGE_RAYGEN_BIT_KHR},
    {RHIShaderStage::AnyHit, VK_SHADER_STAGE_ANY_HIT_BIT_KHR},
    {RHIShaderStage::ClosestHit, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR},
    {RHIShaderStage::Miss, VK_SHADER_STAGE_MISS_BIT_KHR},
    {RHIShaderStage::Intersection, VK_SHADER_STAGE_INTERSECTION_BIT_KHR},
    {RHIShaderStage::Callable, VK_SHADER_STAGE_CALLABLE_BIT_KHR},
    {RHIShaderStage::Mesh, VK_SHADER_STAGE_MESH_BIT_EXT},
    {RHIShaderStage::Task, VK_SHADER_STAGE_TASK_BIT_EXT},
};

inline static std::unordered_map<RHIVertexInputRate, VkVertexInputRate> ToVulkanVertexInputRate = {
    {RHIVertexInputRate::Instance, VK_VERTEX_INPUT_RATE_INSTANCE},
    {RHIVertexInputRate::Vertex, VK_VERTEX_INPUT_RATE_VERTEX},
};

inline static std::unordered_map<RHILoadAction, VkAttachmentLoadOp> ToVulkanLoadOp = {
    {RHILoadAction::DontCare, VK_ATTACHMENT_LOAD_OP_DONT_CARE},
    {RHILoadAction::Clear, VK_ATTACHMENT_LOAD_OP_CLEAR},
    {RHILoadAction::Load, VK_ATTACHMENT_LOAD_OP_LOAD},
};

inline static std::unordered_map<RHIStoreAction, VkAttachmentStoreOp> ToVulkanStoreOp = {
    {RHIStoreAction::DontCare, VK_ATTACHMENT_STORE_OP_DONT_CARE},
    {RHIStoreAction::Store, VK_ATTACHMENT_STORE_OP_STORE},
};

inline static VkImageUsageFlags ToVulkanImageUsage(RHITextureUsage usage)
{
	VkImageUsageFlags vk_usage = 0;

	if (usage & RHITextureUsage::Transfer)
	{
		vk_usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
	}
	if (usage & RHITextureUsage::ShaderResource)
	{
		vk_usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
	}
	if (usage & RHITextureUsage::UnorderedAccess)
	{
		vk_usage |= VK_IMAGE_USAGE_STORAGE_BIT;
	}

	return vk_usage;
}

inline static VkBufferUsageFlags ToVulkanBufferUsage(RHIBufferUsage usage)
{
	VkBufferUsageFlags vk_usage = 0;

	if (usage & RHIBufferUsage::AccelerationStructure)
	{
		vk_usage |= VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR |
		            VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR;
	}
	if (usage & RHIBufferUsage::Index)
	{
		vk_usage |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR;
	}
	if (usage & RHIBufferUsage::Vertex)
	{
		vk_usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR;
	}
	if (usage & RHIBufferUsage::Indirect)
	{
		vk_usage |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
	}
	if (usage & RHIBufferUsage::Transfer)
	{
		vk_usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
		            VK_BUFFER_USAGE_TRANSFER_DST_BIT;
	}
	if (usage & RHIBufferUsage::ConstantBuffer)
	{
		vk_usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
	}
	if (usage & RHIBufferUsage::UnorderedAccess)
	{
		vk_usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
		            VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
	}
	if (usage & RHIBufferUsage::ShaderResource)
	{
		vk_usage |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
	}

	return vk_usage;
}

inline static VkShaderStageFlags ToVulkanShaderStages(RHIShaderStage stage)
{
	VkShaderStageFlags flag = 0;

	if (stage & RHIShaderStage::Compute)
	{
		flag |= VK_SHADER_STAGE_COMPUTE_BIT;
	}
	if (stage & RHIShaderStage::Vertex)
	{
		flag |= VK_SHADER_STAGE_VERTEX_BIT;
	}
	if (stage & RHIShaderStage::Fragment)
	{
		flag |= VK_SHADER_STAGE_FRAGMENT_BIT;
	}
	if (stage & RHIShaderStage::TessellationControl)
	{
		flag |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
	}
	if (stage & RHIShaderStage::TessellationEvaluation)
	{
		flag |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
	}
	if (stage & RHIShaderStage::Geometry)
	{
		flag |= VK_SHADER_STAGE_GEOMETRY_BIT;
	}
	if (stage & RHIShaderStage::RayGen)
	{
		flag |= VK_SHADER_STAGE_RAYGEN_BIT_KHR;
	}
	if (stage & RHIShaderStage::AnyHit)
	{
		flag |= VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
	}
	if (stage & RHIShaderStage::ClosestHit)
	{
		flag |= VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
	}
	if (stage & RHIShaderStage::Miss)
	{
		flag |= VK_SHADER_STAGE_MISS_BIT_KHR;
	}
	if (stage & RHIShaderStage::Intersection)
	{
		flag |= VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
	}
	if (stage & RHIShaderStage::Callable)
	{
		flag |= VK_SHADER_STAGE_CALLABLE_BIT_KHR;
	}
	if (stage & RHIShaderStage::Task)
	{
		flag |= VK_SHADER_STAGE_TASK_BIT_NV;
	}
	if (stage & RHIShaderStage::Mesh)
	{
		flag |= VK_SHADER_STAGE_MESH_BIT_NV;
	}

	return flag;
}

#ifdef CUDA_ENABLE
class WindowsSecurityAttributes
{
  public:
	WindowsSecurityAttributes();

	SECURITY_ATTRIBUTES *operator&();

	~WindowsSecurityAttributes();

  protected:
	SECURITY_ATTRIBUTES  m_winSecurityAttributes;
	PSECURITY_DESCRIPTOR m_winPSecurityDescriptor;
};
#endif
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Descriptor.cpp
================================================
#include "Descriptor.hpp"
#include "AccelerationStructure.hpp"
#include "Buffer.hpp"
#include "Definitions.hpp"
#include "Device.hpp"
#include "Sampler.hpp"
#include "Texture.hpp"

namespace Ilum::Vulkan
{
inline static std::unordered_map<std::thread::id, VkDescriptorPool> DescriptorPools;
inline static std::unordered_map<size_t, VkDescriptorSetLayout>     DescriptorSetLayouts;
inline static std::unordered_map<size_t, VkDescriptorSet>           DescriptorSet;

inline static std::atomic<uint32_t> DescriptorCount    = 0;
inline static uint32_t              MaxDescriptorCount = 16384ul;

inline static std::unordered_map<DescriptorType, VkDescriptorType> DescriptorTypeMap = {
    {DescriptorType::Sampler, VK_DESCRIPTOR_TYPE_SAMPLER},
    {DescriptorType::TextureSRV, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
    {DescriptorType::TextureUAV, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE},
    {DescriptorType::ConstantBuffer, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
    {DescriptorType::StructuredBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER},
    {DescriptorType::AccelerationStructure, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR},
};

Descriptor::Descriptor(RHIDevice *device, const ShaderMeta &meta) :
    RHIDescriptor(device, meta)
{
	DescriptorCount.fetch_add(1);

	std::unordered_map<uint32_t, ShaderMeta> set_meta;
	for (auto &descriptor : m_meta.descriptors)
	{
		set_meta[descriptor.set].descriptors.emplace_back(descriptor);
		HashCombine(
		    set_meta[descriptor.set].hash,
		    descriptor.array_size,
		    descriptor.binding,
		    descriptor.name,
		    descriptor.set,
		    descriptor.stage,
		    descriptor.type);

		m_binding_hash[descriptor.name]      = 0;
		m_descriptor_lookup[descriptor.name] = std::make_pair(descriptor.set, descriptor.binding);

		switch (descriptor.type)
		{
			case DescriptorType::TextureSRV:
				m_texture_resolves.emplace(descriptor.name, TextureResolve{descriptor.set, descriptor.binding, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL});
				break;
			case DescriptorType::TextureUAV:
				m_texture_resolves.emplace(descriptor.name, TextureResolve{descriptor.set, descriptor.binding, VK_IMAGE_LAYOUT_GENERAL});
				break;
			case DescriptorType::Sampler:
				m_texture_resolves.emplace(descriptor.name, TextureResolve{descriptor.set, descriptor.binding});
				break;
			case DescriptorType::ConstantBuffer:
			case DescriptorType::StructuredBuffer:
				m_buffer_resolves.emplace(descriptor.name, BufferResolve{descriptor.set, descriptor.binding});
				break;
			case DescriptorType::AccelerationStructure:
				m_acceleration_structure_resolves.emplace(descriptor.name, AccelerationStructureResolve{descriptor.set, descriptor.binding});
				break;
			default:
				break;
		}
	}

	for (auto &constant : m_meta.constants)
	{
		if (m_constant_resolves.find(constant.name) != m_constant_resolves.end())
		{
			m_constant_resolves[constant.name].stage |= ToVulkanShaderStages(constant.stage);
		}
		else
		{
			m_constant_resolves.emplace(
			    constant.name,
			    ConstantResolve{
			        std::vector<uint8_t>(constant.size),
			        constant.offset,
			        ToVulkanShaderStages(constant.stage)});
		}
	}

	for (auto &[set, meta] : set_meta)
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		// Create descriptor set layout
		VkDescriptorSetLayout layout = VK_NULL_HANDLE;
		if (DescriptorSetLayouts.find(meta.hash) == DescriptorSetLayouts.end())
		{
			layout = CreateDescriptorSetLayout(meta);
			DescriptorSetLayouts.emplace(meta.hash, layout);
		}
		else
		{
			layout = DescriptorSetLayouts[meta.hash];
		}
		m_descriptor_set_layouts.emplace(set, layout);

		m_binding_dirty.emplace(set, false);
	}
}

Descriptor ::~Descriptor()
{
	m_descriptor_set_layouts.clear();
	m_descriptor_sets.clear();

	DescriptorCount.fetch_sub(1);

	if (DescriptorCount == 0)
	{
		for (auto &[thread_id, descriptor_pool] : DescriptorPools)
		{
			vkDestroyDescriptorPool(static_cast<Device *>(p_device)->GetDevice(), descriptor_pool, nullptr);
			descriptor_pool = VK_NULL_HANDLE;
		}
		for (auto &[hash, layout] : DescriptorSetLayouts)
		{
			vkDestroyDescriptorSetLayout(static_cast<Device *>(p_device)->GetDevice(), layout, nullptr);
		}
		DescriptorSetLayouts.clear();
	}
}

RHIDescriptor &Descriptor::BindTexture(const std::string &name, RHITexture *texture, RHITextureDimension dimension)
{
	TextureRange range = {};
	range.dimension    = dimension;
	range.base_layer   = 0;
	range.layer_count  = texture->GetDesc().layers;
	range.base_mip     = 0;
	range.mip_count    = texture->GetDesc().mips;

	return BindTexture(name, texture, range);
}

RHIDescriptor &Descriptor::BindTexture(const std::string &name, RHITexture *texture, const TextureRange &range)
{
	if (m_binding_hash.find(name) == m_binding_hash.end())
	{
		return *this;
	}

	size_t hash = 0;
	HashCombine(hash, texture, range.dimension, range.base_mip, range.mip_count, range.base_layer, range.layer_count);

	if (m_binding_hash[name] != hash)
	{
		VkImageView view = static_cast<Texture *>(texture)->GetView(range);

		m_texture_resolves[name].views = {view};
		m_binding_hash[name]           = hash;

		m_binding_dirty[m_descriptor_lookup[name].first] = true;
	}

	return *this;
}

RHIDescriptor &Descriptor::BindTexture(const std::string &name, const std::vector<RHITexture *> &textures, RHITextureDimension dimension)
{
	if (m_binding_hash.find(name) == m_binding_hash.end())
	{
		return *this;
	}

	size_t hash = 0;
	HashCombine(hash, textures, dimension);

	if (m_binding_hash[name] != hash)
	{
		m_texture_resolves[name].views.clear();
		m_texture_resolves[name].views.reserve(textures.size());

		for (auto *texture : textures)
		{
			TextureRange range = {};
			range.dimension    = dimension;
			range.base_layer   = 0;
			range.base_mip     = 0;
			range.layer_count  = texture->GetDesc().layers;
			range.mip_count    = texture->GetDesc().mips;
			VkImageView view   = static_cast<Texture *>(texture)->GetView(range);

			m_texture_resolves[name].views.push_back(view);
		}

		m_binding_hash[name] = hash;

		m_binding_dirty[m_descriptor_lookup[name].first] = true;
	}

	return *this;
}

RHIDescriptor &Descriptor::BindSampler(const std::string &name, RHISampler *sampler)
{
	if (m_binding_hash.find(name) == m_binding_hash.end())
	{
		return *this;
	}

	size_t hash = 0;
	HashCombine(hash, sampler);

	if (m_binding_hash[name] != hash)
	{
		m_texture_resolves[name].samplers = {static_cast<Sampler *>(sampler)->GetHandle()};

		m_binding_hash[name] = hash;

		m_binding_dirty[m_descriptor_lookup[name].first] = true;
	}

	return *this;
}

RHIDescriptor &Descriptor::BindSampler(const std::string &name, const std::vector<RHISampler *> &samplers)
{
	if (m_binding_hash.find(name) == m_binding_hash.end())
	{
		return *this;
	}

	size_t hash = 0;
	HashCombine(hash, samplers);

	if (m_binding_hash[name] != hash)
	{
		m_texture_resolves[name].samplers.clear();
		m_texture_resolves[name].samplers.reserve(samplers.size());

		for (auto *sampler : samplers)
		{
			m_texture_resolves[name].samplers.push_back(static_cast<Sampler *>(sampler)->GetHandle());
		}

		m_binding_hash[name] = hash;

		m_binding_dirty[m_descriptor_lookup[name].first] = true;
	}

	return *this;
}

RHIDescriptor &Descriptor::BindBuffer(const std::string &name, RHIBuffer *buffer)
{
	if (m_binding_hash.find(name) == m_binding_hash.end())
	{
		return *this;
	}

	if (buffer)
	{
		return BindBuffer(name, buffer, 0, buffer->GetDesc().size);
	}

	return *this;
}

RHIDescriptor &Descriptor::BindBuffer(const std::string &name, RHIBuffer *buffer, size_t offset, size_t range)
{
	if (m_binding_hash.find(name) == m_binding_hash.end())
	{
		return *this;
	}

	size_t   hash          = 0;
	VkBuffer buffer_handle = static_cast<Buffer *>(buffer)->GetHandle();
	HashCombine(hash, buffer_handle, offset, range);

	if (m_binding_hash[name] != hash)
	{
		m_buffer_resolves[name].buffers = {buffer_handle};
		m_buffer_resolves[name].ranges  = {range};
		m_buffer_resolves[name].offsets = {offset};

		m_binding_hash[name] = hash;

		m_binding_dirty[m_descriptor_lookup[name].first] = true;
	}

	return *this;
}

RHIDescriptor &Descriptor::BindBuffer(const std::string &name, const std::vector<RHIBuffer *> &buffers)
{
	if (m_binding_hash.find(name) == m_binding_hash.end())
	{
		return *this;
	}

	size_t hash = 0;
	HashCombine(hash, buffers);

	if (m_binding_hash[name] != hash)
	{
		m_buffer_resolves[name].buffers.clear();
		m_buffer_resolves[name].buffers.reserve(buffers.size());
		m_buffer_resolves[name].ranges.clear();
		m_buffer_resolves[name].ranges.reserve(buffers.size());
		m_buffer_resolves[name].offsets.clear();
		m_buffer_resolves[name].offsets.reserve(buffers.size());

		for (auto *buffer : buffers)
		{
			m_buffer_resolves[name].buffers.push_back(static_cast<Buffer *>(buffer)->GetHandle());
			m_buffer_resolves[name].ranges.push_back(buffer->GetDesc().size);
			m_buffer_resolves[name].offsets.push_back(0);
		}

		m_binding_hash[name] = hash;

		m_binding_dirty[m_descriptor_lookup[name].first] = true;
	}

	return *this;
}

RHIDescriptor &Descriptor::BindConstant(const std::string &name, const void *constant)
{
	std::memcpy(m_constant_resolves[name].data.data(), constant, m_constant_resolves[name].data.size());
	return *this;
}

RHIDescriptor &Descriptor::BindAccelerationStructure(const std::string &name, RHIAccelerationStructure *acceleration_structure)
{
	if (m_binding_hash.find(name) == m_binding_hash.end())
	{
		return *this;
	}

	size_t hash = Hash(static_cast<AccelerationStructure *>(acceleration_structure)->GetHandle());
	if (m_binding_hash[name] != hash)
	{
		m_acceleration_structure_resolves[name].acceleration_structures = {static_cast<AccelerationStructure *>(acceleration_structure)->GetHandle()};
		m_binding_hash[name]                                            = hash;
		m_binding_dirty[m_descriptor_lookup[name].first]                = true;
	}

	return *this;
}

const std::unordered_map<uint32_t, VkDescriptorSet> &Descriptor::GetDescriptorSet()
{
	// Check update
	for (auto &[set, dirty] : m_binding_dirty)
	{
		size_t hash = Hash(m_descriptor_set_layouts.at(set), std::this_thread::get_id());
		for (auto &[name, binding_hash] : m_binding_hash)
		{
			if (m_descriptor_lookup[name].first == set)
			{
				HashCombine(hash, binding_hash);
			}
		}

		if (DescriptorSet.find(hash) != DescriptorSet.end())
		{
			VkDescriptorSet descriptor_set = DescriptorSet[hash];
			m_descriptor_sets[set]         = descriptor_set;
			return m_descriptor_sets;
		}

		if (DescriptorSet.size() >= MaxDescriptorCount)
		{
			p_device->WaitIdle();
			vkResetDescriptorPool(static_cast<Device *>(p_device)->GetDevice(), CreateDescriptorPool(std::this_thread::get_id()), 0);
			DescriptorSet.clear();
		}

		// Allocate descriptor set
		VkDescriptorSetAllocateInfo allocate_info = {};
		allocate_info.sType                       = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
		allocate_info.descriptorPool              = CreateDescriptorPool(std::this_thread::get_id());
		allocate_info.descriptorSetCount          = 1;
		allocate_info.pSetLayouts                 = &m_descriptor_set_layouts.at(set);

		VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
		vkAllocateDescriptorSets(static_cast<Device *>(p_device)->GetDevice(), &allocate_info, &descriptor_set);

		{
			std::lock_guard<std::mutex> lock(m_mutex);
			DescriptorSet.emplace(hash, descriptor_set);
			m_descriptor_sets[set] = descriptor_set;
		}

		std::vector<VkWriteDescriptorSet>                         write_sets;
		std::vector<std::vector<VkDescriptorImageInfo>>           image_infos                                  = {};
		std::vector<std::vector<VkDescriptorBufferInfo>>          buffer_infos                                 = {};
		std::vector<VkWriteDescriptorSetAccelerationStructureKHR> write_descriptor_set_acceleration_structures = {};
		for (auto &descriptor : m_meta.descriptors)
		{
			if (descriptor.set == set)
			{
				bool     is_texture       = false;
				bool     is_buffer        = false;
				bool     is_as            = false;
				uint32_t descriptor_count = 0;

				image_infos.push_back({});
				buffer_infos.push_back({});

				// Handle Texture
				if (descriptor.type == DescriptorType::TextureSRV ||
				    descriptor.type == DescriptorType::TextureUAV)
				{
					is_texture = true;
					for (auto &view : m_texture_resolves[descriptor.name].views)
					{
						image_infos.back().push_back(VkDescriptorImageInfo{
						    VK_NULL_HANDLE,
						    view,
						    m_texture_resolves[descriptor.name].layout});
					}
					descriptor_count = static_cast<uint32_t>(image_infos.back().size());
				}

				// Handle Sampler
				if (descriptor.type == DescriptorType::Sampler)
				{
					is_texture = true;
					for (auto &sampler : m_texture_resolves[descriptor.name].samplers)
					{
						image_infos.back().push_back(VkDescriptorImageInfo{
						    sampler,
						    VK_NULL_HANDLE,
						    VK_IMAGE_LAYOUT_UNDEFINED});
					}
					descriptor_count = static_cast<uint32_t>(image_infos.back().size());
				}

				// Handle Buffer
				if (descriptor.type == DescriptorType::ConstantBuffer ||
				    descriptor.type == DescriptorType::StructuredBuffer)
				{
					is_buffer = true;
					for (uint32_t i = 0; i < m_buffer_resolves[descriptor.name].buffers.size(); i++)
					{
						buffer_infos.back().push_back(VkDescriptorBufferInfo{
						    m_buffer_resolves[descriptor.name].buffers[i],
						    m_buffer_resolves[descriptor.name].offsets[i],
						    m_buffer_resolves[descriptor.name].ranges[i]});
					}
					descriptor_count = static_cast<uint32_t>(buffer_infos.back().size());
				}

				// Handle Acceleration Structure
				if (descriptor.type == DescriptorType::AccelerationStructure)
				{
					is_as = true;

					VkWriteDescriptorSetAccelerationStructureKHR write_set_as = {};
					write_set_as.sType                                        = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
					write_set_as.accelerationStructureCount                   = static_cast<uint32_t>(m_acceleration_structure_resolves[descriptor.name].acceleration_structures.size());
					write_set_as.pAccelerationStructures                      = m_acceleration_structure_resolves[descriptor.name].acceleration_structures.data();
					write_descriptor_set_acceleration_structures.push_back(write_set_as);

					descriptor_count = static_cast<uint32_t>(m_acceleration_structure_resolves[descriptor.name].acceleration_structures.size());
				}

				VkWriteDescriptorSet write_set = {};
				write_set.sType                = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
				write_set.dstSet               = m_descriptor_sets[set];
				write_set.dstBinding           = descriptor.binding;
				write_set.dstArrayElement      = 0;
				write_set.descriptorCount      = descriptor_count;
				write_set.descriptorType       = DescriptorTypeMap[descriptor.type];
				write_set.pImageInfo           = is_texture ? image_infos.back().data() : nullptr;
				write_set.pBufferInfo          = is_buffer ? buffer_infos.back().data() : nullptr;
				write_set.pTexelBufferView     = nullptr;
				write_set.pNext                = is_as ? &write_descriptor_set_acceleration_structures.back() : nullptr;
				write_sets.push_back(write_set);
			}
		}

		vkUpdateDescriptorSets(static_cast<Device *>(p_device)->GetDevice(), static_cast<uint32_t>(write_sets.size()), write_sets.data(), 0, nullptr);
	}

	return m_descriptor_sets;
}

const std::unordered_map<uint32_t, VkDescriptorSetLayout> &Descriptor::GetDescriptorSetLayout()
{
	return m_descriptor_set_layouts;
}

const std::map<std::string, ConstantResolve> &Descriptor::GetConstantResolve() const
{
	return m_constant_resolves;
}

VkDescriptorPool Descriptor::CreateDescriptorPool(const std::thread::id &thread_id)
{
	if (DescriptorPools.find(thread_id) != DescriptorPools.end())
	{
		return DescriptorPools.at(thread_id);
	}

	VkPhysicalDeviceProperties properties = {};
	vkGetPhysicalDeviceProperties(static_cast<Device *>(p_device)->GetPhysicalDevice(), &properties);

	VkDescriptorPoolSize pool_sizes[] =
	    {
	        {VK_DESCRIPTOR_TYPE_SAMPLER, properties.limits.maxDescriptorSetSamplers},
	        {VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, properties.limits.maxDescriptorSetSampledImages},
	        {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, properties.limits.maxDescriptorSetStorageImages},
	        {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, properties.limits.maxDescriptorSetUniformBuffers},
	        {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, properties.limits.maxDescriptorSetStorageBuffers},
	        {VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1024},
	    };
	// Create descriptor pool
	VkDescriptorPoolCreateInfo descriptor_pool_create_info = {};
	descriptor_pool_create_info.sType                      = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
	descriptor_pool_create_info.pPoolSizes                 = pool_sizes;
	descriptor_pool_create_info.poolSizeCount              = 6;
	descriptor_pool_create_info.maxSets                    = MaxDescriptorCount;
	descriptor_pool_create_info.flags                      = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT | VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;

	{
		std::lock_guard<std::mutex> lock(m_mutex);
		DescriptorPools[thread_id] = VK_NULL_HANDLE;
		vkCreateDescriptorPool(static_cast<Device *>(p_device)->GetDevice(), &descriptor_pool_create_info, nullptr, &DescriptorPools[thread_id]);
	}

	return DescriptorPools[thread_id];
}

VkDescriptorSetLayout Descriptor::CreateDescriptorSetLayout(const ShaderMeta &meta)
{
	std::vector<VkDescriptorBindingFlags>     descriptor_binding_flags       = {};
	std::vector<VkDescriptorSetLayoutBinding> descriptor_set_layout_bindings = {};

	VkDescriptorBindingFlags binding_flags = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT;

	for (const auto &descriptor : meta.descriptors)
	{
		VkDescriptorSetLayoutBinding layout_binding = {};
		layout_binding.binding                      = descriptor.binding;
		layout_binding.descriptorType               = DescriptorTypeMap[descriptor.type];
		layout_binding.stageFlags                   = ToVulkanShaderStages(descriptor.stage);
		layout_binding.descriptorCount              = descriptor.array_size == 0 ? 16384 : descriptor.array_size;
		descriptor_set_layout_bindings.push_back(layout_binding);
		if (descriptor.type != DescriptorType::AccelerationStructure)
		{
			descriptor_binding_flags.push_back(binding_flags | (descriptor.array_size == 0 ? VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT : 0));
		}
		else
		{
			descriptor_binding_flags.push_back(0);
		}
	}

	VkDescriptorSetLayoutCreateInfo descriptor_set_layout_create_info = {};
	descriptor_set_layout_create_info.sType                           = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
	descriptor_set_layout_create_info.bindingCount                    = static_cast<uint32_t>(descriptor_set_layout_bindings.size());
	descriptor_set_layout_create_info.pBindings                       = descriptor_set_layout_bindings.data();
	descriptor_set_layout_create_info.flags                           = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT;

	VkDescriptorSetLayoutBindingFlagsCreateInfo descriptor_set_layout_binding_flag_create_info = {};
	descriptor_set_layout_binding_flag_create_info.sType                                       = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
	descriptor_set_layout_binding_flag_create_info.bindingCount                                = static_cast<uint32_t>(descriptor_binding_flags.size());
	descriptor_set_layout_binding_flag_create_info.pBindingFlags                               = descriptor_binding_flags.data();

	descriptor_set_layout_create_info.pNext = &descriptor_set_layout_binding_flag_create_info;

	VkDescriptorSetLayout layout = VK_NULL_HANDLE;
	vkCreateDescriptorSetLayout(static_cast<Device *>(p_device)->GetDevice(), &descriptor_set_layout_create_info, nullptr, &layout);

	return layout;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Descriptor.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
struct TextureResolve
{
	uint32_t      set     = 0;
	uint32_t      binding = 0;
	VkImageLayout layout  = VK_IMAGE_LAYOUT_UNDEFINED;

	std::vector<VkImageView> views;
	std::vector<VkSampler>   samplers;
};

struct BufferResolve
{
	uint32_t set     = 0;
	uint32_t binding = 0;

	std::vector<VkBuffer> buffers;
	std::vector<size_t>   ranges;
	std::vector<size_t>   offsets;
};

struct AccelerationStructureResolve
{
	uint32_t set     = 0;
	uint32_t binding = 0;

	std::vector<VkAccelerationStructureKHR> acceleration_structures;
};

struct ConstantResolve
{
	std::vector<uint8_t> data;
	size_t             offset = 0;
	VkShaderStageFlags stage;
};

class Descriptor : public RHIDescriptor
{
  public:
	Descriptor(RHIDevice *device, const ShaderMeta &meta);

	virtual ~Descriptor() override;

	virtual RHIDescriptor &BindTexture(const std::string &name, RHITexture *texture, RHITextureDimension dimension) override;
	virtual RHIDescriptor &BindTexture(const std::string &name, RHITexture *texture, const TextureRange &range) override;
	virtual RHIDescriptor &BindTexture(const std::string &name, const std::vector<RHITexture *> &textures, RHITextureDimension dimension) override;

	virtual RHIDescriptor &BindSampler(const std::string &name, RHISampler *sampler) override;
	virtual RHIDescriptor &BindSampler(const std::string &name, const std::vector<RHISampler *> &samplers) override;

	virtual RHIDescriptor &BindBuffer(const std::string &name, RHIBuffer *buffer) override;
	virtual RHIDescriptor &BindBuffer(const std::string &name, RHIBuffer *buffer, size_t offset, size_t range) override;
	virtual RHIDescriptor &BindBuffer(const std::string &name, const std::vector<RHIBuffer *> &buffers) override;

	virtual RHIDescriptor &BindConstant(const std::string &name, const void *constant) override;

	virtual RHIDescriptor &BindAccelerationStructure(const std::string &name, RHIAccelerationStructure *acceleration_structure) override;

	const std::unordered_map<uint32_t, VkDescriptorSet> &GetDescriptorSet();

	const std::unordered_map<uint32_t, VkDescriptorSetLayout> &GetDescriptorSetLayout();

	const std::map<std::string, ConstantResolve> &GetConstantResolve() const;

  private:
	VkDescriptorPool CreateDescriptorPool(const std::thread::id &thread_id);

	VkDescriptorSetLayout CreateDescriptorSetLayout(const ShaderMeta &meta);

  private:
	std::unordered_map<uint32_t, VkDescriptorSetLayout> m_descriptor_set_layouts;
	std::unordered_map<uint32_t, VkDescriptorSet>       m_descriptor_sets;

	std::unordered_map<std::string, std::pair<uint32_t, uint32_t>> m_descriptor_lookup;

	std::map<std::string, TextureResolve>               m_texture_resolves;
	std::map<std::string, BufferResolve>                m_buffer_resolves;
	std::map<std::string, AccelerationStructureResolve> m_acceleration_structure_resolves;
	std::map<std::string, ConstantResolve>              m_constant_resolves;

	std::unordered_map<std::string, size_t> m_binding_hash;

	std::unordered_map<uint32_t, bool> m_binding_dirty;

	std::mutex m_mutex;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Device.cpp
================================================
#include "Device.hpp"

namespace Ilum::Vulkan
{
// Extension Function
static PFN_vkCreateDebugUtilsMessengerEXT  vkCreateDebugUtilsMessengerEXT;
static VkDebugUtilsMessengerEXT            vkDebugUtilsMessengerEXT;
static PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT;
PFN_vkSetDebugUtilsObjectTagEXT            vkSetDebugUtilsObjectTagEXT;
PFN_vkSetDebugUtilsObjectNameEXT           vkSetDebugUtilsObjectNameEXT;
PFN_vkCmdBeginDebugUtilsLabelEXT           vkCmdBeginDebugUtilsLabelEXT;
PFN_vkCmdEndDebugUtilsLabelEXT             vkCmdEndDebugUtilsLabelEXT;
PFN_vkGetSemaphoreWin32HandleKHR           vkGetSemaphoreWin32HandleKHR;
PFN_vkGetMemoryWin32HandleKHR              vkGetMemoryWin32HandleKHR;

// Vulkan Extension
static const std::vector<const char *> InstanceExtensions =
#ifdef DEBUG
    {"VK_KHR_surface", "VK_KHR_win32_surface", "VK_EXT_debug_report", "VK_EXT_debug_utils"};
#else
    {"VK_KHR_surface", "VK_KHR_win32_surface"};
#endif

static const std::vector<const char *> ValidationLayers =
#ifdef DEBUG
    {"VK_LAYER_KHRONOS_validation"};
#else
    {};
#endif        // DEBUG

const std::vector<VkValidationFeatureEnableEXT> ValidationExtensions =
#ifdef DEBUG
    {VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT};
#else
    {};
#endif        // DEBUG

static const std::vector<const char *> DeviceExtensions = {
    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
    VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME,
    VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME,
    VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME,
    VK_KHR_RAY_QUERY_EXTENSION_NAME,
    VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME,
    VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME,
    VK_EXT_MESH_SHADER_EXTENSION_NAME,
    VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME,
    VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME,
    VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME,
    VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
    VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME,
#ifdef _WIN64
    VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME,
    VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME
#else
    VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME,
    VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME,
#endif
};

// Utilities Function
inline const std::vector<const char *> GetInstanceExtensionSupported(const std::vector<const char *> &extensions)
{
	uint32_t extension_count = 0;
	vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr);

	std::vector<VkExtensionProperties> device_extensions(extension_count);
	vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, device_extensions.data());

	std::vector<const char *> result;

	for (const auto &extension : extensions)
	{
		bool found = false;
		for (const auto &device_extension : device_extensions)
		{
			if (strcmp(extension, device_extension.extensionName) == 0)
			{
				result.emplace_back(extension);
				found = true;
				break;
			}
		}
	}

	return result;
}

inline bool CheckLayerSupported(const char *layer_name)
{
	uint32_t layer_count;
	vkEnumerateInstanceLayerProperties(&layer_count, nullptr);

	std::vector<VkLayerProperties> layers(layer_count);
	vkEnumerateInstanceLayerProperties(&layer_count, layers.data());

	for (const auto &layer : layers)
	{
		if (strcmp(layer.layerName, layer_name) == 0)
		{
			return true;
		}
	}

	return false;
}

inline uint32_t ScorePhysicalDevice(VkPhysicalDevice physical_device, const std::vector<const char *> &device_extensions, std::vector<const char *> &support_device_extensions)
{
	uint32_t score = 0;

	// Check extensions
	uint32_t device_extension_properties_count = 0;
	vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &device_extension_properties_count, nullptr);

	std::vector<VkExtensionProperties> extension_properties(device_extension_properties_count);
	vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &device_extension_properties_count, extension_properties.data());

	for (auto &device_extension : device_extensions)
	{
		for (auto &support_extension : extension_properties)
		{
			if (std::strcmp(device_extension, support_extension.extensionName) == 0)
			{
				support_device_extensions.push_back(device_extension);
				score += 100;
				break;
			}
		}
	}

	VkPhysicalDeviceProperties properties = {};

	vkGetPhysicalDeviceProperties(physical_device, &properties);

	// Score discrete gpu
	if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
	{
		score += 1000;
	}

	score += properties.limits.maxImageDimension2D;
	return score;
}

inline VkPhysicalDevice SelectPhysicalDevice(const std::vector<VkPhysicalDevice> &physical_devices, const std::vector<const char *> &device_extensions, std::vector<const char *> &support_device_extensions)
{
	// Score - GPU
	uint32_t         score  = 0;
	VkPhysicalDevice handle = VK_NULL_HANDLE;
	for (auto &gpu : physical_devices)
	{
		std::vector<const char *> support_extensions;

		uint32_t tmp_score = ScorePhysicalDevice(gpu, device_extensions, support_extensions);
		if (tmp_score > score)
		{
			score  = tmp_score;
			handle = gpu;

			support_device_extensions = std::move(support_extensions);
		}
	}

	return handle;
}

inline std::optional<uint32_t> GetQueueFamilyIndex(const std::vector<VkQueueFamilyProperties> &queue_family_properties, VkQueueFlagBits queue_flag)
{
	// Dedicated queue for compute
	// Try to find a queue family index that supports compute but not graphics
	if (queue_flag & VK_QUEUE_COMPUTE_BIT)
	{
		for (uint32_t i = 0; i < static_cast<uint32_t>(queue_family_properties.size()); i++)
		{
			if ((queue_family_properties[i].queueFlags & queue_flag) && ((queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0))
			{
				return i;
				break;
			}
		}
	}

	// Dedicated queue for transfer
	// Try to find a queue family index that supports transfer but not graphics and compute
	if (queue_flag & VK_QUEUE_TRANSFER_BIT)
	{
		for (uint32_t i = 0; i < static_cast<uint32_t>(queue_family_properties.size()); i++)
		{
			if ((queue_family_properties[i].queueFlags & queue_flag) && ((queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) && ((queue_family_properties[i].queueFlags & VK_QUEUE_COMPUTE_BIT) == 0))
			{
				return i;
				break;
			}
		}
	}

	// For other queue types or if no separate compute queue is present, return the first one to support the requested flags
	for (uint32_t i = 0; i < static_cast<uint32_t>(queue_family_properties.size()); i++)
	{
		if (queue_family_properties[i].queueFlags & queue_flag)
		{
			return i;
			break;
		}
	}

	return std::optional<uint32_t>();
}

inline const std::vector<const char *> GetDeviceExtensionSupport(VkPhysicalDevice physical_device, const std::vector<const char *> &extensions)
{
	std::vector<const char *> result;

	uint32_t device_extension_properties_count = 0;
	vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &device_extension_properties_count, nullptr);

	std::vector<VkExtensionProperties> extension_properties(device_extension_properties_count);
	vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &device_extension_properties_count, extension_properties.data());

	for (auto &device_extension : extensions)
	{
		bool enable = false;
		for (auto &support_extension : extension_properties)
		{
			if (std::strcmp(device_extension, support_extension.extensionName) == 0)
			{
				result.push_back(device_extension);
				enable = true;
				break;
			}
		}
	}

	return result;
}

static inline VKAPI_ATTR VkBool32 VKAPI_CALL ValidationCallback(VkDebugUtilsMessageSeverityFlagBitsEXT msg_severity, VkDebugUtilsMessageTypeFlagsEXT msg_type, const VkDebugUtilsMessengerCallbackDataEXT *callback_data, void *user_data)
{
	if (msg_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT)
	{
		LOG_INFO(callback_data->pMessage);
	}
	else if (msg_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)
	{
		LOG_WARN(callback_data->pMessage);
	}
	else if (msg_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
	{
		LOG_ERROR(callback_data->pMessage);
	}

	return VK_FALSE;
}

void Device::CreateInstance()
{
	// Initialize volk context
	volkInitialize();

	// Config application info
	VkApplicationInfo app_info{VK_STRUCTURE_TYPE_APPLICATION_INFO};

	uint32_t sdk_version = VK_HEADER_VERSION_COMPLETE;
	uint32_t api_version = 0;

	PFN_vkEnumerateInstanceVersion enumerate_instance_version = reinterpret_cast<PFN_vkEnumerateInstanceVersion>(vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceVersion"));

	if (enumerate_instance_version)
	{
		enumerate_instance_version(&api_version);
	}
	else
	{
		api_version = VK_VERSION_1_0;
	}

	if (sdk_version > api_version)
	{
		std::string sdk_version_str = std::to_string(VK_VERSION_MAJOR(sdk_version)) + "." + std::to_string(VK_VERSION_MINOR(sdk_version)) + "." + std::to_string(VK_VERSION_PATCH(sdk_version));
		std::string api_version_str = std::to_string(VK_VERSION_MAJOR(api_version)) + "." + std::to_string(VK_VERSION_MINOR(api_version)) + "." + std::to_string(VK_VERSION_PATCH(api_version));
		LOG_WARN("Driver support version {} is higher than API version {}, upgrade your VulkanSDK!", sdk_version_str, api_version_str);
	}

	app_info.pApplicationName   = "IlumEngine";
	app_info.pEngineName        = "IlumEngine";
	app_info.engineVersion      = VK_MAKE_VERSION(0, 0, 1);
	app_info.applicationVersion = VK_MAKE_VERSION(0, 0, 1);
	app_info.apiVersion         = std::max(sdk_version, api_version);

	// Check out extensions support
	m_supported_instance_extensions = GetInstanceExtensionSupported(InstanceExtensions);

	// Config instance info
	VkInstanceCreateInfo create_info{VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
	create_info.pApplicationInfo        = &app_info;
	create_info.enabledExtensionCount   = static_cast<uint32_t>(m_supported_instance_extensions.size());
	create_info.ppEnabledExtensionNames = m_supported_instance_extensions.data();
	create_info.enabledLayerCount       = 0;

	// Enable validation layers
#ifdef DEBUG
	VkValidationFeaturesEXT validation_features{VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT};
	validation_features.enabledValidationFeatureCount = static_cast<uint32_t>(ValidationExtensions.size());
	validation_features.pEnabledValidationFeatures    = ValidationExtensions.data();

	// Enable validation layer
	for (auto &layer : ValidationLayers)
	{
		if (CheckLayerSupported(layer))
		{
			create_info.enabledLayerCount   = static_cast<uint32_t>(ValidationLayers.size());
			create_info.ppEnabledLayerNames = ValidationLayers.data();
			create_info.pNext               = &validation_features;
			break;
		}
		else
		{
			LOG_ERROR("Validation layer was required, but not avaliable, disabling debugging");
		}
	}
#endif        // DEBUG

	// Create instance
	if (vkCreateInstance(&create_info, nullptr, &m_instance) != VK_SUCCESS)
	{
		LOG_ERROR("Failed to create vulkan instance!");
		return;
	}
	else
	{
		// Config to volk
		volkLoadInstance(m_instance);
	}

	// Initialize instance extension functions
	vkCreateDebugUtilsMessengerEXT  = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(vkGetInstanceProcAddr(m_instance, "vkCreateDebugUtilsMessengerEXT"));
	vkDestroyDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(vkGetInstanceProcAddr(m_instance, "vkDestroyDebugUtilsMessengerEXT"));
	vkSetDebugUtilsObjectTagEXT     = reinterpret_cast<PFN_vkSetDebugUtilsObjectTagEXT>(vkGetInstanceProcAddr(m_instance, "vkSetDebugUtilsObjectTagEXT"));
	vkSetDebugUtilsObjectNameEXT    = reinterpret_cast<PFN_vkSetDebugUtilsObjectNameEXT>(vkGetInstanceProcAddr(m_instance, "vkSetDebugUtilsObjectNameEXT"));
	vkCmdBeginDebugUtilsLabelEXT    = reinterpret_cast<PFN_vkCmdBeginDebugUtilsLabelEXT>(vkGetInstanceProcAddr(m_instance, "vkCmdBeginDebugUtilsLabelEXT"));
	vkCmdEndDebugUtilsLabelEXT      = reinterpret_cast<PFN_vkCmdEndDebugUtilsLabelEXT>(vkGetInstanceProcAddr(m_instance, "vkCmdEndDebugUtilsLabelEXT"));
	vkGetSemaphoreWin32HandleKHR    = reinterpret_cast<PFN_vkGetSemaphoreWin32HandleKHR>(vkGetInstanceProcAddr(m_instance, "vkGetSemaphoreWin32HandleKHR"));
	vkGetMemoryWin32HandleKHR       = reinterpret_cast<PFN_vkGetMemoryWin32HandleKHR>(vkGetInstanceProcAddr(m_instance, "vkGetMemoryWin32HandleKHR"));

	// Enable debugger
#ifdef DEBUG
	if (vkCreateDebugUtilsMessengerEXT)
	{
		VkDebugUtilsMessengerCreateInfoEXT create_info{VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT};
		create_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
		create_info.messageType     = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
		create_info.pfnUserCallback = ValidationCallback;

		vkCreateDebugUtilsMessengerEXT(m_instance, &create_info, nullptr, &vkDebugUtilsMessengerEXT);
	}
#endif        // DEBUG
}

void Device::CreatePhysicalDevice()
{
	uint32_t physical_device_count = 0;
	vkEnumeratePhysicalDevices(m_instance, &physical_device_count, nullptr);

	// Get all physical devices
	std::vector<VkPhysicalDevice> physical_devices(physical_device_count);
	vkEnumeratePhysicalDevices(m_instance, &physical_device_count, physical_devices.data());

	// Select suitable physical device
	m_physical_device = SelectPhysicalDevice(physical_devices, DeviceExtensions, m_supported_device_extensions);

	VkPhysicalDeviceProperties properties = {};
	vkGetPhysicalDeviceProperties(m_physical_device, &properties);
	m_name = properties.deviceName;
}

void Device::CreateLogicalDevice()
{
	// Queue supporting
	uint32_t queue_family_property_count = 0;
	vkGetPhysicalDeviceQueueFamilyProperties(m_physical_device, &queue_family_property_count, nullptr);
	std::vector<VkQueueFamilyProperties> queue_family_properties(queue_family_property_count);
	vkGetPhysicalDeviceQueueFamilyProperties(m_physical_device, &queue_family_property_count, queue_family_properties.data());

	std::optional<uint32_t> graphics_family, compute_family, transfer_family, present_family;

	graphics_family = GetQueueFamilyIndex(queue_family_properties, VK_QUEUE_GRAPHICS_BIT);
	transfer_family = GetQueueFamilyIndex(queue_family_properties, VK_QUEUE_TRANSFER_BIT);
	compute_family  = GetQueueFamilyIndex(queue_family_properties, VK_QUEUE_COMPUTE_BIT);

	VkQueueFlags support_queues = 0;

	if (graphics_family.has_value())
	{
		m_graphics_family = graphics_family.value();
		support_queues |= VK_QUEUE_GRAPHICS_BIT;
	}

	if (compute_family.has_value())
	{
		m_compute_family = compute_family.value();
		support_queues |= VK_QUEUE_COMPUTE_BIT;
	}

	if (transfer_family.has_value())
	{
		m_transfer_family = transfer_family.value();
		support_queues |= VK_QUEUE_TRANSFER_BIT;
	}

	if (!graphics_family)
	{
		throw std::runtime_error("Failed to find queue graphics family support!");
	}

	// Create device queue
	std::vector<VkDeviceQueueCreateInfo> queue_create_infos;

	uint32_t max_count = 0;
	for (auto &queue_family_property : queue_family_properties)
	{
		max_count = max_count < queue_family_property.queueCount ? queue_family_property.queueCount : max_count;
	}

	std::vector<float> queue_priorities(max_count, 1.f);

	if (support_queues & VK_QUEUE_GRAPHICS_BIT)
	{
		VkDeviceQueueCreateInfo graphics_queue_create_info = {};
		graphics_queue_create_info.sType                   = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
		graphics_queue_create_info.queueFamilyIndex        = m_graphics_family;
		graphics_queue_create_info.queueCount              = queue_family_properties[m_graphics_family].queueCount;
		graphics_queue_create_info.pQueuePriorities        = queue_priorities.data();
		queue_create_infos.emplace_back(graphics_queue_create_info);
		m_graphics_queue_count = queue_family_properties[m_graphics_family].queueCount;
	}
	else
	{
		m_graphics_family = 0;
	}

	if (support_queues & VK_QUEUE_COMPUTE_BIT && m_compute_family != m_graphics_family)
	{
		VkDeviceQueueCreateInfo compute_queue_create_info = {};
		compute_queue_create_info.sType                   = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
		compute_queue_create_info.queueFamilyIndex        = m_compute_family;
		compute_queue_create_info.queueCount              = queue_family_properties[m_compute_family].queueCount;
		compute_queue_create_info.pQueuePriorities        = queue_priorities.data();
		queue_create_infos.emplace_back(compute_queue_create_info);
		m_compute_queue_count = queue_family_properties[m_compute_family].queueCount;
	}
	else
	{
		m_compute_family      = m_graphics_family;
		m_compute_queue_count = m_graphics_queue_count;
	}

	if (support_queues & VK_QUEUE_TRANSFER_BIT && m_transfer_family != m_graphics_family && m_transfer_family != m_compute_family)
	{
		VkDeviceQueueCreateInfo transfer_queue_create_info = {};
		transfer_queue_create_info.sType                   = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
		transfer_queue_create_info.queueFamilyIndex        = m_transfer_family;
		transfer_queue_create_info.queueCount              = queue_family_properties[m_transfer_family].queueCount;
		transfer_queue_create_info.pQueuePriorities        = queue_priorities.data();
		queue_create_infos.emplace_back(transfer_queue_create_info);
		m_transfer_queue_count = queue_family_properties[m_transfer_family].queueCount;
	}
	else
	{
		m_transfer_family      = m_graphics_family;
		m_transfer_queue_count = m_graphics_queue_count;
	}

	// Enable logical device features
	VkPhysicalDeviceFeatures2        physical_device_features          = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
	VkPhysicalDeviceVulkan12Features physical_device_vulkan12_features = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES};
	VkPhysicalDeviceVulkan13Features physical_device_vulkan13_features = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES};

	physical_device_features.pNext          = &physical_device_vulkan12_features;
	physical_device_vulkan12_features.pNext = &physical_device_vulkan13_features;

	vkGetPhysicalDeviceFeatures2(m_physical_device, &physical_device_features);

	VkPhysicalDeviceFeatures2        physical_device_features_enable          = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
	VkPhysicalDeviceVulkan12Features physical_device_vulkan12_features_enable = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES};
	VkPhysicalDeviceVulkan13Features physical_device_vulkan13_features_enable = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES};

#define ENABLE_DEVICE_FEATURE(device_feature, device_feature_enable, feature) \
	if (device_feature.feature)                                               \
	{                                                                         \
		device_feature_enable.feature = VK_TRUE;                              \
		m_supported_device_features.push_back(#feature);                      \
	}                                                                         \
	else                                                                      \
	{                                                                         \
		LOG_WARN("Device feature {} is not supported", #feature);             \
	}

	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, sampleRateShading);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, fillModeNonSolid);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, wideLines);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, samplerAnisotropy);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, vertexPipelineStoresAndAtomics);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, fragmentStoresAndAtomics);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, shaderStorageImageExtendedFormats);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, shaderStorageImageWriteWithoutFormat);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, geometryShader);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, tessellationShader);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, multiViewport);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, imageCubeArray);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, robustBufferAccess);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, multiDrawIndirect);
	ENABLE_DEVICE_FEATURE(physical_device_features.features, physical_device_features_enable.features, drawIndirectFirstInstance);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, drawIndirectCount);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, descriptorIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderInputAttachmentArrayDynamicIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderUniformTexelBufferArrayDynamicIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderStorageTexelBufferArrayDynamicIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderUniformBufferArrayNonUniformIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderSampledImageArrayNonUniformIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderStorageBufferArrayNonUniformIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderStorageImageArrayNonUniformIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderInputAttachmentArrayNonUniformIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderUniformTexelBufferArrayNonUniformIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderStorageTexelBufferArrayNonUniformIndexing);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, descriptorBindingUniformBufferUpdateAfterBind);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, descriptorBindingSampledImageUpdateAfterBind);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, descriptorBindingStorageImageUpdateAfterBind);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, descriptorBindingStorageBufferUpdateAfterBind);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, descriptorBindingUniformTexelBufferUpdateAfterBind);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, descriptorBindingStorageTexelBufferUpdateAfterBind);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, descriptorBindingPartiallyBound);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, runtimeDescriptorArray);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, timelineSemaphore);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, bufferDeviceAddress);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderOutputViewportIndex);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan12_features, physical_device_vulkan12_features_enable, shaderOutputLayer);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan13_features, physical_device_vulkan13_features_enable, dynamicRendering);
	ENABLE_DEVICE_FEATURE(physical_device_vulkan13_features, physical_device_vulkan13_features_enable, maintenance4);

	m_vulkan_feature_support[VulkanFeature::DynamicRendering] = physical_device_vulkan13_features_enable.dynamicRendering;

	// Get support extensions
	auto support_extensions = GetDeviceExtensionSupport(m_physical_device, DeviceExtensions);

	{
		m_feature_support[RHIFeature::RayTracing]       = true;
		std::vector<const char *> raytracing_extensions = {
		    VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME,
		    VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME,
		    VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME,
		    VK_KHR_RAY_QUERY_EXTENSION_NAME};

		for (auto &raytracing_extension : raytracing_extensions)
		{
			bool found = false;
			for (auto &extension : m_supported_device_extensions)
			{
				if (strcmp(raytracing_extension, extension) == 0)
				{
					found = true;
					continue;
				}
			}
			if (!found)
			{
				m_feature_support[RHIFeature::RayTracing] = false;
				break;
			}
		}
	};
	{
		m_feature_support[RHIFeature::MeshShading] = false;
		for (auto &extension : m_supported_device_extensions)
		{
			if (strcmp(VK_EXT_MESH_SHADER_EXTENSION_NAME, extension) == 0)
			{
				m_feature_support[RHIFeature::MeshShading] = true;
				break;
			}
		}
	}
	{
		m_feature_support[RHIFeature::BufferDeviceAddress] = false;
		for (auto &feature : m_supported_device_features)
		{
			if (strcmp("bufferDeviceAddress", feature) == 0)
			{
				m_feature_support[RHIFeature::BufferDeviceAddress] = true;
				break;
			}
		}
	}
	{
		m_feature_support[RHIFeature::Bindless] = false;
		for (auto &extension : m_supported_device_features)
		{
			if (strcmp("descriptorIndexing", extension) == 0)
			{
				m_feature_support[RHIFeature::Bindless] = true;
				break;
			}
		}
	}

	VkPhysicalDeviceAccelerationStructureFeaturesKHR acceleration_structure_feature = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR};
	VkPhysicalDeviceRayTracingPipelineFeaturesKHR    ray_tracing_pipeline_feature   = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR};
	VkPhysicalDeviceRayQueryFeaturesKHR              ray_query_features             = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR};
	VkPhysicalDeviceMeshShaderFeaturesEXT            mesh_shader_feature            = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT};

	void  *feature_ptr_head = nullptr;
	void **feature_ptr_tail = nullptr;

	if (IsFeatureSupport(RHIFeature::RayTracing))
	{
		acceleration_structure_feature.accelerationStructure = VK_TRUE;
		ray_tracing_pipeline_feature.rayTracingPipeline      = VK_TRUE;
		ray_query_features.rayQuery                          = VK_TRUE;

		acceleration_structure_feature.pNext = &ray_tracing_pipeline_feature;
		ray_tracing_pipeline_feature.pNext   = &ray_query_features;

		feature_ptr_head = &acceleration_structure_feature;
		feature_ptr_tail = &ray_query_features.pNext;
	}

	if (IsFeatureSupport(RHIFeature::MeshShading))
	{
		mesh_shader_feature.meshShader          = VK_TRUE;
		mesh_shader_feature.taskShader          = VK_TRUE;
		mesh_shader_feature.multiviewMeshShader = VK_TRUE;

		if (!feature_ptr_head)
		{
			feature_ptr_head = &mesh_shader_feature;
		}
		else
		{
			*feature_ptr_tail = &mesh_shader_feature;
		}
		feature_ptr_tail = &mesh_shader_feature.pNext;
	}

	physical_device_vulkan12_features_enable.pNext = &physical_device_vulkan13_features_enable;
	physical_device_vulkan13_features_enable.pNext = feature_ptr_head;

	// Create device
	VkDeviceCreateInfo device_create_info = {};

	device_create_info.sType                = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
	device_create_info.queueCreateInfoCount = static_cast<uint32_t>(queue_create_infos.size());
	device_create_info.pQueueCreateInfos    = queue_create_infos.data();
	if (!ValidationLayers.empty())
	{
		device_create_info.enabledLayerCount   = static_cast<uint32_t>(ValidationLayers.size());
		device_create_info.ppEnabledLayerNames = ValidationLayers.data();
	}
	device_create_info.enabledExtensionCount   = static_cast<uint32_t>(support_extensions.size());
	device_create_info.ppEnabledExtensionNames = support_extensions.data();
	device_create_info.pEnabledFeatures        = &physical_device_features.features;
	device_create_info.pNext                   = &physical_device_vulkan12_features_enable;

	if (vkCreateDevice(m_physical_device, &device_create_info, nullptr, &m_logical_device) != VK_SUCCESS)
	{
		LOG_ERROR("Failed to create logical device!");
		return;
	}

	// Volk load context
	volkLoadDevice(m_logical_device);

	// Create Vma allocator
	VmaVulkanFunctions vma_vulkan_func{};
	vma_vulkan_func.vkGetInstanceProcAddr               = vkGetInstanceProcAddr;
	vma_vulkan_func.vkGetDeviceProcAddr                 = vkGetDeviceProcAddr;
	vma_vulkan_func.vkAllocateMemory                    = vkAllocateMemory;
	vma_vulkan_func.vkBindBufferMemory                  = vkBindBufferMemory;
	vma_vulkan_func.vkBindImageMemory                   = vkBindImageMemory;
	vma_vulkan_func.vkCreateBuffer                      = vkCreateBuffer;
	vma_vulkan_func.vkCreateImage                       = vkCreateImage;
	vma_vulkan_func.vkDestroyBuffer                     = vkDestroyBuffer;
	vma_vulkan_func.vkDestroyImage                      = vkDestroyImage;
	vma_vulkan_func.vkFlushMappedMemoryRanges           = vkFlushMappedMemoryRanges;
	vma_vulkan_func.vkFreeMemory                        = vkFreeMemory;
	vma_vulkan_func.vkGetBufferMemoryRequirements       = vkGetBufferMemoryRequirements;
	vma_vulkan_func.vkGetImageMemoryRequirements        = vkGetImageMemoryRequirements;
	vma_vulkan_func.vkGetPhysicalDeviceMemoryProperties = vkGetPhysicalDeviceMemoryProperties;
	vma_vulkan_func.vkGetPhysicalDeviceProperties       = vkGetPhysicalDeviceProperties;
	vma_vulkan_func.vkInvalidateMappedMemoryRanges      = vkInvalidateMappedMemoryRanges;
	vma_vulkan_func.vkMapMemory                         = vkMapMemory;
	vma_vulkan_func.vkUnmapMemory                       = vkUnmapMemory;
	vma_vulkan_func.vkCmdCopyBuffer                     = vkCmdCopyBuffer;

	VmaAllocatorCreateInfo allocator_info = {};
	allocator_info.physicalDevice         = m_physical_device;
	allocator_info.device                 = m_logical_device;
	allocator_info.instance               = m_instance;
	allocator_info.vulkanApiVersion       = VK_API_VERSION_1_3;
	allocator_info.flags                  = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT;

	VkPhysicalDeviceMemoryProperties memory_properties = {};
	vkGetPhysicalDeviceMemoryProperties(m_physical_device, &memory_properties);

	allocator_info.pVulkanFunctions = &vma_vulkan_func;

	if (vmaCreateAllocator(&allocator_info, &m_allocator) != VK_SUCCESS)
	{
		LOG_FATAL("Failed to create vulkan memory allocator");
	}
}

Device::Device() :
    RHIDevice("Vulkan")
{
	LOG_INFO("Initializing RHI backend Vulkan...");

	CreateInstance();
	CreatePhysicalDevice();
	CreateLogicalDevice();
}

Device::~Device()
{
	vkDeviceWaitIdle(m_logical_device);

	if (m_allocator)
	{
		vmaDestroyAllocator(m_allocator);
	}

	if (m_logical_device)
	{
		vkDestroyDevice(m_logical_device, nullptr);
	}

	if (vkDebugUtilsMessengerEXT)
	{
		vkDestroyDebugUtilsMessengerEXT(m_instance, vkDebugUtilsMessengerEXT, nullptr);
	}

	if (m_instance)
	{
		vkDestroyInstance(m_instance, nullptr);
	}
}

void Device::WaitIdle()
{
	vkDeviceWaitIdle(m_logical_device);
}

bool Device::IsFeatureSupport(RHIFeature feature)
{
	return m_feature_support[feature];
}

bool Device::IsFeatureSupport(VulkanFeature feature)
{
	return m_vulkan_feature_support[feature];
}

VkInstance Device::GetInstance() const
{
	return m_instance;
}

VkPhysicalDevice Device::GetPhysicalDevice() const
{
	return m_physical_device;
}

VkDevice Device::GetDevice() const
{
	return m_logical_device;
}

VmaAllocator Device::GetAllocator() const
{
	return m_allocator;
}

uint32_t Device::GetQueueFamily(RHIQueueFamily family)
{
	switch (family)
	{
		case Ilum::RHIQueueFamily::Graphics:
			return m_graphics_family;
		case Ilum::RHIQueueFamily::Compute:
			return m_compute_family;
		case Ilum::RHIQueueFamily::Transfer:
			return m_transfer_family;
		default:
			break;
	}
	return m_graphics_family;
}

uint32_t Device::GetQueueCount(RHIQueueFamily family)
{
	switch (family)
	{
		case Ilum::RHIQueueFamily::Graphics:
			return m_graphics_queue_count;
		case Ilum::RHIQueueFamily::Compute:
			return m_compute_queue_count;
		case Ilum::RHIQueueFamily::Transfer:
			return m_transfer_queue_count;
		default:
			break;
	}
	return m_graphics_queue_count;
}

void Device::SetVulkanObjectName(const VkDebugUtilsObjectNameInfoEXT &info)
{
#ifdef DEBUG
	vkSetDebugUtilsObjectNameEXT(m_logical_device, &info);
#endif        // DEBUG
}

void Device::BeginDebugUtilsLabel(VkCommandBuffer cmd_buffer, const VkDebugUtilsLabelEXT &label)
{
#ifdef DEBUG
	vkCmdBeginDebugUtilsLabelEXT(cmd_buffer, &label);
#endif        // DEBUG
}

void Device::EndDebugUtilsLabel(VkCommandBuffer cmd_buffer)
{
#ifdef DEBUG
	vkCmdEndDebugUtilsLabelEXT(cmd_buffer);
#endif        // DEBUG
}

void Device::GetSemaphoreWin32Handle(const VkSemaphoreGetWin32HandleInfoKHR *handle_info, HANDLE *handle)
{
	vkGetSemaphoreWin32HandleKHR(m_logical_device, handle_info, handle);
}

void Device::GetMemoryWin32Handle(const VkMemoryGetWin32HandleInfoKHR *handle_info, HANDLE *handle)
{
	vkGetMemoryWin32HandleKHR(m_logical_device, handle_info, handle);
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Device.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Device : public RHIDevice
{
  private:
	void CreateInstance();
	void CreatePhysicalDevice();
	void CreateLogicalDevice();

  public:
	Device();

	virtual ~Device() override;

	virtual void WaitIdle() override;

	virtual bool IsFeatureSupport(RHIFeature feature) override;

	bool IsFeatureSupport(VulkanFeature feature);

	VkInstance       GetInstance() const;
	VkPhysicalDevice GetPhysicalDevice() const;
	VkDevice         GetDevice() const;
	VmaAllocator     GetAllocator() const;

	uint32_t GetQueueFamily(RHIQueueFamily family);
	uint32_t GetQueueCount(RHIQueueFamily family);

	void SetVulkanObjectName(const VkDebugUtilsObjectNameInfoEXT &info);

	void BeginDebugUtilsLabel(VkCommandBuffer cmd_buffer, const VkDebugUtilsLabelEXT &label);
	void EndDebugUtilsLabel(VkCommandBuffer cmd_buffer);

	void GetSemaphoreWin32Handle(const VkSemaphoreGetWin32HandleInfoKHR *handle_info, HANDLE *handle);
	void GetMemoryWin32Handle(const VkMemoryGetWin32HandleInfoKHR *handle_info, HANDLE *handle);

  private:
	// Supported extensions
	std::vector<const char *> m_supported_instance_extensions;
	std::vector<const char *> m_supported_device_features;
	std::vector<const char *> m_supported_device_extensions;

	std::unordered_map<RHIFeature, bool>    m_feature_support;
	std::unordered_map<VulkanFeature, bool> m_vulkan_feature_support;

  private:
	VkInstance       m_instance        = VK_NULL_HANDLE;
	VkPhysicalDevice m_physical_device = VK_NULL_HANDLE;
	VkDevice         m_logical_device  = VK_NULL_HANDLE;
	VmaAllocator     m_allocator       = VK_NULL_HANDLE;

	// Queue Family
	uint32_t m_graphics_family = 0;
	uint32_t m_compute_family  = 0;
	uint32_t m_transfer_family = 0;

	uint32_t m_graphics_queue_count = 0;
	uint32_t m_compute_queue_count  = 0;
	uint32_t m_transfer_queue_count = 0;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Frame.cpp
================================================
#include "Frame.hpp"
#include "Command.hpp"
#include "Device.hpp"
#include "Synchronization.hpp"
#include "Descriptor.hpp"

namespace Ilum::Vulkan
{
Frame::Frame(RHIDevice *device) :
    RHIFrame(device)
{
}

Frame::~Frame()
{
	p_device->WaitIdle();

	m_fences.clear();
	m_semaphores.clear();
	m_commands.clear();

	for (auto &[hash, pool] : m_command_pools)
	{
		vkDestroyCommandPool(static_cast<Device *>(p_device)->GetDevice(), pool, nullptr);
	}

	m_command_pools.clear();
}

RHIFence *Frame::AllocateFence()
{
	if (m_fences.size() > m_active_fence_index)
	{
		return m_fences[m_active_fence_index++].get();
	}

	while (m_fences.size() <= m_active_fence_index)
	{
		m_fences.emplace_back(std::make_unique<Fence>(p_device));
	}

	m_active_fence_index++;

	return m_fences.back().get();
}

RHISemaphore *Frame::AllocateSemaphore()
{
	if (m_semaphores.size() > m_active_semaphore_index)
	{
		return m_semaphores[m_active_semaphore_index++].get();
	}

	while (m_semaphores.size() <= m_active_semaphore_index)
	{
		m_semaphores.emplace_back(std::make_unique<Semaphore>(p_device));
	}

	m_active_semaphore_index++;

	return m_semaphores.back().get();
}

RHICommand *Frame::AllocateCommand(RHIQueueFamily family)
{
	size_t hash = 0;
	HashCombine(hash, family, std::this_thread::get_id());

	if (m_command_pools.find(hash) == m_command_pools.end())
	{
		std::lock_guard<std::mutex> lock(m_mutex);

		VkCommandPoolCreateInfo create_info = {};
		create_info.sType                   = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
		create_info.flags                   = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
		create_info.queueFamilyIndex        = static_cast<Device *>(p_device)->GetQueueFamily(family);

		VkCommandPool pool = VK_NULL_HANDLE;
		vkCreateCommandPool(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &pool);

		m_command_pools.emplace(hash, pool);
	}

	if (m_commands.find(hash) == m_commands.end())
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		m_commands.emplace(hash, std::vector<std::unique_ptr<Command>>{});
		m_active_cmd_index[hash] = 0;
	}

	if (m_commands.at(hash).size() > m_active_cmd_index.at(hash))
	{
		auto &cmd = m_commands.at(hash).at(m_active_cmd_index.at(hash));
		cmd->Init();
		m_active_cmd_index[hash]++;
		return cmd.get();
	}

	while (m_commands.at(hash).size() <= m_active_cmd_index.at(hash))
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		m_commands[hash].emplace_back(std::make_unique<Command>(p_device, m_command_pools[hash], family));
	}

	m_active_cmd_index[hash]++;

	auto &cmd = m_commands[hash].back();
	cmd->Init();
	return cmd.get();
}

RHIDescriptor *Frame::AllocateDescriptor(const ShaderMeta &meta)
{
	size_t hash = 0;
	HashCombine(hash, meta.hash, std::this_thread::get_id());

	if (m_descriptors.find(hash) == m_descriptors.end())
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		m_descriptors.emplace(hash, std::vector<std::unique_ptr<Descriptor>>{});
		m_active_descriptor_index[hash] = 0;
	}

	if (m_descriptors[hash].size() > m_active_descriptor_index[hash])
	{
		auto &descriptor = m_descriptors[hash][m_active_descriptor_index[hash]];
		m_active_descriptor_index[hash]++;
		return descriptor.get();
	}

	while (m_descriptors[hash].size() <= m_active_descriptor_index[hash])
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		m_descriptors[hash].emplace_back(std::make_unique<Descriptor>(p_device, meta));
	}

	m_active_descriptor_index[hash]++;

	auto &descriptor = m_descriptors[hash].back();
	return descriptor.get();
}

void Frame::Reset()
{
	std::vector<VkFence> fences;

	fences.reserve(m_fences.size());

	for (uint32_t i = 0; i < m_active_fence_index; i++)
	{
		fences.push_back(m_fences[i]->GetHandle());
	}

	if (!fences.empty())
	{
		vkWaitForFences(static_cast<Device *>(p_device)->GetDevice(), static_cast<uint32_t>(fences.size()), fences.data(), VK_TRUE, UINT64_MAX);
		vkResetFences(static_cast<Device *>(p_device)->GetDevice(), static_cast<uint32_t>(fences.size()), fences.data());
	}

	for (auto &[hash, pool] : m_command_pools)
	{
		vkResetCommandPool(static_cast<Device *>(p_device)->GetDevice(), pool, 0);
		m_active_cmd_index[hash] = 0;
		for (auto &cmd : m_commands[hash])
		{
			cmd->SetState(CommandState::Available);
		}
	}

	for (auto& [hash, index] : m_active_descriptor_index)
	{
		index = 0;
	}

	m_active_fence_index     = 0;
	m_active_semaphore_index = 0;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Frame.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Fence;
class Semaphore;
class Descriptor;
class Command;

class Frame : public RHIFrame
{
  public:
	Frame(RHIDevice *device);

	virtual ~Frame() override;

	virtual RHIFence *AllocateFence() override;

	virtual RHISemaphore *AllocateSemaphore() override;

	virtual RHICommand *AllocateCommand(RHIQueueFamily family) override;

	virtual RHIDescriptor *AllocateDescriptor(const ShaderMeta &meta) override;

	virtual void Reset() override;

  private:
	std::vector<std::unique_ptr<Fence>>     m_fences;
	std::vector<std::unique_ptr<Semaphore>> m_semaphores;

	std::unordered_map<size_t, std::vector<std::unique_ptr<Command>>>    m_commands;
	std::unordered_map<size_t, std::vector<std::unique_ptr<Descriptor>>> m_descriptors;

	std::unordered_map<size_t, VkCommandPool> m_command_pools;

	uint32_t m_active_fence_index     = 0;
	uint32_t m_active_semaphore_index = 0;

	std::unordered_map<size_t, uint32_t> m_active_cmd_index;
	std::unordered_map<size_t, uint32_t> m_active_descriptor_index;

	std::mutex m_mutex;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Fwd.cpp
================================================
#define VOLK_IMPLEMENTATION
#include "volk.h"

#define VMA_IMPLEMENTATION
#include "vk_mem_alloc.h"

================================================
FILE: Source/Plugin/RHI/Vulkan/Fwd.hpp
================================================
#pragma once

#include <array>
#include <map>
#include <memory>
#include <optional>
#include <vector>

#include <volk.h>

#include "vk_mem_alloc.h"

#include <Core/Core.hpp>

#include <RHI/RHIAccelerationStructure.hpp>
#include <RHI/RHIBuffer.hpp>
#include <RHI/RHICommand.hpp>
#include <RHI/RHIDefinitions.hpp>
#include <RHI/RHIDescriptor.hpp>
#include <RHI/RHIDevice.hpp>
#include <RHI/RHIFrame.hpp>
#include <RHI/RHIPipelineState.hpp>
#include <RHI/RHIProfiler.hpp>
#include <RHI/RHIQueue.hpp>
#include <RHI/RHIRenderTarget.hpp>
#include <RHI/RHISampler.hpp>
#include <RHI/RHIShader.hpp>
#include <RHI/RHISwapchain.hpp>
#include <RHI/RHISynchronization.hpp>
#include <RHI/RHITexture.hpp>

#include "Definitions.hpp"

#ifdef _WIN64
#	include <Windows.h>
#endif        // _WIN64

namespace Ilum
{
namespace Vulkan
{
class AccelerationStructure;
class Buffer;
class Command;
class Descriptor;
class Device;
class Frame;
class PipelineState;
class Profiler;
class Queue;
class RenderTarget;
class Sampler;
class Shader;
class Swapchain;
class Fence;
class Semaphore;
class Texture;
}        // namespace Vulkan
}        // namespace Ilum

================================================
FILE: Source/Plugin/RHI/Vulkan/PipelineState.cpp
================================================
#include "PipelineState.hpp"
#include "Definitions.hpp"
#include "Descriptor.hpp"
#include "Device.hpp"
#include "RenderTarget.hpp"
#include "Shader.hpp"

#include <volk.h>

namespace Ilum::Vulkan
{
class ShaderBindingTableInfo
{
  public:
	ShaderBindingTableInfo(Device *device, uint32_t handle_count) :
	    p_device(device)
	{
		if (handle_count == 0)
		{
			return;
		}

		VkPhysicalDeviceRayTracingPipelinePropertiesKHR raytracing_pipeline_properties = {};
		raytracing_pipeline_properties.sType                                           = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
		VkPhysicalDeviceProperties2 deviceProperties2                                  = {};
		deviceProperties2.sType                                                        = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
		deviceProperties2.pNext                                                        = &raytracing_pipeline_properties;
		vkGetPhysicalDeviceProperties2(p_device->GetPhysicalDevice(), &deviceProperties2);

		uint32_t handle_size_aligned = (raytracing_pipeline_properties.shaderGroupHandleSize + raytracing_pipeline_properties.shaderGroupHandleAlignment - 1) &
		                               ~(raytracing_pipeline_properties.shaderGroupHandleAlignment - 1);

		VkBufferCreateInfo buffer_info = {};
		buffer_info.sType              = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
		buffer_info.usage              = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
		buffer_info.size               = static_cast<size_t>(handle_count) * raytracing_pipeline_properties.shaderGroupHandleSize;

		VmaAllocationCreateInfo memory_info{};
		memory_info.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
		memory_info.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;

		VmaAllocationInfo allocation_info{};
		vmaCreateBuffer(p_device->GetAllocator(),
		                &buffer_info, &memory_info,
		                &m_buffer, &m_allocation,
		                &allocation_info);

		m_memory = allocation_info.deviceMemory;

		VkBufferDeviceAddressInfoKHR buffer_device_address_info{};
		buffer_device_address_info.sType  = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
		buffer_device_address_info.buffer = m_buffer;
		m_handle.deviceAddress            = vkGetBufferDeviceAddress(p_device->GetDevice(), &buffer_device_address_info);
		m_handle.stride                   = handle_size_aligned;
		m_handle.size                     = handle_count * handle_size_aligned;

		m_mapped_data = static_cast<uint8_t *>(allocation_info.pMappedData);
	}

	~ShaderBindingTableInfo()
	{
		if (m_buffer && m_allocation)
		{
			vmaDestroyBuffer(p_device->GetAllocator(), m_buffer, m_allocation);
		}
	}

	uint8_t *GetData()
	{
		return m_mapped_data;
	}

	const VkStridedDeviceAddressRegionKHR *GetHandle() const
	{
		return &m_handle;
	}

  private:
	Device *p_device = nullptr;

	uint32_t m_handle_count = 0;
	uint8_t *m_mapped_data  = nullptr;

	VkStridedDeviceAddressRegionKHR m_handle     = {};
	VkBuffer                        m_buffer     = VK_NULL_HANDLE;
	VmaAllocation                   m_allocation = VK_NULL_HANDLE;
	VkDeviceMemory                  m_memory     = VK_NULL_HANDLE;
};

struct ShaderBindingTableInfos
{
	std::unique_ptr<ShaderBindingTableInfo> raygen   = nullptr;
	std::unique_ptr<ShaderBindingTableInfo> miss     = nullptr;
	std::unique_ptr<ShaderBindingTableInfo> hit      = nullptr;
	std::unique_ptr<ShaderBindingTableInfo> callable = nullptr;
};

static std::unordered_map<std::thread::id, VkPipelineCache>                     PipelineCaches;
static std::unordered_map<size_t, VkPipeline>                                   Pipelines;
static std::unordered_map<size_t, VkPipelineLayout>                             PipelineLayouts;
static std::unordered_map<VkPipeline, std::unique_ptr<ShaderBindingTableInfos>> ShaderBindingTables;
static std::mutex                                                               Mutex;

static std::atomic<uint32_t> PipelineCount = 0;

PipelineState::PipelineState(RHIDevice *device) :
    RHIPipelineState(device)
{
	PipelineCount.fetch_add(1);
}

PipelineState ::~PipelineState()
{
	PipelineCount.fetch_sub(1);

	if (PipelineCount == 0)
	{
		for (auto &[hash, pipeline] : Pipelines)
		{
			vkDestroyPipeline(static_cast<Device *>(p_device)->GetDevice(), pipeline, nullptr);
		}

		for (auto &[hash, layout] : PipelineLayouts)
		{
			vkDestroyPipelineLayout(static_cast<Device *>(p_device)->GetDevice(), layout, nullptr);
		}

		ShaderBindingTables.clear();
		Pipelines.clear();
		PipelineLayouts.clear();

		for (auto &[thread_id, pipeline_cache] : PipelineCaches)
		{
			vkDestroyPipelineCache(static_cast<Device *>(p_device)->GetDevice(), pipeline_cache, nullptr);
			pipeline_cache = VK_NULL_HANDLE;
		}
	}
}

VkPipelineLayout PipelineState::GetPipelineLayout(Descriptor *descriptor)
{
	size_t hash = 0;
	HashCombine(hash, descriptor->GetShaderMeta().hash, GetHash());

	if (PipelineLayouts.find(hash) != PipelineLayouts.end())
	{
		return PipelineLayouts[hash];
	}

	return CreatePipelineLayout(descriptor);
}

VkPipeline PipelineState::GetPipeline(Descriptor *descriptor, RenderTarget *render_target)
{
	for (const auto &[stage, shader] : m_shaders)
	{
		if (stage & RHIShaderStage::Fragment)
		{
			assert(render_target != nullptr);
			return CreateGraphicsPipeline(descriptor, render_target);
		}
		else if (stage & RHIShaderStage::Compute)
		{
			return CreateComputePipeline(descriptor);
		}
		else if (stage & RHIShaderStage::RayGen)
		{
			return CreateRayTracingPipeline(descriptor);
		}
	}
	return VK_NULL_HANDLE;
}

ShaderBindingTable PipelineState::GetShaderBindingTable(VkPipeline pipeline)
{
	ShaderBindingTable sbt;
	if (ShaderBindingTables.find(pipeline) != ShaderBindingTables.end())
	{
		auto &shader_binding_table_infos = ShaderBindingTables.at(pipeline);

		sbt.raygen   = shader_binding_table_infos->raygen->GetHandle();
		sbt.hit      = shader_binding_table_infos->hit->GetHandle();
		sbt.miss     = shader_binding_table_infos->miss->GetHandle();
		sbt.callable = shader_binding_table_infos->callable->GetHandle();
	}
	return sbt;
}

VkPipelineBindPoint PipelineState::GetPipelineBindPoint() const
{
	for (const auto &[stage, shader] : m_shaders)
	{
		if (stage & RHIShaderStage::Fragment)
		{
			return VK_PIPELINE_BIND_POINT_GRAPHICS;
		}
		else if (stage & RHIShaderStage::Compute)
		{
			return VK_PIPELINE_BIND_POINT_COMPUTE;
		}
		else if (stage & RHIShaderStage::RayGen)
		{
			return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
		}
	}
	return VK_PIPELINE_BIND_POINT_GRAPHICS;
}

VkPipelineCache PipelineState::CreatePipelineCache(const std::thread::id &thread_id)
{
	if (PipelineCaches.find(thread_id) == PipelineCaches.end())
	{
		std::lock_guard<std::mutex> lock(Mutex);
		PipelineCaches[thread_id]             = VK_NULL_HANDLE;
		VkPipelineCacheCreateInfo create_info = {};
		create_info.sType                     = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
		vkCreatePipelineCache(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &PipelineCaches[thread_id]);
	}
	return PipelineCaches.at(thread_id);
}

VkPipelineLayout PipelineState::CreatePipelineLayout(Descriptor *descriptor)
{
	size_t hash = 0;
	HashCombine(hash, descriptor->GetShaderMeta().hash, GetHash());

	// Push constant merge range
	std::unordered_map<size_t, VkPushConstantRange> push_constant_range_map;
	for (auto &constant : descriptor->GetShaderMeta().constants)
	{
		size_t hash = Hash(constant.size, constant.offset);
		if (push_constant_range_map.find(hash) != push_constant_range_map.end())
		{
			push_constant_range_map[hash].stageFlags |= ToVulkanShaderStages(constant.stage);
		}
		else
		{
			VkPushConstantRange push_constant_range = {};
			push_constant_range.stageFlags          = ToVulkanShaderStages(constant.stage);
			push_constant_range.size                = constant.size;
			push_constant_range.offset              = constant.offset;
			push_constant_range_map.emplace(hash, push_constant_range);
		}
	}

	// Push constant merge stage
	std::unordered_map<VkShaderStageFlags, VkPushConstantRange> push_constant_map;
	for (auto &[hash, constant] : push_constant_range_map)
	{
		if (push_constant_map.find(constant.stageFlags) == push_constant_map.end())
		{
			push_constant_map[constant.stageFlags] = constant;
		}
		else
		{
			push_constant_map[constant.stageFlags].offset = std::min(push_constant_map[constant.stageFlags].offset, constant.offset);
			push_constant_map[constant.stageFlags].size += constant.size;
		}
	}

	std::vector<VkPushConstantRange> push_constants;
	push_constants.reserve(push_constant_map.size());
	for (auto &[hash, constant] : push_constant_map)
	{
		push_constants.push_back(std::move(constant));
	}

	std::vector<VkDescriptorSetLayout> descriptor_set_layouts;
	for (auto &[set, layout] : descriptor->GetDescriptorSetLayout())
	{
		descriptor_set_layouts.push_back(layout);
	}

	VkPipelineLayoutCreateInfo pipeline_layout_create_info = {};
	pipeline_layout_create_info.sType                      = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
	pipeline_layout_create_info.pushConstantRangeCount     = static_cast<uint32_t>(push_constants.size());
	pipeline_layout_create_info.pPushConstantRanges        = push_constants.data();
	pipeline_layout_create_info.setLayoutCount             = static_cast<uint32_t>(descriptor_set_layouts.size());
	pipeline_layout_create_info.pSetLayouts                = descriptor_set_layouts.data();

	VkPipelineLayout layout = VK_NULL_HANDLE;
	vkCreatePipelineLayout(static_cast<Device *>(p_device)->GetDevice(), &pipeline_layout_create_info, nullptr, &layout);

	PipelineLayouts.emplace(hash, layout);

	return layout;
}

VkPipeline PipelineState::CreateGraphicsPipeline(Descriptor *descriptor, RenderTarget *render_target)
{
	size_t hash = 0;
	HashCombine(hash, descriptor->GetShaderMeta().hash, GetHash());

	bool dynamic_rendering = static_cast<Device *>(p_device)->IsFeatureSupport(VulkanFeature::DynamicRendering);

	if (render_target)
	{
		if (dynamic_rendering)
		{
			HashCombine(hash, render_target->GetFormatHash());
		}
		else
		{
			HashCombine(hash, render_target->GetRenderPass());
		}
	}

	if (Pipelines.find(hash) != Pipelines.end())
	{
		return Pipelines[hash];
	}

	// Input Assembly State
	VkPipelineInputAssemblyStateCreateInfo input_assembly_state_create_info = {};
	input_assembly_state_create_info.sType                                  = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
	input_assembly_state_create_info.topology                               = ToVulkanPrimitiveTopology[m_input_assembly_state.topology];
	input_assembly_state_create_info.flags                                  = 0;
	input_assembly_state_create_info.primitiveRestartEnable                 = VK_FALSE;

	// Rasterization State
	VkPipelineRasterizationStateCreateInfo rasterization_state_create_info = {};
	rasterization_state_create_info.sType                                  = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
	rasterization_state_create_info.polygonMode                            = ToVulkanPolygonMode[m_rasterization_state.polygon_mode];
	rasterization_state_create_info.cullMode                               = ToVulkanCullMode[m_rasterization_state.cull_mode];
	rasterization_state_create_info.frontFace                              = ToVulkanFrontFace[m_rasterization_state.front_face];
	rasterization_state_create_info.lineWidth                              = m_rasterization_state.line_width;
	rasterization_state_create_info.depthBiasEnable                        = m_rasterization_state.depth_bias_enable;
	rasterization_state_create_info.depthClampEnable                       = m_rasterization_state.depth_clamp_enable;
	rasterization_state_create_info.depthBiasConstantFactor                = m_rasterization_state.depth_bias;
	rasterization_state_create_info.depthBiasSlopeFactor                   = m_rasterization_state.depth_bias_slope;
	rasterization_state_create_info.depthBiasClamp                         = m_rasterization_state.depth_bias_clamp;
	rasterization_state_create_info.flags                                  = 0;

	// Color Blend State
	std::vector<VkPipelineColorBlendAttachmentState> color_blend_attachment_states(m_blend_state.attachment_states.size());

	for (uint32_t i = 0; i < color_blend_attachment_states.size(); i++)
	{
		color_blend_attachment_states[i].blendEnable         = m_blend_state.attachment_states[i].blend_enable;
		color_blend_attachment_states[i].srcColorBlendFactor = ToVulkanBlendFactor[m_blend_state.attachment_states[i].src_color_blend];
		color_blend_attachment_states[i].dstColorBlendFactor = ToVulkanBlendFactor[m_blend_state.attachment_states[i].dst_color_blend];
		color_blend_attachment_states[i].colorBlendOp        = ToVulkanBlendOp[m_blend_state.attachment_states[i].color_blend_op];
		color_blend_attachment_states[i].srcAlphaBlendFactor = ToVulkanBlendFactor[m_blend_state.attachment_states[i].src_alpha_blend];
		color_blend_attachment_states[i].dstAlphaBlendFactor = ToVulkanBlendFactor[m_blend_state.attachment_states[i].dst_alpha_blend];
		color_blend_attachment_states[i].alphaBlendOp        = ToVulkanBlendOp[m_blend_state.attachment_states[i].alpha_blend_op];
		color_blend_attachment_states[i].colorWriteMask      = m_blend_state.attachment_states[i].color_write_mask;
	}

	VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {};
	color_blend_state_create_info.sType                               = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
	color_blend_state_create_info.logicOpEnable                       = m_blend_state.enable;
	color_blend_state_create_info.logicOp                             = ToVulkanLogicOp[m_blend_state.logic_op];
	color_blend_state_create_info.attachmentCount                     = static_cast<uint32_t>(color_blend_attachment_states.size());
	color_blend_state_create_info.pAttachments                        = color_blend_attachment_states.data();
	color_blend_state_create_info.blendConstants[0]                   = m_blend_state.blend_constants[0];
	color_blend_state_create_info.blendConstants[1]                   = m_blend_state.blend_constants[1];
	color_blend_state_create_info.blendConstants[2]                   = m_blend_state.blend_constants[2];
	color_blend_state_create_info.blendConstants[3]                   = m_blend_state.blend_constants[3];

	// Depth Stencil State
	VkPipelineDepthStencilStateCreateInfo depth_stencil_state_create_info = {};
	depth_stencil_state_create_info.sType                                 = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
	depth_stencil_state_create_info.depthTestEnable                       = m_depth_stencil_state.depth_test_enable;
	depth_stencil_state_create_info.depthWriteEnable                      = m_depth_stencil_state.depth_write_enable;
	depth_stencil_state_create_info.depthCompareOp                        = ToVulkanCompareOp[m_depth_stencil_state.compare];
	// TODO: stencil test
	depth_stencil_state_create_info.back              = VkStencilOpState{};
	depth_stencil_state_create_info.front             = VkStencilOpState{};
	depth_stencil_state_create_info.stencilTestEnable = VK_FALSE;

	// Viewport State
	VkPipelineViewportStateCreateInfo viewport_state_create_info = {};
	viewport_state_create_info.sType                             = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
	viewport_state_create_info.viewportCount                     = 1;
	viewport_state_create_info.scissorCount                      = 1;
	viewport_state_create_info.flags                             = 0;

	// Multisample State
	VkPipelineMultisampleStateCreateInfo multisample_state_create_info = {};
	multisample_state_create_info.sType                                = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
	multisample_state_create_info.rasterizationSamples                 = ToVulkanSampleCount[m_multisample_state.samples];
	multisample_state_create_info.sampleShadingEnable                  = m_multisample_state.enable;
	multisample_state_create_info.pSampleMask                          = m_multisample_state.enable ? &m_multisample_state.sample_mask : nullptr;
	multisample_state_create_info.flags                                = 0;

	// Dynamic State
	std::vector<VkDynamicState>      dynamic_states            = {VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_VIEWPORT};
	VkPipelineDynamicStateCreateInfo dynamic_state_create_info = {};
	dynamic_state_create_info.sType                            = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
	dynamic_state_create_info.pDynamicStates                   = dynamic_states.data();
	dynamic_state_create_info.dynamicStateCount                = static_cast<uint32_t>(dynamic_states.size());
	dynamic_state_create_info.flags                            = 0;

	// Vertex Input State
	std::vector<VkVertexInputAttributeDescription> attribute_descriptions = {};
	std::vector<VkVertexInputBindingDescription>   binding_descriptions   = {};

	for (auto &attribute : m_vertex_input_state.input_attributes)
	{
		attribute_descriptions.push_back(VkVertexInputAttributeDescription{
		    attribute.location,
		    attribute.binding,
		    ToVulkanFormat[attribute.format],
		    attribute.offset});
	}

	for (auto &binding : m_vertex_input_state.input_bindings)
	{
		binding_descriptions.push_back(VkVertexInputBindingDescription{
		    binding.binding,
		    binding.stride,
		    ToVulkanVertexInputRate[binding.rate]});
	}

	VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info = {};
	vertex_input_state_create_info.sType                                = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
	vertex_input_state_create_info.vertexAttributeDescriptionCount      = static_cast<uint32_t>(attribute_descriptions.size());
	vertex_input_state_create_info.pVertexAttributeDescriptions         = attribute_descriptions.data();
	vertex_input_state_create_info.vertexBindingDescriptionCount        = static_cast<uint32_t>(binding_descriptions.size());
	vertex_input_state_create_info.pVertexBindingDescriptions           = binding_descriptions.data();

	// Shader Stage State
	std::vector<VkPipelineShaderStageCreateInfo> pipeline_shader_stage_create_infos;
	for (auto &[stage, shader] : m_shaders)
	{
		VkPipelineShaderStageCreateInfo shader_stage_create_info = {};

		shader_stage_create_info.sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
		shader_stage_create_info.stage  = ToVulkanShaderStage[stage];
		shader_stage_create_info.module = static_cast<Shader *>(shader)->GetHandle();
		shader_stage_create_info.pName  = shader->GetEntryPoint().c_str();
		pipeline_shader_stage_create_infos.push_back(shader_stage_create_info);
	}

	VkGraphicsPipelineCreateInfo graphics_pipeline_create_info = {};
	graphics_pipeline_create_info.sType                        = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
	graphics_pipeline_create_info.stageCount                   = static_cast<uint32_t>(pipeline_shader_stage_create_infos.size());
	graphics_pipeline_create_info.pStages                      = pipeline_shader_stage_create_infos.data();

	graphics_pipeline_create_info.pInputAssemblyState = &input_assembly_state_create_info;
	graphics_pipeline_create_info.pRasterizationState = &rasterization_state_create_info;
	graphics_pipeline_create_info.pColorBlendState    = &color_blend_state_create_info;
	graphics_pipeline_create_info.pViewportState      = &viewport_state_create_info;
	graphics_pipeline_create_info.pMultisampleState   = &multisample_state_create_info;
	graphics_pipeline_create_info.pDynamicState       = &dynamic_state_create_info;
	graphics_pipeline_create_info.pVertexInputState   = &vertex_input_state_create_info;
	graphics_pipeline_create_info.pDepthStencilState  = &depth_stencil_state_create_info;

	graphics_pipeline_create_info.layout             = GetPipelineLayout(descriptor);
	graphics_pipeline_create_info.renderPass         = VK_NULL_HANDLE;
	graphics_pipeline_create_info.subpass            = 0;
	graphics_pipeline_create_info.basePipelineHandle = VK_NULL_HANDLE;
	graphics_pipeline_create_info.basePipelineIndex  = -1;

	if (dynamic_rendering)
	{
		VkPipelineRenderingCreateInfo pipeline_rendering_create_info = {};
		pipeline_rendering_create_info.sType                         = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
		pipeline_rendering_create_info.colorAttachmentCount          = static_cast<uint32_t>(render_target->GetColorFormats().size());
		pipeline_rendering_create_info.pColorAttachmentFormats       = render_target->GetColorFormats().data();
		pipeline_rendering_create_info.depthAttachmentFormat         = render_target->GetDepthFormat().has_value() ? render_target->GetDepthFormat().value() : VK_FORMAT_UNDEFINED;
		pipeline_rendering_create_info.stencilAttachmentFormat       = render_target->GetStencilFormat().has_value() ? render_target->GetStencilFormat().value() : VK_FORMAT_UNDEFINED;
		graphics_pipeline_create_info.pNext                          = &pipeline_rendering_create_info;
	}
	else
	{
		if (render_target)
		{
			graphics_pipeline_create_info.renderPass = render_target->GetRenderPass();
		}
	}

	VkPipeline pipeline = VK_NULL_HANDLE;
	vkCreateGraphicsPipelines(static_cast<Device *>(p_device)->GetDevice(), CreatePipelineCache(std::this_thread::get_id()), 1, &graphics_pipeline_create_info, nullptr, &pipeline);

	{
		std::lock_guard<std::mutex> lock(Mutex);
		Pipelines.emplace(hash, pipeline);
	}

	return pipeline;
}

VkPipeline PipelineState::CreateComputePipeline(Descriptor *descriptor)
{
	size_t hash = 0;
	HashCombine(hash, descriptor->GetShaderMeta().hash, GetHash());

	if (Pipelines.find(hash) != Pipelines.end())
	{
		return Pipelines[hash];
	}

	VkPipelineShaderStageCreateInfo shader_stage_create_info = {};
	for (const auto &[stage, shader] : m_shaders)
	{
		if (stage & RHIShaderStage::Compute)
		{
			shader_stage_create_info.sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
			shader_stage_create_info.stage  = VK_SHADER_STAGE_COMPUTE_BIT;
			shader_stage_create_info.module = static_cast<const Shader *>(shader)->GetHandle();
			shader_stage_create_info.pName  = shader->GetEntryPoint().c_str();
			break;
		}
	}

	VkComputePipelineCreateInfo compute_pipeline_create_info = {};
	compute_pipeline_create_info.sType                       = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
	compute_pipeline_create_info.stage                       = shader_stage_create_info;
	compute_pipeline_create_info.layout                      = GetPipelineLayout(descriptor);
	compute_pipeline_create_info.basePipelineIndex           = 0;
	compute_pipeline_create_info.basePipelineHandle          = VK_NULL_HANDLE;

	VkPipeline pipeline = VK_NULL_HANDLE;
	vkCreateComputePipelines(static_cast<Device *>(p_device)->GetDevice(), CreatePipelineCache(std::this_thread::get_id()), 1, &compute_pipeline_create_info, nullptr, &pipeline);

	{
		std::lock_guard<std::mutex> lock(Mutex);
		Pipelines.emplace(hash, pipeline);
	}

	return pipeline;
}

VkPipeline PipelineState::CreateRayTracingPipeline(Descriptor *descriptor)
{
	size_t hash = 0;
	HashCombine(hash, descriptor->GetShaderMeta().hash, GetHash());

	if (Pipelines.find(hash) != Pipelines.end())
	{
		return Pipelines[hash];
	}

	VkPipeline pipeline = VK_NULL_HANDLE;

	std::vector<VkRayTracingShaderGroupCreateInfoKHR> shader_group_create_infos;
	std::vector<VkPipelineShaderStageCreateInfo>      pipeline_shader_stage_create_infos;

	uint32_t raygen_count   = 0;
	uint32_t raymiss_count  = 0;
	uint32_t rayhit_count   = 0;
	uint32_t callable_count = 0;

	// Ray Generation Group
	{
		for (const auto &[stage, shader] : m_shaders)
		{
			if (stage & RHIShaderStage::RayGen)
			{
				VkPipelineShaderStageCreateInfo pipeline_shader_stage_create_info = {};
				pipeline_shader_stage_create_info.sType                           = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
				pipeline_shader_stage_create_info.stage                           = VK_SHADER_STAGE_RAYGEN_BIT_KHR;
				pipeline_shader_stage_create_info.module                          = static_cast<const Shader *>(shader)->GetHandle();
				pipeline_shader_stage_create_info.pName                           = shader->GetEntryPoint().c_str();
				pipeline_shader_stage_create_infos.push_back(pipeline_shader_stage_create_info);

				VkRayTracingShaderGroupCreateInfoKHR shader_group = {};
				shader_group.sType                                = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
				shader_group.type                                 = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
				shader_group.generalShader                        = static_cast<uint32_t>(pipeline_shader_stage_create_infos.size()) - 1;
				shader_group.closestHitShader                     = VK_SHADER_UNUSED_KHR;
				shader_group.anyHitShader                         = VK_SHADER_UNUSED_KHR;
				shader_group.intersectionShader                   = VK_SHADER_UNUSED_KHR;
				shader_group_create_infos.push_back(shader_group);

				raygen_count++;
			}
		}
	}

	// Ray Miss Group
	{
		for (const auto &[stage, shader] : m_shaders)
		{
			if (stage & RHIShaderStage::Miss)
			{
				VkPipelineShaderStageCreateInfo pipeline_shader_stage_create_info = {};
				pipeline_shader_stage_create_info.sType                           = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
				pipeline_shader_stage_create_info.stage                           = VK_SHADER_STAGE_MISS_BIT_KHR;
				pipeline_shader_stage_create_info.module                          = static_cast<const Shader *>(shader)->GetHandle();
				pipeline_shader_stage_create_info.pName                           = shader->GetEntryPoint().c_str();
				pipeline_shader_stage_create_infos.push_back(pipeline_shader_stage_create_info);

				VkRayTracingShaderGroupCreateInfoKHR shader_group = {};
				shader_group.sType                                = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
				shader_group.type                                 = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
				shader_group.generalShader                        = static_cast<uint32_t>(pipeline_shader_stage_create_infos.size()) - 1;
				shader_group.closestHitShader                     = VK_SHADER_UNUSED_KHR;
				shader_group.anyHitShader                         = VK_SHADER_UNUSED_KHR;
				shader_group.intersectionShader                   = VK_SHADER_UNUSED_KHR;
				shader_group_create_infos.push_back(shader_group);

				raymiss_count++;
			}
		}
	}

	// Closest Hit Group
	{
		for (const auto &[stage, shader] : m_shaders)
		{
			if (stage & RHIShaderStage::ClosestHit)
			{
				VkPipelineShaderStageCreateInfo pipeline_shader_stage_create_info = {};
				pipeline_shader_stage_create_info.sType                           = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
				pipeline_shader_stage_create_info.stage                           = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
				pipeline_shader_stage_create_info.module                          = static_cast<const Shader *>(shader)->GetHandle();
				pipeline_shader_stage_create_info.pName                           = shader->GetEntryPoint().c_str();
				pipeline_shader_stage_create_infos.push_back(pipeline_shader_stage_create_info);

				VkRayTracingShaderGroupCreateInfoKHR shader_group = {};
				shader_group.sType                                = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
				shader_group.type                                 = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
				shader_group.generalShader                        = VK_SHADER_UNUSED_KHR;
				shader_group.closestHitShader                     = static_cast<uint32_t>(pipeline_shader_stage_create_infos.size()) - 1;
				shader_group.anyHitShader                         = VK_SHADER_UNUSED_KHR;
				shader_group.intersectionShader                   = VK_SHADER_UNUSED_KHR;
				shader_group_create_infos.push_back(shader_group);

				rayhit_count++;
			}
		}
	}

	// Any Hit Group
	{
		for (const auto &[stage, shader] : m_shaders)
		{
			if (stage & RHIShaderStage::AnyHit)
			{
				VkPipelineShaderStageCreateInfo pipeline_shader_stage_create_info = {};
				pipeline_shader_stage_create_info.sType                           = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
				pipeline_shader_stage_create_info.stage                           = VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
				pipeline_shader_stage_create_info.module                          = static_cast<const Shader *>(shader)->GetHandle();
				pipeline_shader_stage_create_info.pName                           = shader->GetEntryPoint().c_str();
				pipeline_shader_stage_create_infos.push_back(pipeline_shader_stage_create_info);

				VkRayTracingShaderGroupCreateInfoKHR shader_group = {};
				shader_group.sType                                = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
				shader_group.type                                 = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
				shader_group.generalShader                        = VK_SHADER_UNUSED_KHR;
				shader_group.closestHitShader                     = VK_SHADER_UNUSED_KHR;
				shader_group.anyHitShader                         = static_cast<uint32_t>(pipeline_shader_stage_create_infos.size()) - 1;
				shader_group.intersectionShader                   = VK_SHADER_UNUSED_KHR;
				shader_group_create_infos.push_back(shader_group);

				rayhit_count++;
			}
		}
	}

	// Intersection Group
	{
		for (const auto &[stage, shader] : m_shaders)
		{
			if (stage & RHIShaderStage::Intersection)
			{
				VkPipelineShaderStageCreateInfo pipeline_shader_stage_create_info = {};
				pipeline_shader_stage_create_info.sType                           = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
				pipeline_shader_stage_create_info.stage                           = VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
				pipeline_shader_stage_create_info.module                          = static_cast<const Shader *>(shader)->GetHandle();
				pipeline_shader_stage_create_info.pName                           = shader->GetEntryPoint().c_str();
				pipeline_shader_stage_create_infos.push_back(pipeline_shader_stage_create_info);

				VkRayTracingShaderGroupCreateInfoKHR shader_group = {};
				shader_group.sType                                = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
				shader_group.type                                 = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
				shader_group.generalShader                        = VK_SHADER_UNUSED_KHR;
				shader_group.closestHitShader                     = VK_SHADER_UNUSED_KHR;
				shader_group.anyHitShader                         = VK_SHADER_UNUSED_KHR;
				shader_group.intersectionShader                   = static_cast<uint32_t>(pipeline_shader_stage_create_infos.size()) - 1;
				shader_group_create_infos.push_back(shader_group);

				rayhit_count++;
			}
		}
	}

	// Callable Group
	{
		for (const auto &[stage, shader] : m_shaders)
		{
			if (stage & RHIShaderStage::Callable)
			{
				VkPipelineShaderStageCreateInfo pipeline_shader_stage_create_info = {};
				pipeline_shader_stage_create_info.sType                           = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
				pipeline_shader_stage_create_info.stage                           = VK_SHADER_STAGE_CALLABLE_BIT_KHR;
				pipeline_shader_stage_create_info.module                          = static_cast<const Shader *>(shader)->GetHandle();
				pipeline_shader_stage_create_info.pName                           = shader->GetEntryPoint().c_str();
				pipeline_shader_stage_create_infos.push_back(pipeline_shader_stage_create_info);

				VkRayTracingShaderGroupCreateInfoKHR shader_group = {};
				shader_group.sType                                = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
				shader_group.type                                 = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
				shader_group.generalShader                        = static_cast<uint32_t>(pipeline_shader_stage_create_infos.size()) - 1;
				shader_group.closestHitShader                     = VK_SHADER_UNUSED_KHR;
				shader_group.anyHitShader                         = VK_SHADER_UNUSED_KHR;
				shader_group.intersectionShader                   = VK_SHADER_UNUSED_KHR;
				shader_group_create_infos.push_back(shader_group);

				callable_count++;
			}
		}
	}

	VkRayTracingPipelineCreateInfoKHR raytracing_pipeline_create_info = {};
	raytracing_pipeline_create_info.sType                             = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR;
	raytracing_pipeline_create_info.stageCount                        = static_cast<uint32_t>(pipeline_shader_stage_create_infos.size());
	raytracing_pipeline_create_info.pStages                           = pipeline_shader_stage_create_infos.data();
	raytracing_pipeline_create_info.groupCount                        = static_cast<uint32_t>(shader_group_create_infos.size());
	raytracing_pipeline_create_info.pGroups                           = shader_group_create_infos.data();
	raytracing_pipeline_create_info.maxPipelineRayRecursionDepth      = 4;
	raytracing_pipeline_create_info.layout                            = GetPipelineLayout(descriptor);

	vkCreateRayTracingPipelinesKHR(static_cast<Device *>(p_device)->GetDevice(), VK_NULL_HANDLE, CreatePipelineCache(std::this_thread::get_id()), 1, &raytracing_pipeline_create_info, nullptr, &pipeline);

	{
		std::lock_guard<std::mutex> lock(Mutex);
		Pipelines.emplace(hash, pipeline);
	}

	// Create shader binding table
	/*
	    SBT Layout:

	        /-----------\
	        | raygen    |
	        |-----------|
	        | miss        |
	        |-----------|
	        | hit           |
	        |-----------|
	        | callable   |
	        \-----------/

	*/

	auto sbt = std::make_unique<ShaderBindingTableInfos>();

	VkPhysicalDeviceRayTracingPipelinePropertiesKHR raytracing_properties = {};
	raytracing_properties.sType                                           = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
	VkPhysicalDeviceProperties2 deviceProperties2                         = {};
	deviceProperties2.sType                                               = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
	deviceProperties2.pNext                                               = &raytracing_properties;
	vkGetPhysicalDeviceProperties2(static_cast<Device *>(p_device)->GetPhysicalDevice(), &deviceProperties2);

	const uint32_t handle_size         = raytracing_properties.shaderGroupHandleSize;
	const uint32_t handle_size_aligned = (raytracing_properties.shaderGroupHandleSize + raytracing_properties.shaderGroupHandleAlignment - 1) & ~(raytracing_properties.shaderGroupHandleAlignment - 1);
	const uint32_t group_count         = static_cast<uint32_t>(shader_group_create_infos.size());
	const uint32_t sbt_size            = group_count * handle_size_aligned;

	std::vector<uint8_t> shader_handle_storage(sbt_size);

	vkGetRayTracingShaderGroupHandlesKHR(static_cast<Device *>(p_device)->GetDevice(), pipeline, 0, group_count, sbt_size, shader_handle_storage.data());

	uint32_t handle_offset = 0;

	// Gen Group
	{
		sbt->raygen = std::make_unique<ShaderBindingTableInfo>(static_cast<Device *>(p_device), raygen_count);
		std::memcpy(sbt->raygen->GetData(), shader_handle_storage.data() + handle_offset, handle_size * raygen_count);
		handle_offset += raygen_count * handle_size_aligned;
	}

	// Miss Group
	{
		sbt->miss = std::make_unique<ShaderBindingTableInfo>(static_cast<Device *>(p_device), raymiss_count);
		std::memcpy(sbt->miss->GetData(), shader_handle_storage.data() + handle_offset, handle_size * raymiss_count);
		handle_offset += raymiss_count * handle_size_aligned;
	}

	// Hit Group
	{
		sbt->hit = std::make_unique<ShaderBindingTableInfo>(static_cast<Device *>(p_device), rayhit_count);
		std::memcpy(sbt->hit->GetData(), shader_handle_storage.data() + handle_offset, handle_size * rayhit_count);
		handle_offset += rayhit_count * handle_size_aligned;
	}

	// Callable Group
	{
		sbt->callable = std::make_unique<ShaderBindingTableInfo>(static_cast<Device *>(p_device), callable_count);
		std::memcpy(sbt->callable->GetData(), shader_handle_storage.data() + handle_offset, handle_size * callable_count);
		handle_offset += callable_count * handle_size_aligned;
	}

	{
		std::lock_guard<std::mutex> lock(Mutex);
		ShaderBindingTables.emplace(pipeline, std::move(sbt));
	}

	return pipeline;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/PipelineState.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Descriptor;
class RenderTarget;

struct ShaderBindingTable
{
	const VkStridedDeviceAddressRegionKHR *raygen   = nullptr;
	const VkStridedDeviceAddressRegionKHR *miss     = nullptr;
	const VkStridedDeviceAddressRegionKHR *hit      = nullptr;
	const VkStridedDeviceAddressRegionKHR *callable = nullptr;
};

class PipelineState : public RHIPipelineState
{
  public:
	PipelineState(RHIDevice *device);

	virtual ~PipelineState() override;

	VkPipelineLayout GetPipelineLayout(Descriptor *descriptor);

	VkPipeline GetPipeline(Descriptor *descriptor, RenderTarget *render_target);

	ShaderBindingTable GetShaderBindingTable(VkPipeline pipeline);

	VkPipelineBindPoint GetPipelineBindPoint() const;

  private:
	VkPipelineCache  CreatePipelineCache(const std::thread::id &thread_id);
	VkPipelineLayout CreatePipelineLayout(Descriptor *descriptor);
	VkPipeline       CreateGraphicsPipeline(Descriptor *descriptor, RenderTarget *render_target);
	VkPipeline       CreateComputePipeline(Descriptor *descriptor);
	VkPipeline       CreateRayTracingPipeline(Descriptor *descriptor);
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Profiler.cpp
================================================
#include "Profiler.hpp"

#include "Command.hpp"
#include "Device.hpp"

namespace Ilum::Vulkan
{
Profiler::Profiler(RHIDevice *device, uint32_t frame_count) :
    RHIProfiler(device, frame_count)
{
	VkQueryPoolCreateInfo createInfo = {};
	createInfo.sType                 = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
	createInfo.pNext                 = nullptr;
	createInfo.flags                 = 0;

	createInfo.queryType  = VK_QUERY_TYPE_TIMESTAMP;
	createInfo.queryCount = 2;

	m_query_pools.resize(frame_count);
	for (auto &pool : m_query_pools)
	{
		vkCreateQueryPool(static_cast<Device *>(p_device)->GetDevice(), &createInfo, nullptr, &pool);
	}
}

Profiler ::~Profiler()
{
	for (auto &pool : m_query_pools)
	{
		vkDestroyQueryPool(static_cast<Device *>(p_device)->GetDevice(), pool, nullptr);
	}
}

void Profiler::Begin(RHICommand *cmd_buffer, uint32_t frame_index)
{
	m_current_index = frame_index;
	m_cmd_buffer    = static_cast<Command *>(cmd_buffer)->GetHandle();

	m_state.thread_id = std::this_thread::get_id();

	vkGetQueryPoolResults(static_cast<Device *>(p_device)->GetDevice(), m_query_pools[m_current_index], 0, 1, sizeof(uint64_t), &m_state.gpu_start, sizeof(uint64_t), VK_QUERY_RESULT_64_BIT);
	vkGetQueryPoolResults(static_cast<Device *>(p_device)->GetDevice(), m_query_pools[m_current_index], 1, 1, sizeof(uint64_t), &m_state.gpu_end, sizeof(uint64_t), VK_QUERY_RESULT_64_BIT);
	m_state.gpu_time = static_cast<float>(m_state.gpu_end - m_state.gpu_start) / 1000000.f;
	m_state.cpu_time = std::chrono::duration<float, std::milli>(m_state.cpu_end - m_state.cpu_start).count();

	vkCmdResetQueryPool(m_cmd_buffer, m_query_pools[m_current_index], 0, 2);
	vkCmdWriteTimestamp(m_cmd_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, m_query_pools[m_current_index], 0);
	m_state.cpu_start = std::chrono::high_resolution_clock::now();
}

void Profiler::End(RHICommand *cmd_buffer)
{
	assert(m_cmd_buffer != VK_NULL_HANDLE);
	vkCmdWriteTimestamp(m_cmd_buffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, m_query_pools[m_current_index], 1);
	m_state.cpu_end = std::chrono::high_resolution_clock::now();
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Profiler.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Profiler : public RHIProfiler
{
  public:
	Profiler(RHIDevice *device, uint32_t frame_count);

	virtual ~Profiler() override;

	virtual void Begin(RHICommand *cmd_buffer, uint32_t frame_index) override;

	virtual void End(RHICommand *cmd_buffer) override;

  private:
	std::vector<VkQueryPool> m_query_pools;
	uint32_t                 m_current_index = 0;
	VkCommandBuffer          m_cmd_buffer    = VK_NULL_HANDLE;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Queue.cpp
================================================
#include "Queue.hpp"
#include "Command.hpp"
#include "Device.hpp"
#include "Synchronization.hpp"

namespace Ilum::Vulkan
{
Queue::Queue(RHIDevice *device) :
    RHIQueue(device), p_device(static_cast<Device *>(device))
{
	for (uint32_t i = 0; i < p_device->GetQueueCount(RHIQueueFamily::Graphics); i++)
	{
		m_queues[RHIQueueFamily::Graphics].push_back(VK_NULL_HANDLE);
		vkGetDeviceQueue(p_device->GetDevice(), p_device->GetQueueFamily(RHIQueueFamily::Graphics), i, &m_queues[RHIQueueFamily::Graphics].back());
		m_queue_fences.emplace(m_queues[RHIQueueFamily::Graphics].back(), VK_NULL_HANDLE);

		{
			std::string queue_name = "Graphics Queue - " + std::to_string(i);

			VkDebugUtilsObjectNameInfoEXT info = {};
			info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
			info.pObjectName                   = queue_name.c_str();
			info.objectHandle                  = (uint64_t) m_queues[RHIQueueFamily::Graphics].back();
			info.objectType                    = VK_OBJECT_TYPE_QUEUE;
			static_cast<Device *>(p_device)->SetVulkanObjectName(info);
		}
	}

	for (uint32_t i = 0; i < p_device->GetQueueCount(RHIQueueFamily::Transfer); i++)
	{
		m_queues[RHIQueueFamily::Transfer].push_back(VK_NULL_HANDLE);
		vkGetDeviceQueue(p_device->GetDevice(), p_device->GetQueueFamily(RHIQueueFamily::Transfer), i, &m_queues[RHIQueueFamily::Transfer].back());
		m_queue_fences.emplace(m_queues[RHIQueueFamily::Transfer].back(), VK_NULL_HANDLE);

		{
			std::string queue_name = "Transfer Queue - " + std::to_string(i);

			VkDebugUtilsObjectNameInfoEXT info = {};
			info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
			info.pObjectName                   = queue_name.c_str();
			info.objectHandle                  = (uint64_t) m_queues[RHIQueueFamily::Graphics].back();
			info.objectType                    = VK_OBJECT_TYPE_QUEUE;
			static_cast<Device *>(p_device)->SetVulkanObjectName(info);
		}
	}

	for (uint32_t i = 0; i < p_device->GetQueueCount(RHIQueueFamily::Compute); i++)
	{
		m_queues[RHIQueueFamily::Compute].push_back(VK_NULL_HANDLE);
		vkGetDeviceQueue(p_device->GetDevice(), p_device->GetQueueFamily(RHIQueueFamily::Compute), i, &m_queues[RHIQueueFamily::Compute].back());
		m_queue_fences.emplace(m_queues[RHIQueueFamily::Compute].back(), VK_NULL_HANDLE);

		{
			std::string queue_name = "Compute Queue - " + std::to_string(i);

			VkDebugUtilsObjectNameInfoEXT info = {};
			info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
			info.pObjectName                   = queue_name.c_str();
			info.objectHandle                  = (uint64_t) m_queues[RHIQueueFamily::Graphics].back();
			info.objectType                    = VK_OBJECT_TYPE_QUEUE;
			static_cast<Device *>(p_device)->SetVulkanObjectName(info);
		}
	}

	for (auto &[queue, fence] : m_queue_fences)
	{
		VkFenceCreateInfo create_info = {};
		create_info.sType             = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
		vkCreateFence(p_device->GetDevice(), &create_info, nullptr, &fence);
	}

	m_queue_index[RHIQueueFamily::Graphics] = 0;
	m_queue_index[RHIQueueFamily::Transfer] = 0;
	m_queue_index[RHIQueueFamily::Compute]  = 0;
}

Queue::~Queue()
{
	p_device->WaitIdle();

	for (auto &[queue, fence] : m_queue_fences)
	{
		vkDestroyFence(p_device->GetDevice(), fence, nullptr);
	}
	m_queue_fences.clear();
}

void Queue::Execute(RHIQueueFamily family, const std::vector<SubmitInfo> &submit_infos, RHIFence *fence)
{
	VkQueue queue    = m_queues.at(family).at(m_queue_index[family]++);
	VkFence vk_fence = fence ? static_cast<Fence *>(fence)->GetHandle() : m_queue_fences.at(queue);

	if (vkGetFenceStatus(p_device->GetDevice(), vk_fence) == VK_SUCCESS)
	{
		vkWaitForFences(p_device->GetDevice(), 1, &vk_fence, VK_TRUE, std::numeric_limits<uint64_t>::max());
		vkResetFences(p_device->GetDevice(), 1, &vk_fence);
	}

	std::vector<VkSubmitInfo> vk_submit_infos;
	vk_submit_infos.reserve(submit_infos.size());

	std::vector<std::vector<VkPipelineStageFlags>> pipeline_stage_flags(submit_infos.size());
	std::vector<std::vector<VkCommandBuffer>>      cmd_buffers(submit_infos.size());
	std::vector<std::vector<VkSemaphore>>          wait_semaphores(submit_infos.size());
	std::vector<std::vector<VkSemaphore>>          signal_semaphores(submit_infos.size());

	for (uint32_t i = 0; i < submit_infos.size(); i++)
	{
		const auto &submit_info = submit_infos[i];

		pipeline_stage_flags[i].resize(submit_info.wait_semaphores.size());
		std::fill(pipeline_stage_flags[i].begin(), pipeline_stage_flags[i].end(),
		          submit_info.queue_family == RHIQueueFamily::Compute ?
		              VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT :
		              (submit_info.queue_family == RHIQueueFamily::Graphics ?
		                   VK_PIPELINE_STAGE_VERTEX_INPUT_BIT :
		                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT));

		cmd_buffers[i].reserve(submit_info.cmd_buffers.size());
		for (auto &cmd_buffer : submit_info.cmd_buffers)
		{
			cmd_buffers[i].push_back(static_cast<Command *>(cmd_buffer)->GetHandle());
		}

		wait_semaphores[i].reserve(submit_info.wait_semaphores.size());
		for (auto &wait_semaphore : submit_info.wait_semaphores)
		{
			wait_semaphores[i].push_back(static_cast<Semaphore *>(wait_semaphore)->GetHandle());
		}

		signal_semaphores[i].reserve(submit_info.signal_semaphores.size());
		for (auto &signal_semaphore : submit_info.signal_semaphores)
		{
			signal_semaphores[i].push_back(static_cast<Semaphore *>(signal_semaphore)->GetHandle());
		}

		VkSubmitInfo vk_submit_info = {};
		vk_submit_info.sType        = VK_STRUCTURE_TYPE_SUBMIT_INFO;

		vk_submit_info.commandBufferCount   = static_cast<uint32_t>(cmd_buffers[i].size());
		vk_submit_info.pCommandBuffers      = cmd_buffers[i].data();
		vk_submit_info.signalSemaphoreCount = static_cast<uint32_t>(signal_semaphores[i].size());
		vk_submit_info.pSignalSemaphores    = signal_semaphores[i].data();
		vk_submit_info.waitSemaphoreCount   = static_cast<uint32_t>(wait_semaphores[i].size());
		vk_submit_info.pWaitSemaphores      = wait_semaphores[i].data();
		vk_submit_info.pWaitDstStageMask    = pipeline_stage_flags[i].data();

		vk_submit_infos.push_back(std::move(vk_submit_info));
	}

	vkQueueSubmit(queue, static_cast<uint32_t>(vk_submit_infos.size()), vk_submit_infos.data(), vk_fence);

	m_queue_index[family] = m_queue_index[family] % p_device->GetQueueCount(family);
}

void Queue::Execute(RHICommand *cmd_buffer)
{
	auto vk_cmd_buffer = static_cast<Command *>(cmd_buffer)->GetHandle();

	RHIQueueFamily family = cmd_buffer->GetQueueFamily();

	size_t  index = m_queue_index[family];
	VkQueue queue = m_queues.at(family).at(index);
	VkFence fence = m_queue_fences.at(queue);

	if (vkGetFenceStatus(p_device->GetDevice(), fence) == VK_SUCCESS)
	{
		vkWaitForFences(p_device->GetDevice(), 1, &fence, VK_TRUE, std::numeric_limits<uint64_t>::max());
		vkResetFences(p_device->GetDevice(), 1, &fence);
	}

	VkSubmitInfo submit_info         = {};
	submit_info.sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	submit_info.commandBufferCount   = 1;
	submit_info.pCommandBuffers      = &vk_cmd_buffer;
	submit_info.signalSemaphoreCount = 0;
	submit_info.pSignalSemaphores    = nullptr;
	submit_info.waitSemaphoreCount   = 0;
	submit_info.pWaitSemaphores      = nullptr;
	submit_info.pWaitDstStageMask    = nullptr;

	vkQueueSubmit(m_queues[family][index], 1, &submit_info, fence);
	vkWaitForFences(p_device->GetDevice(), 1, &fence, VK_TRUE, std::numeric_limits<uint64_t>::max());
	vkResetFences(p_device->GetDevice(), 1, &fence);
}

void Queue::Wait()
{
	std::vector<VkFence> fences;
	fences.reserve(m_queue_fences.size());

	for (auto &[queue, fence] : m_queue_fences)
	{
		if (vkGetFenceStatus(p_device->GetDevice(), fence) == VK_SUCCESS)
		{
			fences.push_back(fence);
		}
	}

	vkWaitForFences(p_device->GetDevice(), static_cast<uint32_t>(fences.size()), fences.data(), VK_TRUE, std::numeric_limits<uint64_t>::max());
	vkResetFences(p_device->GetDevice(), static_cast<uint32_t>(fences.size()), fences.data());
}

VkQueue Queue::GetHandle(RHIQueueFamily family, uint32_t index) const
{
	return m_queues.at(family).at(index % m_queues.at(family).size());
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Queue.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Device;

class Queue : public RHIQueue
{
  public:
	Queue(RHIDevice *device);

	virtual ~Queue();

	virtual void Execute(RHIQueueFamily family, const std::vector<SubmitInfo> &submit_infos, RHIFence *fence) override;

	virtual void Execute(RHICommand *cmd_buffer) override;

	virtual void Wait() override;

	VkQueue GetHandle(RHIQueueFamily family, uint32_t index) const;

  private:
	Device *p_device = nullptr;

	std::map<RHIQueueFamily, std::vector<VkQueue>>  m_queues;
	std::map<RHIQueueFamily, std::atomic<size_t>> m_queue_index;

	std::unordered_map<VkQueue, VkFence> m_queue_fences;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/RenderTarget.cpp
================================================
#include "RenderTarget.hpp"
#include "Definitions.hpp"
#include "Device.hpp"
#include "Texture.hpp"

namespace Ilum::Vulkan
{
static std::unordered_map<size_t, VkRenderPass>  RenderPassCache;
static std::unordered_map<size_t, VkFramebuffer> FramebufferCache;

static uint32_t RenderTargetCount = 0;

RenderTarget::RenderTarget(RHIDevice *device) :
    RHIRenderTarget(device)
{
	RenderTargetCount++;
}

RenderTarget::~RenderTarget()
{
	if (--RenderTargetCount == 0)
	{
		p_device->WaitIdle();

		for (auto &[hash, render_pass] : RenderPassCache)
		{
			vkDestroyRenderPass(static_cast<Device *>(p_device)->GetDevice(), render_pass, nullptr);
		}

		for (auto &[hash, framebuffer] : FramebufferCache)
		{
			vkDestroyFramebuffer(static_cast<Device *>(p_device)->GetDevice(), framebuffer, nullptr);
		}

		RenderPassCache.clear();
		FramebufferCache.clear();
	}
}

RHIRenderTarget &RenderTarget::Set(uint32_t slot, RHITexture *texture, RHITextureDimension dimension, const ColorAttachment &attachment)
{
	return Set(slot, texture, TextureRange{dimension, 0, texture->GetDesc().mips, 0, texture->GetDesc().layers}, attachment);
}

RHIRenderTarget &RenderTarget::Set(uint32_t slot, RHITexture *texture, const TextureRange &range, const ColorAttachment &attachment)
{
	VkRenderingAttachmentInfo attachment_info = {};
	attachment_info.sType                     = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
	attachment_info.loadOp                    = ToVulkanLoadOp[attachment.load];
	attachment_info.storeOp                   = ToVulkanStoreOp[attachment.store];
	attachment_info.imageView                 = static_cast<Texture *>(texture)->GetView(range);
	attachment_info.imageLayout               = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
	std::memcpy(attachment_info.clearValue.color.float32, attachment.clear_value.data(), 4 * sizeof(float));

	HashCombine(m_hash, attachment_info.loadOp, attachment_info.storeOp, attachment_info.imageView, attachment_info.imageLayout);

	while (slot >= m_color_attachments.size())
	{
		m_color_attachments.push_back({});
		m_color_formats.push_back({});
	}

	m_color_attachments[slot] = attachment_info;
	m_color_formats[slot]     = ToVulkanFormat[texture->GetDesc().format];

	m_width  = std::max(m_width, texture->GetDesc().width);
	m_height = std::max(m_height, texture->GetDesc().height);
	m_layers = std::max(m_layers, texture->GetDesc().layers);

	return *this;
}

RHIRenderTarget &RenderTarget::Set(RHITexture *texture, RHITextureDimension dimension, const DepthStencilAttachment &attachment)
{
	return Set(texture, TextureRange{dimension, 0, texture->GetDesc().mips, 0, texture->GetDesc().layers}, attachment);
}

RHIRenderTarget &RenderTarget::Set(RHITexture *texture, const TextureRange &range, const DepthStencilAttachment &attachment)
{
	VkRenderingAttachmentInfo attachment_info     = {};
	attachment_info.sType                         = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
	attachment_info.loadOp                        = ToVulkanLoadOp[attachment.depth_load];
	attachment_info.storeOp                       = ToVulkanStoreOp[attachment.depth_store];
	attachment_info.imageView                     = static_cast<Texture *>(texture)->GetView(range);
	attachment_info.imageLayout                   = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
	attachment_info.clearValue.depthStencil.depth = attachment.clear_depth;

	HashCombine(m_hash, attachment_info.loadOp, attachment_info.storeOp, attachment_info.imageView, attachment_info.imageLayout);

	m_depth_attachment = attachment_info;
	m_depth_format     = ToVulkanFormat[texture->GetDesc().format];

	if (IsStencilFormat(texture->GetDesc().format))
	{
		attachment_info.loadOp                          = ToVulkanLoadOp[attachment.stencil_load];
		attachment_info.storeOp                         = ToVulkanStoreOp[attachment.stencil_store];
		attachment_info.clearValue.depthStencil.stencil = attachment.clear_stencil;
		m_stencil_attachment                            = attachment_info;
		m_stencil_format                                = ToVulkanFormat[texture->GetDesc().format];

		HashCombine(m_hash, attachment_info.loadOp, attachment_info.storeOp);
	}

	m_width  = std::max(m_width, texture->GetDesc().width);
	m_height = std::max(m_height, texture->GetDesc().height);
	m_layers = std::max(m_layers, texture->GetDesc().layers);

	return *this;
}

VkRenderPass RenderTarget::GetRenderPass() const
{
	std::vector<VkAttachmentDescription> descriptions;
	std::vector<VkAttachmentReference>   color_references;
	std::optional<VkAttachmentReference> depth_stencil_reference;

	for (uint32_t i = 0; i < m_color_attachments.size(); i++)
	{
		VkAttachmentDescription description = {};
		description.samples                 = VK_SAMPLE_COUNT_1_BIT;
		description.initialLayout           = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
		description.finalLayout             = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
		description.loadOp                  = m_color_attachments[i].loadOp;
		description.storeOp                 = m_color_attachments[i].storeOp;
		description.format                  = m_color_formats[i];

		VkAttachmentReference reference = {};
		reference.attachment            = static_cast<uint32_t>(descriptions.size());
		reference.layout                = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

		descriptions.push_back(description);
		color_references.push_back(reference);
	}

	if (m_depth_attachment.has_value() || m_stencil_attachment.has_value())
	{
		VkAttachmentDescription description = {};
		description.samples                 = VK_SAMPLE_COUNT_1_BIT;
		description.initialLayout           = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
		description.finalLayout             = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
		description.format                  = m_depth_format.value();

		if (m_depth_attachment.has_value())
		{
			description.loadOp  = m_depth_attachment.value().loadOp;
			description.storeOp = m_depth_attachment.value().storeOp;
		}

		if (m_stencil_attachment.has_value())
		{
			description.stencilLoadOp  = m_stencil_attachment.value().loadOp;
			description.stencilStoreOp = m_stencil_attachment.value().storeOp;
		}

		VkAttachmentReference reference = {};
		reference.attachment            = static_cast<uint32_t>(descriptions.size());
		reference.layout                = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

		descriptions.push_back(description);
		depth_stencil_reference = reference;
	}

	if (RenderPassCache.find(m_hash) != RenderPassCache.end())
	{
		return RenderPassCache.at(m_hash);
	}

	VkRenderPass render_pass = VK_NULL_HANDLE;

	VkSubpassDescription subpass_description    = {};
	subpass_description.pipelineBindPoint       = VK_PIPELINE_BIND_POINT_GRAPHICS;
	subpass_description.colorAttachmentCount    = static_cast<uint32_t>(color_references.size());
	subpass_description.pColorAttachments       = color_references.data();
	subpass_description.pDepthStencilAttachment = depth_stencil_reference.has_value() ? &depth_stencil_reference.value() : nullptr;

	std::array<VkSubpassDependency, 2> subpass_dependencies;

	subpass_dependencies[0].srcSubpass      = VK_SUBPASS_EXTERNAL;
	subpass_dependencies[0].dstSubpass      = 0;
	subpass_dependencies[0].srcStageMask    = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
	subpass_dependencies[0].dstStageMask    = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
	subpass_dependencies[0].srcAccessMask   = VK_ACCESS_MEMORY_READ_BIT;
	subpass_dependencies[0].dstAccessMask   = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
	subpass_dependencies[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;

	subpass_dependencies[1].srcSubpass      = 0;
	subpass_dependencies[1].dstSubpass      = VK_SUBPASS_EXTERNAL;
	subpass_dependencies[1].srcStageMask    = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
	subpass_dependencies[1].dstStageMask    = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
	subpass_dependencies[1].srcAccessMask   = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
	subpass_dependencies[1].dstAccessMask   = VK_ACCESS_MEMORY_READ_BIT;
	subpass_dependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;

	// Create render pass
	VkRenderPassCreateInfo render_pass_create_info = {};
	render_pass_create_info.sType                  = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
	render_pass_create_info.attachmentCount        = static_cast<uint32_t>(descriptions.size());
	render_pass_create_info.pAttachments           = descriptions.data();
	render_pass_create_info.subpassCount           = 1;
	render_pass_create_info.pSubpasses             = &subpass_description;
	render_pass_create_info.dependencyCount        = static_cast<uint32_t>(subpass_dependencies.size());
	render_pass_create_info.pDependencies          = subpass_dependencies.data();

	vkCreateRenderPass(static_cast<Device *>(p_device)->GetDevice(), &render_pass_create_info, nullptr, &render_pass);

	RenderPassCache.emplace(m_hash, render_pass);

	return render_pass;
}

VkFramebuffer RenderTarget::GetFramebuffer() const
{
	std::vector<VkImageView> views;
	views.reserve(m_color_attachments.size() + 1);
	for (auto &attachment : m_color_attachments)
	{
		views.push_back(attachment.imageView);
	}
	if (m_depth_attachment.has_value())
	{
		views.push_back(m_depth_attachment.value().imageView);
	}

	size_t hash = 0;
	HashCombine(hash, views);

	if (FramebufferCache.find(hash) != FramebufferCache.end())
	{
		return FramebufferCache.at(hash);
	}

	VkFramebufferCreateInfo frame_buffer_create_info = {};
	frame_buffer_create_info.sType                   = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
	frame_buffer_create_info.renderPass              = GetRenderPass();
	frame_buffer_create_info.attachmentCount         = static_cast<uint32_t>(views.size());
	frame_buffer_create_info.pAttachments            = views.data();
	frame_buffer_create_info.width                   = m_width;
	frame_buffer_create_info.height                  = m_height;
	frame_buffer_create_info.layers                  = m_layers;

	VkFramebuffer frame_buffer = VK_NULL_HANDLE;
	vkCreateFramebuffer(static_cast<Device *>(p_device)->GetDevice(), &frame_buffer_create_info, nullptr, &frame_buffer);

	FramebufferCache.emplace(hash, frame_buffer);

	return frame_buffer;
}

VkRect2D RenderTarget::GetRenderArea() const
{
	return VkRect2D{
	    VkOffset2D{0, 0},
	    VkExtent2D{m_width, m_height}};
}

std::vector<VkClearValue> RenderTarget::GetClearValue() const
{
	std::vector<VkClearValue> clear_values;
	clear_values.reserve(m_color_attachments.size() + 1);
	for (auto &attachment : m_color_attachments)
	{
		clear_values.push_back(attachment.clearValue);
	}
	if (m_depth_attachment.has_value())
	{
		clear_values.push_back(m_depth_attachment.value().clearValue);
	}

	return clear_values;
}

const std::vector<VkRenderingAttachmentInfo> &RenderTarget::GetColorAttachments()
{
	return m_color_attachments;
}

const std::optional<VkRenderingAttachmentInfo> &RenderTarget::GetDepthAttachment()
{
	return m_depth_attachment;
}

const std::optional<VkRenderingAttachmentInfo> &RenderTarget::GetStencilAttachment()
{
	return m_stencil_attachment;
}

const std::vector<VkFormat> &RenderTarget::GetColorFormats()
{
	return m_color_formats;
}

const std::optional<VkFormat> &RenderTarget::GetDepthFormat()
{
	return m_depth_format;
}

const std::optional<VkFormat> &RenderTarget::GetStencilFormat()
{
	return m_stencil_format;
}

size_t RenderTarget::GetFormatHash() const
{
	size_t hash = 0;
	HashCombine(hash, m_color_formats);

	if (m_depth_format.has_value())
	{
		HashCombine(hash, m_depth_format.value());
	}

	if (m_stencil_format.has_value())
	{
		HashCombine(hash, m_stencil_format.value());
	}

	return hash;
}

size_t RenderTarget::GetHash() const
{
	return m_hash;
}

RHIRenderTarget &RenderTarget::Clear()
{
	m_color_attachments.clear();
	m_depth_attachment.reset();
	m_stencil_attachment.reset();

	m_color_formats.clear();
	m_depth_format.reset();
	m_stencil_format.reset();

	m_width  = 0;
	m_height = 0;

	m_hash = 0;

	return *this;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/RenderTarget.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
struct FrameBufferResolve
{
	VkImageView  view;
	VkClearValue clear_value;
};

class RenderTarget : public RHIRenderTarget
{
  public:
	RenderTarget(RHIDevice *device);

	virtual ~RenderTarget() override;

	virtual RHIRenderTarget &Set(uint32_t slot, RHITexture *texture, RHITextureDimension dimension, const ColorAttachment &attachment) override;
	virtual RHIRenderTarget &Set(uint32_t slot, RHITexture *texture, const TextureRange &range, const ColorAttachment &attachment) override;
	virtual RHIRenderTarget &Set(RHITexture *texture, RHITextureDimension dimension, const DepthStencilAttachment &attachment) override;
	virtual RHIRenderTarget &Set(RHITexture *texture, const TextureRange &range, const DepthStencilAttachment &attachment) override;

	VkRenderPass GetRenderPass() const;

	VkFramebuffer GetFramebuffer() const;

	VkRect2D GetRenderArea() const;

	std::vector<VkClearValue> GetClearValue() const;

	const std::vector<VkRenderingAttachmentInfo> &GetColorAttachments();

	const std::optional<VkRenderingAttachmentInfo> &GetDepthAttachment();

	const std::optional<VkRenderingAttachmentInfo> &GetStencilAttachment();

	const std::vector<VkFormat> &GetColorFormats();

	const std::optional<VkFormat> &GetDepthFormat();

	const std::optional<VkFormat> &GetStencilFormat();

	size_t GetFormatHash() const;

	size_t GetHash() const;

	virtual RHIRenderTarget &Clear() override;

  private:
	// Dynamic Rendering
	std::vector<VkRenderingAttachmentInfo>   m_color_attachments;
	std::optional<VkRenderingAttachmentInfo> m_depth_attachment;
	std::optional<VkRenderingAttachmentInfo> m_stencil_attachment;

	std::vector<VkFormat>   m_color_formats;
	std::optional<VkFormat> m_depth_format;
	std::optional<VkFormat> m_stencil_format;

	size_t m_hash = 0;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Sampler.cpp
================================================
#include "Sampler.hpp"
#include "Definitions.hpp"
#include "Device.hpp"

namespace Ilum::Vulkan
{
Sampler::Sampler(RHIDevice *device, const SamplerDesc &desc) :
    RHISampler(device, desc)
{
	VkSamplerCreateInfo create_info = {};
	create_info.sType               = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
	create_info.minFilter           = ToVulkanFilter[desc.min_filter];
	create_info.magFilter           = ToVulkanFilter[desc.mag_filter];
	create_info.mipmapMode          = ToVulkanMipmapMode[desc.mipmap_mode];
	create_info.addressModeU        = ToVulkanAddressMode[desc.address_mode_u];
	create_info.addressModeV        = ToVulkanAddressMode[desc.address_mode_v];
	create_info.addressModeW        = ToVulkanAddressMode[desc.address_mode_w];
	create_info.anisotropyEnable    = desc.anisotropic;
	create_info.maxAnisotropy       = 16.f;
	create_info.mipLodBias          = desc.mip_lod_bias;
	create_info.minLod              = desc.min_lod;
	create_info.maxLod              = desc.max_lod;
	create_info.borderColor         = ToVulkanBorderColor[desc.border_color];

	vkCreateSampler(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &m_handle);
}

Sampler::~Sampler()
{
	if (m_handle)
	{
		vkDestroySampler(static_cast<Device *>(p_device)->GetDevice(), m_handle, nullptr);
	}
}

VkSampler Sampler::GetHandle() const
{
	return m_handle;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Sampler.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Sampler : public RHISampler
{
  public:
	Sampler(RHIDevice *device, const SamplerDesc &desc);
	virtual ~Sampler() override;

	VkSampler GetHandle() const;

  private:
	VkSampler m_handle = VK_NULL_HANDLE;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Shader.cpp
================================================
#pragma once

#include "Shader.hpp"
#include "Device.hpp"

namespace Ilum::Vulkan
{
Shader::Shader(RHIDevice *device, const std::string &entry_point, const std::vector<uint8_t> &source) :
    RHIShader(device, entry_point, source)
{
	VkShaderModuleCreateInfo create_info = {};
	create_info.sType                    = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
	create_info.codeSize                 = source.size();
	create_info.pCode                    = reinterpret_cast<const uint32_t *>(source.data());
	vkCreateShaderModule(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &m_handle);
}

Shader::~Shader()
{
	if (m_handle)
	{
		vkDestroyShaderModule(static_cast<Device *>(p_device)->GetDevice(), m_handle, nullptr);
	}
}

VkShaderModule Shader::GetHandle() const
{
	return m_handle;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Shader.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Shader : public RHIShader
{
  public:
	Shader(RHIDevice *device, const std::string& entry_point, const std::vector<uint8_t> &source);
	
	virtual ~Shader() override;

	VkShaderModule GetHandle() const;

  private:
	VkShaderModule m_handle = VK_NULL_HANDLE;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Swapchain.cpp
================================================
#pragma once

#include "Swapchain.hpp"
#include "Command.hpp"
#include "Device.hpp"
#include "Queue.hpp"
#include "Synchronization.hpp"
#include "Texture.hpp"

#include <Core/Time.hpp>

#ifdef _WIN32
#	include <Windows.h>
#endif

#include <algorithm>

namespace Ilum::Vulkan
{
inline std::optional<uint32_t> GetQueueFamilyIndex(const std::vector<VkQueueFamilyProperties> &queue_family_properties, VkQueueFlagBits queue_flag)
{
	// Dedicated queue for compute
	// Try to find a queue family index that supports compute but not graphics
	if (queue_flag & VK_QUEUE_COMPUTE_BIT)
	{
		for (uint32_t i = 0; i < static_cast<uint32_t>(queue_family_properties.size()); i++)
		{
			if ((queue_family_properties[i].queueFlags & queue_flag) && ((queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0))
			{
				return i;
				break;
			}
		}
	}

	// Dedicated queue for transfer
	// Try to find a queue family index that supports transfer but not graphics and compute
	if (queue_flag & VK_QUEUE_TRANSFER_BIT)
	{
		for (uint32_t i = 0; i < static_cast<uint32_t>(queue_family_properties.size()); i++)
		{
			if ((queue_family_properties[i].queueFlags & queue_flag) && ((queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) && ((queue_family_properties[i].queueFlags & VK_QUEUE_COMPUTE_BIT) == 0))
			{
				return i;
				break;
			}
		}
	}

	// For other queue types or if no separate compute queue is present, return the first one to support the requested flags
	for (uint32_t i = 0; i < static_cast<uint32_t>(queue_family_properties.size()); i++)
	{
		if (queue_family_properties[i].queueFlags & queue_flag)
		{
			return i;
			break;
		}
	}

	return std::optional<uint32_t>();
}

inline VkPresentModeKHR GetPresentMode(const VkPhysicalDevice &physical_device, const VkSurfaceKHR &surface, bool vsync)
{
	uint32_t                      presentmode_count;
	std::vector<VkPresentModeKHR> presentmodes;
	vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &presentmode_count, nullptr);
	if (presentmode_count != 0)
	{
		presentmodes.resize(presentmode_count);
		vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &presentmode_count, presentmodes.data());
	}

	for (VkPresentModeKHR present_mode : presentmodes)
	{
		if (!vsync)
		{
			if (VK_PRESENT_MODE_MAILBOX_KHR == present_mode)
			{
				return VK_PRESENT_MODE_MAILBOX_KHR;
			}
		}
		else
		{
			if (VK_PRESENT_MODE_FIFO_KHR == present_mode)
			{
				return VK_PRESENT_MODE_FIFO_KHR;
			}
		}
	}
	return VK_PRESENT_MODE_FIFO_KHR;
}

Swapchain::Swapchain(Device *device, void *window_handle, uint32_t width, uint32_t height, bool vsync) :
    RHISwapchain(device, width, height, vsync)
{
#ifdef _WIN32
	{
		VkWin32SurfaceCreateInfoKHR createInfo{};
		createInfo.sType     = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
		createInfo.hwnd      = (HWND) window_handle;
		createInfo.hinstance = GetModuleHandle(nullptr);
		auto result          = vkCreateWin32SurfaceKHR(static_cast<Device *>(device)->GetInstance(), &createInfo, nullptr, &m_surface);
	}
#endif        // _WIN32

	// m_capabilities
	auto result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(static_cast<Device *>(device)->GetPhysicalDevice(), m_surface, &m_capabilities);

	// formats
	uint32_t                        format_count;
	std::vector<VkSurfaceFormatKHR> formats;
	vkGetPhysicalDeviceSurfaceFormatsKHR(static_cast<Device *>(device)->GetPhysicalDevice(), m_surface, &format_count, nullptr);
	if (format_count != 0)
	{
		formats.resize(format_count);
		vkGetPhysicalDeviceSurfaceFormatsKHR(static_cast<Device *>(device)->GetPhysicalDevice(), m_surface, &format_count, formats.data());
	}

	// Choose swapchain surface format
	for (const auto &surface_format : formats)
	{
		if (surface_format.format == VK_FORMAT_B8G8R8A8_UNORM &&
		    surface_format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
		{
			m_surface_format = surface_format;
		}
	}
	if (m_surface_format.format == VK_FORMAT_UNDEFINED)
	{
		m_surface_format = formats[0];
	}

	// Choose swapchain extent
	VkExtent2D chosen_extent = {};
	if (m_capabilities.currentExtent.width != UINT32_MAX)
	{
		chosen_extent = m_capabilities.currentExtent;
	}
	else
	{
		VkExtent2D actualExtent = {};
		actualExtent.width      = width;
		actualExtent.height     = height;

		actualExtent.width =
		    std::clamp(actualExtent.width, m_capabilities.minImageExtent.width, m_capabilities.maxImageExtent.width);
		actualExtent.height =
		    std::clamp(actualExtent.height, m_capabilities.minImageExtent.height, m_capabilities.maxImageExtent.height);

		chosen_extent = actualExtent;
	}

	m_image_count = m_capabilities.minImageCount + 1;
	if (m_capabilities.maxImageCount > 0 && m_image_count > m_capabilities.maxImageCount)
	{
		m_image_count = m_capabilities.maxImageCount;
	}

	// Queue supporting
	uint32_t queue_family_property_count = 0;
	vkGetPhysicalDeviceQueueFamilyProperties(static_cast<Device *>(p_device)->GetPhysicalDevice(), &queue_family_property_count, nullptr);
	std::vector<VkQueueFamilyProperties> queue_family_properties(queue_family_property_count);
	vkGetPhysicalDeviceQueueFamilyProperties(static_cast<Device *>(p_device)->GetPhysicalDevice(), &queue_family_property_count, queue_family_properties.data());

	std::optional<uint32_t> graphics_family, compute_family, transfer_family;

	graphics_family = GetQueueFamilyIndex(queue_family_properties, VK_QUEUE_GRAPHICS_BIT);
	transfer_family = GetQueueFamilyIndex(queue_family_properties, VK_QUEUE_TRANSFER_BIT);
	compute_family  = GetQueueFamilyIndex(queue_family_properties, VK_QUEUE_COMPUTE_BIT);

	VkQueueFlags support_queues = 0;

	for (uint32_t i = 0; i < queue_family_property_count; i++)
	{
		// Check for presentation support
		VkBool32 present_support;
		vkGetPhysicalDeviceSurfaceSupportKHR(static_cast<Device *>(p_device)->GetPhysicalDevice(), i, m_surface, &present_support);

		if (queue_family_properties[i].queueCount > 0 && present_support)
		{
			m_present_family = i;
			break;
		}
	}

	vkGetDeviceQueue(static_cast<Device *>(p_device)->GetDevice(), m_present_family, 0, &m_present_queue);

	Resize(chosen_extent.width, chosen_extent.height, m_vsync);
}

Swapchain::~Swapchain()
{
	if (m_swapchain)
	{
		vkDestroySwapchainKHR(static_cast<Device *>(p_device)->GetDevice(), m_swapchain, nullptr);
	}

	if (m_surface)
	{
		vkDestroySurfaceKHR(static_cast<Device *>(p_device)->GetInstance(), m_surface, nullptr);
	}
}

uint32_t Swapchain::GetTextureCount()
{
	return static_cast<uint32_t>(m_textures.size());
}

void Swapchain::AcquireNextTexture(RHISemaphore *signal_semaphore, RHIFence *signal_fence)
{
	auto result = vkAcquireNextImageKHR(
	    static_cast<Device *>(p_device)->GetDevice(),
	    m_swapchain,
	    std::numeric_limits<uint64_t>::max(),
	    signal_semaphore ? static_cast<Semaphore *>(signal_semaphore)->GetHandle() : nullptr,
	    signal_fence ? static_cast<Fence *>(signal_fence)->GetHandle() : nullptr,
	    &m_frame_index);
}

RHITexture *Swapchain::GetCurrentTexture()
{
	return m_textures[m_frame_index].get();
}

uint32_t Swapchain::GetCurrentFrameIndex()
{
	return m_frame_index;
}

bool Swapchain::Present(RHISemaphore *semaphore)
{
	VkSemaphore semaphore_handle = semaphore ? static_cast<Semaphore *>(semaphore)->GetHandle() : VK_NULL_HANDLE;

	VkPresentInfoKHR present_info = {};
	present_info.sType            = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
	present_info.pNext            = NULL;
	present_info.swapchainCount   = 1;
	present_info.pSwapchains      = &m_swapchain;
	present_info.pImageIndices    = &m_frame_index;

	if (semaphore)
	{
		present_info.pWaitSemaphores    = &semaphore_handle;
		present_info.waitSemaphoreCount = 1;
	}

	vkQueueWaitIdle(m_present_queue);
	auto result = vkQueuePresentKHR(m_present_queue, &present_info);

	if (result == VK_ERROR_OUT_OF_DATE_KHR)
	{
		m_frame_index = 0;
	}

	return result == VK_SUCCESS;
}

void Swapchain::Resize(uint32_t width, uint32_t height, bool vsync)
{
	p_device->WaitIdle();

	m_width  = width;
	m_height = height;
	m_vsync  = vsync;

	VkSwapchainCreateInfoKHR createInfo = {};
	createInfo.sType                    = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
	createInfo.surface                  = m_surface;

	createInfo.minImageCount    = m_image_count;
	createInfo.imageFormat      = m_surface_format.format;
	createInfo.imageColorSpace  = m_surface_format.colorSpace;
	createInfo.imageExtent      = VkExtent2D{width, height};
	createInfo.imageArrayLayers = 1;
	createInfo.imageUsage       = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT;

	uint32_t queueFamilyIndices[] = {m_present_family};

	createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
	createInfo.preTransform     = m_capabilities.currentTransform;
	createInfo.compositeAlpha   = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
	createInfo.presentMode      = GetPresentMode(static_cast<Device *>(p_device)->GetPhysicalDevice(), m_surface, m_vsync);
	createInfo.clipped          = VK_TRUE;

	VkSwapchainKHR old_swapchain = m_swapchain;

	createInfo.oldSwapchain = old_swapchain;

	vkCreateSwapchainKHR(static_cast<Device *>(p_device)->GetDevice(), &createInfo, nullptr, &m_swapchain);

	if (old_swapchain)
	{
		vkDestroySwapchainKHR(static_cast<Device *>(p_device)->GetDevice(), old_swapchain, nullptr);
	}

	{
		m_textures.clear();

		TextureDesc desc = {};
		desc.width       = width;
		desc.height      = height;
		desc.depth       = 1;
		desc.mips        = 1;
		desc.layers      = 1;
		desc.samples     = 1;

		// TODO: Maybe different format?
		desc.format = RHIFormat::B8G8R8A8_UNORM;
		desc.usage  = RHITextureUsage::RenderTarget | RHITextureUsage::UnorderedAccess;

		uint32_t m_image_count = 0;

		std::vector<VkImage> images;
		vkGetSwapchainImagesKHR(static_cast<Device *>(p_device)->GetDevice(), m_swapchain, &m_image_count, nullptr);
		images.resize(m_image_count);
		vkGetSwapchainImagesKHR(static_cast<Device *>(p_device)->GetDevice(), m_swapchain, &m_image_count, images.data());

		for (size_t i = 0; i < images.size(); i++)
		{
			desc.name = "Swapchain Image " + std::to_string(i);
			m_textures.emplace_back(std::make_unique<Texture>(static_cast<Device *>(p_device), desc, images[i]));
		}
	}

	{
		auto cmd_buffer = std::make_unique<Command>(p_device, RHIQueueFamily::Graphics);
		cmd_buffer->Init();
		cmd_buffer->Begin();
		cmd_buffer->ResourceStateTransition({TextureStateTransition{m_textures[0].get(), RHIResourceState::Undefined, RHIResourceState::Present, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
		                                     TextureStateTransition{m_textures[1].get(), RHIResourceState::Undefined, RHIResourceState::Present, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
		                                     TextureStateTransition{m_textures[2].get(), RHIResourceState::Undefined, RHIResourceState::Present, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
		                                    {});
		cmd_buffer->End();
		auto fence = std::make_unique<Fence>(p_device);

		auto vk_cmd_buffer = cmd_buffer->GetHandle();

		VkSubmitInfo submit_info         = {};
		submit_info.sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO;
		submit_info.commandBufferCount   = 1;
		submit_info.pCommandBuffers      = &vk_cmd_buffer;
		submit_info.signalSemaphoreCount = 0;
		submit_info.pSignalSemaphores    = nullptr;
		submit_info.waitSemaphoreCount   = 0;
		submit_info.pWaitSemaphores      = nullptr;
		submit_info.pWaitDstStageMask    = nullptr;

		vkQueueSubmit(m_present_queue, 1, &submit_info, fence ? fence->GetHandle() : nullptr);
		fence->Wait();
	}

	m_frame_index = 0;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Swapchain.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Texture;
class Queue;
class Device;

class Swapchain : public RHISwapchain
{
  public:
	Swapchain(Device *device, void *window_handle, uint32_t width, uint32_t height, bool vsync);

	virtual ~Swapchain() override;

	virtual uint32_t GetTextureCount() override;

	virtual void AcquireNextTexture(RHISemaphore *signal_semaphore, RHIFence *signal_fence) override;

	virtual RHITexture *GetCurrentTexture() override;

	virtual uint32_t GetCurrentFrameIndex() override;

	virtual bool Present(RHISemaphore *semaphore) override;

	virtual void Resize(uint32_t width, uint32_t height, bool vsync) override;

  private:
	VkSurfaceKHR   m_surface   = VK_NULL_HANDLE;
	VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;

	VkQueue m_present_queue = VK_NULL_HANDLE;
	uint32_t m_present_family = 0;

	std::vector<std::unique_ptr<Texture>> m_textures;

	uint32_t                 m_image_count = 0;
	VkSurfaceFormatKHR       m_surface_format;
	VkSurfaceCapabilitiesKHR m_capabilities;

	uint32_t m_frame_index = 0;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Synchronization.cpp
================================================
#include "Synchronization.hpp"
#include "Device.hpp"

#include <dxgi1_2.h>

namespace Ilum::Vulkan
{
Fence::Fence(RHIDevice *device) :
    RHIFence(device)
{
	VkFenceCreateInfo create_info = {};
	create_info.sType             = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
	vkCreateFence(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &m_handle);
}

Fence::~Fence()
{
	if (m_handle)
	{
		vkDestroyFence(static_cast<Device *>(p_device)->GetDevice(), m_handle, nullptr);
	}
}

void Fence::Wait(uint64_t timeout)
{
	vkWaitForFences(static_cast<Device *>(p_device)->GetDevice(), 1, &m_handle, true, timeout);
}

void Fence::Reset()
{
	vkResetFences(static_cast<Device *>(p_device)->GetDevice(), 1, &m_handle);
}

VkFence Fence::GetHandle() const
{
	return m_handle;
}

Semaphore::Semaphore(RHIDevice *device) :
    RHISemaphore(device)
{
	VkSemaphoreCreateInfo create_info = {};
	create_info.sType                 = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
	create_info.pNext                 = nullptr;

#ifdef CUDA_ENABLE
#	if defined(_WIN64)
	WindowsSecurityAttributes windows_security_attributes;

	VkExportSemaphoreWin32HandleInfoKHR export_semaphore_win32_handle_info = {};
	export_semaphore_win32_handle_info.sType                               = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
	export_semaphore_win32_handle_info.pNext                               = NULL;
	export_semaphore_win32_handle_info.pAttributes                         = &windows_security_attributes;
	export_semaphore_win32_handle_info.dwAccess                            = DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE;
	export_semaphore_win32_handle_info.name                                = (LPCWSTR) NULL;
#	endif
	VkExportSemaphoreCreateInfoKHR export_semaphore_create_info = {};

	export_semaphore_create_info.sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR;
#	if defined(_WIN64)
	export_semaphore_create_info.pNext       = &export_semaphore_win32_handle_info;
	export_semaphore_create_info.handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
#	else
	export_semaphore_create_info.pNext       = NULL;
	export_semaphore_create_info.handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
#	endif
	create_info.pNext = &export_semaphore_create_info;
#endif        // CUDA_ENABLE



	vkCreateSemaphore(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &m_handle);
}

Semaphore::~Semaphore()
{
	if (m_handle)
	{
		vkDestroySemaphore(static_cast<Device *>(p_device)->GetDevice(), m_handle, nullptr);
	}
}

void Semaphore::SetName(const std::string &name)
{
	VkDebugUtilsObjectNameInfoEXT info = {};
	info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
	info.pObjectName                   = name.c_str();
	info.objectHandle                  = (uint64_t) m_handle;
	info.objectType                    = VK_OBJECT_TYPE_SEMAPHORE;
	static_cast<Device *>(p_device)->SetVulkanObjectName(info);
}

VkSemaphore Semaphore::GetHandle() const
{
	return m_handle;
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Synchronization.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
class Fence : public RHIFence
{
  public:
	Fence(RHIDevice *device);
	virtual ~Fence() override;

	virtual void Wait(uint64_t timeout = std::numeric_limits<uint64_t>::max()) override;
	virtual void Reset() override;

	VkFence GetHandle() const;

  private:
	VkFence m_handle = VK_NULL_HANDLE;
};

class Semaphore : public RHISemaphore
{
  public:
	Semaphore(RHIDevice *device);

	virtual ~Semaphore() override;

	virtual void SetName(const std::string &name) override;

	VkSemaphore GetHandle() const;

  private:
	VkSemaphore m_handle = VK_NULL_HANDLE;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Texture.cpp
================================================
#include "Texture.hpp"
#include "Definitions.hpp"
#include "Device.hpp"

#include <dxgi1_2.h>

namespace Ilum::Vulkan
{
TextureState TextureState::Create(RHIResourceState state)
{
	TextureState vk_state = {};

	switch (state)
	{
		case RHIResourceState::TransferSource:
			vk_state.layout      = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
			vk_state.access_mask = VK_ACCESS_TRANSFER_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_TRANSFER_BIT;
			break;
		case RHIResourceState::TransferDest:
			vk_state.layout      = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
			vk_state.access_mask = VK_ACCESS_TRANSFER_WRITE_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_TRANSFER_BIT;
			break;
		case RHIResourceState::ShaderResource:
			vk_state.layout      = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
			vk_state.access_mask = VK_ACCESS_SHADER_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
			break;
		case RHIResourceState::UnorderedAccess:
			vk_state.layout      = VK_IMAGE_LAYOUT_GENERAL;
			vk_state.access_mask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
			break;
		case RHIResourceState::RenderTarget:
			vk_state.layout      = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
			vk_state.access_mask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
			break;
		case RHIResourceState::DepthWrite:
			vk_state.layout      = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
			vk_state.access_mask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
			break;
		case RHIResourceState::DepthRead:
			vk_state.layout      = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
			vk_state.access_mask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
			break;
		case RHIResourceState::Present:
			vk_state.layout      = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
			vk_state.access_mask = VK_ACCESS_MEMORY_READ_BIT;
			vk_state.stage       = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
			break;
		default:
			vk_state.layout      = VK_IMAGE_LAYOUT_UNDEFINED;
			vk_state.access_mask = VK_ACCESS_NONE_KHR;
			vk_state.stage       = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
			break;
	}
	return vk_state;
}

Texture::Texture(RHIDevice *device, const TextureDesc &desc) :
    RHITexture(device, desc)
{
	VkImageCreateInfo create_info = {};
	create_info.sType             = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
	create_info.imageType         = VK_IMAGE_TYPE_2D;
	create_info.format            = ToVulkanFormat[desc.format];
	create_info.extent            = VkExtent3D{desc.width, desc.height, desc.depth};
	create_info.samples           = ToVulkanSampleCountFlag[desc.samples];
	create_info.mipLevels         = desc.mips;
	create_info.arrayLayers       = desc.layers;
	create_info.tiling            = VK_IMAGE_TILING_OPTIMAL;
	create_info.usage             = ToVulkanImageUsage(desc.usage);
	create_info.sharingMode       = VK_SHARING_MODE_EXCLUSIVE;
	create_info.initialLayout     = VK_IMAGE_LAYOUT_UNDEFINED;

	// Render Target Setting
	if (desc.usage & RHITextureUsage::RenderTarget)
	{
		create_info.usage |= IsDepthFormat(desc.format) ?
		                         VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT :
                                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
	}

	// Cubemap Setting
	if (desc.layers % 6 == 0 && desc.width == desc.height && desc.depth == 1)
	{
		create_info.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
	}

	// External memory use vkallocate method
#ifdef CUDA_ENABLE
	VkExternalMemoryImageCreateInfo external_create_info = {};

	external_create_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
	external_create_info.pNext = nullptr;
#	ifdef _WIN64
	external_create_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
#	else
	external_create_info.handleTypes        = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
#	endif
	create_info.pNext = &external_create_info;

	vkCreateImage(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &m_handle);

	VkMemoryRequirements memory_req = {};
	vkGetImageMemoryRequirements(static_cast<Device *>(p_device)->GetDevice(), m_handle, &memory_req);
	m_memory_size = memory_req.size;

#	ifdef _WIN64
	WindowsSecurityAttributes winSecurityAttributes;

	VkExportMemoryWin32HandleInfoKHR vulkanExportMemoryWin32HandleInfoKHR = {};
	vulkanExportMemoryWin32HandleInfoKHR.sType =
	    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
	vulkanExportMemoryWin32HandleInfoKHR.pNext       = NULL;
	vulkanExportMemoryWin32HandleInfoKHR.pAttributes = &winSecurityAttributes;
	vulkanExportMemoryWin32HandleInfoKHR.dwAccess =
	    DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE;
	vulkanExportMemoryWin32HandleInfoKHR.name = (LPCWSTR) NULL;
#	endif
	VkExportMemoryAllocateInfoKHR export_memory_allocate_info = {};
	export_memory_allocate_info.sType =
	    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR;
#	ifdef _WIN64
	export_memory_allocate_info.pNext       = &vulkanExportMemoryWin32HandleInfoKHR;
	export_memory_allocate_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
#	else
	export_memory_allocate_info.pNext       = NULL;
	export_memory_allocate_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
#	endif

	VkMemoryAllocateInfo allocate_Info = {};
	allocate_Info.sType                = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	allocate_Info.allocationSize       = memory_req.size;
	allocate_Info.pNext                = &export_memory_allocate_info;

	VkPhysicalDeviceMemoryProperties physical_device_properties = {};
	vkGetPhysicalDeviceMemoryProperties(static_cast<Device *>(p_device)->GetPhysicalDevice(), &physical_device_properties);

	for (uint32_t i = 0; i < physical_device_properties.memoryTypeCount; i++)
	{
		if ((memory_req.memoryTypeBits & (1 << i)) &&
		    (physical_device_properties.memoryTypes[i].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
		        (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
		{
			allocate_Info.memoryTypeIndex = i;
			break;
		}
	}

	vkAllocateMemory(static_cast<Device *>(p_device)->GetDevice(), &allocate_Info, nullptr, &m_memory);
	vkBindImageMemory(static_cast<Device *>(p_device)->GetDevice(), m_handle, m_memory, 0);
#else
	VmaAllocationCreateInfo allocation_create_info = {};

	allocation_create_info.usage = VMA_MEMORY_USAGE_GPU_ONLY;

	vmaCreateImage(static_cast<Device *>(p_device)->GetAllocator(), &create_info, &allocation_create_info, &m_handle, &m_allocation, nullptr);

	VkMemoryRequirements memory_req = {};
	vkGetImageMemoryRequirements(static_cast<Device *>(p_device)->GetDevice(), m_handle, &memory_req);
	m_memory_size = memory_req.size;
#endif        // CUDA_ENABLE

	if (!m_desc.name.empty())
	{
		VkDebugUtilsObjectNameInfoEXT info = {};
		info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
		info.pObjectName                   = m_desc.name.c_str();
		info.objectHandle                  = (uint64_t) m_handle;
		info.objectType                    = VK_OBJECT_TYPE_IMAGE;
		static_cast<Device *>(p_device)->SetVulkanObjectName(info);
	}
}

Texture::Texture(RHIDevice *device, const TextureDesc &desc, VkImage image, bool is_swapchain_buffer) :
    RHITexture(device, desc), m_handle(image), m_is_swapchain_buffer(is_swapchain_buffer)
{
	if (!m_desc.name.empty())
	{
		VkDebugUtilsObjectNameInfoEXT info = {};
		info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
		info.pObjectName                   = m_desc.name.c_str();
		info.objectHandle                  = (uint64_t) m_handle;
		info.objectType                    = VK_OBJECT_TYPE_IMAGE;
		static_cast<Device *>(p_device)->SetVulkanObjectName(info);
	}
}

std::unique_ptr<RHITexture> Texture::Alias(const TextureDesc &desc)
{
	if (!m_allocation)
	{
		return std::make_unique<Texture>(p_device, desc);
	}

	VkImageCreateInfo create_info = {};
	create_info.sType             = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
	create_info.imageType         = VK_IMAGE_TYPE_2D;
	create_info.format            = ToVulkanFormat[desc.format];
	create_info.extent            = VkExtent3D{desc.width, desc.height, desc.depth};
	create_info.samples           = ToVulkanSampleCountFlag[desc.samples];
	create_info.mipLevels         = desc.mips;
	create_info.arrayLayers       = desc.layers;
	create_info.tiling            = VK_IMAGE_TILING_OPTIMAL;
	create_info.usage             = ToVulkanImageUsage(desc.usage);
	create_info.sharingMode       = VK_SHARING_MODE_EXCLUSIVE;
	create_info.initialLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
	create_info.flags             = VK_IMAGE_CREATE_ALIAS_BIT;

	// Render Target Setting
	if (desc.usage & RHITextureUsage::RenderTarget)
	{
		create_info.usage |= IsDepthFormat(desc.format) ?
		                         VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT :
                                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
	}

	// Cubemap Setting
	if (desc.layers % 6 == 0 && desc.width == desc.height && desc.depth == 1)
	{
		create_info.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
	}

	VkImage image = VK_NULL_HANDLE;
	vmaCreateAliasingImage(static_cast<Device *>(p_device)->GetAllocator(), m_allocation, &create_info, &image);
	return std::make_unique<Texture>(p_device, desc, image, false);

	/*vkCreateImage(static_cast<Device *>(p_device)->GetDevice(), &create_info, nullptr, &image);

	VkMemoryRequirements memory_req = {};
	vkGetImageMemoryRequirements(static_cast<Device *>(p_device)->GetDevice(), image, &memory_req);

	VmaAllocationInfo info = {};
	vmaGetAllocationInfo(static_cast<Device *>(p_device)->GetAllocator(), m_allocation, &info);

	if (info.size >= memory_req.size)
	{
		vmaBindImageMemory(static_cast<Device *>(p_device)->GetAllocator(), m_allocation, image);
		return std::make_unique<Texture>(p_device, desc, image, false);
	}
	else
	{
		vkDestroyImage(static_cast<Device *>(p_device)->GetDevice(), image, nullptr);
		return std::make_unique<Texture>(p_device, desc);
	}*/
}

Texture::~Texture()
{
	vkDeviceWaitIdle(static_cast<Device *>(p_device)->GetDevice());

	if (m_allocation)
	{
		vmaFreeMemory(static_cast<Device *>(p_device)->GetAllocator(), m_allocation);
		m_allocation = VK_NULL_HANDLE;
	}

	if (m_memory)
	{
		vkFreeMemory(static_cast<Device *>(p_device)->GetDevice(), m_memory, nullptr);
		m_memory = VK_NULL_HANDLE;
	}

	if (m_handle && !m_is_swapchain_buffer)
	{
		vkDestroyImage(static_cast<Device *>(p_device)->GetDevice(), m_handle, nullptr);
		m_handle = VK_NULL_HANDLE;
	}

	for (auto &[hash, view] : m_view_cache)
	{
		vkDestroyImageView(static_cast<Device *>(p_device)->GetDevice(), view, nullptr);
	}
	m_view_cache.clear();
}

VkImage Texture::GetHandle() const
{
	return m_handle;
}

VkDeviceMemory Texture::GetMemory() const
{
	return m_memory;
}

size_t Texture::GetMemorySize() const
{
	return m_memory_size;
}

VkImageView Texture::GetView(const TextureRange &range) const
{
	size_t hash = range.Hash();
	if (m_view_cache.find(hash) != m_view_cache.end())
	{
		return m_view_cache.at(hash);
	}

	VkImageViewCreateInfo view_create_info           = {};
	view_create_info.sType                           = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
	view_create_info.format                          = ToVulkanFormat[m_desc.format];
	view_create_info.image                           = m_handle;
	view_create_info.subresourceRange.aspectMask     = IsDepthFormat(m_desc.format) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
	view_create_info.subresourceRange.baseArrayLayer = range.base_layer;
	view_create_info.subresourceRange.baseMipLevel   = range.base_mip;
	view_create_info.subresourceRange.layerCount     = range.layer_count;
	view_create_info.subresourceRange.levelCount     = range.mip_count;
	view_create_info.viewType                        = ToVulkanImageViewType[range.dimension];
	view_create_info.components                      = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};

	m_view_cache[hash] = VK_NULL_HANDLE;
	vkCreateImageView(static_cast<Device *>(p_device)->GetDevice(), &view_create_info, nullptr, &m_view_cache[hash]);

	if (!m_desc.name.empty())
	{
		std::string name = fmt::format("{} - View {}", m_desc.name, std::to_string(hash));

		VkDebugUtilsObjectNameInfoEXT info = {};
		info.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
		info.pObjectName                   = name.c_str();
		info.objectHandle                  = (uint64_t) m_view_cache[hash];
		info.objectType                    = VK_OBJECT_TYPE_IMAGE_VIEW;
		static_cast<Device *>(p_device)->SetVulkanObjectName(info);
	}

	return m_view_cache.at(hash);
}
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Texture.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum::Vulkan
{
struct TextureState
{
	VkImageLayout        layout      = VK_IMAGE_LAYOUT_UNDEFINED;
	VkAccessFlags        access_mask = VK_ACCESS_NONE;
	VkPipelineStageFlags stage       = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;

	inline bool operator==(const TextureState &other)
	{
		return layout == other.layout &&
		       access_mask == other.access_mask &&
		       stage == other.stage;
	}

	static TextureState Create(RHIResourceState state);
};

class Texture : public RHITexture
{
  public:
	Texture(RHIDevice *device, const TextureDesc &desc);

	Texture(RHIDevice *device, const TextureDesc &desc, VkImage image, bool is_swapchain_buffer = true);

	virtual std::unique_ptr<RHITexture> Alias(const TextureDesc &desc) override;

	virtual ~Texture() override;

	VkImage GetHandle() const;

	VkDeviceMemory GetMemory() const;

	virtual size_t GetMemorySize() const override;

	VkImageView GetView(const TextureRange &range) const;

  private:
	VkImage        m_handle     = VK_NULL_HANDLE;
	VmaAllocation  m_allocation = VK_NULL_HANDLE;
	VkDeviceMemory m_memory     = VK_NULL_HANDLE;

	size_t m_memory_size = 0;

	bool m_is_swapchain_buffer = false;

	mutable std::unordered_map<size_t, VkImageView> m_view_cache;
};
}        // namespace Ilum::Vulkan

================================================
FILE: Source/Plugin/RHI/Vulkan/Vulkan.cpp
================================================
#include "Fwd.hpp"

#include "AccelerationStructure.hpp"
#include "Buffer.hpp"
#include "Command.hpp"
#include "Descriptor.hpp"
#include "Device.hpp"
#include "Frame.hpp"
#include "PipelineState.hpp"
#include "Profiler.hpp"
#include "Queue.hpp"
#include "RenderTarget.hpp"
#include "Sampler.hpp"
#include "Shader.hpp"
#include "Swapchain.hpp"
#include "Synchronization.hpp"
#include "Texture.hpp"

using namespace Ilum;
using namespace Ilum::Vulkan;

#undef CreateSemaphore

extern "C"
{
	EXPORT_API RHIDevice *CreateDevice()
	{
		return new Device;
	}

	EXPORT_API RHIFrame *CreateFrame(Device *device)
	{
		return new Frame(device);
	}

	EXPORT_API RHISwapchain *CreateSwapchain(Device *device, void *window_handle, uint32_t width, uint32_t height, bool vsync)
	{
		return new Swapchain(device, window_handle, width, height, vsync);
	}

	EXPORT_API RHIQueue *CreateQueue(Device *device)
	{
		return new Queue(device);
	}

	EXPORT_API RHIBuffer *CreateBuffer(Device *device, const BufferDesc &desc)
	{
		return new Buffer(device, desc);
	}

	EXPORT_API RHITexture *CreateTexture(Device *device, const TextureDesc &desc)
	{
		return new Texture(device, desc);
	}

	EXPORT_API RHISampler *CreateSampler(Device *device, const SamplerDesc &desc)
	{
		return new Sampler(device, desc);
	}

	EXPORT_API RHIShader *CreateShader(RHIDevice *device, const std::string &entry_point, const std::vector<uint8_t> &source)
	{
		return new Shader(device, entry_point, source);
	}

	EXPORT_API RHIRenderTarget *CreateRenderTarget(Device *device)
	{
		return new RenderTarget(device);
	}

	EXPORT_API RHISemaphore *CreateSemaphore(Device *device)
	{
		return new Semaphore(device);
	}

	EXPORT_API RHIFence *CreateFence(Device *device)
	{
		return new Fence(device);
	}

	EXPORT_API RHIDescriptor *CreateDescriptor(Device *device, const ShaderMeta &meta)
	{
		return new Descriptor(device, meta);
	}

	EXPORT_API RHIPipelineState *CreatePipelineState(Device *device)
	{
		return new PipelineState(device);
	}

	EXPORT_API RHIProfiler *CreateProfiler(RHIDevice *device, uint32_t frame_count)
	{
		return new Profiler(device, frame_count);
	}

	EXPORT_API RHIAccelerationStructure *CreateAccelerationStructure(Device *device)
	{
		return new AccelerationStructure(device);
	}

	EXPORT_API HANDLE GetTextureMemHandle(Device *device, Texture *texture)
	{
		HANDLE handle = {};

		VkMemoryGetWin32HandleInfoKHR handle_info = {};

		handle_info.sType  = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR;
		handle_info.pNext  = NULL;
		handle_info.memory = texture->GetMemory();

#ifdef _WIN64
		handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
#else
		handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
#endif        // _WIN64

		device->GetMemoryWin32Handle(&handle_info, &handle);

		return handle;
	}

	EXPORT_API HANDLE GetBufferMemHandle(Device *device, Buffer *buffer)
	{
		HANDLE handle = {};

		VkMemoryGetWin32HandleInfoKHR handle_info = {};

		handle_info.sType  = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR;
		handle_info.pNext  = NULL;
		handle_info.memory = buffer->GetMemory();

#ifdef _WIN64
		handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
#else
		handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
#endif        // _WIN64

		device->GetMemoryWin32Handle(&handle_info, &handle);

		return handle;
	}

	EXPORT_API HANDLE GetSemaphoreHandle(Device *device, Semaphore *semaphore)
	{
		HANDLE handle = {};

		VkSemaphoreGetWin32HandleInfoKHR handle_info = {};
		handle_info.sType                            = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR;
		handle_info.pNext                            = NULL;
		handle_info.semaphore                        = semaphore->GetHandle();

#ifdef _WIN64
		handle_info.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
#else
		handle_info.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
#endif        // _WIN64

		device->GetSemaphoreWin32Handle(&handle_info, &handle);

		return handle;
	}
}

================================================
FILE: Source/Plugin/RHI/Vulkan/vk_mem_alloc.h
================================================
//
// Copyright (c) 2017-2022 Advanced Micro Devices, Inc. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//

#ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H
#define AMD_VULKAN_MEMORY_ALLOCATOR_H

/** \mainpage Vulkan Memory Allocator

<b>Version 3.1.0-development</b>

Copyright (c) 2017-2022 Advanced Micro Devices, Inc. All rights reserved. \n
License: MIT

<b>API documentation divided into groups:</b> [Modules](modules.html)

\section main_table_of_contents Table of contents

- <b>User guide</b>
  - \subpage quick_start
    - [Project setup](@ref quick_start_project_setup)
    - [Initialization](@ref quick_start_initialization)
    - [Resource allocation](@ref quick_start_resource_allocation)
  - \subpage choosing_memory_type
    - [Usage](@ref choosing_memory_type_usage)
    - [Required and preferred flags](@ref choosing_memory_type_required_preferred_flags)
    - [Explicit memory types](@ref choosing_memory_type_explicit_memory_types)
    - [Custom memory pools](@ref choosing_memory_type_custom_memory_pools)
    - [Dedicated allocations](@ref choosing_memory_type_dedicated_allocations)
  - \subpage memory_mapping
    - [Mapping functions](@ref memory_mapping_mapping_functions)
    - [Persistently mapped memory](@ref memory_mapping_persistently_mapped_memory)
    - [Cache flush and invalidate](@ref memory_mapping_cache_control)
  - \subpage staying_within_budget
    - [Querying for budget](@ref staying_within_budget_querying_for_budget)
    - [Controlling memory usage](@ref staying_within_budget_controlling_memory_usage)
  - \subpage resource_aliasing
  - \subpage custom_memory_pools
    - [Choosing memory type index](@ref custom_memory_pools_MemTypeIndex)
    - [Linear allocation algorithm](@ref linear_algorithm)
      - [Free-at-once](@ref linear_algorithm_free_at_once)
      - [Stack](@ref linear_algorithm_stack)
      - [Double stack](@ref linear_algorithm_double_stack)
      - [Ring buffer](@ref linear_algorithm_ring_buffer)
  - \subpage defragmentation
  - \subpage statistics
    - [Numeric statistics](@ref statistics_numeric_statistics)
    - [JSON dump](@ref statistics_json_dump)
  - \subpage allocation_annotation
    - [Allocation user data](@ref allocation_user_data)
    - [Allocation names](@ref allocation_names)
  - \subpage virtual_allocator
  - \subpage debugging_memory_usage
    - [Memory initialization](@ref debugging_memory_usage_initialization)
    - [Margins](@ref debugging_memory_usage_margins)
    - [Corruption detection](@ref debugging_memory_usage_corruption_detection)
  - \subpage opengl_interop
- \subpage usage_patterns
    - [GPU-only resource](@ref usage_patterns_gpu_only)
    - [Staging copy for upload](@ref usage_patterns_staging_copy_upload)
    - [Readback](@ref usage_patterns_readback)
    - [Advanced data uploading](@ref usage_patterns_advanced_data_uploading)
    - [Other use cases](@ref usage_patterns_other_use_cases)
- \subpage configuration
  - [Pointers to Vulkan functions](@ref config_Vulkan_functions)
  - [Custom host memory allocator](@ref custom_memory_allocator)
  - [Device memory allocation callbacks](@ref allocation_callbacks)
  - [Device heap memory limit](@ref heap_memory_limit)
- <b>Extension support</b>
    - \subpage vk_khr_dedicated_allocation
    - \subpage enabling_buffer_device_address
    - \subpage vk_ext_memory_priority
    - \subpage vk_amd_device_coherent_memory
- \subpage general_considerations
  - [Thread safety](@ref general_considerations_thread_safety)
  - [Versioning and compatibility](@ref general_considerations_versioning_and_compatibility)
  - [Validation layer warnings](@ref general_considerations_validation_layer_warnings)
  - [Allocation algorithm](@ref general_considerations_allocation_algorithm)
  - [Features not supported](@ref general_considerations_features_not_supported)

\section main_see_also See also

- [**Product page on GPUOpen**](https://gpuopen.com/gaming-product/vulkan-memory-allocator/)
- [**Source repository on GitHub**](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)

\defgroup group_init Library initialization

\brief API elements related to the initialization and management of the entire library, especially #VmaAllocator object.

\defgroup group_alloc Memory allocation

\brief API elements related to the allocation, deallocation, and management of Vulkan memory, buffers, images.
Most basic ones being: vmaCreateBuffer(), vmaCreateImage().

\defgroup group_virtual Virtual allocator

\brief API elements related to the mechanism of \ref virtual_allocator - using the core allocation algorithm
for user-defined purpose without allocating any real GPU memory.

\defgroup group_stats Statistics

\brief API elements that query current status of the allocator, from memory usage, budget, to full dump of the internal state in JSON format.
See documentation chapter: \ref statistics.
*/


#ifdef __cplusplus
extern "C" {
#endif

#ifndef VULKAN_H_
    #include <vulkan/vulkan.h>
#endif

#if !defined(VMA_VULKAN_VERSION)
    #if defined(VK_VERSION_1_3)
        #define VMA_VULKAN_VERSION 1003000
    #elif defined(VK_VERSION_1_2)
        #define VMA_VULKAN_VERSION 1002000
    #elif defined(VK_VERSION_1_1)
        #define VMA_VULKAN_VERSION 1001000
    #else
        #define VMA_VULKAN_VERSION 1000000
    #endif
#endif

#if defined(__ANDROID__) && defined(VK_NO_PROTOTYPES) && VMA_STATIC_VULKAN_FUNCTIONS
    extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
    extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
    extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
    extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
    extern PFN_vkAllocateMemory vkAllocateMemory;
    extern PFN_vkFreeMemory vkFreeMemory;
    extern PFN_vkMapMemory vkMapMemory;
    extern PFN_vkUnmapMemory vkUnmapMemory;
    extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
    extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
    extern PFN_vkBindBufferMemory vkBindBufferMemory;
    extern PFN_vkBindImageMemory vkBindImageMemory;
    extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
    extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
    extern PFN_vkCreateBuffer vkCreateBuffer;
    extern PFN_vkDestroyBuffer vkDestroyBuffer;
    extern PFN_vkCreateImage vkCreateImage;
    extern PFN_vkDestroyImage vkDestroyImage;
    extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
    #if VMA_VULKAN_VERSION >= 1001000
        extern PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2;
        extern PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2;
        extern PFN_vkBindBufferMemory2 vkBindBufferMemory2;
        extern PFN_vkBindImageMemory2 vkBindImageMemory2;
        extern PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2;
    #endif // #if VMA_VULKAN_VERSION >= 1001000
#endif // #if defined(__ANDROID__) && VMA_STATIC_VULKAN_FUNCTIONS && VK_NO_PROTOTYPES

#if !defined(VMA_DEDICATED_ALLOCATION)
    #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
        #define VMA_DEDICATED_ALLOCATION 1
    #else
        #define VMA_DEDICATED_ALLOCATION 0
    #endif
#endif

#if !defined(VMA_BIND_MEMORY2)
    #if VK_KHR_bind_memory2
        #define VMA_BIND_MEMORY2 1
    #else
        #define VMA_BIND_MEMORY2 0
    #endif
#endif

#if !defined(VMA_MEMORY_BUDGET)
    #if VK_EXT_memory_budget && (VK_KHR_get_physical_device_properties2 || VMA_VULKAN_VERSION >= 1001000)
        #define VMA_MEMORY_BUDGET 1
    #else
        #define VMA_MEMORY_BUDGET 0
    #endif
#endif

// Defined to 1 when VK_KHR_buffer_device_address device extension or equivalent core Vulkan 1.2 feature is defined in its headers.
#if !defined(VMA_BUFFER_DEVICE_ADDRESS)
    #if VK_KHR_buffer_device_address || VMA_VULKAN_VERSION >= 1002000
        #define VMA_BUFFER_DEVICE_ADDRESS 1
    #else
        #define VMA_BUFFER_DEVICE_ADDRESS 0
    #endif
#endif

// Defined to 1 when VK_EXT_memory_priority device extension is defined in Vulkan headers.
#if !defined(VMA_MEMORY_PRIORITY)
    #if VK_EXT_memory_priority
        #define VMA_MEMORY_PRIORITY 1
    #else
        #define VMA_MEMORY_PRIORITY 0
    #endif
#endif

// Defined to 1 when VK_KHR_external_memory device extension is defined in Vulkan headers.
#if !defined(VMA_EXTERNAL_MEMORY)
    #if VK_KHR_external_memory
        #define VMA_EXTERNAL_MEMORY 1
    #else
        #define VMA_EXTERNAL_MEMORY 0
    #endif
#endif

// Define these macros to decorate all public functions with additional code,
// before and after returned type, appropriately. This may be useful for
// exporting the functions when compiling VMA as a separate library. Example:
// #define VMA_CALL_PRE  __declspec(dllexport)
// #define VMA_CALL_POST __cdecl
#ifndef VMA_CALL_PRE
    #define VMA_CALL_PRE
#endif
#ifndef VMA_CALL_POST
    #define VMA_CALL_POST
#endif

// Define this macro to decorate pointers with an attribute specifying the
// length of the array they point to if they are not null.
//
// The length may be one of
// - The name of another parameter in the argument list where the pointer is declared
// - The name of another member in the struct where the pointer is declared
// - The name of a member of a struct type, meaning the value of that member in
//   the context of the call. For example
//   VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryHeapCount"),
//   this means the number of memory heaps available in the device associated
//   with the VmaAllocator being dealt with.
#ifndef VMA_LEN_IF_NOT_NULL
    #define VMA_LEN_IF_NOT_NULL(len)
#endif

// The VMA_NULLABLE macro is defined to be _Nullable when compiling with Clang.
// see: https://clang.llvm.org/docs/AttributeReference.html#nullable
#ifndef VMA_NULLABLE
    #ifdef __clang__
        #define VMA_NULLABLE _Nullable
    #else
        #define VMA_NULLABLE
    #endif
#endif

// The VMA_NOT_NULL macro is defined to be _Nonnull when compiling with Clang.
// see: https://clang.llvm.org/docs/AttributeReference.html#nonnull
#ifndef VMA_NOT_NULL
    #ifdef __clang__
        #define VMA_NOT_NULL _Nonnull
    #else
        #define VMA_NOT_NULL
    #endif
#endif

// If non-dispatchable handles are represented as pointers then we can give
// then nullability annotations
#ifndef VMA_NOT_NULL_NON_DISPATCHABLE
    #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
        #define VMA_NOT_NULL_NON_DISPATCHABLE VMA_NOT_NULL
    #else
        #define VMA_NOT_NULL_NON_DISPATCHABLE
    #endif
#endif

#ifndef VMA_NULLABLE_NON_DISPATCHABLE
    #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
        #define VMA_NULLABLE_NON_DISPATCHABLE VMA_NULLABLE
    #else
        #define VMA_NULLABLE_NON_DISPATCHABLE
    #endif
#endif

#ifndef VMA_STATS_STRING_ENABLED
    #define VMA_STATS_STRING_ENABLED 1
#endif

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
//    INTERFACE
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

// Sections for managing code placement in file, only for development purposes e.g. for convenient folding inside an IDE.
#ifndef _VMA_ENUM_DECLARATIONS

/**
\addtogroup group_init
@{
*/

/// Flags for created #VmaAllocator.
typedef enum VmaAllocatorCreateFlagBits
{
    /** \brief Allocator and all objects created from it will not be synchronized internally, so you must guarantee they are used from only one thread at a time or synchronized externally by you.

    Using this flag may increase performance because internal mutexes are not used.
    */
    VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
    /** \brief Enables usage of VK_KHR_dedicated_allocation extension.

    The flag works only if VmaAllocatorCreateInfo::vulkanApiVersion `== VK_API_VERSION_1_0`.
    When it is `VK_API_VERSION_1_1`, the flag is ignored because the extension has been promoted to Vulkan 1.1.

    Using this extension will automatically allocate dedicated blocks of memory for
    some buffers and images instead of suballocating place for them out of bigger
    memory blocks (as if you explicitly used #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
    flag) when it is recommended by the driver. It may improve performance on some
    GPUs.

    You may set this flag only if you found out that following device extensions are
    supported, you enabled them while creating Vulkan device passed as
    VmaAllocatorCreateInfo::device, and you want them to be used internally by this
    library:

    - VK_KHR_get_memory_requirements2 (device extension)
    - VK_KHR_dedicated_allocation (device extension)

    When this flag is set, you can experience following warnings reported by Vulkan
    validation layer. You can ignore them.

    > vkBindBufferMemory(): Binding memory to buffer 0x2d but vkGetBufferMemoryRequirements() has not been called on that buffer.
    */
    VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
    /**
    Enables usage of VK_KHR_bind_memory2 extension.

    The flag works only if VmaAllocatorCreateInfo::vulkanApiVersion `== VK_API_VERSION_1_0`.
    When it is `VK_API_VERSION_1_1`, the flag is ignored because the extension has been promoted to Vulkan 1.1.

    You may set this flag only if you found out that this device extension is supported,
    you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
    and you want it to be used internally by this library.

    The extension provides functions `vkBindBufferMemory2KHR` and `vkBindImageMemory2KHR`,
    which allow to pass a chain of `pNext` structures while binding.
    This flag is required if you use `pNext` parameter in vmaBindBufferMemory2() or vmaBindImageMemory2().
    */
    VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT = 0x00000004,
    /**
    Enables usage of VK_EXT_memory_budget extension.

    You may set this flag only if you found out that this device extension is supported,
    you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
    and you want it to be used internally by this library, along with another instance extension
    VK_KHR_get_physical_device_properties2, which is required by it (or Vulkan 1.1, where this extension is promoted).

    The extension provides query for current memory usage and budget, which will probably
    be more accurate than an estimation used by the library otherwise.
    */
    VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT = 0x00000008,
    /**
    Enables usage of VK_AMD_device_coherent_memory extension.

    You may set this flag only if you:

    - found out that this device extension is supported and enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
    - checked that `VkPhysicalDeviceCoherentMemoryFeaturesAMD::deviceCoherentMemory` is true and set it while creating the Vulkan device,
    - want it to be used internally by this library.

    The extension and accompanying device feature provide access to memory types with
    `VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD` and `VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD` flags.
    They are useful mostly for writing breadcrumb markers - a common method for debugging GPU crash/hang/TDR.

    When the extension is not enabled, such memory types are still enumerated, but their usage is illegal.
    To protect from this error, if you don't create the allocator with this flag, it will refuse to allocate any memory or create a custom pool in such memory type,
    returning `VK_ERROR_FEATURE_NOT_PRESENT`.
    */
    VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT = 0x00000010,
    /**
    Enables usage of "buffer device address" feature, which allows you to use function
    `vkGetBufferDeviceAddress*` to get raw GPU pointer to a buffer and pass it for usage inside a shader.

    You may set this flag only if you:

    1. (For Vulkan version < 1.2) Found as available and enabled device extension
    VK_KHR_buffer_device_address.
    This extension is promoted to core Vulkan 1.2.
    2. Found as available and enabled device feature `VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress`.

    When this flag is set, you can create buffers with `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT` using VMA.
    The library automatically adds `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT` to
    allocated memory blocks wherever it might be needed.

    For more information, see documentation chapter \ref enabling_buffer_device_address.
    */
    VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT = 0x00000020,
    /**
    Enables usage of VK_EXT_memory_priority extension in the library.

    You may set this flag only if you found available and enabled this device extension,
    along with `VkPhysicalDeviceMemoryPriorityFeaturesEXT::memoryPriority == VK_TRUE`,
    while creating Vulkan device passed as VmaAllocatorCreateInfo::device.

    When this flag is used, VmaAllocationCreateInfo::priority and VmaPoolCreateInfo::priority
    are used to set priorities of allocated Vulkan memory. Without it, these variables are ignored.

    A priority must be a floating-point value between 0 and 1, indicating the priority of the allocation relative to other memory allocations.
    Larger values are higher priority. The granularity of the priorities is implementation-dependent.
    It is automatically passed to every call to `vkAllocateMemory` done by the library using structure `VkMemoryPriorityAllocateInfoEXT`.
    The value to be used for default priority is 0.5.
    For more details, see the documentation of the VK_EXT_memory_priority extension.
    */
    VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT = 0x00000040,

    VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VmaAllocatorCreateFlagBits;
/// See #VmaAllocatorCreateFlagBits.
typedef VkFlags VmaAllocatorCreateFlags;

/** @} */

/**
\addtogroup group_alloc
@{
*/

/// \brief Intended usage of the allocated memory.
typedef enum VmaMemoryUsage
{
    /** No intended memory usage specified.
    Use other members of VmaAllocationCreateInfo to specify your requirements.
    */
    VMA_MEMORY_USAGE_UNKNOWN = 0,
    /**
    \deprecated Obsolete, preserved for backward compatibility.
    Prefers `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.
    */
    VMA_MEMORY_USAGE_GPU_ONLY = 1,
    /**
    \deprecated Obsolete, preserved for backward compatibility.
    Guarantees `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` and `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT`.
    */
    VMA_MEMORY_USAGE_CPU_ONLY = 2,
    /**
    \deprecated Obsolete, preserved for backward compatibility.
    Guarantees `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`, prefers `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.
    */
    VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
    /**
    \deprecated Obsolete, preserved for backward compatibility.
    Guarantees `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`, prefers `VK_MEMORY_PROPERTY_HOST_CACHED_BIT`.
    */
    VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
    /**
    \deprecated Obsolete, preserved for backward compatibility.
    Prefers not `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.
    */
    VMA_MEMORY_USAGE_CPU_COPY = 5,
    /**
    Lazily allocated GPU memory having `VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT`.
    Exists mostly on mobile platforms. Using it on desktop PC or other GPUs with no such memory type present will fail the allocation.

    Usage: Memory for transient attachment images (color attachments, depth attachments etc.), created with `VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT`.

    Allocations with this usage are always created as dedicated - it implies #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
    */
    VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED = 6,
    /**
    Selects best memory type automatically.
    This flag is recommended for most common use cases.

    When using this flag, if you want to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT),
    you must pass one of the flags: #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
    in VmaAllocationCreateInfo::flags.

    It can be used only with functions that let the library know `VkBufferCreateInfo` or `VkImageCreateInfo`, e.g.
    vmaCreateBuffer(), vmaCreateImage(), vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo()
    and not with generic memory allocation functions.
    */
    VMA_MEMORY_USAGE_AUTO = 7,
    /**
    Selects best memory type automatically with preference for GPU (device) memory.

    When using this flag, if you want to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT),
    you must pass one of the flags: #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
    in VmaAllocationCreateInfo::flags.

    It can be used only with functions that let the library know `VkBufferCreateInfo` or `VkImageCreateInfo`, e.g.
    vmaCreateBuffer(), vmaCreateImage(), vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo()
    and not with generic memory allocation functions.
    */
    VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE = 8,
    /**
    Selects best memory type automatically with preference for CPU (host) memory.

    When using this flag, if you want to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT),
    you must pass one of the flags: #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
    in VmaAllocationCreateInfo::flags.

    It can be used only with functions that let the library know `VkBufferCreateInfo` or `VkImageCreateInfo`, e.g.
    vmaCreateBuffer(), vmaCreateImage(), vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo()
    and not with generic memory allocation functions.
    */
    VMA_MEMORY_USAGE_AUTO_PREFER_HOST = 9,

    VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
} VmaMemoryUsage;

/// Flags to be passed as VmaAllocationCreateInfo::flags.
typedef enum VmaAllocationCreateFlagBits
{
    /** \brief Set this flag if the allocation should have its own memory block.

    Use it for special, big resources, like fullscreen images used as attachments.
    */
    VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,

    /** \brief Set this flag to only try to allocate from existing `VkDeviceMemory` blocks and never create new such block.

    If new allocation cannot be placed in any of the existing blocks, allocation
    fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY` error.

    You should not use #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT and
    #VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT at the same time. It makes no sense.
    */
    VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
    /** \brief Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.

    Pointer to mapped memory will be returned through VmaAllocationInfo::pMappedData.

    It is valid to use this flag for allocation made from memory type that is not
    `HOST_VISIBLE`. This flag is then ignored and memory is not mapped. This is
    useful if you need an allocation that is efficient to use on GPU
    (`DEVICE_LOCAL`) and still want to map it directly if possible on platforms that
    support it (e.g. Intel GPU).
    */
    VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
    /** \deprecated Preserved for backward compatibility. Consider using vmaSetAllocationName() instead.

    Set this flag to treat VmaAllocationCreateInfo::pUserData as pointer to a
    null-terminated string. Instead of copying pointer value, a local copy of the
    string is made and stored in allocation's `pName`. The string is automatically
    freed together with the allocation. It is also used in vmaBuildStatsString().
    */
    VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
    /** Allocation will be created from upper stack in a double stack pool.

    This flag is only allowed for custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT flag.
    */
    VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
    /** Create both buffer/image and allocation, but don't bind them together.
    It is useful when you want to bind yourself to do some more advanced binding, e.g. using some extensions.
    The flag is meaningful only with functions that bind by default: vmaCreateBuffer(), vmaCreateImage().
    Otherwise it is ignored.

    If you want to make sure the new buffer/image is not tied to the new memory allocation
    through `VkMemoryDedicatedAllocateInfoKHR` structure in case the allocation ends up in its own memory block,
    use also flag #VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT.
    */
    VMA_ALLOCATION_CREATE_DONT_BIND_BIT = 0x00000080,
    /** Create allocation only if additional device memory required for it, if any, won't exceed
    memory budget. Otherwise return `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
    */
    VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT = 0x00000100,
    /** \brief Set this flag if the allocated memory will have aliasing resources.

    Usage of this flag prevents supplying `VkMemoryDedicatedAllocateInfoKHR` when #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT is specified.
    Otherwise created dedicated memory will not be suitable for aliasing resources, resulting in Vulkan Validation Layer errors.
    */
    VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT = 0x00000200,
    /**
    Requests possibility to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT).

    - If you use #VMA_MEMORY_USAGE_AUTO or other `VMA_MEMORY_USAGE_AUTO*` value,
      you must use this flag to be able to map the allocation. Otherwise, mapping is incorrect.
    - If you use other value of #VmaMemoryUsage, this flag is ignored and mapping is always possible in memory types that are `HOST_VISIBLE`.
      This includes allocations created in \ref custom_memory_pools.

    Declares that mapped memory will only be written sequentially, e.g. using `memcpy()` or a loop writing number-by-number,
    never read or accessed randomly, so a memory type can be selected that is uncached and write-combined.

    \warning Violating this declaration may work correctly, but will likely be very slow.
    Watch out for implicit reads introduced by doing e.g. `pMappedData[i] += x;`
    Better prepare your data in a local variable and `memcpy()` it to the mapped pointer all at once.
    */
    VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT = 0x00000400,
    /**
    Requests possibility to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT).

    - If you use #VMA_MEMORY_USAGE_AUTO or other `VMA_MEMORY_USAGE_AUTO*` value,
      you must use this flag to be able to map the allocation. Otherwise, mapping is incorrect.
    - If you use other value of #VmaMemoryUsage, this flag is ignored and mapping is always possible in memory types that are `HOST_VISIBLE`.
      This includes allocations created in \ref custom_memory_pools.

    Declares that mapped memory can be read, written, and accessed in random order,
    so a `HOST_CACHED` memory type is required.
    */
    VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT = 0x00000800,
    /**
    Together with #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT,
    it says that despite request for host access, a not-`HOST_VISIBLE` memory type can be selected
    if it may improve performance.

    By using this flag, you declare that you will check if the allocation ended up in a `HOST_VISIBLE` memory type
    (e.g. using vmaGetAllocationMemoryProperties()) and if not, you will create some "staging" buffer and
    issue an explicit transfer to write/read your data.
    To prepare for this possibility, don't forget to add appropriate flags like
    `VK_BUFFER_USAGE_TRANSFER_DST_BIT`, `VK_BUFFER_USAGE_TRANSFER_SRC_BIT` to the parameters of created buffer or image.
    */
    VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT = 0x00001000,
    /** Allocation strategy that chooses smallest possible free range for the allocation
    to minimize memory usage and fragmentation, possibly at the expense of allocation time.
    */
    VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = 0x00010000,
    /** Allocation strategy that chooses first suitable free range for the allocation -
    not necessarily in terms of the smallest offset but the one that is easiest and fastest to find
    to minimize allocation time, possibly at the expense of allocation quality.
    */
    VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = 0x00020000,
    /** Allocation strategy that chooses always the lowest offset in available space.
    This is not the most efficient strategy but achieves highly packed data.
    Used internally by defragmentation, not recommended in typical usage.
    */
    VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT  = 0x00040000,
    /** Alias to #VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT.
    */
    VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT,
    /** Alias to #VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT.
    */
    VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT,
    /** A bit mask to extract only `STRATEGY` bits from entire set of flags.
    */
    VMA_ALLOCATION_CREATE_STRATEGY_MASK =
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT |
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT |
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,

    VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VmaAllocationCreateFlagBits;
/// See #VmaAllocationCreateFlagBits.
typedef VkFlags VmaAllocationCreateFlags;

/// Flags to be passed as VmaPoolCreateInfo::flags.
typedef enum VmaPoolCreateFlagBits
{
    /** \brief Use this flag if you always allocate only buffers and linear images or only optimal images out of this pool and so Buffer-Image Granularity can be ignored.

    This is an optional optimization flag.

    If you always allocate using vmaCreateBuffer(), vmaCreateImage(),
    vmaAllocateMemoryForBuffer(), then you don't need to use it because allocator
    knows exact type of your allocations so it can handle Buffer-Image Granularity
    in the optimal way.

    If you also allocate using vmaAllocateMemoryForImage() or vmaAllocateMemory(),
    exact type of such allocations is not known, so allocator must be conservative
    in handling Buffer-Image Granularity, which can lead to suboptimal allocation
    (wasted memory). In that case, if you can make sure you always allocate only
    buffers and linear images or only optimal images out of this pool, use this flag
    to make allocator disregard Buffer-Image Granularity and so make allocations
    faster and more optimal.
    */
    VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,

    /** \brief Enables alternative, linear allocation algorithm in this pool.

    Specify this flag to enable linear allocation algorithm, which always creates
    new allocations after last one and doesn't reuse space from allocations freed in
    between. It trades memory consumption for simplified algorithm and data
    structure, which has better performance and uses less memory for metadata.

    By using this flag, you can achieve behavior of free-at-once, stack,
    ring buffer, and double stack.
    For details, see documentation chapter \ref linear_algorithm.
    */
    VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,

    /** Bit mask to extract only `ALGORITHM` bits from entire set of flags.
    */
    VMA_POOL_CREATE_ALGORITHM_MASK =
        VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT,

    VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VmaPoolCreateFlagBits;
/// Flags to be passed as VmaPoolCreateInfo::flags. See #VmaPoolCreateFlagBits.
typedef VkFlags VmaPoolCreateFlags;

/// Flags to be passed as VmaDefragmentationInfo::flags.
typedef enum VmaDefragmentationFlagBits
{
    /* \brief Use simple but fast algorithm for defragmentation.
    May not achieve best results but will require least time to compute and least allocations to copy.
    */
    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT = 0x1,
    /* \brief Default defragmentation algorithm, applied also when no `ALGORITHM` flag is specified.
    Offers a balance between defragmentation quality and the amount of allocations and bytes that need to be moved.
    */
    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT = 0x2,
    /* \brief Perform full defragmentation of memory.
    Can result in notably more time to compute and allocations to copy, but will achieve best memory packing.
    */
    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT = 0x4,
    /** \brief Use the most roboust algorithm at the cost of time to compute and number of copies to make.
    Only available when bufferImageGranularity is greater than 1, since it aims to reduce
    alignment issues between different types of resources.
    Otherwise falls back to same behavior as #VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT.
    */
    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT = 0x8,

    /// A bit mask to extract only `ALGORITHM` bits from entire set of flags.
    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_MASK =
        VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT |
        VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT |
        VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT |
        VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT,

    VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VmaDefragmentationFlagBits;
/// See #VmaDefragmentationFlagBits.
typedef VkFlags VmaDefragmentationFlags;

/// Operation performed on single defragmentation move. See structure #VmaDefragmentationMove.
typedef enum VmaDefragmentationMoveOperation
{
    /// Buffer/image has been recreated at `dstTmpAllocation`, data has been copied, old buffer/image has been destroyed. `srcAllocation` should be changed to point to the new place. This is the default value set by vmaBeginDefragmentationPass().
    VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY = 0,
    /// Set this value if you cannot move the allocation. New place reserved at `dstTmpAllocation` will be freed. `srcAllocation` will remain unchanged.
    VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE = 1,
    /// Set this value if you decide to abandon the allocation and you destroyed the buffer/image. New place reserved at `dstTmpAllocation` will be freed, along with `srcAllocation`, which will be destroyed.
    VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY = 2,
} VmaDefragmentationMoveOperation;

/** @} */

/**
\addtogroup group_virtual
@{
*/

/// Flags to be passed as VmaVirtualBlockCreateInfo::flags.
typedef enum VmaVirtualBlockCreateFlagBits
{
    /** \brief Enables alternative, linear allocation algorithm in this virtual block.

    Specify this flag to enable linear allocation algorithm, which always creates
    new allocations after last one and doesn't reuse space from allocations freed in
    between. It trades memory consumption for simplified algorithm and data
    structure, which has better performance and uses less memory for metadata.

    By using this flag, you can achieve behavior of free-at-once, stack,
    ring buffer, and double stack.
    For details, see documentation chapter \ref linear_algorithm.
    */
    VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT = 0x00000001,

    /** \brief Bit mask to extract only `ALGORITHM` bits from entire set of flags.
    */
    VMA_VIRTUAL_BLOCK_CREATE_ALGORITHM_MASK =
        VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT,

    VMA_VIRTUAL_BLOCK_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VmaVirtualBlockCreateFlagBits;
/// Flags to be passed as VmaVirtualBlockCreateInfo::flags. See #VmaVirtualBlockCreateFlagBits.
typedef VkFlags VmaVirtualBlockCreateFlags;

/// Flags to be passed as VmaVirtualAllocationCreateInfo::flags.
typedef enum VmaVirtualAllocationCreateFlagBits
{
    /** \brief Allocation will be created from upper stack in a double stack pool.

    This flag is only allowed for virtual blocks created with #VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT flag.
    */
    VMA_VIRTUAL_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT,
    /** \brief Allocation strategy that tries to minimize memory usage.
    */
    VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT,
    /** \brief Allocation strategy that tries to minimize allocation time.
    */
    VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT,
    /** Allocation strategy that chooses always the lowest offset in available space.
    This is not the most efficient strategy but achieves highly packed data.
    */
    VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
    /** \brief A bit mask to extract only `STRATEGY` bits from entire set of flags.

    These strategy flags are binary compatible with equivalent flags in #VmaAllocationCreateFlagBits.
    */
    VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MASK = VMA_ALLOCATION_CREATE_STRATEGY_MASK,

    VMA_VIRTUAL_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VmaVirtualAllocationCreateFlagBits;
/// Flags to be passed as VmaVirtualAllocationCreateInfo::flags. See #VmaVirtualAllocationCreateFlagBits.
typedef VkFlags VmaVirtualAllocationCreateFlags;

/** @} */

#endif // _VMA_ENUM_DECLARATIONS

#ifndef _VMA_DATA_TYPES_DECLARATIONS

/**
\addtogroup group_init
@{ */

/** \struct VmaAllocator
\brief Represents main object of this library initialized.

Fill structure #VmaAllocatorCreateInfo and call function vmaCreateAllocator() to create it.
Call function vmaDestroyAllocator() to destroy it.

It is recommended to create just one object of this type per `VkDevice` object,
right after Vulkan is initialized and keep it alive until before Vulkan device is destroyed.
*/
VK_DEFINE_HANDLE(VmaAllocator)

/** @} */

/**
\addtogroup group_alloc
@{
*/

/** \struct VmaPool
\brief Represents custom memory pool

Fill structure VmaPoolCreateInfo and call function vmaCreatePool() to create it.
Call function vmaDestroyPool() to destroy it.

For more information see [Custom memory pools](@ref choosing_memory_type_custom_memory_pools).
*/
VK_DEFINE_HANDLE(VmaPool)

/** \struct VmaAllocation
\brief Represents single memory allocation.

It may be either dedicated block of `VkDeviceMemory` or a specific region of a bigger block of this type
plus unique offset.

There are multiple ways to create such object.
You need to fill structure VmaAllocationCreateInfo.
For more information see [Choosing memory type](@ref choosing_memory_type).

Although the library provides convenience functions that create Vulkan buffer or image,
allocate memory for it and bind them together,
binding of the allocation to a buffer or an image is out of scope of the allocation itself.
Allocation object can exist without buffer/image bound,
binding can be done manually by the user, and destruction of it can be done
independently of destruction of the allocation.

The object also remembers its size and some other information.
To retrieve this information, use function vmaGetAllocationInfo() and inspect
returned structure VmaAllocationInfo.
*/
VK_DEFINE_HANDLE(VmaAllocation)

/** \struct VmaDefragmentationContext
\brief An opaque object that represents started defragmentation process.

Fill structure #VmaDefragmentationInfo and call function vmaBeginDefragmentation() to create it.
Call function vmaEndDefragmentation() to destroy it.
*/
VK_DEFINE_HANDLE(VmaDefragmentationContext)

/** @} */

/**
\addtogroup group_virtual
@{
*/

/** \struct VmaVirtualAllocation
\brief Represents single memory allocation done inside VmaVirtualBlock.

Use it as a unique identifier to virtual allocation within the single block.

Use value `VK_NULL_HANDLE` to represent a null/invalid allocation.
*/
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VmaVirtualAllocation)

/** @} */

/**
\addtogroup group_virtual
@{
*/

/** \struct VmaVirtualBlock
\brief Handle to a virtual block object that allows to use core allocation algorithm without allocating any real GPU memory.

Fill in #VmaVirtualBlockCreateInfo structure and use vmaCreateVirtualBlock() to create it. Use vmaDestroyVirtualBlock() to destroy it.
For more information, see documentation chapter \ref virtual_allocator.

This object is not thread-safe - should not be used from multiple threads simultaneously, must be synchronized externally.
*/
VK_DEFINE_HANDLE(VmaVirtualBlock)

/** @} */

/**
\addtogroup group_init
@{
*/

/// Callback function called after successful vkAllocateMemory.
typedef void (VKAPI_PTR* PFN_vmaAllocateDeviceMemoryFunction)(
    VmaAllocator VMA_NOT_NULL                    allocator,
    uint32_t                                     memoryType,
    VkDeviceMemory VMA_NOT_NULL_NON_DISPATCHABLE memory,
    VkDeviceSize                                 size,
    void* VMA_NULLABLE                           pUserData);

/// Callback function called before vkFreeMemory.
typedef void (VKAPI_PTR* PFN_vmaFreeDeviceMemoryFunction)(
    VmaAllocator VMA_NOT_NULL                    allocator,
    uint32_t                                     memoryType,
    VkDeviceMemory VMA_NOT_NULL_NON_DISPATCHABLE memory,
    VkDeviceSize                                 size,
    void* VMA_NULLABLE                           pUserData);

/** \brief Set of callbacks that the library will call for `vkAllocateMemory` and `vkFreeMemory`.

Provided for informative purpose, e.g. to gather statistics about number of
allocations or total amount of memory allocated in Vulkan.

Used in VmaAllocatorCreateInfo::pDeviceMemoryCallbacks.
*/
typedef struct VmaDeviceMemoryCallbacks
{
    /// Optional, can be null.
    PFN_vmaAllocateDeviceMemoryFunction VMA_NULLABLE pfnAllocate;
    /// Optional, can be null.
    PFN_vmaFreeDeviceMemoryFunction VMA_NULLABLE pfnFree;
    /// Optional, can be null.
    void* VMA_NULLABLE pUserData;
} VmaDeviceMemoryCallbacks;

/** \brief Pointers to some Vulkan functions - a subset used by the library.

Used in VmaAllocatorCreateInfo::pVulkanFunctions.
*/
typedef struct VmaVulkanFunctions
{
    /// Required when using VMA_DYNAMIC_VULKAN_FUNCTIONS.
    PFN_vkGetInstanceProcAddr VMA_NULLABLE vkGetInstanceProcAddr;
    /// Required when using VMA_DYNAMIC_VULKAN_FUNCTIONS.
    PFN_vkGetDeviceProcAddr VMA_NULLABLE vkGetDeviceProcAddr;
    PFN_vkGetPhysicalDeviceProperties VMA_NULLABLE vkGetPhysicalDeviceProperties;
    PFN_vkGetPhysicalDeviceMemoryProperties VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties;
    PFN_vkAllocateMemory VMA_NULLABLE vkAllocateMemory;
    PFN_vkFreeMemory VMA_NULLABLE vkFreeMemory;
    PFN_vkMapMemory VMA_NULLABLE vkMapMemory;
    PFN_vkUnmapMemory VMA_NULLABLE vkUnmapMemory;
    PFN_vkFlushMappedMemoryRanges VMA_NULLABLE vkFlushMappedMemoryRanges;
    PFN_vkInvalidateMappedMemoryRanges VMA_NULLABLE vkInvalidateMappedMemoryRanges;
    PFN_vkBindBufferMemory VMA_NULLABLE vkBindBufferMemory;
    PFN_vkBindImageMemory VMA_NULLABLE vkBindImageMemory;
    PFN_vkGetBufferMemoryRequirements VMA_NULLABLE vkGetBufferMemoryRequirements;
    PFN_vkGetImageMemoryRequirements VMA_NULLABLE vkGetImageMemoryRequirements;
    PFN_vkCreateBuffer VMA_NULLABLE vkCreateBuffer;
    PFN_vkDestroyBuffer VMA_NULLABLE vkDestroyBuffer;
    PFN_vkCreateImage VMA_NULLABLE vkCreateImage;
    PFN_vkDestroyImage VMA_NULLABLE vkDestroyImage;
    PFN_vkCmdCopyBuffer VMA_NULLABLE vkCmdCopyBuffer;
#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
    /// Fetch "vkGetBufferMemoryRequirements2" on Vulkan >= 1.1, fetch "vkGetBufferMemoryRequirements2KHR" when using VK_KHR_dedicated_allocation extension.
    PFN_vkGetBufferMemoryRequirements2KHR VMA_NULLABLE vkGetBufferMemoryRequirements2KHR;
    /// Fetch "vkGetImageMemoryRequirements2" on Vulkan >= 1.1, fetch "vkGetImageMemoryRequirements2KHR" when using VK_KHR_dedicated_allocation extension.
    PFN_vkGetImageMemoryRequirements2KHR VMA_NULLABLE vkGetImageMemoryRequirements2KHR;
#endif
#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
    /// Fetch "vkBindBufferMemory2" on Vulkan >= 1.1, fetch "vkBindBufferMemory2KHR" when using VK_KHR_bind_memory2 extension.
    PFN_vkBindBufferMemory2KHR VMA_NULLABLE vkBindBufferMemory2KHR;
    /// Fetch "vkBindImageMemory2" on Vulkan >= 1.1, fetch "vkBindImageMemory2KHR" when using VK_KHR_bind_memory2 extension.
    PFN_vkBindImageMemory2KHR VMA_NULLABLE vkBindImageMemory2KHR;
#endif
#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
    PFN_vkGetPhysicalDeviceMemoryProperties2KHR VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties2KHR;
#endif
#if VMA_VULKAN_VERSION >= 1003000
    /// Fetch from "vkGetDeviceBufferMemoryRequirements" on Vulkan >= 1.3, but you can also fetch it from "vkGetDeviceBufferMemoryRequirementsKHR" if you enabled extension VK_KHR_maintenance4.
    PFN_vkGetDeviceBufferMemoryRequirements VMA_NULLABLE vkGetDeviceBufferMemoryRequirements;
    /// Fetch from "vkGetDeviceImageMemoryRequirements" on Vulkan >= 1.3, but you can also fetch it from "vkGetDeviceImageMemoryRequirementsKHR" if you enabled extension VK_KHR_maintenance4.
    PFN_vkGetDeviceImageMemoryRequirements VMA_NULLABLE vkGetDeviceImageMemoryRequirements;
#endif
} VmaVulkanFunctions;

/// Description of a Allocator to be created.
typedef struct VmaAllocatorCreateInfo
{
    /// Flags for created allocator. Use #VmaAllocatorCreateFlagBits enum.
    VmaAllocatorCreateFlags flags;
    /// Vulkan physical device.
    /** It must be valid throughout whole lifetime of created allocator. */
    VkPhysicalDevice VMA_NOT_NULL physicalDevice;
    /// Vulkan device.
    /** It must be valid throughout whole lifetime of created allocator. */
    VkDevice VMA_NOT_NULL device;
    /// Preferred size of a single `VkDeviceMemory` block to be allocated from large heaps > 1 GiB. Optional.
    /** Set to 0 to use default, which is currently 256 MiB. */
    VkDeviceSize preferredLargeHeapBlockSize;
    /// Custom CPU memory allocation callbacks. Optional.
    /** Optional, can be null. When specified, will also be used for all CPU-side memory allocations. */
    const VkAllocationCallbacks* VMA_NULLABLE pAllocationCallbacks;
    /// Informative callbacks for `vkAllocateMemory`, `vkFreeMemory`. Optional.
    /** Optional, can be null. */
    const VmaDeviceMemoryCallbacks* VMA_NULLABLE pDeviceMemoryCallbacks;
    /** \brief Either null or a pointer to an array of limits on maximum number of bytes that can be allocated out of particular Vulkan memory heap.

    If not NULL, it must be a pointer to an array of
    `VkPhysicalDeviceMemoryProperties::memoryHeapCount` elements, defining limit on
    maximum number of bytes that can be allocated out of particular Vulkan memory
    heap.

    Any of the elements may be equal to `VK_WHOLE_SIZE`, which means no limit on that
    heap. This is also the default in case of `pHeapSizeLimit` = NULL.

    If there is a limit defined for a heap:

    - If user tries to allocate more memory from that heap using this allocator,
      the allocation fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
    - If the limit is smaller than heap size reported in `VkMemoryHeap::size`, the
      value of this limit will be reported instead when using vmaGetMemoryProperties().

    Warning! Using this feature may not be equivalent to installing a GPU with
    smaller amount of memory, because graphics driver doesn't necessary fail new
    allocations with `VK_ERROR_OUT_OF_DEVICE_MEMORY` result when memory capacity is
    exceeded. It may return success and just silently migrate some device memory
    blocks to system RAM. This driver behavior can also be controlled using
    VK_AMD_memory_overallocation_behavior extension.
    */
    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryHeapCount") pHeapSizeLimit;

    /** \brief Pointers to Vulkan functions. Can be null.

    For details see [Pointers to Vulkan functions](@ref config_Vulkan_functions).
    */
    const VmaVulkanFunctions* VMA_NULLABLE pVulkanFunctions;
    /** \brief Handle to Vulkan instance object.

    Starting from version 3.0.0 this member is no longer optional, it must be set!
    */
    VkInstance VMA_NOT_NULL instance;
    /** \brief Optional. The highest version of Vulkan that the application is designed to use.

    It must be a value in the format as created by macro `VK_MAKE_VERSION` or a constant like: `VK_API_VERSION_1_1`, `VK_API_VERSION_1_0`.
    The patch version number specified is ignored. Only the major and minor versions are considered.
    It must be less or equal (preferably equal) to value as passed to `vkCreateInstance` as `VkApplicationInfo::apiVersion`.
    Only versions 1.0, 1.1, 1.2, 1.3 are supported by the current implementation.
    Leaving it initialized to zero is equivalent to `VK_API_VERSION_1_0`.
    */
    uint32_t vulkanApiVersion;
#if VMA_EXTERNAL_MEMORY
    /** \brief Either null or a pointer to an array of external memory handle types for each Vulkan memory type.

    If not NULL, it must be a pointer to an array of `VkPhysicalDeviceMemoryProperties::memoryTypeCount`
    elements, defining external memory handle types of particular Vulkan memory type,
    to be passed using `VkExportMemoryAllocateInfoKHR`.

    Any of the elements may be equal to 0, which means not to use `VkExportMemoryAllocateInfoKHR` on this memory type.
    This is also the default in case of `pTypeExternalMemoryHandleTypes` = NULL.
    */
    const VkExternalMemoryHandleTypeFlagsKHR* VMA_NULLABLE VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryTypeCount") pTypeExternalMemoryHandleTypes;
#endif // #if VMA_EXTERNAL_MEMORY
} VmaAllocatorCreateInfo;

/// Information about existing #VmaAllocator object.
typedef struct VmaAllocatorInfo
{
    /** \brief Handle to Vulkan instance object.

    This is the same value as has been passed through VmaAllocatorCreateInfo::instance.
    */
    VkInstance VMA_NOT_NULL instance;
    /** \brief Handle to Vulkan physical device object.

    This is the same value as has been passed through VmaAllocatorCreateInfo::physicalDevice.
    */
    VkPhysicalDevice VMA_NOT_NULL physicalDevice;
    /** \brief Handle to Vulkan device object.

    This is the same value as has been passed through VmaAllocatorCreateInfo::device.
    */
    VkDevice VMA_NOT_NULL device;
} VmaAllocatorInfo;

/** @} */

/**
\addtogroup group_stats
@{
*/

/** \brief Calculated statistics of memory usage e.g. in a specific memory type, heap, custom pool, or total.

These are fast to calculate.
See functions: vmaGetHeapBudgets(), vmaGetPoolStatistics().
*/
typedef struct VmaStatistics
{
    /** \brief Number of `VkDeviceMemory` objects - Vulkan memory blocks allocated.
    */
    uint32_t blockCount;
    /** \brief Number of #VmaAllocation objects allocated.

    Dedicated allocations have their own blocks, so each one adds 1 to `allocationCount` as well as `blockCount`.
    */
    uint32_t allocationCount;
    /** \brief Number of bytes allocated in `VkDeviceMemory` blocks.

    \note To avoid confusion, please be aware that what Vulkan calls an "allocation" - a whole `VkDeviceMemory` object
    (e.g. as in `VkPhysicalDeviceLimits::maxMemoryAllocationCount`) is called a "block" in VMA, while VMA calls
    "allocation" a #VmaAllocation object that represents a memory region sub-allocated from such block, usually for a single buffer or image.
    */
    VkDeviceSize blockBytes;
    /** \brief Total number of bytes occupied by all #VmaAllocation objects.

    Always less or equal than `blockBytes`.
    Difference `(blockBytes - allocationBytes)` is the amount of memory allocated from Vulkan
    but unused by any #VmaAllocation.
    */
    VkDeviceSize allocationBytes;
} VmaStatistics;

/** \brief More detailed statistics than #VmaStatistics.

These are slower to calculate. Use for debugging purposes.
See functions: vmaCalculateStatistics(), vmaCalculatePoolStatistics().

Previous version of the statistics API provided averages, but they have been removed
because they can be easily calculated as:

\code
VkDeviceSize allocationSizeAvg = detailedStats.statistics.allocationBytes / detailedStats.statistics.allocationCount;
VkDeviceSize unusedBytes = detailedStats.statistics.blockBytes - detailedStats.statistics.allocationBytes;
VkDeviceSize unusedRangeSizeAvg = unusedBytes / detailedStats.unusedRangeCount;
\endcode
*/
typedef struct VmaDetailedStatistics
{
    /// Basic statistics.
    VmaStatistics statistics;
    /// Number of free ranges of memory between allocations.
    uint32_t unusedRangeCount;
    /// Smallest allocation size. `VK_WHOLE_SIZE` if there are 0 allocations.
    VkDeviceSize allocationSizeMin;
    /// Largest allocation size. 0 if there are 0 allocations.
    VkDeviceSize allocationSizeMax;
    /// Smallest empty range size. `VK_WHOLE_SIZE` if there are 0 empty ranges.
    VkDeviceSize unusedRangeSizeMin;
    /// Largest empty range size. 0 if there are 0 empty ranges.
    VkDeviceSize unusedRangeSizeMax;
} VmaDetailedStatistics;

/** \brief  General statistics from current state of the Allocator -
total memory usage across all memory heaps and types.

These are slower to calculate. Use for debugging purposes.
See function vmaCalculateStatistics().
*/
typedef struct VmaTotalStatistics
{
    VmaDetailedStatistics memoryType[VK_MAX_MEMORY_TYPES];
    VmaDetailedStatistics memoryHeap[VK_MAX_MEMORY_HEAPS];
    VmaDetailedStatistics total;
} VmaTotalStatistics;

/** \brief Statistics of current memory usage and available budget for a specific memory heap.

These are fast to calculate.
See function vmaGetHeapBudgets().
*/
typedef struct VmaBudget
{
    /** \brief Statistics fetched from the library.
    */
    VmaStatistics statistics;
    /** \brief Estimated current memory usage of the program, in bytes.

    Fetched from system using VK_EXT_memory_budget extension if enabled.

    It might be different than `statistics.blockBytes` (usually higher) due to additional implicit objects
    also occupying the memory, like swapchain, pipelines, descriptor heaps, command buffers, or
    `VkDeviceMemory` blocks allocated outside of this library, if any.
    */
    VkDeviceSize usage;
    /** \brief Estimated amount of memory available to the program, in bytes.

    Fetched from system using VK_EXT_memory_budget extension if enabled.

    It might be different (most probably smaller) than `VkMemoryHeap::size[heapIndex]` due to factors
    external to the program, decided by the operating system.
    Difference `budget - usage` is the amount of additional memory that can probably
    be allocated without problems. Exceeding the budget may result in various problems.
    */
    VkDeviceSize budget;
} VmaBudget;

/** @} */

/**
\addtogroup group_alloc
@{
*/

/** \brief Parameters of new #VmaAllocation.

To be used with functions like vmaCreateBuffer(), vmaCreateImage(), and many others.
*/
typedef struct VmaAllocationCreateInfo
{
    /// Use #VmaAllocationCreateFlagBits enum.
    VmaAllocationCreateFlags flags;
    /** \brief Intended usage of memory.

    You can leave #VMA_MEMORY_USAGE_UNKNOWN if you specify memory requirements in other way. \n
    If `pool` is not null, this member is ignored.
    */
    VmaMemoryUsage usage;
    /** \brief Flags that must be set in a Memory Type chosen for an allocation.

    Leave 0 if you specify memory requirements in other way. \n
    If `pool` is not null, this member is ignored.*/
    VkMemoryPropertyFlags requiredFlags;
    /** \brief Flags that preferably should be set in a memory type chosen for an allocation.

    Set to 0 if no additional flags are preferred. \n
    If `pool` is not null, this member is ignored. */
    VkMemoryPropertyFlags preferredFlags;
    /** \brief Bitmask containing one bit set for every memory type acceptable for this allocation.

    Value 0 is equivalent to `UINT32_MAX` - it means any memory type is accepted if
    it meets other requirements specified by this structure, with no further
    restrictions on memory type index. \n
    If `pool` is not null, this member is ignored.
    */
    uint32_t memoryTypeBits;
    /** \brief Pool that this allocation should be created in.

    Leave `VK_NULL_HANDLE` to allocate from default pool. If not null, members:
    `usage`, `requiredFlags`, `preferredFlags`, `memoryTypeBits` are ignored.
    */
    VmaPool VMA_NULLABLE pool;
    /** \brief Custom general-purpose pointer that will be stored in #VmaAllocation, can be read as VmaAllocationInfo::pUserData and changed using vmaSetAllocationUserData().

    If #VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT is used, it must be either
    null or pointer to a null-terminated string. The string will be then copied to
    internal buffer, so it doesn't need to be valid after allocation call.
    */
    void* VMA_NULLABLE pUserData;
    /** \brief A floating-point value between 0 and 1, indicating the priority of the allocation relative to other memory allocations.

    It is used only when #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT flag was used during creation of the #VmaAllocator object
    and this allocation ends up as dedicated or is explicitly forced as dedicated using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
    Otherwise, it has the priority of a memory block where it is placed and this variable is ignored.
    */
    float priority;
} VmaAllocationCreateInfo;

/// Describes parameter of created #VmaPool.
typedef struct VmaPoolCreateInfo
{
    /** \brief Vulkan memory type index to allocate this pool from.
    */
    uint32_t memoryTypeIndex;
    /** \brief Use combination of #VmaPoolCreateFlagBits.
    */
    VmaPoolCreateFlags flags;
    /** \brief Size of a single `VkDeviceMemory` block to be allocated as part of this pool, in bytes. Optional.

    Specify nonzero to set explicit, constant size of memory blocks used by this
    pool.

    Leave 0 to use default and let the library manage block sizes automatically.
    Sizes of particular blocks may vary.
    In this case, the pool will also support dedicated allocations.
    */
    VkDeviceSize blockSize;
    /** \brief Minimum number of blocks to be always allocated in this pool, even if they stay empty.

    Set to 0 to have no preallocated blocks and allow the pool be completely empty.
    */
    size_t minBlockCount;
    /** \brief Maximum number of blocks that can be allocated in this pool. Optional.

    Set to 0 to use default, which is `SIZE_MAX`, which means no limit.

    Set to same value as VmaPoolCreateInfo::minBlockCount to have fixed amount of memory allocated
    throughout whole lifetime of this pool.
    */
    size_t maxBlockCount;
    /** \brief A floating-point value between 0 and 1, indicating the priority of the allocations in this pool relative to other memory allocations.

    It is used only when #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT flag was used during creation of the #VmaAllocator object.
    Otherwise, this variable is ignored.
    */
    float priority;
    /** \brief Additional minimum alignment to be used for all allocations created from this pool. Can be 0.

    Leave 0 (default) not to impose any additional alignment. If not 0, it must be a power of two.
    It can be useful in cases where alignment returned by Vulkan by functions like `vkGetBufferMemoryRequirements` is not enough,
    e.g. when doing interop with OpenGL.
    */
    VkDeviceSize minAllocationAlignment;
    /** \brief Additional `pNext` chain to be attached to `VkMemoryAllocateInfo` used for every allocation made by this pool. Optional.

    Optional, can be null. If not null, it must point to a `pNext` chain of structures that can be attached to `VkMemoryAllocateInfo`.
    It can be useful for special needs such as adding `VkExportMemoryAllocateInfoKHR`.
    Structures pointed by this member must remain alive and unchanged for the whole lifetime of the custom pool.

    Please note that some structures, e.g. `VkMemoryPriorityAllocateInfoEXT`, `VkMemoryDedicatedAllocateInfoKHR`,
    can be attached automatically by this library when using other, more convenient of its features.
    */
    void* VMA_NULLABLE pMemoryAllocateNext;
} VmaPoolCreateInfo;

/** @} */

/**
\addtogroup group_alloc
@{
*/

/// Parameters of #VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
typedef struct VmaAllocationInfo
{
    /** \brief Memory type index that this allocation was allocated from.

    It never changes.
    */
    uint32_t memoryType;
    /** \brief Handle to Vulkan memory object.

    Same memory object can be shared by multiple allocations.

    It can change after the allocation is moved during \ref defragmentation.
    */
    VkDeviceMemory VMA_NULLABLE_NON_DISPATCHABLE deviceMemory;
    /** \brief Offset in `VkDeviceMemory` object to the beginning of this allocation, in bytes. `(deviceMemory, offset)` pair is unique to this allocation.

    You usually don't need to use this offset. If you create a buffer or an image together with the allocation using e.g. function
    vmaCreateBuffer(), vmaCreateImage(), functions that operate on these resources refer to the beginning of the buffer or image,
    not entire device memory block. Functions like vmaMapMemory(), vmaBindBufferMemory() also refer to the beginning of the allocation
    and apply this offset automatically.

    It can change after the allocation is moved during \ref defragmentation.
    */
    VkDeviceSize offset;
    /** \brief Size of this allocation, in bytes.

    It never changes.

    \note Allocation size returned in this variable may be greater than the size
    requested for the resource e.g. as `VkBufferCreateInfo::size`. Whole size of the
    allocation is accessible for operations on memory e.g. using a pointer after
    mapping with vmaMapMemory(), but operations on the resource e.g. using
    `vkCmdCopyBuffer` must be limited to the size of the resource.
    */
    VkDeviceSize size;
    /** \brief Pointer to the beginning of this allocation as mapped data.

    If the allocation hasn't been mapped using vmaMapMemory() and hasn't been
    created with #VMA_ALLOCATION_CREATE_MAPPED_BIT flag, this value is null.

    It can change after call to vmaMapMemory(), vmaUnmapMemory().
    It can also change after the allocation is moved during \ref defragmentation.
    */
    void* VMA_NULLABLE pMappedData;
    /** \brief Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vmaSetAllocationUserData().

    It can change after call to vmaSetAllocationUserData() for this allocation.
    */
    void* VMA_NULLABLE pUserData;
    /** \brief Custom allocation name that was set with vmaSetAllocationName().

    It can change after call to vmaSetAllocationName() for this allocation.

    Another way to set custom name is to pass it in VmaAllocationCreateInfo::pUserData with
    additional flag #VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT set [DEPRECATED].
    */
    const char* VMA_NULLABLE pName;
} VmaAllocationInfo;

/** \brief Parameters for defragmentation.

To be used with function vmaBeginDefragmentation().
*/
typedef struct VmaDefragmentationInfo
{
    /// \brief Use combination of #VmaDefragmentationFlagBits.
    VmaDefragmentationFlags flags;
    /** \brief Custom pool to be defragmented.

    If null then default pools will undergo defragmentation process.
    */
    VmaPool VMA_NULLABLE pool;
    /** \brief Maximum numbers of bytes that can be copied during single pass, while moving allocations to different places.

    `0` means no limit.
    */
    VkDeviceSize maxBytesPerPass;
    /** \brief Maximum number of allocations that can be moved during single pass to a different place.

    `0` means no limit.
    */
    uint32_t maxAllocationsPerPass;
} VmaDefragmentationInfo;

/// Single move of an allocation to be done for defragmentation.
typedef struct VmaDefragmentationMove
{
    /// Operation to be performed on the allocation by vmaEndDefragmentationPass(). Default value is #VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY. You can modify it.
    VmaDefragmentationMoveOperation operation;
    /// Allocation that should be moved.
    VmaAllocation VMA_NOT_NULL srcAllocation;
    /** \brief Temporary allocation pointing to destination memory that will replace `srcAllocation`.

    \warning Do not store this allocation in your data structures! It exists only temporarily, for the duration of the defragmentation pass,
    to be used for binding new buffer/image to the destination memory using e.g. vmaBindBufferMemory().
    vmaEndDefragmentationPass() will destroy it and make `srcAllocation` point to this memory.
    */
    VmaAllocation VMA_NOT_NULL dstTmpAllocation;
} VmaDefragmentationMove;

/** \brief Parameters for incremental defragmentation steps.

To be used with function vmaBeginDefragmentationPass().
*/
typedef struct VmaDefragmentationPassMoveInfo
{
    /// Number of elements in the `pMoves` array.
    uint32_t moveCount;
    /** \brief Array of moves to be performed by the user in the current defragmentation pass.

    Pointer to an array of `moveCount` elements, owned by VMA, created in vmaBeginDefragmentationPass(), destroyed in vmaEndDefragmentationPass().

    For each element, you should:

    1. Create a new buffer/image in the place pointed by VmaDefragmentationMove::dstMemory + VmaDefragmentationMove::dstOffset.
    2. Copy data from the VmaDefragmentationMove::srcAllocation e.g. using `vkCmdCopyBuffer`, `vkCmdCopyImage`.
    3. Make sure these commands finished executing on the GPU.
    4. Destroy the old buffer/image.

    Only then you can finish defragmentation pass by calling vmaEndDefragmentationPass().
    After this call, the allocation will point to the new place in memory.

    Alternatively, if you cannot move specific allocation, you can set VmaDefragmentationMove::operation to #VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE.

    Alternatively, if you decide you want to completely remove the allocation:

    1. Destroy its buffer/image.
    2. Set VmaDefragmentationMove::operation to #VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY.

    Then, after vmaEndDefragmentationPass() the allocation will be freed.
    */
    VmaDefragmentationMove* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(moveCount) pMoves;
} VmaDefragmentationPassMoveInfo;

/// Statistics returned for defragmentation process in function vmaEndDefragmentation().
typedef struct VmaDefragmentationStats
{
    /// Total number of bytes that have been copied while moving allocations to different places.
    VkDeviceSize bytesMoved;
    /// Total number of bytes that have been released to the system by freeing empty `VkDeviceMemory` objects.
    VkDeviceSize bytesFreed;
    /// Number of allocations that have been moved to different places.
    uint32_t allocationsMoved;
    /// Number of empty `VkDeviceMemory` objects that have been released to the system.
    uint32_t deviceMemoryBlocksFreed;
} VmaDefragmentationStats;

/** @} */

/**
\addtogroup group_virtual
@{
*/

/// Parameters of created #VmaVirtualBlock object to be passed to vmaCreateVirtualBlock().
typedef struct VmaVirtualBlockCreateInfo
{
    /** \brief Total size of the virtual block.

    Sizes can be expressed in bytes or any units you want as long as you are consistent in using them.
    For example, if you allocate from some array of structures, 1 can mean single instance of entire structure.
    */
    VkDeviceSize size;

    /** \brief Use combination of #VmaVirtualBlockCreateFlagBits.
    */
    VmaVirtualBlockCreateFlags flags;

    /** \brief Custom CPU memory allocation callbacks. Optional.

    Optional, can be null. When specified, they will be used for all CPU-side memory allocations.
    */
    const VkAllocationCallbacks* VMA_NULLABLE pAllocationCallbacks;
} VmaVirtualBlockCreateInfo;

/// Parameters of created virtual allocation to be passed to vmaVirtualAllocate().
typedef struct VmaVirtualAllocationCreateInfo
{
    /** \brief Size of the allocation.

    Cannot be zero.
    */
    VkDeviceSize size;
    /** \brief Required alignment of the allocation. Optional.

    Must be power of two. Special value 0 has the same meaning as 1 - means no special alignment is required, so allocation can start at any offset.
    */
    VkDeviceSize alignment;
    /** \brief Use combination of #VmaVirtualAllocationCreateFlagBits.
    */
    VmaVirtualAllocationCreateFlags flags;
    /** \brief Custom pointer to be associated with the allocation. Optional.

    It can be any value and can be used for user-defined purposes. It can be fetched or changed later.
    */
    void* VMA_NULLABLE pUserData;
} VmaVirtualAllocationCreateInfo;

/// Parameters of an existing virtual allocation, returned by vmaGetVirtualAllocationInfo().
typedef struct VmaVirtualAllocationInfo
{
    /** \brief Offset of the allocation.

    Offset at which the allocation was made.
    */
    VkDeviceSize offset;
    /** \brief Size of the allocation.

    Same value as passed in VmaVirtualAllocationCreateInfo::size.
    */
    VkDeviceSize size;
    /** \brief Custom pointer associated with the allocation.

    Same value as passed in VmaVirtualAllocationCreateInfo::pUserData or to vmaSetVirtualAllocationUserData().
    */
    void* VMA_NULLABLE pUserData;
} VmaVirtualAllocationInfo;

/** @} */

#endif // _VMA_DATA_TYPES_DECLARATIONS

#ifndef _VMA_FUNCTION_HEADERS

/**
\addtogroup group_init
@{
*/

/// Creates #VmaAllocator object.
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
    const VmaAllocatorCreateInfo* VMA_NOT_NULL pCreateInfo,
    VmaAllocator VMA_NULLABLE* VMA_NOT_NULL pAllocator);

/// Destroys allocator object.
VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
    VmaAllocator VMA_NULLABLE allocator);

/** \brief Returns information about existing #VmaAllocator object - handle to Vulkan device etc.

It might be useful if you want to keep just the #VmaAllocator handle and fetch other required handles to
`VkPhysicalDevice`, `VkDevice` etc. every time using this function.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocatorInfo(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocatorInfo* VMA_NOT_NULL pAllocatorInfo);

/**
PhysicalDeviceProperties are fetched from physicalDevice by the allocator.
You can access it here, without fetching it again on your own.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkPhysicalDeviceProperties* VMA_NULLABLE* VMA_NOT_NULL ppPhysicalDeviceProperties);

/**
PhysicalDeviceMemoryProperties are fetched from physicalDevice by the allocator.
You can access it here, without fetching it again on your own.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkPhysicalDeviceMemoryProperties* VMA_NULLABLE* VMA_NOT_NULL ppPhysicalDeviceMemoryProperties);

/**
\brief Given Memory Type Index, returns Property Flags of this memory type.

This is just a convenience function. Same information can be obtained using
vmaGetMemoryProperties().
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
    VmaAllocator VMA_NOT_NULL allocator,
    uint32_t memoryTypeIndex,
    VkMemoryPropertyFlags* VMA_NOT_NULL pFlags);

/** \brief Sets index of the current frame.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
    VmaAllocator VMA_NOT_NULL allocator,
    uint32_t frameIndex);

/** @} */

/**
\addtogroup group_stats
@{
*/

/** \brief Retrieves statistics from current state of the Allocator.

This function is called "calculate" not "get" because it has to traverse all
internal data structures, so it may be quite slow. Use it for debugging purposes.
For faster but more brief statistics suitable to be called every frame or every allocation,
use vmaGetHeapBudgets().

Note that when using allocator from multiple threads, returned information may immediately
become outdated.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStatistics(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaTotalStatistics* VMA_NOT_NULL pStats);

/** \brief Retrieves information about current memory usage and budget for all memory heaps.

\param allocator
\param[out] pBudgets Must point to array with number of elements at least equal to number of memory heaps in physical device used.

This function is called "get" not "calculate" because it is very fast, suitable to be called
every frame or every allocation. For more detailed statistics use vmaCalculateStatistics().

Note that when using allocator from multiple threads, returned information may immediately
become outdated.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetHeapBudgets(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaBudget* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryHeapCount") pBudgets);

/** @} */

/**
\addtogroup group_alloc
@{
*/

/**
\brief Helps to find memoryTypeIndex, given memoryTypeBits and VmaAllocationCreateInfo.

This algorithm tries to find a memory type that:

- Is allowed by memoryTypeBits.
- Contains all the flags from pAllocationCreateInfo->requiredFlags.
- Matches intended usage.
- Has as many flags from pAllocationCreateInfo->preferredFlags as possible.

\return Returns VK_ERROR_FEATURE_NOT_PRESENT if not found. Receiving such result
from this function or any other allocating function probably means that your
device doesn't support any memory type with requested features for the specific
type of resource you want to use it for. Please check parameters of your
resource, like image layout (OPTIMAL versus LINEAR) or mip level count.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
    VmaAllocator VMA_NOT_NULL allocator,
    uint32_t memoryTypeBits,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);

/**
\brief Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo.

It can be useful e.g. to determine value to be used as VmaPoolCreateInfo::memoryTypeIndex.
It internally creates a temporary, dummy buffer that never has memory bound.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);

/**
\brief Helps to find memoryTypeIndex, given VkImageCreateInfo and VmaAllocationCreateInfo.

It can be useful e.g. to determine value to be used as VmaPoolCreateInfo::memoryTypeIndex.
It internally creates a temporary, dummy image that never has memory bound.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);

/** \brief Allocates Vulkan device memory and creates #VmaPool object.

\param allocator Allocator object.
\param pCreateInfo Parameters of pool to create.
\param[out] pPool Handle to created pool.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
    VmaAllocator VMA_NOT_NULL allocator,
    const VmaPoolCreateInfo* VMA_NOT_NULL pCreateInfo,
    VmaPool VMA_NULLABLE* VMA_NOT_NULL pPool);

/** \brief Destroys #VmaPool object and frees Vulkan device memory.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaPool VMA_NULLABLE pool);

/** @} */

/**
\addtogroup group_stats
@{
*/

/** \brief Retrieves statistics of existing #VmaPool object.

\param allocator Allocator object.
\param pool Pool object.
\param[out] pPoolStats Statistics of specified pool.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStatistics(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaPool VMA_NOT_NULL pool,
    VmaStatistics* VMA_NOT_NULL pPoolStats);

/** \brief Retrieves detailed statistics of existing #VmaPool object.

\param allocator Allocator object.
\param pool Pool object.
\param[out] pPoolStats Statistics of specified pool.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaCalculatePoolStatistics(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaPool VMA_NOT_NULL pool,
    VmaDetailedStatistics* VMA_NOT_NULL pPoolStats);

/** @} */

/**
\addtogroup group_alloc
@{
*/

/** \brief Checks magic number in margins around all allocations in given memory pool in search for corruptions.

Corruption detection is enabled only when `VMA_DEBUG_DETECT_CORRUPTION` macro is defined to nonzero,
`VMA_DEBUG_MARGIN` is defined to nonzero and the pool is created in memory type that is
`HOST_VISIBLE` and `HOST_COHERENT`. For more information, see [Corruption detection](@ref debugging_memory_usage_corruption_detection).

Possible return values:

- `VK_ERROR_FEATURE_NOT_PRESENT` - corruption detection is not enabled for specified pool.
- `VK_SUCCESS` - corruption detection has been performed and succeeded.
- `VK_ERROR_UNKNOWN` - corruption detection has been performed and found memory corruptions around one of the allocations.
  `VMA_ASSERT` is also fired in that case.
- Other value: Error returned by Vulkan, e.g. memory mapping failure.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaPool VMA_NOT_NULL pool);

/** \brief Retrieves name of a custom pool.

After the call `ppName` is either null or points to an internally-owned null-terminated string
containing name of the pool that was previously set. The pointer becomes invalid when the pool is
destroyed or its name is changed using vmaSetPoolName().
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaPool VMA_NOT_NULL pool,
    const char* VMA_NULLABLE* VMA_NOT_NULL ppName);

/** \brief Sets name of a custom pool.

`pName` can be either null or pointer to a null-terminated string with new name for the pool.
Function makes internal copy of the string, so it can be changed or freed immediately after this call.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaPool VMA_NOT_NULL pool,
    const char* VMA_NULLABLE pName);

/** \brief General purpose memory allocation.

\param allocator
\param pVkMemoryRequirements
\param pCreateInfo
\param[out] pAllocation Handle to allocated memory.
\param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().

You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().

It is recommended to use vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(),
vmaCreateBuffer(), vmaCreateImage() instead whenever possible.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkMemoryRequirements* VMA_NOT_NULL pVkMemoryRequirements,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);

/** \brief General purpose memory allocation for multiple allocation objects at once.

\param allocator Allocator object.
\param pVkMemoryRequirements Memory requirements for each allocation.
\param pCreateInfo Creation parameters for each allocation.
\param allocationCount Number of allocations to make.
\param[out] pAllocations Pointer to array that will be filled with handles to created allocations.
\param[out] pAllocationInfo Optional. Pointer to array that will be filled with parameters of created allocations.

You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().

Word "pages" is just a suggestion to use this function to allocate pieces of memory needed for sparse binding.
It is just a general purpose allocation function able to make multiple allocations at once.
It may be internally optimized to be more efficient than calling vmaAllocateMemory() `allocationCount` times.

All allocations are made using same parameters. All of them are created out of the same memory pool and type.
If any allocation fails, all allocations already made within this function call are also freed, so that when
returned result is not `VK_SUCCESS`, `pAllocation` array is always entirely filled with `VK_NULL_HANDLE`.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkMemoryRequirements* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pVkMemoryRequirements,
    const VmaAllocationCreateInfo* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pCreateInfo,
    size_t allocationCount,
    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations,
    VmaAllocationInfo* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocationInfo);

/** \brief Allocates memory suitable for given `VkBuffer`.

\param allocator
\param buffer
\param pCreateInfo
\param[out] pAllocation Handle to allocated memory.
\param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().

It only creates #VmaAllocation. To bind the memory to the buffer, use vmaBindBufferMemory().

This is a special-purpose function. In most cases you should use vmaCreateBuffer().

You must free the allocation using vmaFreeMemory() when no longer needed.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
    VmaAllocator VMA_NOT_NULL allocator,
    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);

/** \brief Allocates memory suitable for given `VkImage`.

\param allocator
\param image
\param pCreateInfo
\param[out] pAllocation Handle to allocated memory.
\param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().

It only creates #VmaAllocation. To bind the memory to the buffer, use vmaBindImageMemory().

This is a special-purpose function. In most cases you should use vmaCreateImage().

You must free the allocation using vmaFreeMemory() when no longer needed.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
    VmaAllocator VMA_NOT_NULL allocator,
    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);

/** \brief Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().

Passing `VK_NULL_HANDLE` as `allocation` is valid. Such function call is just skipped.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
    VmaAllocator VMA_NOT_NULL allocator,
    const VmaAllocation VMA_NULLABLE allocation);

/** \brief Frees memory and destroys multiple allocations.

Word "pages" is just a suggestion to use this function to free pieces of memory used for sparse binding.
It is just a general purpose function to free memory and destroy allocations made using e.g. vmaAllocateMemory(),
vmaAllocateMemoryPages() and other functions.
It may be internally optimized to be more efficient than calling vmaFreeMemory() `allocationCount` times.

Allocations in `pAllocations` array can come from any memory pools and types.
Passing `VK_NULL_HANDLE` as elements of `pAllocations` array is valid. Such entries are just skipped.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
    VmaAllocator VMA_NOT_NULL allocator,
    size_t allocationCount,
    const VmaAllocation VMA_NULLABLE* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations);

/** \brief Returns current information about specified allocation.

Current parameters of given allocation are returned in `pAllocationInfo`.

Although this function doesn't lock any mutex, so it should be quite efficient,
you should avoid calling it too often.
You can retrieve same VmaAllocationInfo structure while creating your resource, from function
vmaCreateBuffer(), vmaCreateImage(). You can remember it if you are sure parameters don't change
(e.g. due to defragmentation).
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VmaAllocationInfo* VMA_NOT_NULL pAllocationInfo);

/** \brief Sets pUserData in given allocation to new value.

The value of pointer `pUserData` is copied to allocation's `pUserData`.
It is opaque, so you can use it however you want - e.g.
as a pointer, ordinal number or some handle to you own data.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    void* VMA_NULLABLE pUserData);

/** \brief Sets pName in given allocation to new value.

`pName` must be either null, or pointer to a null-terminated string. The function
makes local copy of the string and sets it as allocation's `pName`. String
passed as pName doesn't need to be valid for whole lifetime of the allocation -
you can free it after this call. String previously pointed by allocation's
`pName` is freed from memory.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationName(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    const char* VMA_NULLABLE pName);

/**
\brief Given an allocation, returns Property Flags of its memory type.

This is just a convenience function. Same information can be obtained using
vmaGetAllocationInfo() + vmaGetMemoryProperties().
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationMemoryProperties(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkMemoryPropertyFlags* VMA_NOT_NULL pFlags);

/** \brief Maps memory represented by given allocation and returns pointer to it.

Maps memory represented by given allocation to make it accessible to CPU code.
When succeeded, `*ppData` contains pointer to first byte of this memory.

\warning
If the allocation is part of a bigger `VkDeviceMemory` block, returned pointer is
correctly offsetted to the beginning of region assigned to this particular allocation.
Unlike the result of `vkMapMemory`, it points to the allocation, not to the beginning of the whole block.
You should not add VmaAllocationInfo::offset to it!

Mapping is internally reference-counted and synchronized, so despite raw Vulkan
function `vkMapMemory()` cannot be used to map same block of `VkDeviceMemory`
multiple times simultaneously, it is safe to call this function on allocations
assigned to the same memory block. Actual Vulkan memory will be mapped on first
mapping and unmapped on last unmapping.

If the function succeeded, you must call vmaUnmapMemory() to unmap the
allocation when mapping is no longer needed or before freeing the allocation, at
the latest.

It also safe to call this function multiple times on the same allocation. You
must call vmaUnmapMemory() same number of times as you called vmaMapMemory().

It is also safe to call this function on allocation created with
#VMA_ALLOCATION_CREATE_MAPPED_BIT flag. Its memory stays mapped all the time.
You must still call vmaUnmapMemory() same number of times as you called
vmaMapMemory(). You must not call vmaUnmapMemory() additional time to free the
"0-th" mapping made automatically due to #VMA_ALLOCATION_CREATE_MAPPED_BIT flag.

This function fails when used on allocation made in memory type that is not
`HOST_VISIBLE`.

This function doesn't automatically flush or invalidate caches.
If the allocation is made from a memory types that is not `HOST_COHERENT`,
you also need to use vmaInvalidateAllocation() / vmaFlushAllocation(), as required by Vulkan specification.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    void* VMA_NULLABLE* VMA_NOT_NULL ppData);

/** \brief Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().

For details, see description of vmaMapMemory().

This function doesn't automatically flush or invalidate caches.
If the allocation is made from a memory types that is not `HOST_COHERENT`,
you also need to use vmaInvalidateAllocation() / vmaFlushAllocation(), as required by Vulkan specification.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation);

/** \brief Flushes memory of given allocation.

Calls `vkFlushMappedMemoryRanges()` for memory associated with given range of given allocation.
It needs to be called after writing to a mapped memory for memory types that are not `HOST_COHERENT`.
Unmap operation doesn't do that automatically.

- `offset` must be relative to the beginning of allocation.
- `size` can be `VK_WHOLE_SIZE`. It means all memory from `offset` the the end of given allocation.
- `offset` and `size` don't have to be aligned.
  They are internally rounded down/up to multiply of `nonCoherentAtomSize`.
- If `size` is 0, this call is ignored.
- If memory type that the `allocation` belongs to is not `HOST_VISIBLE` or it is `HOST_COHERENT`,
  this call is ignored.

Warning! `offset` and `size` are relative to the contents of given `allocation`.
If you mean whole allocation, you can pass 0 and `VK_WHOLE_SIZE`, respectively.
Do not pass allocation's offset as `offset`!!!

This function returns the `VkResult` from `vkFlushMappedMemoryRanges` if it is
called, otherwise `VK_SUCCESS`.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocation(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkDeviceSize offset,
    VkDeviceSize size);

/** \brief Invalidates memory of given allocation.

Calls `vkInvalidateMappedMemoryRanges()` for memory associated with given range of given allocation.
It needs to be called before reading from a mapped memory for memory types that are not `HOST_COHERENT`.
Map operation doesn't do that automatically.

- `offset` must be relative to the beginning of allocation.
- `size` can be `VK_WHOLE_SIZE`. It means all memory from `offset` the the end of given allocation.
- `offset` and `size` don't have to be aligned.
  They are internally rounded down/up to multiply of `nonCoherentAtomSize`.
- If `size` is 0, this call is ignored.
- If memory type that the `allocation` belongs to is not `HOST_VISIBLE` or it is `HOST_COHERENT`,
  this call is ignored.

Warning! `offset` and `size` are relative to the contents of given `allocation`.
If you mean whole allocation, you can pass 0 and `VK_WHOLE_SIZE`, respectively.
Do not pass allocation's offset as `offset`!!!

This function returns the `VkResult` from `vkInvalidateMappedMemoryRanges` if
it is called, otherwise `VK_SUCCESS`.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocation(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkDeviceSize offset,
    VkDeviceSize size);

/** \brief Flushes memory of given set of allocations.

Calls `vkFlushMappedMemoryRanges()` for memory associated with given ranges of given allocations.
For more information, see documentation of vmaFlushAllocation().

\param allocator
\param allocationCount
\param allocations
\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
\param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.

This function returns the `VkResult` from `vkFlushMappedMemoryRanges` if it is
called, otherwise `VK_SUCCESS`.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocations(
    VmaAllocator VMA_NOT_NULL allocator,
    uint32_t allocationCount,
    const VmaAllocation VMA_NOT_NULL* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) allocations,
    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) offsets,
    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) sizes);

/** \brief Invalidates memory of given set of allocations.

Calls `vkInvalidateMappedMemoryRanges()` for memory associated with given ranges of given allocations.
For more information, see documentation of vmaInvalidateAllocation().

\param allocator
\param allocationCount
\param allocations
\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
\param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.

This function returns the `VkResult` from `vkInvalidateMappedMemoryRanges` if it is
called, otherwise `VK_SUCCESS`.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
    VmaAllocator VMA_NOT_NULL allocator,
    uint32_t allocationCount,
    const VmaAllocation VMA_NOT_NULL* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) allocations,
    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) offsets,
    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) sizes);

/** \brief Checks magic number in margins around all allocations in given memory types (in both default and custom pools) in search for corruptions.

\param allocator
\param memoryTypeBits Bit mask, where each bit set means that a memory type with that index should be checked.

Corruption detection is enabled only when `VMA_DEBUG_DETECT_CORRUPTION` macro is defined to nonzero,
`VMA_DEBUG_MARGIN` is defined to nonzero and only for memory types that are
`HOST_VISIBLE` and `HOST_COHERENT`. For more information, see [Corruption detection](@ref debugging_memory_usage_corruption_detection).

Possible return values:

- `VK_ERROR_FEATURE_NOT_PRESENT` - corruption detection is not enabled for any of specified memory types.
- `VK_SUCCESS` - corruption detection has been performed and succeeded.
- `VK_ERROR_UNKNOWN` - corruption detection has been performed and found memory corruptions around one of the allocations.
  `VMA_ASSERT` is also fired in that case.
- Other value: Error returned by Vulkan, e.g. memory mapping failure.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(
    VmaAllocator VMA_NOT_NULL allocator,
    uint32_t memoryTypeBits);

/** \brief Begins defragmentation process.

\param allocator Allocator object.
\param pInfo Structure filled with parameters of defragmentation.
\param[out] pContext Context object that must be passed to vmaEndDefragmentation() to finish defragmentation.
\returns
- `VK_SUCCESS` if defragmentation can begin.
- `VK_ERROR_FEATURE_NOT_PRESENT` if defragmentation is not supported.

For more information about defragmentation, see documentation chapter:
[Defragmentation](@ref defragmentation).
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentation(
    VmaAllocator VMA_NOT_NULL allocator,
    const VmaDefragmentationInfo* VMA_NOT_NULL pInfo,
    VmaDefragmentationContext VMA_NULLABLE* VMA_NOT_NULL pContext);

/** \brief Ends defragmentation process.

\param allocator Allocator object.
\param context Context object that has been created by vmaBeginDefragmentation().
\param[out] pStats Optional stats for the defragmentation. Can be null.

Use this function to finish defragmentation started by vmaBeginDefragmentation().
*/
VMA_CALL_PRE void VMA_CALL_POST vmaEndDefragmentation(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaDefragmentationContext VMA_NOT_NULL context,
    VmaDefragmentationStats* VMA_NULLABLE pStats);

/** \brief Starts single defragmentation pass.

\param allocator Allocator object.
\param context Context object that has been created by vmaBeginDefragmentation().
\param[out] pPassInfo Computed information for current pass.
\returns
- `VK_SUCCESS` if no more moves are possible. Then you can omit call to vmaEndDefragmentationPass() and simply end whole defragmentation.
- `VK_INCOMPLETE` if there are pending moves returned in `pPassInfo`. You need to perform them, call vmaEndDefragmentationPass(),
  and then preferably try another pass with vmaBeginDefragmentationPass().
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentationPass(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaDefragmentationContext VMA_NOT_NULL context,
    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL pPassInfo);

/** \brief Ends single defragmentation pass.

\param allocator Allocator object.
\param context Context object that has been created by vmaBeginDefragmentation().
\param pPassInfo Computed information for current pass filled by vmaBeginDefragmentationPass() and possibly modified by you.

Returns `VK_SUCCESS` if no more moves are possible or `VK_INCOMPLETE` if more defragmentations are possible.

Ends incremental defragmentation pass and commits all defragmentation moves from `pPassInfo`.
After this call:

- Allocations at `pPassInfo[i].srcAllocation` that had `pPassInfo[i].operation ==` #VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY
  (which is the default) will be pointing to the new destination place.
- Allocation at `pPassInfo[i].srcAllocation` that had `pPassInfo[i].operation ==` #VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY
  will be freed.

If no more moves are possible you can end whole defragmentation.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaEndDefragmentationPass(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaDefragmentationContext VMA_NOT_NULL context,
    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL pPassInfo);

/** \brief Binds buffer to allocation.

Binds specified buffer to region of memory represented by specified allocation.
Gets `VkDeviceMemory` handle and offset from the allocation.
If you want to create a buffer, allocate memory for it and bind them together separately,
you should use this function for binding instead of standard `vkBindBufferMemory()`,
because it ensures proper synchronization so that when a `VkDeviceMemory` object is used by multiple
allocations, calls to `vkBind*Memory()` or `vkMapMemory()` won't happen from multiple threads simultaneously
(which is illegal in Vulkan).

It is recommended to use function vmaCreateBuffer() instead of this one.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer);

/** \brief Binds buffer to allocation with additional parameters.

\param allocator
\param allocation
\param allocationLocalOffset Additional offset to be added while binding, relative to the beginning of the `allocation`. Normally it should be 0.
\param buffer
\param pNext A chain of structures to be attached to `VkBindBufferMemoryInfoKHR` structure used internally. Normally it should be null.

This function is similar to vmaBindBufferMemory(), but it provides additional parameters.

If `pNext` is not null, #VmaAllocator object must have been created with #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag
or with VmaAllocatorCreateInfo::vulkanApiVersion `>= VK_API_VERSION_1_1`. Otherwise the call fails.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkDeviceSize allocationLocalOffset,
    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer,
    const void* VMA_NULLABLE pNext);

/** \brief Binds image to allocation.

Binds specified image to region of memory represented by specified allocation.
Gets `VkDeviceMemory` handle and offset from the allocation.
If you want to create an image, allocate memory for it and bind them together separately,
you should use this function for binding instead of standard `vkBindImageMemory()`,
because it ensures proper synchronization so that when a `VkDeviceMemory` object is used by multiple
allocations, calls to `vkBind*Memory()` or `vkMapMemory()` won't happen from multiple threads simultaneously
(which is illegal in Vulkan).

It is recommended to use function vmaCreateImage() instead of this one.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image);

/** \brief Binds image to allocation with additional parameters.

\param allocator
\param allocation
\param allocationLocalOffset Additional offset to be added while binding, relative to the beginning of the `allocation`. Normally it should be 0.
\param image
\param pNext A chain of structures to be attached to `VkBindImageMemoryInfoKHR` structure used internally. Normally it should be null.

This function is similar to vmaBindImageMemory(), but it provides additional parameters.

If `pNext` is not null, #VmaAllocator object must have been created with #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag
or with VmaAllocatorCreateInfo::vulkanApiVersion `>= VK_API_VERSION_1_1`. Otherwise the call fails.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkDeviceSize allocationLocalOffset,
    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image,
    const void* VMA_NULLABLE pNext);

/** \brief Creates a new `VkBuffer`, allocates and binds memory for it.

\param allocator
\param pBufferCreateInfo
\param pAllocationCreateInfo
\param[out] pBuffer Buffer that was created.
\param[out] pAllocation Allocation that was created.
\param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().

This function automatically:

-# Creates buffer.
-# Allocates appropriate memory for it.
-# Binds the buffer with the memory.

If any of these operations fail, buffer and allocation are not created,
returned value is negative error code, `*pBuffer` and `*pAllocation` are null.

If the function succeeded, you must destroy both buffer and allocation when you
no longer need them using either convenience function vmaDestroyBuffer() or
separately, using `vkDestroyBuffer()` and vmaFreeMemory().

If #VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag was used,
VK_KHR_dedicated_allocation extension is used internally to query driver whether
it requires or prefers the new buffer to have dedicated allocation. If yes,
and if dedicated allocation is possible
(#VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT is not used), it creates dedicated
allocation for this buffer, just like when using
#VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.

\note This function creates a new `VkBuffer`. Sub-allocation of parts of one large buffer,
although recommended as a good practice, is out of scope of this library and could be implemented
by the user as a higher-level logic on top of VMA.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer,
    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);

/** \brief Creates a buffer with additional minimum alignment.

Similar to vmaCreateBuffer() but provides additional parameter `minAlignment` which allows to specify custom,
minimum alignment to be used when placing the buffer inside a larger memory block, which may be needed e.g.
for interop with OpenGL.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBufferWithAlignment(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
    VkDeviceSize minAlignment,
    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer,
    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);

/** \brief Creates a new `VkBuffer`, binds already created memory for it.

\param allocator
\param allocation Allocation that provides memory to be used for binding new buffer to it.
\param pBufferCreateInfo
\param[out] pBuffer Buffer that was created.

This function automatically:

-# Creates buffer.
-# Binds the buffer with the supplied memory.

If any of these operations fail, buffer is not created,
returned value is negative error code and `*pBuffer` is null.

If the function succeeded, you must destroy the buffer when you
no longer need it using `vkDestroyBuffer()`. If you want to also destroy the corresponding
allocation you can use convenience function vmaDestroyBuffer().

\note There is a new version of this function augmented with parameter `allocationLocalOffset` - see vmaCreateAliasingBuffer2().
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingBuffer(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer);

/** \brief Creates a new `VkBuffer`, binds already created memory for it.

\param allocator
\param allocation Allocation that provides memory to be used for binding new buffer to it.
\param allocationLocalOffset Additional offset to be added while binding, relative to the beginning of the allocation. Normally it should be 0.
\param pBufferCreateInfo 
\param[out] pBuffer Buffer that was created.

This function automatically:

-# Creates buffer.
-# Binds the buffer with the supplied memory.

If any of these operations fail, buffer is not created,
returned value is negative error code and `*pBuffer` is null.

If the function succeeded, you must destroy the buffer when you
no longer need it using `vkDestroyBuffer()`. If you want to also destroy the corresponding
allocation you can use convenience function vmaDestroyBuffer().

\note This is a new version of the function augmented with parameter `allocationLocalOffset`.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingBuffer2(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkDeviceSize allocationLocalOffset,
    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer);

/** \brief Destroys Vulkan buffer and frees allocated memory.

This is just a convenience function equivalent to:

\code
vkDestroyBuffer(device, buffer, allocationCallbacks);
vmaFreeMemory(allocator, allocation);
\endcode

It is safe to pass null as buffer and/or allocation.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
    VmaAllocator VMA_NOT_NULL allocator,
    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE buffer,
    VmaAllocation VMA_NULLABLE allocation);

/// Function similar to vmaCreateBuffer().
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
    VmaAllocator VMA_NOT_NULL allocator,
    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
    VkImage VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pImage,
    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);

/// Function similar to vmaCreateAliasingBuffer() but for images.
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingImage(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
    VkImage VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pImage);

/// Function similar to vmaCreateAliasingBuffer2() but for images.
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingImage2(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkDeviceSize allocationLocalOffset,
    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
    VkImage VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pImage);

/** \brief Destroys Vulkan image and frees allocated memory.

This is just a convenience function equivalent to:

\code
vkDestroyImage(device, image, allocationCallbacks);
vmaFreeMemory(allocator, allocation);
\endcode

It is safe to pass null as image and/or allocation.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
    VmaAllocator VMA_NOT_NULL allocator,
    VkImage VMA_NULLABLE_NON_DISPATCHABLE image,
    VmaAllocation VMA_NULLABLE allocation);

/** @} */

/**
\addtogroup group_virtual
@{
*/

/** \brief Creates new #VmaVirtualBlock object.

\param pCreateInfo Parameters for creation.
\param[out] pVirtualBlock Returned virtual block object or `VMA_NULL` if creation failed.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateVirtualBlock(
    const VmaVirtualBlockCreateInfo* VMA_NOT_NULL pCreateInfo,
    VmaVirtualBlock VMA_NULLABLE* VMA_NOT_NULL pVirtualBlock);

/** \brief Destroys #VmaVirtualBlock object.

Please note that you should consciously handle virtual allocations that could remain unfreed in the block.
You should either free them individually using vmaVirtualFree() or call vmaClearVirtualBlock()
if you are sure this is what you want. If you do neither, an assert is called.

If you keep pointers to some additional metadata associated with your virtual allocations in their `pUserData`,
don't forget to free them.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaDestroyVirtualBlock(
    VmaVirtualBlock VMA_NULLABLE virtualBlock);

/** \brief Returns true of the #VmaVirtualBlock is empty - contains 0 virtual allocations and has all its space available for new allocations.
*/
VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaIsVirtualBlockEmpty(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock);

/** \brief Returns information about a specific virtual allocation within a virtual block, like its size and `pUserData` pointer.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetVirtualAllocationInfo(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaVirtualAllocation VMA_NOT_NULL_NON_DISPATCHABLE allocation, VmaVirtualAllocationInfo* VMA_NOT_NULL pVirtualAllocInfo);

/** \brief Allocates new virtual allocation inside given #VmaVirtualBlock.

If the allocation fails due to not enough free space available, `VK_ERROR_OUT_OF_DEVICE_MEMORY` is returned
(despite the function doesn't ever allocate actual GPU memory).
`pAllocation` is then set to `VK_NULL_HANDLE` and `pOffset`, if not null, it set to `UINT64_MAX`.

\param virtualBlock Virtual block
\param pCreateInfo Parameters for the allocation
\param[out] pAllocation Returned handle of the new allocation
\param[out] pOffset Returned offset of the new allocation. Optional, can be null.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaVirtualAllocate(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    const VmaVirtualAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
    VmaVirtualAllocation VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pAllocation,
    VkDeviceSize* VMA_NULLABLE pOffset);

/** \brief Frees virtual allocation inside given #VmaVirtualBlock.

It is correct to call this function with `allocation == VK_NULL_HANDLE` - it does nothing.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaVirtualFree(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaVirtualAllocation VMA_NULLABLE_NON_DISPATCHABLE allocation);

/** \brief Frees all virtual allocations inside given #VmaVirtualBlock.

You must either call this function or free each virtual allocation individually with vmaVirtualFree()
before destroying a virtual block. Otherwise, an assert is called.

If you keep pointer to some additional metadata associated with your virtual allocation in its `pUserData`,
don't forget to free it as well.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaClearVirtualBlock(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock);

/** \brief Changes custom pointer associated with given virtual allocation.
*/
VMA_CALL_PRE void VMA_CALL_POST vmaSetVirtualAllocationUserData(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaVirtualAllocation VMA_NOT_NULL_NON_DISPATCHABLE allocation,
    void* VMA_NULLABLE pUserData);

/** \brief Calculates and returns statistics about virtual allocations and memory usage in given #VmaVirtualBlock.

This function is fast to call. For more detailed statistics, see vmaCalculateVirtualBlockStatistics().
*/
VMA_CALL_PRE void VMA_CALL_POST vmaGetVirtualBlockStatistics(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaStatistics* VMA_NOT_NULL pStats);

/** \brief Calculates and returns detailed statistics about virtual allocations and memory usage in given #VmaVirtualBlock.

This function is slow to call. Use for debugging purposes.
For less detailed statistics, see vmaGetVirtualBlockStatistics().
*/
VMA_CALL_PRE void VMA_CALL_POST vmaCalculateVirtualBlockStatistics(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaDetailedStatistics* VMA_NOT_NULL pStats);

/** @} */

#if VMA_STATS_STRING_ENABLED
/**
\addtogroup group_stats
@{
*/

/** \brief Builds and returns a null-terminated string in JSON format with information about given #VmaVirtualBlock.
\param virtualBlock Virtual block.
\param[out] ppStatsString Returned string.
\param detailedMap Pass `VK_FALSE` to only obtain statistics as returned by vmaCalculateVirtualBlockStatistics(). Pass `VK_TRUE` to also obtain full list of allocations and free spaces.

Returned string must be freed using vmaFreeVirtualBlockStatsString().
*/
VMA_CALL_PRE void VMA_CALL_POST vmaBuildVirtualBlockStatsString(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    char* VMA_NULLABLE* VMA_NOT_NULL ppStatsString,
    VkBool32 detailedMap);

/// Frees a string returned by vmaBuildVirtualBlockStatsString().
VMA_CALL_PRE void VMA_CALL_POST vmaFreeVirtualBlockStatsString(
    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    char* VMA_NULLABLE pStatsString);

/** \brief Builds and returns statistics as a null-terminated string in JSON format.
\param allocator
\param[out] ppStatsString Must be freed using vmaFreeStatsString() function.
\param detailedMap
*/
VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
    VmaAllocator VMA_NOT_NULL allocator,
    char* VMA_NULLABLE* VMA_NOT_NULL ppStatsString,
    VkBool32 detailedMap);

VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
    VmaAllocator VMA_NOT_NULL allocator,
    char* VMA_NULLABLE pStatsString);

/** @} */

#endif // VMA_STATS_STRING_ENABLED

#endif // _VMA_FUNCTION_HEADERS

#ifdef __cplusplus
}
#endif

#endif // AMD_VULKAN_MEMORY_ALLOCATOR_H

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
//    IMPLEMENTATION
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

// For Visual Studio IntelliSense.
#if defined(__cplusplus) && defined(__INTELLISENSE__)
#define VMA_IMPLEMENTATION
#endif

#ifdef VMA_IMPLEMENTATION
#undef VMA_IMPLEMENTATION

#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <type_traits>

#ifdef _MSC_VER
    #include <intrin.h> // For functions like __popcnt, _BitScanForward etc.
#endif
#if __cplusplus >= 202002L || _MSVC_LANG >= 202002L // C++20
    #include <bit> // For std::popcount
#endif

/*******************************************************************************
CONFIGURATION SECTION

Define some of these macros before each #include of this header or change them
here if you need other then default behavior depending on your environment.
*/
#ifndef _VMA_CONFIGURATION

/*
Define this macro to 1 to make the library fetch pointers to Vulkan functions
internally, like:

    vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
*/
#if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
    #define VMA_STATIC_VULKAN_FUNCTIONS 1
#endif

/*
Define this macro to 1 to make the library fetch pointers to Vulkan functions
internally, like:

    vulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkGetDeviceProcAddr(device, "vkAllocateMemory");

To use this feature in new versions of VMA you now have to pass
VmaVulkanFunctions::vkGetInstanceProcAddr and vkGetDeviceProcAddr as
VmaAllocatorCreateInfo::pVulkanFunctions. Other members can be null.
*/
#if !defined(VMA_DYNAMIC_VULKAN_FUNCTIONS)
    #define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
#endif

#ifndef VMA_USE_STL_SHARED_MUTEX
    // Compiler conforms to C++17.
    #if __cplusplus >= 201703L
        #define VMA_USE_STL_SHARED_MUTEX 1
    // Visual studio defines __cplusplus properly only when passed additional parameter: /Zc:__cplusplus
    // Otherwise it is always 199711L, despite shared_mutex works since Visual Studio 2015 Update 2.
    #elif defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && __cplusplus == 199711L && _MSVC_LANG >= 201703L
        #define VMA_USE_STL_SHARED_MUTEX 1
    #else
        #define VMA_USE_STL_SHARED_MUTEX 0
    #endif
#endif

/*
Define this macro to include custom header files without having to edit this file directly, e.g.:

    // Inside of "my_vma_configuration_user_includes.h":

    #include "my_custom_assert.h" // for MY_CUSTOM_ASSERT
    #include "my_custom_min.h" // for my_custom_min
    #include <algorithm>
    #include <mutex>

    // Inside a different file, which includes "vk_mem_alloc.h":

    #define VMA_CONFIGURATION_USER_INCLUDES_H "my_vma_configuration_user_includes.h"
    #define VMA_ASSERT(expr) MY_CUSTOM_ASSERT(expr)
    #define VMA_MIN(v1, v2)  (my_custom_min(v1, v2))
    #include "vk_mem_alloc.h"
    ...

The following headers are used in this CONFIGURATION section only, so feel free to
remove them if not needed.
*/
#if !defined(VMA_CONFIGURATION_USER_INCLUDES_H)
    #include <cassert> // for assert
    #include <algorithm> // for min, max
    #include <mutex>
#else
    #include VMA_CONFIGURATION_USER_INCLUDES_H
#endif

#ifndef VMA_NULL
   // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
   #define VMA_NULL   nullptr
#endif

// Normal assert to check for programmer's errors, especially in Debug configuration.
#ifndef VMA_ASSERT
   #ifdef NDEBUG
       #define VMA_ASSERT(expr)
   #else
       #define VMA_ASSERT(expr)         assert(expr)
   #endif
#endif

// Assert that will be called very often, like inside data structures e.g. operator[].
// Making it non-empty can make program slow.
#ifndef VMA_HEAVY_ASSERT
   #ifdef NDEBUG
       #define VMA_HEAVY_ASSERT(expr)
   #else
       #define VMA_HEAVY_ASSERT(expr)   //VMA_ASSERT(expr)
   #endif
#endif

// If your compiler is not compatible with C++17 and definition of
// aligned_alloc() function is missing, uncommenting following line may help:

//#include <malloc.h>

#if defined(__ANDROID_API__) && (__ANDROID_API__ < 16)
#include <cstdlib>
static void* vma_aligned_alloc(size_t alignment, size_t size)
{
    // alignment must be >= sizeof(void*)
    if(alignment < sizeof(void*))
    {
        alignment = sizeof(void*);
    }

    return memalign(alignment, size);
}
#elif defined(__APPLE__) || defined(__ANDROID__) || (defined(__linux__) && defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC))
#include <cstdlib>

#if defined(__APPLE__)
#include <AvailabilityMacros.h>
#endif

static void* vma_aligned_alloc(size_t alignment, size_t size)
{
    // Unfortunately, aligned_alloc causes VMA to crash due to it returning null pointers. (At least under 11.4)
    // Therefore, for now disable this specific exception until a proper solution is found.
    //#if defined(__APPLE__) && (defined(MAC_OS_X_VERSION_10_16) || defined(__IPHONE_14_0))
    //#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_16 || __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0
    //    // For C++14, usr/include/malloc/_malloc.h declares aligned_alloc()) only
    //    // with the MacOSX11.0 SDK in Xcode 12 (which is what adds
    //    // MAC_OS_X_VERSION_10_16), even though the function is marked
    //    // available for 10.15. That is why the preprocessor checks for 10.16 but
    //    // the __builtin_available checks for 10.15.
    //    // People who use C++17 could call aligned_alloc with the 10.15 SDK already.
    //    if (__builtin_available(macOS 10.15, iOS 13, *))
    //        return aligned_alloc(alignment, size);
    //#endif
    //#endif

    // alignment must be >= sizeof(void*)
    if(alignment < sizeof(void*))
    {
        alignment = sizeof(void*);
    }

    void *pointer;
    if(posix_memalign(&pointer, alignment, size) == 0)
        return pointer;
    return VMA_NULL;
}
#elif defined(_WIN32)
static void* vma_aligned_alloc(size_t alignment, size_t size)
{
    return _aligned_malloc(size, alignment);
}
#elif __cplusplus >= 201703L // Compiler conforms to C++17.
static void* vma_aligned_alloc(size_t alignment, size_t size)
{
    return aligned_alloc(alignment, size);
}
#else
static void* vma_aligned_alloc(size_t alignment, size_t size)
{
    VMA_ASSERT(0 && "Could not implement aligned_alloc automatically. Please enable C++17 or later in your compiler or provide custom implementation of macro VMA_SYSTEM_ALIGNED_MALLOC (and VMA_SYSTEM_ALIGNED_FREE if needed) using the API of your system.");
    return VMA_NULL;
}
#endif

#if defined(_WIN32)
static void vma_aligned_free(void* ptr)
{
    _aligned_free(ptr);
}
#else
static void vma_aligned_free(void* VMA_NULLABLE ptr)
{
    free(ptr);
}
#endif

#ifndef VMA_ALIGN_OF
   #define VMA_ALIGN_OF(type)       (__alignof(type))
#endif

#ifndef VMA_SYSTEM_ALIGNED_MALLOC
   #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) vma_aligned_alloc((alignment), (size))
#endif

#ifndef VMA_SYSTEM_ALIGNED_FREE
   // VMA_SYSTEM_FREE is the old name, but might have been defined by the user
   #if defined(VMA_SYSTEM_FREE)
      #define VMA_SYSTEM_ALIGNED_FREE(ptr)     VMA_SYSTEM_FREE(ptr)
   #else
      #define VMA_SYSTEM_ALIGNED_FREE(ptr)     vma_aligned_free(ptr)
    #endif
#endif

#ifndef VMA_COUNT_BITS_SET
    // Returns number of bits set to 1 in (v)
    #define VMA_COUNT_BITS_SET(v) VmaCountBitsSet(v)
#endif

#ifndef VMA_BITSCAN_LSB
    // Scans integer for index of first nonzero value from the Least Significant Bit (LSB). If mask is 0 then returns UINT8_MAX
    #define VMA_BITSCAN_LSB(mask) VmaBitScanLSB(mask)
#endif

#ifndef VMA_BITSCAN_MSB
    // Scans integer for index of first nonzero value from the Most Significant Bit (MSB). If mask is 0 then returns UINT8_MAX
    #define VMA_BITSCAN_MSB(mask) VmaBitScanMSB(mask)
#endif

#ifndef VMA_MIN
   #define VMA_MIN(v1, v2)    ((std::min)((v1), (v2)))
#endif

#ifndef VMA_MAX
   #define VMA_MAX(v1, v2)    ((std::max)((v1), (v2)))
#endif

#ifndef VMA_SWAP
   #define VMA_SWAP(v1, v2)   std::swap((v1), (v2))
#endif

#ifndef VMA_SORT
   #define VMA_SORT(beg, end, cmp)  std::sort(beg, end, cmp)
#endif

#ifndef VMA_DEBUG_LOG
   #define VMA_DEBUG_LOG(format, ...)
   /*
   #define VMA_DEBUG_LOG(format, ...) do { \
       printf(format, __VA_ARGS__); \
       printf("\n"); \
   } while(false)
   */
#endif

// Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
#if VMA_STATS_STRING_ENABLED
    static inline void VmaUint32ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint32_t num)
    {
        snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
    }
    static inline void VmaUint64ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint64_t num)
    {
        snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
    }
    static inline void VmaPtrToStr(char* VMA_NOT_NULL outStr, size_t strLen, const void* ptr)
    {
        snprintf(outStr, strLen, "%p", ptr);
    }
#endif

#ifndef VMA_MUTEX
    class VmaMutex
    {
    public:
        void Lock() { m_Mutex.lock(); }
        void Unlock() { m_Mutex.unlock(); }
        bool TryLock() { return m_Mutex.try_lock(); }
    private:
        std::mutex m_Mutex;
    };
    #define VMA_MUTEX VmaMutex
#endif

// Read-write mutex, where "read" is shared access, "write" is exclusive access.
#ifndef VMA_RW_MUTEX
    #if VMA_USE_STL_SHARED_MUTEX
        // Use std::shared_mutex from C++17.
        #include <shared_mutex>
        class VmaRWMutex
        {
        public:
            void LockRead() { m_Mutex.lock_shared(); }
            void UnlockRead() { m_Mutex.unlock_shared(); }
            bool TryLockRead() { return m_Mutex.try_lock_shared(); }
            void LockWrite() { m_Mutex.lock(); }
            void UnlockWrite() { m_Mutex.unlock(); }
            bool TryLockWrite() { return m_Mutex.try_lock(); }
        private:
            std::shared_mutex m_Mutex;
        };
        #define VMA_RW_MUTEX VmaRWMutex
    #elif defined(_WIN32) && defined(WINVER) && WINVER >= 0x0600
        // Use SRWLOCK from WinAPI.
        // Minimum supported client = Windows Vista, server = Windows Server 2008.
        class VmaRWMutex
        {
        public:
            VmaRWMutex() { InitializeSRWLock(&m_Lock); }
            void LockRead() { AcquireSRWLockShared(&m_Lock); }
            void UnlockRead() { ReleaseSRWLockShared(&m_Lock); }
            bool TryLockRead() { return TryAcquireSRWLockShared(&m_Lock) != FALSE; }
            void LockWrite() { AcquireSRWLockExclusive(&m_Lock); }
            void UnlockWrite() { ReleaseSRWLockExclusive(&m_Lock); }
            bool TryLockWrite() { return TryAcquireSRWLockExclusive(&m_Lock) != FALSE; }
        private:
            SRWLOCK m_Lock;
        };
        #define VMA_RW_MUTEX VmaRWMutex
    #else
        // Less efficient fallback: Use normal mutex.
        class VmaRWMutex
        {
        public:
            void LockRead() { m_Mutex.Lock(); }
            void UnlockRead() { m_Mutex.Unlock(); }
            bool TryLockRead() { return m_Mutex.TryLock(); }
            void LockWrite() { m_Mutex.Lock(); }
            void UnlockWrite() { m_Mutex.Unlock(); }
            bool TryLockWrite() { return m_Mutex.TryLock(); }
        private:
            VMA_MUTEX m_Mutex;
        };
        #define VMA_RW_MUTEX VmaRWMutex
    #endif // #if VMA_USE_STL_SHARED_MUTEX
#endif // #ifndef VMA_RW_MUTEX

/*
If providing your own implementation, you need to implement a subset of std::atomic.
*/
#ifndef VMA_ATOMIC_UINT32
    #include <atomic>
    #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
#endif

#ifndef VMA_ATOMIC_UINT64
    #include <atomic>
    #define VMA_ATOMIC_UINT64 std::atomic<uint64_t>
#endif

#ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
    /**
    Every allocation will have its own memory block.
    Define to 1 for debugging purposes only.
    */
    #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
#endif

#ifndef VMA_MIN_ALIGNMENT
    /**
    Minimum alignment of all allocations, in bytes.
    Set to more than 1 for debugging purposes. Must be power of two.
    */
    #ifdef VMA_DEBUG_ALIGNMENT // Old name
        #define VMA_MIN_ALIGNMENT VMA_DEBUG_ALIGNMENT
    #else
        #define VMA_MIN_ALIGNMENT (1)
    #endif
#endif

#ifndef VMA_DEBUG_MARGIN
    /**
    Minimum margin after every allocation, in bytes.
    Set nonzero for debugging purposes only.
    */
    #define VMA_DEBUG_MARGIN (0)
#endif

#ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
    /**
    Define this macro to 1 to automatically fill new allocations and destroyed
    allocations with some bit pattern.
    */
    #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
#endif

#ifndef VMA_DEBUG_DETECT_CORRUPTION
    /**
    Define this macro to 1 together with non-zero value of VMA_DEBUG_MARGIN to
    enable writing magic value to the margin after every allocation and
    validating it, so that memory corruptions (out-of-bounds writes) are detected.
    */
    #define VMA_DEBUG_DETECT_CORRUPTION (0)
#endif

#ifndef VMA_DEBUG_GLOBAL_MUTEX
    /**
    Set this to 1 for debugging purposes only, to enable single mutex protecting all
    entry calls to the library. Can be useful for debugging multithreading issues.
    */
    #define VMA_DEBUG_GLOBAL_MUTEX (0)
#endif

#ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
    /**
    Minimum value for VkPhysicalDeviceLimits::bufferImageGranularity.
    Set to more than 1 for debugging purposes only. Must be power of two.
    */
    #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
#endif

#ifndef VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT
    /*
    Set this to 1 to make VMA never exceed VkPhysicalDeviceLimits::maxMemoryAllocationCount
    and return error instead of leaving up to Vulkan implementation what to do in such cases.
    */
    #define VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT (0)
#endif

#ifndef VMA_SMALL_HEAP_MAX_SIZE
   /// Maximum size of a memory heap in Vulkan to consider it "small".
   #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
#endif

#ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
   /// Default size of a block allocated as single VkDeviceMemory from a "large" heap.
   #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
#endif

/*
Mapping hysteresis is a logic that launches when vmaMapMemory/vmaUnmapMemory is called
or a persistently mapped allocation is created and destroyed several times in a row.
It keeps additional +1 mapping of a device memory block to prevent calling actual
vkMapMemory/vkUnmapMemory too many times, which may improve performance and help
tools like RenderDoc.
*/
#ifndef VMA_MAPPING_HYSTERESIS_ENABLED
    #define VMA_MAPPING_HYSTERESIS_ENABLED 1
#endif

#ifndef VMA_CLASS_NO_COPY
    #define VMA_CLASS_NO_COPY(className) \
        private: \
            className(const className&) = delete; \
            className& operator=(const className&) = delete;
#endif

#define VMA_VALIDATE(cond) do { if(!(cond)) { \
        VMA_ASSERT(0 && "Validation failed: " #cond); \
        return false; \
    } } while(false)

/*******************************************************************************
END OF CONFIGURATION
*/
#endif // _VMA_CONFIGURATION


static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
// Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;

// Copy of some Vulkan definitions so we don't need to check their existence just to handle few constants.
static const uint32_t VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY = 0x00000040;
static const uint32_t VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY = 0x00000080;
static const uint32_t VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY = 0x00020000;
static const uint32_t VK_IMAGE_CREATE_DISJOINT_BIT_COPY = 0x00000200;
static const int32_t VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT_COPY = 1000158000;
static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;
static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
static const uint32_t VMA_VENDOR_ID_AMD = 4098;

// This one is tricky. Vulkan specification defines this code as available since
// Vulkan 1.0, but doesn't actually define it in Vulkan SDK earlier than 1.2.131.
// See pull request #207.
#define VK_ERROR_UNKNOWN_COPY ((VkResult)-13)


#if VMA_STATS_STRING_ENABLED
// Correspond to values of enum VmaSuballocationType.
static const char* VMA_SUBALLOCATION_TYPE_NAMES[] =
{
    "FREE",
    "UNKNOWN",
    "BUFFER",
    "IMAGE_UNKNOWN",
    "IMAGE_LINEAR",
    "IMAGE_OPTIMAL",
};
#endif

static VkAllocationCallbacks VmaEmptyAllocationCallbacks =
    { VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };


#ifndef _VMA_ENUM_DECLARATIONS

enum VmaSuballocationType
{
    VMA_SUBALLOCATION_TYPE_FREE = 0,
    VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
    VMA_SUBALLOCATION_TYPE_BUFFER = 2,
    VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
    VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
    VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
    VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
};

enum VMA_CACHE_OPERATION
{
    VMA_CACHE_FLUSH,
    VMA_CACHE_INVALIDATE
};

enum class VmaAllocationRequestType
{
    Normal,
    TLSF,
    // Used by "Linear" algorithm.
    UpperAddress,
    EndOf1st,
    EndOf2nd,
};

#endif // _VMA_ENUM_DECLARATIONS

#ifndef _VMA_FORWARD_DECLARATIONS
// Opaque handle used by allocation algorithms to identify single allocation in any conforming way.
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VmaAllocHandle)

struct VmaMutexLock;
struct VmaMutexLockRead;
struct VmaMutexLockWrite;

template<typename T>
struct AtomicTransactionalIncrement;

template<typename T>
struct VmaStlAllocator;

template<typename T, typename AllocatorT>
class VmaVector;

template<typename T, typename AllocatorT, size_t N>
class VmaSmallVector;

template<typename T>
class VmaPoolAllocator;

template<typename T>
struct VmaListItem;

template<typename T>
class VmaRawList;

template<typename T, typename AllocatorT>
class VmaList;

template<typename ItemTypeTraits>
class VmaIntrusiveLinkedList;

// Unused in this version
#if 0
template<typename T1, typename T2>
struct VmaPair;
template<typename FirstT, typename SecondT>
struct VmaPairFirstLess;

template<typename KeyT, typename ValueT>
class VmaMap;
#endif

#if VMA_STATS_STRING_ENABLED
class VmaStringBuilder;
class VmaJsonWriter;
#endif

class VmaDeviceMemoryBlock;

struct VmaDedicatedAllocationListItemTraits;
class VmaDedicatedAllocationList;

struct VmaSuballocation;
struct VmaSuballocationOffsetLess;
struct VmaSuballocationOffsetGreater;
struct VmaSuballocationItemSizeLess;

typedef VmaList<VmaSuballocation, VmaStlAllocator<VmaSuballocation>> VmaSuballocationList;

struct VmaAllocationRequest;

class VmaBlockMetadata;
class VmaBlockMetadata_Linear;
class VmaBlockMetadata_TLSF;

class VmaBlockVector;

struct VmaPoolListItemTraits;

struct VmaCurrentBudgetData;

class VmaAllocationObjectAllocator;

#endif // _VMA_FORWARD_DECLARATIONS


#ifndef _VMA_FUNCTIONS

/*
Returns number of bits set to 1 in (v).

On specific platforms and compilers you can use instrinsics like:

Visual Studio:
    return __popcnt(v);
GCC, Clang:
    return static_cast<uint32_t>(__builtin_popcount(v));

Define macro VMA_COUNT_BITS_SET to provide your optimized implementation.
But you need to check in runtime whether user's CPU supports these, as some old processors don't.
*/
static inline uint32_t VmaCountBitsSet(uint32_t v)
{
#if __cplusplus >= 202002L || _MSVC_LANG >= 202002L // C++20
    return std::popcount(v);
#else
    uint32_t c = v - ((v >> 1) & 0x55555555);
    c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
    c = ((c >> 4) + c) & 0x0F0F0F0F;
    c = ((c >> 8) + c) & 0x00FF00FF;
    c = ((c >> 16) + c) & 0x0000FFFF;
    return c;
#endif
}

static inline uint8_t VmaBitScanLSB(uint64_t mask)
{
#if defined(_MSC_VER) && defined(_WIN64)
    unsigned long pos;
    if (_BitScanForward64(&pos, mask))
        return static_cast<uint8_t>(pos);
    return UINT8_MAX;
#elif defined __GNUC__ || defined __clang__
    return static_cast<uint8_t>(__builtin_ffsll(mask)) - 1U;
#else
    uint8_t pos = 0;
    uint64_t bit = 1;
    do
    {
        if (mask & bit)
            return pos;
        bit <<= 1;
    } while (pos++ < 63);
    return UINT8_MAX;
#endif
}

static inline uint8_t VmaBitScanLSB(uint32_t mask)
{
#ifdef _MSC_VER
    unsigned long pos;
    if (_BitScanForward(&pos, mask))
        return static_cast<uint8_t>(pos);
    return UINT8_MAX;
#elif defined __GNUC__ || defined __clang__
    return static_cast<uint8_t>(__builtin_ffs(mask)) - 1U;
#else
    uint8_t pos = 0;
    uint32_t bit = 1;
    do
    {
        if (mask & bit)
            return pos;
        bit <<= 1;
    } while (pos++ < 31);
    return UINT8_MAX;
#endif
}

static inline uint8_t VmaBitScanMSB(uint64_t mask)
{
#if defined(_MSC_VER) && defined(_WIN64)
    unsigned long pos;
    if (_BitScanReverse64(&pos, mask))
        return static_cast<uint8_t>(pos);
#elif defined __GNUC__ || defined __clang__
    if (mask)
        return 63 - static_cast<uint8_t>(__builtin_clzll(mask));
#else
    uint8_t pos = 63;
    uint64_t bit = 1ULL << 63;
    do
    {
        if (mask & bit)
            return pos;
        bit >>= 1;
    } while (pos-- > 0);
#endif
    return UINT8_MAX;
}

static inline uint8_t VmaBitScanMSB(uint32_t mask)
{
#ifdef _MSC_VER
    unsigned long pos;
    if (_BitScanReverse(&pos, mask))
        return static_cast<uint8_t>(pos);
#elif defined __GNUC__ || defined __clang__
    if (mask)
        return 31 - static_cast<uint8_t>(__builtin_clz(mask));
#else
    uint8_t pos = 31;
    uint32_t bit = 1UL << 31;
    do
    {
        if (mask & bit)
            return pos;
        bit >>= 1;
    } while (pos-- > 0);
#endif
    return UINT8_MAX;
}

/*
Returns true if given number is a power of two.
T must be unsigned integer number or signed integer but always nonnegative.
For 0 returns true.
*/
template <typename T>
inline bool VmaIsPow2(T x)
{
    return (x & (x - 1)) == 0;
}

// Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
// Use types like uint32_t, uint64_t as T.
template <typename T>
static inline T VmaAlignUp(T val, T alignment)
{
    VMA_HEAVY_ASSERT(VmaIsPow2(alignment));
    return (val + alignment - 1) & ~(alignment - 1);
}

// Aligns given value down to nearest multiply of align value. For example: VmaAlignDown(11, 8) = 8.
// Use types like uint32_t, uint64_t as T.
template <typename T>
static inline T VmaAlignDown(T val, T alignment)
{
    VMA_HEAVY_ASSERT(VmaIsPow2(alignment));
    return val & ~(alignment - 1);
}

// Division with mathematical rounding to nearest number.
template <typename T>
static inline T VmaRoundDiv(T x, T y)
{
    return (x + (y / (T)2)) / y;
}

// Divide by 'y' and round up to nearest integer.
template <typename T>
static inline T VmaDivideRoundingUp(T x, T y)
{
    return (x + y - (T)1) / y;
}

// Returns smallest power of 2 greater or equal to v.
static inline uint32_t VmaNextPow2(uint32_t v)
{
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v++;
    return v;
}

static inline uint64_t VmaNextPow2(uint64_t v)
{
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v |= v >> 32;
    v++;
    return v;
}

// Returns largest power of 2 less or equal to v.
static inline uint32_t VmaPrevPow2(uint32_t v)
{
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v = v ^ (v >> 1);
    return v;
}

static inline uint64_t VmaPrevPow2(uint64_t v)
{
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v |= v >> 32;
    v = v ^ (v >> 1);
    return v;
}

static inline bool VmaStrIsEmpty(const char* pStr)
{
    return pStr == VMA_NULL || *pStr == '\0';
}

/*
Returns true if two memory blocks occupy overlapping pages.
ResourceA must be in less memory offset than ResourceB.

Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
*/
static inline bool VmaBlocksOnSamePage(
    VkDeviceSize resourceAOffset,
    VkDeviceSize resourceASize,
    VkDeviceSize resourceBOffset,
    VkDeviceSize pageSize)
{
    VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
    VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
    VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
    VkDeviceSize resourceBStart = resourceBOffset;
    VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
    return resourceAEndPage == resourceBStartPage;
}

/*
Returns true if given suballocation types could conflict and must respect
VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
or linear image and another one is optimal image. If type is unknown, behave
conservatively.
*/
static inline bool VmaIsBufferImageGranularityConflict(
    VmaSuballocationType suballocType1,
    VmaSuballocationType suballocType2)
{
    if (suballocType1 > suballocType2)
    {
        VMA_SWAP(suballocType1, suballocType2);
    }

    switch (suballocType1)
    {
    case VMA_SUBALLOCATION_TYPE_FREE:
        return false;
    case VMA_SUBALLOCATION_TYPE_UNKNOWN:
        return true;
    case VMA_SUBALLOCATION_TYPE_BUFFER:
        return
            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
        return
            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
        return
            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
        return false;
    default:
        VMA_ASSERT(0);
        return true;
    }
}

static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
{
#if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
    uint32_t* pDst = (uint32_t*)((char*)pData + offset);
    const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
    for (size_t i = 0; i < numberCount; ++i, ++pDst)
    {
        *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
    }
#else
    // no-op
#endif
}

static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
{
#if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
    const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
    const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
    for (size_t i = 0; i < numberCount; ++i, ++pSrc)
    {
        if (*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
        {
            return false;
        }
    }
#endif
    return true;
}

/*
Fills structure with parameters of an example buffer to be used for transfers
during GPU memory defragmentation.
*/
static void VmaFillGpuDefragmentationBufferCreateInfo(VkBufferCreateInfo& outBufCreateInfo)
{
    memset(&outBufCreateInfo, 0, sizeof(outBufCreateInfo));
    outBufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    outBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
    outBufCreateInfo.size = (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE; // Example size.
}


/*
Performs binary search and returns iterator to first element that is greater or
equal to (key), according to comparison (cmp).

Cmp should return true if first argument is less than second argument.

Returned value is the found element, if present in the collection or place where
new element with value (key) should be inserted.
*/
template <typename CmpLess, typename IterT, typename KeyT>
static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT& key, const CmpLess& cmp)
{
    size_t down = 0, up = (end - beg);
    while (down < up)
    {
        const size_t mid = down + (up - down) / 2;  // Overflow-safe midpoint calculation
        if (cmp(*(beg + mid), key))
        {
            down = mid + 1;
        }
        else
        {
            up = mid;
        }
    }
    return beg + down;
}

template<typename CmpLess, typename IterT, typename KeyT>
IterT VmaBinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& value, const CmpLess& cmp)
{
    IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
        beg, end, value, cmp);
    if (it == end ||
        (!cmp(*it, value) && !cmp(value, *it)))
    {
        return it;
    }
    return end;
}

/*
Returns true if all pointers in the array are not-null and unique.
Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT.
T must be pointer type, e.g. VmaAllocation, VmaPool.
*/
template<typename T>
static bool VmaValidatePointerArray(uint32_t count, const T* arr)
{
    for (uint32_t i = 0; i < count; ++i)
    {
        const T iPtr = arr[i];
        if (iPtr == VMA_NULL)
        {
            return false;
        }
        for (uint32_t j = i + 1; j < count; ++j)
        {
            if (iPtr == arr[j])
            {
                return false;
            }
        }
    }
    return true;
}

template<typename MainT, typename NewT>
static inline void VmaPnextChainPushFront(MainT* mainStruct, NewT* newStruct)
{
    newStruct->pNext = mainStruct->pNext;
    mainStruct->pNext = newStruct;
}

// This is the main algorithm that guides the selection of a memory type best for an allocation -
// converts usage to required/preferred/not preferred flags.
static bool FindMemoryPreferences(
    bool isIntegratedGPU,
    const VmaAllocationCreateInfo& allocCreateInfo,
    VkFlags bufImgUsage, // VkBufferCreateInfo::usage or VkImageCreateInfo::usage. UINT32_MAX if unknown.
    VkMemoryPropertyFlags& outRequiredFlags,
    VkMemoryPropertyFlags& outPreferredFlags,
    VkMemoryPropertyFlags& outNotPreferredFlags)
{
    outRequiredFlags = allocCreateInfo.requiredFlags;
    outPreferredFlags = allocCreateInfo.preferredFlags;
    outNotPreferredFlags = 0;

    switch(allocCreateInfo.usage)
    {
    case VMA_MEMORY_USAGE_UNKNOWN:
        break;
    case VMA_MEMORY_USAGE_GPU_ONLY:
        if(!isIntegratedGPU || (outPreferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        {
            outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        }
        break;
    case VMA_MEMORY_USAGE_CPU_ONLY:
        outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        break;
    case VMA_MEMORY_USAGE_CPU_TO_GPU:
        outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        if(!isIntegratedGPU || (outPreferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        {
            outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        }
        break;
    case VMA_MEMORY_USAGE_GPU_TO_CPU:
        outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        outPreferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
        break;
    case VMA_MEMORY_USAGE_CPU_COPY:
        outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        break;
    case VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED:
        outRequiredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
        break;
    case VMA_MEMORY_USAGE_AUTO:
    case VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE:
    case VMA_MEMORY_USAGE_AUTO_PREFER_HOST:
    {
        if(bufImgUsage == UINT32_MAX)
        {
            VMA_ASSERT(0 && "VMA_MEMORY_USAGE_AUTO* values can only be used with functions like vmaCreateBuffer, vmaCreateImage so that the details of the created resource are known.");
            return false;
        }
        // This relies on values of VK_IMAGE_USAGE_TRANSFER* being the same VK_BUFFER_IMAGE_TRANSFER*.
        const bool deviceAccess = (bufImgUsage & ~(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT)) != 0;
        const bool hostAccessSequentialWrite = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT) != 0;
        const bool hostAccessRandom = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT) != 0;
        const bool hostAccessAllowTransferInstead = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT) != 0;
        const bool preferDevice = allocCreateInfo.usage == VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
        const bool preferHost = allocCreateInfo.usage == VMA_MEMORY_USAGE_AUTO_PREFER_HOST;

        // CPU random access - e.g. a buffer written to or transferred from GPU to read back on CPU.
        if(hostAccessRandom)
        {
            if(!isIntegratedGPU && deviceAccess && hostAccessAllowTransferInstead && !preferHost)
            {
                // Nice if it will end up in HOST_VISIBLE, but more importantly prefer DEVICE_LOCAL.
                // Omitting HOST_VISIBLE here is intentional.
                // In case there is DEVICE_LOCAL | HOST_VISIBLE | HOST_CACHED, it will pick that one.
                // Otherwise, this will give same weight to DEVICE_LOCAL as HOST_VISIBLE | HOST_CACHED and select the former if occurs first on the list.
                outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
            }
            else
            {
                // Always CPU memory, cached.
                outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
            }
        }
        // CPU sequential write - may be CPU or host-visible GPU memory, uncached and write-combined.
        else if(hostAccessSequentialWrite)
        {
            // Want uncached and write-combined.
            outNotPreferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;

            if(!isIntegratedGPU && deviceAccess && hostAccessAllowTransferInstead && !preferHost)
            {
                outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
            }
            else
            {
                outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
                // Direct GPU access, CPU sequential write (e.g. a dynamic uniform buffer updated every frame)
                if(deviceAccess)
                {
                    // Could go to CPU memory or GPU BAR/unified. Up to the user to decide. If no preference, choose GPU memory.
                    if(preferHost)
                        outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
                    else
                        outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
                }
                // GPU no direct access, CPU sequential write (e.g. an upload buffer to be transferred to the GPU)
                else
                {
                    // Could go to CPU memory or GPU BAR/unified. Up to the user to decide. If no preference, choose CPU memory.
                    if(preferDevice)
                        outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
                    else
                        outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
                }
            }
        }
        // No CPU access
        else
        {
            // GPU access, no CPU access (e.g. a color attachment image) - prefer GPU memory
            if(deviceAccess)
            {
                // ...unless there is a clear preference from the user not to do so.
                if(preferHost)
                    outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
                else
                    outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
            }
            // No direct GPU access, no CPU access, just transfers.
            // It may be staging copy intended for e.g. preserving image for next frame (then better GPU memory) or
            // a "swap file" copy to free some GPU memory (then better CPU memory).
            // Up to the user to decide. If no preferece, assume the former and choose GPU memory.
            if(preferHost)
                outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
            else
                outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        }
        break;
    }
    default:
        VMA_ASSERT(0);
    }

    // Avoid DEVICE_COHERENT unless explicitly requested.
    if(((allocCreateInfo.requiredFlags | allocCreateInfo.preferredFlags) &
        (VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY | VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY)) == 0)
    {
        outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY;
    }

    return true;
}

////////////////////////////////////////////////////////////////////////////////
// Memory allocation

static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
{
    void* result = VMA_NULL;
    if ((pAllocationCallbacks != VMA_NULL) &&
        (pAllocationCallbacks->pfnAllocation != VMA_NULL))
    {
        result = (*pAllocationCallbacks->pfnAllocation)(
            pAllocationCallbacks->pUserData,
            size,
            alignment,
            VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
    }
    else
    {
        result = VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
    }
    VMA_ASSERT(result != VMA_NULL && "CPU memory allocation failed.");
    return result;
}

static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
{
    if ((pAllocationCallbacks != VMA_NULL) &&
        (pAllocationCallbacks->pfnFree != VMA_NULL))
    {
        (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
    }
    else
    {
        VMA_SYSTEM_ALIGNED_FREE(ptr);
    }
}

template<typename T>
static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
{
    return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
}

template<typename T>
static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
{
    return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
}

#define vma_new(allocator, type)   new(VmaAllocate<type>(allocator))(type)

#define vma_new_array(allocator, type, count)   new(VmaAllocateArray<type>((allocator), (count)))(type)

template<typename T>
static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
{
    ptr->~T();
    VmaFree(pAllocationCallbacks, ptr);
}

template<typename T>
static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
{
    if (ptr != VMA_NULL)
    {
        for (size_t i = count; i--; )
        {
            ptr[i].~T();
        }
        VmaFree(pAllocationCallbacks, ptr);
    }
}

static char* VmaCreateStringCopy(const VkAllocationCallbacks* allocs, const char* srcStr)
{
    if (srcStr != VMA_NULL)
    {
        const size_t len = strlen(srcStr);
        char* const result = vma_new_array(allocs, char, len + 1);
        memcpy(result, srcStr, len + 1);
        return result;
    }
    return VMA_NULL;
}

#if VMA_STATS_STRING_ENABLED
static char* VmaCreateStringCopy(const VkAllocationCallbacks* allocs, const char* srcStr, size_t strLen)
{
    if (srcStr != VMA_NULL)
    {
        char* const result = vma_new_array(allocs, char, strLen + 1);
        memcpy(result, srcStr, strLen);
        result[strLen] = '\0';
        return result;
    }
    return VMA_NULL;
}
#endif // VMA_STATS_STRING_ENABLED

static void VmaFreeString(const VkAllocationCallbacks* allocs, char* str)
{
    if (str != VMA_NULL)
    {
        const size_t len = strlen(str);
        vma_delete_array(allocs, str, len + 1);
    }
}

template<typename CmpLess, typename VectorT>
size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
{
    const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        vector.data(),
        vector.data() + vector.size(),
        value,
        CmpLess()) - vector.data();
    VmaVectorInsert(vector, indexToInsert, value);
    return indexToInsert;
}

template<typename CmpLess, typename VectorT>
bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
{
    CmpLess comparator;
    typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
        vector.begin(),
        vector.end(),
        value,
        comparator);
    if ((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
    {
        size_t indexToRemove = it - vector.begin();
        VmaVectorRemove(vector, indexToRemove);
        return true;
    }
    return false;
}
#endif // _VMA_FUNCTIONS

#ifndef _VMA_STATISTICS_FUNCTIONS

static void VmaClearStatistics(VmaStatistics& outStats)
{
    outStats.blockCount = 0;
    outStats.allocationCount = 0;
    outStats.blockBytes = 0;
    outStats.allocationBytes = 0;
}

static void VmaAddStatistics(VmaStatistics& inoutStats, const VmaStatistics& src)
{
    inoutStats.blockCount += src.blockCount;
    inoutStats.allocationCount += src.allocationCount;
    inoutStats.blockBytes += src.blockBytes;
    inoutStats.allocationBytes += src.allocationBytes;
}

static void VmaClearDetailedStatistics(VmaDetailedStatistics& outStats)
{
    VmaClearStatistics(outStats.statistics);
    outStats.unusedRangeCount = 0;
    outStats.allocationSizeMin = VK_WHOLE_SIZE;
    outStats.allocationSizeMax = 0;
    outStats.unusedRangeSizeMin = VK_WHOLE_SIZE;
    outStats.unusedRangeSizeMax = 0;
}

static void VmaAddDetailedStatisticsAllocation(VmaDetailedStatistics& inoutStats, VkDeviceSize size)
{
    inoutStats.statistics.allocationCount++;
    inoutStats.statistics.allocationBytes += size;
    inoutStats.allocationSizeMin = VMA_MIN(inoutStats.allocationSizeMin, size);
    inoutStats.allocationSizeMax = VMA_MAX(inoutStats.allocationSizeMax, size);
}

static void VmaAddDetailedStatisticsUnusedRange(VmaDetailedStatistics& inoutStats, VkDeviceSize size)
{
    inoutStats.unusedRangeCount++;
    inoutStats.unusedRangeSizeMin = VMA_MIN(inoutStats.unusedRangeSizeMin, size);
    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, size);
}

static void VmaAddDetailedStatistics(VmaDetailedStatistics& inoutStats, const VmaDetailedStatistics& src)
{
    VmaAddStatistics(inoutStats.statistics, src.statistics);
    inoutStats.unusedRangeCount += src.unusedRangeCount;
    inoutStats.allocationSizeMin = VMA_MIN(inoutStats.allocationSizeMin, src.allocationSizeMin);
    inoutStats.allocationSizeMax = VMA_MAX(inoutStats.allocationSizeMax, src.allocationSizeMax);
    inoutStats.unusedRangeSizeMin = VMA_MIN(inoutStats.unusedRangeSizeMin, src.unusedRangeSizeMin);
    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, src.unusedRangeSizeMax);
}

#endif // _VMA_STATISTICS_FUNCTIONS

#ifndef _VMA_MUTEX_LOCK
// Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
struct VmaMutexLock
{
    VMA_CLASS_NO_COPY(VmaMutexLock)
public:
    VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
        m_pMutex(useMutex ? &mutex : VMA_NULL)
    {
        if (m_pMutex) { m_pMutex->Lock(); }
    }
    ~VmaMutexLock() {  if (m_pMutex) { m_pMutex->Unlock(); } }

private:
    VMA_MUTEX* m_pMutex;
};

// Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for reading.
struct VmaMutexLockRead
{
    VMA_CLASS_NO_COPY(VmaMutexLockRead)
public:
    VmaMutexLockRead(VMA_RW_MUTEX& mutex, bool useMutex) :
        m_pMutex(useMutex ? &mutex : VMA_NULL)
    {
        if (m_pMutex) { m_pMutex->LockRead(); }
    }
    ~VmaMutexLockRead() { if (m_pMutex) { m_pMutex->UnlockRead(); } }

private:
    VMA_RW_MUTEX* m_pMutex;
};

// Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for writing.
struct VmaMutexLockWrite
{
    VMA_CLASS_NO_COPY(VmaMutexLockWrite)
public:
    VmaMutexLockWrite(VMA_RW_MUTEX& mutex, bool useMutex)
        : m_pMutex(useMutex ? &mutex : VMA_NULL)
    {
        if (m_pMutex) { m_pMutex->LockWrite(); }
    }
    ~VmaMutexLockWrite() { if (m_pMutex) { m_pMutex->UnlockWrite(); } }

private:
    VMA_RW_MUTEX* m_pMutex;
};

#if VMA_DEBUG_GLOBAL_MUTEX
    static VMA_MUTEX gDebugGlobalMutex;
    #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
#else
    #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
#endif
#endif // _VMA_MUTEX_LOCK

#ifndef _VMA_ATOMIC_TRANSACTIONAL_INCREMENT
// An object that increments given atomic but decrements it back in the destructor unless Commit() is called.
template<typename T>
struct AtomicTransactionalIncrement
{
public:
    typedef std::atomic<T> AtomicT;

    ~AtomicTransactionalIncrement()
    {
        if(m_Atomic)
            --(*m_Atomic);
    }

    void Commit() { m_Atomic = nullptr; }
    T Increment(AtomicT* atomic)
    {
        m_Atomic = atomic;
        return m_Atomic->fetch_add(1);
    }

private:
    AtomicT* m_Atomic = nullptr;
};
#endif // _VMA_ATOMIC_TRANSACTIONAL_INCREMENT

#ifndef _VMA_STL_ALLOCATOR
// STL-compatible allocator.
template<typename T>
struct VmaStlAllocator
{
    const VkAllocationCallbacks* const m_pCallbacks;
    typedef T value_type;

    VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) {}
    template<typename U>
    VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) {}
    VmaStlAllocator(const VmaStlAllocator&) = default;
    VmaStlAllocator& operator=(const VmaStlAllocator&) = delete;

    T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
    void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }

    template<typename U>
    bool operator==(const VmaStlAllocator<U>& rhs) const
    {
        return m_pCallbacks == rhs.m_pCallbacks;
    }
    template<typename U>
    bool operator!=(const VmaStlAllocator<U>& rhs) const
    {
        return m_pCallbacks != rhs.m_pCallbacks;
    }
};
#endif // _VMA_STL_ALLOCATOR

#ifndef _VMA_VECTOR
/* Class with interface compatible with subset of std::vector.
T must be POD because constructors and destructors are not called and memcpy is
used for these objects. */
template<typename T, typename AllocatorT>
class VmaVector
{
public:
    typedef T value_type;
    typedef T* iterator;
    typedef const T* const_iterator;

    VmaVector(const AllocatorT& allocator);
    VmaVector(size_t count, const AllocatorT& allocator);
    // This version of the constructor is here for compatibility with pre-C++14 std::vector.
    // value is unused.
    VmaVector(size_t count, const T& value, const AllocatorT& allocator) : VmaVector(count, allocator) {}
    VmaVector(const VmaVector<T, AllocatorT>& src);
    VmaVector& operator=(const VmaVector& rhs);
    ~VmaVector() { VmaFree(m_Allocator.m_pCallbacks, m_pArray); }

    bool empty() const { return m_Count == 0; }
    size_t size() const { return m_Count; }
    T* data() { return m_pArray; }
    T& front() { VMA_HEAVY_ASSERT(m_Count > 0); return m_pArray[0]; }
    T& back() { VMA_HEAVY_ASSERT(m_Count > 0); return m_pArray[m_Count - 1]; }
    const T* data() const { return m_pArray; }
    const T& front() const { VMA_HEAVY_ASSERT(m_Count > 0); return m_pArray[0]; }
    const T& back() const { VMA_HEAVY_ASSERT(m_Count > 0); return m_pArray[m_Count - 1]; }

    iterator begin() { return m_pArray; }
    iterator end() { return m_pArray + m_Count; }
    const_iterator cbegin() const { return m_pArray; }
    const_iterator cend() const { return m_pArray + m_Count; }
    const_iterator begin() const { return cbegin(); }
    const_iterator end() const { return cend(); }

    void pop_front() { VMA_HEAVY_ASSERT(m_Count > 0); remove(0); }
    void pop_back() { VMA_HEAVY_ASSERT(m_Count > 0); resize(size() - 1); }
    void push_front(const T& src) { insert(0, src); }

    void push_back(const T& src);
    void reserve(size_t newCapacity, bool freeMemory = false);
    void resize(size_t newCount);
    void clear() { resize(0); }
    void shrink_to_fit();
    void insert(size_t index, const T& src);
    void remove(size_t index);

    T& operator[](size_t index) { VMA_HEAVY_ASSERT(index < m_Count); return m_pArray[index]; }
    const T& operator[](size_t index) const { VMA_HEAVY_ASSERT(index < m_Count); return m_pArray[index]; }

private:
    AllocatorT m_Allocator;
    T* m_pArray;
    size_t m_Count;
    size_t m_Capacity;
};

#ifndef _VMA_VECTOR_FUNCTIONS
template<typename T, typename AllocatorT>
VmaVector<T, AllocatorT>::VmaVector(const AllocatorT& allocator)
    : m_Allocator(allocator),
    m_pArray(VMA_NULL),
    m_Count(0),
    m_Capacity(0) {}

template<typename T, typename AllocatorT>
VmaVector<T, AllocatorT>::VmaVector(size_t count, const AllocatorT& allocator)
    : m_Allocator(allocator),
    m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
    m_Count(count),
    m_Capacity(count) {}

template<typename T, typename AllocatorT>
VmaVector<T, AllocatorT>::VmaVector(const VmaVector& src)
    : m_Allocator(src.m_Allocator),
    m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
    m_Count(src.m_Count),
    m_Capacity(src.m_Count)
{
    if (m_Count != 0)
    {
        memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
    }
}

template<typename T, typename AllocatorT>
VmaVector<T, AllocatorT>& VmaVector<T, AllocatorT>::operator=(const VmaVector& rhs)
{
    if (&rhs != this)
    {
        resize(rhs.m_Count);
        if (m_Count != 0)
        {
            memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
        }
    }
    return *this;
}

template<typename T, typename AllocatorT>
void VmaVector<T, AllocatorT>::push_back(const T& src)
{
    const size_t newIndex = size();
    resize(newIndex + 1);
    m_pArray[newIndex] = src;
}

template<typename T, typename AllocatorT>
void VmaVector<T, AllocatorT>::reserve(size_t newCapacity, bool freeMemory)
{
    newCapacity = VMA_MAX(newCapacity, m_Count);

    if ((newCapacity < m_Capacity) && !freeMemory)
    {
        newCapacity = m_Capacity;
    }

    if (newCapacity != m_Capacity)
    {
        T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
        if (m_Count != 0)
        {
            memcpy(newArray, m_pArray, m_Count * sizeof(T));
        }
        VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        m_Capacity = newCapacity;
        m_pArray = newArray;
    }
}

template<typename T, typename AllocatorT>
void VmaVector<T, AllocatorT>::resize(size_t newCount)
{
    size_t newCapacity = m_Capacity;
    if (newCount > m_Capacity)
    {
        newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
    }

    if (newCapacity != m_Capacity)
    {
        T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
        const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
        if (elementsToCopy != 0)
        {
            memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
        }
        VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        m_Capacity = newCapacity;
        m_pArray = newArray;
    }

    m_Count = newCount;
}

template<typename T, typename AllocatorT>
void VmaVector<T, AllocatorT>::shrink_to_fit()
{
    if (m_Capacity > m_Count)
    {
        T* newArray = VMA_NULL;
        if (m_Count > 0)
        {
            newArray = VmaAllocateArray<T>(m_Allocator.m_pCallbacks, m_Count);
            memcpy(newArray, m_pArray, m_Count * sizeof(T));
        }
        VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        m_Capacity = m_Count;
        m_pArray = newArray;
    }
}

template<typename T, typename AllocatorT>
void VmaVector<T, AllocatorT>::insert(size_t index, const T& src)
{
    VMA_HEAVY_ASSERT(index <= m_Count);
    const size_t oldCount = size();
    resize(oldCount + 1);
    if (index < oldCount)
    {
        memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
    }
    m_pArray[index] = src;
}

template<typename T, typename AllocatorT>
void VmaVector<T, AllocatorT>::remove(size_t index)
{
    VMA_HEAVY_ASSERT(index < m_Count);
    const size_t oldCount = size();
    if (index < oldCount - 1)
    {
        memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
    }
    resize(oldCount - 1);
}
#endif // _VMA_VECTOR_FUNCTIONS

template<typename T, typename allocatorT>
static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
{
    vec.insert(index, item);
}

template<typename T, typename allocatorT>
static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
{
    vec.remove(index);
}
#endif // _VMA_VECTOR

#ifndef _VMA_SMALL_VECTOR
/*
This is a vector (a variable-sized array), optimized for the case when the array is small.

It contains some number of elements in-place, which allows it to avoid heap allocation
when the actual number of elements is below that threshold. This allows normal "small"
cases to be fast without losing generality for large inputs.
*/
template<typename T, typename AllocatorT, size_t N>
class VmaSmallVector
{
public:
    typedef T value_type;
    typedef T* iterator;

    VmaSmallVector(const AllocatorT& allocator);
    VmaSmallVector(size_t count, const AllocatorT& allocator);
    template<typename SrcT, typename SrcAllocatorT, size_t SrcN>
    VmaSmallVector(const VmaSmallVector<SrcT, SrcAllocatorT, SrcN>&) = delete;
    template<typename SrcT, typename SrcAllocatorT, size_t SrcN>
    VmaSmallVector<T, AllocatorT, N>& operator=(const VmaSmallVector<SrcT, SrcAllocatorT, SrcN>&) = delete;
    ~VmaSmallVector() = default;

    bool empty() const { return m_Count == 0; }
    size_t size() const { return m_Count; }
    T* data() { return m_Count > N ? m_DynamicArray.data() : m_StaticArray; }
    T& front() { VMA_HEAVY_ASSERT(m_Count > 0); return data()[0]; }
    T& back() { VMA_HEAVY_ASSERT(m_Count > 0); return data()[m_Count - 1]; }
    const T* data() const { return m_Count > N ? m_DynamicArray.data() : m_StaticArray; }
    const T& front() const { VMA_HEAVY_ASSERT(m_Count > 0); return data()[0]; }
    const T& back() const { VMA_HEAVY_ASSERT(m_Count > 0); return data()[m_Count - 1]; }

    iterator begin() { return data(); }
    iterator end() { return data() + m_Count; }

    void pop_front() { VMA_HEAVY_ASSERT(m_Count > 0); remove(0); }
    void pop_back() { VMA_HEAVY_ASSERT(m_Count > 0); resize(size() - 1); }
    void push_front(const T& src) { insert(0, src); }

    void push_back(const T& src);
    void resize(size_t newCount, bool freeMemory = false);
    void clear(bool freeMemory = false);
    void insert(size_t index, const T& src);
    void remove(size_t index);

    T& operator[](size_t index) { VMA_HEAVY_ASSERT(index < m_Count); return data()[index]; }
    const T& operator[](size_t index) const { VMA_HEAVY_ASSERT(index < m_Count); return data()[index]; }

private:
    size_t m_Count;
    T m_StaticArray[N]; // Used when m_Size <= N
    VmaVector<T, AllocatorT> m_DynamicArray; // Used when m_Size > N
};

#ifndef _VMA_SMALL_VECTOR_FUNCTIONS
template<typename T, typename AllocatorT, size_t N>
VmaSmallVector<T, AllocatorT, N>::VmaSmallVector(const AllocatorT& allocator)
    : m_Count(0),
    m_DynamicArray(allocator) {}

template<typename T, typename AllocatorT, size_t N>
VmaSmallVector<T, AllocatorT, N>::VmaSmallVector(size_t count, const AllocatorT& allocator)
    : m_Count(count),
    m_DynamicArray(count > N ? count : 0, allocator) {}

template<typename T, typename AllocatorT, size_t N>
void VmaSmallVector<T, AllocatorT, N>::push_back(const T& src)
{
    const size_t newIndex = size();
    resize(newIndex + 1);
    data()[newIndex] = src;
}

template<typename T, typename AllocatorT, size_t N>
void VmaSmallVector<T, AllocatorT, N>::resize(size_t newCount, bool freeMemory)
{
    if (newCount > N && m_Count > N)
    {
        // Any direction, staying in m_DynamicArray
        m_DynamicArray.resize(newCount);
        if (freeMemory)
        {
            m_DynamicArray.shrink_to_fit();
        }
    }
    else if (newCount > N && m_Count <= N)
    {
        // Growing, moving from m_StaticArray to m_DynamicArray
        m_DynamicArray.resize(newCount);
        if (m_Count > 0)
        {
            memcpy(m_DynamicArray.data(), m_StaticArray, m_Count * sizeof(T));
        }
    }
    else if (newCount <= N && m_Count > N)
    {
        // Shrinking, moving from m_DynamicArray to m_StaticArray
        if (newCount > 0)
        {
            memcpy(m_StaticArray, m_DynamicArray.data(), newCount * sizeof(T));
        }
        m_DynamicArray.resize(0);
        if (freeMemory)
        {
            m_DynamicArray.shrink_to_fit();
        }
    }
    else
    {
        // Any direction, staying in m_StaticArray - nothing to do here
    }
    m_Count = newCount;
}

template<typename T, typename AllocatorT, size_t N>
void VmaSmallVector<T, AllocatorT, N>::clear(bool freeMemory)
{
    m_DynamicArray.clear();
    if (freeMemory)
    {
        m_DynamicArray.shrink_to_fit();
    }
    m_Count = 0;
}

template<typename T, typename AllocatorT, size_t N>
void VmaSmallVector<T, AllocatorT, N>::insert(size_t index, const T& src)
{
    VMA_HEAVY_ASSERT(index <= m_Count);
    const size_t oldCount = size();
    resize(oldCount + 1);
    T* const dataPtr = data();
    if (index < oldCount)
    {
        //  I know, this could be more optimal for case where memmove can be memcpy directly from m_StaticArray to m_DynamicArray.
        memmove(dataPtr + (index + 1), dataPtr + index, (oldCount - index) * sizeof(T));
    }
    dataPtr[index] = src;
}

template<typename T, typename AllocatorT, size_t N>
void VmaSmallVector<T, AllocatorT, N>::remove(size_t index)
{
    VMA_HEAVY_ASSERT(index < m_Count);
    const size_t oldCount = size();
    if (index < oldCount - 1)
    {
        //  I know, this could be more optimal for case where memmove can be memcpy directly from m_DynamicArray to m_StaticArray.
        T* const dataPtr = data();
        memmove(dataPtr + index, dataPtr + (index + 1), (oldCount - index - 1) * sizeof(T));
    }
    resize(oldCount - 1);
}
#endif // _VMA_SMALL_VECTOR_FUNCTIONS
#endif // _VMA_SMALL_VECTOR

#ifndef _VMA_POOL_ALLOCATOR
/*
Allocator for objects of type T using a list of arrays (pools) to speed up
allocation. Number of elements that can be allocated is not bounded because
allocator can create multiple blocks.
*/
template<typename T>
class VmaPoolAllocator
{
    VMA_CLASS_NO_COPY(VmaPoolAllocator)
public:
    VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity);
    ~VmaPoolAllocator();
    template<typename... Types> T* Alloc(Types&&... args);
    void Free(T* ptr);

private:
    union Item
    {
        uint32_t NextFreeIndex;
        alignas(T) char Value[sizeof(T)];
    };
    struct ItemBlock
    {
        Item* pItems;
        uint32_t Capacity;
        uint32_t FirstFreeIndex;
    };

    const VkAllocationCallbacks* m_pAllocationCallbacks;
    const uint32_t m_FirstBlockCapacity;
    VmaVector<ItemBlock, VmaStlAllocator<ItemBlock>> m_ItemBlocks;

    ItemBlock& CreateNewBlock();
};

#ifndef _VMA_POOL_ALLOCATOR_FUNCTIONS
template<typename T>
VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity)
    : m_pAllocationCallbacks(pAllocationCallbacks),
    m_FirstBlockCapacity(firstBlockCapacity),
    m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
{
    VMA_ASSERT(m_FirstBlockCapacity > 1);
}

template<typename T>
VmaPoolAllocator<T>::~VmaPoolAllocator()
{
    for (size_t i = m_ItemBlocks.size(); i--;)
        vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemBlocks[i].Capacity);
    m_ItemBlocks.clear();
}

template<typename T>
template<typename... Types> T* VmaPoolAllocator<T>::Alloc(Types&&... args)
{
    for (size_t i = m_ItemBlocks.size(); i--; )
    {
        ItemBlock& block = m_ItemBlocks[i];
        // This block has some free items: Use first one.
        if (block.FirstFreeIndex != UINT32_MAX)
        {
            Item* const pItem = &block.pItems[block.FirstFreeIndex];
            block.FirstFreeIndex = pItem->NextFreeIndex;
            T* result = (T*)&pItem->Value;
            new(result)T(std::forward<Types>(args)...); // Explicit constructor call.
            return result;
        }
    }

    // No block has free item: Create new one and use it.
    ItemBlock& newBlock = CreateNewBlock();
    Item* const pItem = &newBlock.pItems[0];
    newBlock.FirstFreeIndex = pItem->NextFreeIndex;
    T* result = (T*)&pItem->Value;
    new(result) T(std::forward<Types>(args)...); // Explicit constructor call.
    return result;
}

template<typename T>
void VmaPoolAllocator<T>::Free(T* ptr)
{
    // Search all memory blocks to find ptr.
    for (size_t i = m_ItemBlocks.size(); i--; )
    {
        ItemBlock& block = m_ItemBlocks[i];

        // Casting to union.
        Item* pItemPtr;
        memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));

        // Check if pItemPtr is in address range of this block.
        if ((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + block.Capacity))
        {
            ptr->~T(); // Explicit destructor call.
            const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
            pItemPtr->NextFreeIndex = block.FirstFreeIndex;
            block.FirstFreeIndex = index;
            return;
        }
    }
    VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
}

template<typename T>
typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
{
    const uint32_t newBlockCapacity = m_ItemBlocks.empty() ?
        m_FirstBlockCapacity : m_ItemBlocks.back().Capacity * 3 / 2;

    const ItemBlock newBlock =
    {
        vma_new_array(m_pAllocationCallbacks, Item, newBlockCapacity),
        newBlockCapacity,
        0
    };

    m_ItemBlocks.push_back(newBlock);

    // Setup singly-linked list of all free items in this block.
    for (uint32_t i = 0; i < newBlockCapacity - 1; ++i)
        newBlock.pItems[i].NextFreeIndex = i + 1;
    newBlock.pItems[newBlockCapacity - 1].NextFreeIndex = UINT32_MAX;
    return m_ItemBlocks.back();
}
#endif // _VMA_POOL_ALLOCATOR_FUNCTIONS
#endif // _VMA_POOL_ALLOCATOR

#ifndef _VMA_RAW_LIST
template<typename T>
struct VmaListItem
{
    VmaListItem* pPrev;
    VmaListItem* pNext;
    T Value;
};

// Doubly linked list.
template<typename T>
class VmaRawList
{
    VMA_CLASS_NO_COPY(VmaRawList)
public:
    typedef VmaListItem<T> ItemType;

    VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
    // Intentionally not calling Clear, because that would be unnecessary
    // computations to return all items to m_ItemAllocator as free.
    ~VmaRawList() = default;

    size_t GetCount() const { return m_Count; }
    bool IsEmpty() const { return m_Count == 0; }

    ItemType* Front() { return m_pFront; }
    ItemType* Back() { return m_pBack; }
    const ItemType* Front() const { return m_pFront; }
    const ItemType* Back() const { return m_pBack; }

    ItemType* PushFront();
    ItemType* PushBack();
    ItemType* PushFront(const T& value);
    ItemType* PushBack(const T& value);
    void PopFront();
    void PopBack();

    // Item can be null - it means PushBack.
    ItemType* InsertBefore(ItemType* pItem);
    // Item can be null - it means PushFront.
    ItemType* InsertAfter(ItemType* pItem);
    ItemType* InsertBefore(ItemType* pItem, const T& value);
    ItemType* InsertAfter(ItemType* pItem, const T& value);

    void Clear();
    void Remove(ItemType* pItem);

private:
    const VkAllocationCallbacks* const m_pAllocationCallbacks;
    VmaPoolAllocator<ItemType> m_ItemAllocator;
    ItemType* m_pFront;
    ItemType* m_pBack;
    size_t m_Count;
};

#ifndef _VMA_RAW_LIST_FUNCTIONS
template<typename T>
VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks)
    : m_pAllocationCallbacks(pAllocationCallbacks),
    m_ItemAllocator(pAllocationCallbacks, 128),
    m_pFront(VMA_NULL),
    m_pBack(VMA_NULL),
    m_Count(0) {}

template<typename T>
VmaListItem<T>* VmaRawList<T>::PushFront()
{
    ItemType* const pNewItem = m_ItemAllocator.Alloc();
    pNewItem->pPrev = VMA_NULL;
    if (IsEmpty())
    {
        pNewItem->pNext = VMA_NULL;
        m_pFront = pNewItem;
        m_pBack = pNewItem;
        m_Count = 1;
    }
    else
    {
        pNewItem->pNext = m_pFront;
        m_pFront->pPrev = pNewItem;
        m_pFront = pNewItem;
        ++m_Count;
    }
    return pNewItem;
}

template<typename T>
VmaListItem<T>* VmaRawList<T>::PushBack()
{
    ItemType* const pNewItem = m_ItemAllocator.Alloc();
    pNewItem->pNext = VMA_NULL;
    if(IsEmpty())
    {
        pNewItem->pPrev = VMA_NULL;
        m_pFront = pNewItem;
        m_pBack = pNewItem;
        m_Count = 1;
    }
    else
    {
        pNewItem->pPrev = m_pBack;
        m_pBack->pNext = pNewItem;
        m_pBack = pNewItem;
        ++m_Count;
    }
    return pNewItem;
}

template<typename T>
VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
{
    ItemType* const pNewItem = PushFront();
    pNewItem->Value = value;
    return pNewItem;
}

template<typename T>
VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
{
    ItemType* const pNewItem = PushBack();
    pNewItem->Value = value;
    return pNewItem;
}

template<typename T>
void VmaRawList<T>::PopFront()
{
    VMA_HEAVY_ASSERT(m_Count > 0);
    ItemType* const pFrontItem = m_pFront;
    ItemType* const pNextItem = pFrontItem->pNext;
    if (pNextItem != VMA_NULL)
    {
        pNextItem->pPrev = VMA_NULL;
    }
    m_pFront = pNextItem;
    m_ItemAllocator.Free(pFrontItem);
    --m_Count;
}

template<typename T>
void VmaRawList<T>::PopBack()
{
    VMA_HEAVY_ASSERT(m_Count > 0);
    ItemType* const pBackItem = m_pBack;
    ItemType* const pPrevItem = pBackItem->pPrev;
    if(pPrevItem != VMA_NULL)
    {
        pPrevItem->pNext = VMA_NULL;
    }
    m_pBack = pPrevItem;
    m_ItemAllocator.Free(pBackItem);
    --m_Count;
}

template<typename T>
void VmaRawList<T>::Clear()
{
    if (IsEmpty() == false)
    {
        ItemType* pItem = m_pBack;
        while (pItem != VMA_NULL)
        {
            ItemType* const pPrevItem = pItem->pPrev;
            m_ItemAllocator.Free(pItem);
            pItem = pPrevItem;
        }
        m_pFront = VMA_NULL;
        m_pBack = VMA_NULL;
        m_Count = 0;
    }
}

template<typename T>
void VmaRawList<T>::Remove(ItemType* pItem)
{
    VMA_HEAVY_ASSERT(pItem != VMA_NULL);
    VMA_HEAVY_ASSERT(m_Count > 0);

    if(pItem->pPrev != VMA_NULL)
    {
        pItem->pPrev->pNext = pItem->pNext;
    }
    else
    {
        VMA_HEAVY_ASSERT(m_pFront == pItem);
        m_pFront = pItem->pNext;
    }

    if(pItem->pNext != VMA_NULL)
    {
        pItem->pNext->pPrev = pItem->pPrev;
    }
    else
    {
        VMA_HEAVY_ASSERT(m_pBack == pItem);
        m_pBack = pItem->pPrev;
    }

    m_ItemAllocator.Free(pItem);
    --m_Count;
}

template<typename T>
VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
{
    if(pItem != VMA_NULL)
    {
        ItemType* const prevItem = pItem->pPrev;
        ItemType* const newItem = m_ItemAllocator.Alloc();
        newItem->pPrev = prevItem;
        newItem->pNext = pItem;
        pItem->pPrev = newItem;
        if(prevItem != VMA_NULL)
        {
            prevItem->pNext = newItem;
        }
        else
        {
            VMA_HEAVY_ASSERT(m_pFront == pItem);
            m_pFront = newItem;
        }
        ++m_Count;
        return newItem;
    }
    else
        return PushBack();
}

template<typename T>
VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
{
    if(pItem != VMA_NULL)
    {
        ItemType* const nextItem = pItem->pNext;
        ItemType* const newItem = m_ItemAllocator.Alloc();
        newItem->pNext = nextItem;
        newItem->pPrev = pItem;
        pItem->pNext = newItem;
        if(nextItem != VMA_NULL)
        {
            nextItem->pPrev = newItem;
        }
        else
        {
            VMA_HEAVY_ASSERT(m_pBack == pItem);
            m_pBack = newItem;
        }
        ++m_Count;
        return newItem;
    }
    else
        return PushFront();
}

template<typename T>
VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
{
    ItemType* const newItem = InsertBefore(pItem);
    newItem->Value = value;
    return newItem;
}

template<typename T>
VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
{
    ItemType* const newItem = InsertAfter(pItem);
    newItem->Value = value;
    return newItem;
}
#endif // _VMA_RAW_LIST_FUNCTIONS
#endif // _VMA_RAW_LIST

#ifndef _VMA_LIST
template<typename T, typename AllocatorT>
class VmaList
{
    VMA_CLASS_NO_COPY(VmaList)
public:
    class reverse_iterator;
    class const_iterator;
    class const_reverse_iterator;

    class iterator
    {
        friend class const_iterator;
        friend class VmaList<T, AllocatorT>;
    public:
        iterator() :  m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
        iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}

        T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
        T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }

        bool operator==(const iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
        bool operator!=(const iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }

        iterator operator++(int) { iterator result = *this; ++*this; return result; }
        iterator operator--(int) { iterator result = *this; --*this; return result; }

        iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pNext; return *this; }
        iterator& operator--();

    private:
        VmaRawList<T>* m_pList;
        VmaListItem<T>* m_pItem;

        iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) : m_pList(pList),  m_pItem(pItem) {}
    };
    class reverse_iterator
    {
        friend class const_reverse_iterator;
        friend class VmaList<T, AllocatorT>;
    public:
        reverse_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
        reverse_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}

        T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
        T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }

        bool operator==(const reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
        bool operator!=(const reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }

        reverse_iterator operator++(int) { reverse_iterator result = *this; ++* this; return result; }
        reverse_iterator operator--(int) { reverse_iterator result = *this; --* this; return result; }

        reverse_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pPrev; return *this; }
        reverse_iterator& operator--();

    private:
        VmaRawList<T>* m_pList;
        VmaListItem<T>* m_pItem;

        reverse_iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) : m_pList(pList),  m_pItem(pItem) {}
    };
    class const_iterator
    {
        friend class VmaList<T, AllocatorT>;
    public:
        const_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
        const_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
        const_iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}

        iterator drop_const() { return { const_cast<VmaRawList<T>*>(m_pList), const_cast<VmaListItem<T>*>(m_pItem) }; }

        const T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
        const T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }

        bool operator==(const const_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
        bool operator!=(const const_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }

        const_iterator operator++(int) { const_iterator result = *this; ++* this; return result; }
        const_iterator operator--(int) { const_iterator result = *this; --* this; return result; }

        const_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pNext; return *this; }
        const_iterator& operator--();

    private:
        const VmaRawList<T>* m_pList;
        const VmaListItem<T>* m_pItem;

        const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) : m_pList(pList), m_pItem(pItem) {}
    };
    class const_reverse_iterator
    {
        friend class VmaList<T, AllocatorT>;
    public:
        const_reverse_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
        const_reverse_iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
        const_reverse_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}

        reverse_iterator drop_const() { return { const_cast<VmaRawList<T>*>(m_pList), const_cast<VmaListItem<T>*>(m_pItem) }; }

        const T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
        const T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }

        bool operator==(const const_reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
        bool operator!=(const const_reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }

        const_reverse_iterator operator++(int) { const_reverse_iterator result = *this; ++* this; return result; }
        const_reverse_iterator operator--(int) { const_reverse_iterator result = *this; --* this; return result; }

        const_reverse_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pPrev; return *this; }
        const_reverse_iterator& operator--();

    private:
        const VmaRawList<T>* m_pList;
        const VmaListItem<T>* m_pItem;

        const_reverse_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) : m_pList(pList), m_pItem(pItem) {}
    };

    VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) {}

    bool empty() const { return m_RawList.IsEmpty(); }
    size_t size() const { return m_RawList.GetCount(); }

    iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
    iterator end() { return iterator(&m_RawList, VMA_NULL); }

    const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
    const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }

    const_iterator begin() const { return cbegin(); }
    const_iterator end() const { return cend(); }

    reverse_iterator rbegin() { return reverse_iterator(&m_RawList, m_RawList.Back()); }
    reverse_iterator rend() { return reverse_iterator(&m_RawList, VMA_NULL); }

    const_reverse_iterator crbegin() const { return const_reverse_iterator(&m_RawList, m_RawList.Back()); }
    const_reverse_iterator crend() const { return const_reverse_iterator(&m_RawList, VMA_NULL); }

    const_reverse_iterator rbegin() const { return crbegin(); }
    const_reverse_iterator rend() const { return crend(); }

    void push_back(const T& value) { m_RawList.PushBack(value); }
    iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }

    void clear() { m_RawList.Clear(); }
    void erase(iterator it) { m_RawList.Remove(it.m_pItem); }

private:
    VmaRawList<T> m_RawList;
};

#ifndef _VMA_LIST_FUNCTIONS
template<typename T, typename AllocatorT>
typename VmaList<T, AllocatorT>::iterator& VmaList<T, AllocatorT>::iterator::operator--()
{
    if (m_pItem != VMA_NULL)
    {
        m_pItem = m_pItem->pPrev;
    }
    else
    {
        VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        m_pItem = m_pList->Back();
    }
    return *this;
}

template<typename T, typename AllocatorT>
typename VmaList<T, AllocatorT>::reverse_iterator& VmaList<T, AllocatorT>::reverse_iterator::operator--()
{
    if (m_pItem != VMA_NULL)
    {
        m_pItem = m_pItem->pNext;
    }
    else
    {
        VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        m_pItem = m_pList->Front();
    }
    return *this;
}

template<typename T, typename AllocatorT>
typename VmaList<T, AllocatorT>::const_iterator& VmaList<T, AllocatorT>::const_iterator::operator--()
{
    if (m_pItem != VMA_NULL)
    {
        m_pItem = m_pItem->pPrev;
    }
    else
    {
        VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        m_pItem = m_pList->Back();
    }
    return *this;
}

template<typename T, typename AllocatorT>
typename VmaList<T, AllocatorT>::const_reverse_iterator& VmaList<T, AllocatorT>::const_reverse_iterator::operator--()
{
    if (m_pItem != VMA_NULL)
    {
        m_pItem = m_pItem->pNext;
    }
    else
    {
        VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        m_pItem = m_pList->Back();
    }
    return *this;
}
#endif // _VMA_LIST_FUNCTIONS
#endif // _VMA_LIST

#ifndef _VMA_INTRUSIVE_LINKED_LIST
/*
Expected interface of ItemTypeTraits:
struct MyItemTypeTraits
{
    typedef MyItem ItemType;
    static ItemType* GetPrev(const ItemType* item) { return item->myPrevPtr; }
    static ItemType* GetNext(const ItemType* item) { return item->myNextPtr; }
    static ItemType*& AccessPrev(ItemType* item) { return item->myPrevPtr; }
    static ItemType*& AccessNext(ItemType* item) { return item->myNextPtr; }
};
*/
template<typename ItemTypeTraits>
class VmaIntrusiveLinkedList
{
public:
    typedef typename ItemTypeTraits::ItemType ItemType;
    static ItemType* GetPrev(const ItemType* item) { return ItemTypeTraits::GetPrev(item); }
    static ItemType* GetNext(const ItemType* item) { return ItemTypeTraits::GetNext(item); }

    // Movable, not copyable.
    VmaIntrusiveLinkedList() = default;
    VmaIntrusiveLinkedList(VmaIntrusiveLinkedList && src);
    VmaIntrusiveLinkedList(const VmaIntrusiveLinkedList&) = delete;
    VmaIntrusiveLinkedList& operator=(VmaIntrusiveLinkedList&& src);
    VmaIntrusiveLinkedList& operator=(const VmaIntrusiveLinkedList&) = delete;
    ~VmaIntrusiveLinkedList() { VMA_HEAVY_ASSERT(IsEmpty()); }

    size_t GetCount() const { return m_Count; }
    bool IsEmpty() const { return m_Count == 0; }
    ItemType* Front() { return m_Front; }
    ItemType* Back() { return m_Back; }
    const ItemType* Front() const { return m_Front; }
    const ItemType* Back() const { return m_Back; }

    void PushBack(ItemType* item);
    void PushFront(ItemType* item);
    ItemType* PopBack();
    ItemType* PopFront();

    // MyItem can be null - it means PushBack.
    void InsertBefore(ItemType* existingItem, ItemType* newItem);
    // MyItem can be null - it means PushFront.
    void InsertAfter(ItemType* existingItem, ItemType* newItem);
    void Remove(ItemType* item);
    void RemoveAll();

private:
    ItemType* m_Front = VMA_NULL;
    ItemType* m_Back = VMA_NULL;
    size_t m_Count = 0;
};

#ifndef _VMA_INTRUSIVE_LINKED_LIST_FUNCTIONS
template<typename ItemTypeTraits>
VmaIntrusiveLinkedList<ItemTypeTraits>::VmaIntrusiveLinkedList(VmaIntrusiveLinkedList&& src)
    : m_Front(src.m_Front), m_Back(src.m_Back), m_Count(src.m_Count)
{
    src.m_Front = src.m_Back = VMA_NULL;
    src.m_Count = 0;
}

template<typename ItemTypeTraits>
VmaIntrusiveLinkedList<ItemTypeTraits>& VmaIntrusiveLinkedList<ItemTypeTraits>::operator=(VmaIntrusiveLinkedList&& src)
{
    if (&src != this)
    {
        VMA_HEAVY_ASSERT(IsEmpty());
        m_Front = src.m_Front;
        m_Back = src.m_Back;
        m_Count = src.m_Count;
        src.m_Front = src.m_Back = VMA_NULL;
        src.m_Count = 0;
    }
    return *this;
}

template<typename ItemTypeTraits>
void VmaIntrusiveLinkedList<ItemTypeTraits>::PushBack(ItemType* item)
{
    VMA_HEAVY_ASSERT(ItemTypeTraits::GetPrev(item) == VMA_NULL && ItemTypeTraits::GetNext(item) == VMA_NULL);
    if (IsEmpty())
    {
        m_Front = item;
        m_Back = item;
        m_Count = 1;
    }
    else
    {
        ItemTypeTraits::AccessPrev(item) = m_Back;
        ItemTypeTraits::AccessNext(m_Back) = item;
        m_Back = item;
        ++m_Count;
    }
}

template<typename ItemTypeTraits>
void VmaIntrusiveLinkedList<ItemTypeTraits>::PushFront(ItemType* item)
{
    VMA_HEAVY_ASSERT(ItemTypeTraits::GetPrev(item) == VMA_NULL && ItemTypeTraits::GetNext(item) == VMA_NULL);
    if (IsEmpty())
    {
        m_Front = item;
        m_Back = item;
        m_Count = 1;
    }
    else
    {
        ItemTypeTraits::AccessNext(item) = m_Front;
        ItemTypeTraits::AccessPrev(m_Front) = item;
        m_Front = item;
        ++m_Count;
    }
}

template<typename ItemTypeTraits>
typename VmaIntrusiveLinkedList<ItemTypeTraits>::ItemType* VmaIntrusiveLinkedList<ItemTypeTraits>::PopBack()
{
    VMA_HEAVY_ASSERT(m_Count > 0);
    ItemType* const backItem = m_Back;
    ItemType* const prevItem = ItemTypeTraits::GetPrev(backItem);
    if (prevItem != VMA_NULL)
    {
        ItemTypeTraits::AccessNext(prevItem) = VMA_NULL;
    }
    m_Back = prevItem;
    --m_Count;
    ItemTypeTraits::AccessPrev(backItem) = VMA_NULL;
    ItemTypeTraits::AccessNext(backItem) = VMA_NULL;
    return backItem;
}

template<typename ItemTypeTraits>
typename VmaIntrusiveLinkedList<ItemTypeTraits>::ItemType* VmaIntrusiveLinkedList<ItemTypeTraits>::PopFront()
{
    VMA_HEAVY_ASSERT(m_Count > 0);
    ItemType* const frontItem = m_Front;
    ItemType* const nextItem = ItemTypeTraits::GetNext(frontItem);
    if (nextItem != VMA_NULL)
    {
        ItemTypeTraits::AccessPrev(nextItem) = VMA_NULL;
    }
    m_Front = nextItem;
    --m_Count;
    ItemTypeTraits::AccessPrev(frontItem) = VMA_NULL;
    ItemTypeTraits::AccessNext(frontItem) = VMA_NULL;
    return frontItem;
}

template<typename ItemTypeTraits>
void VmaIntrusiveLinkedList<ItemTypeTraits>::InsertBefore(ItemType* existingItem, ItemType* newItem)
{
    VMA_HEAVY_ASSERT(newItem != VMA_NULL && ItemTypeTraits::GetPrev(newItem) == VMA_NULL && ItemTypeTraits::GetNext(newItem) == VMA_NULL);
    if (existingItem != VMA_NULL)
    {
        ItemType* const prevItem = ItemTypeTraits::GetPrev(existingItem);
        ItemTypeTraits::AccessPrev(newItem) = prevItem;
        ItemTypeTraits::AccessNext(newItem) = existingItem;
        ItemTypeTraits::AccessPrev(existingItem) = newItem;
        if (prevItem != VMA_NULL)
        {
            ItemTypeTraits::AccessNext(prevItem) = newItem;
        }
        else
        {
            VMA_HEAVY_ASSERT(m_Front == existingItem);
            m_Front = newItem;
        }
        ++m_Count;
    }
    else
        PushBack(newItem);
}

template<typename ItemTypeTraits>
void VmaIntrusiveLinkedList<ItemTypeTraits>::InsertAfter(ItemType* existingItem, ItemType* newItem)
{
    VMA_HEAVY_ASSERT(newItem != VMA_NULL && ItemTypeTraits::GetPrev(newItem) == VMA_NULL && ItemTypeTraits::GetNext(newItem) == VMA_NULL);
    if (existingItem != VMA_NULL)
    {
        ItemType* const nextItem = ItemTypeTraits::GetNext(existingItem);
        ItemTypeTraits::AccessNext(newItem) = nextItem;
        ItemTypeTraits::AccessPrev(newItem) = existingItem;
        ItemTypeTraits::AccessNext(existingItem) = newItem;
        if (nextItem != VMA_NULL)
        {
            ItemTypeTraits::AccessPrev(nextItem) = newItem;
        }
        else
        {
            VMA_HEAVY_ASSERT(m_Back == existingItem);
            m_Back = newItem;
        }
        ++m_Count;
    }
    else
        return PushFront(newItem);
}

template<typename ItemTypeTraits>
void VmaIntrusiveLinkedList<ItemTypeTraits>::Remove(ItemType* item)
{
    VMA_HEAVY_ASSERT(item != VMA_NULL && m_Count > 0);
    if (ItemTypeTraits::GetPrev(item) != VMA_NULL)
    {
        ItemTypeTraits::AccessNext(ItemTypeTraits::AccessPrev(item)) = ItemTypeTraits::GetNext(item);
    }
    else
    {
        VMA_HEAVY_ASSERT(m_Front == item);
        m_Front = ItemTypeTraits::GetNext(item);
    }

    if (ItemTypeTraits::GetNext(item) != VMA_NULL)
    {
        ItemTypeTraits::AccessPrev(ItemTypeTraits::AccessNext(item)) = ItemTypeTraits::GetPrev(item);
    }
    else
    {
        VMA_HEAVY_ASSERT(m_Back == item);
        m_Back = ItemTypeTraits::GetPrev(item);
    }
    ItemTypeTraits::AccessPrev(item) = VMA_NULL;
    ItemTypeTraits::AccessNext(item) = VMA_NULL;
    --m_Count;
}

template<typename ItemTypeTraits>
void VmaIntrusiveLinkedList<ItemTypeTraits>::RemoveAll()
{
    if (!IsEmpty())
    {
        ItemType* item = m_Back;
        while (item != VMA_NULL)
        {
            ItemType* const prevItem = ItemTypeTraits::AccessPrev(item);
            ItemTypeTraits::AccessPrev(item) = VMA_NULL;
            ItemTypeTraits::AccessNext(item) = VMA_NULL;
            item = prevItem;
        }
        m_Front = VMA_NULL;
        m_Back = VMA_NULL;
        m_Count = 0;
    }
}
#endif // _VMA_INTRUSIVE_LINKED_LIST_FUNCTIONS
#endif // _VMA_INTRUSIVE_LINKED_LIST

// Unused in this version.
#if 0

#ifndef _VMA_PAIR
template<typename T1, typename T2>
struct VmaPair
{
    T1 first;
    T2 second;

    VmaPair() : first(), second() {}
    VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) {}
};

template<typename FirstT, typename SecondT>
struct VmaPairFirstLess
{
    bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
    {
        return lhs.first < rhs.first;
    }
    bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
    {
        return lhs.first < rhsFirst;
    }
};
#endif // _VMA_PAIR

#ifndef _VMA_MAP
/* Class compatible with subset of interface of std::unordered_map.
KeyT, ValueT must be POD because they will be stored in VmaVector.
*/
template<typename KeyT, typename ValueT>
class VmaMap
{
public:
    typedef VmaPair<KeyT, ValueT> PairType;
    typedef PairType* iterator;

    VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) {}

    iterator begin() { return m_Vector.begin(); }
    iterator end() { return m_Vector.end(); }
    size_t size() { return m_Vector.size(); }

    void insert(const PairType& pair);
    iterator find(const KeyT& key);
    void erase(iterator it);

private:
    VmaVector< PairType, VmaStlAllocator<PairType>> m_Vector;
};

#ifndef _VMA_MAP_FUNCTIONS
template<typename KeyT, typename ValueT>
void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
{
    const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        m_Vector.data(),
        m_Vector.data() + m_Vector.size(),
        pair,
        VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
    VmaVectorInsert(m_Vector, indexToInsert, pair);
}

template<typename KeyT, typename ValueT>
VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
{
    PairType* it = VmaBinaryFindFirstNotLess(
        m_Vector.data(),
        m_Vector.data() + m_Vector.size(),
        key,
        VmaPairFirstLess<KeyT, ValueT>());
    if ((it != m_Vector.end()) && (it->first == key))
    {
        return it;
    }
    else
    {
        return m_Vector.end();
    }
}

template<typename KeyT, typename ValueT>
void VmaMap<KeyT, ValueT>::erase(iterator it)
{
    VmaVectorRemove(m_Vector, it - m_Vector.begin());
}
#endif // _VMA_MAP_FUNCTIONS
#endif // _VMA_MAP

#endif // #if 0

#if !defined(_VMA_STRING_BUILDER) && VMA_STATS_STRING_ENABLED
class VmaStringBuilder
{
public:
    VmaStringBuilder(const VkAllocationCallbacks* allocationCallbacks) : m_Data(VmaStlAllocator<char>(allocationCallbacks)) {}
    ~VmaStringBuilder() = default;

    size_t GetLength() const { return m_Data.size(); }
    const char* GetData() const { return m_Data.data(); }
    void AddNewLine() { Add('\n'); }
    void Add(char ch) { m_Data.push_back(ch); }

    void Add(const char* pStr);
    void AddNumber(uint32_t num);
    void AddNumber(uint64_t num);
    void AddPointer(const void* ptr);

private:
    VmaVector<char, VmaStlAllocator<char>> m_Data;
};

#ifndef _VMA_STRING_BUILDER_FUNCTIONS
void VmaStringBuilder::Add(const char* pStr)
{
    const size_t strLen = strlen(pStr);
    if (strLen > 0)
    {
        const size_t oldCount = m_Data.size();
        m_Data.resize(oldCount + strLen);
        memcpy(m_Data.data() + oldCount, pStr, strLen);
    }
}

void VmaStringBuilder::AddNumber(uint32_t num)
{
    char buf[11];
    buf[10] = '\0';
    char* p = &buf[10];
    do
    {
        *--p = '0' + (num % 10);
        num /= 10;
    } while (num);
    Add(p);
}

void VmaStringBuilder::AddNumber(uint64_t num)
{
    char buf[21];
    buf[20] = '\0';
    char* p = &buf[20];
    do
    {
        *--p = '0' + (num % 10);
        num /= 10;
    } while (num);
    Add(p);
}

void VmaStringBuilder::AddPointer(const void* ptr)
{
    char buf[21];
    VmaPtrToStr(buf, sizeof(buf), ptr);
    Add(buf);
}
#endif //_VMA_STRING_BUILDER_FUNCTIONS
#endif // _VMA_STRING_BUILDER

#if !defined(_VMA_JSON_WRITER) && VMA_STATS_STRING_ENABLED
/*
Allows to conveniently build a correct JSON document to be written to the
VmaStringBuilder passed to the constructor.
*/
class VmaJsonWriter
{
    VMA_CLASS_NO_COPY(VmaJsonWriter)
public:
    // sb - string builder to write the document to. Must remain alive for the whole lifetime of this object.
    VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
    ~VmaJsonWriter();

    // Begins object by writing "{".
    // Inside an object, you must call pairs of WriteString and a value, e.g.:
    // j.BeginObject(true); j.WriteString("A"); j.WriteNumber(1); j.WriteString("B"); j.WriteNumber(2); j.EndObject();
    // Will write: { "A": 1, "B": 2 }
    void BeginObject(bool singleLine = false);
    // Ends object by writing "}".
    void EndObject();

    // Begins array by writing "[".
    // Inside an array, you can write a sequence of any values.
    void BeginArray(bool singleLine = false);
    // Ends array by writing "[".
    void EndArray();

    // Writes a string value inside "".
    // pStr can contain any ANSI characters, including '"', new line etc. - they will be properly escaped.
    void WriteString(const char* pStr);

    // Begins writing a string value.
    // Call BeginString, ContinueString, ContinueString, ..., EndString instead of
    // WriteString to conveniently build the string content incrementally, made of
    // parts including numbers.
    void BeginString(const char* pStr = VMA_NULL);
    // Posts next part of an open string.
    void ContinueString(const char* pStr);
    // Posts next part of an open string. The number is converted to decimal characters.
    void ContinueString(uint32_t n);
    void ContinueString(uint64_t n);
    // Posts next part of an open string. Pointer value is converted to characters
    // using "%p" formatting - shown as hexadecimal number, e.g.: 000000081276Ad00
    void ContinueString_Pointer(const void* ptr);
    // Ends writing a string value by writing '"'.
    void EndString(const char* pStr = VMA_NULL);

    // Writes a number value.
    void WriteNumber(uint32_t n);
    void WriteNumber(uint64_t n);
    // Writes a boolean value - false or true.
    void WriteBool(bool b);
    // Writes a null value.
    void WriteNull();

private:
    enum COLLECTION_TYPE
    {
        COLLECTION_TYPE_OBJECT,
        COLLECTION_TYPE_ARRAY,
    };
    struct StackItem
    {
        COLLECTION_TYPE type;
        uint32_t valueCount;
        bool singleLineMode;
    };

    static const char* const INDENT;

    VmaStringBuilder& m_SB;
    VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
    bool m_InsideString;

    void BeginValue(bool isString);
    void WriteIndent(bool oneLess = false);
};
const char* const VmaJsonWriter::INDENT = "  ";

#ifndef _VMA_JSON_WRITER_FUNCTIONS
VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb)
    : m_SB(sb),
    m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
    m_InsideString(false) {}

VmaJsonWriter::~VmaJsonWriter()
{
    VMA_ASSERT(!m_InsideString);
    VMA_ASSERT(m_Stack.empty());
}

void VmaJsonWriter::BeginObject(bool singleLine)
{
    VMA_ASSERT(!m_InsideString);

    BeginValue(false);
    m_SB.Add('{');

    StackItem item;
    item.type = COLLECTION_TYPE_OBJECT;
    item.valueCount = 0;
    item.singleLineMode = singleLine;
    m_Stack.push_back(item);
}

void VmaJsonWriter::EndObject()
{
    VMA_ASSERT(!m_InsideString);

    WriteIndent(true);
    m_SB.Add('}');

    VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
    m_Stack.pop_back();
}

void VmaJsonWriter::BeginArray(bool singleLine)
{
    VMA_ASSERT(!m_InsideString);

    BeginValue(false);
    m_SB.Add('[');

    StackItem item;
    item.type = COLLECTION_TYPE_ARRAY;
    item.valueCount = 0;
    item.singleLineMode = singleLine;
    m_Stack.push_back(item);
}

void VmaJsonWriter::EndArray()
{
    VMA_ASSERT(!m_InsideString);

    WriteIndent(true);
    m_SB.Add(']');

    VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
    m_Stack.pop_back();
}

void VmaJsonWriter::WriteString(const char* pStr)
{
    BeginString(pStr);
    EndString();
}

void VmaJsonWriter::BeginString(const char* pStr)
{
    VMA_ASSERT(!m_InsideString);

    BeginValue(true);
    m_SB.Add('"');
    m_InsideString = true;
    if (pStr != VMA_NULL && pStr[0] != '\0')
    {
        ContinueString(pStr);
    }
}

void VmaJsonWriter::ContinueString(const char* pStr)
{
    VMA_ASSERT(m_InsideString);

    const size_t strLen = strlen(pStr);
    for (size_t i = 0; i < strLen; ++i)
    {
        char ch = pStr[i];
        if (ch == '\\')
        {
            m_SB.Add("\\\\");
        }
        else if (ch == '"')
        {
            m_SB.Add("\\\"");
        }
        else if (ch >= 32)
        {
            m_SB.Add(ch);
        }
        else switch (ch)
        {
        case '\b':
            m_SB.Add("\\b");
            break;
        case '\f':
            m_SB.Add("\\f");
            break;
        case '\n':
            m_SB.Add("\\n");
            break;
        case '\r':
            m_SB.Add("\\r");
            break;
        case '\t':
            m_SB.Add("\\t");
            break;
        default:
            VMA_ASSERT(0 && "Character not currently supported.");
            break;
        }
    }
}

void VmaJsonWriter::ContinueString(uint32_t n)
{
    VMA_ASSERT(m_InsideString);
    m_SB.AddNumber(n);
}

void VmaJsonWriter::ContinueString(uint64_t n)
{
    VMA_ASSERT(m_InsideString);
    m_SB.AddNumber(n);
}

void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
{
    VMA_ASSERT(m_InsideString);
    m_SB.AddPointer(ptr);
}

void VmaJsonWriter::EndString(const char* pStr)
{
    VMA_ASSERT(m_InsideString);
    if (pStr != VMA_NULL && pStr[0] != '\0')
    {
        ContinueString(pStr);
    }
    m_SB.Add('"');
    m_InsideString = false;
}

void VmaJsonWriter::WriteNumber(uint32_t n)
{
    VMA_ASSERT(!m_InsideString);
    BeginValue(false);
    m_SB.AddNumber(n);
}

void VmaJsonWriter::WriteNumber(uint64_t n)
{
    VMA_ASSERT(!m_InsideString);
    BeginValue(false);
    m_SB.AddNumber(n);
}

void VmaJsonWriter::WriteBool(bool b)
{
    VMA_ASSERT(!m_InsideString);
    BeginValue(false);
    m_SB.Add(b ? "true" : "false");
}

void VmaJsonWriter::WriteNull()
{
    VMA_ASSERT(!m_InsideString);
    BeginValue(false);
    m_SB.Add("null");
}

void VmaJsonWriter::BeginValue(bool isString)
{
    if (!m_Stack.empty())
    {
        StackItem& currItem = m_Stack.back();
        if (currItem.type == COLLECTION_TYPE_OBJECT &&
            currItem.valueCount % 2 == 0)
        {
            VMA_ASSERT(isString);
        }

        if (currItem.type == COLLECTION_TYPE_OBJECT &&
            currItem.valueCount % 2 != 0)
        {
            m_SB.Add(": ");
        }
        else if (currItem.valueCount > 0)
        {
            m_SB.Add(", ");
            WriteIndent();
        }
        else
        {
            WriteIndent();
        }
        ++currItem.valueCount;
    }
}

void VmaJsonWriter::WriteIndent(bool oneLess)
{
    if (!m_Stack.empty() && !m_Stack.back().singleLineMode)
    {
        m_SB.AddNewLine();

        size_t count = m_Stack.size();
        if (count > 0 && oneLess)
        {
            --count;
        }
        for (size_t i = 0; i < count; ++i)
        {
            m_SB.Add(INDENT);
        }
    }
}
#endif // _VMA_JSON_WRITER_FUNCTIONS

static void VmaPrintDetailedStatistics(VmaJsonWriter& json, const VmaDetailedStatistics& stat)
{
    json.BeginObject();

    json.WriteString("BlockCount");
    json.WriteNumber(stat.statistics.blockCount);
    json.WriteString("BlockBytes");
    json.WriteNumber(stat.statistics.blockBytes);
    json.WriteString("AllocationCount");
    json.WriteNumber(stat.statistics.allocationCount);
    json.WriteString("AllocationBytes");
    json.WriteNumber(stat.statistics.allocationBytes);
    json.WriteString("UnusedRangeCount");
    json.WriteNumber(stat.unusedRangeCount);

    if (stat.statistics.allocationCount > 1)
    {
        json.WriteString("AllocationSizeMin");
        json.WriteNumber(stat.allocationSizeMin);
        json.WriteString("AllocationSizeMax");
        json.WriteNumber(stat.allocationSizeMax);
    }
    if (stat.unusedRangeCount > 1)
    {
        json.WriteString("UnusedRangeSizeMin");
        json.WriteNumber(stat.unusedRangeSizeMin);
        json.WriteString("UnusedRangeSizeMax");
        json.WriteNumber(stat.unusedRangeSizeMax);
    }
    json.EndObject();
}
#endif // _VMA_JSON_WRITER

#ifndef _VMA_MAPPING_HYSTERESIS

class VmaMappingHysteresis
{
    VMA_CLASS_NO_COPY(VmaMappingHysteresis)
public:
    VmaMappingHysteresis() = default;

    uint32_t GetExtraMapping() const { return m_ExtraMapping; }

    // Call when Map was called.
    // Returns true if switched to extra +1 mapping reference count.
    bool PostMap()
    {
#if VMA_MAPPING_HYSTERESIS_ENABLED
        if(m_ExtraMapping == 0)
        {
            ++m_MajorCounter;
            if(m_MajorCounter >= COUNTER_MIN_EXTRA_MAPPING)
            {
                m_ExtraMapping = 1;
                m_MajorCounter = 0;
                m_MinorCounter = 0;
                return true;
            }
        }
        else // m_ExtraMapping == 1
            PostMinorCounter();
#endif // #if VMA_MAPPING_HYSTERESIS_ENABLED
        return false;
    }

    // Call when Unmap was called.
    void PostUnmap()
    {
#if VMA_MAPPING_HYSTERESIS_ENABLED
        if(m_ExtraMapping == 0)
            ++m_MajorCounter;
        else // m_ExtraMapping == 1
            PostMinorCounter();
#endif // #if VMA_MAPPING_HYSTERESIS_ENABLED
    }

    // Call when allocation was made from the memory block.
    void PostAlloc()
    {
#if VMA_MAPPING_HYSTERESIS_ENABLED
        if(m_ExtraMapping == 1)
            ++m_MajorCounter;
        else // m_ExtraMapping == 0
            PostMinorCounter();
#endif // #if VMA_MAPPING_HYSTERESIS_ENABLED
    }

    // Call when allocation was freed from the memory block.
    // Returns true if switched to extra -1 mapping reference count.
    bool PostFree()
    {
#if VMA_MAPPING_HYSTERESIS_ENABLED
        if(m_ExtraMapping == 1)
        {
            ++m_MajorCounter;
            if(m_MajorCounter >= COUNTER_MIN_EXTRA_MAPPING &&
                m_MajorCounter > m_MinorCounter + 1)
            {
                m_ExtraMapping = 0;
                m_MajorCounter = 0;
                m_MinorCounter = 0;
                return true;
            }
        }
        else // m_ExtraMapping == 0
            PostMinorCounter();
#endif // #if VMA_MAPPING_HYSTERESIS_ENABLED
        return false;
    }

private:
    static const int32_t COUNTER_MIN_EXTRA_MAPPING = 7;

    uint32_t m_MinorCounter = 0;
    uint32_t m_MajorCounter = 0;
    uint32_t m_ExtraMapping = 0; // 0 or 1.

    void PostMinorCounter()
    {
        if(m_MinorCounter < m_MajorCounter)
        {
            ++m_MinorCounter;
        }
        else if(m_MajorCounter > 0)
        {
            --m_MajorCounter;
            --m_MinorCounter;
        }
    }
};

#endif // _VMA_MAPPING_HYSTERESIS

#ifndef _VMA_DEVICE_MEMORY_BLOCK
/*
Represents a single block of device memory (`VkDeviceMemory`) with all the
data about its regions (aka suballocations, #VmaAllocation), assigned and free.

Thread-safety:
- Access to m_pMetadata must be externally synchronized.
- Map, Unmap, Bind* are synchronized internally.
*/
class VmaDeviceMemoryBlock
{
    VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
public:
    VmaBlockMetadata* m_pMetadata;

    VmaDeviceMemoryBlock(VmaAllocator hAllocator);
    ~VmaDeviceMemoryBlock();

    // Always call after construction.
    void Init(
        VmaAllocator hAllocator,
        VmaPool hParentPool,
        uint32_t newMemoryTypeIndex,
        VkDeviceMemory newMemory,
        VkDeviceSize newSize,
        uint32_t id,
        uint32_t algorithm,
        VkDeviceSize bufferImageGranularity);
    // Always call before destruction.
    void Destroy(VmaAllocator allocator);

    VmaPool GetParentPool() const { return m_hParentPool; }
    VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
    uint32_t GetId() const { return m_Id; }
    void* GetMappedData() const { return m_pMappedData; }
    uint32_t GetMapRefCount() const { return m_MapCount; }

    // Call when allocation/free was made from m_pMetadata.
    // Used for m_MappingHysteresis.
    void PostAlloc(VmaAllocator hAllocator);
    void PostFree(VmaAllocator hAllocator);

    // Validates all data structures inside this object. If not valid, returns false.
    bool Validate() const;
    VkResult CheckCorruption(VmaAllocator hAllocator);

    // ppData can be null.
    VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
    void Unmap(VmaAllocator hAllocator, uint32_t count);

    VkResult WriteMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
    VkResult ValidateMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);

    VkResult BindBufferMemory(
        const VmaAllocator hAllocator,
        const VmaAllocation hAllocation,
        VkDeviceSize allocationLocalOffset,
        VkBuffer hBuffer,
        const void* pNext);
    VkResult BindImageMemory(
        const VmaAllocator hAllocator,
        const VmaAllocation hAllocation,
        VkDeviceSize allocationLocalOffset,
        VkImage hImage,
        const void* pNext);

private:
    VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
    uint32_t m_MemoryTypeIndex;
    uint32_t m_Id;
    VkDeviceMemory m_hMemory;

    /*
    Protects access to m_hMemory so it is not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
    Also protects m_MapCount, m_pMappedData.
    Allocations, deallocations, any change in m_pMetadata is protected by parent's VmaBlockVector::m_Mutex.
    */
    VMA_MUTEX m_MapAndBindMutex;
    VmaMappingHysteresis m_MappingHysteresis;
    uint32_t m_MapCount;
    void* m_pMappedData;
};
#endif // _VMA_DEVICE_MEMORY_BLOCK

#ifndef _VMA_ALLOCATION_T
struct VmaAllocation_T
{
    friend struct VmaDedicatedAllocationListItemTraits;

    enum FLAGS
    {
        FLAG_PERSISTENT_MAP   = 0x01,
        FLAG_MAPPING_ALLOWED  = 0x02,
    };

public:
    enum ALLOCATION_TYPE
    {
        ALLOCATION_TYPE_NONE,
        ALLOCATION_TYPE_BLOCK,
        ALLOCATION_TYPE_DEDICATED,
    };

    // This struct is allocated using VmaPoolAllocator.
    VmaAllocation_T(bool mappingAllowed);
    ~VmaAllocation_T();

    void InitBlockAllocation(
        VmaDeviceMemoryBlock* block,
        VmaAllocHandle allocHandle,
        VkDeviceSize alignment,
        VkDeviceSize size,
        uint32_t memoryTypeIndex,
        VmaSuballocationType suballocationType,
        bool mapped);
    // pMappedData not null means allocation is created with MAPPED flag.
    void InitDedicatedAllocation(
        VmaPool hParentPool,
        uint32_t memoryTypeIndex,
        VkDeviceMemory hMemory,
        VmaSuballocationType suballocationType,
        void* pMappedData,
        VkDeviceSize size);

    ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
    VkDeviceSize GetAlignment() const { return m_Alignment; }
    VkDeviceSize GetSize() const { return m_Size; }
    void* GetUserData() const { return m_pUserData; }
    const char* GetName() const { return m_pName; }
    VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }

    VmaDeviceMemoryBlock* GetBlock() const { VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK); return m_BlockAllocation.m_Block; }
    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
    bool IsPersistentMap() const { return (m_Flags & FLAG_PERSISTENT_MAP) != 0; }
    bool IsMappingAllowed() const { return (m_Flags & FLAG_MAPPING_ALLOWED) != 0; }

    void SetUserData(VmaAllocator hAllocator, void* pUserData) { m_pUserData = pUserData; }
    void SetName(VmaAllocator hAllocator, const char* pName);
    void FreeName(VmaAllocator hAllocator);
    uint8_t SwapBlockAllocation(VmaAllocator hAllocator, VmaAllocation allocation);
    VmaAllocHandle GetAllocHandle() const;
    VkDeviceSize GetOffset() const;
    VmaPool GetParentPool() const;
    VkDeviceMemory GetMemory() const;
    void* GetMappedData() const;

    void BlockAllocMap();
    void BlockAllocUnmap();
    VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
    void DedicatedAllocUnmap(VmaAllocator hAllocator);

#if VMA_STATS_STRING_ENABLED
    uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }

    void InitBufferImageUsage(uint32_t bufferImageUsage);
    void PrintParameters(class VmaJsonWriter& json) const;
#endif

private:
    // Allocation out of VmaDeviceMemoryBlock.
    struct BlockAllocation
    {
        VmaDeviceMemoryBlock* m_Block;
        VmaAllocHandle m_AllocHandle;
    };
    // Allocation for an object that has its own private VkDeviceMemory.
    struct DedicatedAllocation
    {
        VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
        VkDeviceMemory m_hMemory;
        void* m_pMappedData; // Not null means memory is mapped.
        VmaAllocation_T* m_Prev;
        VmaAllocation_T* m_Next;
    };
    union
    {
        // Allocation out of VmaDeviceMemoryBlock.
        BlockAllocation m_BlockAllocation;
        // Allocation for an object that has its own private VkDeviceMemory.
        DedicatedAllocation m_DedicatedAllocation;
    };

    VkDeviceSize m_Alignment;
    VkDeviceSize m_Size;
    void* m_pUserData;
    char* m_pName;
    uint32_t m_MemoryTypeIndex;
    uint8_t m_Type; // ALLOCATION_TYPE
    uint8_t m_SuballocationType; // VmaSuballocationType
    // Reference counter for vmaMapMemory()/vmaUnmapMemory().
    uint8_t m_MapCount;
    uint8_t m_Flags; // enum FLAGS
#if VMA_STATS_STRING_ENABLED
    uint32_t m_BufferImageUsage; // 0 if unknown.
#endif
};
#endif // _VMA_ALLOCATION_T

#ifndef _VMA_DEDICATED_ALLOCATION_LIST_ITEM_TRAITS
struct VmaDedicatedAllocationListItemTraits
{
    typedef VmaAllocation_T ItemType;

    static ItemType* GetPrev(const ItemType* item)
    {
        VMA_HEAVY_ASSERT(item->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
        return item->m_DedicatedAllocation.m_Prev;
    }
    static ItemType* GetNext(const ItemType* item)
    {
        VMA_HEAVY_ASSERT(item->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
        return item->m_DedicatedAllocation.m_Next;
    }
    static ItemType*& AccessPrev(ItemType* item)
    {
        VMA_HEAVY_ASSERT(item->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
        return item->m_DedicatedAllocation.m_Prev;
    }
    static ItemType*& AccessNext(ItemType* item)
    {
        VMA_HEAVY_ASSERT(item->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
        return item->m_DedicatedAllocation.m_Next;
    }
};
#endif // _VMA_DEDICATED_ALLOCATION_LIST_ITEM_TRAITS

#ifndef _VMA_DEDICATED_ALLOCATION_LIST
/*
Stores linked list of VmaAllocation_T objects.
Thread-safe, synchronized internally.
*/
class VmaDedicatedAllocationList
{
public:
    VmaDedicatedAllocationList() {}
    ~VmaDedicatedAllocationList();

    void Init(bool useMutex) { m_UseMutex = useMutex; }
    bool Validate();

    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats);
    void AddStatistics(VmaStatistics& inoutStats);
#if VMA_STATS_STRING_ENABLED
    // Writes JSON array with the list of allocations.
    void BuildStatsString(VmaJsonWriter& json);
#endif

    bool IsEmpty();
    void Register(VmaAllocation alloc);
    void Unregister(VmaAllocation alloc);

private:
    typedef VmaIntrusiveLinkedList<VmaDedicatedAllocationListItemTraits> DedicatedAllocationLinkedList;

    bool m_UseMutex = true;
    VMA_RW_MUTEX m_Mutex;
    DedicatedAllocationLinkedList m_AllocationList;
};

#ifndef _VMA_DEDICATED_ALLOCATION_LIST_FUNCTIONS

VmaDedicatedAllocationList::~VmaDedicatedAllocationList()
{
    VMA_HEAVY_ASSERT(Validate());

    if (!m_AllocationList.IsEmpty())
    {
        VMA_ASSERT(false && "Unfreed dedicated allocations found!");
    }
}

bool VmaDedicatedAllocationList::Validate()
{
    const size_t declaredCount = m_AllocationList.GetCount();
    size_t actualCount = 0;
    VmaMutexLockRead lock(m_Mutex, m_UseMutex);
    for (VmaAllocation alloc = m_AllocationList.Front();
        alloc != VMA_NULL; alloc = m_AllocationList.GetNext(alloc))
    {
        ++actualCount;
    }
    VMA_VALIDATE(actualCount == declaredCount);

    return true;
}

void VmaDedicatedAllocationList::AddDetailedStatistics(VmaDetailedStatistics& inoutStats)
{
    for(auto* item = m_AllocationList.Front(); item != nullptr; item = DedicatedAllocationLinkedList::GetNext(item))
    {
        const VkDeviceSize size = item->GetSize();
        inoutStats.statistics.blockCount++;
        inoutStats.statistics.blockBytes += size;
        VmaAddDetailedStatisticsAllocation(inoutStats, item->GetSize());
    }
}

void VmaDedicatedAllocationList::AddStatistics(VmaStatistics& inoutStats)
{
    VmaMutexLockRead lock(m_Mutex, m_UseMutex);

    const uint32_t allocCount = (uint32_t)m_AllocationList.GetCount();
    inoutStats.blockCount += allocCount;
    inoutStats.allocationCount += allocCount;

    for(auto* item = m_AllocationList.Front(); item != nullptr; item = DedicatedAllocationLinkedList::GetNext(item))
    {
        const VkDeviceSize size = item->GetSize();
        inoutStats.blockBytes += size;
        inoutStats.allocationBytes += size;
    }
}

#if VMA_STATS_STRING_ENABLED
void VmaDedicatedAllocationList::BuildStatsString(VmaJsonWriter& json)
{
    VmaMutexLockRead lock(m_Mutex, m_UseMutex);
    json.BeginArray();
    for (VmaAllocation alloc = m_AllocationList.Front();
        alloc != VMA_NULL; alloc = m_AllocationList.GetNext(alloc))
    {
        json.BeginObject(true);
        alloc->PrintParameters(json);
        json.EndObject();
    }
    json.EndArray();
}
#endif // VMA_STATS_STRING_ENABLED

bool VmaDedicatedAllocationList::IsEmpty()
{
    VmaMutexLockRead lock(m_Mutex, m_UseMutex);
    return m_AllocationList.IsEmpty();
}

void VmaDedicatedAllocationList::Register(VmaAllocation alloc)
{
    VmaMutexLockWrite lock(m_Mutex, m_UseMutex);
    m_AllocationList.PushBack(alloc);
}

void VmaDedicatedAllocationList::Unregister(VmaAllocation alloc)
{
    VmaMutexLockWrite lock(m_Mutex, m_UseMutex);
    m_AllocationList.Remove(alloc);
}
#endif // _VMA_DEDICATED_ALLOCATION_LIST_FUNCTIONS
#endif // _VMA_DEDICATED_ALLOCATION_LIST

#ifndef _VMA_SUBALLOCATION
/*
Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
allocated memory block or free.
*/
struct VmaSuballocation
{
    VkDeviceSize offset;
    VkDeviceSize size;
    void* userData;
    VmaSuballocationType type;
};

// Comparator for offsets.
struct VmaSuballocationOffsetLess
{
    bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
    {
        return lhs.offset < rhs.offset;
    }
};

struct VmaSuballocationOffsetGreater
{
    bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
    {
        return lhs.offset > rhs.offset;
    }
};

struct VmaSuballocationItemSizeLess
{
    bool operator()(const VmaSuballocationList::iterator lhs,
        const VmaSuballocationList::iterator rhs) const
    {
        return lhs->size < rhs->size;
    }

    bool operator()(const VmaSuballocationList::iterator lhs,
        VkDeviceSize rhsSize) const
    {
        return lhs->size < rhsSize;
    }
};
#endif // _VMA_SUBALLOCATION

#ifndef _VMA_ALLOCATION_REQUEST
/*
Parameters of planned allocation inside a VmaDeviceMemoryBlock.
item points to a FREE suballocation.
*/
struct VmaAllocationRequest
{
    VmaAllocHandle allocHandle;
    VkDeviceSize size;
    VmaSuballocationList::iterator item;
    void* customData;
    uint64_t algorithmData;
    VmaAllocationRequestType type;
};
#endif // _VMA_ALLOCATION_REQUEST

#ifndef _VMA_BLOCK_METADATA
/*
Data structure used for bookkeeping of allocations and unused ranges of memory
in a single VkDeviceMemory block.
*/
class VmaBlockMetadata
{
public:
    // pAllocationCallbacks, if not null, must be owned externally - alive and unchanged for the whole lifetime of this object.
    VmaBlockMetadata(const VkAllocationCallbacks* pAllocationCallbacks,
        VkDeviceSize bufferImageGranularity, bool isVirtual);
    virtual ~VmaBlockMetadata() = default;

    virtual void Init(VkDeviceSize size) { m_Size = size; }
    bool IsVirtual() const { return m_IsVirtual; }
    VkDeviceSize GetSize() const { return m_Size; }

    // Validates all data structures inside this object. If not valid, returns false.
    virtual bool Validate() const = 0;
    virtual size_t GetAllocationCount() const = 0;
    virtual size_t GetFreeRegionsCount() const = 0;
    virtual VkDeviceSize GetSumFreeSize() const = 0;
    // Returns true if this block is empty - contains only single free suballocation.
    virtual bool IsEmpty() const = 0;
    virtual void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) = 0;
    virtual VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const = 0;
    virtual void* GetAllocationUserData(VmaAllocHandle allocHandle) const = 0;

    virtual VmaAllocHandle GetAllocationListBegin() const = 0;
    virtual VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const = 0;
    virtual VkDeviceSize GetNextFreeRegionSize(VmaAllocHandle alloc) const = 0;

    // Shouldn't modify blockCount.
    virtual void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const = 0;
    virtual void AddStatistics(VmaStatistics& inoutStats) const = 0;

#if VMA_STATS_STRING_ENABLED
    virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
#endif

    // Tries to find a place for suballocation with given parameters inside this block.
    // If succeeded, fills pAllocationRequest and returns true.
    // If failed, returns false.
    virtual bool CreateAllocationRequest(
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        bool upperAddress,
        VmaSuballocationType allocType,
        // Always one of VMA_ALLOCATION_CREATE_STRATEGY_* or VMA_ALLOCATION_INTERNAL_STRATEGY_* flags.
        uint32_t strategy,
        VmaAllocationRequest* pAllocationRequest) = 0;

    virtual VkResult CheckCorruption(const void* pBlockData) = 0;

    // Makes actual allocation based on request. Request must already be checked and valid.
    virtual void Alloc(
        const VmaAllocationRequest& request,
        VmaSuballocationType type,
        void* userData) = 0;

    // Frees suballocation assigned to given memory region.
    virtual void Free(VmaAllocHandle allocHandle) = 0;

    // Frees all allocations.
    // Careful! Don't call it if there are VmaAllocation objects owned by userData of cleared allocations!
    virtual void Clear() = 0;

    virtual void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) = 0;
    virtual void DebugLogAllAllocations() const = 0;

protected:
    const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; }
    VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
    VkDeviceSize GetDebugMargin() const { return IsVirtual() ? 0 : VMA_DEBUG_MARGIN; }

    void DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size, void* userData) const;
#if VMA_STATS_STRING_ENABLED
    // mapRefCount == UINT32_MAX means unspecified.
    void PrintDetailedMap_Begin(class VmaJsonWriter& json,
        VkDeviceSize unusedBytes,
        size_t allocationCount,
        size_t unusedRangeCount) const;
    void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        VkDeviceSize offset, VkDeviceSize size, void* userData) const;
    void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        VkDeviceSize offset,
        VkDeviceSize size) const;
    void PrintDetailedMap_End(class VmaJsonWriter& json) const;
#endif

private:
    VkDeviceSize m_Size;
    const VkAllocationCallbacks* m_pAllocationCallbacks;
    const VkDeviceSize m_BufferImageGranularity;
    const bool m_IsVirtual;
};

#ifndef _VMA_BLOCK_METADATA_FUNCTIONS
VmaBlockMetadata::VmaBlockMetadata(const VkAllocationCallbacks* pAllocationCallbacks,
    VkDeviceSize bufferImageGranularity, bool isVirtual)
    : m_Size(0),
    m_pAllocationCallbacks(pAllocationCallbacks),
    m_BufferImageGranularity(bufferImageGranularity),
    m_IsVirtual(isVirtual) {}

void VmaBlockMetadata::DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size, void* userData) const
{
    if (IsVirtual())
    {
        VMA_DEBUG_LOG("UNFREED VIRTUAL ALLOCATION; Offset: %llu; Size: %llu; UserData: %p", offset, size, userData);
    }
    else
    {
        VMA_ASSERT(userData != VMA_NULL);
        VmaAllocation allocation = reinterpret_cast<VmaAllocation>(userData);

        userData = allocation->GetUserData();
        const char* name = allocation->GetName();

#if VMA_STATS_STRING_ENABLED
        VMA_DEBUG_LOG("UNFREED ALLOCATION; Offset: %llu; Size: %llu; UserData: %p; Name: %s; Type: %s; Usage: %u",
            offset, size, userData, name ? name : "vma_empty",
            VMA_SUBALLOCATION_TYPE_NAMES[allocation->GetSuballocationType()],
            allocation->GetBufferImageUsage());
#else
        VMA_DEBUG_LOG("UNFREED ALLOCATION; Offset: %llu; Size: %llu; UserData: %p; Name: %s; Type: %u",
            offset, size, userData, name ? name : "vma_empty",
            (uint32_t)allocation->GetSuballocationType());
#endif // VMA_STATS_STRING_ENABLED
    }

}

#if VMA_STATS_STRING_ENABLED
void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
    VkDeviceSize unusedBytes, size_t allocationCount, size_t unusedRangeCount) const
{
    json.WriteString("TotalBytes");
    json.WriteNumber(GetSize());

    json.WriteString("UnusedBytes");
    json.WriteNumber(unusedBytes);

    json.WriteString("Allocations");
    json.WriteNumber((uint64_t)allocationCount);

    json.WriteString("UnusedRanges");
    json.WriteNumber((uint64_t)unusedRangeCount);

    json.WriteString("Suballocations");
    json.BeginArray();
}

void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
    VkDeviceSize offset, VkDeviceSize size, void* userData) const
{
    json.BeginObject(true);

    json.WriteString("Offset");
    json.WriteNumber(offset);

    if (IsVirtual())
    {
        json.WriteString("Size");
        json.WriteNumber(size);
        if (userData)
        {
            json.WriteString("CustomData");
            json.BeginString();
            json.ContinueString_Pointer(userData);
            json.EndString();
        }
    }
    else
    {
        ((VmaAllocation)userData)->PrintParameters(json);
    }

    json.EndObject();
}

void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
    VkDeviceSize offset, VkDeviceSize size) const
{
    json.BeginObject(true);

    json.WriteString("Offset");
    json.WriteNumber(offset);

    json.WriteString("Type");
    json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);

    json.WriteString("Size");
    json.WriteNumber(size);

    json.EndObject();
}

void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
{
    json.EndArray();
}
#endif // VMA_STATS_STRING_ENABLED
#endif // _VMA_BLOCK_METADATA_FUNCTIONS
#endif // _VMA_BLOCK_METADATA

#ifndef _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY
// Before deleting object of this class remember to call 'Destroy()'
class VmaBlockBufferImageGranularity final
{
public:
    struct ValidationContext
    {
        const VkAllocationCallbacks* allocCallbacks;
        uint16_t* pageAllocs;
    };

    VmaBlockBufferImageGranularity(VkDeviceSize bufferImageGranularity);
    ~VmaBlockBufferImageGranularity();

    bool IsEnabled() const { return m_BufferImageGranularity > MAX_LOW_BUFFER_IMAGE_GRANULARITY; }

    void Init(const VkAllocationCallbacks* pAllocationCallbacks, VkDeviceSize size);
    // Before destroying object you must call free it's memory
    void Destroy(const VkAllocationCallbacks* pAllocationCallbacks);

    void RoundupAllocRequest(VmaSuballocationType allocType,
        VkDeviceSize& inOutAllocSize,
        VkDeviceSize& inOutAllocAlignment) const;

    bool CheckConflictAndAlignUp(VkDeviceSize& inOutAllocOffset,
        VkDeviceSize allocSize,
        VkDeviceSize blockOffset,
        VkDeviceSize blockSize,
        VmaSuballocationType allocType) const;

    void AllocPages(uint8_t allocType, VkDeviceSize offset, VkDeviceSize size);
    void FreePages(VkDeviceSize offset, VkDeviceSize size);
    void Clear();

    ValidationContext StartValidation(const VkAllocationCallbacks* pAllocationCallbacks,
        bool isVirutal) const;
    bool Validate(ValidationContext& ctx, VkDeviceSize offset, VkDeviceSize size) const;
    bool FinishValidation(ValidationContext& ctx) const;

private:
    static const uint16_t MAX_LOW_BUFFER_IMAGE_GRANULARITY = 256;

    struct RegionInfo
    {
        uint8_t allocType;
        uint16_t allocCount;
    };

    VkDeviceSize m_BufferImageGranularity;
    uint32_t m_RegionCount;
    RegionInfo* m_RegionInfo;

    uint32_t GetStartPage(VkDeviceSize offset) const { return OffsetToPageIndex(offset & ~(m_BufferImageGranularity - 1)); }
    uint32_t GetEndPage(VkDeviceSize offset, VkDeviceSize size) const { return OffsetToPageIndex((offset + size - 1) & ~(m_BufferImageGranularity - 1)); }

    uint32_t OffsetToPageIndex(VkDeviceSize offset) const;
    void AllocPage(RegionInfo& page, uint8_t allocType);
};

#ifndef _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY_FUNCTIONS
VmaBlockBufferImageGranularity::VmaBlockBufferImageGranularity(VkDeviceSize bufferImageGranularity)
    : m_BufferImageGranularity(bufferImageGranularity),
    m_RegionCount(0),
    m_RegionInfo(VMA_NULL) {}

VmaBlockBufferImageGranularity::~VmaBlockBufferImageGranularity()
{
    VMA_ASSERT(m_RegionInfo == VMA_NULL && "Free not called before destroying object!");
}

void VmaBlockBufferImageGranularity::Init(const VkAllocationCallbacks* pAllocationCallbacks, VkDeviceSize size)
{
    if (IsEnabled())
    {
        m_RegionCount = static_cast<uint32_t>(VmaDivideRoundingUp(size, m_BufferImageGranularity));
        m_RegionInfo = vma_new_array(pAllocationCallbacks, RegionInfo, m_RegionCount);
        memset(m_RegionInfo, 0, m_RegionCount * sizeof(RegionInfo));
    }
}

void VmaBlockBufferImageGranularity::Destroy(const VkAllocationCallbacks* pAllocationCallbacks)
{
    if (m_RegionInfo)
    {
        vma_delete_array(pAllocationCallbacks, m_RegionInfo, m_RegionCount);
        m_RegionInfo = VMA_NULL;
    }
}

void VmaBlockBufferImageGranularity::RoundupAllocRequest(VmaSuballocationType allocType,
    VkDeviceSize& inOutAllocSize,
    VkDeviceSize& inOutAllocAlignment) const
{
    if (m_BufferImageGranularity > 1 &&
        m_BufferImageGranularity <= MAX_LOW_BUFFER_IMAGE_GRANULARITY)
    {
        if (allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
            allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
            allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
        {
            inOutAllocAlignment = VMA_MAX(inOutAllocAlignment, m_BufferImageGranularity);
            inOutAllocSize = VmaAlignUp(inOutAllocSize, m_BufferImageGranularity);
        }
    }
}

bool VmaBlockBufferImageGranularity::CheckConflictAndAlignUp(VkDeviceSize& inOutAllocOffset,
    VkDeviceSize allocSize,
    VkDeviceSize blockOffset,
    VkDeviceSize blockSize,
    VmaSuballocationType allocType) const
{
    if (IsEnabled())
    {
        uint32_t startPage = GetStartPage(inOutAllocOffset);
        if (m_RegionInfo[startPage].allocCount > 0 &&
            VmaIsBufferImageGranularityConflict(static_cast<VmaSuballocationType>(m_RegionInfo[startPage].allocType), allocType))
        {
            inOutAllocOffset = VmaAlignUp(inOutAllocOffset, m_BufferImageGranularity);
            if (blockSize < allocSize + inOutAllocOffset - blockOffset)
                return true;
            ++startPage;
        }
        uint32_t endPage = GetEndPage(inOutAllocOffset, allocSize);
        if (endPage != startPage &&
            m_RegionInfo[endPage].allocCount > 0 &&
            VmaIsBufferImageGranularityConflict(static_cast<VmaSuballocationType>(m_RegionInfo[endPage].allocType), allocType))
        {
            return true;
        }
    }
    return false;
}

void VmaBlockBufferImageGranularity::AllocPages(uint8_t allocType, VkDeviceSize offset, VkDeviceSize size)
{
    if (IsEnabled())
    {
        uint32_t startPage = GetStartPage(offset);
        AllocPage(m_RegionInfo[startPage], allocType);

        uint32_t endPage = GetEndPage(offset, size);
        if (startPage != endPage)
            AllocPage(m_RegionInfo[endPage], allocType);
    }
}

void VmaBlockBufferImageGranularity::FreePages(VkDeviceSize offset, VkDeviceSize size)
{
    if (IsEnabled())
    {
        uint32_t startPage = GetStartPage(offset);
        --m_RegionInfo[startPage].allocCount;
        if (m_RegionInfo[startPage].allocCount == 0)
            m_RegionInfo[startPage].allocType = VMA_SUBALLOCATION_TYPE_FREE;
        uint32_t endPage = GetEndPage(offset, size);
        if (startPage != endPage)
        {
            --m_RegionInfo[endPage].allocCount;
            if (m_RegionInfo[endPage].allocCount == 0)
                m_RegionInfo[endPage].allocType = VMA_SUBALLOCATION_TYPE_FREE;
        }
    }
}

void VmaBlockBufferImageGranularity::Clear()
{
    if (m_RegionInfo)
        memset(m_RegionInfo, 0, m_RegionCount * sizeof(RegionInfo));
}

VmaBlockBufferImageGranularity::ValidationContext VmaBlockBufferImageGranularity::StartValidation(
    const VkAllocationCallbacks* pAllocationCallbacks, bool isVirutal) const
{
    ValidationContext ctx{ pAllocationCallbacks, VMA_NULL };
    if (!isVirutal && IsEnabled())
    {
        ctx.pageAllocs = vma_new_array(pAllocationCallbacks, uint16_t, m_RegionCount);
        memset(ctx.pageAllocs, 0, m_RegionCount * sizeof(uint16_t));
    }
    return ctx;
}

bool VmaBlockBufferImageGranularity::Validate(ValidationContext& ctx,
    VkDeviceSize offset, VkDeviceSize size) const
{
    if (IsEnabled())
    {
        uint32_t start = GetStartPage(offset);
        ++ctx.pageAllocs[start];
        VMA_VALIDATE(m_RegionInfo[start].allocCount > 0);

        uint32_t end = GetEndPage(offset, size);
        if (start != end)
        {
            ++ctx.pageAllocs[end];
            VMA_VALIDATE(m_RegionInfo[end].allocCount > 0);
        }
    }
    return true;
}

bool VmaBlockBufferImageGranularity::FinishValidation(ValidationContext& ctx) const
{
    // Check proper page structure
    if (IsEnabled())
    {
        VMA_ASSERT(ctx.pageAllocs != VMA_NULL && "Validation context not initialized!");

        for (uint32_t page = 0; page < m_RegionCount; ++page)
        {
            VMA_VALIDATE(ctx.pageAllocs[page] == m_RegionInfo[page].allocCount);
        }
        vma_delete_array(ctx.allocCallbacks, ctx.pageAllocs, m_RegionCount);
        ctx.pageAllocs = VMA_NULL;
    }
    return true;
}

uint32_t VmaBlockBufferImageGranularity::OffsetToPageIndex(VkDeviceSize offset) const
{
    return static_cast<uint32_t>(offset >> VMA_BITSCAN_MSB(m_BufferImageGranularity));
}

void VmaBlockBufferImageGranularity::AllocPage(RegionInfo& page, uint8_t allocType)
{
    // When current alloc type is free then it can be overridden by new type
    if (page.allocCount == 0 || (page.allocCount > 0 && page.allocType == VMA_SUBALLOCATION_TYPE_FREE))
        page.allocType = allocType;

    ++page.allocCount;
}
#endif // _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY_FUNCTIONS
#endif // _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY

#if 0
#ifndef _VMA_BLOCK_METADATA_GENERIC
class VmaBlockMetadata_Generic : public VmaBlockMetadata
{
    friend class VmaDefragmentationAlgorithm_Generic;
    friend class VmaDefragmentationAlgorithm_Fast;
    VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
public:
    VmaBlockMetadata_Generic(const VkAllocationCallbacks* pAllocationCallbacks,
        VkDeviceSize bufferImageGranularity, bool isVirtual);
    virtual ~VmaBlockMetadata_Generic() = default;

    size_t GetAllocationCount() const override { return m_Suballocations.size() - m_FreeCount; }
    VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize; }
    bool IsEmpty() const override { return (m_Suballocations.size() == 1) && (m_FreeCount == 1); }
    void Free(VmaAllocHandle allocHandle) override { FreeSuballocation(FindAtOffset((VkDeviceSize)allocHandle - 1)); }
    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return (VkDeviceSize)allocHandle - 1; }

    void Init(VkDeviceSize size) override;
    bool Validate() const override;

    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
    void AddStatistics(VmaStatistics& inoutStats) const override;

#if VMA_STATS_STRING_ENABLED
    void PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const override;
#endif

    bool CreateAllocationRequest(
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        bool upperAddress,
        VmaSuballocationType allocType,
        uint32_t strategy,
        VmaAllocationRequest* pAllocationRequest) override;

    VkResult CheckCorruption(const void* pBlockData) override;

    void Alloc(
        const VmaAllocationRequest& request,
        VmaSuballocationType type,
        void* userData) override;

    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
    VmaAllocHandle GetAllocationListBegin() const override;
    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
    void Clear() override;
    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
    void DebugLogAllAllocations() const override;

private:
    uint32_t m_FreeCount;
    VkDeviceSize m_SumFreeSize;
    VmaSuballocationList m_Suballocations;
    // Suballocations that are free. Sorted by size, ascending.
    VmaVector<VmaSuballocationList::iterator, VmaStlAllocator<VmaSuballocationList::iterator>> m_FreeSuballocationsBySize;

    VkDeviceSize AlignAllocationSize(VkDeviceSize size) const { return IsVirtual() ? size : VmaAlignUp(size, (VkDeviceSize)16); }

    VmaSuballocationList::iterator FindAtOffset(VkDeviceSize offset) const;
    bool ValidateFreeSuballocationList() const;

    // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
    // If yes, fills pOffset and returns true. If no, returns false.
    bool CheckAllocation(
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        VmaSuballocationType allocType,
        VmaSuballocationList::const_iterator suballocItem,
        VmaAllocHandle* pAllocHandle) const;

    // Given free suballocation, it merges it with following one, which must also be free.
    void MergeFreeWithNext(VmaSuballocationList::iterator item);
    // Releases given suballocation, making it free.
    // Merges it with adjacent free suballocations if applicable.
    // Returns iterator to new free suballocation at this place.
    VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
    // Given free suballocation, it inserts it into sorted list of
    // m_FreeSuballocationsBySize if it is suitable.
    void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
    // Given free suballocation, it removes it from sorted list of
    // m_FreeSuballocationsBySize if it is suitable.
    void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
};

#ifndef _VMA_BLOCK_METADATA_GENERIC_FUNCTIONS
VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(const VkAllocationCallbacks* pAllocationCallbacks,
    VkDeviceSize bufferImageGranularity, bool isVirtual)
    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
    m_FreeCount(0),
    m_SumFreeSize(0),
    m_Suballocations(VmaStlAllocator<VmaSuballocation>(pAllocationCallbacks)),
    m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(pAllocationCallbacks)) {}

void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
{
    VmaBlockMetadata::Init(size);

    m_FreeCount = 1;
    m_SumFreeSize = size;

    VmaSuballocation suballoc = {};
    suballoc.offset = 0;
    suballoc.size = size;
    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;

    m_Suballocations.push_back(suballoc);
    m_FreeSuballocationsBySize.push_back(m_Suballocations.begin());
}

bool VmaBlockMetadata_Generic::Validate() const
{
    VMA_VALIDATE(!m_Suballocations.empty());

    // Expected offset of new suballocation as calculated from previous ones.
    VkDeviceSize calculatedOffset = 0;
    // Expected number of free suballocations as calculated from traversing their list.
    uint32_t calculatedFreeCount = 0;
    // Expected sum size of free suballocations as calculated from traversing their list.
    VkDeviceSize calculatedSumFreeSize = 0;
    // Expected number of free suballocations that should be registered in
    // m_FreeSuballocationsBySize calculated from traversing their list.
    size_t freeSuballocationsToRegister = 0;
    // True if previous visited suballocation was free.
    bool prevFree = false;

    const VkDeviceSize debugMargin = GetDebugMargin();

    for (const auto& subAlloc : m_Suballocations)
    {
        // Actual offset of this suballocation doesn't match expected one.
        VMA_VALIDATE(subAlloc.offset == calculatedOffset);

        const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
        // Two adjacent free suballocations are invalid. They should be merged.
        VMA_VALIDATE(!prevFree || !currFree);

        VmaAllocation alloc = (VmaAllocation)subAlloc.userData;
        if (!IsVirtual())
        {
            VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
        }

        if (currFree)
        {
            calculatedSumFreeSize += subAlloc.size;
            ++calculatedFreeCount;
            ++freeSuballocationsToRegister;

            // Margin required between allocations - every free space must be at least that large.
            VMA_VALIDATE(subAlloc.size >= debugMargin);
        }
        else
        {
            if (!IsVirtual())
            {
                VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == subAlloc.offset + 1);
                VMA_VALIDATE(alloc->GetSize() == subAlloc.size);
            }

            // Margin required between allocations - previous allocation must be free.
            VMA_VALIDATE(debugMargin == 0 || prevFree);
        }

        calculatedOffset += subAlloc.size;
        prevFree = currFree;
    }

    // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
    // match expected one.
    VMA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);

    VkDeviceSize lastSize = 0;
    for (size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
    {
        VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];

        // Only free suballocations can be registered in m_FreeSuballocationsBySize.
        VMA_VALIDATE(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        // They must be sorted by size ascending.
        VMA_VALIDATE(suballocItem->size >= lastSize);

        lastSize = suballocItem->size;
    }

    // Check if totals match calculated values.
    VMA_VALIDATE(ValidateFreeSuballocationList());
    VMA_VALIDATE(calculatedOffset == GetSize());
    VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
    VMA_VALIDATE(calculatedFreeCount == m_FreeCount);

    return true;
}

void VmaBlockMetadata_Generic::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
{
    const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
    inoutStats.statistics.blockCount++;
    inoutStats.statistics.blockBytes += GetSize();

    for (const auto& suballoc : m_Suballocations)
    {
        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
            VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);
        else
            VmaAddDetailedStatisticsUnusedRange(inoutStats, suballoc.size);
    }
}

void VmaBlockMetadata_Generic::AddStatistics(VmaStatistics& inoutStats) const
{
    inoutStats.blockCount++;
    inoutStats.allocationCount += (uint32_t)m_Suballocations.size() - m_FreeCount;
    inoutStats.blockBytes += GetSize();
    inoutStats.allocationBytes += GetSize() - m_SumFreeSize;
}

#if VMA_STATS_STRING_ENABLED
void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const
{
    PrintDetailedMap_Begin(json,
        m_SumFreeSize, // unusedBytes
        m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
        m_FreeCount, // unusedRangeCount
        mapRefCount);

    for (const auto& suballoc : m_Suballocations)
    {
        if (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
        {
            PrintDetailedMap_UnusedRange(json, suballoc.offset, suballoc.size);
        }
        else
        {
            PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);
        }
    }

    PrintDetailedMap_End(json);
}
#endif // VMA_STATS_STRING_ENABLED

bool VmaBlockMetadata_Generic::CreateAllocationRequest(
    VkDeviceSize allocSize,
    VkDeviceSize allocAlignment,
    bool upperAddress,
    VmaSuballocationType allocType,
    uint32_t strategy,
    VmaAllocationRequest* pAllocationRequest)
{
    VMA_ASSERT(allocSize > 0);
    VMA_ASSERT(!upperAddress);
    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
    VMA_ASSERT(pAllocationRequest != VMA_NULL);
    VMA_HEAVY_ASSERT(Validate());

    allocSize = AlignAllocationSize(allocSize);

    pAllocationRequest->type = VmaAllocationRequestType::Normal;
    pAllocationRequest->size = allocSize;

    const VkDeviceSize debugMargin = GetDebugMargin();

    // There is not enough total free space in this block to fulfill the request: Early return.
    if (m_SumFreeSize < allocSize + debugMargin)
    {
        return false;
    }

    // New algorithm, efficiently searching freeSuballocationsBySize.
    const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
    if (freeSuballocCount > 0)
    {
        if (strategy == 0 ||
            strategy == VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT)
        {
            // Find first free suballocation with size not less than allocSize + debugMargin.
            VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
                m_FreeSuballocationsBySize.data(),
                m_FreeSuballocationsBySize.data() + freeSuballocCount,
                allocSize + debugMargin,
                VmaSuballocationItemSizeLess());
            size_t index = it - m_FreeSuballocationsBySize.data();
            for (; index < freeSuballocCount; ++index)
            {
                if (CheckAllocation(
                    allocSize,
                    allocAlignment,
                    allocType,
                    m_FreeSuballocationsBySize[index],
                    &pAllocationRequest->allocHandle))
                {
                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];
                    return true;
                }
            }
        }
        else if (strategy == VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET)
        {
            for (VmaSuballocationList::iterator it = m_Suballocations.begin();
                it != m_Suballocations.end();
                ++it)
            {
                if (it->type == VMA_SUBALLOCATION_TYPE_FREE && CheckAllocation(
                    allocSize,
                    allocAlignment,
                    allocType,
                    it,
                    &pAllocationRequest->allocHandle))
                {
                    pAllocationRequest->item = it;
                    return true;
                }
            }
        }
        else
        {
            VMA_ASSERT(strategy & (VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT | VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT ));
            // Search staring from biggest suballocations.
            for (size_t index = freeSuballocCount; index--; )
            {
                if (CheckAllocation(
                    allocSize,
                    allocAlignment,
                    allocType,
                    m_FreeSuballocationsBySize[index],
                    &pAllocationRequest->allocHandle))
                {
                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];
                    return true;
                }
            }
        }
    }

    return false;
}

VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
{
    for (auto& suballoc : m_Suballocations)
    {
        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        {
            if (!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
            {
                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
                return VK_ERROR_UNKNOWN_COPY;
            }
        }
    }

    return VK_SUCCESS;
}

void VmaBlockMetadata_Generic::Alloc(
    const VmaAllocationRequest& request,
    VmaSuballocationType type,
    void* userData)
{
    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
    VMA_ASSERT(request.item != m_Suballocations.end());
    VmaSuballocation& suballoc = *request.item;
    // Given suballocation is a free block.
    VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);

    // Given offset is inside this suballocation.
    VMA_ASSERT((VkDeviceSize)request.allocHandle - 1 >= suballoc.offset);
    const VkDeviceSize paddingBegin = (VkDeviceSize)request.allocHandle - suballoc.offset - 1;
    VMA_ASSERT(suballoc.size >= paddingBegin + request.size);
    const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - request.size;

    // Unregister this free suballocation from m_FreeSuballocationsBySize and update
    // it to become used.
    UnregisterFreeSuballocation(request.item);

    suballoc.offset = (VkDeviceSize)request.allocHandle - 1;
    suballoc.size = request.size;
    suballoc.type = type;
    suballoc.userData = userData;

    // If there are any free bytes remaining at the end, insert new free suballocation after current one.
    if (paddingEnd)
    {
        VmaSuballocation paddingSuballoc = {};
        paddingSuballoc.offset = suballoc.offset + suballoc.size;
        paddingSuballoc.size = paddingEnd;
        paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        VmaSuballocationList::iterator next = request.item;
        ++next;
        const VmaSuballocationList::iterator paddingEndItem =
            m_Suballocations.insert(next, paddingSuballoc);
        RegisterFreeSuballocation(paddingEndItem);
    }

    // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
    if (paddingBegin)
    {
        VmaSuballocation paddingSuballoc = {};
        paddingSuballoc.offset = suballoc.offset - paddingBegin;
        paddingSuballoc.size = paddingBegin;
        paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        const VmaSuballocationList::iterator paddingBeginItem =
            m_Suballocations.insert(request.item, paddingSuballoc);
        RegisterFreeSuballocation(paddingBeginItem);
    }

    // Update totals.
    m_FreeCount = m_FreeCount - 1;
    if (paddingBegin > 0)
    {
        ++m_FreeCount;
    }
    if (paddingEnd > 0)
    {
        ++m_FreeCount;
    }
    m_SumFreeSize -= request.size;
}

void VmaBlockMetadata_Generic::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
{
    outInfo.offset = (VkDeviceSize)allocHandle - 1;
    const VmaSuballocation& suballoc = *FindAtOffset(outInfo.offset);
    outInfo.size = suballoc.size;
    outInfo.pUserData = suballoc.userData;
}

void* VmaBlockMetadata_Generic::GetAllocationUserData(VmaAllocHandle allocHandle) const
{
    return FindAtOffset((VkDeviceSize)allocHandle - 1)->userData;
}

VmaAllocHandle VmaBlockMetadata_Generic::GetAllocationListBegin() const
{
    if (IsEmpty())
        return VK_NULL_HANDLE;

    for (const auto& suballoc : m_Suballocations)
    {
        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
            return (VmaAllocHandle)(suballoc.offset + 1);
    }
    VMA_ASSERT(false && "Should contain at least 1 allocation!");
    return VK_NULL_HANDLE;
}

VmaAllocHandle VmaBlockMetadata_Generic::GetNextAllocation(VmaAllocHandle prevAlloc) const
{
    VmaSuballocationList::const_iterator prev = FindAtOffset((VkDeviceSize)prevAlloc - 1);

    for (VmaSuballocationList::const_iterator it = ++prev; it != m_Suballocations.end(); ++it)
    {
        if (it->type != VMA_SUBALLOCATION_TYPE_FREE)
            return (VmaAllocHandle)(it->offset + 1);
    }
    return VK_NULL_HANDLE;
}

void VmaBlockMetadata_Generic::Clear()
{
    const VkDeviceSize size = GetSize();

    VMA_ASSERT(IsVirtual());
    m_FreeCount = 1;
    m_SumFreeSize = size;
    m_Suballocations.clear();
    m_FreeSuballocationsBySize.clear();

    VmaSuballocation suballoc = {};
    suballoc.offset = 0;
    suballoc.size = size;
    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    m_Suballocations.push_back(suballoc);

    m_FreeSuballocationsBySize.push_back(m_Suballocations.begin());
}

void VmaBlockMetadata_Generic::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
{
    VmaSuballocation& suballoc = *FindAtOffset((VkDeviceSize)allocHandle - 1);
    suballoc.userData = userData;
}

void VmaBlockMetadata_Generic::DebugLogAllAllocations() const
{
    for (const auto& suballoc : m_Suballocations)
    {
        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
            DebugLogAllocation(suballoc.offset, suballoc.size, suballoc.userData);
    }
}

VmaSuballocationList::iterator VmaBlockMetadata_Generic::FindAtOffset(VkDeviceSize offset) const
{
    VMA_HEAVY_ASSERT(!m_Suballocations.empty());
    const VkDeviceSize last = m_Suballocations.rbegin()->offset;
    if (last == offset)
        return m_Suballocations.rbegin().drop_const();
    const VkDeviceSize first = m_Suballocations.begin()->offset;
    if (first == offset)
        return m_Suballocations.begin().drop_const();

    const size_t suballocCount = m_Suballocations.size();
    const VkDeviceSize step = (last - first + m_Suballocations.begin()->size) / suballocCount;
    auto findSuballocation = [&](auto begin, auto end) -> VmaSuballocationList::iterator
    {
        for (auto suballocItem = begin;
            suballocItem != end;
            ++suballocItem)
        {
            if (suballocItem->offset == offset)
                return suballocItem.drop_const();
        }
        VMA_ASSERT(false && "Not found!");
        return m_Suballocations.end().drop_const();
    };
    // If requested offset is closer to the end of range, search from the end
    if (offset - first > suballocCount * step / 2)
    {
        return findSuballocation(m_Suballocations.rbegin(), m_Suballocations.rend());
    }
    return findSuballocation(m_Suballocations.begin(), m_Suballocations.end());
}

bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
{
    VkDeviceSize lastSize = 0;
    for (size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
    {
        const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];

        VMA_VALIDATE(it->type == VMA_SUBALLOCATION_TYPE_FREE);
        VMA_VALIDATE(it->size >= lastSize);
        lastSize = it->size;
    }
    return true;
}

bool VmaBlockMetadata_Generic::CheckAllocation(
    VkDeviceSize allocSize,
    VkDeviceSize allocAlignment,
    VmaSuballocationType allocType,
    VmaSuballocationList::const_iterator suballocItem,
    VmaAllocHandle* pAllocHandle) const
{
    VMA_ASSERT(allocSize > 0);
    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
    VMA_ASSERT(suballocItem != m_Suballocations.cend());
    VMA_ASSERT(pAllocHandle != VMA_NULL);

    const VkDeviceSize debugMargin = GetDebugMargin();
    const VkDeviceSize bufferImageGranularity = GetBufferImageGranularity();

    const VmaSuballocation& suballoc = *suballocItem;
    VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);

    // Size of this suballocation is too small for this request: Early return.
    if (suballoc.size < allocSize)
    {
        return false;
    }

    // Start from offset equal to beginning of this suballocation.
    VkDeviceSize offset = suballoc.offset + (suballocItem == m_Suballocations.cbegin() ? 0 : GetDebugMargin());

    // Apply debugMargin from the end of previous alloc.
    if (debugMargin > 0)
    {
        offset += debugMargin;
    }

    // Apply alignment.
    offset = VmaAlignUp(offset, allocAlignment);

    // Check previous suballocations for BufferImageGranularity conflicts.
    // Make bigger alignment if necessary.
    if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment)
    {
        bool bufferImageGranularityConflict = false;
        VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        while (prevSuballocItem != m_Suballocations.cbegin())
        {
            --prevSuballocItem;
            const VmaSuballocation& prevSuballoc = *prevSuballocItem;
            if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, offset, bufferImageGranularity))
            {
                if (VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
                {
                    bufferImageGranularityConflict = true;
                    break;
                }
            }
            else
                // Already on previous page.
                break;
        }
        if (bufferImageGranularityConflict)
        {
            offset = VmaAlignUp(offset, bufferImageGranularity);
        }
    }

    // Calculate padding at the beginning based on current offset.
    const VkDeviceSize paddingBegin = offset - suballoc.offset;

    // Fail if requested size plus margin after is bigger than size of this suballocation.
    if (paddingBegin + allocSize + debugMargin > suballoc.size)
    {
        return false;
    }

    // Check next suballocations for BufferImageGranularity conflicts.
    // If conflict exists, allocation cannot be made here.
    if (allocSize % bufferImageGranularity || offset % bufferImageGranularity)
    {
        VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
        ++nextSuballocItem;
        while (nextSuballocItem != m_Suballocations.cend())
        {
            const VmaSuballocation& nextSuballoc = *nextSuballocItem;
            if (VmaBlocksOnSamePage(offset, allocSize, nextSuballoc.offset, bufferImageGranularity))
            {
                if (VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
                {
                    return false;
                }
            }
            else
            {
                // Already on next page.
                break;
            }
            ++nextSuballocItem;
        }
    }

    *pAllocHandle = (VmaAllocHandle)(offset + 1);
    // All tests passed: Success. pAllocHandle is already filled.
    return true;
}

void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
{
    VMA_ASSERT(item != m_Suballocations.end());
    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);

    VmaSuballocationList::iterator nextItem = item;
    ++nextItem;
    VMA_ASSERT(nextItem != m_Suballocations.end());
    VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);

    item->size += nextItem->size;
    --m_FreeCount;
    m_Suballocations.erase(nextItem);
}

VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
{
    // Change this suballocation to be marked as free.
    VmaSuballocation& suballoc = *suballocItem;
    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    suballoc.userData = VMA_NULL;

    // Update totals.
    ++m_FreeCount;
    m_SumFreeSize += suballoc.size;

    // Merge with previous and/or next suballocation if it's also free.
    bool mergeWithNext = false;
    bool mergeWithPrev = false;

    VmaSuballocationList::iterator nextItem = suballocItem;
    ++nextItem;
    if ((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
    {
        mergeWithNext = true;
    }

    VmaSuballocationList::iterator prevItem = suballocItem;
    if (suballocItem != m_Suballocations.begin())
    {
        --prevItem;
        if (prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        {
            mergeWithPrev = true;
        }
    }

    if (mergeWithNext)
    {
        UnregisterFreeSuballocation(nextItem);
        MergeFreeWithNext(suballocItem);
    }

    if (mergeWithPrev)
    {
        UnregisterFreeSuballocation(prevItem);
        MergeFreeWithNext(prevItem);
        RegisterFreeSuballocation(prevItem);
        return prevItem;
    }
    else
    {
        RegisterFreeSuballocation(suballocItem);
        return suballocItem;
    }
}

void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
{
    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
    VMA_ASSERT(item->size > 0);

    // You may want to enable this validation at the beginning or at the end of
    // this function, depending on what do you want to check.
    VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());

    if (m_FreeSuballocationsBySize.empty())
    {
        m_FreeSuballocationsBySize.push_back(item);
    }
    else
    {
        VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
    }

    //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
}

void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
{
    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
    VMA_ASSERT(item->size > 0);

    // You may want to enable this validation at the beginning or at the end of
    // this function, depending on what do you want to check.
    VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());

    VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        m_FreeSuballocationsBySize.data(),
        m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
        item,
        VmaSuballocationItemSizeLess());
    for (size_t index = it - m_FreeSuballocationsBySize.data();
        index < m_FreeSuballocationsBySize.size();
        ++index)
    {
        if (m_FreeSuballocationsBySize[index] == item)
        {
            VmaVectorRemove(m_FreeSuballocationsBySize, index);
            return;
        }
        VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
    }
    VMA_ASSERT(0 && "Not found.");

    //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
}
#endif // _VMA_BLOCK_METADATA_GENERIC_FUNCTIONS
#endif // _VMA_BLOCK_METADATA_GENERIC
#endif // #if 0

#ifndef _VMA_BLOCK_METADATA_LINEAR
/*
Allocations and their references in internal data structure look like this:

if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):

        0 +-------+
          |       |
          |       |
          |       |
          +-------+
          | Alloc |  1st[m_1stNullItemsBeginCount]
          +-------+
          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
          +-------+
          |  ...  |
          +-------+
          | Alloc |  1st[1st.size() - 1]
          +-------+
          |       |
          |       |
          |       |
GetSize() +-------+

if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):

        0 +-------+
          | Alloc |  2nd[0]
          +-------+
          | Alloc |  2nd[1]
          +-------+
          |  ...  |
          +-------+
          | Alloc |  2nd[2nd.size() - 1]
          +-------+
          |       |
          |       |
          |       |
          +-------+
          | Alloc |  1st[m_1stNullItemsBeginCount]
          +-------+
          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
          +-------+
          |  ...  |
          +-------+
          | Alloc |  1st[1st.size() - 1]
          +-------+
          |       |
GetSize() +-------+

if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):

        0 +-------+
          |       |
          |       |
          |       |
          +-------+
          | Alloc |  1st[m_1stNullItemsBeginCount]
          +-------+
          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
          +-------+
          |  ...  |
          +-------+
          | Alloc |  1st[1st.size() - 1]
          +-------+
          |       |
          |       |
          |       |
          +-------+
          | Alloc |  2nd[2nd.size() - 1]
          +-------+
          |  ...  |
          +-------+
          | Alloc |  2nd[1]
          +-------+
          | Alloc |  2nd[0]
GetSize() +-------+

*/
class VmaBlockMetadata_Linear : public VmaBlockMetadata
{
    VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
public:
    VmaBlockMetadata_Linear(const VkAllocationCallbacks* pAllocationCallbacks,
        VkDeviceSize bufferImageGranularity, bool isVirtual);
    virtual ~VmaBlockMetadata_Linear() = default;

    VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize; }
    bool IsEmpty() const override { return GetAllocationCount() == 0; }
    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return (VkDeviceSize)allocHandle - 1; }

    void Init(VkDeviceSize size) override;
    bool Validate() const override;
    size_t GetAllocationCount() const override;
    size_t GetFreeRegionsCount() const override;

    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
    void AddStatistics(VmaStatistics& inoutStats) const override;

#if VMA_STATS_STRING_ENABLED
    void PrintDetailedMap(class VmaJsonWriter& json) const override;
#endif

    bool CreateAllocationRequest(
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        bool upperAddress,
        VmaSuballocationType allocType,
        uint32_t strategy,
        VmaAllocationRequest* pAllocationRequest) override;

    VkResult CheckCorruption(const void* pBlockData) override;

    void Alloc(
        const VmaAllocationRequest& request,
        VmaSuballocationType type,
        void* userData) override;

    void Free(VmaAllocHandle allocHandle) override;
    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
    VmaAllocHandle GetAllocationListBegin() const override;
    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
    VkDeviceSize GetNextFreeRegionSize(VmaAllocHandle alloc) const override;
    void Clear() override;
    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
    void DebugLogAllAllocations() const override;

private:
    /*
    There are two suballocation vectors, used in ping-pong way.
    The one with index m_1stVectorIndex is called 1st.
    The one with index (m_1stVectorIndex ^ 1) is called 2nd.
    2nd can be non-empty only when 1st is not empty.
    When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
    */
    typedef VmaVector<VmaSuballocation, VmaStlAllocator<VmaSuballocation>> SuballocationVectorType;

    enum SECOND_VECTOR_MODE
    {
        SECOND_VECTOR_EMPTY,
        /*
        Suballocations in 2nd vector are created later than the ones in 1st, but they
        all have smaller offset.
        */
        SECOND_VECTOR_RING_BUFFER,
        /*
        Suballocations in 2nd vector are upper side of double stack.
        They all have offsets higher than those in 1st vector.
        Top of this stack means smaller offsets, but higher indices in this vector.
        */
        SECOND_VECTOR_DOUBLE_STACK,
    };

    VkDeviceSize m_SumFreeSize;
    SuballocationVectorType m_Suballocations0, m_Suballocations1;
    uint32_t m_1stVectorIndex;
    SECOND_VECTOR_MODE m_2ndVectorMode;
    // Number of items in 1st vector with hAllocation = null at the beginning.
    size_t m_1stNullItemsBeginCount;
    // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
    size_t m_1stNullItemsMiddleCount;
    // Number of items in 2nd vector with hAllocation = null.
    size_t m_2ndNullItemsCount;

    SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
    SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
    const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
    const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }

    VmaSuballocation& FindSuballocation(VkDeviceSize offset) const;
    bool ShouldCompact1st() const;
    void CleanupAfterFree();

    bool CreateAllocationRequest_LowerAddress(
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        VmaSuballocationType allocType,
        uint32_t strategy,
        VmaAllocationRequest* pAllocationRequest);
    bool CreateAllocationRequest_UpperAddress(
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        VmaSuballocationType allocType,
        uint32_t strategy,
        VmaAllocationRequest* pAllocationRequest);
};

#ifndef _VMA_BLOCK_METADATA_LINEAR_FUNCTIONS
VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(const VkAllocationCallbacks* pAllocationCallbacks,
    VkDeviceSize bufferImageGranularity, bool isVirtual)
    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
    m_SumFreeSize(0),
    m_Suballocations0(VmaStlAllocator<VmaSuballocation>(pAllocationCallbacks)),
    m_Suballocations1(VmaStlAllocator<VmaSuballocation>(pAllocationCallbacks)),
    m_1stVectorIndex(0),
    m_2ndVectorMode(SECOND_VECTOR_EMPTY),
    m_1stNullItemsBeginCount(0),
    m_1stNullItemsMiddleCount(0),
    m_2ndNullItemsCount(0) {}

void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
{
    VmaBlockMetadata::Init(size);
    m_SumFreeSize = size;
}

bool VmaBlockMetadata_Linear::Validate() const
{
    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

    VMA_VALIDATE(suballocations2nd.empty() == (m_2ndVectorMode == SECOND_VECTOR_EMPTY));
    VMA_VALIDATE(!suballocations1st.empty() ||
        suballocations2nd.empty() ||
        m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER);

    if (!suballocations1st.empty())
    {
        // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
        VMA_VALIDATE(suballocations1st[m_1stNullItemsBeginCount].type != VMA_SUBALLOCATION_TYPE_FREE);
        // Null item at the end should be just pop_back().
        VMA_VALIDATE(suballocations1st.back().type != VMA_SUBALLOCATION_TYPE_FREE);
    }
    if (!suballocations2nd.empty())
    {
        // Null item at the end should be just pop_back().
        VMA_VALIDATE(suballocations2nd.back().type != VMA_SUBALLOCATION_TYPE_FREE);
    }

    VMA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());
    VMA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());

    VkDeviceSize sumUsedSize = 0;
    const size_t suballoc1stCount = suballocations1st.size();
    const VkDeviceSize debugMargin = GetDebugMargin();
    VkDeviceSize offset = 0;

    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
    {
        const size_t suballoc2ndCount = suballocations2nd.size();
        size_t nullItem2ndCount = 0;
        for (size_t i = 0; i < suballoc2ndCount; ++i)
        {
            const VmaSuballocation& suballoc = suballocations2nd[i];
            const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);

            VmaAllocation const alloc = (VmaAllocation)suballoc.userData;
            if (!IsVirtual())
            {
                VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
            }
            VMA_VALIDATE(suballoc.offset >= offset);

            if (!currFree)
            {
                if (!IsVirtual())
                {
                    VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == suballoc.offset + 1);
                    VMA_VALIDATE(alloc->GetSize() == suballoc.size);
                }
                sumUsedSize += suballoc.size;
            }
            else
            {
                ++nullItem2ndCount;
            }

            offset = suballoc.offset + suballoc.size + debugMargin;
        }

        VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
    }

    for (size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
    {
        const VmaSuballocation& suballoc = suballocations1st[i];
        VMA_VALIDATE(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE &&
            suballoc.userData == VMA_NULL);
    }

    size_t nullItem1stCount = m_1stNullItemsBeginCount;

    for (size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
    {
        const VmaSuballocation& suballoc = suballocations1st[i];
        const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);

        VmaAllocation const alloc = (VmaAllocation)suballoc.userData;
        if (!IsVirtual())
        {
            VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
        }
        VMA_VALIDATE(suballoc.offset >= offset);
        VMA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);

        if (!currFree)
        {
            if (!IsVirtual())
            {
                VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == suballoc.offset + 1);
                VMA_VALIDATE(alloc->GetSize() == suballoc.size);
            }
            sumUsedSize += suballoc.size;
        }
        else
        {
            ++nullItem1stCount;
        }

        offset = suballoc.offset + suballoc.size + debugMargin;
    }
    VMA_VALIDATE(nullItem1stCount == m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount);

    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
    {
        const size_t suballoc2ndCount = suballocations2nd.size();
        size_t nullItem2ndCount = 0;
        for (size_t i = suballoc2ndCount; i--; )
        {
            const VmaSuballocation& suballoc = suballocations2nd[i];
            const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);

            VmaAllocation const alloc = (VmaAllocation)suballoc.userData;
            if (!IsVirtual())
            {
                VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
            }
            VMA_VALIDATE(suballoc.offset >= offset);

            if (!currFree)
            {
                if (!IsVirtual())
                {
                    VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == suballoc.offset + 1);
                    VMA_VALIDATE(alloc->GetSize() == suballoc.size);
                }
                sumUsedSize += suballoc.size;
            }
            else
            {
                ++nullItem2ndCount;
            }

            offset = suballoc.offset + suballoc.size + debugMargin;
        }

        VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
    }

    VMA_VALIDATE(offset <= GetSize());
    VMA_VALIDATE(m_SumFreeSize == GetSize() - sumUsedSize);

    return true;
}

size_t VmaBlockMetadata_Linear::GetAllocationCount() const
{
    return AccessSuballocations1st().size() - m_1stNullItemsBeginCount - m_1stNullItemsMiddleCount +
        AccessSuballocations2nd().size() - m_2ndNullItemsCount;
}

size_t VmaBlockMetadata_Linear::GetFreeRegionsCount() const
{
    // Function only used for defragmentation, which is disabled for this algorithm
    VMA_ASSERT(0);
    return SIZE_MAX;
}

void VmaBlockMetadata_Linear::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
{
    const VkDeviceSize size = GetSize();
    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
    const size_t suballoc1stCount = suballocations1st.size();
    const size_t suballoc2ndCount = suballocations2nd.size();

    inoutStats.statistics.blockCount++;
    inoutStats.statistics.blockBytes += size;

    VkDeviceSize lastOffset = 0;

    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
    {
        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        size_t nextAlloc2ndIndex = 0;
        while (lastOffset < freeSpace2ndTo1stEnd)
        {
            // Find next non-null allocation or move nextAllocIndex to the end.
            while (nextAlloc2ndIndex < suballoc2ndCount &&
                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
            {
                ++nextAlloc2ndIndex;
            }

            // Found non-null allocation.
            if (nextAlloc2ndIndex < suballoc2ndCount)
            {
                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];

                // 1. Process free space before this allocation.
                if (lastOffset < suballoc.offset)
                {
                    // There is free space from lastOffset to suballoc.offset.
                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
                    VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
                }

                // 2. Process this allocation.
                // There is allocation with suballoc.offset, suballoc.size.
                VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);

                // 3. Prepare for next iteration.
                lastOffset = suballoc.offset + suballoc.size;
                ++nextAlloc2ndIndex;
            }
            // We are at the end.
            else
            {
                // There is free space from lastOffset to freeSpace2ndTo1stEnd.
                if (lastOffset < freeSpace2ndTo1stEnd)
                {
                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
                    VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
                }

                // End of loop.
                lastOffset = freeSpace2ndTo1stEnd;
            }
        }
    }

    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
    const VkDeviceSize freeSpace1stTo2ndEnd =
        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
    while (lastOffset < freeSpace1stTo2ndEnd)
    {
        // Find next non-null allocation or move nextAllocIndex to the end.
        while (nextAlloc1stIndex < suballoc1stCount &&
            suballocations1st[nextAlloc1stIndex].userData == VMA_NULL)
        {
            ++nextAlloc1stIndex;
        }

        // Found non-null allocation.
        if (nextAlloc1stIndex < suballoc1stCount)
        {
            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];

            // 1. Process free space before this allocation.
            if (lastOffset < suballoc.offset)
            {
                // There is free space from lastOffset to suballoc.offset.
                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
                VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
            }

            // 2. Process this allocation.
            // There is allocation with suballoc.offset, suballoc.size.
            VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);

            // 3. Prepare for next iteration.
            lastOffset = suballoc.offset + suballoc.size;
            ++nextAlloc1stIndex;
        }
        // We are at the end.
        else
        {
            // There is free space from lastOffset to freeSpace1stTo2ndEnd.
            if (lastOffset < freeSpace1stTo2ndEnd)
            {
                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
                VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
            }

            // End of loop.
            lastOffset = freeSpace1stTo2ndEnd;
        }
    }

    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
    {
        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        while (lastOffset < size)
        {
            // Find next non-null allocation or move nextAllocIndex to the end.
            while (nextAlloc2ndIndex != SIZE_MAX &&
                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
            {
                --nextAlloc2ndIndex;
            }

            // Found non-null allocation.
            if (nextAlloc2ndIndex != SIZE_MAX)
            {
                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];

                // 1. Process free space before this allocation.
                if (lastOffset < suballoc.offset)
                {
                    // There is free space from lastOffset to suballoc.offset.
                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
                    VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
                }

                // 2. Process this allocation.
                // There is allocation with suballoc.offset, suballoc.size.
                VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);

                // 3. Prepare for next iteration.
                lastOffset = suballoc.offset + suballoc.size;
                --nextAlloc2ndIndex;
            }
            // We are at the end.
            else
            {
                // There is free space from lastOffset to size.
                if (lastOffset < size)
                {
                    const VkDeviceSize unusedRangeSize = size - lastOffset;
                    VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
                }

                // End of loop.
                lastOffset = size;
            }
        }
    }
}

void VmaBlockMetadata_Linear::AddStatistics(VmaStatistics& inoutStats) const
{
    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
    const VkDeviceSize size = GetSize();
    const size_t suballoc1stCount = suballocations1st.size();
    const size_t suballoc2ndCount = suballocations2nd.size();

    inoutStats.blockCount++;
    inoutStats.blockBytes += size;
    inoutStats.allocationBytes += size - m_SumFreeSize;

    VkDeviceSize lastOffset = 0;

    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
    {
        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
        while (lastOffset < freeSpace2ndTo1stEnd)
        {
            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
            while (nextAlloc2ndIndex < suballoc2ndCount &&
                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
            {
                ++nextAlloc2ndIndex;
            }

            // Found non-null allocation.
            if (nextAlloc2ndIndex < suballoc2ndCount)
            {
                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];

                // 1. Process free space before this allocation.
                if (lastOffset < suballoc.offset)
                {
                    // There is free space from lastOffset to suballoc.offset.
                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
                }

                // 2. Process this allocation.
                // There is allocation with suballoc.offset, suballoc.size.
                ++inoutStats.allocationCount;

                // 3. Prepare for next iteration.
                lastOffset = suballoc.offset + suballoc.size;
                ++nextAlloc2ndIndex;
            }
            // We are at the end.
            else
            {
                if (lastOffset < freeSpace2ndTo1stEnd)
                {
                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
                }

                // End of loop.
                lastOffset = freeSpace2ndTo1stEnd;
            }
        }
    }

    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
    const VkDeviceSize freeSpace1stTo2ndEnd =
        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
    while (lastOffset < freeSpace1stTo2ndEnd)
    {
        // Find next non-null allocation or move nextAllocIndex to the end.
        while (nextAlloc1stIndex < suballoc1stCount &&
            suballocations1st[nextAlloc1stIndex].userData == VMA_NULL)
        {
            ++nextAlloc1stIndex;
        }

        // Found non-null allocation.
        if (nextAlloc1stIndex < suballoc1stCount)
        {
            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];

            // 1. Process free space before this allocation.
            if (lastOffset < suballoc.offset)
            {
                // There is free space from lastOffset to suballoc.offset.
                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
            }

            // 2. Process this allocation.
            // There is allocation with suballoc.offset, suballoc.size.
            ++inoutStats.allocationCount;

            // 3. Prepare for next iteration.
            lastOffset = suballoc.offset + suballoc.size;
            ++nextAlloc1stIndex;
        }
        // We are at the end.
        else
        {
            if (lastOffset < freeSpace1stTo2ndEnd)
            {
                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
            }

            // End of loop.
            lastOffset = freeSpace1stTo2ndEnd;
        }
    }

    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
    {
        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        while (lastOffset < size)
        {
            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
            while (nextAlloc2ndIndex != SIZE_MAX &&
                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
            {
                --nextAlloc2ndIndex;
            }

            // Found non-null allocation.
            if (nextAlloc2ndIndex != SIZE_MAX)
            {
                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];

                // 1. Process free space before this allocation.
                if (lastOffset < suballoc.offset)
                {
                    // There is free space from lastOffset to suballoc.offset.
                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
                }

                // 2. Process this allocation.
                // There is allocation with suballoc.offset, suballoc.size.
                ++inoutStats.allocationCount;

                // 3. Prepare for next iteration.
                lastOffset = suballoc.offset + suballoc.size;
                --nextAlloc2ndIndex;
            }
            // We are at the end.
            else
            {
                if (lastOffset < size)
                {
                    // There is free space from lastOffset to size.
                    const VkDeviceSize unusedRangeSize = size - lastOffset;
                }

                // End of loop.
                lastOffset = size;
            }
        }
    }
}

#if VMA_STATS_STRING_ENABLED
void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
{
    const VkDeviceSize size = GetSize();
    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
    const size_t suballoc1stCount = suballocations1st.size();
    const size_t suballoc2ndCount = suballocations2nd.size();

    // FIRST PASS

    size_t unusedRangeCount = 0;
    VkDeviceSize usedBytes = 0;

    VkDeviceSize lastOffset = 0;

    size_t alloc2ndCount = 0;
    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
    {
        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        size_t nextAlloc2ndIndex = 0;
        while (lastOffset < freeSpace2ndTo1stEnd)
        {
            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
            while (nextAlloc2ndIndex < suballoc2ndCount &&
                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
            {
                ++nextAlloc2ndIndex;
            }

            // Found non-null allocation.
            if (nextAlloc2ndIndex < suballoc2ndCount)
            {
                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];

                // 1. Process free space before this allocation.
                if (lastOffset < suballoc.offset)
                {
                    // There is free space from lastOffset to suballoc.offset.
                    ++unusedRangeCount;
                }

                // 2. Process this allocation.
                // There is allocation with suballoc.offset, suballoc.size.
                ++alloc2ndCount;
                usedBytes += suballoc.size;

                // 3. Prepare for next iteration.
                lastOffset = suballoc.offset + suballoc.size;
                ++nextAlloc2ndIndex;
            }
            // We are at the end.
            else
            {
                if (lastOffset < freeSpace2ndTo1stEnd)
                {
                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
                    ++unusedRangeCount;
                }

                // End of loop.
                lastOffset = freeSpace2ndTo1stEnd;
            }
        }
    }

    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
    size_t alloc1stCount = 0;
    const VkDeviceSize freeSpace1stTo2ndEnd =
        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
    while (lastOffset < freeSpace1stTo2ndEnd)
    {
        // Find next non-null allocation or move nextAllocIndex to the end.
        while (nextAlloc1stIndex < suballoc1stCount &&
            suballocations1st[nextAlloc1stIndex].userData == VMA_NULL)
        {
            ++nextAlloc1stIndex;
        }

        // Found non-null allocation.
        if (nextAlloc1stIndex < suballoc1stCount)
        {
            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];

            // 1. Process free space before this allocation.
            if (lastOffset < suballoc.offset)
            {
                // There is free space from lastOffset to suballoc.offset.
                ++unusedRangeCount;
            }

            // 2. Process this allocation.
            // There is allocation with suballoc.offset, suballoc.size.
            ++alloc1stCount;
            usedBytes += suballoc.size;

            // 3. Prepare for next iteration.
            lastOffset = suballoc.offset + suballoc.size;
            ++nextAlloc1stIndex;
        }
        // We are at the end.
        else
        {
            if (lastOffset < size)
            {
                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
                ++unusedRangeCount;
            }

            // End of loop.
            lastOffset = freeSpace1stTo2ndEnd;
        }
    }

    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
    {
        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        while (lastOffset < size)
        {
            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
            while (nextAlloc2ndIndex != SIZE_MAX &&
                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
            {
                --nextAlloc2ndIndex;
            }

            // Found non-null allocation.
            if (nextAlloc2ndIndex != SIZE_MAX)
            {
                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];

                // 1. Process free space before this allocation.
                if (lastOffset < suballoc.offset)
                {
                    // There is free space from lastOffset to suballoc.offset.
                    ++unusedRangeCount;
                }

                // 2. Process this allocation.
                // There is allocation with suballoc.offset, suballoc.size.
                ++alloc2ndCount;
                usedBytes += suballoc.size;

                // 3. Prepare for next iteration.
                lastOffset = suballoc.offset + suballoc.size;
                --nextAlloc2ndIndex;
            }
            // We are at the end.
            else
            {
                if (lastOffset < size)
                {
                    // There is free space from lastOffset to size.
                    ++unusedRangeCount;
                }

                // End of loop.
                lastOffset = size;
            }
        }
    }

    const VkDeviceSize unusedBytes = size - usedBytes;
    PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);

    // SECOND PASS
    lastOffset = 0;

    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
    {
        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        size_t nextAlloc2ndIndex = 0;
        while (lastOffset < freeSpace2ndTo1stEnd)
        {
            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
            while (nextAlloc2ndIndex < suballoc2ndCount &&
                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
            {
                ++nextAlloc2ndIndex;
            }

            // Found non-null allocation.
            if (nextAlloc2ndIndex < suballoc2ndCount)
            {
                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];

                // 1. Process free space before this allocation.
                if (lastOffset < suballoc.offset)
                {
                    // There is free space from lastOffset to suballoc.offset.
                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
                }

                // 2. Process this allocation.
                // There is allocation with suballoc.offset, suballoc.size.
                PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);

                // 3. Prepare for next iteration.
                lastOffset = suballoc.offset + suballoc.size;
                ++nextAlloc2ndIndex;
            }
            // We are at the end.
            else
            {
                if (lastOffset < freeSpace2ndTo1stEnd)
                {
                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
                }

                // End of loop.
                lastOffset = freeSpace2ndTo1stEnd;
            }
        }
    }

    nextAlloc1stIndex = m_1stNullItemsBeginCount;
    while (lastOffset < freeSpace1stTo2ndEnd)
    {
        // Find next non-null allocation or move nextAllocIndex to the end.
        while (nextAlloc1stIndex < suballoc1stCount &&
            suballocations1st[nextAlloc1stIndex].userData == VMA_NULL)
        {
            ++nextAlloc1stIndex;
        }

        // Found non-null allocation.
        if (nextAlloc1stIndex < suballoc1stCount)
        {
            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];

            // 1. Process free space before this allocation.
            if (lastOffset < suballoc.offset)
            {
                // There is free space from lastOffset to suballoc.offset.
                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
                PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
            }

            // 2. Process this allocation.
            // There is allocation with suballoc.offset, suballoc.size.
            PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);

            // 3. Prepare for next iteration.
            lastOffset = suballoc.offset + suballoc.size;
            ++nextAlloc1stIndex;
        }
        // We are at the end.
        else
        {
            if (lastOffset < freeSpace1stTo2ndEnd)
            {
                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
                PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
            }

            // End of loop.
            lastOffset = freeSpace1stTo2ndEnd;
        }
    }

    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
    {
        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        while (lastOffset < size)
        {
            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
            while (nextAlloc2ndIndex != SIZE_MAX &&
                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
            {
                --nextAlloc2ndIndex;
            }

            // Found non-null allocation.
            if (nextAlloc2ndIndex != SIZE_MAX)
            {
                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];

                // 1. Process free space before this allocation.
                if (lastOffset < suballoc.offset)
                {
                    // There is free space from lastOffset to suballoc.offset.
                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
                }

                // 2. Process this allocation.
                // There is allocation with suballoc.offset, suballoc.size.
                PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);

                // 3. Prepare for next iteration.
                lastOffset = suballoc.offset + suballoc.size;
                --nextAlloc2ndIndex;
            }
            // We are at the end.
            else
            {
                if (lastOffset < size)
                {
                    // There is free space from lastOffset to size.
                    const VkDeviceSize unusedRangeSize = size - lastOffset;
                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
                }

                // End of loop.
                lastOffset = size;
            }
        }
    }

    PrintDetailedMap_End(json);
}
#endif // VMA_STATS_STRING_ENABLED

bool VmaBlockMetadata_Linear::CreateAllocationRequest(
    VkDeviceSize allocSize,
    VkDeviceSize allocAlignment,
    bool upperAddress,
    VmaSuballocationType allocType,
    uint32_t strategy,
    VmaAllocationRequest* pAllocationRequest)
{
    VMA_ASSERT(allocSize > 0);
    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
    VMA_ASSERT(pAllocationRequest != VMA_NULL);
    VMA_HEAVY_ASSERT(Validate());
    pAllocationRequest->size = allocSize;
    return upperAddress ?
        CreateAllocationRequest_UpperAddress(
            allocSize, allocAlignment, allocType, strategy, pAllocationRequest) :
        CreateAllocationRequest_LowerAddress(
            allocSize, allocAlignment, allocType, strategy, pAllocationRequest);
}

VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
{
    VMA_ASSERT(!IsVirtual());
    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    for (size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
    {
        const VmaSuballocation& suballoc = suballocations1st[i];
        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        {
            if (!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
            {
                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
                return VK_ERROR_UNKNOWN_COPY;
            }
        }
    }

    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
    for (size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
    {
        const VmaSuballocation& suballoc = suballocations2nd[i];
        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        {
            if (!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
            {
                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
                return VK_ERROR_UNKNOWN_COPY;
            }
        }
    }

    return VK_SUCCESS;
}

void VmaBlockMetadata_Linear::Alloc(
    const VmaAllocationRequest& request,
    VmaSuballocationType type,
    void* userData)
{
    const VkDeviceSize offset = (VkDeviceSize)request.allocHandle - 1;
    const VmaSuballocation newSuballoc = { offset, request.size, userData, type };

    switch (request.type)
    {
    case VmaAllocationRequestType::UpperAddress:
    {
        VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
            "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
        SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        suballocations2nd.push_back(newSuballoc);
        m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
    }
    break;
    case VmaAllocationRequestType::EndOf1st:
    {
        SuballocationVectorType& suballocations1st = AccessSuballocations1st();

        VMA_ASSERT(suballocations1st.empty() ||
            offset >= suballocations1st.back().offset + suballocations1st.back().size);
        // Check if it fits before the end of the block.
        VMA_ASSERT(offset + request.size <= GetSize());

        suballocations1st.push_back(newSuballoc);
    }
    break;
    case VmaAllocationRequestType::EndOf2nd:
    {
        SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
        VMA_ASSERT(!suballocations1st.empty() &&
            offset + request.size <= suballocations1st[m_1stNullItemsBeginCount].offset);
        SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

        switch (m_2ndVectorMode)
        {
        case SECOND_VECTOR_EMPTY:
            // First allocation from second part ring buffer.
            VMA_ASSERT(suballocations2nd.empty());
            m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
            break;
        case SECOND_VECTOR_RING_BUFFER:
            // 2-part ring buffer is already started.
            VMA_ASSERT(!suballocations2nd.empty());
            break;
        case SECOND_VECTOR_DOUBLE_STACK:
            VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
            break;
        default:
            VMA_ASSERT(0);
        }

        suballocations2nd.push_back(newSuballoc);
    }
    break;
    default:
        VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
    }

    m_SumFreeSize -= newSuballoc.size;
}

void VmaBlockMetadata_Linear::Free(VmaAllocHandle allocHandle)
{
    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
    VkDeviceSize offset = (VkDeviceSize)allocHandle - 1;

    if (!suballocations1st.empty())
    {
        // First allocation: Mark it as next empty at the beginning.
        VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        if (firstSuballoc.offset == offset)
        {
            firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
            firstSuballoc.userData = VMA_NULL;
            m_SumFreeSize += firstSuballoc.size;
            ++m_1stNullItemsBeginCount;
            CleanupAfterFree();
            return;
        }
    }

    // Last allocation in 2-part ring buffer or top of upper stack (same logic).
    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
    {
        VmaSuballocation& lastSuballoc = suballocations2nd.back();
        if (lastSuballoc.offset == offset)
        {
            m_SumFreeSize += lastSuballoc.size;
            suballocations2nd.pop_back();
            CleanupAfterFree();
            return;
        }
    }
    // Last allocation in 1st vector.
    else if (m_2ndVectorMode == SECOND_VECTOR_EMPTY)
    {
        VmaSuballocation& lastSuballoc = suballocations1st.back();
        if (lastSuballoc.offset == offset)
        {
            m_SumFreeSize += lastSuballoc.size;
            suballocations1st.pop_back();
            CleanupAfterFree();
            return;
        }
    }

    VmaSuballocation refSuballoc;
    refSuballoc.offset = offset;
    // Rest of members stays uninitialized intentionally for better performance.

    // Item from the middle of 1st vector.
    {
        const SuballocationVectorType::iterator it = VmaBinaryFindSorted(
            suballocations1st.begin() + m_1stNullItemsBeginCount,
            suballocations1st.end(),
            refSuballoc,
            VmaSuballocationOffsetLess());
        if (it != suballocations1st.end())
        {
            it->type = VMA_SUBALLOCATION_TYPE_FREE;
            it->userData = VMA_NULL;
            ++m_1stNullItemsMiddleCount;
            m_SumFreeSize += it->size;
            CleanupAfterFree();
            return;
        }
    }

    if (m_2ndVectorMode != SECOND_VECTOR_EMPTY)
    {
        // Item from the middle of 2nd vector.
        const SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
        if (it != suballocations2nd.end())
        {
            it->type = VMA_SUBALLOCATION_TYPE_FREE;
            it->userData = VMA_NULL;
            ++m_2ndNullItemsCount;
            m_SumFreeSize += it->size;
            CleanupAfterFree();
            return;
        }
    }

    VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
}

void VmaBlockMetadata_Linear::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
{
    outInfo.offset = (VkDeviceSize)allocHandle - 1;
    VmaSuballocation& suballoc = FindSuballocation(outInfo.offset);
    outInfo.size = suballoc.size;
    outInfo.pUserData = suballoc.userData;
}

void* VmaBlockMetadata_Linear::GetAllocationUserData(VmaAllocHandle allocHandle) const
{
    return FindSuballocation((VkDeviceSize)allocHandle - 1).userData;
}

VmaAllocHandle VmaBlockMetadata_Linear::GetAllocationListBegin() const
{
    // Function only used for defragmentation, which is disabled for this algorithm
    VMA_ASSERT(0);
    return VK_NULL_HANDLE;
}

VmaAllocHandle VmaBlockMetadata_Linear::GetNextAllocation(VmaAllocHandle prevAlloc) const
{
    // Function only used for defragmentation, which is disabled for this algorithm
    VMA_ASSERT(0);
    return VK_NULL_HANDLE;
}

VkDeviceSize VmaBlockMetadata_Linear::GetNextFreeRegionSize(VmaAllocHandle alloc) const
{
    // Function only used for defragmentation, which is disabled for this algorithm
    VMA_ASSERT(0);
    return 0;
}

void VmaBlockMetadata_Linear::Clear()
{
    m_SumFreeSize = GetSize();
    m_Suballocations0.clear();
    m_Suballocations1.clear();
    // Leaving m_1stVectorIndex unchanged - it doesn't matter.
    m_2ndVectorMode = SECOND_VECTOR_EMPTY;
    m_1stNullItemsBeginCount = 0;
    m_1stNullItemsMiddleCount = 0;
    m_2ndNullItemsCount = 0;
}

void VmaBlockMetadata_Linear::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
{
    VmaSuballocation& suballoc = FindSuballocation((VkDeviceSize)allocHandle - 1);
    suballoc.userData = userData;
}

void VmaBlockMetadata_Linear::DebugLogAllAllocations() const
{
    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    for (auto it = suballocations1st.begin() + m_1stNullItemsBeginCount; it != suballocations1st.end(); ++it)
        if (it->type != VMA_SUBALLOCATION_TYPE_FREE)
            DebugLogAllocation(it->offset, it->size, it->userData);

    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
    for (auto it = suballocations2nd.begin(); it != suballocations2nd.end(); ++it)
        if (it->type != VMA_SUBALLOCATION_TYPE_FREE)
            DebugLogAllocation(it->offset, it->size, it->userData);
}

VmaSuballocation& VmaBlockMetadata_Linear::FindSuballocation(VkDeviceSize offset) const
{
    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

    VmaSuballocation refSuballoc;
    refSuballoc.offset = offset;
    // Rest of members stays uninitialized intentionally for better performance.

    // Item from the 1st vector.
    {
        SuballocationVectorType::const_iterator it = VmaBinaryFindSorted(
            suballocations1st.begin() + m_1stNullItemsBeginCount,
            suballocations1st.end(),
            refSuballoc,
            VmaSuballocationOffsetLess());
        if (it != suballocations1st.end())
        {
            return const_cast<VmaSuballocation&>(*it);
        }
    }

    if (m_2ndVectorMode != SECOND_VECTOR_EMPTY)
    {
        // Rest of members stays uninitialized intentionally for better performance.
        SuballocationVectorType::const_iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
        if (it != suballocations2nd.end())
        {
            return const_cast<VmaSuballocation&>(*it);
        }
    }

    VMA_ASSERT(0 && "Allocation not found in linear allocator!");
    return const_cast<VmaSuballocation&>(suballocations1st.back()); // Should never occur.
}

bool VmaBlockMetadata_Linear::ShouldCompact1st() const
{
    const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
    const size_t suballocCount = AccessSuballocations1st().size();
    return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
}

void VmaBlockMetadata_Linear::CleanupAfterFree()
{
    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

    if (IsEmpty())
    {
        suballocations1st.clear();
        suballocations2nd.clear();
        m_1stNullItemsBeginCount = 0;
        m_1stNullItemsMiddleCount = 0;
        m_2ndNullItemsCount = 0;
        m_2ndVectorMode = SECOND_VECTOR_EMPTY;
    }
    else
    {
        const size_t suballoc1stCount = suballocations1st.size();
        const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        VMA_ASSERT(nullItem1stCount <= suballoc1stCount);

        // Find more null items at the beginning of 1st vector.
        while (m_1stNullItemsBeginCount < suballoc1stCount &&
            suballocations1st[m_1stNullItemsBeginCount].type == VMA_SUBALLOCATION_TYPE_FREE)
        {
            ++m_1stNullItemsBeginCount;
            --m_1stNullItemsMiddleCount;
        }

        // Find more null items at the end of 1st vector.
        while (m_1stNullItemsMiddleCount > 0 &&
            suballocations1st.back().type == VMA_SUBALLOCATION_TYPE_FREE)
        {
            --m_1stNullItemsMiddleCount;
            suballocations1st.pop_back();
        }

        // Find more null items at the end of 2nd vector.
        while (m_2ndNullItemsCount > 0 &&
            suballocations2nd.back().type == VMA_SUBALLOCATION_TYPE_FREE)
        {
            --m_2ndNullItemsCount;
            suballocations2nd.pop_back();
        }

        // Find more null items at the beginning of 2nd vector.
        while (m_2ndNullItemsCount > 0 &&
            suballocations2nd[0].type == VMA_SUBALLOCATION_TYPE_FREE)
        {
            --m_2ndNullItemsCount;
            VmaVectorRemove(suballocations2nd, 0);
        }

        if (ShouldCompact1st())
        {
            const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
            size_t srcIndex = m_1stNullItemsBeginCount;
            for (size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
            {
                while (suballocations1st[srcIndex].type == VMA_SUBALLOCATION_TYPE_FREE)
                {
                    ++srcIndex;
                }
                if (dstIndex != srcIndex)
                {
                    suballocations1st[dstIndex] = suballocations1st[srcIndex];
                }
                ++srcIndex;
            }
            suballocations1st.resize(nonNullItemCount);
            m_1stNullItemsBeginCount = 0;
            m_1stNullItemsMiddleCount = 0;
        }

        // 2nd vector became empty.
        if (suballocations2nd.empty())
        {
            m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        }

        // 1st vector became empty.
        if (suballocations1st.size() - m_1stNullItemsBeginCount == 0)
        {
            suballocations1st.clear();
            m_1stNullItemsBeginCount = 0;

            if (!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
            {
                // Swap 1st with 2nd. Now 2nd is empty.
                m_2ndVectorMode = SECOND_VECTOR_EMPTY;
                m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
                while (m_1stNullItemsBeginCount < suballocations2nd.size() &&
                    suballocations2nd[m_1stNullItemsBeginCount].type == VMA_SUBALLOCATION_TYPE_FREE)
                {
                    ++m_1stNullItemsBeginCount;
                    --m_1stNullItemsMiddleCount;
                }
                m_2ndNullItemsCount = 0;
                m_1stVectorIndex ^= 1;
            }
        }
    }

    VMA_HEAVY_ASSERT(Validate());
}

bool VmaBlockMetadata_Linear::CreateAllocationRequest_LowerAddress(
    VkDeviceSize allocSize,
    VkDeviceSize allocAlignment,
    VmaSuballocationType allocType,
    uint32_t strategy,
    VmaAllocationRequest* pAllocationRequest)
{
    const VkDeviceSize blockSize = GetSize();
    const VkDeviceSize debugMargin = GetDebugMargin();
    const VkDeviceSize bufferImageGranularity = GetBufferImageGranularity();
    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

    if (m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
    {
        // Try to allocate at the end of 1st vector.

        VkDeviceSize resultBaseOffset = 0;
        if (!suballocations1st.empty())
        {
            const VmaSuballocation& lastSuballoc = suballocations1st.back();
            resultBaseOffset = lastSuballoc.offset + lastSuballoc.size + debugMargin;
        }

        // Start from offset equal to beginning of free space.
        VkDeviceSize resultOffset = resultBaseOffset;

        // Apply alignment.
        resultOffset = VmaAlignUp(resultOffset, allocAlignment);

        // Check previous suballocations for BufferImageGranularity conflicts.
        // Make bigger alignment if necessary.
        if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment && !suballocations1st.empty())
        {
            bool bufferImageGranularityConflict = false;
            for (size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
            {
                const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
                if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
                {
                    if (VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
                    {
                        bufferImageGranularityConflict = true;
                        break;
                    }
                }
                else
                    // Already on previous page.
                    break;
            }
            if (bufferImageGranularityConflict)
            {
                resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
            }
        }

        const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
            suballocations2nd.back().offset : blockSize;

        // There is enough free space at the end after alignment.
        if (resultOffset + allocSize + debugMargin <= freeSpaceEnd)
        {
            // Check next suballocations for BufferImageGranularity conflicts.
            // If conflict exists, allocation cannot be made here.
            if ((allocSize % bufferImageGranularity || resultOffset % bufferImageGranularity) && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
            {
                for (size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
                {
                    const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
                    if (VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
                    {
                        if (VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        // Already on previous page.
                        break;
                    }
                }
            }

            // All tests passed: Success.
            pAllocationRequest->allocHandle = (VmaAllocHandle)(resultOffset + 1);
            // pAllocationRequest->item, customData unused.
            pAllocationRequest->type = VmaAllocationRequestType::EndOf1st;
            return true;
        }
    }

    // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
    // beginning of 1st vector as the end of free space.
    if (m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
    {
        VMA_ASSERT(!suballocations1st.empty());

        VkDeviceSize resultBaseOffset = 0;
        if (!suballocations2nd.empty())
        {
            const VmaSuballocation& lastSuballoc = suballocations2nd.back();
            resultBaseOffset = lastSuballoc.offset + lastSuballoc.size + debugMargin;
        }

        // Start from offset equal to beginning of free space.
        VkDeviceSize resultOffset = resultBaseOffset;

        // Apply alignment.
        resultOffset = VmaAlignUp(resultOffset, allocAlignment);

        // Check previous suballocations for BufferImageGranularity conflicts.
        // Make bigger alignment if necessary.
        if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment && !suballocations2nd.empty())
        {
            bool bufferImageGranularityConflict = false;
            for (size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
            {
                const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
                if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
                {
                    if (VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
                    {
                        bufferImageGranularityConflict = true;
                        break;
                    }
                }
                else
                    // Already on previous page.
                    break;
            }
            if (bufferImageGranularityConflict)
            {
                resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
            }
        }

        size_t index1st = m_1stNullItemsBeginCount;

        // There is enough free space at the end after alignment.
        if ((index1st == suballocations1st.size() && resultOffset + allocSize + debugMargin <= blockSize) ||
            (index1st < suballocations1st.size() && resultOffset + allocSize + debugMargin <= suballocations1st[index1st].offset))
        {
            // Check next suballocations for BufferImageGranularity conflicts.
            // If conflict exists, allocation cannot be made here.
            if (allocSize % bufferImageGranularity || resultOffset % bufferImageGranularity)
            {
                for (size_t nextSuballocIndex = index1st;
                    nextSuballocIndex < suballocations1st.size();
                    nextSuballocIndex++)
                {
                    const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
                    if (VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
                    {
                        if (VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        // Already on next page.
                        break;
                    }
                }
            }

            // All tests passed: Success.
            pAllocationRequest->allocHandle = (VmaAllocHandle)(resultOffset + 1);
            pAllocationRequest->type = VmaAllocationRequestType::EndOf2nd;
            // pAllocationRequest->item, customData unused.
            return true;
        }
    }

    return false;
}

bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
    VkDeviceSize allocSize,
    VkDeviceSize allocAlignment,
    VmaSuballocationType allocType,
    uint32_t strategy,
    VmaAllocationRequest* pAllocationRequest)
{
    const VkDeviceSize blockSize = GetSize();
    const VkDeviceSize bufferImageGranularity = GetBufferImageGranularity();
    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
    {
        VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
        return false;
    }

    // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
    if (allocSize > blockSize)
    {
        return false;
    }
    VkDeviceSize resultBaseOffset = blockSize - allocSize;
    if (!suballocations2nd.empty())
    {
        const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        resultBaseOffset = lastSuballoc.offset - allocSize;
        if (allocSize > lastSuballoc.offset)
        {
            return false;
        }
    }

    // Start from offset equal to end of free space.
    VkDeviceSize resultOffset = resultBaseOffset;

    const VkDeviceSize debugMargin = GetDebugMargin();

    // Apply debugMargin at the end.
    if (debugMargin > 0)
    {
        if (resultOffset < debugMargin)
        {
            return false;
        }
        resultOffset -= debugMargin;
    }

    // Apply alignment.
    resultOffset = VmaAlignDown(resultOffset, allocAlignment);

    // Check next suballocations from 2nd for BufferImageGranularity conflicts.
    // Make bigger alignment if necessary.
    if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment && !suballocations2nd.empty())
    {
        bool bufferImageGranularityConflict = false;
        for (size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        {
            const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
            if (VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
            {
                if (VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
                {
                    bufferImageGranularityConflict = true;
                    break;
                }
            }
            else
                // Already on previous page.
                break;
        }
        if (bufferImageGranularityConflict)
        {
            resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
        }
    }

    // There is enough free space.
    const VkDeviceSize endOf1st = !suballocations1st.empty() ?
        suballocations1st.back().offset + suballocations1st.back().size :
        0;
    if (endOf1st + debugMargin <= resultOffset)
    {
        // Check previous suballocations for BufferImageGranularity conflicts.
        // If conflict exists, allocation cannot be made here.
        if (bufferImageGranularity > 1)
        {
            for (size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
            {
                const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
                if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
                {
                    if (VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
                    {
                        return false;
                    }
                }
                else
                {
                    // Already on next page.
                    break;
                }
            }
        }

        // All tests passed: Success.
        pAllocationRequest->allocHandle = (VmaAllocHandle)(resultOffset + 1);
        // pAllocationRequest->item unused.
        pAllocationRequest->type = VmaAllocationRequestType::UpperAddress;
        return true;
    }

    return false;
}
#endif // _VMA_BLOCK_METADATA_LINEAR_FUNCTIONS
#endif // _VMA_BLOCK_METADATA_LINEAR

#if 0
#ifndef _VMA_BLOCK_METADATA_BUDDY
/*
- GetSize() is the original size of allocated memory block.
- m_UsableSize is this size aligned down to a power of two.
  All allocations and calculations happen relative to m_UsableSize.
- GetUnusableSize() is the difference between them.
  It is reported as separate, unused range, not available for allocations.

Node at level 0 has size = m_UsableSize.
Each next level contains nodes with size 2 times smaller than current level.
m_LevelCount is the maximum number of levels to use in the current object.
*/
class VmaBlockMetadata_Buddy : public VmaBlockMetadata
{
    VMA_CLASS_NO_COPY(VmaBlockMetadata_Buddy)
public:
    VmaBlockMetadata_Buddy(const VkAllocationCallbacks* pAllocationCallbacks,
        VkDeviceSize bufferImageGranularity, bool isVirtual);
    virtual ~VmaBlockMetadata_Buddy();

    size_t GetAllocationCount() const override { return m_AllocationCount; }
    VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize + GetUnusableSize(); }
    bool IsEmpty() const override { return m_Root->type == Node::TYPE_FREE; }
    VkResult CheckCorruption(const void* pBlockData) override { return VK_ERROR_FEATURE_NOT_PRESENT; }
    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return (VkDeviceSize)allocHandle - 1; }
    void DebugLogAllAllocations() const override { DebugLogAllAllocationNode(m_Root, 0); }

    void Init(VkDeviceSize size) override;
    bool Validate() const override;

    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
    void AddStatistics(VmaStatistics& inoutStats) const override;

#if VMA_STATS_STRING_ENABLED
    void PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const override;
#endif

    bool CreateAllocationRequest(
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        bool upperAddress,
        VmaSuballocationType allocType,
        uint32_t strategy,
        VmaAllocationRequest* pAllocationRequest) override;

    void Alloc(
        const VmaAllocationRequest& request,
        VmaSuballocationType type,
        void* userData) override;

    void Free(VmaAllocHandle allocHandle) override;
    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
    VmaAllocHandle GetAllocationListBegin() const override;
    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
    void Clear() override;
    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;

private:
    static const size_t MAX_LEVELS = 48;

    struct ValidationContext
    {
        size_t calculatedAllocationCount = 0;
        size_t calculatedFreeCount = 0;
        VkDeviceSize calculatedSumFreeSize = 0;
    };
    struct Node
    {
        VkDeviceSize offset;
        enum TYPE
        {
            TYPE_FREE,
            TYPE_ALLOCATION,
            TYPE_SPLIT,
            TYPE_COUNT
        } type;
        Node* parent;
        Node* buddy;

        union
        {
            struct
            {
                Node* prev;
                Node* next;
            } free;
            struct
            {
                void* userData;
            } allocation;
            struct
            {
                Node* leftChild;
            } split;
        };
    };

    // Size of the memory block aligned down to a power of two.
    VkDeviceSize m_UsableSize;
    uint32_t m_LevelCount;
    VmaPoolAllocator<Node> m_NodeAllocator;
    Node* m_Root;
    struct
    {
        Node* front;
        Node* back;
    } m_FreeList[MAX_LEVELS];

    // Number of nodes in the tree with type == TYPE_ALLOCATION.
    size_t m_AllocationCount;
    // Number of nodes in the tree with type == TYPE_FREE.
    size_t m_FreeCount;
    // Doesn't include space wasted due to internal fragmentation - allocation sizes are just aligned up to node sizes.
    // Doesn't include unusable size.
    VkDeviceSize m_SumFreeSize;

    VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }
    VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }

    VkDeviceSize AlignAllocationSize(VkDeviceSize size) const
    {
        if (!IsVirtual())
        {
            size = VmaAlignUp(size, (VkDeviceSize)16);
        }
        return VmaNextPow2(size);
    }
    Node* FindAllocationNode(VkDeviceSize offset, uint32_t& outLevel) const;
    void DeleteNodeChildren(Node* node);
    bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;
    uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;
    void AddNodeToDetailedStatistics(VmaDetailedStatistics& inoutStats, const Node* node, VkDeviceSize levelNodeSize) const;
    // Adds node to the front of FreeList at given level.
    // node->type must be FREE.
    // node->free.prev, next can be undefined.
    void AddToFreeListFront(uint32_t level, Node* node);
    // Removes node from FreeList at given level.
    // node->type must be FREE.
    // node->free.prev, next stay untouched.
    void RemoveFromFreeList(uint32_t level, Node* node);
    void DebugLogAllAllocationNode(Node* node, uint32_t level) const;

#if VMA_STATS_STRING_ENABLED
    void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;
#endif
};

#ifndef _VMA_BLOCK_METADATA_BUDDY_FUNCTIONS
VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(const VkAllocationCallbacks* pAllocationCallbacks,
    VkDeviceSize bufferImageGranularity, bool isVirtual)
    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
    m_NodeAllocator(pAllocationCallbacks, 32), // firstBlockCapacity
    m_Root(VMA_NULL),
    m_AllocationCount(0),
    m_FreeCount(1),
    m_SumFreeSize(0)
{
    memset(m_FreeList, 0, sizeof(m_FreeList));
}

VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()
{
    DeleteNodeChildren(m_Root);
    m_NodeAllocator.Free(m_Root);
}

void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)
{
    VmaBlockMetadata::Init(size);

    m_UsableSize = VmaPrevPow2(size);
    m_SumFreeSize = m_UsableSize;

    // Calculate m_LevelCount.
    const VkDeviceSize minNodeSize = IsVirtual() ? 1 : 16;
    m_LevelCount = 1;
    while (m_LevelCount < MAX_LEVELS &&
        LevelToNodeSize(m_LevelCount) >= minNodeSize)
    {
        ++m_LevelCount;
    }

    Node* rootNode = m_NodeAllocator.Alloc();
    rootNode->offset = 0;
    rootNode->type = Node::TYPE_FREE;
    rootNode->parent = VMA_NULL;
    rootNode->buddy = VMA_NULL;

    m_Root = rootNode;
    AddToFreeListFront(0, rootNode);
}

bool VmaBlockMetadata_Buddy::Validate() const
{
    // Validate tree.
    ValidationContext ctx;
    if (!ValidateNode(ctx, VMA_NULL, m_Root, 0, LevelToNodeSize(0)))
    {
        VMA_VALIDATE(false && "ValidateNode failed.");
    }
    VMA_VALIDATE(m_AllocationCount == ctx.calculatedAllocationCount);
    VMA_VALIDATE(m_SumFreeSize == ctx.calculatedSumFreeSize);

    // Validate free node lists.
    for (uint32_t level = 0; level < m_LevelCount; ++level)
    {
        VMA_VALIDATE(m_FreeList[level].front == VMA_NULL ||
            m_FreeList[level].front->free.prev == VMA_NULL);

        for (Node* node = m_FreeList[level].front;
            node != VMA_NULL;
            node = node->free.next)
        {
            VMA_VALIDATE(node->type == Node::TYPE_FREE);

            if (node->free.next == VMA_NULL)
            {
                VMA_VALIDATE(m_FreeList[level].back == node);
            }
            else
            {
                VMA_VALIDATE(node->free.next->free.prev == node);
            }
        }
    }

    // Validate that free lists ar higher levels are empty.
    for (uint32_t level = m_LevelCount; level < MAX_LEVELS; ++level)
    {
        VMA_VALIDATE(m_FreeList[level].front == VMA_NULL && m_FreeList[level].back == VMA_NULL);
    }

    return true;
}

void VmaBlockMetadata_Buddy::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
{
    inoutStats.statistics.blockCount++;
    inoutStats.statistics.blockBytes += GetSize();

    AddNodeToDetailedStatistics(inoutStats, m_Root, LevelToNodeSize(0));

    const VkDeviceSize unusableSize = GetUnusableSize();
    if (unusableSize > 0)
        VmaAddDetailedStatisticsUnusedRange(inoutStats, unusableSize);
}

void VmaBlockMetadata_Buddy::AddStatistics(VmaStatistics& inoutStats) const
{
    inoutStats.blockCount++;
    inoutStats.allocationCount += (uint32_t)m_AllocationCount;
    inoutStats.blockBytes += GetSize();
    inoutStats.allocationBytes += GetSize() - m_SumFreeSize;
}

#if VMA_STATS_STRING_ENABLED
void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const
{
    VmaDetailedStatistics stats;
    VmaClearDetailedStatistics(stats);
    AddDetailedStatistics(stats);

    PrintDetailedMap_Begin(
        json,
        stats.statistics.blockBytes - stats.statistics.allocationBytes,
        stats.statistics.allocationCount,
        stats.unusedRangeCount,
        mapRefCount);

    PrintDetailedMapNode(json, m_Root, LevelToNodeSize(0));

    const VkDeviceSize unusableSize = GetUnusableSize();
    if (unusableSize > 0)
    {
        PrintDetailedMap_UnusedRange(json,
            m_UsableSize, // offset
            unusableSize); // size
    }

    PrintDetailedMap_End(json);
}
#endif // VMA_STATS_STRING_ENABLED

bool VmaBlockMetadata_Buddy::CreateAllocationRequest(
    VkDeviceSize allocSize,
    VkDeviceSize allocAlignment,
    bool upperAddress,
    VmaSuballocationType allocType,
    uint32_t strategy,
    VmaAllocationRequest* pAllocationRequest)
{
    VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");

    allocSize = AlignAllocationSize(allocSize);

    // Simple way to respect bufferImageGranularity. May be optimized some day.
    // Whenever it might be an OPTIMAL image...
    if (allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
        allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
    {
        allocAlignment = VMA_MAX(allocAlignment, GetBufferImageGranularity());
        allocSize = VmaAlignUp(allocSize, GetBufferImageGranularity());
    }

    if (allocSize > m_UsableSize)
    {
        return false;
    }

    const uint32_t targetLevel = AllocSizeToLevel(allocSize);
    for (uint32_t level = targetLevel; level--; )
    {
        for (Node* freeNode = m_FreeList[level].front;
            freeNode != VMA_NULL;
            freeNode = freeNode->free.next)
        {
            if (freeNode->offset % allocAlignment == 0)
            {
                pAllocationRequest->type = VmaAllocationRequestType::Normal;
                pAllocationRequest->allocHandle = (VmaAllocHandle)(freeNode->offset + 1);
                pAllocationRequest->size = allocSize;
                pAllocationRequest->customData = (void*)(uintptr_t)level;
                return true;
            }
        }
    }

    return false;
}

void VmaBlockMetadata_Buddy::Alloc(
    const VmaAllocationRequest& request,
    VmaSuballocationType type,
    void* userData)
{
    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);

    const uint32_t targetLevel = AllocSizeToLevel(request.size);
    uint32_t currLevel = (uint32_t)(uintptr_t)request.customData;

    Node* currNode = m_FreeList[currLevel].front;
    VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
    const VkDeviceSize offset = (VkDeviceSize)request.allocHandle - 1;
    while (currNode->offset != offset)
    {
        currNode = currNode->free.next;
        VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
    }

    // Go down, splitting free nodes.
    while (currLevel < targetLevel)
    {
        // currNode is already first free node at currLevel.
        // Remove it from list of free nodes at this currLevel.
        RemoveFromFreeList(currLevel, currNode);

        const uint32_t childrenLevel = currLevel + 1;

        // Create two free sub-nodes.
        Node* leftChild = m_NodeAllocator.Alloc();
        Node* rightChild = m_NodeAllocator.Alloc();

        leftChild->offset = currNode->offset;
        leftChild->type = Node::TYPE_FREE;
        leftChild->parent = currNode;
        leftChild->buddy = rightChild;

        rightChild->offset = currNode->offset + LevelToNodeSize(childrenLevel);
        rightChild->type = Node::TYPE_FREE;
        rightChild->parent = currNode;
        rightChild->buddy = leftChild;

        // Convert current currNode to split type.
        currNode->type = Node::TYPE_SPLIT;
        currNode->split.leftChild = leftChild;

        // Add child nodes to free list. Order is important!
        AddToFreeListFront(childrenLevel, rightChild);
        AddToFreeListFront(childrenLevel, leftChild);

        ++m_FreeCount;
        ++currLevel;
        currNode = m_FreeList[currLevel].front;

        /*
        We can be sure that currNode, as left child of node previously split,
        also fulfills the alignment requirement.
        */
    }

    // Remove from free list.
    VMA_ASSERT(currLevel == targetLevel &&
        currNode != VMA_NULL &&
        currNode->type == Node::TYPE_FREE);
    RemoveFromFreeList(currLevel, currNode);

    // Convert to allocation node.
    currNode->type = Node::TYPE_ALLOCATION;
    currNode->allocation.userData = userData;

    ++m_AllocationCount;
    --m_FreeCount;
    m_SumFreeSize -= request.size;
}

void VmaBlockMetadata_Buddy::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
{
    uint32_t level = 0;
    outInfo.offset = (VkDeviceSize)allocHandle - 1;
    const Node* const node = FindAllocationNode(outInfo.offset, level);
    outInfo.size = LevelToNodeSize(level);
    outInfo.pUserData = node->allocation.userData;
}

void* VmaBlockMetadata_Buddy::GetAllocationUserData(VmaAllocHandle allocHandle) const
{
    uint32_t level = 0;
    const Node* const node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);
    return node->allocation.userData;
}

VmaAllocHandle VmaBlockMetadata_Buddy::GetAllocationListBegin() const
{
    // Function only used for defragmentation, which is disabled for this algorithm
    return VK_NULL_HANDLE;
}

VmaAllocHandle VmaBlockMetadata_Buddy::GetNextAllocation(VmaAllocHandle prevAlloc) const
{
    // Function only used for defragmentation, which is disabled for this algorithm
    return VK_NULL_HANDLE;
}

void VmaBlockMetadata_Buddy::DeleteNodeChildren(Node* node)
{
    if (node->type == Node::TYPE_SPLIT)
    {
        DeleteNodeChildren(node->split.leftChild->buddy);
        DeleteNodeChildren(node->split.leftChild);
        const VkAllocationCallbacks* allocationCallbacks = GetAllocationCallbacks();
        m_NodeAllocator.Free(node->split.leftChild->buddy);
        m_NodeAllocator.Free(node->split.leftChild);
    }
}

void VmaBlockMetadata_Buddy::Clear()
{
    DeleteNodeChildren(m_Root);
    m_Root->type = Node::TYPE_FREE;
    m_AllocationCount = 0;
    m_FreeCount = 1;
    m_SumFreeSize = m_UsableSize;
}

void VmaBlockMetadata_Buddy::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
{
    uint32_t level = 0;
    Node* const node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);
    node->allocation.userData = userData;
}

VmaBlockMetadata_Buddy::Node* VmaBlockMetadata_Buddy::FindAllocationNode(VkDeviceSize offset, uint32_t& outLevel) const
{
    Node* node = m_Root;
    VkDeviceSize nodeOffset = 0;
    outLevel = 0;
    VkDeviceSize levelNodeSize = LevelToNodeSize(0);
    while (node->type == Node::TYPE_SPLIT)
    {
        const VkDeviceSize nextLevelNodeSize = levelNodeSize >> 1;
        if (offset < nodeOffset + nextLevelNodeSize)
        {
            node = node->split.leftChild;
        }
        else
        {
            node = node->split.leftChild->buddy;
            nodeOffset += nextLevelNodeSize;
        }
        ++outLevel;
        levelNodeSize = nextLevelNodeSize;
    }

    VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);
    return node;
}

bool VmaBlockMetadata_Buddy::ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const
{
    VMA_VALIDATE(level < m_LevelCount);
    VMA_VALIDATE(curr->parent == parent);
    VMA_VALIDATE((curr->buddy == VMA_NULL) == (parent == VMA_NULL));
    VMA_VALIDATE(curr->buddy == VMA_NULL || curr->buddy->buddy == curr);
    switch (curr->type)
    {
    case Node::TYPE_FREE:
        // curr->free.prev, next are validated separately.
        ctx.calculatedSumFreeSize += levelNodeSize;
        ++ctx.calculatedFreeCount;
        break;
    case Node::TYPE_ALLOCATION:
        ++ctx.calculatedAllocationCount;
        if (!IsVirtual())
        {
            VMA_VALIDATE(curr->allocation.userData != VMA_NULL);
        }
        break;
    case Node::TYPE_SPLIT:
    {
        const uint32_t childrenLevel = level + 1;
        const VkDeviceSize childrenLevelNodeSize = levelNodeSize >> 1;
        const Node* const leftChild = curr->split.leftChild;
        VMA_VALIDATE(leftChild != VMA_NULL);
        VMA_VALIDATE(leftChild->offset == curr->offset);
        if (!ValidateNode(ctx, curr, leftChild, childrenLevel, childrenLevelNodeSize))
        {
            VMA_VALIDATE(false && "ValidateNode for left child failed.");
        }
        const Node* const rightChild = leftChild->buddy;
        VMA_VALIDATE(rightChild->offset == curr->offset + childrenLevelNodeSize);
        if (!ValidateNode(ctx, curr, rightChild, childrenLevel, childrenLevelNodeSize))
        {
            VMA_VALIDATE(false && "ValidateNode for right child failed.");
        }
    }
    break;
    default:
        return false;
    }

    return true;
}

uint32_t VmaBlockMetadata_Buddy::AllocSizeToLevel(VkDeviceSize allocSize) const
{
    // I know this could be optimized somehow e.g. by using std::log2p1 from C++20.
    uint32_t level = 0;
    VkDeviceSize currLevelNodeSize = m_UsableSize;
    VkDeviceSize nextLevelNodeSize = currLevelNodeSize >> 1;
    while (allocSize <= nextLevelNodeSize && level + 1 < m_LevelCount)
    {
        ++level;
        currLevelNodeSize >>= 1;
        nextLevelNodeSize >>= 1;
    }
    return level;
}

void VmaBlockMetadata_Buddy::Free(VmaAllocHandle allocHandle)
{
    uint32_t level = 0;
    Node* node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);

    ++m_FreeCount;
    --m_AllocationCount;
    m_SumFreeSize += LevelToNodeSize(level);

    node->type = Node::TYPE_FREE;

    // Join free nodes if possible.
    while (level > 0 && node->buddy->type == Node::TYPE_FREE)
    {
        RemoveFromFreeList(level, node->buddy);
        Node* const parent = node->parent;

        m_NodeAllocator.Free(node->buddy);
        m_NodeAllocator.Free(node);
        parent->type = Node::TYPE_FREE;

        node = parent;
        --level;
        --m_FreeCount;
    }

    AddToFreeListFront(level, node);
}

void VmaBlockMetadata_Buddy::AddNodeToDetailedStatistics(VmaDetailedStatistics& inoutStats, const Node* node, VkDeviceSize levelNodeSize) const
{
    switch (node->type)
    {
    case Node::TYPE_FREE:
        VmaAddDetailedStatisticsUnusedRange(inoutStats, levelNodeSize);
        break;
    case Node::TYPE_ALLOCATION:
        VmaAddDetailedStatisticsAllocation(inoutStats, levelNodeSize);
        break;
    case Node::TYPE_SPLIT:
    {
        const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
        const Node* const leftChild = node->split.leftChild;
        AddNodeToDetailedStatistics(inoutStats, leftChild, childrenNodeSize);
        const Node* const rightChild = leftChild->buddy;
        AddNodeToDetailedStatistics(inoutStats, rightChild, childrenNodeSize);
    }
    break;
    default:
        VMA_ASSERT(0);
    }
}

void VmaBlockMetadata_Buddy::AddToFreeListFront(uint32_t level, Node* node)
{
    VMA_ASSERT(node->type == Node::TYPE_FREE);

    // List is empty.
    Node* const frontNode = m_FreeList[level].front;
    if (frontNode == VMA_NULL)
    {
        VMA_ASSERT(m_FreeList[level].back == VMA_NULL);
        node->free.prev = node->free.next = VMA_NULL;
        m_FreeList[level].front = m_FreeList[level].back = node;
    }
    else
    {
        VMA_ASSERT(frontNode->free.prev == VMA_NULL);
        node->free.prev = VMA_NULL;
        node->free.next = frontNode;
        frontNode->free.prev = node;
        m_FreeList[level].front = node;
    }
}

void VmaBlockMetadata_Buddy::RemoveFromFreeList(uint32_t level, Node* node)
{
    VMA_ASSERT(m_FreeList[level].front != VMA_NULL);

    // It is at the front.
    if (node->free.prev == VMA_NULL)
    {
        VMA_ASSERT(m_FreeList[level].front == node);
        m_FreeList[level].front = node->free.next;
    }
    else
    {
        Node* const prevFreeNode = node->free.prev;
        VMA_ASSERT(prevFreeNode->free.next == node);
        prevFreeNode->free.next = node->free.next;
    }

    // It is at the back.
    if (node->free.next == VMA_NULL)
    {
        VMA_ASSERT(m_FreeList[level].back == node);
        m_FreeList[level].back = node->free.prev;
    }
    else
    {
        Node* const nextFreeNode = node->free.next;
        VMA_ASSERT(nextFreeNode->free.prev == node);
        nextFreeNode->free.prev = node->free.prev;
    }
}

void VmaBlockMetadata_Buddy::DebugLogAllAllocationNode(Node* node, uint32_t level) const
{
    switch (node->type)
    {
    case Node::TYPE_FREE:
        break;
    case Node::TYPE_ALLOCATION:
        DebugLogAllocation(node->offset, LevelToNodeSize(level), node->allocation.userData);
        break;
    case Node::TYPE_SPLIT:
    {
        ++level;
        DebugLogAllAllocationNode(node->split.leftChild, level);
        DebugLogAllAllocationNode(node->split.leftChild->buddy, level);
    }
    break;
    default:
        VMA_ASSERT(0);
    }
}

#if VMA_STATS_STRING_ENABLED
void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const
{
    switch (node->type)
    {
    case Node::TYPE_FREE:
        PrintDetailedMap_UnusedRange(json, node->offset, levelNodeSize);
        break;
    case Node::TYPE_ALLOCATION:
        PrintDetailedMap_Allocation(json, node->offset, levelNodeSize, node->allocation.userData);
        break;
    case Node::TYPE_SPLIT:
    {
        const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
        const Node* const leftChild = node->split.leftChild;
        PrintDetailedMapNode(json, leftChild, childrenNodeSize);
        const Node* const rightChild = leftChild->buddy;
        PrintDetailedMapNode(json, rightChild, childrenNodeSize);
    }
    break;
    default:
        VMA_ASSERT(0);
    }
}
#endif // VMA_STATS_STRING_ENABLED
#endif // _VMA_BLOCK_METADATA_BUDDY_FUNCTIONS
#endif // _VMA_BLOCK_METADATA_BUDDY
#endif // #if 0

#ifndef _VMA_BLOCK_METADATA_TLSF
// To not search current larger region if first allocation won't succeed and skip to smaller range
// use with VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT as strategy in CreateAllocationRequest().
// When fragmentation and reusal of previous blocks doesn't matter then use with
// VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT for fastest alloc time possible.
class VmaBlockMetadata_TLSF : public VmaBlockMetadata
{
    VMA_CLASS_NO_COPY(VmaBlockMetadata_TLSF)
public:
    VmaBlockMetadata_TLSF(const VkAllocationCallbacks* pAllocationCallbacks,
        VkDeviceSize bufferImageGranularity, bool isVirtual);
    virtual ~VmaBlockMetadata_TLSF();

    size_t GetAllocationCount() const override { return m_AllocCount; }
    size_t GetFreeRegionsCount() const override { return m_BlocksFreeCount + 1; }
    VkDeviceSize GetSumFreeSize() const override { return m_BlocksFreeSize + m_NullBlock->size; }
    bool IsEmpty() const override { return m_NullBlock->offset == 0; }
    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return ((Block*)allocHandle)->offset; }

    void Init(VkDeviceSize size) override;
    bool Validate() const override;

    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
    void AddStatistics(VmaStatistics& inoutStats) const override;

#if VMA_STATS_STRING_ENABLED
    void PrintDetailedMap(class VmaJsonWriter& json) const override;
#endif

    bool CreateAllocationRequest(
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        bool upperAddress,
        VmaSuballocationType allocType,
        uint32_t strategy,
        VmaAllocationRequest* pAllocationRequest) override;

    VkResult CheckCorruption(const void* pBlockData) override;
    void Alloc(
        const VmaAllocationRequest& request,
        VmaSuballocationType type,
        void* userData) override;

    void Free(VmaAllocHandle allocHandle) override;
    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
    VmaAllocHandle GetAllocationListBegin() const override;
    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
    VkDeviceSize GetNextFreeRegionSize(VmaAllocHandle alloc) const override;
    void Clear() override;
    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
    void DebugLogAllAllocations() const override;

private:
    // According to original paper it should be preferable 4 or 5:
    // M. Masmano, I. Ripoll, A. Crespo, and J. Real "TLSF: a New Dynamic Memory Allocator for Real-Time Systems"
    // http://www.gii.upv.es/tlsf/files/ecrts04_tlsf.pdf
    static const uint8_t SECOND_LEVEL_INDEX = 5;
    static const uint16_t SMALL_BUFFER_SIZE = 256;
    static const uint32_t INITIAL_BLOCK_ALLOC_COUNT = 16;
    static const uint8_t MEMORY_CLASS_SHIFT = 7;
    static const uint8_t MAX_MEMORY_CLASSES = 65 - MEMORY_CLASS_SHIFT;

    class Block
    {
    public:
        VkDeviceSize offset;
        VkDeviceSize size;
        Block* prevPhysical;
        Block* nextPhysical;

        void MarkFree() { prevFree = VMA_NULL; }
        void MarkTaken() { prevFree = this; }
        bool IsFree() const { return prevFree != this; }
        void*& UserData() { VMA_HEAVY_ASSERT(!IsFree()); return userData; }
        Block*& PrevFree() { return prevFree; }
        Block*& NextFree() { VMA_HEAVY_ASSERT(IsFree()); return nextFree; }

    private:
        Block* prevFree; // Address of the same block here indicates that block is taken
        union
        {
            Block* nextFree;
            void* userData;
        };
    };

    size_t m_AllocCount;
    // Total number of free blocks besides null block
    size_t m_BlocksFreeCount;
    // Total size of free blocks excluding null block
    VkDeviceSize m_BlocksFreeSize;
    uint32_t m_IsFreeBitmap;
    uint8_t m_MemoryClasses;
    uint32_t m_InnerIsFreeBitmap[MAX_MEMORY_CLASSES];
    uint32_t m_ListsCount;
    /*
    * 0: 0-3 lists for small buffers
    * 1+: 0-(2^SLI-1) lists for normal buffers
    */
    Block** m_FreeList;
    VmaPoolAllocator<Block> m_BlockAllocator;
    Block* m_NullBlock;
    VmaBlockBufferImageGranularity m_GranularityHandler;

    uint8_t SizeToMemoryClass(VkDeviceSize size) const;
    uint16_t SizeToSecondIndex(VkDeviceSize size, uint8_t memoryClass) const;
    uint32_t GetListIndex(uint8_t memoryClass, uint16_t secondIndex) const;
    uint32_t GetListIndex(VkDeviceSize size) const;

    void RemoveFreeBlock(Block* block);
    void InsertFreeBlock(Block* block);
    void MergeBlock(Block* block, Block* prev);

    Block* FindFreeBlock(VkDeviceSize size, uint32_t& listIndex) const;
    bool CheckBlock(
        Block& block,
        uint32_t listIndex,
        VkDeviceSize allocSize,
        VkDeviceSize allocAlignment,
        VmaSuballocationType allocType,
        VmaAllocationRequest* pAllocationRequest);
};

#ifndef _VMA_BLOCK_METADATA_TLSF_FUNCTIONS
VmaBlockMetadata_TLSF::VmaBlockMetadata_TLSF(const VkAllocationCallbacks* pAllocationCallbacks,
    VkDeviceSize bufferImageGranularity, bool isVirtual)
    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
    m_AllocCount(0),
    m_BlocksFreeCount(0),
    m_BlocksFreeSize(0),
    m_IsFreeBitmap(0),
    m_MemoryClasses(0),
    m_ListsCount(0),
    m_FreeList(VMA_NULL),
    m_BlockAllocator(pAllocationCallbacks, INITIAL_BLOCK_ALLOC_COUNT),
    m_NullBlock(VMA_NULL),
    m_GranularityHandler(bufferImageGranularity) {}

VmaBlockMetadata_TLSF::~VmaBlockMetadata_TLSF()
{
    if (m_FreeList)
        vma_delete_array(GetAllocationCallbacks(), m_FreeList, m_ListsCount);
    m_GranularityHandler.Destroy(GetAllocationCallbacks());
}

void VmaBlockMetadata_TLSF::Init(VkDeviceSize size)
{
    VmaBlockMetadata::Init(size);

    if (!IsVirtual())
        m_GranularityHandler.Init(GetAllocationCallbacks(), size);

    m_NullBlock = m_BlockAllocator.Alloc();
    m_NullBlock->size = size;
    m_NullBlock->offset = 0;
    m_NullBlock->prevPhysical = VMA_NULL;
    m_NullBlock->nextPhysical = VMA_NULL;
    m_NullBlock->MarkFree();
    m_NullBlock->NextFree() = VMA_NULL;
    m_NullBlock->PrevFree() = VMA_NULL;
    uint8_t memoryClass = SizeToMemoryClass(size);
    uint16_t sli = SizeToSecondIndex(size, memoryClass);
    m_ListsCount = (memoryClass == 0 ? 0 : (memoryClass - 1) * (1UL << SECOND_LEVEL_INDEX) + sli) + 1;
    if (IsVirtual())
        m_ListsCount += 1UL << SECOND_LEVEL_INDEX;
    else
        m_ListsCount += 4;

    m_MemoryClasses = memoryClass + 2;
    memset(m_InnerIsFreeBitmap, 0, MAX_MEMORY_CLASSES * sizeof(uint32_t));

    m_FreeList = vma_new_array(GetAllocationCallbacks(), Block*, m_ListsCount);
    memset(m_FreeList, 0, m_ListsCount * sizeof(Block*));
}

bool VmaBlockMetadata_TLSF::Validate() const
{
    VMA_VALIDATE(GetSumFreeSize() <= GetSize());

    VkDeviceSize calculatedSize = m_NullBlock->size;
    VkDeviceSize calculatedFreeSize = m_NullBlock->size;
    size_t allocCount = 0;
    size_t freeCount = 0;

    // Check integrity of free lists
    for (uint32_t list = 0; list < m_ListsCount; ++list)
    {
        Block* block = m_FreeList[list];
        if (block != VMA_NULL)
        {
            VMA_VALIDATE(block->IsFree());
            VMA_VALIDATE(block->PrevFree() == VMA_NULL);
            while (block->NextFree())
            {
                VMA_VALIDATE(block->NextFree()->IsFree());
                VMA_VALIDATE(block->NextFree()->PrevFree() == block);
                block = block->NextFree();
            }
        }
    }

    VkDeviceSize nextOffset = m_NullBlock->offset;
    auto validateCtx = m_GranularityHandler.StartValidation(GetAllocationCallbacks(), IsVirtual());

    VMA_VALIDATE(m_NullBlock->nextPhysical == VMA_NULL);
    if (m_NullBlock->prevPhysical)
    {
        VMA_VALIDATE(m_NullBlock->prevPhysical->nextPhysical == m_NullBlock);
    }
    // Check all blocks
    for (Block* prev = m_NullBlock->prevPhysical; prev != VMA_NULL; prev = prev->prevPhysical)
    {
        VMA_VALIDATE(prev->offset + prev->size == nextOffset);
        nextOffset = prev->offset;
        calculatedSize += prev->size;

        uint32_t listIndex = GetListIndex(prev->size);
        if (prev->IsFree())
        {
            ++freeCount;
            // Check if free block belongs to free list
            Block* freeBlock = m_FreeList[listIndex];
            VMA_VALIDATE(freeBlock != VMA_NULL);

            bool found = false;
            do
            {
                if (freeBlock == prev)
                    found = true;

                freeBlock = freeBlock->NextFree();
            } while (!found && freeBlock != VMA_NULL);

            VMA_VALIDATE(found);
            calculatedFreeSize += prev->size;
        }
        else
        {
            ++allocCount;
            // Check if taken block is not on a free list
            Block* freeBlock = m_FreeList[listIndex];
            while (freeBlock)
            {
                VMA_VALIDATE(freeBlock != prev);
                freeBlock = freeBlock->NextFree();
            }

            if (!IsVirtual())
            {
                VMA_VALIDATE(m_GranularityHandler.Validate(validateCtx, prev->offset, prev->size));
            }
        }

        if (prev->prevPhysical)
        {
            VMA_VALIDATE(prev->prevPhysical->nextPhysical == prev);
        }
    }

    if (!IsVirtual())
    {
        VMA_VALIDATE(m_GranularityHandler.FinishValidation(validateCtx));
    }

    VMA_VALIDATE(nextOffset == 0);
    VMA_VALIDATE(calculatedSize == GetSize());
    VMA_VALIDATE(calculatedFreeSize == GetSumFreeSize());
    VMA_VALIDATE(allocCount == m_AllocCount);
    VMA_VALIDATE(freeCount == m_BlocksFreeCount);

    return true;
}

void VmaBlockMetadata_TLSF::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
{
    inoutStats.statistics.blockCount++;
    inoutStats.statistics.blockBytes += GetSize();
    if (m_NullBlock->size > 0)
        VmaAddDetailedStatisticsUnusedRange(inoutStats, m_NullBlock->size);

    for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
    {
        if (block->IsFree())
            VmaAddDetailedStatisticsUnusedRange(inoutStats, block->size);
        else
            VmaAddDetailedStatisticsAllocation(inoutStats, block->size);
    }
}

void VmaBlockMetadata_TLSF::AddStatistics(VmaStatistics& inoutStats) const
{
    inoutStats.blockCount++;
    inoutStats.allocationCount += (uint32_t)m_AllocCount;
    inoutStats.blockBytes += GetSize();
    inoutStats.allocationBytes += GetSize() - GetSumFreeSize();
}

#if VMA_STATS_STRING_ENABLED
void VmaBlockMetadata_TLSF::PrintDetailedMap(class VmaJsonWriter& json) const
{
    size_t blockCount = m_AllocCount + m_BlocksFreeCount;
    VmaStlAllocator<Block*> allocator(GetAllocationCallbacks());
    VmaVector<Block*, VmaStlAllocator<Block*>> blockList(blockCount, allocator);

    size_t i = blockCount;
    for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
    {
        blockList[--i] = block;
    }
    VMA_ASSERT(i == 0);

    VmaDetailedStatistics stats;
    VmaClearDetailedStatistics(stats);
    AddDetailedStatistics(stats);

    PrintDetailedMap_Begin(json,
        stats.statistics.blockBytes - stats.statistics.allocationBytes,
        stats.statistics.allocationCount,
        stats.unusedRangeCount);

    for (; i < blockCount; ++i)
    {
        Block* block = blockList[i];
        if (block->IsFree())
            PrintDetailedMap_UnusedRange(json, block->offset, block->size);
        else
            PrintDetailedMap_Allocation(json, block->offset, block->size, block->UserData());
    }
    if (m_NullBlock->size > 0)
        PrintDetailedMap_UnusedRange(json, m_NullBlock->offset, m_NullBlock->size);

    PrintDetailedMap_End(json);
}
#endif

bool VmaBlockMetadata_TLSF::CreateAllocationRequest(
    VkDeviceSize allocSize,
    VkDeviceSize allocAlignment,
    bool upperAddress,
    VmaSuballocationType allocType,
    uint32_t strategy,
    VmaAllocationRequest* pAllocationRequest)
{
    VMA_ASSERT(allocSize > 0 && "Cannot allocate empty block!");
    VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");

    // For small granularity round up
    if (!IsVirtual())
        m_GranularityHandler.RoundupAllocRequest(allocType, allocSize, allocAlignment);

    allocSize += GetDebugMargin();
    // Quick check for too small pool
    if (allocSize > GetSumFreeSize())
        return false;

    // If no free blocks in pool then check only null block
    if (m_BlocksFreeCount == 0)
        return CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest);

    // Round up to the next block
    VkDeviceSize sizeForNextList = allocSize;
    VkDeviceSize smallSizeStep = SMALL_BUFFER_SIZE / (IsVirtual() ? 1 << SECOND_LEVEL_INDEX : 4);
    if (allocSize > SMALL_BUFFER_SIZE)
    {
        sizeForNextList += (1ULL << (VMA_BITSCAN_MSB(allocSize) - SECOND_LEVEL_INDEX));
    }
    else if (allocSize > SMALL_BUFFER_SIZE - smallSizeStep)
        sizeForNextList = SMALL_BUFFER_SIZE + 1;
    else
        sizeForNextList += smallSizeStep;

    uint32_t nextListIndex = 0;
    uint32_t prevListIndex = 0;
    Block* nextListBlock = VMA_NULL;
    Block* prevListBlock = VMA_NULL;

    // Check blocks according to strategies
    if (strategy & VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT)
    {
        // Quick check for larger block first
        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
        if (nextListBlock != VMA_NULL && CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
            return true;

        // If not fitted then null block
        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest))
            return true;

        // Null block failed, search larger bucket
        while (nextListBlock)
        {
            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
                return true;
            nextListBlock = nextListBlock->NextFree();
        }

        // Failed again, check best fit bucket
        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
        while (prevListBlock)
        {
            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
                return true;
            prevListBlock = prevListBlock->NextFree();
        }
    }
    else if (strategy & VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT)
    {
        // Check best fit bucket
        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
        while (prevListBlock)
        {
            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
                return true;
            prevListBlock = prevListBlock->NextFree();
        }

        // If failed check null block
        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest))
            return true;

        // Check larger bucket
        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
        while (nextListBlock)
        {
            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
                return true;
            nextListBlock = nextListBlock->NextFree();
        }
    }
    else if (strategy & VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT )
    {
        // Perform search from the start
        VmaStlAllocator<Block*> allocator(GetAllocationCallbacks());
        VmaVector<Block*, VmaStlAllocator<Block*>> blockList(m_BlocksFreeCount, allocator);

        size_t i = m_BlocksFreeCount;
        for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
        {
            if (block->IsFree() && block->size >= allocSize)
                blockList[--i] = block;
        }

        for (; i < m_BlocksFreeCount; ++i)
        {
            Block& block = *blockList[i];
            if (CheckBlock(block, GetListIndex(block.size), allocSize, allocAlignment, allocType, pAllocationRequest))
                return true;
        }

        // If failed check null block
        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest))
            return true;

        // Whole range searched, no more memory
        return false;
    }
    else
    {
        // Check larger bucket
        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
        while (nextListBlock)
        {
            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
                return true;
            nextListBlock = nextListBlock->NextFree();
        }

        // If failed check null block
        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest))
            return true;

        // Check best fit bucket
        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
        while (prevListBlock)
        {
            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
                return true;
            prevListBlock = prevListBlock->NextFree();
        }
    }

    // Worst case, full search has to be done
    while (++nextListIndex < m_ListsCount)
    {
        nextListBlock = m_FreeList[nextListIndex];
        while (nextListBlock)
        {
            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
                return true;
            nextListBlock = nextListBlock->NextFree();
        }
    }

    // No more memory sadly
    return false;
}

VkResult VmaBlockMetadata_TLSF::CheckCorruption(const void* pBlockData)
{
    for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
    {
        if (!block->IsFree())
        {
            if (!VmaValidateMagicValue(pBlockData, block->offset + block->size))
            {
                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
                return VK_ERROR_UNKNOWN_COPY;
            }
        }
    }

    return VK_SUCCESS;
}

void VmaBlockMetadata_TLSF::Alloc(
    const VmaAllocationRequest& request,
    VmaSuballocationType type,
    void* userData)
{
    VMA_ASSERT(request.type == VmaAllocationRequestType::TLSF);

    // Get block and pop it from the free list
    Block* currentBlock = (Block*)request.allocHandle;
    VkDeviceSize offset = request.algorithmData;
    VMA_ASSERT(currentBlock != VMA_NULL);
    VMA_ASSERT(currentBlock->offset <= offset);

    if (currentBlock != m_NullBlock)
        RemoveFreeBlock(currentBlock);

    VkDeviceSize debugMargin = GetDebugMargin();
    VkDeviceSize misssingAlignment = offset - currentBlock->offset;

    // Append missing alignment to prev block or create new one
    if (misssingAlignment)
    {
        Block* prevBlock = currentBlock->prevPhysical;
        VMA_ASSERT(prevBlock != VMA_NULL && "There should be no missing alignment at offset 0!");

        if (prevBlock->IsFree() && prevBlock->size != debugMargin)
        {
            uint32_t oldList = GetListIndex(prevBlock->size);
            prevBlock->size += misssingAlignment;
            // Check if new size crosses list bucket
            if (oldList != GetListIndex(prevBlock->size))
            {
                prevBlock->size -= misssingAlignment;
                RemoveFreeBlock(prevBlock);
                prevBlock->size += misssingAlignment;
                InsertFreeBlock(prevBlock);
            }
            else
                m_BlocksFreeSize += misssingAlignment;
        }
        else
        {
            Block* newBlock = m_BlockAllocator.Alloc();
            currentBlock->prevPhysical = newBlock;
            prevBlock->nextPhysical = newBlock;
            newBlock->prevPhysical = prevBlock;
            newBlock->nextPhysical = currentBlock;
            newBlock->size = misssingAlignment;
            newBlock->offset = currentBlock->offset;
            newBlock->MarkTaken();

            InsertFreeBlock(newBlock);
        }

        currentBlock->size -= misssingAlignment;
        currentBlock->offset += misssingAlignment;
    }

    VkDeviceSize size = request.size + debugMargin;
    if (currentBlock->size == size)
    {
        if (currentBlock == m_NullBlock)
        {
            // Setup new null block
            m_NullBlock = m_BlockAllocator.Alloc();
            m_NullBlock->size = 0;
            m_NullBlock->offset = currentBlock->offset + size;
            m_NullBlock->prevPhysical = currentBlock;
            m_NullBlock->nextPhysical = VMA_NULL;
            m_NullBlock->MarkFree();
            m_NullBlock->PrevFree() = VMA_NULL;
            m_NullBlock->NextFree() = VMA_NULL;
            currentBlock->nextPhysical = m_NullBlock;
            currentBlock->MarkTaken();
        }
    }
    else
    {
        VMA_ASSERT(currentBlock->size > size && "Proper block already found, shouldn't find smaller one!");

        // Create new free block
        Block* newBlock = m_BlockAllocator.Alloc();
        newBlock->size = currentBlock->size - size;
        newBlock->offset = currentBlock->offset + size;
        newBlock->prevPhysical = currentBlock;
        newBlock->nextPhysical = currentBlock->nextPhysical;
        currentBlock->nextPhysical = newBlock;
        currentBlock->size = size;

        if (currentBlock == m_NullBlock)
        {
            m_NullBlock = newBlock;
            m_NullBlock->MarkFree();
            m_NullBlock->NextFree() = VMA_NULL;
            m_NullBlock->PrevFree() = VMA_NULL;
            currentBlock->MarkTaken();
        }
        else
        {
            newBlock->nextPhysical->prevPhysical = newBlock;
            newBlock->MarkTaken();
            InsertFreeBlock(newBlock);
        }
    }
    currentBlock->UserData() = userData;

    if (debugMargin > 0)
    {
        currentBlock->size -= debugMargin;
        Block* newBlock = m_BlockAllocator.Alloc();
        newBlock->size = debugMargin;
        newBlock->offset = currentBlock->offset + currentBlock->size;
        newBlock->prevPhysical = currentBlock;
        newBlock->nextPhysical = currentBlock->nextPhysical;
        newBlock->MarkTaken();
        currentBlock->nextPhysical->prevPhysical = newBlock;
        currentBlock->nextPhysical = newBlock;
        InsertFreeBlock(newBlock);
    }

    if (!IsVirtual())
        m_GranularityHandler.AllocPages((uint8_t)(uintptr_t)request.customData,
            currentBlock->offset, currentBlock->size);
    ++m_AllocCount;
}

void VmaBlockMetadata_TLSF::Free(VmaAllocHandle allocHandle)
{
    Block* block = (Block*)allocHandle;
    Block* next = block->nextPhysical;
    VMA_ASSERT(!block->IsFree() && "Block is already free!");

    if (!IsVirtual())
        m_GranularityHandler.FreePages(block->offset, block->size);
    --m_AllocCount;

    VkDeviceSize debugMargin = GetDebugMargin();
    if (debugMargin > 0)
    {
        RemoveFreeBlock(next);
        MergeBlock(next, block);
        block = next;
        next = next->nextPhysical;
    }

    // Try merging
    Block* prev = block->prevPhysical;
    if (prev != VMA_NULL && prev->IsFree() && prev->size != debugMargin)
    {
        RemoveFreeBlock(prev);
        MergeBlock(block, prev);
    }

    if (!next->IsFree())
        InsertFreeBlock(block);
    else if (next == m_NullBlock)
        MergeBlock(m_NullBlock, block);
    else
    {
        RemoveFreeBlock(next);
        MergeBlock(next, block);
        InsertFreeBlock(next);
    }
}

void VmaBlockMetadata_TLSF::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
{
    Block* block = (Block*)allocHandle;
    VMA_ASSERT(!block->IsFree() && "Cannot get allocation info for free block!");
    outInfo.offset = block->offset;
    outInfo.size = block->size;
    outInfo.pUserData = block->UserData();
}

void* VmaBlockMetadata_TLSF::GetAllocationUserData(VmaAllocHandle allocHandle) const
{
    Block* block = (Block*)allocHandle;
    VMA_ASSERT(!block->IsFree() && "Cannot get user data for free block!");
    return block->UserData();
}

VmaAllocHandle VmaBlockMetadata_TLSF::GetAllocationListBegin() const
{
    if (m_AllocCount == 0)
        return VK_NULL_HANDLE;

    for (Block* block = m_NullBlock->prevPhysical; block; block = block->prevPhysical)
    {
        if (!block->IsFree())
            return (VmaAllocHandle)block;
    }
    VMA_ASSERT(false && "If m_AllocCount > 0 then should find any allocation!");
    return VK_NULL_HANDLE;
}

VmaAllocHandle VmaBlockMetadata_TLSF::GetNextAllocation(VmaAllocHandle prevAlloc) const
{
    Block* startBlock = (Block*)prevAlloc;
    VMA_ASSERT(!startBlock->IsFree() && "Incorrect block!");

    for (Block* block = startBlock->prevPhysical; block; block = block->prevPhysical)
    {
        if (!block->IsFree())
            return (VmaAllocHandle)block;
    }
    return VK_NULL_HANDLE;
}

VkDeviceSize VmaBlockMetadata_TLSF::GetNextFreeRegionSize(VmaAllocHandle alloc) const
{
    Block* block = (Block*)alloc;
    VMA_ASSERT(!block->IsFree() && "Incorrect block!");

    if (block->prevPhysical)
        return block->prevPhysical->IsFree() ? block->prevPhysical->size : 0;
    return 0;
}

void VmaBlockMetadata_TLSF::Clear()
{
    m_AllocCount = 0;
    m_BlocksFreeCount = 0;
    m_BlocksFreeSize = 0;
    m_IsFreeBitmap = 0;
    m_NullBlock->offset = 0;
    m_NullBlock->size = GetSize();
    Block* block = m_NullBlock->prevPhysical;
    m_NullBlock->prevPhysical = VMA_NULL;
    while (block)
    {
        Block* prev = block->prevPhysical;
        m_BlockAllocator.Free(block);
        block = prev;
    }
    memset(m_FreeList, 0, m_ListsCount * sizeof(Block*));
    memset(m_InnerIsFreeBitmap, 0, m_MemoryClasses * sizeof(uint32_t));
    m_GranularityHandler.Clear();
}

void VmaBlockMetadata_TLSF::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
{
    Block* block = (Block*)allocHandle;
    VMA_ASSERT(!block->IsFree() && "Trying to set user data for not allocated block!");
    block->UserData() = userData;
}

void VmaBlockMetadata_TLSF::DebugLogAllAllocations() const
{
    for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
        if (!block->IsFree())
            DebugLogAllocation(block->offset, block->size, block->UserData());
}

uint8_t VmaBlockMetadata_TLSF::SizeToMemoryClass(VkDeviceSize size) const
{
    if (size > SMALL_BUFFER_SIZE)
        return VMA_BITSCAN_MSB(size) - MEMORY_CLASS_SHIFT;
    return 0;
}

uint16_t VmaBlockMetadata_TLSF::SizeToSecondIndex(VkDeviceSize size, uint8_t memoryClass) const
{
    if (memoryClass == 0)
    {
        if (IsVirtual())
            return static_cast<uint16_t>((size - 1) / 8);
        else
            return static_cast<uint16_t>((size - 1) / 64);
    }
    return static_cast<uint16_t>((size >> (memoryClass + MEMORY_CLASS_SHIFT - SECOND_LEVEL_INDEX)) ^ (1U << SECOND_LEVEL_INDEX));
}

uint32_t VmaBlockMetadata_TLSF::GetListIndex(uint8_t memoryClass, uint16_t secondIndex) const
{
    if (memoryClass == 0)
        return secondIndex;

    const uint32_t index = static_cast<uint32_t>(memoryClass - 1) * (1 << SECOND_LEVEL_INDEX) + secondIndex;
    if (IsVirtual())
        return index + (1 << SECOND_LEVEL_INDEX);
    else
        return index + 4;
}

uint32_t VmaBlockMetadata_TLSF::GetListIndex(VkDeviceSize size) const
{
    uint8_t memoryClass = SizeToMemoryClass(size);
    return GetListIndex(memoryClass, SizeToSecondIndex(size, memoryClass));
}

void VmaBlockMetadata_TLSF::RemoveFreeBlock(Block* block)
{
    VMA_ASSERT(block != m_NullBlock);
    VMA_ASSERT(block->IsFree());

    if (block->NextFree() != VMA_NULL)
        block->NextFree()->PrevFree() = block->PrevFree();
    if (block->PrevFree() != VMA_NULL)
        block->PrevFree()->NextFree() = block->NextFree();
    else
    {
        uint8_t memClass = SizeToMemoryClass(block->size);
        uint16_t secondIndex = SizeToSecondIndex(block->size, memClass);
        uint32_t index = GetListIndex(memClass, secondIndex);
        VMA_ASSERT(m_FreeList[index] == block);
        m_FreeList[index] = block->NextFree();
        if (block->NextFree() == VMA_NULL)
        {
            m_InnerIsFreeBitmap[memClass] &= ~(1U << secondIndex);
            if (m_InnerIsFreeBitmap[memClass] == 0)
                m_IsFreeBitmap &= ~(1UL << memClass);
        }
    }
    block->MarkTaken();
    block->UserData() = VMA_NULL;
    --m_BlocksFreeCount;
    m_BlocksFreeSize -= block->size;
}

void VmaBlockMetadata_TLSF::InsertFreeBlock(Block* block)
{
    VMA_ASSERT(block != m_NullBlock);
    VMA_ASSERT(!block->IsFree() && "Cannot insert block twice!");

    uint8_t memClass = SizeToMemoryClass(block->size);
    uint16_t secondIndex = SizeToSecondIndex(block->size, memClass);
    uint32_t index = GetListIndex(memClass, secondIndex);
    VMA_ASSERT(index < m_ListsCount);
    block->PrevFree() = VMA_NULL;
    block->NextFree() = m_FreeList[index];
    m_FreeList[index] = block;
    if (block->NextFree() != VMA_NULL)
        block->NextFree()->PrevFree() = block;
    else
    {
        m_InnerIsFreeBitmap[memClass] |= 1U << secondIndex;
        m_IsFreeBitmap |= 1UL << memClass;
    }
    ++m_BlocksFreeCount;
    m_BlocksFreeSize += block->size;
}

void VmaBlockMetadata_TLSF::MergeBlock(Block* block, Block* prev)
{
    VMA_ASSERT(block->prevPhysical == prev && "Cannot merge separate physical regions!");
    VMA_ASSERT(!prev->IsFree() && "Cannot merge block that belongs to free list!");

    block->offset = prev->offset;
    block->size += prev->size;
    block->prevPhysical = prev->prevPhysical;
    if (block->prevPhysical)
        block->prevPhysical->nextPhysical = block;
    m_BlockAllocator.Free(prev);
}

VmaBlockMetadata_TLSF::Block* VmaBlockMetadata_TLSF::FindFreeBlock(VkDeviceSize size, uint32_t& listIndex) const
{
    uint8_t memoryClass = SizeToMemoryClass(size);
    uint32_t innerFreeMap = m_InnerIsFreeBitmap[memoryClass] & (~0U << SizeToSecondIndex(size, memoryClass));
    if (!innerFreeMap)
    {
        // Check higher levels for available blocks
        uint32_t freeMap = m_IsFreeBitmap & (~0UL << (memoryClass + 1));
        if (!freeMap)
            return VMA_NULL; // No more memory available

        // Find lowest free region
        memoryClass = VMA_BITSCAN_LSB(freeMap);
        innerFreeMap = m_InnerIsFreeBitmap[memoryClass];
        VMA_ASSERT(innerFreeMap != 0);
    }
    // Find lowest free subregion
    listIndex = GetListIndex(memoryClass, VMA_BITSCAN_LSB(innerFreeMap));
    VMA_ASSERT(m_FreeList[listIndex]);
    return m_FreeList[listIndex];
}

bool VmaBlockMetadata_TLSF::CheckBlock(
    Block& block,
    uint32_t listIndex,
    VkDeviceSize allocSize,
    VkDeviceSize allocAlignment,
    VmaSuballocationType allocType,
    VmaAllocationRequest* pAllocationRequest)
{
    VMA_ASSERT(block.IsFree() && "Block is already taken!");

    VkDeviceSize alignedOffset = VmaAlignUp(block.offset, allocAlignment);
    if (block.size < allocSize + alignedOffset - block.offset)
        return false;

    // Check for granularity conflicts
    if (!IsVirtual() &&
        m_GranularityHandler.CheckConflictAndAlignUp(alignedOffset, allocSize, block.offset, block.size, allocType))
        return false;

    // Alloc successful
    pAllocationRequest->type = VmaAllocationRequestType::TLSF;
    pAllocationRequest->allocHandle = (VmaAllocHandle)&block;
    pAllocationRequest->size = allocSize - GetDebugMargin();
    pAllocationRequest->customData = (void*)allocType;
    pAllocationRequest->algorithmData = alignedOffset;

    // Place block at the start of list if it's normal block
    if (listIndex != m_ListsCount && block.PrevFree())
    {
        block.PrevFree()->NextFree() = block.NextFree();
        if (block.NextFree())
            block.NextFree()->PrevFree() = block.PrevFree();
        block.PrevFree() = VMA_NULL;
        block.NextFree() = m_FreeList[listIndex];
        m_FreeList[listIndex] = &block;
        if (block.NextFree())
            block.NextFree()->PrevFree() = &block;
    }

    return true;
}
#endif // _VMA_BLOCK_METADATA_TLSF_FUNCTIONS
#endif // _VMA_BLOCK_METADATA_TLSF

#ifndef _VMA_BLOCK_VECTOR
/*
Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
Vulkan memory type.

Synchronized internally with a mutex.
*/
class VmaBlockVector
{
    friend struct VmaDefragmentationContext_T;
    VMA_CLASS_NO_COPY(VmaBlockVector)
public:
    VmaBlockVector(
        VmaAllocator hAllocator,
        VmaPool hParentPool,
        uint32_t memoryTypeIndex,
        VkDeviceSize preferredBlockSize,
        size_t minBlockCount,
        size_t maxBlockCount,
        VkDeviceSize bufferImageGranularity,
        bool explicitBlockSize,
        uint32_t algorithm,
        float priority,
        VkDeviceSize minAllocationAlignment,
        void* pMemoryAllocateNext);
    ~VmaBlockVector();

    VmaAllocator GetAllocator() const { return m_hAllocator; }
    VmaPool GetParentPool() const { return m_hParentPool; }
    bool IsCustomPool() const { return m_hParentPool != VMA_NULL; }
    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
    VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
    VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
    uint32_t GetAlgorithm() const { return m_Algorithm; }
    bool HasExplicitBlockSize() const { return m_ExplicitBlockSize; }
    float GetPriority() const { return m_Priority; }
    const void* GetAllocationNextPtr() const { return m_pMemoryAllocateNext; }
    // To be used only while the m_Mutex is locked. Used during defragmentation.
    size_t GetBlockCount() const { return m_Blocks.size(); }
    // To be used only while the m_Mutex is locked. Used during defragmentation.
    VmaDeviceMemoryBlock* GetBlock(size_t index) const { return m_Blocks[index]; }
    VMA_RW_MUTEX &GetMutex() { return m_Mutex; }

    VkResult CreateMinBlocks();
    void AddStatistics(VmaStatistics& inoutStats);
    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats);
    bool IsEmpty();
    bool IsCorruptionDetectionEnabled() const;

    VkResult Allocate(
        VkDeviceSize size,
        VkDeviceSize alignment,
        const VmaAllocationCreateInfo& createInfo,
        VmaSuballocationType suballocType,
        size_t allocationCount,
        VmaAllocation* pAllocations);

    void Free(const VmaAllocation hAllocation);

#if VMA_STATS_STRING_ENABLED
    void PrintDetailedMap(class VmaJsonWriter& json);
#endif

    VkResult CheckCorruption();

private:
    const VmaAllocator m_hAllocator;
    const VmaPool m_hParentPool;
    const uint32_t m_MemoryTypeIndex;
    const VkDeviceSize m_PreferredBlockSize;
    const size_t m_MinBlockCount;
    const size_t m_MaxBlockCount;
    const VkDeviceSize m_BufferImageGranularity;
    const bool m_ExplicitBlockSize;
    const uint32_t m_Algorithm;
    const float m_Priority;
    const VkDeviceSize m_MinAllocationAlignment;

    void* const m_pMemoryAllocateNext;
    VMA_RW_MUTEX m_Mutex;
    // Incrementally sorted by sumFreeSize, ascending.
    VmaVector<VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*>> m_Blocks;
    uint32_t m_NextBlockId;
    bool m_IncrementalSort = true;

    void SetIncrementalSort(bool val) { m_IncrementalSort = val; }

    VkDeviceSize CalcMaxBlockSize() const;
    // Finds and removes given block from vector.
    void Remove(VmaDeviceMemoryBlock* pBlock);
    // Performs single step in sorting m_Blocks. They may not be fully sorted
    // after this call.
    void IncrementallySortBlocks();
    void SortByFreeSize();

    VkResult AllocatePage(
        VkDeviceSize size,
        VkDeviceSize alignment,
        const VmaAllocationCreateInfo& createInfo,
        VmaSuballocationType suballocType,
        VmaAllocation* pAllocation);

    VkResult AllocateFromBlock(
        VmaDeviceMemoryBlock* pBlock,
        VkDeviceSize size,
        VkDeviceSize alignment,
        VmaAllocationCreateFlags allocFlags,
        void* pUserData,
        VmaSuballocationType suballocType,
        uint32_t strategy,
        VmaAllocation* pAllocation);

    VkResult CommitAllocationRequest(
        VmaAllocationRequest& allocRequest,
        VmaDeviceMemoryBlock* pBlock,
        VkDeviceSize alignment,
        VmaAllocationCreateFlags allocFlags,
        void* pUserData,
        VmaSuballocationType suballocType,
        VmaAllocation* pAllocation);

    VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
    bool HasEmptyBlock();
};
#endif // _VMA_BLOCK_VECTOR

#ifndef _VMA_DEFRAGMENTATION_CONTEXT
struct VmaDefragmentationContext_T
{
    VMA_CLASS_NO_COPY(VmaDefragmentationContext_T)
public:
    VmaDefragmentationContext_T(
        VmaAllocator hAllocator,
        const VmaDefragmentationInfo& info);
    ~VmaDefragmentationContext_T();

    void GetStats(VmaDefragmentationStats& outStats) { outStats = m_GlobalStats; }

    VkResult DefragmentPassBegin(VmaDefragmentationPassMoveInfo& moveInfo);
    VkResult DefragmentPassEnd(VmaDefragmentationPassMoveInfo& moveInfo);

private:
    // Max number of allocations to ignore due to size constraints before ending single pass
    static const uint8_t MAX_ALLOCS_TO_IGNORE = 16;
    enum class CounterStatus { Pass, Ignore, End };

    struct FragmentedBlock
    {
        uint32_t data;
        VmaDeviceMemoryBlock* block;
    };
    struct StateBalanced
    {
        VkDeviceSize avgFreeSize = 0;
        VkDeviceSize avgAllocSize = UINT64_MAX;
    };
    struct StateExtensive
    {
        enum class Operation : uint8_t
        {
            FindFreeBlockBuffer, FindFreeBlockTexture, FindFreeBlockAll,
            MoveBuffers, MoveTextures, MoveAll,
            Cleanup, Done
        };

        Operation operation = Operation::FindFreeBlockTexture;
        size_t firstFreeBlock = SIZE_MAX;
    };
    struct MoveAllocationData
    {
        VkDeviceSize size;
        VkDeviceSize alignment;
        VmaSuballocationType type;
        VmaAllocationCreateFlags flags;
        VmaDefragmentationMove move = {};
    };

    const VkDeviceSize m_MaxPassBytes;
    const uint32_t m_MaxPassAllocations;

    VmaStlAllocator<VmaDefragmentationMove> m_MoveAllocator;
    VmaVector<VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove>> m_Moves;

    uint8_t m_IgnoredAllocs = 0;
    uint32_t m_Algorithm;
    uint32_t m_BlockVectorCount;
    VmaBlockVector* m_PoolBlockVector;
    VmaBlockVector** m_pBlockVectors;
    size_t m_ImmovableBlockCount = 0;
    VmaDefragmentationStats m_GlobalStats = { 0 };
    VmaDefragmentationStats m_PassStats = { 0 };
    void* m_AlgorithmState = VMA_NULL;

    static MoveAllocationData GetMoveData(VmaAllocHandle handle, VmaBlockMetadata* metadata);
    CounterStatus CheckCounters(VkDeviceSize bytes);
    bool IncrementCounters(VkDeviceSize bytes);
    bool ReallocWithinBlock(VmaBlockVector& vector, VmaDeviceMemoryBlock* block);
    bool AllocInOtherBlock(size_t start, size_t end, MoveAllocationData& data, VmaBlockVector& vector);

    bool ComputeDefragmentation(VmaBlockVector& vector, size_t index);
    bool ComputeDefragmentation_Fast(VmaBlockVector& vector);
    bool ComputeDefragmentation_Balanced(VmaBlockVector& vector, size_t index, bool update);
    bool ComputeDefragmentation_Full(VmaBlockVector& vector);
    bool ComputeDefragmentation_Extensive(VmaBlockVector& vector, size_t index);

    void UpdateVectorStatistics(VmaBlockVector& vector, StateBalanced& state);
    bool MoveDataToFreeBlocks(VmaSuballocationType currentType,
        VmaBlockVector& vector, size_t firstFreeBlock,
        bool& texturePresent, bool& bufferPresent, bool& otherPresent);
};
#endif // _VMA_DEFRAGMENTATION_CONTEXT

#ifndef _VMA_POOL_T
struct VmaPool_T
{
    friend struct VmaPoolListItemTraits;
    VMA_CLASS_NO_COPY(VmaPool_T)
public:
    VmaBlockVector m_BlockVector;
    VmaDedicatedAllocationList m_DedicatedAllocations;

    VmaPool_T(
        VmaAllocator hAllocator,
        const VmaPoolCreateInfo& createInfo,
        VkDeviceSize preferredBlockSize);
    ~VmaPool_T();

    uint32_t GetId() const { return m_Id; }
    void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }

    const char* GetName() const { return m_Name; }
    void SetName(const char* pName);

#if VMA_STATS_STRING_ENABLED
    //void PrintDetailedMap(class VmaStringBuilder& sb);
#endif

private:
    uint32_t m_Id;
    char* m_Name;
    VmaPool_T* m_PrevPool = VMA_NULL;
    VmaPool_T* m_NextPool = VMA_NULL;
};

struct VmaPoolListItemTraits
{
    typedef VmaPool_T ItemType;

    static ItemType* GetPrev(const ItemType* item) { return item->m_PrevPool; }
    static ItemType* GetNext(const ItemType* item) { return item->m_NextPool; }
    static ItemType*& AccessPrev(ItemType* item) { return item->m_PrevPool; }
    static ItemType*& AccessNext(ItemType* item) { return item->m_NextPool; }
};
#endif // _VMA_POOL_T

#ifndef _VMA_CURRENT_BUDGET_DATA
struct VmaCurrentBudgetData
{
    VMA_ATOMIC_UINT32 m_BlockCount[VK_MAX_MEMORY_HEAPS];
    VMA_ATOMIC_UINT32 m_AllocationCount[VK_MAX_MEMORY_HEAPS];
    VMA_ATOMIC_UINT64 m_BlockBytes[VK_MAX_MEMORY_HEAPS];
    VMA_ATOMIC_UINT64 m_AllocationBytes[VK_MAX_MEMORY_HEAPS];

#if VMA_MEMORY_BUDGET
    VMA_ATOMIC_UINT32 m_OperationsSinceBudgetFetch;
    VMA_RW_MUTEX m_BudgetMutex;
    uint64_t m_VulkanUsage[VK_MAX_MEMORY_HEAPS];
    uint64_t m_VulkanBudget[VK_MAX_MEMORY_HEAPS];
    uint64_t m_BlockBytesAtBudgetFetch[VK_MAX_MEMORY_HEAPS];
#endif // VMA_MEMORY_BUDGET

    VmaCurrentBudgetData();

    void AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize);
    void RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize);
};

#ifndef _VMA_CURRENT_BUDGET_DATA_FUNCTIONS
VmaCurrentBudgetData::VmaCurrentBudgetData()
{
    for (uint32_t heapIndex = 0; heapIndex < VK_MAX_MEMORY_HEAPS; ++heapIndex)
    {
        m_BlockCount[heapIndex] = 0;
        m_AllocationCount[heapIndex] = 0;
        m_BlockBytes[heapIndex] = 0;
        m_AllocationBytes[heapIndex] = 0;
#if VMA_MEMORY_BUDGET
        m_VulkanUsage[heapIndex] = 0;
        m_VulkanBudget[heapIndex] = 0;
        m_BlockBytesAtBudgetFetch[heapIndex] = 0;
#endif
    }

#if VMA_MEMORY_BUDGET
    m_OperationsSinceBudgetFetch = 0;
#endif
}

void VmaCurrentBudgetData::AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
{
    m_AllocationBytes[heapIndex] += allocationSize;
    ++m_AllocationCount[heapIndex];
#if VMA_MEMORY_BUDGET
    ++m_OperationsSinceBudgetFetch;
#endif
}

void VmaCurrentBudgetData::RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
{
    VMA_ASSERT(m_AllocationBytes[heapIndex] >= allocationSize);
    m_AllocationBytes[heapIndex] -= allocationSize;
    VMA_ASSERT(m_AllocationCount[heapIndex] > 0);
    --m_AllocationCount[heapIndex];
#if VMA_MEMORY_BUDGET
    ++m_OperationsSinceBudgetFetch;
#endif
}
#endif // _VMA_CURRENT_BUDGET_DATA_FUNCTIONS
#endif // _VMA_CURRENT_BUDGET_DATA

#ifndef _VMA_ALLOCATION_OBJECT_ALLOCATOR
/*
Thread-safe wrapper over VmaPoolAllocator free list, for allocation of VmaAllocation_T objects.
*/
class VmaAllocationObjectAllocator
{
    VMA_CLASS_NO_COPY(VmaAllocationObjectAllocator)
public:
    VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks)
        : m_Allocator(pAllocationCallbacks, 1024) {}

    template<typename... Types> VmaAllocation Allocate(Types&&... args);
    void Free(VmaAllocation hAlloc);

private:
    VMA_MUTEX m_Mutex;
    VmaPoolAllocator<VmaAllocation_T> m_Allocator;
};

template<typename... Types>
VmaAllocation VmaAllocationObjectAllocator::Allocate(Types&&... args)
{
    VmaMutexLock mutexLock(m_Mutex);
    return m_Allocator.Alloc<Types...>(std::forward<Types>(args)...);
}

void VmaAllocationObjectAllocator::Free(VmaAllocation hAlloc)
{
    VmaMutexLock mutexLock(m_Mutex);
    m_Allocator.Free(hAlloc);
}
#endif // _VMA_ALLOCATION_OBJECT_ALLOCATOR

#ifndef _VMA_VIRTUAL_BLOCK_T
struct VmaVirtualBlock_T
{
    VMA_CLASS_NO_COPY(VmaVirtualBlock_T)
public:
    const bool m_AllocationCallbacksSpecified;
    const VkAllocationCallbacks m_AllocationCallbacks;

    VmaVirtualBlock_T(const VmaVirtualBlockCreateInfo& createInfo);
    ~VmaVirtualBlock_T();

    VkResult Init() { return VK_SUCCESS; }
    bool IsEmpty() const { return m_Metadata->IsEmpty(); }
    void Free(VmaVirtualAllocation allocation) { m_Metadata->Free((VmaAllocHandle)allocation); }
    void SetAllocationUserData(VmaVirtualAllocation allocation, void* userData) { m_Metadata->SetAllocationUserData((VmaAllocHandle)allocation, userData); }
    void Clear() { m_Metadata->Clear(); }

    const VkAllocationCallbacks* GetAllocationCallbacks() const;
    void GetAllocationInfo(VmaVirtualAllocation allocation, VmaVirtualAllocationInfo& outInfo);
    VkResult Allocate(const VmaVirtualAllocationCreateInfo& createInfo, VmaVirtualAllocation& outAllocation,
        VkDeviceSize* outOffset);
    void GetStatistics(VmaStatistics& outStats) const;
    void CalculateDetailedStatistics(VmaDetailedStatistics& outStats) const;
#if VMA_STATS_STRING_ENABLED
    void BuildStatsString(bool detailedMap, VmaStringBuilder& sb) const;
#endif

private:
    VmaBlockMetadata* m_Metadata;
};

#ifndef _VMA_VIRTUAL_BLOCK_T_FUNCTIONS
VmaVirtualBlock_T::VmaVirtualBlock_T(const VmaVirtualBlockCreateInfo& createInfo)
    : m_AllocationCallbacksSpecified(createInfo.pAllocationCallbacks != VMA_NULL),
    m_AllocationCallbacks(createInfo.pAllocationCallbacks != VMA_NULL ? *createInfo.pAllocationCallbacks : VmaEmptyAllocationCallbacks)
{
    const uint32_t algorithm = createInfo.flags & VMA_VIRTUAL_BLOCK_CREATE_ALGORITHM_MASK;
    switch (algorithm)
    {
    default:
        VMA_ASSERT(0);
    case 0:
        m_Metadata = vma_new(GetAllocationCallbacks(), VmaBlockMetadata_TLSF)(VK_NULL_HANDLE, 1, true);
        break;
    case VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT:
        m_Metadata = vma_new(GetAllocationCallbacks(), VmaBlockMetadata_Linear)(VK_NULL_HANDLE, 1, true);
        break;
    }

    m_Metadata->Init(createInfo.size);
}

VmaVirtualBlock_T::~VmaVirtualBlock_T()
{
    // Define macro VMA_DEBUG_LOG to receive the list of the unfreed allocations
    if (!m_Metadata->IsEmpty())
        m_Metadata->DebugLogAllAllocations();
    // This is the most important assert in the entire library.
    // Hitting it means you have some memory leak - unreleased virtual allocations.
    VMA_ASSERT(m_Metadata->IsEmpty() && "Some virtual allocations were not freed before destruction of this virtual block!");

    vma_delete(GetAllocationCallbacks(), m_Metadata);
}

const VkAllocationCallbacks* VmaVirtualBlock_T::GetAllocationCallbacks() const
{
    return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : VMA_NULL;
}

void VmaVirtualBlock_T::GetAllocationInfo(VmaVirtualAllocation allocation, VmaVirtualAllocationInfo& outInfo)
{
    m_Metadata->GetAllocationInfo((VmaAllocHandle)allocation, outInfo);
}

VkResult VmaVirtualBlock_T::Allocate(const VmaVirtualAllocationCreateInfo& createInfo, VmaVirtualAllocation& outAllocation,
    VkDeviceSize* outOffset)
{
    VmaAllocationRequest request = {};
    if (m_Metadata->CreateAllocationRequest(
        createInfo.size, // allocSize
        VMA_MAX(createInfo.alignment, (VkDeviceSize)1), // allocAlignment
        (createInfo.flags & VMA_VIRTUAL_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0, // upperAddress
        VMA_SUBALLOCATION_TYPE_UNKNOWN, // allocType - unimportant
        createInfo.flags & VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MASK, // strategy
        &request))
    {
        m_Metadata->Alloc(request,
            VMA_SUBALLOCATION_TYPE_UNKNOWN, // type - unimportant
            createInfo.pUserData);
        outAllocation = (VmaVirtualAllocation)request.allocHandle;
        if(outOffset)
            *outOffset = m_Metadata->GetAllocationOffset(request.allocHandle);
        return VK_SUCCESS;
    }
    outAllocation = (VmaVirtualAllocation)VK_NULL_HANDLE;
    if (outOffset)
        *outOffset = UINT64_MAX;
    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
}

void VmaVirtualBlock_T::GetStatistics(VmaStatistics& outStats) const
{
    VmaClearStatistics(outStats);
    m_Metadata->AddStatistics(outStats);
}

void VmaVirtualBlock_T::CalculateDetailedStatistics(VmaDetailedStatistics& outStats) const
{
    VmaClearDetailedStatistics(outStats);
    m_Metadata->AddDetailedStatistics(outStats);
}

#if VMA_STATS_STRING_ENABLED
void VmaVirtualBlock_T::BuildStatsString(bool detailedMap, VmaStringBuilder& sb) const
{
    VmaJsonWriter json(GetAllocationCallbacks(), sb);
    json.BeginObject();

    VmaDetailedStatistics stats;
    CalculateDetailedStatistics(stats);

    json.WriteString("Stats");
    VmaPrintDetailedStatistics(json, stats);

    if (detailedMap)
    {
        json.WriteString("Details");
        json.BeginObject();
        m_Metadata->PrintDetailedMap(json);
        json.EndObject();
    }

    json.EndObject();
}
#endif // VMA_STATS_STRING_ENABLED
#endif // _VMA_VIRTUAL_BLOCK_T_FUNCTIONS
#endif // _VMA_VIRTUAL_BLOCK_T


// Main allocator object.
struct VmaAllocator_T
{
    VMA_CLASS_NO_COPY(VmaAllocator_T)
public:
    bool m_UseMutex;
    uint32_t m_VulkanApiVersion;
    bool m_UseKhrDedicatedAllocation; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
    bool m_UseKhrBindMemory2; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
    bool m_UseExtMemoryBudget;
    bool m_UseAmdDeviceCoherentMemory;
    bool m_UseKhrBufferDeviceAddress;
    bool m_UseExtMemoryPriority;
    VkDevice m_hDevice;
    VkInstance m_hInstance;
    bool m_AllocationCallbacksSpecified;
    VkAllocationCallbacks m_AllocationCallbacks;
    VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
    VmaAllocationObjectAllocator m_AllocationObjectAllocator;

    // Each bit (1 << i) is set if HeapSizeLimit is enabled for that heap, so cannot allocate more than the heap size.
    uint32_t m_HeapSizeLimitMask;

    VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
    VkPhysicalDeviceMemoryProperties m_MemProps;

    // Default pools.
    VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
    VmaDedicatedAllocationList m_DedicatedAllocations[VK_MAX_MEMORY_TYPES];

    VmaCurrentBudgetData m_Budget;
    VMA_ATOMIC_UINT32 m_DeviceMemoryCount; // Total number of VkDeviceMemory objects.

    VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
    VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
    ~VmaAllocator_T();

    const VkAllocationCallbacks* GetAllocationCallbacks() const
    {
        return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : VMA_NULL;
    }
    const VmaVulkanFunctions& GetVulkanFunctions() const
    {
        return m_VulkanFunctions;
    }

    VkPhysicalDevice GetPhysicalDevice() const { return m_PhysicalDevice; }

    VkDeviceSize GetBufferImageGranularity() const
    {
        return VMA_MAX(
            static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
            m_PhysicalDeviceProperties.limits.bufferImageGranularity);
    }

    uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
    uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }

    uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
    {
        VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
        return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
    }
    // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
    bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
    {
        return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
    }
    // Minimum alignment for all allocations in specific memory type.
    VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
    {
        return IsMemoryTypeNonCoherent(memTypeIndex) ?
            VMA_MAX((VkDeviceSize)VMA_MIN_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
            (VkDeviceSize)VMA_MIN_ALIGNMENT;
    }

    bool IsIntegratedGpu() const
    {
        return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
    }

    uint32_t GetGlobalMemoryTypeBits() const { return m_GlobalMemoryTypeBits; }

    void GetBufferMemoryRequirements(
        VkBuffer hBuffer,
        VkMemoryRequirements& memReq,
        bool& requiresDedicatedAllocation,
        bool& prefersDedicatedAllocation) const;
    void GetImageMemoryRequirements(
        VkImage hImage,
        VkMemoryRequirements& memReq,
        bool& requiresDedicatedAllocation,
        bool& prefersDedicatedAllocation) const;
    VkResult FindMemoryTypeIndex(
        uint32_t memoryTypeBits,
        const VmaAllocationCreateInfo* pAllocationCreateInfo,
        VkFlags bufImgUsage, // VkBufferCreateInfo::usage or VkImageCreateInfo::usage. UINT32_MAX if unknown.
        uint32_t* pMemoryTypeIndex) const;

    // Main allocation function.
    VkResult AllocateMemory(
        const VkMemoryRequirements& vkMemReq,
        bool requiresDedicatedAllocation,
        bool prefersDedicatedAllocation,
        VkBuffer dedicatedBuffer,
        VkImage dedicatedImage,
        VkFlags dedicatedBufferImageUsage, // UINT32_MAX if unknown.
        const VmaAllocationCreateInfo& createInfo,
        VmaSuballocationType suballocType,
        size_t allocationCount,
        VmaAllocation* pAllocations);

    // Main deallocation function.
    void FreeMemory(
        size_t allocationCount,
        const VmaAllocation* pAllocations);

    void CalculateStatistics(VmaTotalStatistics* pStats);

    void GetHeapBudgets(
        VmaBudget* outBudgets, uint32_t firstHeap, uint32_t heapCount);

#if VMA_STATS_STRING_ENABLED
    void PrintDetailedMap(class VmaJsonWriter& json);
#endif

    void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);

    VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
    void DestroyPool(VmaPool pool);
    void GetPoolStatistics(VmaPool pool, VmaStatistics* pPoolStats);
    void CalculatePoolStatistics(VmaPool pool, VmaDetailedStatistics* pPoolStats);

    void SetCurrentFrameIndex(uint32_t frameIndex);
    uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }

    VkResult CheckPoolCorruption(VmaPool hPool);
    VkResult CheckCorruption(uint32_t memoryTypeBits);

    // Call to Vulkan function vkAllocateMemory with accompanying bookkeeping.
    VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
    // Call to Vulkan function vkFreeMemory with accompanying bookkeeping.
    void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
    // Call to Vulkan function vkBindBufferMemory or vkBindBufferMemory2KHR.
    VkResult BindVulkanBuffer(
        VkDeviceMemory memory,
        VkDeviceSize memoryOffset,
        VkBuffer buffer,
        const void* pNext);
    // Call to Vulkan function vkBindImageMemory or vkBindImageMemory2KHR.
    VkResult BindVulkanImage(
        VkDeviceMemory memory,
        VkDeviceSize memoryOffset,
        VkImage image,
        const void* pNext);

    VkResult Map(VmaAllocation hAllocation, void** ppData);
    void Unmap(VmaAllocation hAllocation);

    VkResult BindBufferMemory(
        VmaAllocation hAllocation,
        VkDeviceSize allocationLocalOffset,
        VkBuffer hBuffer,
        const void* pNext);
    VkResult BindImageMemory(
        VmaAllocation hAllocation,
        VkDeviceSize allocationLocalOffset,
        VkImage hImage,
        const void* pNext);

    VkResult FlushOrInvalidateAllocation(
        VmaAllocation hAllocation,
        VkDeviceSize offset, VkDeviceSize size,
        VMA_CACHE_OPERATION op);
    VkResult FlushOrInvalidateAllocations(
        uint32_t allocationCount,
        const VmaAllocation* allocations,
        const VkDeviceSize* offsets, const VkDeviceSize* sizes,
        VMA_CACHE_OPERATION op);

    void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);

    /*
    Returns bit mask of memory types that can support defragmentation on GPU as
    they support creation of required buffer for copy operations.
    */
    uint32_t GetGpuDefragmentationMemoryTypeBits();

#if VMA_EXTERNAL_MEMORY
    VkExternalMemoryHandleTypeFlagsKHR GetExternalMemoryHandleTypeFlags(uint32_t memTypeIndex) const
    {
        return m_TypeExternalMemoryHandleTypes[memTypeIndex];
    }
#endif // #if VMA_EXTERNAL_MEMORY

private:
    VkDeviceSize m_PreferredLargeHeapBlockSize;

    VkPhysicalDevice m_PhysicalDevice;
    VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
    VMA_ATOMIC_UINT32 m_GpuDefragmentationMemoryTypeBits; // UINT32_MAX means uninitialized.
#if VMA_EXTERNAL_MEMORY
    VkExternalMemoryHandleTypeFlagsKHR m_TypeExternalMemoryHandleTypes[VK_MAX_MEMORY_TYPES];
#endif // #if VMA_EXTERNAL_MEMORY

    VMA_RW_MUTEX m_PoolsMutex;
    typedef VmaIntrusiveLinkedList<VmaPoolListItemTraits> PoolList;
    // Protected by m_PoolsMutex.
    PoolList m_Pools;
    uint32_t m_NextPoolId;

    VmaVulkanFunctions m_VulkanFunctions;

    // Global bit mask AND-ed with any memoryTypeBits to disallow certain memory types.
    uint32_t m_GlobalMemoryTypeBits;

    void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);

#if VMA_STATIC_VULKAN_FUNCTIONS == 1
    void ImportVulkanFunctions_Static();
#endif

    void ImportVulkanFunctions_Custom(const VmaVulkanFunctions* pVulkanFunctions);

#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
    void ImportVulkanFunctions_Dynamic();
#endif

    void ValidateVulkanFunctions();

    VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);

    VkResult AllocateMemoryOfType(
        VmaPool pool,
        VkDeviceSize size,
        VkDeviceSize alignment,
        bool dedicatedPreferred,
        VkBuffer dedicatedBuffer,
        VkImage dedicatedImage,
        VkFlags dedicatedBufferImageUsage,
        const VmaAllocationCreateInfo& createInfo,
        uint32_t memTypeIndex,
        VmaSuballocationType suballocType,
        VmaDedicatedAllocationList& dedicatedAllocations,
        VmaBlockVector& blockVector,
        size_t allocationCount,
        VmaAllocation* pAllocations);

    // Helper function only to be used inside AllocateDedicatedMemory.
    VkResult AllocateDedicatedMemoryPage(
        VmaPool pool,
        VkDeviceSize size,
        VmaSuballocationType suballocType,
        uint32_t memTypeIndex,
        const VkMemoryAllocateInfo& allocInfo,
        bool map,
        bool isUserDataString,
        bool isMappingAllowed,
        void* pUserData,
        VmaAllocation* pAllocation);

    // Allocates and registers new VkDeviceMemory specifically for dedicated allocations.
    VkResult AllocateDedicatedMemory(
        VmaPool pool,
        VkDeviceSize size,
        VmaSuballocationType suballocType,
        VmaDedicatedAllocationList& dedicatedAllocations,
        uint32_t memTypeIndex,
        bool map,
        bool isUserDataString,
        bool isMappingAllowed,
        bool canAliasMemory,
        void* pUserData,
        float priority,
        VkBuffer dedicatedBuffer,
        VkImage dedicatedImage,
        VkFlags dedicatedBufferImageUsage,
        size_t allocationCount,
        VmaAllocation* pAllocations,
        const void* pNextChain = nullptr);

    void FreeDedicatedMemory(const VmaAllocation allocation);

    VkResult CalcMemTypeParams(
        VmaAllocationCreateInfo& outCreateInfo,
        uint32_t memTypeIndex,
        VkDeviceSize size,
        size_t allocationCount);
    VkResult CalcAllocationParams(
        VmaAllocationCreateInfo& outCreateInfo,
        bool dedicatedRequired,
        bool dedicatedPreferred);

    /*
    Calculates and returns bit mask of memory types that can support defragmentation
    on GPU as they support creation of required buffer for copy operations.
    */
    uint32_t CalculateGpuDefragmentationMemoryTypeBits() const;
    uint32_t CalculateGlobalMemoryTypeBits() const;

    bool GetFlushOrInvalidateRange(
        VmaAllocation allocation,
        VkDeviceSize offset, VkDeviceSize size,
        VkMappedMemoryRange& outRange) const;

#if VMA_MEMORY_BUDGET
    void UpdateVulkanBudget();
#endif // #if VMA_MEMORY_BUDGET
};


#ifndef _VMA_MEMORY_FUNCTIONS
static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
{
    return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
}

static void VmaFree(VmaAllocator hAllocator, void* ptr)
{
    VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
}

template<typename T>
static T* VmaAllocate(VmaAllocator hAllocator)
{
    return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
}

template<typename T>
static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
{
    return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
}

template<typename T>
static void vma_delete(VmaAllocator hAllocator, T* ptr)
{
    if(ptr != VMA_NULL)
    {
        ptr->~T();
        VmaFree(hAllocator, ptr);
    }
}

template<typename T>
static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
{
    if(ptr != VMA_NULL)
    {
        for(size_t i = count; i--; )
            ptr[i].~T();
        VmaFree(hAllocator, ptr);
    }
}
#endif // _VMA_MEMORY_FUNCTIONS

#ifndef _VMA_DEVICE_MEMORY_BLOCK_FUNCTIONS
VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator)
    : m_pMetadata(VMA_NULL),
    m_MemoryTypeIndex(UINT32_MAX),
    m_Id(0),
    m_hMemory(VK_NULL_HANDLE),
    m_MapCount(0),
    m_pMappedData(VMA_NULL) {}

VmaDeviceMemoryBlock::~VmaDeviceMemoryBlock()
{
    VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
    VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
}

void VmaDeviceMemoryBlock::Init(
    VmaAllocator hAllocator,
    VmaPool hParentPool,
    uint32_t newMemoryTypeIndex,
    VkDeviceMemory newMemory,
    VkDeviceSize newSize,
    uint32_t id,
    uint32_t algorithm,
    VkDeviceSize bufferImageGranularity)
{
    VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);

    m_hParentPool = hParentPool;
    m_MemoryTypeIndex = newMemoryTypeIndex;
    m_Id = id;
    m_hMemory = newMemory;

    switch (algorithm)
    {
    case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator->GetAllocationCallbacks(),
            bufferImageGranularity, false); // isVirtual
        break;
    default:
        VMA_ASSERT(0);
        // Fall-through.
    case 0:
        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_TLSF)(hAllocator->GetAllocationCallbacks(),
            bufferImageGranularity, false); // isVirtual
    }
    m_pMetadata->Init(newSize);
}

void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
{
    // Define macro VMA_DEBUG_LOG to receive the list of the unfreed allocations
    if (!m_pMetadata->IsEmpty())
        m_pMetadata->DebugLogAllAllocations();
    // This is the most important assert in the entire library.
    // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
    VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");

    VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
    allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
    m_hMemory = VK_NULL_HANDLE;

    vma_delete(allocator, m_pMetadata);
    m_pMetadata = VMA_NULL;
}

void VmaDeviceMemoryBlock::PostAlloc(VmaAllocator hAllocator)
{
    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
    m_MappingHysteresis.PostAlloc();
}

void VmaDeviceMemoryBlock::PostFree(VmaAllocator hAllocator)
{
    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
    if(m_MappingHysteresis.PostFree())
    {
        VMA_ASSERT(m_MappingHysteresis.GetExtraMapping() == 0);
        if (m_MapCount == 0)
        {
            m_pMappedData = VMA_NULL;
            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
        }
    }
}

bool VmaDeviceMemoryBlock::Validate() const
{
    VMA_VALIDATE((m_hMemory != VK_NULL_HANDLE) &&
        (m_pMetadata->GetSize() != 0));

    return m_pMetadata->Validate();
}

VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
{
    void* pData = nullptr;
    VkResult res = Map(hAllocator, 1, &pData);
    if (res != VK_SUCCESS)
    {
        return res;
    }

    res = m_pMetadata->CheckCorruption(pData);

    Unmap(hAllocator, 1);

    return res;
}

VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
{
    if (count == 0)
    {
        return VK_SUCCESS;
    }

    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
    const uint32_t oldTotalMapCount = m_MapCount + m_MappingHysteresis.GetExtraMapping();
    m_MappingHysteresis.PostMap();
    if (oldTotalMapCount != 0)
    {
        m_MapCount += count;
        VMA_ASSERT(m_pMappedData != VMA_NULL);
        if (ppData != VMA_NULL)
        {
            *ppData = m_pMappedData;
        }
        return VK_SUCCESS;
    }
    else
    {
        VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
            hAllocator->m_hDevice,
            m_hMemory,
            0, // offset
            VK_WHOLE_SIZE,
            0, // flags
            &m_pMappedData);
        if (result == VK_SUCCESS)
        {
            if (ppData != VMA_NULL)
            {
                *ppData = m_pMappedData;
            }
            m_MapCount = count;
        }
        return result;
    }
}

void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
{
    if (count == 0)
    {
        return;
    }

    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
    if (m_MapCount >= count)
    {
        m_MapCount -= count;
        const uint32_t totalMapCount = m_MapCount + m_MappingHysteresis.GetExtraMapping();
        if (totalMapCount == 0)
        {
            m_pMappedData = VMA_NULL;
            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
        }
        m_MappingHysteresis.PostUnmap();
    }
    else
    {
        VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
    }
}

VkResult VmaDeviceMemoryBlock::WriteMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
{
    VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);

    void* pData;
    VkResult res = Map(hAllocator, 1, &pData);
    if (res != VK_SUCCESS)
    {
        return res;
    }

    VmaWriteMagicValue(pData, allocOffset + allocSize);

    Unmap(hAllocator, 1);
    return VK_SUCCESS;
}

VkResult VmaDeviceMemoryBlock::ValidateMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
{
    VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);

    void* pData;
    VkResult res = Map(hAllocator, 1, &pData);
    if (res != VK_SUCCESS)
    {
        return res;
    }

    if (!VmaValidateMagicValue(pData, allocOffset + allocSize))
    {
        VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
    }

    Unmap(hAllocator, 1);
    return VK_SUCCESS;
}

VkResult VmaDeviceMemoryBlock::BindBufferMemory(
    const VmaAllocator hAllocator,
    const VmaAllocation hAllocation,
    VkDeviceSize allocationLocalOffset,
    VkBuffer hBuffer,
    const void* pNext)
{
    VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        hAllocation->GetBlock() == this);
    VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
        "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
    const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
    // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
    return hAllocator->BindVulkanBuffer(m_hMemory, memoryOffset, hBuffer, pNext);
}

VkResult VmaDeviceMemoryBlock::BindImageMemory(
    const VmaAllocator hAllocator,
    const VmaAllocation hAllocation,
    VkDeviceSize allocationLocalOffset,
    VkImage hImage,
    const void* pNext)
{
    VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        hAllocation->GetBlock() == this);
    VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
        "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
    const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
    // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
    return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);
}
#endif // _VMA_DEVICE_MEMORY_BLOCK_FUNCTIONS

#ifndef _VMA_ALLOCATION_T_FUNCTIONS
VmaAllocation_T::VmaAllocation_T(bool mappingAllowed)
    : m_Alignment{ 1 },
    m_Size{ 0 },
    m_pUserData{ VMA_NULL },
    m_pName{ VMA_NULL },
    m_MemoryTypeIndex{ 0 },
    m_Type{ (uint8_t)ALLOCATION_TYPE_NONE },
    m_SuballocationType{ (uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN },
    m_MapCount{ 0 },
    m_Flags{ 0 }
{
    if(mappingAllowed)
        m_Flags |= (uint8_t)FLAG_MAPPING_ALLOWED;

#if VMA_STATS_STRING_ENABLED
    m_BufferImageUsage = 0;
#endif
}

VmaAllocation_T::~VmaAllocation_T()
{
    VMA_ASSERT(m_MapCount == 0 && "Allocation was not unmapped before destruction.");

    // Check if owned string was freed.
    VMA_ASSERT(m_pName == VMA_NULL);
}

void VmaAllocation_T::InitBlockAllocation(
    VmaDeviceMemoryBlock* block,
    VmaAllocHandle allocHandle,
    VkDeviceSize alignment,
    VkDeviceSize size,
    uint32_t memoryTypeIndex,
    VmaSuballocationType suballocationType,
    bool mapped)
{
    VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
    VMA_ASSERT(block != VMA_NULL);
    m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
    m_Alignment = alignment;
    m_Size = size;
    m_MemoryTypeIndex = memoryTypeIndex;
    if(mapped)
    {
        VMA_ASSERT(IsMappingAllowed() && "Mapping is not allowed on this allocation! Please use one of the new VMA_ALLOCATION_CREATE_HOST_ACCESS_* flags when creating it.");
        m_Flags |= (uint8_t)FLAG_PERSISTENT_MAP;
    }
    m_SuballocationType = (uint8_t)suballocationType;
    m_BlockAllocation.m_Block = block;
    m_BlockAllocation.m_AllocHandle = allocHandle;
}

void VmaAllocation_T::InitDedicatedAllocation(
    VmaPool hParentPool,
    uint32_t memoryTypeIndex,
    VkDeviceMemory hMemory,
    VmaSuballocationType suballocationType,
    void* pMappedData,
    VkDeviceSize size)
{
    VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
    VMA_ASSERT(hMemory != VK_NULL_HANDLE);
    m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
    m_Alignment = 0;
    m_Size = size;
    m_MemoryTypeIndex = memoryTypeIndex;
    m_SuballocationType = (uint8_t)suballocationType;
    if(pMappedData != VMA_NULL)
    {
        VMA_ASSERT(IsMappingAllowed() && "Mapping is not allowed on this allocation! Please use one of the new VMA_ALLOCATION_CREATE_HOST_ACCESS_* flags when creating it.");
        m_Flags |= (uint8_t)FLAG_PERSISTENT_MAP;
    }
    m_DedicatedAllocation.m_hParentPool = hParentPool;
    m_DedicatedAllocation.m_hMemory = hMemory;
    m_DedicatedAllocation.m_pMappedData = pMappedData;
    m_DedicatedAllocation.m_Prev = VMA_NULL;
    m_DedicatedAllocation.m_Next = VMA_NULL;
}

void VmaAllocation_T::SetName(VmaAllocator hAllocator, const char* pName)
{
    VMA_ASSERT(pName == VMA_NULL || pName != m_pName);

    FreeName(hAllocator);

    if (pName != VMA_NULL)
        m_pName = VmaCreateStringCopy(hAllocator->GetAllocationCallbacks(), pName);
}

uint8_t VmaAllocation_T::SwapBlockAllocation(VmaAllocator hAllocator, VmaAllocation allocation)
{
    VMA_ASSERT(allocation != VMA_NULL);
    VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
    VMA_ASSERT(allocation->m_Type == ALLOCATION_TYPE_BLOCK);

    if (m_MapCount != 0)
        m_BlockAllocation.m_Block->Unmap(hAllocator, m_MapCount);

    m_BlockAllocation.m_Block->m_pMetadata->SetAllocationUserData(m_BlockAllocation.m_AllocHandle, allocation);
    VMA_SWAP(m_BlockAllocation, allocation->m_BlockAllocation);
    m_BlockAllocation.m_Block->m_pMetadata->SetAllocationUserData(m_BlockAllocation.m_AllocHandle, this);

#if VMA_STATS_STRING_ENABLED
    VMA_SWAP(m_BufferImageUsage, allocation->m_BufferImageUsage);
#endif
    return m_MapCount;
}

VmaAllocHandle VmaAllocation_T::GetAllocHandle() const
{
    switch (m_Type)
    {
    case ALLOCATION_TYPE_BLOCK:
        return m_BlockAllocation.m_AllocHandle;
    case ALLOCATION_TYPE_DEDICATED:
        return VK_NULL_HANDLE;
    default:
        VMA_ASSERT(0);
        return VK_NULL_HANDLE;
    }
}

VkDeviceSize VmaAllocation_T::GetOffset() const
{
    switch (m_Type)
    {
    case ALLOCATION_TYPE_BLOCK:
        return m_BlockAllocation.m_Block->m_pMetadata->GetAllocationOffset(m_BlockAllocation.m_AllocHandle);
    case ALLOCATION_TYPE_DEDICATED:
        return 0;
    default:
        VMA_ASSERT(0);
        return 0;
    }
}

VmaPool VmaAllocation_T::GetParentPool() const
{
    switch (m_Type)
    {
    case ALLOCATION_TYPE_BLOCK:
        return m_BlockAllocation.m_Block->GetParentPool();
    case ALLOCATION_TYPE_DEDICATED:
        return m_DedicatedAllocation.m_hParentPool;
    default:
        VMA_ASSERT(0);
        return VK_NULL_HANDLE;
    }
}

VkDeviceMemory VmaAllocation_T::GetMemory() const
{
    switch (m_Type)
    {
    case ALLOCATION_TYPE_BLOCK:
        return m_BlockAllocation.m_Block->GetDeviceMemory();
    case ALLOCATION_TYPE_DEDICATED:
        return m_DedicatedAllocation.m_hMemory;
    default:
        VMA_ASSERT(0);
        return VK_NULL_HANDLE;
    }
}

void* VmaAllocation_T::GetMappedData() const
{
    switch (m_Type)
    {
    case ALLOCATION_TYPE_BLOCK:
        if (m_MapCount != 0 || IsPersistentMap())
        {
            void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
            VMA_ASSERT(pBlockData != VMA_NULL);
            return (char*)pBlockData + GetOffset();
        }
        else
        {
            return VMA_NULL;
        }
        break;
    case ALLOCATION_TYPE_DEDICATED:
        VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0 || IsPersistentMap()));
        return m_DedicatedAllocation.m_pMappedData;
    default:
        VMA_ASSERT(0);
        return VMA_NULL;
    }
}

void VmaAllocation_T::BlockAllocMap()
{
    VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
    VMA_ASSERT(IsMappingAllowed() && "Mapping is not allowed on this allocation! Please use one of the new VMA_ALLOCATION_CREATE_HOST_ACCESS_* flags when creating it.");

    if (m_MapCount < 0xFF)
    {
        ++m_MapCount;
    }
    else
    {
        VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
    }
}

void VmaAllocation_T::BlockAllocUnmap()
{
    VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);

    if (m_MapCount > 0)
    {
        --m_MapCount;
    }
    else
    {
        VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
    }
}

VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
{
    VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
    VMA_ASSERT(IsMappingAllowed() && "Mapping is not allowed on this allocation! Please use one of the new VMA_ALLOCATION_CREATE_HOST_ACCESS_* flags when creating it.");

    if (m_MapCount != 0 || IsPersistentMap())
    {
        if (m_MapCount < 0xFF)
        {
            VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
            *ppData = m_DedicatedAllocation.m_pMappedData;
            ++m_MapCount;
            return VK_SUCCESS;
        }
        else
        {
            VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
            return VK_ERROR_MEMORY_MAP_FAILED;
        }
    }
    else
    {
        VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
            hAllocator->m_hDevice,
            m_DedicatedAllocation.m_hMemory,
            0, // offset
            VK_WHOLE_SIZE,
            0, // flags
            ppData);
        if (result == VK_SUCCESS)
        {
            m_DedicatedAllocation.m_pMappedData = *ppData;
            m_MapCount = 1;
        }
        return result;
    }
}

void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
{
    VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);

    if (m_MapCount > 0)
    {
        --m_MapCount;
        if (m_MapCount == 0 && !IsPersistentMap())
        {
            m_DedicatedAllocation.m_pMappedData = VMA_NULL;
            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
                hAllocator->m_hDevice,
                m_DedicatedAllocation.m_hMemory);
        }
    }
    else
    {
        VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
    }
}

#if VMA_STATS_STRING_ENABLED
void VmaAllocation_T::InitBufferImageUsage(uint32_t bufferImageUsage)
{
    VMA_ASSERT(m_BufferImageUsage == 0);
    m_BufferImageUsage = bufferImageUsage;
}

void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
{
    json.WriteString("Type");
    json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);

    json.WriteString("Size");
    json.WriteNumber(m_Size);
    json.WriteString("Usage");
    json.WriteNumber(m_BufferImageUsage);

    if (m_pUserData != VMA_NULL)
    {
        json.WriteString("CustomData");
        json.BeginString();
        json.ContinueString_Pointer(m_pUserData);
        json.EndString();
    }
    if (m_pName != VMA_NULL)
    {
        json.WriteString("Name");
        json.WriteString(m_pName);
    }
}
#endif // VMA_STATS_STRING_ENABLED

void VmaAllocation_T::FreeName(VmaAllocator hAllocator)
{
    if(m_pName)
    {
        VmaFreeString(hAllocator->GetAllocationCallbacks(), m_pName);
        m_pName = VMA_NULL;
    }
}
#endif // _VMA_ALLOCATION_T_FUNCTIONS

#ifndef _VMA_BLOCK_VECTOR_FUNCTIONS
VmaBlockVector::VmaBlockVector(
    VmaAllocator hAllocator,
    VmaPool hParentPool,
    uint32_t memoryTypeIndex,
    VkDeviceSize preferredBlockSize,
    size_t minBlockCount,
    size_t maxBlockCount,
    VkDeviceSize bufferImageGranularity,
    bool explicitBlockSize,
    uint32_t algorithm,
    float priority,
    VkDeviceSize minAllocationAlignment,
    void* pMemoryAllocateNext)
    : m_hAllocator(hAllocator),
    m_hParentPool(hParentPool),
    m_MemoryTypeIndex(memoryTypeIndex),
    m_PreferredBlockSize(preferredBlockSize),
    m_MinBlockCount(minBlockCount),
    m_MaxBlockCount(maxBlockCount),
    m_BufferImageGranularity(bufferImageGranularity),
    m_ExplicitBlockSize(explicitBlockSize),
    m_Algorithm(algorithm),
    m_Priority(priority),
    m_MinAllocationAlignment(minAllocationAlignment),
    m_pMemoryAllocateNext(pMemoryAllocateNext),
    m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
    m_NextBlockId(0) {}

VmaBlockVector::~VmaBlockVector()
{
    for (size_t i = m_Blocks.size(); i--; )
    {
        m_Blocks[i]->Destroy(m_hAllocator);
        vma_delete(m_hAllocator, m_Blocks[i]);
    }
}

VkResult VmaBlockVector::CreateMinBlocks()
{
    for (size_t i = 0; i < m_MinBlockCount; ++i)
    {
        VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
        if (res != VK_SUCCESS)
        {
            return res;
        }
    }
    return VK_SUCCESS;
}

void VmaBlockVector::AddStatistics(VmaStatistics& inoutStats)
{
    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);

    const size_t blockCount = m_Blocks.size();
    for (uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
    {
        const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        VMA_ASSERT(pBlock);
        VMA_HEAVY_ASSERT(pBlock->Validate());
        pBlock->m_pMetadata->AddStatistics(inoutStats);
    }
}

void VmaBlockVector::AddDetailedStatistics(VmaDetailedStatistics& inoutStats)
{
    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);

    const size_t blockCount = m_Blocks.size();
    for (uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
    {
        const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        VMA_ASSERT(pBlock);
        VMA_HEAVY_ASSERT(pBlock->Validate());
        pBlock->m_pMetadata->AddDetailedStatistics(inoutStats);
    }
}

bool VmaBlockVector::IsEmpty()
{
    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
    return m_Blocks.empty();
}

bool VmaBlockVector::IsCorruptionDetectionEnabled() const
{
    const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
    return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
        (VMA_DEBUG_MARGIN > 0) &&
        (m_Algorithm == 0 || m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) &&
        (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
}

VkResult VmaBlockVector::Allocate(
    VkDeviceSize size,
    VkDeviceSize alignment,
    const VmaAllocationCreateInfo& createInfo,
    VmaSuballocationType suballocType,
    size_t allocationCount,
    VmaAllocation* pAllocations)
{
    size_t allocIndex;
    VkResult res = VK_SUCCESS;

    alignment = VMA_MAX(alignment, m_MinAllocationAlignment);

    if (IsCorruptionDetectionEnabled())
    {
        size = VmaAlignUp<VkDeviceSize>(size, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
        alignment = VmaAlignUp<VkDeviceSize>(alignment, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
    }

    {
        VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
        for (allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        {
            res = AllocatePage(
                size,
                alignment,
                createInfo,
                suballocType,
                pAllocations + allocIndex);
            if (res != VK_SUCCESS)
            {
                break;
            }
        }
    }

    if (res != VK_SUCCESS)
    {
        // Free all already created allocations.
        while (allocIndex--)
            Free(pAllocations[allocIndex]);
        memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
    }

    return res;
}

VkResult VmaBlockVector::AllocatePage(
    VkDeviceSize size,
    VkDeviceSize alignment,
    const VmaAllocationCreateInfo& createInfo,
    VmaSuballocationType suballocType,
    VmaAllocation* pAllocation)
{
    const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;

    VkDeviceSize freeMemory;
    {
        const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
        VmaBudget heapBudget = {};
        m_hAllocator->GetHeapBudgets(&heapBudget, heapIndex, 1);
        freeMemory = (heapBudget.usage < heapBudget.budget) ? (heapBudget.budget - heapBudget.usage) : 0;
    }

    const bool canFallbackToDedicated = !HasExplicitBlockSize() &&
        (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0;
    const bool canCreateNewBlock =
        ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
        (m_Blocks.size() < m_MaxBlockCount) &&
        (freeMemory >= size || !canFallbackToDedicated);
    uint32_t strategy = createInfo.flags & VMA_ALLOCATION_CREATE_STRATEGY_MASK;

    // Upper address can only be used with linear allocator and within single memory block.
    if (isUpperAddress &&
        (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT || m_MaxBlockCount > 1))
    {
        return VK_ERROR_FEATURE_NOT_PRESENT;
    }

    // Early reject: requested allocation size is larger that maximum block size for this block vector.
    if (size + VMA_DEBUG_MARGIN > m_PreferredBlockSize)
    {
        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    }

    // 1. Search existing allocations. Try to allocate.
    if (m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
    {
        // Use only last block.
        if (!m_Blocks.empty())
        {
            VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks.back();
            VMA_ASSERT(pCurrBlock);
            VkResult res = AllocateFromBlock(
                pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
            if (res == VK_SUCCESS)
            {
                VMA_DEBUG_LOG("    Returned from last block #%u", pCurrBlock->GetId());
                IncrementallySortBlocks();
                return VK_SUCCESS;
            }
        }
    }
    else
    {
        if (strategy != VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT) // MIN_MEMORY or default
        {
            const bool isHostVisible =
                (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0;
            if(isHostVisible)
            {
                const bool isMappingAllowed = (createInfo.flags &
                    (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0;
                /*
                For non-mappable allocations, check blocks that are not mapped first.
                For mappable allocations, check blocks that are already mapped first.
                This way, having many blocks, we will separate mappable and non-mappable allocations,
                hopefully limiting the number of blocks that are mapped, which will help tools like RenderDoc.
                */
                for(size_t mappingI = 0; mappingI < 2; ++mappingI)
                {
                    // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
                    for (size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
                    {
                        VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
                        VMA_ASSERT(pCurrBlock);
                        const bool isBlockMapped = pCurrBlock->GetMappedData() != VMA_NULL;
                        if((mappingI == 0) == (isMappingAllowed == isBlockMapped))
                        {
                            VkResult res = AllocateFromBlock(
                                pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                            if (res == VK_SUCCESS)
                            {
                                VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());
                                IncrementallySortBlocks();
                                return VK_SUCCESS;
                            }
                        }
                    }
                }
            }
            else
            {
                // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
                for (size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
                {
                    VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
                    VMA_ASSERT(pCurrBlock);
                    VkResult res = AllocateFromBlock(
                        pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                    if (res == VK_SUCCESS)
                    {
                        VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());
                        IncrementallySortBlocks();
                        return VK_SUCCESS;
                    }
                }
            }
        }
        else // VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT
        {
            // Backward order in m_Blocks - prefer blocks with largest amount of free space.
            for (size_t blockIndex = m_Blocks.size(); blockIndex--; )
            {
                VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
                VMA_ASSERT(pCurrBlock);
                VkResult res = AllocateFromBlock(pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                if (res == VK_SUCCESS)
                {
                    VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());
                    IncrementallySortBlocks();
                    return VK_SUCCESS;
                }
            }
        }
    }

    // 2. Try to create new block.
    if (canCreateNewBlock)
    {
        // Calculate optimal size for new block.
        VkDeviceSize newBlockSize = m_PreferredBlockSize;
        uint32_t newBlockSizeShift = 0;
        const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;

        if (!m_ExplicitBlockSize)
        {
            // Allocate 1/8, 1/4, 1/2 as first blocks.
            const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
            for (uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
            {
                const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
                if (smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
                {
                    newBlockSize = smallerNewBlockSize;
                    ++newBlockSizeShift;
                }
                else
                {
                    break;
                }
            }
        }

        size_t newBlockIndex = 0;
        VkResult res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
            CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
        // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
        if (!m_ExplicitBlockSize)
        {
            while (res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
            {
                const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
                if (smallerNewBlockSize >= size)
                {
                    newBlockSize = smallerNewBlockSize;
                    ++newBlockSizeShift;
                    res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
                        CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
                }
                else
                {
                    break;
                }
            }
        }

        if (res == VK_SUCCESS)
        {
            VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
            VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);

            res = AllocateFromBlock(
                pBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
            if (res == VK_SUCCESS)
            {
                VMA_DEBUG_LOG("    Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);
                IncrementallySortBlocks();
                return VK_SUCCESS;
            }
            else
            {
                // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
            }
        }
    }

    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
}

void VmaBlockVector::Free(const VmaAllocation hAllocation)
{
    VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;

    bool budgetExceeded = false;
    {
        const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
        VmaBudget heapBudget = {};
        m_hAllocator->GetHeapBudgets(&heapBudget, heapIndex, 1);
        budgetExceeded = heapBudget.usage >= heapBudget.budget;
    }

    // Scope for lock.
    {
        VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);

        VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();

        if (IsCorruptionDetectionEnabled())
        {
            VkResult res = pBlock->ValidateMagicValueAfterAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
            VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
        }

        if (hAllocation->IsPersistentMap())
        {
            pBlock->Unmap(m_hAllocator, 1);
        }

        const bool hadEmptyBlockBeforeFree = HasEmptyBlock();
        pBlock->m_pMetadata->Free(hAllocation->GetAllocHandle());
        pBlock->PostFree(m_hAllocator);
        VMA_HEAVY_ASSERT(pBlock->Validate());

        VMA_DEBUG_LOG("  Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);

        const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;
        // pBlock became empty after this deallocation.
        if (pBlock->m_pMetadata->IsEmpty())
        {
            // Already had empty block. We don't want to have two, so delete this one.
            if ((hadEmptyBlockBeforeFree || budgetExceeded) && canDeleteBlock)
            {
                pBlockToDelete = pBlock;
                Remove(pBlock);
            }
            // else: We now have one empty block - leave it. A hysteresis to avoid allocating whole block back and forth.
        }
        // pBlock didn't become empty, but we have another empty block - find and free that one.
        // (This is optional, heuristics.)
        else if (hadEmptyBlockBeforeFree && canDeleteBlock)
        {
            VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
            if (pLastBlock->m_pMetadata->IsEmpty())
            {
                pBlockToDelete = pLastBlock;
                m_Blocks.pop_back();
            }
        }

        IncrementallySortBlocks();
    }

    // Destruction of a free block. Deferred until this point, outside of mutex
    // lock, for performance reason.
    if (pBlockToDelete != VMA_NULL)
    {
        VMA_DEBUG_LOG("    Deleted empty block #%u", pBlockToDelete->GetId());
        pBlockToDelete->Destroy(m_hAllocator);
        vma_delete(m_hAllocator, pBlockToDelete);
    }

    m_hAllocator->m_Budget.RemoveAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), hAllocation->GetSize());
    m_hAllocator->m_AllocationObjectAllocator.Free(hAllocation);
}

VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
{
    VkDeviceSize result = 0;
    for (size_t i = m_Blocks.size(); i--; )
    {
        result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
        if (result >= m_PreferredBlockSize)
        {
            break;
        }
    }
    return result;
}

void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
{
    for (uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    {
        if (m_Blocks[blockIndex] == pBlock)
        {
            VmaVectorRemove(m_Blocks, blockIndex);
            return;
        }
    }
    VMA_ASSERT(0);
}

void VmaBlockVector::IncrementallySortBlocks()
{
    if (!m_IncrementalSort)
        return;
    if (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
    {
        // Bubble sort only until first swap.
        for (size_t i = 1; i < m_Blocks.size(); ++i)
        {
            if (m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
            {
                VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
                return;
            }
        }
    }
}

void VmaBlockVector::SortByFreeSize()
{
    VMA_SORT(m_Blocks.begin(), m_Blocks.end(),
        [](VmaDeviceMemoryBlock* b1, VmaDeviceMemoryBlock* b2) -> bool
        {
            return b1->m_pMetadata->GetSumFreeSize() < b2->m_pMetadata->GetSumFreeSize();
        });
}

VkResult VmaBlockVector::AllocateFromBlock(
    VmaDeviceMemoryBlock* pBlock,
    VkDeviceSize size,
    VkDeviceSize alignment,
    VmaAllocationCreateFlags allocFlags,
    void* pUserData,
    VmaSuballocationType suballocType,
    uint32_t strategy,
    VmaAllocation* pAllocation)
{
    const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;

    VmaAllocationRequest currRequest = {};
    if (pBlock->m_pMetadata->CreateAllocationRequest(
        size,
        alignment,
        isUpperAddress,
        suballocType,
        strategy,
        &currRequest))
    {
        return CommitAllocationRequest(currRequest, pBlock, alignment, allocFlags, pUserData, suballocType, pAllocation);
    }
    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
}

VkResult VmaBlockVector::CommitAllocationRequest(
    VmaAllocationRequest& allocRequest,
    VmaDeviceMemoryBlock* pBlock,
    VkDeviceSize alignment,
    VmaAllocationCreateFlags allocFlags,
    void* pUserData,
    VmaSuballocationType suballocType,
    VmaAllocation* pAllocation)
{
    const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
    const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
    const bool isMappingAllowed = (allocFlags &
        (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0;

    pBlock->PostAlloc(m_hAllocator);
    // Allocate from pCurrBlock.
    if (mapped)
    {
        VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
        if (res != VK_SUCCESS)
        {
            return res;
        }
    }

    *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate(isMappingAllowed);
    pBlock->m_pMetadata->Alloc(allocRequest, suballocType, *pAllocation);
    (*pAllocation)->InitBlockAllocation(
        pBlock,
        allocRequest.allocHandle,
        alignment,
        allocRequest.size, // Not size, as actual allocation size may be larger than requested!
        m_MemoryTypeIndex,
        suballocType,
        mapped);
    VMA_HEAVY_ASSERT(pBlock->Validate());
    if (isUserDataString)
        (*pAllocation)->SetName(m_hAllocator, (const char*)pUserData);
    else
        (*pAllocation)->SetUserData(m_hAllocator, pUserData);
    m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), allocRequest.size);
    if (VMA_DEBUG_INITIALIZE_ALLOCATIONS)
    {
        m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
    }
    if (IsCorruptionDetectionEnabled())
    {
        VkResult res = pBlock->WriteMagicValueAfterAllocation(m_hAllocator, (*pAllocation)->GetOffset(), allocRequest.size);
        VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
    }
    return VK_SUCCESS;
}

VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
{
    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
    allocInfo.pNext = m_pMemoryAllocateNext;
    allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
    allocInfo.allocationSize = blockSize;

#if VMA_BUFFER_DEVICE_ADDRESS
    // Every standalone block can potentially contain a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT - always enable the feature.
    VkMemoryAllocateFlagsInfoKHR allocFlagsInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR };
    if (m_hAllocator->m_UseKhrBufferDeviceAddress)
    {
        allocFlagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
        VmaPnextChainPushFront(&allocInfo, &allocFlagsInfo);
    }
#endif // VMA_BUFFER_DEVICE_ADDRESS

#if VMA_MEMORY_PRIORITY
    VkMemoryPriorityAllocateInfoEXT priorityInfo = { VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT };
    if (m_hAllocator->m_UseExtMemoryPriority)
    {
        VMA_ASSERT(m_Priority >= 0.f && m_Priority <= 1.f);
        priorityInfo.priority = m_Priority;
        VmaPnextChainPushFront(&allocInfo, &priorityInfo);
    }
#endif // VMA_MEMORY_PRIORITY

#if VMA_EXTERNAL_MEMORY
    // Attach VkExportMemoryAllocateInfoKHR if necessary.
    VkExportMemoryAllocateInfoKHR exportMemoryAllocInfo = { VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR };
    exportMemoryAllocInfo.handleTypes = m_hAllocator->GetExternalMemoryHandleTypeFlags(m_MemoryTypeIndex);
    if (exportMemoryAllocInfo.handleTypes != 0)
    {
        VmaPnextChainPushFront(&allocInfo, &exportMemoryAllocInfo);
    }
#endif // VMA_EXTERNAL_MEMORY

    VkDeviceMemory mem = VK_NULL_HANDLE;
    VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
    if (res < 0)
    {
        return res;
    }

    // New VkDeviceMemory successfully created.

    // Create new Allocation for it.
    VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
    pBlock->Init(
        m_hAllocator,
        m_hParentPool,
        m_MemoryTypeIndex,
        mem,
        allocInfo.allocationSize,
        m_NextBlockId++,
        m_Algorithm,
        m_BufferImageGranularity);

    m_Blocks.push_back(pBlock);
    if (pNewBlockIndex != VMA_NULL)
    {
        *pNewBlockIndex = m_Blocks.size() - 1;
    }

    return VK_SUCCESS;
}

bool VmaBlockVector::HasEmptyBlock()
{
    for (size_t index = 0, count = m_Blocks.size(); index < count; ++index)
    {
        VmaDeviceMemoryBlock* const pBlock = m_Blocks[index];
        if (pBlock->m_pMetadata->IsEmpty())
        {
            return true;
        }
    }
    return false;
}

#if VMA_STATS_STRING_ENABLED
void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
{
    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);


    json.BeginObject();
    for (size_t i = 0; i < m_Blocks.size(); ++i)
    {
        json.BeginString();
        json.ContinueString(m_Blocks[i]->GetId());
        json.EndString();

        json.BeginObject();
        json.WriteString("MapRefCount");
        json.WriteNumber(m_Blocks[i]->GetMapRefCount());

        m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
        json.EndObject();
    }
    json.EndObject();
}
#endif // VMA_STATS_STRING_ENABLED

VkResult VmaBlockVector::CheckCorruption()
{
    if (!IsCorruptionDetectionEnabled())
    {
        return VK_ERROR_FEATURE_NOT_PRESENT;
    }

    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
    for (uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    {
        VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        VMA_ASSERT(pBlock);
        VkResult res = pBlock->CheckCorruption(m_hAllocator);
        if (res != VK_SUCCESS)
        {
            return res;
        }
    }
    return VK_SUCCESS;
}

#endif // _VMA_BLOCK_VECTOR_FUNCTIONS

#ifndef _VMA_DEFRAGMENTATION_CONTEXT_FUNCTIONS
VmaDefragmentationContext_T::VmaDefragmentationContext_T(
    VmaAllocator hAllocator,
    const VmaDefragmentationInfo& info)
    : m_MaxPassBytes(info.maxBytesPerPass == 0 ? VK_WHOLE_SIZE : info.maxBytesPerPass),
    m_MaxPassAllocations(info.maxAllocationsPerPass == 0 ? UINT32_MAX : info.maxAllocationsPerPass),
    m_MoveAllocator(hAllocator->GetAllocationCallbacks()),
    m_Moves(m_MoveAllocator)
{
    m_Algorithm = info.flags & VMA_DEFRAGMENTATION_FLAG_ALGORITHM_MASK;

    if (info.pool != VMA_NULL)
    {
        m_BlockVectorCount = 1;
        m_PoolBlockVector = &info.pool->m_BlockVector;
        m_pBlockVectors = &m_PoolBlockVector;
        m_PoolBlockVector->SetIncrementalSort(false);
        m_PoolBlockVector->SortByFreeSize();
    }
    else
    {
        m_BlockVectorCount = hAllocator->GetMemoryTypeCount();
        m_PoolBlockVector = VMA_NULL;
        m_pBlockVectors = hAllocator->m_pBlockVectors;
        for (uint32_t i = 0; i < m_BlockVectorCount; ++i)
        {
            VmaBlockVector* vector = m_pBlockVectors[i];
            if (vector != VMA_NULL)
            {
                vector->SetIncrementalSort(false);
                vector->SortByFreeSize();
            }
        }
    }

    switch (m_Algorithm)
    {
    case 0: // Default algorithm
        m_Algorithm = VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT;
    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT:
    {
        m_AlgorithmState = vma_new_array(hAllocator, StateBalanced, m_BlockVectorCount);
        break;
    }
    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
    {
        if (hAllocator->GetBufferImageGranularity() > 1)
        {
            m_AlgorithmState = vma_new_array(hAllocator, StateExtensive, m_BlockVectorCount);
        }
        break;
    }
    }
}

VmaDefragmentationContext_T::~VmaDefragmentationContext_T()
{
    if (m_PoolBlockVector != VMA_NULL)
    {
        m_PoolBlockVector->SetIncrementalSort(true);
    }
    else
    {
        for (uint32_t i = 0; i < m_BlockVectorCount; ++i)
        {
            VmaBlockVector* vector = m_pBlockVectors[i];
            if (vector != VMA_NULL)
                vector->SetIncrementalSort(true);
        }
    }

    if (m_AlgorithmState)
    {
        switch (m_Algorithm)
        {
        case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT:
            vma_delete_array(m_MoveAllocator.m_pCallbacks, reinterpret_cast<StateBalanced*>(m_AlgorithmState), m_BlockVectorCount);
            break;
        case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
            vma_delete_array(m_MoveAllocator.m_pCallbacks, reinterpret_cast<StateExtensive*>(m_AlgorithmState), m_BlockVectorCount);
            break;
        default:
            VMA_ASSERT(0);
        }
    }
}

VkResult VmaDefragmentationContext_T::DefragmentPassBegin(VmaDefragmentationPassMoveInfo& moveInfo)
{
    if (m_PoolBlockVector != VMA_NULL)
    {
        VmaMutexLockWrite lock(m_PoolBlockVector->GetMutex(), m_PoolBlockVector->GetAllocator()->m_UseMutex);

        if (m_PoolBlockVector->GetBlockCount() > 1)
            ComputeDefragmentation(*m_PoolBlockVector, 0);
        else if (m_PoolBlockVector->GetBlockCount() == 1)
            ReallocWithinBlock(*m_PoolBlockVector, m_PoolBlockVector->GetBlock(0));
    }
    else
    {
        for (uint32_t i = 0; i < m_BlockVectorCount; ++i)
        {
            if (m_pBlockVectors[i] != VMA_NULL)
            {
                VmaMutexLockWrite lock(m_pBlockVectors[i]->GetMutex(), m_pBlockVectors[i]->GetAllocator()->m_UseMutex);

                if (m_pBlockVectors[i]->GetBlockCount() > 1)
                {
                    if (ComputeDefragmentation(*m_pBlockVectors[i], i))
                        break;
                }
                else if (m_pBlockVectors[i]->GetBlockCount() == 1)
                {
                    if (ReallocWithinBlock(*m_pBlockVectors[i], m_pBlockVectors[i]->GetBlock(0)))
                        break;
                }
            }
        }
    }

    moveInfo.moveCount = static_cast<uint32_t>(m_Moves.size());
    if (moveInfo.moveCount > 0)
    {
        moveInfo.pMoves = m_Moves.data();
        return VK_INCOMPLETE;
    }

    moveInfo.pMoves = VMA_NULL;
    return VK_SUCCESS;
}

VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMoveInfo& moveInfo)
{
    VMA_ASSERT(moveInfo.moveCount > 0 ? moveInfo.pMoves != VMA_NULL : true);

    VkResult result = VK_SUCCESS;
    VmaStlAllocator<FragmentedBlock> blockAllocator(m_MoveAllocator.m_pCallbacks);
    VmaVector<FragmentedBlock, VmaStlAllocator<FragmentedBlock>> immovableBlocks(blockAllocator);
    VmaVector<FragmentedBlock, VmaStlAllocator<FragmentedBlock>> mappedBlocks(blockAllocator);

    VmaAllocator allocator = VMA_NULL;
    for (uint32_t i = 0; i < moveInfo.moveCount; ++i)
    {
        VmaDefragmentationMove& move = moveInfo.pMoves[i];
        size_t prevCount = 0, currentCount = 0;
        VkDeviceSize freedBlockSize = 0;

        uint32_t vectorIndex;
        VmaBlockVector* vector;
        if (m_PoolBlockVector != VMA_NULL)
        {
            vectorIndex = 0;
            vector = m_PoolBlockVector;
        }
        else
        {
            vectorIndex = move.srcAllocation->GetMemoryTypeIndex();
            vector = m_pBlockVectors[vectorIndex];
            VMA_ASSERT(vector != VMA_NULL);
        }

        switch (move.operation)
        {
        case VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY:
        {
            uint8_t mapCount = move.srcAllocation->SwapBlockAllocation(vector->m_hAllocator, move.dstTmpAllocation);
            if (mapCount > 0)
            {
                allocator = vector->m_hAllocator;
                VmaDeviceMemoryBlock* newMapBlock = move.srcAllocation->GetBlock();
                bool notPresent = true;
                for (FragmentedBlock& block : mappedBlocks)
                {
                    if (block.block == newMapBlock)
                    {
                        notPresent = false;
                        block.data += mapCount;
                        break;
                    }
                }
                if (notPresent)
                    mappedBlocks.push_back({ mapCount, newMapBlock });
            }

            // Scope for locks, Free have it's own lock
            {
                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
                prevCount = vector->GetBlockCount();
                freedBlockSize = move.dstTmpAllocation->GetBlock()->m_pMetadata->GetSize();
            }
            vector->Free(move.dstTmpAllocation);
            {
                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
                currentCount = vector->GetBlockCount();
            }

            result = VK_INCOMPLETE;
            break;
        }
        case VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE:
        {
            m_PassStats.bytesMoved -= move.srcAllocation->GetSize();
            --m_PassStats.allocationsMoved;
            vector->Free(move.dstTmpAllocation);

            VmaDeviceMemoryBlock* newBlock = move.srcAllocation->GetBlock();
            bool notPresent = true;
            for (const FragmentedBlock& block : immovableBlocks)
            {
                if (block.block == newBlock)
                {
                    notPresent = false;
                    break;
                }
            }
            if (notPresent)
                immovableBlocks.push_back({ vectorIndex, newBlock });
            break;
        }
        case VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY:
        {
            m_PassStats.bytesMoved -= move.srcAllocation->GetSize();
            --m_PassStats.allocationsMoved;
            // Scope for locks, Free have it's own lock
            {
                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
                prevCount = vector->GetBlockCount();
                freedBlockSize = move.srcAllocation->GetBlock()->m_pMetadata->GetSize();
            }
            vector->Free(move.srcAllocation);
            {
                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
                currentCount = vector->GetBlockCount();
            }
            freedBlockSize *= prevCount - currentCount;

            VkDeviceSize dstBlockSize;
            {
                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
                dstBlockSize = move.dstTmpAllocation->GetBlock()->m_pMetadata->GetSize();
            }
            vector->Free(move.dstTmpAllocation);
            {
                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
                freedBlockSize += dstBlockSize * (currentCount - vector->GetBlockCount());
                currentCount = vector->GetBlockCount();
            }

            result = VK_INCOMPLETE;
            break;
        }
        default:
            VMA_ASSERT(0);
        }

        if (prevCount > currentCount)
        {
            size_t freedBlocks = prevCount - currentCount;
            m_PassStats.deviceMemoryBlocksFreed += static_cast<uint32_t>(freedBlocks);
            m_PassStats.bytesFreed += freedBlockSize;
        }

        switch (m_Algorithm)
        {
        case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
        {
            if (m_AlgorithmState != VMA_NULL)
            {
                // Avoid unnecessary tries to allocate when new free block is available
                StateExtensive& state = reinterpret_cast<StateExtensive*>(m_AlgorithmState)[vectorIndex];
                if (state.firstFreeBlock != SIZE_MAX)
                {
                    const size_t diff = prevCount - currentCount;
                    if (state.firstFreeBlock >= diff)
                    {
                        state.firstFreeBlock -= diff;
                        if (state.firstFreeBlock != 0)
                            state.firstFreeBlock -= vector->GetBlock(state.firstFreeBlock - 1)->m_pMetadata->IsEmpty();
                    }
                    else
                        state.firstFreeBlock = 0;
                }
            }
        }
        }
    }
    moveInfo.moveCount = 0;
    moveInfo.pMoves = VMA_NULL;
    m_Moves.clear();

    // Update stats
    m_GlobalStats.allocationsMoved += m_PassStats.allocationsMoved;
    m_GlobalStats.bytesFreed += m_PassStats.bytesFreed;
    m_GlobalStats.bytesMoved += m_PassStats.bytesMoved;
    m_GlobalStats.deviceMemoryBlocksFreed += m_PassStats.deviceMemoryBlocksFreed;
    m_PassStats = { 0 };

    // Move blocks with immovable allocations according to algorithm
    if (immovableBlocks.size() > 0)
    {
        switch (m_Algorithm)
        {
        case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
        {
            if (m_AlgorithmState != VMA_NULL)
            {
                bool swapped = false;
                // Move to the start of free blocks range
                for (const FragmentedBlock& block : immovableBlocks)
                {
                    StateExtensive& state = reinterpret_cast<StateExtensive*>(m_AlgorithmState)[block.data];
                    if (state.operation != StateExtensive::Operation::Cleanup)
                    {
                        VmaBlockVector* vector = m_pBlockVectors[block.data];
                        VmaMutexLockWrite lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);

                        for (size_t i = 0, count = vector->GetBlockCount() - m_ImmovableBlockCount; i < count; ++i)
                        {
                            if (vector->GetBlock(i) == block.block)
                            {
                                VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[vector->GetBlockCount() - ++m_ImmovableBlockCount]);
                                if (state.firstFreeBlock != SIZE_MAX)
                                {
                                    if (i + 1 < state.firstFreeBlock)
                                    {
                                        if (state.firstFreeBlock > 1)
                                            VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[--state.firstFreeBlock]);
                                        else
                                            --state.firstFreeBlock;
                                    }
                                }
                                swapped = true;
                                break;
                            }
                        }
                    }
                }
                if (swapped)
                    result = VK_INCOMPLETE;
                break;
            }
        }
        default:
        {
            // Move to the beginning
            for (const FragmentedBlock& block : immovableBlocks)
            {
                VmaBlockVector* vector = m_pBlockVectors[block.data];
                VmaMutexLockWrite lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);

                for (size_t i = m_ImmovableBlockCount; i < vector->GetBlockCount(); ++i)
                {
                    if (vector->GetBlock(i) == block.block)
                    {
                        VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[m_ImmovableBlockCount++]);
                        break;
                    }
                }
            }
            break;
        }
        }
    }

    // Bulk-map destination blocks
    for (const FragmentedBlock& block : mappedBlocks)
    {
        VkResult res = block.block->Map(allocator, block.data, VMA_NULL);
        VMA_ASSERT(res == VK_SUCCESS);
    }
    return result;
}

bool VmaDefragmentationContext_T::ComputeDefragmentation(VmaBlockVector& vector, size_t index)
{
    switch (m_Algorithm)
    {
    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT:
        return ComputeDefragmentation_Fast(vector);
    default:
        VMA_ASSERT(0);
    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT:
        return ComputeDefragmentation_Balanced(vector, index, true);
    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT:
        return ComputeDefragmentation_Full(vector);
    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
        return ComputeDefragmentation_Extensive(vector, index);
    }
}

VmaDefragmentationContext_T::MoveAllocationData VmaDefragmentationContext_T::GetMoveData(
    VmaAllocHandle handle, VmaBlockMetadata* metadata)
{
    MoveAllocationData moveData;
    moveData.move.srcAllocation = (VmaAllocation)metadata->GetAllocationUserData(handle);
    moveData.size = moveData.move.srcAllocation->GetSize();
    moveData.alignment = moveData.move.srcAllocation->GetAlignment();
    moveData.type = moveData.move.srcAllocation->GetSuballocationType();
    moveData.flags = 0;

    if (moveData.move.srcAllocation->IsPersistentMap())
        moveData.flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
    if (moveData.move.srcAllocation->IsMappingAllowed())
        moveData.flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;

    return moveData;
}

VmaDefragmentationContext_T::CounterStatus VmaDefragmentationContext_T::CheckCounters(VkDeviceSize bytes)
{
    // Ignore allocation if will exceed max size for copy
    if (m_PassStats.bytesMoved + bytes > m_MaxPassBytes)
    {
        if (++m_IgnoredAllocs < MAX_ALLOCS_TO_IGNORE)
            return CounterStatus::Ignore;
        else
            return CounterStatus::End;
    }
    return CounterStatus::Pass;
}

bool VmaDefragmentationContext_T::IncrementCounters(VkDeviceSize bytes)
{
    m_PassStats.bytesMoved += bytes;
    // Early return when max found
    if (++m_PassStats.allocationsMoved >= m_MaxPassAllocations || m_PassStats.bytesMoved >= m_MaxPassBytes)
    {
        VMA_ASSERT(m_PassStats.allocationsMoved == m_MaxPassAllocations ||
            m_PassStats.bytesMoved == m_MaxPassBytes && "Exceeded maximal pass threshold!");
        return true;
    }
    return false;
}

bool VmaDefragmentationContext_T::ReallocWithinBlock(VmaBlockVector& vector, VmaDeviceMemoryBlock* block)
{
    VmaBlockMetadata* metadata = block->m_pMetadata;

    for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
        handle != VK_NULL_HANDLE;
        handle = metadata->GetNextAllocation(handle))
    {
        MoveAllocationData moveData = GetMoveData(handle, metadata);
        // Ignore newly created allocations by defragmentation algorithm
        if (moveData.move.srcAllocation->GetUserData() == this)
            continue;
        switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
        {
        case CounterStatus::Ignore:
            continue;
        case CounterStatus::End:
            return true;
        default:
            VMA_ASSERT(0);
        case CounterStatus::Pass:
            break;
        }

        VkDeviceSize offset = moveData.move.srcAllocation->GetOffset();
        if (offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
        {
            VmaAllocationRequest request = {};
            if (metadata->CreateAllocationRequest(
                moveData.size,
                moveData.alignment,
                false,
                moveData.type,
                VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
                &request))
            {
                if (metadata->GetAllocationOffset(request.allocHandle) < offset)
                {
                    if (vector.CommitAllocationRequest(
                        request,
                        block,
                        moveData.alignment,
                        moveData.flags,
                        this,
                        moveData.type,
                        &moveData.move.dstTmpAllocation) == VK_SUCCESS)
                    {
                        m_Moves.push_back(moveData.move);
                        if (IncrementCounters(moveData.size))
                            return true;
                    }
                }
            }
        }
    }
    return false;
}

bool VmaDefragmentationContext_T::AllocInOtherBlock(size_t start, size_t end, MoveAllocationData& data, VmaBlockVector& vector)
{
    for (; start < end; ++start)
    {
        VmaDeviceMemoryBlock* dstBlock = vector.GetBlock(start);
        if (dstBlock->m_pMetadata->GetSumFreeSize() >= data.size)
        {
            if (vector.AllocateFromBlock(dstBlock,
                data.size,
                data.alignment,
                data.flags,
                this,
                data.type,
                0,
                &data.move.dstTmpAllocation) == VK_SUCCESS)
            {
                m_Moves.push_back(data.move);
                if (IncrementCounters(data.size))
                    return true;
                break;
            }
        }
    }
    return false;
}

bool VmaDefragmentationContext_T::ComputeDefragmentation_Fast(VmaBlockVector& vector)
{
    // Move only between blocks

    // Go through allocations in last blocks and try to fit them inside first ones
    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
    {
        VmaBlockMetadata* metadata = vector.GetBlock(i)->m_pMetadata;

        for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
            handle != VK_NULL_HANDLE;
            handle = metadata->GetNextAllocation(handle))
        {
            MoveAllocationData moveData = GetMoveData(handle, metadata);
            // Ignore newly created allocations by defragmentation algorithm
            if (moveData.move.srcAllocation->GetUserData() == this)
                continue;
            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
            {
            case CounterStatus::Ignore:
                continue;
            case CounterStatus::End:
                return true;
            default:
                VMA_ASSERT(0);
            case CounterStatus::Pass:
                break;
            }

            // Check all previous blocks for free space
            if (AllocInOtherBlock(0, i, moveData, vector))
                return true;
        }
    }
    return false;
}

bool VmaDefragmentationContext_T::ComputeDefragmentation_Balanced(VmaBlockVector& vector, size_t index, bool update)
{
    // Go over every allocation and try to fit it in previous blocks at lowest offsets,
    // if not possible: realloc within single block to minimize offset (exclude offset == 0),
    // but only if there are noticeable gaps between them (some heuristic, ex. average size of allocation in block)
    VMA_ASSERT(m_AlgorithmState != VMA_NULL);

    StateBalanced& vectorState = reinterpret_cast<StateBalanced*>(m_AlgorithmState)[index];
    if (update && vectorState.avgAllocSize == UINT64_MAX)
        UpdateVectorStatistics(vector, vectorState);

    const size_t startMoveCount = m_Moves.size();
    VkDeviceSize minimalFreeRegion = vectorState.avgFreeSize / 2;
    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
    {
        VmaDeviceMemoryBlock* block = vector.GetBlock(i);
        VmaBlockMetadata* metadata = block->m_pMetadata;
        VkDeviceSize prevFreeRegionSize = 0;

        for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
            handle != VK_NULL_HANDLE;
            handle = metadata->GetNextAllocation(handle))
        {
            MoveAllocationData moveData = GetMoveData(handle, metadata);
            // Ignore newly created allocations by defragmentation algorithm
            if (moveData.move.srcAllocation->GetUserData() == this)
                continue;
            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
            {
            case CounterStatus::Ignore:
                continue;
            case CounterStatus::End:
                return true;
            default:
                VMA_ASSERT(0);
            case CounterStatus::Pass:
                break;
            }

            // Check all previous blocks for free space
            const size_t prevMoveCount = m_Moves.size();
            if (AllocInOtherBlock(0, i, moveData, vector))
                return true;

            VkDeviceSize nextFreeRegionSize = metadata->GetNextFreeRegionSize(handle);
            // If no room found then realloc within block for lower offset
            VkDeviceSize offset = moveData.move.srcAllocation->GetOffset();
            if (prevMoveCount == m_Moves.size() && offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
            {
                // Check if realloc will make sense
                if (prevFreeRegionSize >= minimalFreeRegion ||
                    nextFreeRegionSize >= minimalFreeRegion ||
                    moveData.size <= vectorState.avgFreeSize ||
                    moveData.size <= vectorState.avgAllocSize)
                {
                    VmaAllocationRequest request = {};
                    if (metadata->CreateAllocationRequest(
                        moveData.size,
                        moveData.alignment,
                        false,
                        moveData.type,
                        VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
                        &request))
                    {
                        if (metadata->GetAllocationOffset(request.allocHandle) < offset)
                        {
                            if (vector.CommitAllocationRequest(
                                request,
                                block,
                                moveData.alignment,
                                moveData.flags,
                                this,
                                moveData.type,
                                &moveData.move.dstTmpAllocation) == VK_SUCCESS)
                            {
                                m_Moves.push_back(moveData.move);
                                if (IncrementCounters(moveData.size))
                                    return true;
                            }
                        }
                    }
                }
            }
            prevFreeRegionSize = nextFreeRegionSize;
        }
    }

    // No moves performed, update statistics to current vector state
    if (startMoveCount == m_Moves.size() && !update)
    {
        vectorState.avgAllocSize = UINT64_MAX;
        return ComputeDefragmentation_Balanced(vector, index, false);
    }
    return false;
}

bool VmaDefragmentationContext_T::ComputeDefragmentation_Full(VmaBlockVector& vector)
{
    // Go over every allocation and try to fit it in previous blocks at lowest offsets,
    // if not possible: realloc within single block to minimize offset (exclude offset == 0)

    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
    {
        VmaDeviceMemoryBlock* block = vector.GetBlock(i);
        VmaBlockMetadata* metadata = block->m_pMetadata;

        for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
            handle != VK_NULL_HANDLE;
            handle = metadata->GetNextAllocation(handle))
        {
            MoveAllocationData moveData = GetMoveData(handle, metadata);
            // Ignore newly created allocations by defragmentation algorithm
            if (moveData.move.srcAllocation->GetUserData() == this)
                continue;
            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
            {
            case CounterStatus::Ignore:
                continue;
            case CounterStatus::End:
                return true;
            default:
                VMA_ASSERT(0);
            case CounterStatus::Pass:
                break;
            }

            // Check all previous blocks for free space
            const size_t prevMoveCount = m_Moves.size();
            if (AllocInOtherBlock(0, i, moveData, vector))
                return true;

            // If no room found then realloc within block for lower offset
            VkDeviceSize offset = moveData.move.srcAllocation->GetOffset();
            if (prevMoveCount == m_Moves.size() && offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
            {
                VmaAllocationRequest request = {};
                if (metadata->CreateAllocationRequest(
                    moveData.size,
                    moveData.alignment,
                    false,
                    moveData.type,
                    VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
                    &request))
                {
                    if (metadata->GetAllocationOffset(request.allocHandle) < offset)
                    {
                        if (vector.CommitAllocationRequest(
                            request,
                            block,
                            moveData.alignment,
                            moveData.flags,
                            this,
                            moveData.type,
                            &moveData.move.dstTmpAllocation) == VK_SUCCESS)
                        {
                            m_Moves.push_back(moveData.move);
                            if (IncrementCounters(moveData.size))
                                return true;
                        }
                    }
                }
            }
        }
    }
    return false;
}

bool VmaDefragmentationContext_T::ComputeDefragmentation_Extensive(VmaBlockVector& vector, size_t index)
{
    // First free single block, then populate it to the brim, then free another block, and so on

    // Fallback to previous algorithm since without granularity conflicts it can achieve max packing
    if (vector.m_BufferImageGranularity == 1)
        return ComputeDefragmentation_Full(vector);

    VMA_ASSERT(m_AlgorithmState != VMA_NULL);

    StateExtensive& vectorState = reinterpret_cast<StateExtensive*>(m_AlgorithmState)[index];

    bool texturePresent = false, bufferPresent = false, otherPresent = false;
    switch (vectorState.operation)
    {
    case StateExtensive::Operation::Done: // Vector defragmented
        return false;
    case StateExtensive::Operation::FindFreeBlockBuffer:
    case StateExtensive::Operation::FindFreeBlockTexture:
    case StateExtensive::Operation::FindFreeBlockAll:
    {
        // No more blocks to free, just perform fast realloc and move to cleanup
        if (vectorState.firstFreeBlock == 0)
        {
            vectorState.operation = StateExtensive::Operation::Cleanup;
            return ComputeDefragmentation_Fast(vector);
        }

        // No free blocks, have to clear last one
        size_t last = (vectorState.firstFreeBlock == SIZE_MAX ? vector.GetBlockCount() : vectorState.firstFreeBlock) - 1;
        VmaBlockMetadata* freeMetadata = vector.GetBlock(last)->m_pMetadata;

        const size_t prevMoveCount = m_Moves.size();
        for (VmaAllocHandle handle = freeMetadata->GetAllocationListBegin();
            handle != VK_NULL_HANDLE;
            handle = freeMetadata->GetNextAllocation(handle))
        {
            MoveAllocationData moveData = GetMoveData(handle, freeMetadata);
            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
            {
            case CounterStatus::Ignore:
                continue;
            case CounterStatus::End:
                return true;
            default:
                VMA_ASSERT(0);
            case CounterStatus::Pass:
                break;
            }

            // Check all previous blocks for free space
            if (AllocInOtherBlock(0, last, moveData, vector))
            {
                // Full clear performed already
                if (prevMoveCount != m_Moves.size() && freeMetadata->GetNextAllocation(handle) == VK_NULL_HANDLE)
                    reinterpret_cast<size_t*>(m_AlgorithmState)[index] = last;
                return true;
            }
        }

        if (prevMoveCount == m_Moves.size())
        {
            // Cannot perform full clear, have to move data in other blocks around
            if (last != 0)
            {
                for (size_t i = last - 1; i; --i)
                {
                    if (ReallocWithinBlock(vector, vector.GetBlock(i)))
                        return true;
                }
            }

            if (prevMoveCount == m_Moves.size())
            {
                // No possible reallocs within blocks, try to move them around fast
                return ComputeDefragmentation_Fast(vector);
            }
        }
        else
        {
            switch (vectorState.operation)
            {
            case StateExtensive::Operation::FindFreeBlockBuffer:
                vectorState.operation = StateExtensive::Operation::MoveBuffers;
                break;
            default:
                VMA_ASSERT(0);
            case StateExtensive::Operation::FindFreeBlockTexture:
                vectorState.operation = StateExtensive::Operation::MoveTextures;
                break;
            case StateExtensive::Operation::FindFreeBlockAll:
                vectorState.operation = StateExtensive::Operation::MoveAll;
                break;
            }
            vectorState.firstFreeBlock = last;
            // Nothing done, block found without reallocations, can perform another reallocs in same pass
            return ComputeDefragmentation_Extensive(vector, index);
        }
        break;
    }
    case StateExtensive::Operation::MoveTextures:
    {
        if (MoveDataToFreeBlocks(VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL, vector,
            vectorState.firstFreeBlock, texturePresent, bufferPresent, otherPresent))
        {
            if (texturePresent)
            {
                vectorState.operation = StateExtensive::Operation::FindFreeBlockTexture;
                return ComputeDefragmentation_Extensive(vector, index);
            }

            if (!bufferPresent && !otherPresent)
            {
                vectorState.operation = StateExtensive::Operation::Cleanup;
                break;
            }

            // No more textures to move, check buffers
            vectorState.operation = StateExtensive::Operation::MoveBuffers;
            bufferPresent = false;
            otherPresent = false;
        }
        else
            break;
    }
    case StateExtensive::Operation::MoveBuffers:
    {
        if (MoveDataToFreeBlocks(VMA_SUBALLOCATION_TYPE_BUFFER, vector,
            vectorState.firstFreeBlock, texturePresent, bufferPresent, otherPresent))
        {
            if (bufferPresent)
            {
                vectorState.operation = StateExtensive::Operation::FindFreeBlockBuffer;
                return ComputeDefragmentation_Extensive(vector, index);
            }

            if (!otherPresent)
            {
                vectorState.operation = StateExtensive::Operation::Cleanup;
                break;
            }

            // No more buffers to move, check all others
            vectorState.operation = StateExtensive::Operation::MoveAll;
            otherPresent = false;
        }
        else
            break;
    }
    case StateExtensive::Operation::MoveAll:
    {
        if (MoveDataToFreeBlocks(VMA_SUBALLOCATION_TYPE_FREE, vector,
            vectorState.firstFreeBlock, texturePresent, bufferPresent, otherPresent))
        {
            if (otherPresent)
            {
                vectorState.operation = StateExtensive::Operation::FindFreeBlockBuffer;
                return ComputeDefragmentation_Extensive(vector, index);
            }
            // Everything moved
            vectorState.operation = StateExtensive::Operation::Cleanup;
        }
        break;
    }
    case StateExtensive::Operation::Cleanup:
        // Cleanup is handled below so that other operations may reuse the cleanup code. This case is here to prevent the unhandled enum value warning (C4062).
        break;
    }

    if (vectorState.operation == StateExtensive::Operation::Cleanup)
    {
        // All other work done, pack data in blocks even tighter if possible
        const size_t prevMoveCount = m_Moves.size();
        for (size_t i = 0; i < vector.GetBlockCount(); ++i)
        {
            if (ReallocWithinBlock(vector, vector.GetBlock(i)))
                return true;
        }

        if (prevMoveCount == m_Moves.size())
            vectorState.operation = StateExtensive::Operation::Done;
    }
    return false;
}

void VmaDefragmentationContext_T::UpdateVectorStatistics(VmaBlockVector& vector, StateBalanced& state)
{
    size_t allocCount = 0;
    size_t freeCount = 0;
    state.avgFreeSize = 0;
    state.avgAllocSize = 0;

    for (size_t i = 0; i < vector.GetBlockCount(); ++i)
    {
        VmaBlockMetadata* metadata = vector.GetBlock(i)->m_pMetadata;

        allocCount += metadata->GetAllocationCount();
        freeCount += metadata->GetFreeRegionsCount();
        state.avgFreeSize += metadata->GetSumFreeSize();
        state.avgAllocSize += metadata->GetSize();
    }

    state.avgAllocSize = (state.avgAllocSize - state.avgFreeSize) / allocCount;
    state.avgFreeSize /= freeCount;
}

bool VmaDefragmentationContext_T::MoveDataToFreeBlocks(VmaSuballocationType currentType,
    VmaBlockVector& vector, size_t firstFreeBlock,
    bool& texturePresent, bool& bufferPresent, bool& otherPresent)
{
    const size_t prevMoveCount = m_Moves.size();
    for (size_t i = firstFreeBlock ; i;)
    {
        VmaDeviceMemoryBlock* block = vector.GetBlock(--i);
        VmaBlockMetadata* metadata = block->m_pMetadata;

        for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
            handle != VK_NULL_HANDLE;
            handle = metadata->GetNextAllocation(handle))
        {
            MoveAllocationData moveData = GetMoveData(handle, metadata);
            // Ignore newly created allocations by defragmentation algorithm
            if (moveData.move.srcAllocation->GetUserData() == this)
                continue;
            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
            {
            case CounterStatus::Ignore:
                continue;
            case CounterStatus::End:
                return true;
            default:
                VMA_ASSERT(0);
            case CounterStatus::Pass:
                break;
            }

            // Move only single type of resources at once
            if (!VmaIsBufferImageGranularityConflict(moveData.type, currentType))
            {
                // Try to fit allocation into free blocks
                if (AllocInOtherBlock(firstFreeBlock, vector.GetBlockCount(), moveData, vector))
                    return false;
            }

            if (!VmaIsBufferImageGranularityConflict(moveData.type, VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL))
                texturePresent = true;
            else if (!VmaIsBufferImageGranularityConflict(moveData.type, VMA_SUBALLOCATION_TYPE_BUFFER))
                bufferPresent = true;
            else
                otherPresent = true;
        }
    }
    return prevMoveCount == m_Moves.size();
}
#endif // _VMA_DEFRAGMENTATION_CONTEXT_FUNCTIONS

#ifndef _VMA_POOL_T_FUNCTIONS
VmaPool_T::VmaPool_T(
    VmaAllocator hAllocator,
    const VmaPoolCreateInfo& createInfo,
    VkDeviceSize preferredBlockSize)
    : m_BlockVector(
        hAllocator,
        this, // hParentPool
        createInfo.memoryTypeIndex,
        createInfo.blockSize != 0 ? createInfo.blockSize : preferredBlockSize,
        createInfo.minBlockCount,
        createInfo.maxBlockCount,
        (createInfo.flags& VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
        createInfo.blockSize != 0, // explicitBlockSize
        createInfo.flags & VMA_POOL_CREATE_ALGORITHM_MASK, // algorithm
        createInfo.priority,
        VMA_MAX(hAllocator->GetMemoryTypeMinAlignment(createInfo.memoryTypeIndex), createInfo.minAllocationAlignment),
        createInfo.pMemoryAllocateNext),
    m_Id(0),
    m_Name(VMA_NULL) {}

VmaPool_T::~VmaPool_T()
{
    VMA_ASSERT(m_PrevPool == VMA_NULL && m_NextPool == VMA_NULL);
}

void VmaPool_T::SetName(const char* pName)
{
    const VkAllocationCallbacks* allocs = m_BlockVector.GetAllocator()->GetAllocationCallbacks();
    VmaFreeString(allocs, m_Name);

    if (pName != VMA_NULL)
    {
        m_Name = VmaCreateStringCopy(allocs, pName);
    }
    else
    {
        m_Name = VMA_NULL;
    }
}
#endif // _VMA_POOL_T_FUNCTIONS

#ifndef _VMA_ALLOCATOR_T_FUNCTIONS
VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
    m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
    m_VulkanApiVersion(pCreateInfo->vulkanApiVersion != 0 ? pCreateInfo->vulkanApiVersion : VK_API_VERSION_1_0),
    m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
    m_UseKhrBindMemory2((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0),
    m_UseExtMemoryBudget((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0),
    m_UseAmdDeviceCoherentMemory((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT) != 0),
    m_UseKhrBufferDeviceAddress((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT) != 0),
    m_UseExtMemoryPriority((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT) != 0),
    m_hDevice(pCreateInfo->device),
    m_hInstance(pCreateInfo->instance),
    m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
    m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
        *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
    m_AllocationObjectAllocator(&m_AllocationCallbacks),
    m_HeapSizeLimitMask(0),
    m_DeviceMemoryCount(0),
    m_PreferredLargeHeapBlockSize(0),
    m_PhysicalDevice(pCreateInfo->physicalDevice),
    m_GpuDefragmentationMemoryTypeBits(UINT32_MAX),
    m_NextPoolId(0),
    m_GlobalMemoryTypeBits(UINT32_MAX)
{
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
    {
        m_UseKhrDedicatedAllocation = false;
        m_UseKhrBindMemory2 = false;
    }

    if(VMA_DEBUG_DETECT_CORRUPTION)
    {
        // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
        VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
    }

    VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device && pCreateInfo->instance);

    if(m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0))
    {
#if !(VMA_DEDICATED_ALLOCATION)
        if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
        {
            VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
        }
#endif
#if !(VMA_BIND_MEMORY2)
        if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0)
        {
            VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT set but required extension is disabled by preprocessor macros.");
        }
#endif
    }
#if !(VMA_MEMORY_BUDGET)
    if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0)
    {
        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT set but required extension is disabled by preprocessor macros.");
    }
#endif
#if !(VMA_BUFFER_DEVICE_ADDRESS)
    if(m_UseKhrBufferDeviceAddress)
    {
        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT is set but required extension or Vulkan 1.2 is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
    }
#endif
#if VMA_VULKAN_VERSION < 1003000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
    {
        VMA_ASSERT(0 && "vulkanApiVersion >= VK_API_VERSION_1_3 but required Vulkan version is disabled by preprocessor macros.");
    }
#endif
#if VMA_VULKAN_VERSION < 1002000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 2, 0))
    {
        VMA_ASSERT(0 && "vulkanApiVersion >= VK_API_VERSION_1_2 but required Vulkan version is disabled by preprocessor macros.");
    }
#endif
#if VMA_VULKAN_VERSION < 1001000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
    {
        VMA_ASSERT(0 && "vulkanApiVersion >= VK_API_VERSION_1_1 but required Vulkan version is disabled by preprocessor macros.");
    }
#endif
#if !(VMA_MEMORY_PRIORITY)
    if(m_UseExtMemoryPriority)
    {
        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT is set but required extension is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
    }
#endif

    memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
    memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
    memset(&m_MemProps, 0, sizeof(m_MemProps));

    memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
    memset(&m_VulkanFunctions, 0, sizeof(m_VulkanFunctions));

#if VMA_EXTERNAL_MEMORY
    memset(&m_TypeExternalMemoryHandleTypes, 0, sizeof(m_TypeExternalMemoryHandleTypes));
#endif // #if VMA_EXTERNAL_MEMORY

    if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
    {
        m_DeviceMemoryCallbacks.pUserData = pCreateInfo->pDeviceMemoryCallbacks->pUserData;
        m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
        m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
    }

    ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);

    (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
    (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);

    VMA_ASSERT(VmaIsPow2(VMA_MIN_ALIGNMENT));
    VMA_ASSERT(VmaIsPow2(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY));
    VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.bufferImageGranularity));
    VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.nonCoherentAtomSize));

    m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
        pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);

    m_GlobalMemoryTypeBits = CalculateGlobalMemoryTypeBits();

#if VMA_EXTERNAL_MEMORY
    if(pCreateInfo->pTypeExternalMemoryHandleTypes != VMA_NULL)
    {
        memcpy(m_TypeExternalMemoryHandleTypes, pCreateInfo->pTypeExternalMemoryHandleTypes,
            sizeof(VkExternalMemoryHandleTypeFlagsKHR) * GetMemoryTypeCount());
    }
#endif // #if VMA_EXTERNAL_MEMORY

    if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
    {
        for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        {
            const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
            if(limit != VK_WHOLE_SIZE)
            {
                m_HeapSizeLimitMask |= 1u << heapIndex;
                if(limit < m_MemProps.memoryHeaps[heapIndex].size)
                {
                    m_MemProps.memoryHeaps[heapIndex].size = limit;
                }
            }
        }
    }

    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    {
        // Create only supported types
        if((m_GlobalMemoryTypeBits & (1u << memTypeIndex)) != 0)
        {
            const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
            m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
                this,
                VK_NULL_HANDLE, // hParentPool
                memTypeIndex,
                preferredBlockSize,
                0,
                SIZE_MAX,
                GetBufferImageGranularity(),
                false, // explicitBlockSize
                0, // algorithm
                0.5f, // priority (0.5 is the default per Vulkan spec)
                GetMemoryTypeMinAlignment(memTypeIndex), // minAllocationAlignment
                VMA_NULL); // // pMemoryAllocateNext
            // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
            // becase minBlockCount is 0.
        }
    }
}

VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
{
    VkResult res = VK_SUCCESS;

#if VMA_MEMORY_BUDGET
    if(m_UseExtMemoryBudget)
    {
        UpdateVulkanBudget();
    }
#endif // #if VMA_MEMORY_BUDGET

    return res;
}

VmaAllocator_T::~VmaAllocator_T()
{
    VMA_ASSERT(m_Pools.IsEmpty());

    for(size_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
    {
        vma_delete(this, m_pBlockVectors[memTypeIndex]);
    }
}

void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
{
#if VMA_STATIC_VULKAN_FUNCTIONS == 1
    ImportVulkanFunctions_Static();
#endif

    if(pVulkanFunctions != VMA_NULL)
    {
        ImportVulkanFunctions_Custom(pVulkanFunctions);
    }

#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
    ImportVulkanFunctions_Dynamic();
#endif

    ValidateVulkanFunctions();
}

#if VMA_STATIC_VULKAN_FUNCTIONS == 1

void VmaAllocator_T::ImportVulkanFunctions_Static()
{
    // Vulkan 1.0
    m_VulkanFunctions.vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)vkGetInstanceProcAddr;
    m_VulkanFunctions.vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)vkGetDeviceProcAddr;
    m_VulkanFunctions.vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)vkGetPhysicalDeviceProperties;
    m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vkGetPhysicalDeviceMemoryProperties;
    m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
    m_VulkanFunctions.vkFreeMemory = (PFN_vkFreeMemory)vkFreeMemory;
    m_VulkanFunctions.vkMapMemory = (PFN_vkMapMemory)vkMapMemory;
    m_VulkanFunctions.vkUnmapMemory = (PFN_vkUnmapMemory)vkUnmapMemory;
    m_VulkanFunctions.vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)vkFlushMappedMemoryRanges;
    m_VulkanFunctions.vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)vkInvalidateMappedMemoryRanges;
    m_VulkanFunctions.vkBindBufferMemory = (PFN_vkBindBufferMemory)vkBindBufferMemory;
    m_VulkanFunctions.vkBindImageMemory = (PFN_vkBindImageMemory)vkBindImageMemory;
    m_VulkanFunctions.vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)vkGetBufferMemoryRequirements;
    m_VulkanFunctions.vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vkGetImageMemoryRequirements;
    m_VulkanFunctions.vkCreateBuffer = (PFN_vkCreateBuffer)vkCreateBuffer;
    m_VulkanFunctions.vkDestroyBuffer = (PFN_vkDestroyBuffer)vkDestroyBuffer;
    m_VulkanFunctions.vkCreateImage = (PFN_vkCreateImage)vkCreateImage;
    m_VulkanFunctions.vkDestroyImage = (PFN_vkDestroyImage)vkDestroyImage;
    m_VulkanFunctions.vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)vkCmdCopyBuffer;

    // Vulkan 1.1
#if VMA_VULKAN_VERSION >= 1001000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
    {
        m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2)vkGetBufferMemoryRequirements2;
        m_VulkanFunctions.vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2)vkGetImageMemoryRequirements2;
        m_VulkanFunctions.vkBindBufferMemory2KHR = (PFN_vkBindBufferMemory2)vkBindBufferMemory2;
        m_VulkanFunctions.vkBindImageMemory2KHR = (PFN_vkBindImageMemory2)vkBindImageMemory2;
        m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2)vkGetPhysicalDeviceMemoryProperties2;
    }
#endif

#if VMA_VULKAN_VERSION >= 1003000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
    {
        m_VulkanFunctions.vkGetDeviceBufferMemoryRequirements = (PFN_vkGetDeviceBufferMemoryRequirements)vkGetDeviceBufferMemoryRequirements;
        m_VulkanFunctions.vkGetDeviceImageMemoryRequirements = (PFN_vkGetDeviceImageMemoryRequirements)vkGetDeviceImageMemoryRequirements;
    }
#endif
}

#endif // VMA_STATIC_VULKAN_FUNCTIONS == 1

void VmaAllocator_T::ImportVulkanFunctions_Custom(const VmaVulkanFunctions* pVulkanFunctions)
{
    VMA_ASSERT(pVulkanFunctions != VMA_NULL);

#define VMA_COPY_IF_NOT_NULL(funcName) \
    if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;

    VMA_COPY_IF_NOT_NULL(vkGetInstanceProcAddr);
    VMA_COPY_IF_NOT_NULL(vkGetDeviceProcAddr);
    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
    VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
    VMA_COPY_IF_NOT_NULL(vkFreeMemory);
    VMA_COPY_IF_NOT_NULL(vkMapMemory);
    VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
    VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
    VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
    VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
    VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
    VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
    VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
    VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
    VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
    VMA_COPY_IF_NOT_NULL(vkCreateImage);
    VMA_COPY_IF_NOT_NULL(vkDestroyImage);
    VMA_COPY_IF_NOT_NULL(vkCmdCopyBuffer);

#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
    VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
    VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
#endif

#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
    VMA_COPY_IF_NOT_NULL(vkBindBufferMemory2KHR);
    VMA_COPY_IF_NOT_NULL(vkBindImageMemory2KHR);
#endif

#if VMA_MEMORY_BUDGET
    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
#endif

#if VMA_VULKAN_VERSION >= 1003000
    VMA_COPY_IF_NOT_NULL(vkGetDeviceBufferMemoryRequirements);
    VMA_COPY_IF_NOT_NULL(vkGetDeviceImageMemoryRequirements);
#endif

#undef VMA_COPY_IF_NOT_NULL
}

#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1

void VmaAllocator_T::ImportVulkanFunctions_Dynamic()
{
    VMA_ASSERT(m_VulkanFunctions.vkGetInstanceProcAddr && m_VulkanFunctions.vkGetDeviceProcAddr &&
        "To use VMA_DYNAMIC_VULKAN_FUNCTIONS in new versions of VMA you now have to pass "
        "VmaVulkanFunctions::vkGetInstanceProcAddr and vkGetDeviceProcAddr as VmaAllocatorCreateInfo::pVulkanFunctions. "
        "Other members can be null.");

#define VMA_FETCH_INSTANCE_FUNC(memberName, functionPointerType, functionNameString) \
    if(m_VulkanFunctions.memberName == VMA_NULL) \
        m_VulkanFunctions.memberName = \
            (functionPointerType)m_VulkanFunctions.vkGetInstanceProcAddr(m_hInstance, functionNameString);
#define VMA_FETCH_DEVICE_FUNC(memberName, functionPointerType, functionNameString) \
    if(m_VulkanFunctions.memberName == VMA_NULL) \
        m_VulkanFunctions.memberName = \
            (functionPointerType)m_VulkanFunctions.vkGetDeviceProcAddr(m_hDevice, functionNameString);

    VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceProperties, PFN_vkGetPhysicalDeviceProperties, "vkGetPhysicalDeviceProperties");
    VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties, PFN_vkGetPhysicalDeviceMemoryProperties, "vkGetPhysicalDeviceMemoryProperties");
    VMA_FETCH_DEVICE_FUNC(vkAllocateMemory, PFN_vkAllocateMemory, "vkAllocateMemory");
    VMA_FETCH_DEVICE_FUNC(vkFreeMemory, PFN_vkFreeMemory, "vkFreeMemory");
    VMA_FETCH_DEVICE_FUNC(vkMapMemory, PFN_vkMapMemory, "vkMapMemory");
    VMA_FETCH_DEVICE_FUNC(vkUnmapMemory, PFN_vkUnmapMemory, "vkUnmapMemory");
    VMA_FETCH_DEVICE_FUNC(vkFlushMappedMemoryRanges, PFN_vkFlushMappedMemoryRanges, "vkFlushMappedMemoryRanges");
    VMA_FETCH_DEVICE_FUNC(vkInvalidateMappedMemoryRanges, PFN_vkInvalidateMappedMemoryRanges, "vkInvalidateMappedMemoryRanges");
    VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory, PFN_vkBindBufferMemory, "vkBindBufferMemory");
    VMA_FETCH_DEVICE_FUNC(vkBindImageMemory, PFN_vkBindImageMemory, "vkBindImageMemory");
    VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements, PFN_vkGetBufferMemoryRequirements, "vkGetBufferMemoryRequirements");
    VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements, PFN_vkGetImageMemoryRequirements, "vkGetImageMemoryRequirements");
    VMA_FETCH_DEVICE_FUNC(vkCreateBuffer, PFN_vkCreateBuffer, "vkCreateBuffer");
    VMA_FETCH_DEVICE_FUNC(vkDestroyBuffer, PFN_vkDestroyBuffer, "vkDestroyBuffer");
    VMA_FETCH_DEVICE_FUNC(vkCreateImage, PFN_vkCreateImage, "vkCreateImage");
    VMA_FETCH_DEVICE_FUNC(vkDestroyImage, PFN_vkDestroyImage, "vkDestroyImage");
    VMA_FETCH_DEVICE_FUNC(vkCmdCopyBuffer, PFN_vkCmdCopyBuffer, "vkCmdCopyBuffer");

#if VMA_VULKAN_VERSION >= 1001000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
    {
        VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements2KHR, PFN_vkGetBufferMemoryRequirements2, "vkGetBufferMemoryRequirements2");
        VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements2KHR, PFN_vkGetImageMemoryRequirements2, "vkGetImageMemoryRequirements2");
        VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory2KHR, PFN_vkBindBufferMemory2, "vkBindBufferMemory2");
        VMA_FETCH_DEVICE_FUNC(vkBindImageMemory2KHR, PFN_vkBindImageMemory2, "vkBindImageMemory2");
        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2");
    }
#endif

#if VMA_DEDICATED_ALLOCATION
    if(m_UseKhrDedicatedAllocation)
    {
        VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements2KHR, PFN_vkGetBufferMemoryRequirements2KHR, "vkGetBufferMemoryRequirements2KHR");
        VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements2KHR, PFN_vkGetImageMemoryRequirements2KHR, "vkGetImageMemoryRequirements2KHR");
    }
#endif

#if VMA_BIND_MEMORY2
    if(m_UseKhrBindMemory2)
    {
        VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory2KHR, PFN_vkBindBufferMemory2KHR, "vkBindBufferMemory2KHR");
        VMA_FETCH_DEVICE_FUNC(vkBindImageMemory2KHR, PFN_vkBindImageMemory2KHR, "vkBindImageMemory2KHR");
    }
#endif // #if VMA_BIND_MEMORY2

#if VMA_MEMORY_BUDGET
    if(m_UseExtMemoryBudget)
    {
        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2KHR, "vkGetPhysicalDeviceMemoryProperties2KHR");
    }
#endif // #if VMA_MEMORY_BUDGET

#if VMA_VULKAN_VERSION >= 1003000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
    {
        VMA_FETCH_DEVICE_FUNC(vkGetDeviceBufferMemoryRequirements, PFN_vkGetDeviceBufferMemoryRequirements, "vkGetDeviceBufferMemoryRequirements");
        VMA_FETCH_DEVICE_FUNC(vkGetDeviceImageMemoryRequirements, PFN_vkGetDeviceImageMemoryRequirements, "vkGetDeviceImageMemoryRequirements");
    }
#endif

#undef VMA_FETCH_DEVICE_FUNC
#undef VMA_FETCH_INSTANCE_FUNC
}

#endif // VMA_DYNAMIC_VULKAN_FUNCTIONS == 1

void VmaAllocator_T::ValidateVulkanFunctions()
{
    VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
    VMA_ASSERT(m_VulkanFunctions.vkCmdCopyBuffer != VMA_NULL);

#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0) || m_UseKhrDedicatedAllocation)
    {
        VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
        VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
    }
#endif

#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0) || m_UseKhrBindMemory2)
    {
        VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL);
        VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL);
    }
#endif

#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
    if(m_UseExtMemoryBudget || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
    {
        VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR != VMA_NULL);
    }
#endif

#if VMA_VULKAN_VERSION >= 1003000
    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
    {
        VMA_ASSERT(m_VulkanFunctions.vkGetDeviceBufferMemoryRequirements != VMA_NULL);
        VMA_ASSERT(m_VulkanFunctions.vkGetDeviceImageMemoryRequirements != VMA_NULL);
    }
#endif
}

VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
{
    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
    const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
    const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
    return VmaAlignUp(isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize, (VkDeviceSize)32);
}

VkResult VmaAllocator_T::AllocateMemoryOfType(
    VmaPool pool,
    VkDeviceSize size,
    VkDeviceSize alignment,
    bool dedicatedPreferred,
    VkBuffer dedicatedBuffer,
    VkImage dedicatedImage,
    VkFlags dedicatedBufferImageUsage,
    const VmaAllocationCreateInfo& createInfo,
    uint32_t memTypeIndex,
    VmaSuballocationType suballocType,
    VmaDedicatedAllocationList& dedicatedAllocations,
    VmaBlockVector& blockVector,
    size_t allocationCount,
    VmaAllocation* pAllocations)
{
    VMA_ASSERT(pAllocations != VMA_NULL);
    VMA_DEBUG_LOG("  AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%llu", memTypeIndex, allocationCount, size);

    VmaAllocationCreateInfo finalCreateInfo = createInfo;
    VkResult res = CalcMemTypeParams(
        finalCreateInfo,
        memTypeIndex,
        size,
        allocationCount);
    if(res != VK_SUCCESS)
        return res;

    if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
    {
        return AllocateDedicatedMemory(
            pool,
            size,
            suballocType,
            dedicatedAllocations,
            memTypeIndex,
            (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
            (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
            (finalCreateInfo.flags &
                (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0,
            (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT) != 0,
            finalCreateInfo.pUserData,
            finalCreateInfo.priority,
            dedicatedBuffer,
            dedicatedImage,
            dedicatedBufferImageUsage,
            allocationCount,
            pAllocations,
            blockVector.GetAllocationNextPtr());
    }
    else
    {
        const bool canAllocateDedicated =
            (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
            (pool == VK_NULL_HANDLE || !blockVector.HasExplicitBlockSize());

        if(canAllocateDedicated)
        {
            // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
            if(size > blockVector.GetPreferredBlockSize() / 2)
            {
                dedicatedPreferred = true;
            }
            // Protection against creating each allocation as dedicated when we reach or exceed heap size/budget,
            // which can quickly deplete maxMemoryAllocationCount: Don't prefer dedicated allocations when above
            // 3/4 of the maximum allocation count.
            if(m_DeviceMemoryCount.load() > m_PhysicalDeviceProperties.limits.maxMemoryAllocationCount * 3 / 4)
            {
                dedicatedPreferred = false;
            }

            if(dedicatedPreferred)
            {
                res = AllocateDedicatedMemory(
                    pool,
                    size,
                    suballocType,
                    dedicatedAllocations,
                    memTypeIndex,
                    (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
                    (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
                    (finalCreateInfo.flags &
                        (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0,
                    (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT) != 0,
                    finalCreateInfo.pUserData,
                    finalCreateInfo.priority,
                    dedicatedBuffer,
                    dedicatedImage,
                    dedicatedBufferImageUsage,
                    allocationCount,
                    pAllocations,
                    blockVector.GetAllocationNextPtr());
                if(res == VK_SUCCESS)
                {
                    // Succeeded: AllocateDedicatedMemory function already filled pMemory, nothing more to do here.
                    VMA_DEBUG_LOG("    Allocated as DedicatedMemory");
                    return VK_SUCCESS;
                }
            }
        }

        res = blockVector.Allocate(
            size,
            alignment,
            finalCreateInfo,
            suballocType,
            allocationCount,
            pAllocations);
        if(res == VK_SUCCESS)
            return VK_SUCCESS;

        // Try dedicated memory.
        if(canAllocateDedicated && !dedicatedPreferred)
        {
            res = AllocateDedicatedMemory(
                pool,
                size,
                suballocType,
                dedicatedAllocations,
                memTypeIndex,
                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
                (finalCreateInfo.flags &
                    (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0,
                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT) != 0,
                finalCreateInfo.pUserData,
                finalCreateInfo.priority,
                dedicatedBuffer,
                dedicatedImage,
                dedicatedBufferImageUsage,
                allocationCount,
                pAllocations,
                blockVector.GetAllocationNextPtr());
            if(res == VK_SUCCESS)
            {
                // Succeeded: AllocateDedicatedMemory function already filled pMemory, nothing more to do here.
                VMA_DEBUG_LOG("    Allocated as DedicatedMemory");
                return VK_SUCCESS;
            }
        }
        // Everything failed: Return error code.
        VMA_DEBUG_LOG("    vkAllocateMemory FAILED");
        return res;
    }
}

VkResult VmaAllocator_T::AllocateDedicatedMemory(
    VmaPool pool,
    VkDeviceSize size,
    VmaSuballocationType suballocType,
    VmaDedicatedAllocationList& dedicatedAllocations,
    uint32_t memTypeIndex,
    bool map,
    bool isUserDataString,
    bool isMappingAllowed,
    bool canAliasMemory,
    void* pUserData,
    float priority,
    VkBuffer dedicatedBuffer,
    VkImage dedicatedImage,
    VkFlags dedicatedBufferImageUsage,
    size_t allocationCount,
    VmaAllocation* pAllocations,
    const void* pNextChain)
{
    VMA_ASSERT(allocationCount > 0 && pAllocations);

    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
    allocInfo.memoryTypeIndex = memTypeIndex;
    allocInfo.allocationSize = size;
    allocInfo.pNext = pNextChain;

#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
    VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
    if(!canAliasMemory)
    {
        if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
        {
            if(dedicatedBuffer != VK_NULL_HANDLE)
            {
                VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
                dedicatedAllocInfo.buffer = dedicatedBuffer;
                VmaPnextChainPushFront(&allocInfo, &dedicatedAllocInfo);
            }
            else if(dedicatedImage != VK_NULL_HANDLE)
            {
                dedicatedAllocInfo.image = dedicatedImage;
                VmaPnextChainPushFront(&allocInfo, &dedicatedAllocInfo);
            }
        }
    }
#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000

#if VMA_BUFFER_DEVICE_ADDRESS
    VkMemoryAllocateFlagsInfoKHR allocFlagsInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR };
    if(m_UseKhrBufferDeviceAddress)
    {
        bool canContainBufferWithDeviceAddress = true;
        if(dedicatedBuffer != VK_NULL_HANDLE)
        {
            canContainBufferWithDeviceAddress = dedicatedBufferImageUsage == UINT32_MAX || // Usage flags unknown
                (dedicatedBufferImageUsage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT) != 0;
        }
        else if(dedicatedImage != VK_NULL_HANDLE)
        {
            canContainBufferWithDeviceAddress = false;
        }
        if(canContainBufferWithDeviceAddress)
        {
            allocFlagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
            VmaPnextChainPushFront(&allocInfo, &allocFlagsInfo);
        }
    }
#endif // #if VMA_BUFFER_DEVICE_ADDRESS

#if VMA_MEMORY_PRIORITY
    VkMemoryPriorityAllocateInfoEXT priorityInfo = { VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT };
    if(m_UseExtMemoryPriority)
    {
        VMA_ASSERT(priority >= 0.f && priority <= 1.f);
        priorityInfo.priority = priority;
        VmaPnextChainPushFront(&allocInfo, &priorityInfo);
    }
#endif // #if VMA_MEMORY_PRIORITY

#if VMA_EXTERNAL_MEMORY
    // Attach VkExportMemoryAllocateInfoKHR if necessary.
    VkExportMemoryAllocateInfoKHR exportMemoryAllocInfo = { VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR };
    exportMemoryAllocInfo.handleTypes = GetExternalMemoryHandleTypeFlags(memTypeIndex);
    if(exportMemoryAllocInfo.handleTypes != 0)
    {
        VmaPnextChainPushFront(&allocInfo, &exportMemoryAllocInfo);
    }
#endif // #if VMA_EXTERNAL_MEMORY

    size_t allocIndex;
    VkResult res = VK_SUCCESS;
    for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
    {
        res = AllocateDedicatedMemoryPage(
            pool,
            size,
            suballocType,
            memTypeIndex,
            allocInfo,
            map,
            isUserDataString,
            isMappingAllowed,
            pUserData,
            pAllocations + allocIndex);
        if(res != VK_SUCCESS)
        {
            break;
        }
    }

    if(res == VK_SUCCESS)
    {
        for (allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        {
            dedicatedAllocations.Register(pAllocations[allocIndex]);
        }
        VMA_DEBUG_LOG("    Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
    }
    else
    {
        // Free all already created allocations.
        while(allocIndex--)
        {
            VmaAllocation currAlloc = pAllocations[allocIndex];
            VkDeviceMemory hMemory = currAlloc->GetMemory();

            /*
            There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
            before vkFreeMemory.

            if(currAlloc->GetMappedData() != VMA_NULL)
            {
                (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
            }
            */

            FreeVulkanMemory(memTypeIndex, currAlloc->GetSize(), hMemory);
            m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), currAlloc->GetSize());
            m_AllocationObjectAllocator.Free(currAlloc);
        }

        memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
    }

    return res;
}

VkResult VmaAllocator_T::AllocateDedicatedMemoryPage(
    VmaPool pool,
    VkDeviceSize size,
    VmaSuballocationType suballocType,
    uint32_t memTypeIndex,
    const VkMemoryAllocateInfo& allocInfo,
    bool map,
    bool isUserDataString,
    bool isMappingAllowed,
    void* pUserData,
    VmaAllocation* pAllocation)
{
    VkDeviceMemory hMemory = VK_NULL_HANDLE;
    VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
    if(res < 0)
    {
        VMA_DEBUG_LOG("    vkAllocateMemory FAILED");
        return res;
    }

    void* pMappedData = VMA_NULL;
    if(map)
    {
        res = (*m_VulkanFunctions.vkMapMemory)(
            m_hDevice,
            hMemory,
            0,
            VK_WHOLE_SIZE,
            0,
            &pMappedData);
        if(res < 0)
        {
            VMA_DEBUG_LOG("    vkMapMemory FAILED");
            FreeVulkanMemory(memTypeIndex, size, hMemory);
            return res;
        }
    }

    *pAllocation = m_AllocationObjectAllocator.Allocate(isMappingAllowed);
    (*pAllocation)->InitDedicatedAllocation(pool, memTypeIndex, hMemory, suballocType, pMappedData, size);
    if (isUserDataString)
        (*pAllocation)->SetName(this, (const char*)pUserData);
    else
        (*pAllocation)->SetUserData(this, pUserData);
    m_Budget.AddAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), size);
    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
    {
        FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
    }

    return VK_SUCCESS;
}

void VmaAllocator_T::GetBufferMemoryRequirements(
    VkBuffer hBuffer,
    VkMemoryRequirements& memReq,
    bool& requiresDedicatedAllocation,
    bool& prefersDedicatedAllocation) const
{
#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
    if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
    {
        VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
        memReqInfo.buffer = hBuffer;

        VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };

        VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        VmaPnextChainPushFront(&memReq2, &memDedicatedReq);

        (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);

        memReq = memReq2.memoryRequirements;
        requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        prefersDedicatedAllocation  = (memDedicatedReq.prefersDedicatedAllocation  != VK_FALSE);
    }
    else
#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
    {
        (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
        requiresDedicatedAllocation = false;
        prefersDedicatedAllocation  = false;
    }
}

void VmaAllocator_T::GetImageMemoryRequirements(
    VkImage hImage,
    VkMemoryRequirements& memReq,
    bool& requiresDedicatedAllocation,
    bool& prefersDedicatedAllocation) const
{
#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
    if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
    {
        VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
        memReqInfo.image = hImage;

        VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };

        VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        VmaPnextChainPushFront(&memReq2, &memDedicatedReq);

        (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);

        memReq = memReq2.memoryRequirements;
        requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        prefersDedicatedAllocation  = (memDedicatedReq.prefersDedicatedAllocation  != VK_FALSE);
    }
    else
#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
    {
        (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
        requiresDedicatedAllocation = false;
        prefersDedicatedAllocation  = false;
    }
}

VkResult VmaAllocator_T::FindMemoryTypeIndex(
    uint32_t memoryTypeBits,
    const VmaAllocationCreateInfo* pAllocationCreateInfo,
    VkFlags bufImgUsage,
    uint32_t* pMemoryTypeIndex) const
{
    memoryTypeBits &= GetGlobalMemoryTypeBits();

    if(pAllocationCreateInfo->memoryTypeBits != 0)
    {
        memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
    }

    VkMemoryPropertyFlags requiredFlags = 0, preferredFlags = 0, notPreferredFlags = 0;
    if(!FindMemoryPreferences(
        IsIntegratedGpu(),
        *pAllocationCreateInfo,
        bufImgUsage,
        requiredFlags, preferredFlags, notPreferredFlags))
    {
        return VK_ERROR_FEATURE_NOT_PRESENT;
    }

    *pMemoryTypeIndex = UINT32_MAX;
    uint32_t minCost = UINT32_MAX;
    for(uint32_t memTypeIndex = 0, memTypeBit = 1;
        memTypeIndex < GetMemoryTypeCount();
        ++memTypeIndex, memTypeBit <<= 1)
    {
        // This memory type is acceptable according to memoryTypeBits bitmask.
        if((memTypeBit & memoryTypeBits) != 0)
        {
            const VkMemoryPropertyFlags currFlags =
                m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
            // This memory type contains requiredFlags.
            if((requiredFlags & ~currFlags) == 0)
            {
                // Calculate cost as number of bits from preferredFlags not present in this memory type.
                uint32_t currCost = VMA_COUNT_BITS_SET(preferredFlags & ~currFlags) +
                    VMA_COUNT_BITS_SET(currFlags & notPreferredFlags);
                // Remember memory type with lowest cost.
                if(currCost < minCost)
                {
                    *pMemoryTypeIndex = memTypeIndex;
                    if(currCost == 0)
                    {
                        return VK_SUCCESS;
                    }
                    minCost = currCost;
                }
            }
        }
    }
    return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
}

VkResult VmaAllocator_T::CalcMemTypeParams(
    VmaAllocationCreateInfo& inoutCreateInfo,
    uint32_t memTypeIndex,
    VkDeviceSize size,
    size_t allocationCount)
{
    // If memory type is not HOST_VISIBLE, disable MAPPED.
    if((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
    {
        inoutCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
    }

    if((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
        (inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0)
    {
        const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        VmaBudget heapBudget = {};
        GetHeapBudgets(&heapBudget, heapIndex, 1);
        if(heapBudget.usage + size * allocationCount > heapBudget.budget)
        {
            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        }
    }
    return VK_SUCCESS;
}

VkResult VmaAllocator_T::CalcAllocationParams(
    VmaAllocationCreateInfo& inoutCreateInfo,
    bool dedicatedRequired,
    bool dedicatedPreferred)
{
    VMA_ASSERT((inoutCreateInfo.flags &
        (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) !=
        (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT) &&
        "Specifying both flags VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT and VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT is incorrect.");
    VMA_ASSERT((((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT) == 0 ||
        (inoutCreateInfo.flags & (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0)) &&
        "Specifying VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT requires also VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.");
    if(inoutCreateInfo.usage == VMA_MEMORY_USAGE_AUTO || inoutCreateInfo.usage == VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE || inoutCreateInfo.usage == VMA_MEMORY_USAGE_AUTO_PREFER_HOST)
    {
        if((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0)
        {
            VMA_ASSERT((inoutCreateInfo.flags & (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0 &&
                "When using VMA_ALLOCATION_CREATE_MAPPED_BIT and usage = VMA_MEMORY_USAGE_AUTO*, you must also specify VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.");
        }
    }

    // If memory is lazily allocated, it should be always dedicated.
    if(dedicatedRequired ||
        inoutCreateInfo.usage == VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED)
    {
        inoutCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
    }

    if(inoutCreateInfo.pool != VK_NULL_HANDLE)
    {
        if(inoutCreateInfo.pool->m_BlockVector.HasExplicitBlockSize() &&
            (inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
        {
            VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT while current custom pool doesn't support dedicated allocations.");
            return VK_ERROR_FEATURE_NOT_PRESENT;
        }
        inoutCreateInfo.priority = inoutCreateInfo.pool->m_BlockVector.GetPriority();
    }

    if((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
        (inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    {
        VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
        return VK_ERROR_FEATURE_NOT_PRESENT;
    }

    if(VMA_DEBUG_ALWAYS_DEDICATED_MEMORY &&
        (inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    {
        inoutCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
    }

    // Non-auto USAGE values imply HOST_ACCESS flags.
    // And so does VMA_MEMORY_USAGE_UNKNOWN because it is used with custom pools.
    // Which specific flag is used doesn't matter. They change things only when used with VMA_MEMORY_USAGE_AUTO*.
    // Otherwise they just protect from assert on mapping.
    if(inoutCreateInfo.usage != VMA_MEMORY_USAGE_AUTO &&
        inoutCreateInfo.usage != VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE &&
        inoutCreateInfo.usage != VMA_MEMORY_USAGE_AUTO_PREFER_HOST)
    {
        if((inoutCreateInfo.flags & (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) == 0)
        {
            inoutCreateInfo.flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;
        }
    }

    return VK_SUCCESS;
}

VkResult VmaAllocator_T::AllocateMemory(
    const VkMemoryRequirements& vkMemReq,
    bool requiresDedicatedAllocation,
    bool prefersDedicatedAllocation,
    VkBuffer dedicatedBuffer,
    VkImage dedicatedImage,
    VkFlags dedicatedBufferImageUsage,
    const VmaAllocationCreateInfo& createInfo,
    VmaSuballocationType suballocType,
    size_t allocationCount,
    VmaAllocation* pAllocations)
{
    memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);

    VMA_ASSERT(VmaIsPow2(vkMemReq.alignment));

    if(vkMemReq.size == 0)
    {
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    VmaAllocationCreateInfo createInfoFinal = createInfo;
    VkResult res = CalcAllocationParams(createInfoFinal, requiresDedicatedAllocation, prefersDedicatedAllocation);
    if(res != VK_SUCCESS)
        return res;

    if(createInfoFinal.pool != VK_NULL_HANDLE)
    {
        VmaBlockVector& blockVector = createInfoFinal.pool->m_BlockVector;
        return AllocateMemoryOfType(
            createInfoFinal.pool,
            vkMemReq.size,
            vkMemReq.alignment,
            prefersDedicatedAllocation,
            dedicatedBuffer,
            dedicatedImage,
            dedicatedBufferImageUsage,
            createInfoFinal,
            blockVector.GetMemoryTypeIndex(),
            suballocType,
            createInfoFinal.pool->m_DedicatedAllocations,
            blockVector,
            allocationCount,
            pAllocations);
    }
    else
    {
        // Bit mask of memory Vulkan types acceptable for this allocation.
        uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
        uint32_t memTypeIndex = UINT32_MAX;
        res = FindMemoryTypeIndex(memoryTypeBits, &createInfoFinal, dedicatedBufferImageUsage, &memTypeIndex);
        // Can't find any single memory type matching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
        if(res != VK_SUCCESS)
            return res;
        do
        {
            VmaBlockVector* blockVector = m_pBlockVectors[memTypeIndex];
            VMA_ASSERT(blockVector && "Trying to use unsupported memory type!");
            res = AllocateMemoryOfType(
                VK_NULL_HANDLE,
                vkMemReq.size,
                vkMemReq.alignment,
                requiresDedicatedAllocation || prefersDedicatedAllocation,
                dedicatedBuffer,
                dedicatedImage,
                dedicatedBufferImageUsage,
                createInfoFinal,
                memTypeIndex,
                suballocType,
                m_DedicatedAllocations[memTypeIndex],
                *blockVector,
                allocationCount,
                pAllocations);
            // Allocation succeeded
            if(res == VK_SUCCESS)
                return VK_SUCCESS;

            // Remove old memTypeIndex from list of possibilities.
            memoryTypeBits &= ~(1u << memTypeIndex);
            // Find alternative memTypeIndex.
            res = FindMemoryTypeIndex(memoryTypeBits, &createInfoFinal, dedicatedBufferImageUsage, &memTypeIndex);
        } while(res == VK_SUCCESS);

        // No other matching memory type index could be found.
        // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    }
}

void VmaAllocator_T::FreeMemory(
    size_t allocationCount,
    const VmaAllocation* pAllocations)
{
    VMA_ASSERT(pAllocations);

    for(size_t allocIndex = allocationCount; allocIndex--; )
    {
        VmaAllocation allocation = pAllocations[allocIndex];

        if(allocation != VK_NULL_HANDLE)
        {
            if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
            {
                FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
            }

            allocation->FreeName(this);

            switch(allocation->GetType())
            {
            case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
                {
                    VmaBlockVector* pBlockVector = VMA_NULL;
                    VmaPool hPool = allocation->GetParentPool();
                    if(hPool != VK_NULL_HANDLE)
                    {
                        pBlockVector = &hPool->m_BlockVector;
                    }
                    else
                    {
                        const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
                        pBlockVector = m_pBlockVectors[memTypeIndex];
                        VMA_ASSERT(pBlockVector && "Trying to free memory of unsupported type!");
                    }
                    pBlockVector->Free(allocation);
                }
                break;
            case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
                FreeDedicatedMemory(allocation);
                break;
            default:
                VMA_ASSERT(0);
            }
        }
    }
}

void VmaAllocator_T::CalculateStatistics(VmaTotalStatistics* pStats)
{
    // Initialize.
    VmaClearDetailedStatistics(pStats->total);
    for(uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
        VmaClearDetailedStatistics(pStats->memoryType[i]);
    for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        VmaClearDetailedStatistics(pStats->memoryHeap[i]);

    // Process default pools.
    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    {
        VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        if (pBlockVector != VMA_NULL)
            pBlockVector->AddDetailedStatistics(pStats->memoryType[memTypeIndex]);
    }

    // Process custom pools.
    {
        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        for(VmaPool pool = m_Pools.Front(); pool != VMA_NULL; pool = m_Pools.GetNext(pool))
        {
            VmaBlockVector& blockVector = pool->m_BlockVector;
            const uint32_t memTypeIndex = blockVector.GetMemoryTypeIndex();
            blockVector.AddDetailedStatistics(pStats->memoryType[memTypeIndex]);
            pool->m_DedicatedAllocations.AddDetailedStatistics(pStats->memoryType[memTypeIndex]);
        }
    }

    // Process dedicated allocations.
    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    {
        m_DedicatedAllocations[memTypeIndex].AddDetailedStatistics(pStats->memoryType[memTypeIndex]);
    }

    // Sum from memory types to memory heaps.
    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    {
        const uint32_t memHeapIndex = m_MemProps.memoryTypes[memTypeIndex].heapIndex;
        VmaAddDetailedStatistics(pStats->memoryHeap[memHeapIndex], pStats->memoryType[memTypeIndex]);
    }

    // Sum from memory heaps to total.
    for(uint32_t memHeapIndex = 0; memHeapIndex < GetMemoryHeapCount(); ++memHeapIndex)
        VmaAddDetailedStatistics(pStats->total, pStats->memoryHeap[memHeapIndex]);

    VMA_ASSERT(pStats->total.statistics.allocationCount == 0 ||
        pStats->total.allocationSizeMax >= pStats->total.allocationSizeMin);
    VMA_ASSERT(pStats->total.unusedRangeCount == 0 ||
        pStats->total.unusedRangeSizeMax >= pStats->total.unusedRangeSizeMin);
}

void VmaAllocator_T::GetHeapBudgets(VmaBudget* outBudgets, uint32_t firstHeap, uint32_t heapCount)
{
#if VMA_MEMORY_BUDGET
    if(m_UseExtMemoryBudget)
    {
        if(m_Budget.m_OperationsSinceBudgetFetch < 30)
        {
            VmaMutexLockRead lockRead(m_Budget.m_BudgetMutex, m_UseMutex);
            for(uint32_t i = 0; i < heapCount; ++i, ++outBudgets)
            {
                const uint32_t heapIndex = firstHeap + i;

                outBudgets->statistics.blockCount = m_Budget.m_BlockCount[heapIndex];
                outBudgets->statistics.allocationCount = m_Budget.m_AllocationCount[heapIndex];
                outBudgets->statistics.blockBytes = m_Budget.m_BlockBytes[heapIndex];
                outBudgets->statistics.allocationBytes = m_Budget.m_AllocationBytes[heapIndex];

                if(m_Budget.m_VulkanUsage[heapIndex] + outBudgets->statistics.blockBytes > m_Budget.m_BlockBytesAtBudgetFetch[heapIndex])
                {
                    outBudgets->usage = m_Budget.m_VulkanUsage[heapIndex] +
                        outBudgets->statistics.blockBytes - m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
                }
                else
                {
                    outBudgets->usage = 0;
                }

                // Have to take MIN with heap size because explicit HeapSizeLimit is included in it.
                outBudgets->budget = VMA_MIN(
                    m_Budget.m_VulkanBudget[heapIndex], m_MemProps.memoryHeaps[heapIndex].size);
            }
        }
        else
        {
            UpdateVulkanBudget(); // Outside of mutex lock
            GetHeapBudgets(outBudgets, firstHeap, heapCount); // Recursion
        }
    }
    else
#endif
    {
        for(uint32_t i = 0; i < heapCount; ++i, ++outBudgets)
        {
            const uint32_t heapIndex = firstHeap + i;

            outBudgets->statistics.blockCount = m_Budget.m_BlockCount[heapIndex];
            outBudgets->statistics.allocationCount = m_Budget.m_AllocationCount[heapIndex];
            outBudgets->statistics.blockBytes = m_Budget.m_BlockBytes[heapIndex];
            outBudgets->statistics.allocationBytes = m_Budget.m_AllocationBytes[heapIndex];

            outBudgets->usage = outBudgets->statistics.blockBytes;
            outBudgets->budget = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
        }
    }
}

void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
{
    pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
    pAllocationInfo->deviceMemory = hAllocation->GetMemory();
    pAllocationInfo->offset = hAllocation->GetOffset();
    pAllocationInfo->size = hAllocation->GetSize();
    pAllocationInfo->pMappedData = hAllocation->GetMappedData();
    pAllocationInfo->pUserData = hAllocation->GetUserData();
    pAllocationInfo->pName = hAllocation->GetName();
}

VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
{
    VMA_DEBUG_LOG("  CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);

    VmaPoolCreateInfo newCreateInfo = *pCreateInfo;

    // Protection against uninitialized new structure member. If garbage data are left there, this pointer dereference would crash.
    if(pCreateInfo->pMemoryAllocateNext)
    {
        VMA_ASSERT(((const VkBaseInStructure*)pCreateInfo->pMemoryAllocateNext)->sType != 0);
    }

    if(newCreateInfo.maxBlockCount == 0)
    {
        newCreateInfo.maxBlockCount = SIZE_MAX;
    }
    if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount)
    {
        return VK_ERROR_INITIALIZATION_FAILED;
    }
    // Memory type index out of range or forbidden.
    if(pCreateInfo->memoryTypeIndex >= GetMemoryTypeCount() ||
        ((1u << pCreateInfo->memoryTypeIndex) & m_GlobalMemoryTypeBits) == 0)
    {
        return VK_ERROR_FEATURE_NOT_PRESENT;
    }
    if(newCreateInfo.minAllocationAlignment > 0)
    {
        VMA_ASSERT(VmaIsPow2(newCreateInfo.minAllocationAlignment));
    }

    const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);

    *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo, preferredBlockSize);

    VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
    if(res != VK_SUCCESS)
    {
        vma_delete(this, *pPool);
        *pPool = VMA_NULL;
        return res;
    }

    // Add to m_Pools.
    {
        VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
        (*pPool)->SetId(m_NextPoolId++);
        m_Pools.PushBack(*pPool);
    }

    return VK_SUCCESS;
}

void VmaAllocator_T::DestroyPool(VmaPool pool)
{
    // Remove from m_Pools.
    {
        VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
        m_Pools.Remove(pool);
    }

    vma_delete(this, pool);
}

void VmaAllocator_T::GetPoolStatistics(VmaPool pool, VmaStatistics* pPoolStats)
{
    VmaClearStatistics(*pPoolStats);
    pool->m_BlockVector.AddStatistics(*pPoolStats);
    pool->m_DedicatedAllocations.AddStatistics(*pPoolStats);
}

void VmaAllocator_T::CalculatePoolStatistics(VmaPool pool, VmaDetailedStatistics* pPoolStats)
{
    VmaClearDetailedStatistics(*pPoolStats);
    pool->m_BlockVector.AddDetailedStatistics(*pPoolStats);
    pool->m_DedicatedAllocations.AddDetailedStatistics(*pPoolStats);
}

void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
{
    m_CurrentFrameIndex.store(frameIndex);

#if VMA_MEMORY_BUDGET
    if(m_UseExtMemoryBudget)
    {
        UpdateVulkanBudget();
    }
#endif // #if VMA_MEMORY_BUDGET
}

VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
{
    return hPool->m_BlockVector.CheckCorruption();
}

VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
{
    VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;

    // Process default pools.
    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    {
        VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        if(pBlockVector != VMA_NULL)
        {
            VkResult localRes = pBlockVector->CheckCorruption();
            switch(localRes)
            {
            case VK_ERROR_FEATURE_NOT_PRESENT:
                break;
            case VK_SUCCESS:
                finalRes = VK_SUCCESS;
                break;
            default:
                return localRes;
            }
        }
    }

    // Process custom pools.
    {
        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        for(VmaPool pool = m_Pools.Front(); pool != VMA_NULL; pool = m_Pools.GetNext(pool))
        {
            if(((1u << pool->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
            {
                VkResult localRes = pool->m_BlockVector.CheckCorruption();
                switch(localRes)
                {
                case VK_ERROR_FEATURE_NOT_PRESENT:
                    break;
                case VK_SUCCESS:
                    finalRes = VK_SUCCESS;
                    break;
                default:
                    return localRes;
                }
            }
        }
    }

    return finalRes;
}

VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
{
    AtomicTransactionalIncrement<uint32_t> deviceMemoryCountIncrement;
    const uint64_t prevDeviceMemoryCount = deviceMemoryCountIncrement.Increment(&m_DeviceMemoryCount);
#if VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT
    if(prevDeviceMemoryCount >= m_PhysicalDeviceProperties.limits.maxMemoryAllocationCount)
    {
        return VK_ERROR_TOO_MANY_OBJECTS;
    }
#endif

    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);

    // HeapSizeLimit is in effect for this heap.
    if((m_HeapSizeLimitMask & (1u << heapIndex)) != 0)
    {
        const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        VkDeviceSize blockBytes = m_Budget.m_BlockBytes[heapIndex];
        for(;;)
        {
            const VkDeviceSize blockBytesAfterAllocation = blockBytes + pAllocateInfo->allocationSize;
            if(blockBytesAfterAllocation > heapSize)
            {
                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
            }
            if(m_Budget.m_BlockBytes[heapIndex].compare_exchange_strong(blockBytes, blockBytesAfterAllocation))
            {
                break;
            }
        }
    }
    else
    {
        m_Budget.m_BlockBytes[heapIndex] += pAllocateInfo->allocationSize;
    }
    ++m_Budget.m_BlockCount[heapIndex];

    // VULKAN CALL vkAllocateMemory.
    VkResult res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);

    if(res == VK_SUCCESS)
    {
#if VMA_MEMORY_BUDGET
        ++m_Budget.m_OperationsSinceBudgetFetch;
#endif

        // Informative callback.
        if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
        {
            (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize, m_DeviceMemoryCallbacks.pUserData);
        }

        deviceMemoryCountIncrement.Commit();
    }
    else
    {
        --m_Budget.m_BlockCount[heapIndex];
        m_Budget.m_BlockBytes[heapIndex] -= pAllocateInfo->allocationSize;
    }

    return res;
}

void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
{
    // Informative callback.
    if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
    {
        (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size, m_DeviceMemoryCallbacks.pUserData);
    }

    // VULKAN CALL vkFreeMemory.
    (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());

    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
    --m_Budget.m_BlockCount[heapIndex];
    m_Budget.m_BlockBytes[heapIndex] -= size;

    --m_DeviceMemoryCount;
}

VkResult VmaAllocator_T::BindVulkanBuffer(
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset,
    VkBuffer buffer,
    const void* pNext)
{
    if(pNext != VMA_NULL)
    {
#if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
        if((m_UseKhrBindMemory2 || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)) &&
            m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL)
        {
            VkBindBufferMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR };
            bindBufferMemoryInfo.pNext = pNext;
            bindBufferMemoryInfo.buffer = buffer;
            bindBufferMemoryInfo.memory = memory;
            bindBufferMemoryInfo.memoryOffset = memoryOffset;
            return (*m_VulkanFunctions.vkBindBufferMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
        }
        else
#endif // #if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
        {
            return VK_ERROR_EXTENSION_NOT_PRESENT;
        }
    }
    else
    {
        return (*m_VulkanFunctions.vkBindBufferMemory)(m_hDevice, buffer, memory, memoryOffset);
    }
}

VkResult VmaAllocator_T::BindVulkanImage(
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset,
    VkImage image,
    const void* pNext)
{
    if(pNext != VMA_NULL)
    {
#if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
        if((m_UseKhrBindMemory2 || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)) &&
            m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL)
        {
            VkBindImageMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR };
            bindBufferMemoryInfo.pNext = pNext;
            bindBufferMemoryInfo.image = image;
            bindBufferMemoryInfo.memory = memory;
            bindBufferMemoryInfo.memoryOffset = memoryOffset;
            return (*m_VulkanFunctions.vkBindImageMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
        }
        else
#endif // #if VMA_BIND_MEMORY2
        {
            return VK_ERROR_EXTENSION_NOT_PRESENT;
        }
    }
    else
    {
        return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
    }
}

VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
{
    switch(hAllocation->GetType())
    {
    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        {
            VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
            char *pBytes = VMA_NULL;
            VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
            if(res == VK_SUCCESS)
            {
                *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
                hAllocation->BlockAllocMap();
            }
            return res;
        }
    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        return hAllocation->DedicatedAllocMap(this, ppData);
    default:
        VMA_ASSERT(0);
        return VK_ERROR_MEMORY_MAP_FAILED;
    }
}

void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
{
    switch(hAllocation->GetType())
    {
    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        {
            VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
            hAllocation->BlockAllocUnmap();
            pBlock->Unmap(this, 1);
        }
        break;
    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        hAllocation->DedicatedAllocUnmap(this);
        break;
    default:
        VMA_ASSERT(0);
    }
}

VkResult VmaAllocator_T::BindBufferMemory(
    VmaAllocation hAllocation,
    VkDeviceSize allocationLocalOffset,
    VkBuffer hBuffer,
    const void* pNext)
{
    VkResult res = VK_ERROR_UNKNOWN;
    switch(hAllocation->GetType())
    {
    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        res = BindVulkanBuffer(hAllocation->GetMemory(), allocationLocalOffset, hBuffer, pNext);
        break;
    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
    {
        VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block.");
        res = pBlock->BindBufferMemory(this, hAllocation, allocationLocalOffset, hBuffer, pNext);
        break;
    }
    default:
        VMA_ASSERT(0);
    }
    return res;
}

VkResult VmaAllocator_T::BindImageMemory(
    VmaAllocation hAllocation,
    VkDeviceSize allocationLocalOffset,
    VkImage hImage,
    const void* pNext)
{
    VkResult res = VK_ERROR_UNKNOWN;
    switch(hAllocation->GetType())
    {
    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        res = BindVulkanImage(hAllocation->GetMemory(), allocationLocalOffset, hImage, pNext);
        break;
    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
    {
        VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block.");
        res = pBlock->BindImageMemory(this, hAllocation, allocationLocalOffset, hImage, pNext);
        break;
    }
    default:
        VMA_ASSERT(0);
    }
    return res;
}

VkResult VmaAllocator_T::FlushOrInvalidateAllocation(
    VmaAllocation hAllocation,
    VkDeviceSize offset, VkDeviceSize size,
    VMA_CACHE_OPERATION op)
{
    VkResult res = VK_SUCCESS;

    VkMappedMemoryRange memRange = {};
    if(GetFlushOrInvalidateRange(hAllocation, offset, size, memRange))
    {
        switch(op)
        {
        case VMA_CACHE_FLUSH:
            res = (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
            break;
        case VMA_CACHE_INVALIDATE:
            res = (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
            break;
        default:
            VMA_ASSERT(0);
        }
    }
    // else: Just ignore this call.
    return res;
}

VkResult VmaAllocator_T::FlushOrInvalidateAllocations(
    uint32_t allocationCount,
    const VmaAllocation* allocations,
    const VkDeviceSize* offsets, const VkDeviceSize* sizes,
    VMA_CACHE_OPERATION op)
{
    typedef VmaStlAllocator<VkMappedMemoryRange> RangeAllocator;
    typedef VmaSmallVector<VkMappedMemoryRange, RangeAllocator, 16> RangeVector;
    RangeVector ranges = RangeVector(RangeAllocator(GetAllocationCallbacks()));

    for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
    {
        const VmaAllocation alloc = allocations[allocIndex];
        const VkDeviceSize offset = offsets != VMA_NULL ? offsets[allocIndex] : 0;
        const VkDeviceSize size = sizes != VMA_NULL ? sizes[allocIndex] : VK_WHOLE_SIZE;
        VkMappedMemoryRange newRange;
        if(GetFlushOrInvalidateRange(alloc, offset, size, newRange))
        {
            ranges.push_back(newRange);
        }
    }

    VkResult res = VK_SUCCESS;
    if(!ranges.empty())
    {
        switch(op)
        {
        case VMA_CACHE_FLUSH:
            res = (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, (uint32_t)ranges.size(), ranges.data());
            break;
        case VMA_CACHE_INVALIDATE:
            res = (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, (uint32_t)ranges.size(), ranges.data());
            break;
        default:
            VMA_ASSERT(0);
        }
    }
    // else: Just ignore this call.
    return res;
}

void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
{
    VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);

    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
    VmaPool parentPool = allocation->GetParentPool();
    if(parentPool == VK_NULL_HANDLE)
    {
        // Default pool
        m_DedicatedAllocations[memTypeIndex].Unregister(allocation);
    }
    else
    {
        // Custom pool
        parentPool->m_DedicatedAllocations.Unregister(allocation);
    }

    VkDeviceMemory hMemory = allocation->GetMemory();

    /*
    There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
    before vkFreeMemory.

    if(allocation->GetMappedData() != VMA_NULL)
    {
        (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
    }
    */

    FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);

    m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());
    m_AllocationObjectAllocator.Free(allocation);

    VMA_DEBUG_LOG("    Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
}

uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const
{
    VkBufferCreateInfo dummyBufCreateInfo;
    VmaFillGpuDefragmentationBufferCreateInfo(dummyBufCreateInfo);

    uint32_t memoryTypeBits = 0;

    // Create buffer.
    VkBuffer buf = VK_NULL_HANDLE;
    VkResult res = (*GetVulkanFunctions().vkCreateBuffer)(
        m_hDevice, &dummyBufCreateInfo, GetAllocationCallbacks(), &buf);
    if(res == VK_SUCCESS)
    {
        // Query for supported memory types.
        VkMemoryRequirements memReq;
        (*GetVulkanFunctions().vkGetBufferMemoryRequirements)(m_hDevice, buf, &memReq);
        memoryTypeBits = memReq.memoryTypeBits;

        // Destroy buffer.
        (*GetVulkanFunctions().vkDestroyBuffer)(m_hDevice, buf, GetAllocationCallbacks());
    }

    return memoryTypeBits;
}

uint32_t VmaAllocator_T::CalculateGlobalMemoryTypeBits() const
{
    // Make sure memory information is already fetched.
    VMA_ASSERT(GetMemoryTypeCount() > 0);

    uint32_t memoryTypeBits = UINT32_MAX;

    if(!m_UseAmdDeviceCoherentMemory)
    {
        // Exclude memory types that have VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD.
        for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        {
            if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY) != 0)
            {
                memoryTypeBits &= ~(1u << memTypeIndex);
            }
        }
    }

    return memoryTypeBits;
}

bool VmaAllocator_T::GetFlushOrInvalidateRange(
    VmaAllocation allocation,
    VkDeviceSize offset, VkDeviceSize size,
    VkMappedMemoryRange& outRange) const
{
    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
    if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
    {
        const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
        const VkDeviceSize allocationSize = allocation->GetSize();
        VMA_ASSERT(offset <= allocationSize);

        outRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
        outRange.pNext = VMA_NULL;
        outRange.memory = allocation->GetMemory();

        switch(allocation->GetType())
        {
        case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
            outRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
            if(size == VK_WHOLE_SIZE)
            {
                outRange.size = allocationSize - outRange.offset;
            }
            else
            {
                VMA_ASSERT(offset + size <= allocationSize);
                outRange.size = VMA_MIN(
                    VmaAlignUp(size + (offset - outRange.offset), nonCoherentAtomSize),
                    allocationSize - outRange.offset);
            }
            break;
        case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        {
            // 1. Still within this allocation.
            outRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
            if(size == VK_WHOLE_SIZE)
            {
                size = allocationSize - offset;
            }
            else
            {
                VMA_ASSERT(offset + size <= allocationSize);
            }
            outRange.size = VmaAlignUp(size + (offset - outRange.offset), nonCoherentAtomSize);

            // 2. Adjust to whole block.
            const VkDeviceSize allocationOffset = allocation->GetOffset();
            VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
            const VkDeviceSize blockSize = allocation->GetBlock()->m_pMetadata->GetSize();
            outRange.offset += allocationOffset;
            outRange.size = VMA_MIN(outRange.size, blockSize - outRange.offset);

            break;
        }
        default:
            VMA_ASSERT(0);
        }
        return true;
    }
    return false;
}

#if VMA_MEMORY_BUDGET
void VmaAllocator_T::UpdateVulkanBudget()
{
    VMA_ASSERT(m_UseExtMemoryBudget);

    VkPhysicalDeviceMemoryProperties2KHR memProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR };

    VkPhysicalDeviceMemoryBudgetPropertiesEXT budgetProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT };
    VmaPnextChainPushFront(&memProps, &budgetProps);

    GetVulkanFunctions().vkGetPhysicalDeviceMemoryProperties2KHR(m_PhysicalDevice, &memProps);

    {
        VmaMutexLockWrite lockWrite(m_Budget.m_BudgetMutex, m_UseMutex);

        for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        {
            m_Budget.m_VulkanUsage[heapIndex] = budgetProps.heapUsage[heapIndex];
            m_Budget.m_VulkanBudget[heapIndex] = budgetProps.heapBudget[heapIndex];
            m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] = m_Budget.m_BlockBytes[heapIndex].load();

            // Some bugged drivers return the budget incorrectly, e.g. 0 or much bigger than heap size.
            if(m_Budget.m_VulkanBudget[heapIndex] == 0)
            {
                m_Budget.m_VulkanBudget[heapIndex] = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
            }
            else if(m_Budget.m_VulkanBudget[heapIndex] > m_MemProps.memoryHeaps[heapIndex].size)
            {
                m_Budget.m_VulkanBudget[heapIndex] = m_MemProps.memoryHeaps[heapIndex].size;
            }
            if(m_Budget.m_VulkanUsage[heapIndex] == 0 && m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] > 0)
            {
                m_Budget.m_VulkanUsage[heapIndex] = m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
            }
        }
        m_Budget.m_OperationsSinceBudgetFetch = 0;
    }
}
#endif // VMA_MEMORY_BUDGET

void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
{
    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
        hAllocation->IsMappingAllowed() &&
        (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
    {
        void* pData = VMA_NULL;
        VkResult res = Map(hAllocation, &pData);
        if(res == VK_SUCCESS)
        {
            memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
            FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
            Unmap(hAllocation);
        }
        else
        {
            VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
        }
    }
}

uint32_t VmaAllocator_T::GetGpuDefragmentationMemoryTypeBits()
{
    uint32_t memoryTypeBits = m_GpuDefragmentationMemoryTypeBits.load();
    if(memoryTypeBits == UINT32_MAX)
    {
        memoryTypeBits = CalculateGpuDefragmentationMemoryTypeBits();
        m_GpuDefragmentationMemoryTypeBits.store(memoryTypeBits);
    }
    return memoryTypeBits;
}

#if VMA_STATS_STRING_ENABLED
void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
{
    json.WriteString("DefaultPools");
    json.BeginObject();
    {
        for (uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        {
            VmaBlockVector* pBlockVector = m_pBlockVectors[memTypeIndex];
            VmaDedicatedAllocationList& dedicatedAllocList = m_DedicatedAllocations[memTypeIndex];
            if (pBlockVector != VMA_NULL)
            {
                json.BeginString("Type ");
                json.ContinueString(memTypeIndex);
                json.EndString();
                json.BeginObject();
                {
                    json.WriteString("PreferredBlockSize");
                    json.WriteNumber(pBlockVector->GetPreferredBlockSize());

                    json.WriteString("Blocks");
                    pBlockVector->PrintDetailedMap(json);

                    json.WriteString("DedicatedAllocations");
                    dedicatedAllocList.BuildStatsString(json);
                }
                json.EndObject();
            }
        }
    }
    json.EndObject();

    json.WriteString("CustomPools");
    json.BeginObject();
    {
        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        if (!m_Pools.IsEmpty())
        {
            for (uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
            {
                bool displayType = true;
                size_t index = 0;
                for (VmaPool pool = m_Pools.Front(); pool != VMA_NULL; pool = m_Pools.GetNext(pool))
                {
                    VmaBlockVector& blockVector = pool->m_BlockVector;
                    if (blockVector.GetMemoryTypeIndex() == memTypeIndex)
                    {
                        if (displayType)
                        {
                            json.BeginString("Type ");
                            json.ContinueString(memTypeIndex);
                            json.EndString();
                            json.BeginArray();
                            displayType = false;
                        }

                        json.BeginObject();
                        {
                            json.WriteString("Name");
                            json.BeginString();
                            json.ContinueString((uint64_t)index++);
                            if (pool->GetName())
                            {
                                json.ContinueString(" - ");
                                json.ContinueString(pool->GetName());
                            }
                            json.EndString();

                            json.WriteString("PreferredBlockSize");
                            json.WriteNumber(blockVector.GetPreferredBlockSize());

                            json.WriteString("Blocks");
                            blockVector.PrintDetailedMap(json);

                            json.WriteString("DedicatedAllocations");
                            pool->m_DedicatedAllocations.BuildStatsString(json);
                        }
                        json.EndObject();
                    }
                }

                if (!displayType)
                    json.EndArray();
            }
        }
    }
    json.EndObject();
}
#endif // VMA_STATS_STRING_ENABLED
#endif // _VMA_ALLOCATOR_T_FUNCTIONS


#ifndef _VMA_PUBLIC_INTERFACE
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
    const VmaAllocatorCreateInfo* pCreateInfo,
    VmaAllocator* pAllocator)
{
    VMA_ASSERT(pCreateInfo && pAllocator);
    VMA_ASSERT(pCreateInfo->vulkanApiVersion == 0 ||
        (VK_VERSION_MAJOR(pCreateInfo->vulkanApiVersion) == 1 && VK_VERSION_MINOR(pCreateInfo->vulkanApiVersion) <= 3));
    VMA_DEBUG_LOG("vmaCreateAllocator");
    *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
    VkResult result = (*pAllocator)->Init(pCreateInfo);
    if(result < 0)
    {
        vma_delete(pCreateInfo->pAllocationCallbacks, *pAllocator);
        *pAllocator = VK_NULL_HANDLE;
    }
    return result;
}

VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
    VmaAllocator allocator)
{
    if(allocator != VK_NULL_HANDLE)
    {
        VMA_DEBUG_LOG("vmaDestroyAllocator");
        VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks; // Have to copy the callbacks when destroying.
        vma_delete(&allocationCallbacks, allocator);
    }
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocatorInfo(VmaAllocator allocator, VmaAllocatorInfo* pAllocatorInfo)
{
    VMA_ASSERT(allocator && pAllocatorInfo);
    pAllocatorInfo->instance = allocator->m_hInstance;
    pAllocatorInfo->physicalDevice = allocator->GetPhysicalDevice();
    pAllocatorInfo->device = allocator->m_hDevice;
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
    VmaAllocator allocator,
    const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
{
    VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
    *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
    VmaAllocator allocator,
    const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
{
    VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
    *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
    VmaAllocator allocator,
    uint32_t memoryTypeIndex,
    VkMemoryPropertyFlags* pFlags)
{
    VMA_ASSERT(allocator && pFlags);
    VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
    *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
}

VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
    VmaAllocator allocator,
    uint32_t frameIndex)
{
    VMA_ASSERT(allocator);

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocator->SetCurrentFrameIndex(frameIndex);
}

VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStatistics(
    VmaAllocator allocator,
    VmaTotalStatistics* pStats)
{
    VMA_ASSERT(allocator && pStats);
    VMA_DEBUG_GLOBAL_MUTEX_LOCK
    allocator->CalculateStatistics(pStats);
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetHeapBudgets(
    VmaAllocator allocator,
    VmaBudget* pBudgets)
{
    VMA_ASSERT(allocator && pBudgets);
    VMA_DEBUG_GLOBAL_MUTEX_LOCK
    allocator->GetHeapBudgets(pBudgets, 0, allocator->GetMemoryHeapCount());
}

#if VMA_STATS_STRING_ENABLED

VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
    VmaAllocator allocator,
    char** ppStatsString,
    VkBool32 detailedMap)
{
    VMA_ASSERT(allocator && ppStatsString);
    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    VmaStringBuilder sb(allocator->GetAllocationCallbacks());
    {
        VmaBudget budgets[VK_MAX_MEMORY_HEAPS];
        allocator->GetHeapBudgets(budgets, 0, allocator->GetMemoryHeapCount());

        VmaTotalStatistics stats;
        allocator->CalculateStatistics(&stats);

        VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
        json.BeginObject();
        {
            json.WriteString("General");
            json.BeginObject();
            {
                const VkPhysicalDeviceProperties& deviceProperties = allocator->m_PhysicalDeviceProperties;
                const VkPhysicalDeviceMemoryProperties& memoryProperties = allocator->m_MemProps;

                json.WriteString("API");
                json.WriteString("Vulkan");

                json.WriteString("apiVersion");
                json.BeginString();
                json.ContinueString(VK_VERSION_MAJOR(deviceProperties.apiVersion));
                json.ContinueString(".");
                json.ContinueString(VK_VERSION_MINOR(deviceProperties.apiVersion));
                json.ContinueString(".");
                json.ContinueString(VK_VERSION_PATCH(deviceProperties.apiVersion));
                json.EndString();

                json.WriteString("GPU");
                json.WriteString(deviceProperties.deviceName);
                json.WriteString("deviceType");
                json.WriteNumber(static_cast<uint32_t>(deviceProperties.deviceType));

                json.WriteString("maxMemoryAllocationCount");
                json.WriteNumber(deviceProperties.limits.maxMemoryAllocationCount);
                json.WriteString("bufferImageGranularity");
                json.WriteNumber(deviceProperties.limits.bufferImageGranularity);
                json.WriteString("nonCoherentAtomSize");
                json.WriteNumber(deviceProperties.limits.nonCoherentAtomSize);

                json.WriteString("memoryHeapCount");
                json.WriteNumber(memoryProperties.memoryHeapCount);
                json.WriteString("memoryTypeCount");
                json.WriteNumber(memoryProperties.memoryTypeCount);
            }
            json.EndObject();
        }
        {
            json.WriteString("Total");
            VmaPrintDetailedStatistics(json, stats.total);
        }
        {
            json.WriteString("MemoryInfo");
            json.BeginObject();
            {
                for (uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
                {
                    json.BeginString("Heap ");
                    json.ContinueString(heapIndex);
                    json.EndString();
                    json.BeginObject();
                    {
                        const VkMemoryHeap& heapInfo = allocator->m_MemProps.memoryHeaps[heapIndex];
                        json.WriteString("Flags");
                        json.BeginArray(true);
                        {
                            if (heapInfo.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
                                json.WriteString("DEVICE_LOCAL");
                        #if VMA_VULKAN_VERSION >= 1001000
                            if (heapInfo.flags & VK_MEMORY_HEAP_MULTI_INSTANCE_BIT)
                                json.WriteString("MULTI_INSTANCE");
                        #endif

                            VkMemoryHeapFlags flags = heapInfo.flags &
                                ~(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
                        #if VMA_VULKAN_VERSION >= 1001000
                                    | VK_MEMORY_HEAP_MULTI_INSTANCE_BIT
                        #endif
                                    );
                            if (flags != 0)
                                json.WriteNumber(flags);
                        }
                        json.EndArray();

                        json.WriteString("Size");
                        json.WriteNumber(heapInfo.size);

                        json.WriteString("Budget");
                        json.BeginObject();
                        {
                            json.WriteString("BudgetBytes");
                            json.WriteNumber(budgets[heapIndex].budget);
                            json.WriteString("UsageBytes");
                            json.WriteNumber(budgets[heapIndex].usage);
                        }
                        json.EndObject();

                        json.WriteString("Stats");
                        VmaPrintDetailedStatistics(json, stats.memoryHeap[heapIndex]);

                        json.WriteString("MemoryPools");
                        json.BeginObject();
                        {
                            for (uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
                            {
                                if (allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
                                {
                                    json.BeginString("Type ");
                                    json.ContinueString(typeIndex);
                                    json.EndString();
                                    json.BeginObject();
                                    {
                                        json.WriteString("Flags");
                                        json.BeginArray(true);
                                        {
                                            VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
                                            if (flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
                                                json.WriteString("DEVICE_LOCAL");
                                            if (flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
                                                json.WriteString("HOST_VISIBLE");
                                            if (flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
                                                json.WriteString("HOST_COHERENT");
                                            if (flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT)
                                                json.WriteString("HOST_CACHED");
                                            if (flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
                                                json.WriteString("LAZILY_ALLOCATED");
                                        #if VMA_VULKAN_VERSION >= 1001000
                                            if (flags & VK_MEMORY_PROPERTY_PROTECTED_BIT)
                                                json.WriteString("PROTECTED");
                                        #endif
                                        #if VK_AMD_device_coherent_memory
                                            if (flags & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY)
                                                json.WriteString("DEVICE_COHERENT_AMD");
                                            if (flags & VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY)
                                                json.WriteString("DEVICE_UNCACHED_AMD");
                                        #endif

                                            flags &= ~(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
                                        #if VMA_VULKAN_VERSION >= 1001000
                                                | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
                                        #endif
                                        #if VK_AMD_device_coherent_memory
                                                | VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY
                                                | VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY
                                        #endif
                                                | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
                                                | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
                                                | VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
                                            if (flags != 0)
                                                json.WriteNumber(flags);
                                        }
                                        json.EndArray();

                                        json.WriteString("Stats");
                                        VmaPrintDetailedStatistics(json, stats.memoryType[typeIndex]);
                                    }
                                    json.EndObject();
                                }
                            }

                        }
                        json.EndObject();
                    }
                    json.EndObject();
                }
            }
            json.EndObject();
        }

        if (detailedMap == VK_TRUE)
            allocator->PrintDetailedMap(json);

        json.EndObject();
    }

    *ppStatsString = VmaCreateStringCopy(allocator->GetAllocationCallbacks(), sb.GetData(), sb.GetLength());
}

VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
    VmaAllocator allocator,
    char* pStatsString)
{
    if(pStatsString != VMA_NULL)
    {
        VMA_ASSERT(allocator);
        VmaFreeString(allocator->GetAllocationCallbacks(), pStatsString);
    }
}

#endif // VMA_STATS_STRING_ENABLED

/*
This function is not protected by any mutex because it just reads immutable data.
*/
VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
    VmaAllocator allocator,
    uint32_t memoryTypeBits,
    const VmaAllocationCreateInfo* pAllocationCreateInfo,
    uint32_t* pMemoryTypeIndex)
{
    VMA_ASSERT(allocator != VK_NULL_HANDLE);
    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);

    return allocator->FindMemoryTypeIndex(memoryTypeBits, pAllocationCreateInfo, UINT32_MAX, pMemoryTypeIndex);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
    VmaAllocator allocator,
    const VkBufferCreateInfo* pBufferCreateInfo,
    const VmaAllocationCreateInfo* pAllocationCreateInfo,
    uint32_t* pMemoryTypeIndex)
{
    VMA_ASSERT(allocator != VK_NULL_HANDLE);
    VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);

    const VkDevice hDev = allocator->m_hDevice;
    const VmaVulkanFunctions* funcs = &allocator->GetVulkanFunctions();
    VkResult res;

#if VMA_VULKAN_VERSION >= 1003000
    if(funcs->vkGetDeviceBufferMemoryRequirements)
    {
        // Can query straight from VkBufferCreateInfo :)
        VkDeviceBufferMemoryRequirements devBufMemReq = {VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS};
        devBufMemReq.pCreateInfo = pBufferCreateInfo;

        VkMemoryRequirements2 memReq = {VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
        (*funcs->vkGetDeviceBufferMemoryRequirements)(hDev, &devBufMemReq, &memReq);

        res = allocator->FindMemoryTypeIndex(
            memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo, pBufferCreateInfo->usage, pMemoryTypeIndex);
    }
    else
#endif // #if VMA_VULKAN_VERSION >= 1003000
    {
        // Must create a dummy buffer to query :(
        VkBuffer hBuffer = VK_NULL_HANDLE;
        res = funcs->vkCreateBuffer(
            hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
        if(res == VK_SUCCESS)
        {
            VkMemoryRequirements memReq = {};
            funcs->vkGetBufferMemoryRequirements(hDev, hBuffer, &memReq);

            res = allocator->FindMemoryTypeIndex(
                memReq.memoryTypeBits, pAllocationCreateInfo, pBufferCreateInfo->usage, pMemoryTypeIndex);

            funcs->vkDestroyBuffer(
                hDev, hBuffer, allocator->GetAllocationCallbacks());
        }
    }
    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
    VmaAllocator allocator,
    const VkImageCreateInfo* pImageCreateInfo,
    const VmaAllocationCreateInfo* pAllocationCreateInfo,
    uint32_t* pMemoryTypeIndex)
{
    VMA_ASSERT(allocator != VK_NULL_HANDLE);
    VMA_ASSERT(pImageCreateInfo != VMA_NULL);
    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);

    const VkDevice hDev = allocator->m_hDevice;
    const VmaVulkanFunctions* funcs = &allocator->GetVulkanFunctions();
    VkResult res;

#if VMA_VULKAN_VERSION >= 1003000
    if(funcs->vkGetDeviceImageMemoryRequirements)
    {
        // Can query straight from VkImageCreateInfo :)
        VkDeviceImageMemoryRequirements devImgMemReq = {VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS};
        devImgMemReq.pCreateInfo = pImageCreateInfo;
        VMA_ASSERT(pImageCreateInfo->tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT_COPY && (pImageCreateInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT_COPY) == 0 &&
            "Cannot use this VkImageCreateInfo with vmaFindMemoryTypeIndexForImageInfo as I don't know what to pass as VkDeviceImageMemoryRequirements::planeAspect.");

        VkMemoryRequirements2 memReq = {VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
        (*funcs->vkGetDeviceImageMemoryRequirements)(hDev, &devImgMemReq, &memReq);

        res = allocator->FindMemoryTypeIndex(
            memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo, pImageCreateInfo->usage, pMemoryTypeIndex);
    }
    else
#endif // #if VMA_VULKAN_VERSION >= 1003000
    {
        // Must create a dummy image to query :(
        VkImage hImage = VK_NULL_HANDLE;
        res = funcs->vkCreateImage(
            hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
        if(res == VK_SUCCESS)
        {
            VkMemoryRequirements memReq = {};
            funcs->vkGetImageMemoryRequirements(hDev, hImage, &memReq);

            res = allocator->FindMemoryTypeIndex(
                memReq.memoryTypeBits, pAllocationCreateInfo, pImageCreateInfo->usage, pMemoryTypeIndex);

            funcs->vkDestroyImage(
                hDev, hImage, allocator->GetAllocationCallbacks());
        }
    }
    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
    VmaAllocator allocator,
    const VmaPoolCreateInfo* pCreateInfo,
    VmaPool* pPool)
{
    VMA_ASSERT(allocator && pCreateInfo && pPool);

    VMA_DEBUG_LOG("vmaCreatePool");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    return allocator->CreatePool(pCreateInfo, pPool);
}

VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
    VmaAllocator allocator,
    VmaPool pool)
{
    VMA_ASSERT(allocator);

    if(pool == VK_NULL_HANDLE)
    {
        return;
    }

    VMA_DEBUG_LOG("vmaDestroyPool");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocator->DestroyPool(pool);
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStatistics(
    VmaAllocator allocator,
    VmaPool pool,
    VmaStatistics* pPoolStats)
{
    VMA_ASSERT(allocator && pool && pPoolStats);

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocator->GetPoolStatistics(pool, pPoolStats);
}

VMA_CALL_PRE void VMA_CALL_POST vmaCalculatePoolStatistics(
    VmaAllocator allocator,
    VmaPool pool,
    VmaDetailedStatistics* pPoolStats)
{
    VMA_ASSERT(allocator && pool && pPoolStats);

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocator->CalculatePoolStatistics(pool, pPoolStats);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
{
    VMA_ASSERT(allocator && pool);

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    VMA_DEBUG_LOG("vmaCheckPoolCorruption");

    return allocator->CheckPoolCorruption(pool);
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
    VmaAllocator allocator,
    VmaPool pool,
    const char** ppName)
{
    VMA_ASSERT(allocator && pool && ppName);

    VMA_DEBUG_LOG("vmaGetPoolName");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    *ppName = pool->GetName();
}

VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
    VmaAllocator allocator,
    VmaPool pool,
    const char* pName)
{
    VMA_ASSERT(allocator && pool);

    VMA_DEBUG_LOG("vmaSetPoolName");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    pool->SetName(pName);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
    VmaAllocator allocator,
    const VkMemoryRequirements* pVkMemoryRequirements,
    const VmaAllocationCreateInfo* pCreateInfo,
    VmaAllocation* pAllocation,
    VmaAllocationInfo* pAllocationInfo)
{
    VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);

    VMA_DEBUG_LOG("vmaAllocateMemory");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    VkResult result = allocator->AllocateMemory(
        *pVkMemoryRequirements,
        false, // requiresDedicatedAllocation
        false, // prefersDedicatedAllocation
        VK_NULL_HANDLE, // dedicatedBuffer
        VK_NULL_HANDLE, // dedicatedImage
        UINT32_MAX, // dedicatedBufferImageUsage
        *pCreateInfo,
        VMA_SUBALLOCATION_TYPE_UNKNOWN,
        1, // allocationCount
        pAllocation);

    if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
    {
        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    }

    return result;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
    VmaAllocator allocator,
    const VkMemoryRequirements* pVkMemoryRequirements,
    const VmaAllocationCreateInfo* pCreateInfo,
    size_t allocationCount,
    VmaAllocation* pAllocations,
    VmaAllocationInfo* pAllocationInfo)
{
    if(allocationCount == 0)
    {
        return VK_SUCCESS;
    }

    VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocations);

    VMA_DEBUG_LOG("vmaAllocateMemoryPages");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    VkResult result = allocator->AllocateMemory(
        *pVkMemoryRequirements,
        false, // requiresDedicatedAllocation
        false, // prefersDedicatedAllocation
        VK_NULL_HANDLE, // dedicatedBuffer
        VK_NULL_HANDLE, // dedicatedImage
        UINT32_MAX, // dedicatedBufferImageUsage
        *pCreateInfo,
        VMA_SUBALLOCATION_TYPE_UNKNOWN,
        allocationCount,
        pAllocations);

    if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
    {
        for(size_t i = 0; i < allocationCount; ++i)
        {
            allocator->GetAllocationInfo(pAllocations[i], pAllocationInfo + i);
        }
    }

    return result;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
    VmaAllocator allocator,
    VkBuffer buffer,
    const VmaAllocationCreateInfo* pCreateInfo,
    VmaAllocation* pAllocation,
    VmaAllocationInfo* pAllocationInfo)
{
    VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);

    VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    VkMemoryRequirements vkMemReq = {};
    bool requiresDedicatedAllocation = false;
    bool prefersDedicatedAllocation = false;
    allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
        requiresDedicatedAllocation,
        prefersDedicatedAllocation);

    VkResult result = allocator->AllocateMemory(
        vkMemReq,
        requiresDedicatedAllocation,
        prefersDedicatedAllocation,
        buffer, // dedicatedBuffer
        VK_NULL_HANDLE, // dedicatedImage
        UINT32_MAX, // dedicatedBufferImageUsage
        *pCreateInfo,
        VMA_SUBALLOCATION_TYPE_BUFFER,
        1, // allocationCount
        pAllocation);

    if(pAllocationInfo && result == VK_SUCCESS)
    {
        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    }

    return result;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
    VmaAllocator allocator,
    VkImage image,
    const VmaAllocationCreateInfo* pCreateInfo,
    VmaAllocation* pAllocation,
    VmaAllocationInfo* pAllocationInfo)
{
    VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);

    VMA_DEBUG_LOG("vmaAllocateMemoryForImage");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    VkMemoryRequirements vkMemReq = {};
    bool requiresDedicatedAllocation = false;
    bool prefersDedicatedAllocation  = false;
    allocator->GetImageMemoryRequirements(image, vkMemReq,
        requiresDedicatedAllocation, prefersDedicatedAllocation);

    VkResult result = allocator->AllocateMemory(
        vkMemReq,
        requiresDedicatedAllocation,
        prefersDedicatedAllocation,
        VK_NULL_HANDLE, // dedicatedBuffer
        image, // dedicatedImage
        UINT32_MAX, // dedicatedBufferImageUsage
        *pCreateInfo,
        VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
        1, // allocationCount
        pAllocation);

    if(pAllocationInfo && result == VK_SUCCESS)
    {
        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    }

    return result;
}

VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
    VmaAllocator allocator,
    VmaAllocation allocation)
{
    VMA_ASSERT(allocator);

    if(allocation == VK_NULL_HANDLE)
    {
        return;
    }

    VMA_DEBUG_LOG("vmaFreeMemory");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocator->FreeMemory(
        1, // allocationCount
        &allocation);
}

VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
    VmaAllocator allocator,
    size_t allocationCount,
    const VmaAllocation* pAllocations)
{
    if(allocationCount == 0)
    {
        return;
    }

    VMA_ASSERT(allocator);

    VMA_DEBUG_LOG("vmaFreeMemoryPages");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocator->FreeMemory(allocationCount, pAllocations);
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
    VmaAllocator allocator,
    VmaAllocation allocation,
    VmaAllocationInfo* pAllocationInfo)
{
    VMA_ASSERT(allocator && allocation && pAllocationInfo);

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocator->GetAllocationInfo(allocation, pAllocationInfo);
}

VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
    VmaAllocator allocator,
    VmaAllocation allocation,
    void* pUserData)
{
    VMA_ASSERT(allocator && allocation);

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocation->SetUserData(allocator, pUserData);
}

VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationName(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    const char* VMA_NULLABLE pName)
{
    allocation->SetName(allocator, pName);
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationMemoryProperties(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkMemoryPropertyFlags* VMA_NOT_NULL pFlags)
{
    VMA_ASSERT(allocator && allocation && pFlags);
    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
    *pFlags = allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
    VmaAllocator allocator,
    VmaAllocation allocation,
    void** ppData)
{
    VMA_ASSERT(allocator && allocation && ppData);

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    return allocator->Map(allocation, ppData);
}

VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
    VmaAllocator allocator,
    VmaAllocation allocation)
{
    VMA_ASSERT(allocator && allocation);

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    allocator->Unmap(allocation);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocation(
    VmaAllocator allocator,
    VmaAllocation allocation,
    VkDeviceSize offset,
    VkDeviceSize size)
{
    VMA_ASSERT(allocator && allocation);

    VMA_DEBUG_LOG("vmaFlushAllocation");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    const VkResult res = allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);

    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocation(
    VmaAllocator allocator,
    VmaAllocation allocation,
    VkDeviceSize offset,
    VkDeviceSize size)
{
    VMA_ASSERT(allocator && allocation);

    VMA_DEBUG_LOG("vmaInvalidateAllocation");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    const VkResult res = allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);

    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocations(
    VmaAllocator allocator,
    uint32_t allocationCount,
    const VmaAllocation* allocations,
    const VkDeviceSize* offsets,
    const VkDeviceSize* sizes)
{
    VMA_ASSERT(allocator);

    if(allocationCount == 0)
    {
        return VK_SUCCESS;
    }

    VMA_ASSERT(allocations);

    VMA_DEBUG_LOG("vmaFlushAllocations");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    const VkResult res = allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_FLUSH);

    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
    VmaAllocator allocator,
    uint32_t allocationCount,
    const VmaAllocation* allocations,
    const VkDeviceSize* offsets,
    const VkDeviceSize* sizes)
{
    VMA_ASSERT(allocator);

    if(allocationCount == 0)
    {
        return VK_SUCCESS;
    }

    VMA_ASSERT(allocations);

    VMA_DEBUG_LOG("vmaInvalidateAllocations");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    const VkResult res = allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_INVALIDATE);

    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(
    VmaAllocator allocator,
    uint32_t memoryTypeBits)
{
    VMA_ASSERT(allocator);

    VMA_DEBUG_LOG("vmaCheckCorruption");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    return allocator->CheckCorruption(memoryTypeBits);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentation(
    VmaAllocator allocator,
    const VmaDefragmentationInfo* pInfo,
    VmaDefragmentationContext* pContext)
{
    VMA_ASSERT(allocator && pInfo && pContext);

    VMA_DEBUG_LOG("vmaBeginDefragmentation");

    if (pInfo->pool != VMA_NULL)
    {
        // Check if run on supported algorithms
        if (pInfo->pool->m_BlockVector.GetAlgorithm() & VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
            return VK_ERROR_FEATURE_NOT_PRESENT;
    }

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    *pContext = vma_new(allocator, VmaDefragmentationContext_T)(allocator, *pInfo);
    return VK_SUCCESS;
}

VMA_CALL_PRE void VMA_CALL_POST vmaEndDefragmentation(
    VmaAllocator allocator,
    VmaDefragmentationContext context,
    VmaDefragmentationStats* pStats)
{
    VMA_ASSERT(allocator && context);

    VMA_DEBUG_LOG("vmaEndDefragmentation");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    if (pStats)
        context->GetStats(*pStats);
    vma_delete(allocator, context);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentationPass(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaDefragmentationContext VMA_NOT_NULL context,
    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL pPassInfo)
{
    VMA_ASSERT(context && pPassInfo);

    VMA_DEBUG_LOG("vmaBeginDefragmentationPass");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    return context->DefragmentPassBegin(*pPassInfo);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaEndDefragmentationPass(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaDefragmentationContext VMA_NOT_NULL context,
    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL pPassInfo)
{
    VMA_ASSERT(context && pPassInfo);

    VMA_DEBUG_LOG("vmaEndDefragmentationPass");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    return context->DefragmentPassEnd(*pPassInfo);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
    VmaAllocator allocator,
    VmaAllocation allocation,
    VkBuffer buffer)
{
    VMA_ASSERT(allocator && allocation && buffer);

    VMA_DEBUG_LOG("vmaBindBufferMemory");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    return allocator->BindBufferMemory(allocation, 0, buffer, VMA_NULL);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
    VmaAllocator allocator,
    VmaAllocation allocation,
    VkDeviceSize allocationLocalOffset,
    VkBuffer buffer,
    const void* pNext)
{
    VMA_ASSERT(allocator && allocation && buffer);

    VMA_DEBUG_LOG("vmaBindBufferMemory2");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    return allocator->BindBufferMemory(allocation, allocationLocalOffset, buffer, pNext);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
    VmaAllocator allocator,
    VmaAllocation allocation,
    VkImage image)
{
    VMA_ASSERT(allocator && allocation && image);

    VMA_DEBUG_LOG("vmaBindImageMemory");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    return allocator->BindImageMemory(allocation, 0, image, VMA_NULL);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
    VmaAllocator allocator,
    VmaAllocation allocation,
    VkDeviceSize allocationLocalOffset,
    VkImage image,
    const void* pNext)
{
    VMA_ASSERT(allocator && allocation && image);

    VMA_DEBUG_LOG("vmaBindImageMemory2");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

        return allocator->BindImageMemory(allocation, allocationLocalOffset, image, pNext);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
    VmaAllocator allocator,
    const VkBufferCreateInfo* pBufferCreateInfo,
    const VmaAllocationCreateInfo* pAllocationCreateInfo,
    VkBuffer* pBuffer,
    VmaAllocation* pAllocation,
    VmaAllocationInfo* pAllocationInfo)
{
    VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);

    if(pBufferCreateInfo->size == 0)
    {
        return VK_ERROR_INITIALIZATION_FAILED;
    }
    if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY) != 0 &&
        !allocator->m_UseKhrBufferDeviceAddress)
    {
        VMA_ASSERT(0 && "Creating a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT is not valid if VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT was not used.");
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    VMA_DEBUG_LOG("vmaCreateBuffer");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    *pBuffer = VK_NULL_HANDLE;
    *pAllocation = VK_NULL_HANDLE;

    // 1. Create VkBuffer.
    VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
        allocator->m_hDevice,
        pBufferCreateInfo,
        allocator->GetAllocationCallbacks(),
        pBuffer);
    if(res >= 0)
    {
        // 2. vkGetBufferMemoryRequirements.
        VkMemoryRequirements vkMemReq = {};
        bool requiresDedicatedAllocation = false;
        bool prefersDedicatedAllocation  = false;
        allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
            requiresDedicatedAllocation, prefersDedicatedAllocation);

        // 3. Allocate memory using allocator.
        res = allocator->AllocateMemory(
            vkMemReq,
            requiresDedicatedAllocation,
            prefersDedicatedAllocation,
            *pBuffer, // dedicatedBuffer
            VK_NULL_HANDLE, // dedicatedImage
            pBufferCreateInfo->usage, // dedicatedBufferImageUsage
            *pAllocationCreateInfo,
            VMA_SUBALLOCATION_TYPE_BUFFER,
            1, // allocationCount
            pAllocation);

        if(res >= 0)
        {
            // 3. Bind buffer with memory.
            if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
            {
                res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
            }
            if(res >= 0)
            {
                // All steps succeeded.
                #if VMA_STATS_STRING_ENABLED
                    (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
                #endif
                if(pAllocationInfo != VMA_NULL)
                {
                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
                }

                return VK_SUCCESS;
            }
            allocator->FreeMemory(
                1, // allocationCount
                pAllocation);
            *pAllocation = VK_NULL_HANDLE;
            (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
            *pBuffer = VK_NULL_HANDLE;
            return res;
        }
        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        *pBuffer = VK_NULL_HANDLE;
        return res;
    }
    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBufferWithAlignment(
    VmaAllocator allocator,
    const VkBufferCreateInfo* pBufferCreateInfo,
    const VmaAllocationCreateInfo* pAllocationCreateInfo,
    VkDeviceSize minAlignment,
    VkBuffer* pBuffer,
    VmaAllocation* pAllocation,
    VmaAllocationInfo* pAllocationInfo)
{
    VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && VmaIsPow2(minAlignment) && pBuffer && pAllocation);

    if(pBufferCreateInfo->size == 0)
    {
        return VK_ERROR_INITIALIZATION_FAILED;
    }
    if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY) != 0 &&
        !allocator->m_UseKhrBufferDeviceAddress)
    {
        VMA_ASSERT(0 && "Creating a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT is not valid if VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT was not used.");
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    VMA_DEBUG_LOG("vmaCreateBufferWithAlignment");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    *pBuffer = VK_NULL_HANDLE;
    *pAllocation = VK_NULL_HANDLE;

    // 1. Create VkBuffer.
    VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
        allocator->m_hDevice,
        pBufferCreateInfo,
        allocator->GetAllocationCallbacks(),
        pBuffer);
    if(res >= 0)
    {
        // 2. vkGetBufferMemoryRequirements.
        VkMemoryRequirements vkMemReq = {};
        bool requiresDedicatedAllocation = false;
        bool prefersDedicatedAllocation  = false;
        allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
            requiresDedicatedAllocation, prefersDedicatedAllocation);

        // 2a. Include minAlignment
        vkMemReq.alignment = VMA_MAX(vkMemReq.alignment, minAlignment);

        // 3. Allocate memory using allocator.
        res = allocator->AllocateMemory(
            vkMemReq,
            requiresDedicatedAllocation,
            prefersDedicatedAllocation,
            *pBuffer, // dedicatedBuffer
            VK_NULL_HANDLE, // dedicatedImage
            pBufferCreateInfo->usage, // dedicatedBufferImageUsage
            *pAllocationCreateInfo,
            VMA_SUBALLOCATION_TYPE_BUFFER,
            1, // allocationCount
            pAllocation);

        if(res >= 0)
        {
            // 3. Bind buffer with memory.
            if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
            {
                res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
            }
            if(res >= 0)
            {
                // All steps succeeded.
                #if VMA_STATS_STRING_ENABLED
                    (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
                #endif
                if(pAllocationInfo != VMA_NULL)
                {
                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
                }

                return VK_SUCCESS;
            }
            allocator->FreeMemory(
                1, // allocationCount
                pAllocation);
            *pAllocation = VK_NULL_HANDLE;
            (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
            *pBuffer = VK_NULL_HANDLE;
            return res;
        }
        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        *pBuffer = VK_NULL_HANDLE;
        return res;
    }
    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingBuffer(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer)
{
    return vmaCreateAliasingBuffer2(allocator, allocation, 0, pBufferCreateInfo, pBuffer);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingBuffer2(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkDeviceSize allocationLocalOffset,
    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer)
{
    VMA_ASSERT(allocator && pBufferCreateInfo && pBuffer && allocation);
    VMA_ASSERT(allocationLocalOffset + pBufferCreateInfo->size <= allocation->GetSize());

    VMA_DEBUG_LOG("vmaCreateAliasingBuffer2");

    *pBuffer = VK_NULL_HANDLE;

    if (pBufferCreateInfo->size == 0)
    {
        return VK_ERROR_INITIALIZATION_FAILED;
    }
    if ((pBufferCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY) != 0 &&
        !allocator->m_UseKhrBufferDeviceAddress)
    {
        VMA_ASSERT(0 && "Creating a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT is not valid if VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT was not used.");
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    // 1. Create VkBuffer.
    VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
        allocator->m_hDevice,
        pBufferCreateInfo,
        allocator->GetAllocationCallbacks(),
        pBuffer);
    if (res >= 0)
    {
        // 2. Bind buffer with memory.
        res = allocator->BindBufferMemory(allocation, allocationLocalOffset, *pBuffer, VMA_NULL);
        if (res >= 0)
        {
            return VK_SUCCESS;
        }
        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
    }
    return res;
}

VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
    VmaAllocator allocator,
    VkBuffer buffer,
    VmaAllocation allocation)
{
    VMA_ASSERT(allocator);

    if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
    {
        return;
    }

    VMA_DEBUG_LOG("vmaDestroyBuffer");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    if(buffer != VK_NULL_HANDLE)
    {
        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
    }

    if(allocation != VK_NULL_HANDLE)
    {
        allocator->FreeMemory(
            1, // allocationCount
            &allocation);
    }
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
    VmaAllocator allocator,
    const VkImageCreateInfo* pImageCreateInfo,
    const VmaAllocationCreateInfo* pAllocationCreateInfo,
    VkImage* pImage,
    VmaAllocation* pAllocation,
    VmaAllocationInfo* pAllocationInfo)
{
    VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);

    if(pImageCreateInfo->extent.width == 0 ||
        pImageCreateInfo->extent.height == 0 ||
        pImageCreateInfo->extent.depth == 0 ||
        pImageCreateInfo->mipLevels == 0 ||
        pImageCreateInfo->arrayLayers == 0)
    {
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    VMA_DEBUG_LOG("vmaCreateImage");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    *pImage = VK_NULL_HANDLE;
    *pAllocation = VK_NULL_HANDLE;

    // 1. Create VkImage.
    VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
        allocator->m_hDevice,
        pImageCreateInfo,
        allocator->GetAllocationCallbacks(),
        pImage);
    if(res >= 0)
    {
        VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
            VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
            VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;

        // 2. Allocate memory using allocator.
        VkMemoryRequirements vkMemReq = {};
        bool requiresDedicatedAllocation = false;
        bool prefersDedicatedAllocation  = false;
        allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
            requiresDedicatedAllocation, prefersDedicatedAllocation);

        res = allocator->AllocateMemory(
            vkMemReq,
            requiresDedicatedAllocation,
            prefersDedicatedAllocation,
            VK_NULL_HANDLE, // dedicatedBuffer
            *pImage, // dedicatedImage
            pImageCreateInfo->usage, // dedicatedBufferImageUsage
            *pAllocationCreateInfo,
            suballocType,
            1, // allocationCount
            pAllocation);

        if(res >= 0)
        {
            // 3. Bind image with memory.
            if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
            {
                res = allocator->BindImageMemory(*pAllocation, 0, *pImage, VMA_NULL);
            }
            if(res >= 0)
            {
                // All steps succeeded.
                #if VMA_STATS_STRING_ENABLED
                    (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
                #endif
                if(pAllocationInfo != VMA_NULL)
                {
                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
                }

                return VK_SUCCESS;
            }
            allocator->FreeMemory(
                1, // allocationCount
                pAllocation);
            *pAllocation = VK_NULL_HANDLE;
            (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
            *pImage = VK_NULL_HANDLE;
            return res;
        }
        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        *pImage = VK_NULL_HANDLE;
        return res;
    }
    return res;
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingImage(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
    VkImage VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pImage)
{
    return vmaCreateAliasingImage2(allocator, allocation, 0, pImageCreateInfo, pImage);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingImage2(
    VmaAllocator VMA_NOT_NULL allocator,
    VmaAllocation VMA_NOT_NULL allocation,
    VkDeviceSize allocationLocalOffset,
    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
    VkImage VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pImage)
{
    VMA_ASSERT(allocator && pImageCreateInfo && pImage && allocation);

    *pImage = VK_NULL_HANDLE;

    VMA_DEBUG_LOG("vmaCreateImage2");

    if (pImageCreateInfo->extent.width == 0 ||
        pImageCreateInfo->extent.height == 0 ||
        pImageCreateInfo->extent.depth == 0 ||
        pImageCreateInfo->mipLevels == 0 ||
        pImageCreateInfo->arrayLayers == 0)
    {
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    // 1. Create VkImage.
    VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
        allocator->m_hDevice,
        pImageCreateInfo,
        allocator->GetAllocationCallbacks(),
        pImage);
    if (res >= 0)
    {
        // 2. Bind image with memory.
        res = allocator->BindImageMemory(allocation, allocationLocalOffset, *pImage, VMA_NULL);
        if (res >= 0)
        {
            return VK_SUCCESS;
        }
        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
    }
    return res;
}

VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
    VmaAllocator VMA_NOT_NULL allocator,
    VkImage VMA_NULLABLE_NON_DISPATCHABLE image,
    VmaAllocation VMA_NULLABLE allocation)
{
    VMA_ASSERT(allocator);

    if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
    {
        return;
    }

    VMA_DEBUG_LOG("vmaDestroyImage");

    VMA_DEBUG_GLOBAL_MUTEX_LOCK

    if(image != VK_NULL_HANDLE)
    {
        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
    }
    if(allocation != VK_NULL_HANDLE)
    {
        allocator->FreeMemory(
            1, // allocationCount
            &allocation);
    }
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateVirtualBlock(
    const VmaVirtualBlockCreateInfo* VMA_NOT_NULL pCreateInfo,
    VmaVirtualBlock VMA_NULLABLE * VMA_NOT_NULL pVirtualBlock)
{
    VMA_ASSERT(pCreateInfo && pVirtualBlock);
    VMA_ASSERT(pCreateInfo->size > 0);
    VMA_DEBUG_LOG("vmaCreateVirtualBlock");
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    *pVirtualBlock = vma_new(pCreateInfo->pAllocationCallbacks, VmaVirtualBlock_T)(*pCreateInfo);
    VkResult res = (*pVirtualBlock)->Init();
    if(res < 0)
    {
        vma_delete(pCreateInfo->pAllocationCallbacks, *pVirtualBlock);
        *pVirtualBlock = VK_NULL_HANDLE;
    }
    return res;
}

VMA_CALL_PRE void VMA_CALL_POST vmaDestroyVirtualBlock(VmaVirtualBlock VMA_NULLABLE virtualBlock)
{
    if(virtualBlock != VK_NULL_HANDLE)
    {
        VMA_DEBUG_LOG("vmaDestroyVirtualBlock");
        VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        VkAllocationCallbacks allocationCallbacks = virtualBlock->m_AllocationCallbacks; // Have to copy the callbacks when destroying.
        vma_delete(&allocationCallbacks, virtualBlock);
    }
}

VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaIsVirtualBlockEmpty(VmaVirtualBlock VMA_NOT_NULL virtualBlock)
{
    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
    VMA_DEBUG_LOG("vmaIsVirtualBlockEmpty");
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    return virtualBlock->IsEmpty() ? VK_TRUE : VK_FALSE;
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetVirtualAllocationInfo(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaVirtualAllocation VMA_NOT_NULL_NON_DISPATCHABLE allocation, VmaVirtualAllocationInfo* VMA_NOT_NULL pVirtualAllocInfo)
{
    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && pVirtualAllocInfo != VMA_NULL);
    VMA_DEBUG_LOG("vmaGetVirtualAllocationInfo");
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    virtualBlock->GetAllocationInfo(allocation, *pVirtualAllocInfo);
}

VMA_CALL_PRE VkResult VMA_CALL_POST vmaVirtualAllocate(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    const VmaVirtualAllocationCreateInfo* VMA_NOT_NULL pCreateInfo, VmaVirtualAllocation VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pAllocation,
    VkDeviceSize* VMA_NULLABLE pOffset)
{
    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && pCreateInfo != VMA_NULL && pAllocation != VMA_NULL);
    VMA_DEBUG_LOG("vmaVirtualAllocate");
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    return virtualBlock->Allocate(*pCreateInfo, *pAllocation, pOffset);
}

VMA_CALL_PRE void VMA_CALL_POST vmaVirtualFree(VmaVirtualBlock VMA_NOT_NULL virtualBlock, VmaVirtualAllocation VMA_NULLABLE_NON_DISPATCHABLE allocation)
{
    if(allocation != VK_NULL_HANDLE)
    {
        VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
        VMA_DEBUG_LOG("vmaVirtualFree");
        VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        virtualBlock->Free(allocation);
    }
}

VMA_CALL_PRE void VMA_CALL_POST vmaClearVirtualBlock(VmaVirtualBlock VMA_NOT_NULL virtualBlock)
{
    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
    VMA_DEBUG_LOG("vmaClearVirtualBlock");
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    virtualBlock->Clear();
}

VMA_CALL_PRE void VMA_CALL_POST vmaSetVirtualAllocationUserData(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaVirtualAllocation VMA_NOT_NULL_NON_DISPATCHABLE allocation, void* VMA_NULLABLE pUserData)
{
    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
    VMA_DEBUG_LOG("vmaSetVirtualAllocationUserData");
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    virtualBlock->SetAllocationUserData(allocation, pUserData);
}

VMA_CALL_PRE void VMA_CALL_POST vmaGetVirtualBlockStatistics(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaStatistics* VMA_NOT_NULL pStats)
{
    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && pStats != VMA_NULL);
    VMA_DEBUG_LOG("vmaGetVirtualBlockStatistics");
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    virtualBlock->GetStatistics(*pStats);
}

VMA_CALL_PRE void VMA_CALL_POST vmaCalculateVirtualBlockStatistics(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    VmaDetailedStatistics* VMA_NOT_NULL pStats)
{
    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && pStats != VMA_NULL);
    VMA_DEBUG_LOG("vmaCalculateVirtualBlockStatistics");
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    virtualBlock->CalculateDetailedStatistics(*pStats);
}

#if VMA_STATS_STRING_ENABLED

VMA_CALL_PRE void VMA_CALL_POST vmaBuildVirtualBlockStatsString(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    char* VMA_NULLABLE * VMA_NOT_NULL ppStatsString, VkBool32 detailedMap)
{
    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && ppStatsString != VMA_NULL);
    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    const VkAllocationCallbacks* allocationCallbacks = virtualBlock->GetAllocationCallbacks();
    VmaStringBuilder sb(allocationCallbacks);
    virtualBlock->BuildStatsString(detailedMap != VK_FALSE, sb);
    *ppStatsString = VmaCreateStringCopy(allocationCallbacks, sb.GetData(), sb.GetLength());
}

VMA_CALL_PRE void VMA_CALL_POST vmaFreeVirtualBlockStatsString(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
    char* VMA_NULLABLE pStatsString)
{
    if(pStatsString != VMA_NULL)
    {
        VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
        VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        VmaFreeString(virtualBlock->GetAllocationCallbacks(), pStatsString);
    }
}
#endif // VMA_STATS_STRING_ENABLED
#endif // _VMA_PUBLIC_INTERFACE
#endif // VMA_IMPLEMENTATION

/**
\page quick_start Quick start

\section quick_start_project_setup Project setup

Vulkan Memory Allocator comes in form of a "stb-style" single header file.
You don't need to build it as a separate library project.
You can add this file directly to your project and submit it to code repository next to your other source files.

"Single header" doesn't mean that everything is contained in C/C++ declarations,
like it tends to be in case of inline functions or C++ templates.
It means that implementation is bundled with interface in a single file and needs to be extracted using preprocessor macro.
If you don't do it properly, you will get linker errors.

To do it properly:

-# Include "vk_mem_alloc.h" file in each CPP file where you want to use the library.
   This includes declarations of all members of the library.
-# In exactly one CPP file define following macro before this include.
   It enables also internal definitions.

\code
#define VMA_IMPLEMENTATION
#include "vk_mem_alloc.h"
\endcode

It may be a good idea to create dedicated CPP file just for this purpose.

This library includes header `<vulkan/vulkan.h>`, which in turn
includes `<windows.h>` on Windows. If you need some specific macros defined
before including these headers (like `WIN32_LEAN_AND_MEAN` or
`WINVER` for Windows, `VK_USE_PLATFORM_WIN32_KHR` for Vulkan), you must define
them before every `#include` of this library.

This library is written in C++, but has C-compatible interface.
Thus you can include and use vk_mem_alloc.h in C or C++ code, but full
implementation with `VMA_IMPLEMENTATION` macro must be compiled as C++, NOT as C.
Some features of C++14 are used. STL containers, RTTI, or C++ exceptions are not used.


\section quick_start_initialization Initialization

At program startup:

-# Initialize Vulkan to have `VkPhysicalDevice`, `VkDevice` and `VkInstance` object.
-# Fill VmaAllocatorCreateInfo structure and create #VmaAllocator object by
   calling vmaCreateAllocator().

Only members `physicalDevice`, `device`, `instance` are required.
However, you should inform the library which Vulkan version do you use by setting
VmaAllocatorCreateInfo::vulkanApiVersion and which extensions did you enable
by setting VmaAllocatorCreateInfo::flags (like #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT for VK_KHR_buffer_device_address).
Otherwise, VMA would use only features of Vulkan 1.0 core with no extensions.

\subsection quick_start_initialization_selecting_vulkan_version Selecting Vulkan version

VMA supports Vulkan version down to 1.0, for backward compatibility.
If you want to use higher version, you need to inform the library about it.
This is a two-step process.

<b>Step 1: Compile time.</b> By default, VMA compiles with code supporting the highest
Vulkan version found in the included `<vulkan/vulkan.h>` that is also supported by the library.
If this is OK, you don't need to do anything.
However, if you want to compile VMA as if only some lower Vulkan version was available,
define macro `VMA_VULKAN_VERSION` before every `#include "vk_mem_alloc.h"`.
It should have decimal numeric value in form of ABBBCCC, where A = major, BBB = minor, CCC = patch Vulkan version.
For example, to compile against Vulkan 1.2:

\code
#define VMA_VULKAN_VERSION 1002000 // Vulkan 1.2
#include "vk_mem_alloc.h"
\endcode

<b>Step 2: Runtime.</b> Even when compiled with higher Vulkan version available,
VMA can use only features of a lower version, which is configurable during creation of the #VmaAllocator object.
By default, only Vulkan 1.0 is used.
To initialize the allocator with support for higher Vulkan version, you need to set member
VmaAllocatorCreateInfo::vulkanApiVersion to an appropriate value, e.g. using constants like `VK_API_VERSION_1_2`.
See code sample below.

\subsection quick_start_initialization_importing_vulkan_functions Importing Vulkan functions

You may need to configure importing Vulkan functions. There are 3 ways to do this:

-# **If you link with Vulkan static library** (e.g. "vulkan-1.lib" on Windows):
   - You don't need to do anything.
   - VMA will use these, as macro `VMA_STATIC_VULKAN_FUNCTIONS` is defined to 1 by default.
-# **If you want VMA to fetch pointers to Vulkan functions dynamically** using `vkGetInstanceProcAddr`,
   `vkGetDeviceProcAddr` (this is the option presented in the example below):
   - Define `VMA_STATIC_VULKAN_FUNCTIONS` to 0, `VMA_DYNAMIC_VULKAN_FUNCTIONS` to 1.
   - Provide pointers to these two functions via VmaVulkanFunctions::vkGetInstanceProcAddr,
     VmaVulkanFunctions::vkGetDeviceProcAddr.
   - The library will fetch pointers to all other functions it needs internally.
-# **If you fetch pointers to all Vulkan functions in a custom way**, e.g. using some loader like
   [Volk](https://github.com/zeux/volk):
   - Define `VMA_STATIC_VULKAN_FUNCTIONS` and `VMA_DYNAMIC_VULKAN_FUNCTIONS` to 0.
   - Pass these pointers via structure #VmaVulkanFunctions.

Example for case 2:

\code
#define VMA_STATIC_VULKAN_FUNCTIONS 0
#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
#include "vk_mem_alloc.h"

...

VmaVulkanFunctions vulkanFunctions = {};
vulkanFunctions.vkGetInstanceProcAddr = &vkGetInstanceProcAddr;
vulkanFunctions.vkGetDeviceProcAddr = &vkGetDeviceProcAddr;

VmaAllocatorCreateInfo allocatorCreateInfo = {};
allocatorCreateInfo.vulkanApiVersion = VK_API_VERSION_1_2;
allocatorCreateInfo.physicalDevice = physicalDevice;
allocatorCreateInfo.device = device;
allocatorCreateInfo.instance = instance;
allocatorCreateInfo.pVulkanFunctions = &vulkanFunctions;

VmaAllocator allocator;
vmaCreateAllocator(&allocatorCreateInfo, &allocator);
\endcode


\section quick_start_resource_allocation Resource allocation

When you want to create a buffer or image:

-# Fill `VkBufferCreateInfo` / `VkImageCreateInfo` structure.
-# Fill VmaAllocationCreateInfo structure.
-# Call vmaCreateBuffer() / vmaCreateImage() to get `VkBuffer`/`VkImage` with memory
   already allocated and bound to it, plus #VmaAllocation objects that represents its underlying memory.

\code
VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
bufferInfo.size = 65536;
bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;

VmaAllocationCreateInfo allocInfo = {};
allocInfo.usage = VMA_MEMORY_USAGE_AUTO;

VkBuffer buffer;
VmaAllocation allocation;
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
\endcode

Don't forget to destroy your objects when no longer needed:

\code
vmaDestroyBuffer(allocator, buffer, allocation);
vmaDestroyAllocator(allocator);
\endcode


\page choosing_memory_type Choosing memory type

Physical devices in Vulkan support various combinations of memory heaps and
types. Help with choosing correct and optimal memory type for your specific
resource is one of the key features of this library. You can use it by filling
appropriate members of VmaAllocationCreateInfo structure, as described below.
You can also combine multiple methods.

-# If you just want to find memory type index that meets your requirements, you
   can use function: vmaFindMemoryTypeIndexForBufferInfo(),
   vmaFindMemoryTypeIndexForImageInfo(), vmaFindMemoryTypeIndex().
-# If you want to allocate a region of device memory without association with any
   specific image or buffer, you can use function vmaAllocateMemory(). Usage of
   this function is not recommended and usually not needed.
   vmaAllocateMemoryPages() function is also provided for creating multiple allocations at once,
   which may be useful for sparse binding.
-# If you already have a buffer or an image created, you want to allocate memory
   for it and then you will bind it yourself, you can use function
   vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage().
   For binding you should use functions: vmaBindBufferMemory(), vmaBindImageMemory()
   or their extended versions: vmaBindBufferMemory2(), vmaBindImageMemory2().
-# **This is the easiest and recommended way to use this library:**
   If you want to create a buffer or an image, allocate memory for it and bind
   them together, all in one call, you can use function vmaCreateBuffer(),
   vmaCreateImage().

When using 3. or 4., the library internally queries Vulkan for memory types
supported for that buffer or image (function `vkGetBufferMemoryRequirements()`)
and uses only one of these types.

If no memory type can be found that meets all the requirements, these functions
return `VK_ERROR_FEATURE_NOT_PRESENT`.

You can leave VmaAllocationCreateInfo structure completely filled with zeros.
It means no requirements are specified for memory type.
It is valid, although not very useful.

\section choosing_memory_type_usage Usage

The easiest way to specify memory requirements is to fill member
VmaAllocationCreateInfo::usage using one of the values of enum #VmaMemoryUsage.
It defines high level, common usage types.
Since version 3 of the library, it is recommended to use #VMA_MEMORY_USAGE_AUTO to let it select best memory type for your resource automatically.

For example, if you want to create a uniform buffer that will be filled using
transfer only once or infrequently and then used for rendering every frame as a uniform buffer, you can
do it using following code. The buffer will most likely end up in a memory type with
`VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT` to be fast to access by the GPU device.

\code
VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
bufferInfo.size = 65536;
bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;

VmaAllocationCreateInfo allocInfo = {};
allocInfo.usage = VMA_MEMORY_USAGE_AUTO;

VkBuffer buffer;
VmaAllocation allocation;
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
\endcode

If you have a preference for putting the resource in GPU (device) memory or CPU (host) memory
on systems with discrete graphics card that have the memories separate, you can use
#VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE or #VMA_MEMORY_USAGE_AUTO_PREFER_HOST.

When using `VMA_MEMORY_USAGE_AUTO*` while you want to map the allocated memory,
you also need to specify one of the host access flags:
#VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.
This will help the library decide about preferred memory type to ensure it has `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`
so you can map it.

For example, a staging buffer that will be filled via mapped pointer and then
used as a source of transfer to the buffer described previously can be created like this.
It will likely end up in a memory type that is `HOST_VISIBLE` and `HOST_COHERENT`
but not `HOST_CACHED` (meaning uncached, write-combined) and not `DEVICE_LOCAL` (meaning system RAM).

\code
VkBufferCreateInfo stagingBufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
stagingBufferInfo.size = 65536;
stagingBufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;

VmaAllocationCreateInfo stagingAllocInfo = {};
stagingAllocInfo.usage = VMA_MEMORY_USAGE_AUTO;
stagingAllocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;

VkBuffer stagingBuffer;
VmaAllocation stagingAllocation;
vmaCreateBuffer(allocator, &stagingBufferInfo, &stagingAllocInfo, &stagingBuffer, &stagingAllocation, nullptr);
\endcode

For more examples of creating different kinds of resources, see chapter \ref usage_patterns.

Usage values `VMA_MEMORY_USAGE_AUTO*` are legal to use only when the library knows
about the resource being created by having `VkBufferCreateInfo` / `VkImageCreateInfo` passed,
so they work with functions like: vmaCreateBuffer(), vmaCreateImage(), vmaFindMemoryTypeIndexForBufferInfo() etc.
If you allocate raw memory using function vmaAllocateMemory(), you have to use other means of selecting
memory type, as described below.

\note
Old usage values (`VMA_MEMORY_USAGE_GPU_ONLY`, `VMA_MEMORY_USAGE_CPU_ONLY`,
`VMA_MEMORY_USAGE_CPU_TO_GPU`, `VMA_MEMORY_USAGE_GPU_TO_CPU`, `VMA_MEMORY_USAGE_CPU_COPY`)
are still available and work same way as in previous versions of the library
for backward compatibility, but they are not recommended.

\section choosing_memory_type_required_preferred_flags Required and preferred flags

You can specify more detailed requirements by filling members
VmaAllocationCreateInfo::requiredFlags and VmaAllocationCreateInfo::preferredFlags
with a combination of bits from enum `VkMemoryPropertyFlags`. For example,
if you want to create a buffer that will be persistently mapped on host (so it
must be `HOST_VISIBLE`) and preferably will also be `HOST_COHERENT` and `HOST_CACHED`,
use following code:

\code
VmaAllocationCreateInfo allocInfo = {};
allocInfo.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
allocInfo.preferredFlags = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
allocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT;

VkBuffer buffer;
VmaAllocation allocation;
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
\endcode

A memory type is chosen that has all the required flags and as many preferred
flags set as possible.

Value passed in VmaAllocationCreateInfo::usage is internally converted to a set of required and preferred flags,
plus some extra "magic" (heuristics).

\section choosing_memory_type_explicit_memory_types Explicit memory types

If you inspected memory types available on the physical device and you have
a preference for memory types that you want to use, you can fill member
VmaAllocationCreateInfo::memoryTypeBits. It is a bit mask, where each bit set
means that a memory type with that index is allowed to be used for the
allocation. Special value 0, just like `UINT32_MAX`, means there are no
restrictions to memory type index.

Please note that this member is NOT just a memory type index.
Still you can use it to choose just one, specific memory type.
For example, if you already determined that your buffer should be created in
memory type 2, use following code:

\code
uint32_t memoryTypeIndex = 2;

VmaAllocationCreateInfo allocInfo = {};
allocInfo.memoryTypeBits = 1u << memoryTypeIndex;

VkBuffer buffer;
VmaAllocation allocation;
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
\endcode


\section choosing_memory_type_custom_memory_pools Custom memory pools

If you allocate from custom memory pool, all the ways of specifying memory
requirements described above are not applicable and the aforementioned members
of VmaAllocationCreateInfo structure are ignored. Memory type is selected
explicitly when creating the pool and then used to make all the allocations from
that pool. For further details, see \ref custom_memory_pools.

\section choosing_memory_type_dedicated_allocations Dedicated allocations

Memory for allocations is reserved out of larger block of `VkDeviceMemory`
allocated from Vulkan internally. That is the main feature of this whole library.
You can still request a separate memory block to be created for an allocation,
just like you would do in a trivial solution without using any allocator.
In that case, a buffer or image is always bound to that memory at offset 0.
This is called a "dedicated allocation".
You can explicitly request it by using flag #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
The library can also internally decide to use dedicated allocation in some cases, e.g.:

- When the size of the allocation is large.
- When [VK_KHR_dedicated_allocation](@ref vk_khr_dedicated_allocation) extension is enabled
  and it reports that dedicated allocation is required or recommended for the resource.
- When allocation of next big memory block fails due to not enough device memory,
  but allocation with the exact requested size succeeds.


\page memory_mapping Memory mapping

To "map memory" in Vulkan means to obtain a CPU pointer to `VkDeviceMemory`,
to be able to read from it or write to it in CPU code.
Mapping is possible only of memory allocated from a memory type that has
`VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` flag.
Functions `vkMapMemory()`, `vkUnmapMemory()` are designed for this purpose.
You can use them directly with memory allocated by this library,
but it is not recommended because of following issue:
Mapping the same `VkDeviceMemory` block multiple times is illegal - only one mapping at a time is allowed.
This includes mapping disjoint regions. Mapping is not reference-counted internally by Vulkan.
Because of this, Vulkan Memory Allocator provides following facilities:

\note If you want to be able to map an allocation, you need to specify one of the flags
#VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
in VmaAllocationCreateInfo::flags. These flags are required for an allocation to be mappable
when using #VMA_MEMORY_USAGE_AUTO or other `VMA_MEMORY_USAGE_AUTO*` enum values.
For other usage values they are ignored and every such allocation made in `HOST_VISIBLE` memory type is mappable,
but they can still be used for consistency.

\section memory_mapping_mapping_functions Mapping functions

The library provides following functions for mapping of a specific #VmaAllocation: vmaMapMemory(), vmaUnmapMemory().
They are safer and more convenient to use than standard Vulkan functions.
You can map an allocation multiple times simultaneously - mapping is reference-counted internally.
You can also map different allocations simultaneously regardless of whether they use the same `VkDeviceMemory` block.
The way it is implemented is that the library always maps entire memory block, not just region of the allocation.
For further details, see description of vmaMapMemory() function.
Example:

\code
// Having these objects initialized:
struct ConstantBuffer
{
    ...
};
ConstantBuffer constantBufferData = ...

VmaAllocator allocator = ...
VkBuffer constantBuffer = ...
VmaAllocation constantBufferAllocation = ...

// You can map and fill your buffer using following code:

void* mappedData;
vmaMapMemory(allocator, constantBufferAllocation, &mappedData);
memcpy(mappedData, &constantBufferData, sizeof(constantBufferData));
vmaUnmapMemory(allocator, constantBufferAllocation);
\endcode

When mapping, you may see a warning from Vulkan validation layer similar to this one:

<i>Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.</i>

It happens because the library maps entire `VkDeviceMemory` block, where different
types of images and buffers may end up together, especially on GPUs with unified memory like Intel.
You can safely ignore it if you are sure you access only memory of the intended
object that you wanted to map.


\section memory_mapping_persistently_mapped_memory Persistently mapped memory

Keeping your memory persistently mapped is generally OK in Vulkan.
You don't need to unmap it before using its data on the GPU.
The library provides a special feature designed for that:
Allocations made with #VMA_ALLOCATION_CREATE_MAPPED_BIT flag set in
VmaAllocationCreateInfo::flags stay mapped all the time,
so you can just access CPU pointer to it any time
without a need to call any "map" or "unmap" function.
Example:

\code
VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
bufCreateInfo.size = sizeof(ConstantBuffer);
bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
    VMA_ALLOCATION_CREATE_MAPPED_BIT;

VkBuffer buf;
VmaAllocation alloc;
VmaAllocationInfo allocInfo;
vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

// Buffer is already mapped. You can access its memory.
memcpy(allocInfo.pMappedData, &constantBufferData, sizeof(constantBufferData));
\endcode

\note #VMA_ALLOCATION_CREATE_MAPPED_BIT by itself doesn't guarantee that the allocation will end up
in a mappable memory type.
For this, you need to also specify #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or
#VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.
#VMA_ALLOCATION_CREATE_MAPPED_BIT only guarantees that if the memory is `HOST_VISIBLE`, the allocation will be mapped on creation.
For an example of how to make use of this fact, see section \ref usage_patterns_advanced_data_uploading.

\section memory_mapping_cache_control Cache flush and invalidate

Memory in Vulkan doesn't need to be unmapped before using it on GPU,
but unless a memory types has `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT` flag set,
you need to manually **invalidate** cache before reading of mapped pointer
and **flush** cache after writing to mapped pointer.
Map/unmap operations don't do that automatically.
Vulkan provides following functions for this purpose `vkFlushMappedMemoryRanges()`,
`vkInvalidateMappedMemoryRanges()`, but this library provides more convenient
functions that refer to given allocation object: vmaFlushAllocation(),
vmaInvalidateAllocation(),
or multiple objects at once: vmaFlushAllocations(), vmaInvalidateAllocations().

Regions of memory specified for flush/invalidate must be aligned to
`VkPhysicalDeviceLimits::nonCoherentAtomSize`. This is automatically ensured by the library.
In any memory type that is `HOST_VISIBLE` but not `HOST_COHERENT`, all allocations
within blocks are aligned to this value, so their offsets are always multiply of
`nonCoherentAtomSize` and two different allocations never share same "line" of this size.

Also, Windows drivers from all 3 PC GPU vendors (AMD, Intel, NVIDIA)
currently provide `HOST_COHERENT` flag on all memory types that are
`HOST_VISIBLE`, so on PC you may not need to bother.


\page staying_within_budget Staying within budget

When developing a graphics-intensive game or program, it is important to avoid allocating
more GPU memory than it is physically available. When the memory is over-committed,
various bad things can happen, depending on the specific GPU, graphics driver, and
operating system:

- It may just work without any problems.
- The application may slow down because some memory blocks are moved to system RAM
  and the GPU has to access them through PCI Express bus.
- A new allocation may take very long time to complete, even few seconds, and possibly
  freeze entire system.
- The new allocation may fail with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
- It may even result in GPU crash (TDR), observed as `VK_ERROR_DEVICE_LOST`
  returned somewhere later.

\section staying_within_budget_querying_for_budget Querying for budget

To query for current memory usage and available budget, use function vmaGetHeapBudgets().
Returned structure #VmaBudget contains quantities expressed in bytes, per Vulkan memory heap.

Please note that this function returns different information and works faster than
vmaCalculateStatistics(). vmaGetHeapBudgets() can be called every frame or even before every
allocation, while vmaCalculateStatistics() is intended to be used rarely,
only to obtain statistical information, e.g. for debugging purposes.

It is recommended to use <b>VK_EXT_memory_budget</b> device extension to obtain information
about the budget from Vulkan device. VMA is able to use this extension automatically.
When not enabled, the allocator behaves same way, but then it estimates current usage
and available budget based on its internal information and Vulkan memory heap sizes,
which may be less precise. In order to use this extension:

1. Make sure extensions VK_EXT_memory_budget and VK_KHR_get_physical_device_properties2
   required by it are available and enable them. Please note that the first is a device
   extension and the second is instance extension!
2. Use flag #VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT when creating #VmaAllocator object.
3. Make sure to call vmaSetCurrentFrameIndex() every frame. Budget is queried from
   Vulkan inside of it to avoid overhead of querying it with every allocation.

\section staying_within_budget_controlling_memory_usage Controlling memory usage

There are many ways in which you can try to stay within the budget.

First, when making new allocation requires allocating a new memory block, the library
tries not to exceed the budget automatically. If a block with default recommended size
(e.g. 256 MB) would go over budget, a smaller block is allocated, possibly even
dedicated memory for just this resource.

If the size of the requested resource plus current memory usage is more than the
budget, by default the library still tries to create it, leaving it to the Vulkan
implementation whether the allocation succeeds or fails. You can change this behavior
by using #VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT flag. With it, the allocation is
not made if it would exceed the budget or if the budget is already exceeded.
VMA then tries to make the allocation from the next eligible Vulkan memory type.
The all of them fail, the call then fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
Example usage pattern may be to pass the #VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT flag
when creating resources that are not essential for the application (e.g. the texture
of a specific object) and not to pass it when creating critically important resources
(e.g. render targets).

On AMD graphics cards there is a custom vendor extension available: <b>VK_AMD_memory_overallocation_behavior</b>
that allows to control the behavior of the Vulkan implementation in out-of-memory cases -
whether it should fail with an error code or still allow the allocation.
Usage of this extension involves only passing extra structure on Vulkan device creation,
so it is out of scope of this library.

Finally, you can also use #VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT flag to make sure
a new allocation is created only when it fits inside one of the existing memory blocks.
If it would require to allocate a new block, if fails instead with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
This also ensures that the function call is very fast because it never goes to Vulkan
to obtain a new block.

\note Creating \ref custom_memory_pools with VmaPoolCreateInfo::minBlockCount
set to more than 0 will currently try to allocate memory blocks without checking whether they
fit within budget.


\page resource_aliasing Resource aliasing (overlap)

New explicit graphics APIs (Vulkan and Direct3D 12), thanks to manual memory
management, give an opportunity to alias (overlap) multiple resources in the
same region of memory - a feature not available in the old APIs (Direct3D 11, OpenGL).
It can be useful to save video memory, but it must be used with caution.

For example, if you know the flow of your whole render frame in advance, you
are going to use some intermediate textures or buffers only during a small range of render passes,
and you know these ranges don't overlap in time, you can bind these resources to
the same place in memory, even if they have completely different parameters (width, height, format etc.).

![Resource aliasing (overlap)](../gfx/Aliasing.png)

Such scenario is possible using VMA, but you need to create your images manually.
Then you need to calculate parameters of an allocation to be made using formula:

- allocation size = max(size of each image)
- allocation alignment = max(alignment of each image)
- allocation memoryTypeBits = bitwise AND(memoryTypeBits of each image)

Following example shows two different images bound to the same place in memory,
allocated to fit largest of them.

\code
// A 512x512 texture to be sampled.
VkImageCreateInfo img1CreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
img1CreateInfo.imageType = VK_IMAGE_TYPE_2D;
img1CreateInfo.extent.width = 512;
img1CreateInfo.extent.height = 512;
img1CreateInfo.extent.depth = 1;
img1CreateInfo.mipLevels = 10;
img1CreateInfo.arrayLayers = 1;
img1CreateInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
img1CreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
img1CreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
img1CreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
img1CreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;

// A full screen texture to be used as color attachment.
VkImageCreateInfo img2CreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
img2CreateInfo.imageType = VK_IMAGE_TYPE_2D;
img2CreateInfo.extent.width = 1920;
img2CreateInfo.extent.height = 1080;
img2CreateInfo.extent.depth = 1;
img2CreateInfo.mipLevels = 1;
img2CreateInfo.arrayLayers = 1;
img2CreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
img2CreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
img2CreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
img2CreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
img2CreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;

VkImage img1;
res = vkCreateImage(device, &img1CreateInfo, nullptr, &img1);
VkImage img2;
res = vkCreateImage(device, &img2CreateInfo, nullptr, &img2);

VkMemoryRequirements img1MemReq;
vkGetImageMemoryRequirements(device, img1, &img1MemReq);
VkMemoryRequirements img2MemReq;
vkGetImageMemoryRequirements(device, img2, &img2MemReq);

VkMemoryRequirements finalMemReq = {};
finalMemReq.size = std::max(img1MemReq.size, img2MemReq.size);
finalMemReq.alignment = std::max(img1MemReq.alignment, img2MemReq.alignment);
finalMemReq.memoryTypeBits = img1MemReq.memoryTypeBits & img2MemReq.memoryTypeBits;
// Validate if(finalMemReq.memoryTypeBits != 0)

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.preferredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;

VmaAllocation alloc;
res = vmaAllocateMemory(allocator, &finalMemReq, &allocCreateInfo, &alloc, nullptr);

res = vmaBindImageMemory(allocator, alloc, img1);
res = vmaBindImageMemory(allocator, alloc, img2);

// You can use img1, img2 here, but not at the same time!

vmaFreeMemory(allocator, alloc);
vkDestroyImage(allocator, img2, nullptr);
vkDestroyImage(allocator, img1, nullptr);
\endcode

Remember that using resources that alias in memory requires proper synchronization.
You need to issue a memory barrier to make sure commands that use `img1` and `img2`
don't overlap on GPU timeline.
You also need to treat a resource after aliasing as uninitialized - containing garbage data.
For example, if you use `img1` and then want to use `img2`, you need to issue
an image memory barrier for `img2` with `oldLayout` = `VK_IMAGE_LAYOUT_UNDEFINED`.

Additional considerations:

- Vulkan also allows to interpret contents of memory between aliasing resources consistently in some cases.
See chapter 11.8. "Memory Aliasing" of Vulkan specification or `VK_IMAGE_CREATE_ALIAS_BIT` flag.
- You can create more complex layout where different images and buffers are bound
at different offsets inside one large allocation. For example, one can imagine
a big texture used in some render passes, aliasing with a set of many small buffers
used between in some further passes. To bind a resource at non-zero offset in an allocation,
use vmaBindBufferMemory2() / vmaBindImageMemory2().
- Before allocating memory for the resources you want to alias, check `memoryTypeBits`
returned in memory requirements of each resource to make sure the bits overlap.
Some GPUs may expose multiple memory types suitable e.g. only for buffers or
images with `COLOR_ATTACHMENT` usage, so the sets of memory types supported by your
resources may be disjoint. Aliasing them is not possible in that case.


\page custom_memory_pools Custom memory pools

A memory pool contains a number of `VkDeviceMemory` blocks.
The library automatically creates and manages default pool for each memory type available on the device.
Default memory pool automatically grows in size.
Size of allocated blocks is also variable and managed automatically.

You can create custom pool and allocate memory out of it.
It can be useful if you want to:

- Keep certain kind of allocations separate from others.
- Enforce particular, fixed size of Vulkan memory blocks.
- Limit maximum amount of Vulkan memory allocated for that pool.
- Reserve minimum or fixed amount of Vulkan memory always preallocated for that pool.
- Use extra parameters for a set of your allocations that are available in #VmaPoolCreateInfo but not in
  #VmaAllocationCreateInfo - e.g., custom minimum alignment, custom `pNext` chain.
- Perform defragmentation on a specific subset of your allocations.

To use custom memory pools:

-# Fill VmaPoolCreateInfo structure.
-# Call vmaCreatePool() to obtain #VmaPool handle.
-# When making an allocation, set VmaAllocationCreateInfo::pool to this handle.
   You don't need to specify any other parameters of this structure, like `usage`.

Example:

\code
// Find memoryTypeIndex for the pool.
VkBufferCreateInfo sampleBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
sampleBufCreateInfo.size = 0x10000; // Doesn't matter.
sampleBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;

VmaAllocationCreateInfo sampleAllocCreateInfo = {};
sampleAllocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;

uint32_t memTypeIndex;
VkResult res = vmaFindMemoryTypeIndexForBufferInfo(allocator,
    &sampleBufCreateInfo, &sampleAllocCreateInfo, &memTypeIndex);
// Check res...

// Create a pool that can have at most 2 blocks, 128 MiB each.
VmaPoolCreateInfo poolCreateInfo = {};
poolCreateInfo.memoryTypeIndex = memTypeIndex;
poolCreateInfo.blockSize = 128ull * 1024 * 1024;
poolCreateInfo.maxBlockCount = 2;

VmaPool pool;
res = vmaCreatePool(allocator, &poolCreateInfo, &pool);
// Check res...

// Allocate a buffer out of it.
VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
bufCreateInfo.size = 1024;
bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.pool = pool;

VkBuffer buf;
VmaAllocation alloc;
res = vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, nullptr);
// Check res...
\endcode

You have to free all allocations made from this pool before destroying it.

\code
vmaDestroyBuffer(allocator, buf, alloc);
vmaDestroyPool(allocator, pool);
\endcode

New versions of this library support creating dedicated allocations in custom pools.
It is supported only when VmaPoolCreateInfo::blockSize = 0.
To use this feature, set VmaAllocationCreateInfo::pool to the pointer to your custom pool and
VmaAllocationCreateInfo::flags to #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.

\note Excessive use of custom pools is a common mistake when using this library.
Custom pools may be useful for special purposes - when you want to
keep certain type of resources separate e.g. to reserve minimum amount of memory
for them or limit maximum amount of memory they can occupy. For most
resources this is not needed and so it is not recommended to create #VmaPool
objects and allocations out of them. Allocating from the default pool is sufficient.


\section custom_memory_pools_MemTypeIndex Choosing memory type index

When creating a pool, you must explicitly specify memory type index.
To find the one suitable for your buffers or images, you can use helper functions
vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo().
You need to provide structures with example parameters of buffers or images
that you are going to create in that pool.

\code
VkBufferCreateInfo exampleBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
exampleBufCreateInfo.size = 1024; // Doesn't matter
exampleBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;

uint32_t memTypeIndex;
vmaFindMemoryTypeIndexForBufferInfo(allocator, &exampleBufCreateInfo, &allocCreateInfo, &memTypeIndex);

VmaPoolCreateInfo poolCreateInfo = {};
poolCreateInfo.memoryTypeIndex = memTypeIndex;
// ...
\endcode

When creating buffers/images allocated in that pool, provide following parameters:

- `VkBufferCreateInfo`: Prefer to pass same parameters as above.
  Otherwise you risk creating resources in a memory type that is not suitable for them, which may result in undefined behavior.
  Using different `VK_BUFFER_USAGE_` flags may work, but you shouldn't create images in a pool intended for buffers
  or the other way around.
- VmaAllocationCreateInfo: You don't need to pass same parameters. Fill only `pool` member.
  Other members are ignored anyway.

\section linear_algorithm Linear allocation algorithm

Each Vulkan memory block managed by this library has accompanying metadata that
keeps track of used and unused regions. By default, the metadata structure and
algorithm tries to find best place for new allocations among free regions to
optimize memory usage. This way you can allocate and free objects in any order.

![Default allocation algorithm](../gfx/Linear_allocator_1_algo_default.png)

Sometimes there is a need to use simpler, linear allocation algorithm. You can
create custom pool that uses such algorithm by adding flag
#VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT to VmaPoolCreateInfo::flags while creating
#VmaPool object. Then an alternative metadata management is used. It always
creates new allocations after last one and doesn't reuse free regions after
allocations freed in the middle. It results in better allocation performance and
less memory consumed by metadata.

![Linear allocation algorithm](../gfx/Linear_allocator_2_algo_linear.png)

With this one flag, you can create a custom pool that can be used in many ways:
free-at-once, stack, double stack, and ring buffer. See below for details.
You don't need to specify explicitly which of these options you are going to use - it is detected automatically.

\subsection linear_algorithm_free_at_once Free-at-once

In a pool that uses linear algorithm, you still need to free all the allocations
individually, e.g. by using vmaFreeMemory() or vmaDestroyBuffer(). You can free
them in any order. New allocations are always made after last one - free space
in the middle is not reused. However, when you release all the allocation and
the pool becomes empty, allocation starts from the beginning again. This way you
can use linear algorithm to speed up creation of allocations that you are going
to release all at once.

![Free-at-once](../gfx/Linear_allocator_3_free_at_once.png)

This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount
value that allows multiple memory blocks.

\subsection linear_algorithm_stack Stack

When you free an allocation that was created last, its space can be reused.
Thanks to this, if you always release allocations in the order opposite to their
creation (LIFO - Last In First Out), you can achieve behavior of a stack.

![Stack](../gfx/Linear_allocator_4_stack.png)

This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount
value that allows multiple memory blocks.

\subsection linear_algorithm_double_stack Double stack

The space reserved by a custom pool with linear algorithm may be used by two
stacks:

- First, default one, growing up from offset 0.
- Second, "upper" one, growing down from the end towards lower offsets.

To make allocation from the upper stack, add flag #VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
to VmaAllocationCreateInfo::flags.

![Double stack](../gfx/Linear_allocator_7_double_stack.png)

Double stack is available only in pools with one memory block -
VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.

When the two stacks' ends meet so there is not enough space between them for a
new allocation, such allocation fails with usual
`VK_ERROR_OUT_OF_DEVICE_MEMORY` error.

\subsection linear_algorithm_ring_buffer Ring buffer

When you free some allocations from the beginning and there is not enough free space
for a new one at the end of a pool, allocator's "cursor" wraps around to the
beginning and starts allocation there. Thanks to this, if you always release
allocations in the same order as you created them (FIFO - First In First Out),
you can achieve behavior of a ring buffer / queue.

![Ring buffer](../gfx/Linear_allocator_5_ring_buffer.png)

Ring buffer is available only in pools with one memory block -
VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.

\note \ref defragmentation is not supported in custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT.


\page defragmentation Defragmentation

Interleaved allocations and deallocations of many objects of varying size can
cause fragmentation over time, which can lead to a situation where the library is unable
to find a continuous range of free memory for a new allocation despite there is
enough free space, just scattered across many small free ranges between existing
allocations.

To mitigate this problem, you can use defragmentation feature.
It doesn't happen automatically though and needs your cooperation,
because VMA is a low level library that only allocates memory.
It cannot recreate buffers and images in a new place as it doesn't remember the contents of `VkBufferCreateInfo` / `VkImageCreateInfo` structures.
It cannot copy their contents as it doesn't record any commands to a command buffer.

Example:

\code
VmaDefragmentationInfo defragInfo = {};
defragInfo.pool = myPool;
defragInfo.flags = VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT;

VmaDefragmentationContext defragCtx;
VkResult res = vmaBeginDefragmentation(allocator, &defragInfo, &defragCtx);
// Check res...

for(;;)
{
    VmaDefragmentationPassMoveInfo pass;
    res = vmaBeginDefragmentationPass(allocator, defragCtx, &pass);
    if(res == VK_SUCCESS)
        break;
    else if(res != VK_INCOMPLETE)
        // Handle error...

    for(uint32_t i = 0; i < pass.moveCount; ++i)
    {
        // Inspect pass.pMoves[i].srcAllocation, identify what buffer/image it represents.
        VmaAllocationInfo allocInfo;
        vmaGetAllocationInfo(allocator, pass.pMoves[i].srcAllocation, &allocInfo);
        MyEngineResourceData* resData = (MyEngineResourceData*)allocInfo.pUserData;

        // Recreate and bind this buffer/image at: pass.pMoves[i].dstMemory, pass.pMoves[i].dstOffset.
        VkImageCreateInfo imgCreateInfo = ...
        VkImage newImg;
        res = vkCreateImage(device, &imgCreateInfo, nullptr, &newImg);
        // Check res...
        res = vmaBindImageMemory(allocator, pass.pMoves[i].dstTmpAllocation, newImg);
        // Check res...

        // Issue a vkCmdCopyBuffer/vkCmdCopyImage to copy its content to the new place.
        vkCmdCopyImage(cmdBuf, resData->img, ..., newImg, ...);
    }

    // Make sure the copy commands finished executing.
    vkWaitForFences(...);

    // Destroy old buffers/images bound with pass.pMoves[i].srcAllocation.
    for(uint32_t i = 0; i < pass.moveCount; ++i)
    {
        // ...
        vkDestroyImage(device, resData->img, nullptr);
    }

    // Update appropriate descriptors to point to the new places...

    res = vmaEndDefragmentationPass(allocator, defragCtx, &pass);
    if(res == VK_SUCCESS)
        break;
    else if(res != VK_INCOMPLETE)
        // Handle error...
}

vmaEndDefragmentation(allocator, defragCtx, nullptr);
\endcode

Although functions like vmaCreateBuffer(), vmaCreateImage(), vmaDestroyBuffer(), vmaDestroyImage()
create/destroy an allocation and a buffer/image at once, these are just a shortcut for
creating the resource, allocating memory, and binding them together.
Defragmentation works on memory allocations only. You must handle the rest manually.
Defragmentation is an iterative process that should repreat "passes" as long as related functions
return `VK_INCOMPLETE` not `VK_SUCCESS`.
In each pass:

1. vmaBeginDefragmentationPass() function call:
   - Calculates and returns the list of allocations to be moved in this pass.
     Note this can be a time-consuming process.
   - Reserves destination memory for them by creating temporary destination allocations
     that you can query for their `VkDeviceMemory` + offset using vmaGetAllocationInfo().
2. Inside the pass, **you should**:
   - Inspect the returned list of allocations to be moved.
   - Create new buffers/images and bind them at the returned destination temporary allocations.
   - Copy data from source to destination resources if necessary.
   - Destroy the source buffers/images, but NOT their allocations.
3. vmaEndDefragmentationPass() function call:
   - Frees the source memory reserved for the allocations that are moved.
   - Modifies source #VmaAllocation objects that are moved to point to the destination reserved memory.
   - Frees `VkDeviceMemory` blocks that became empty.

Unlike in previous iterations of the defragmentation API, there is no list of "movable" allocations passed as a parameter.
Defragmentation algorithm tries to move all suitable allocations.
You can, however, refuse to move some of them inside a defragmentation pass, by setting
`pass.pMoves[i].operation` to #VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE.
This is not recommended and may result in suboptimal packing of the allocations after defragmentation.
If you cannot ensure any allocation can be moved, it is better to keep movable allocations separate in a custom pool.

Inside a pass, for each allocation that should be moved:

- You should copy its data from the source to the destination place by calling e.g. `vkCmdCopyBuffer()`, `vkCmdCopyImage()`.
  - You need to make sure these commands finished executing before destroying the source buffers/images and before calling vmaEndDefragmentationPass().
- If a resource doesn't contain any meaningful data, e.g. it is a transient color attachment image to be cleared,
  filled, and used temporarily in each rendering frame, you can just recreate this image
  without copying its data.
- If the resource is in `HOST_VISIBLE` and `HOST_CACHED` memory, you can copy its data on the CPU
  using `memcpy()`.
- If you cannot move the allocation, you can set `pass.pMoves[i].operation` to #VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE.
  This will cancel the move.
  - vmaEndDefragmentationPass() will then free the destination memory
    not the source memory of the allocation, leaving it unchanged.
- If you decide the allocation is unimportant and can be destroyed instead of moved (e.g. it wasn't used for long time),
  you can set `pass.pMoves[i].operation` to #VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY.
  - vmaEndDefragmentationPass() will then free both source and destination memory, and will destroy the source #VmaAllocation object.

You can defragment a specific custom pool by setting VmaDefragmentationInfo::pool
(like in the example above) or all the default pools by setting this member to null.

Defragmentation is always performed in each pool separately.
Allocations are never moved between different Vulkan memory types.
The size of the destination memory reserved for a moved allocation is the same as the original one.
Alignment of an allocation as it was determined using `vkGetBufferMemoryRequirements()` etc. is also respected after defragmentation.
Buffers/images should be recreated with the same `VkBufferCreateInfo` / `VkImageCreateInfo` parameters as the original ones.

You can perform the defragmentation incrementally to limit the number of allocations and bytes to be moved
in each pass, e.g. to call it in sync with render frames and not to experience too big hitches.
See members: VmaDefragmentationInfo::maxBytesPerPass, VmaDefragmentationInfo::maxAllocationsPerPass.

It is also safe to perform the defragmentation asynchronously to render frames and other Vulkan and VMA
usage, possibly from multiple threads, with the exception that allocations
returned in VmaDefragmentationPassMoveInfo::pMoves shouldn't be destroyed until the defragmentation pass is ended.

<b>Mapping</b> is preserved on allocations that are moved during defragmentation.
Whether through #VMA_ALLOCATION_CREATE_MAPPED_BIT or vmaMapMemory(), the allocations
are mapped at their new place. Of course, pointer to the mapped data changes, so it needs to be queried
using VmaAllocationInfo::pMappedData.

\note Defragmentation is not supported in custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT.


\page statistics Statistics

This library contains several functions that return information about its internal state,
especially the amount of memory allocated from Vulkan.

\section statistics_numeric_statistics Numeric statistics

If you need to obtain basic statistics about memory usage per heap, together with current budget,
you can call function vmaGetHeapBudgets() and inspect structure #VmaBudget.
This is useful to keep track of memory usage and stay within budget
(see also \ref staying_within_budget).
Example:

\code
uint32_t heapIndex = ...

VmaBudget budgets[VK_MAX_MEMORY_HEAPS];
vmaGetHeapBudgets(allocator, budgets);

printf("My heap currently has %u allocations taking %llu B,\n",
    budgets[heapIndex].statistics.allocationCount,
    budgets[heapIndex].statistics.allocationBytes);
printf("allocated out of %u Vulkan device memory blocks taking %llu B,\n",
    budgets[heapIndex].statistics.blockCount,
    budgets[heapIndex].statistics.blockBytes);
printf("Vulkan reports total usage %llu B with budget %llu B.\n",
    budgets[heapIndex].usage,
    budgets[heapIndex].budget);
\endcode

You can query for more detailed statistics per memory heap, type, and totals,
including minimum and maximum allocation size and unused range size,
by calling function vmaCalculateStatistics() and inspecting structure #VmaTotalStatistics.
This function is slower though, as it has to traverse all the internal data structures,
so it should be used only for debugging purposes.

You can query for statistics of a custom pool using function vmaGetPoolStatistics()
or vmaCalculatePoolStatistics().

You can query for information about a specific allocation using function vmaGetAllocationInfo().
It fill structure #VmaAllocationInfo.

\section statistics_json_dump JSON dump

You can dump internal state of the allocator to a string in JSON format using function vmaBuildStatsString().
The result is guaranteed to be correct JSON.
It uses ANSI encoding.
Any strings provided by user (see [Allocation names](@ref allocation_names))
are copied as-is and properly escaped for JSON, so if they use UTF-8, ISO-8859-2 or any other encoding,
this JSON string can be treated as using this encoding.
It must be freed using function vmaFreeStatsString().

The format of this JSON string is not part of official documentation of the library,
but it will not change in backward-incompatible way without increasing library major version number
and appropriate mention in changelog.

The JSON string contains all the data that can be obtained using vmaCalculateStatistics().
It can also contain detailed map of allocated memory blocks and their regions -
free and occupied by allocations.
This allows e.g. to visualize the memory or assess fragmentation.


\page allocation_annotation Allocation names and user data

\section allocation_user_data Allocation user data

You can annotate allocations with your own information, e.g. for debugging purposes.
To do that, fill VmaAllocationCreateInfo::pUserData field when creating
an allocation. It is an opaque `void*` pointer. You can use it e.g. as a pointer,
some handle, index, key, ordinal number or any other value that would associate
the allocation with your custom metadata.
It is useful to identify appropriate data structures in your engine given #VmaAllocation,
e.g. when doing \ref defragmentation.

\code
VkBufferCreateInfo bufCreateInfo = ...

MyBufferMetadata* pMetadata = CreateBufferMetadata();

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
allocCreateInfo.pUserData = pMetadata;

VkBuffer buffer;
VmaAllocation allocation;
vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buffer, &allocation, nullptr);
\endcode

The pointer may be later retrieved as VmaAllocationInfo::pUserData:

\code
VmaAllocationInfo allocInfo;
vmaGetAllocationInfo(allocator, allocation, &allocInfo);
MyBufferMetadata* pMetadata = (MyBufferMetadata*)allocInfo.pUserData;
\endcode

It can also be changed using function vmaSetAllocationUserData().

Values of (non-zero) allocations' `pUserData` are printed in JSON report created by
vmaBuildStatsString() in hexadecimal form.

\section allocation_names Allocation names

An allocation can also carry a null-terminated string, giving a name to the allocation.
To set it, call vmaSetAllocationName().
The library creates internal copy of the string, so the pointer you pass doesn't need
to be valid for whole lifetime of the allocation. You can free it after the call.

\code
std::string imageName = "Texture: ";
imageName += fileName;
vmaSetAllocationName(allocator, allocation, imageName.c_str());
\endcode

The string can be later retrieved by inspecting VmaAllocationInfo::pName.
It is also printed in JSON report created by vmaBuildStatsString().

\note Setting string name to VMA allocation doesn't automatically set it to the Vulkan buffer or image created with it.
You must do it manually using an extension like VK_EXT_debug_utils, which is independent of this library.


\page virtual_allocator Virtual allocator

As an extra feature, the core allocation algorithm of the library is exposed through a simple and convenient API of "virtual allocator".
It doesn't allocate any real GPU memory. It just keeps track of used and free regions of a "virtual block".
You can use it to allocate your own memory or other objects, even completely unrelated to Vulkan.
A common use case is sub-allocation of pieces of one large GPU buffer.

\section virtual_allocator_creating_virtual_block Creating virtual block

To use this functionality, there is no main "allocator" object.
You don't need to have #VmaAllocator object created.
All you need to do is to create a separate #VmaVirtualBlock object for each block of memory you want to be managed by the allocator:

-# Fill in #VmaVirtualBlockCreateInfo structure.
-# Call vmaCreateVirtualBlock(). Get new #VmaVirtualBlock object.

Example:

\code
VmaVirtualBlockCreateInfo blockCreateInfo = {};
blockCreateInfo.size = 1048576; // 1 MB

VmaVirtualBlock block;
VkResult res = vmaCreateVirtualBlock(&blockCreateInfo, &block);
\endcode

\section virtual_allocator_making_virtual_allocations Making virtual allocations

#VmaVirtualBlock object contains internal data structure that keeps track of free and occupied regions
using the same code as the main Vulkan memory allocator.
Similarly to #VmaAllocation for standard GPU allocations, there is #VmaVirtualAllocation type
that represents an opaque handle to an allocation within the virtual block.

In order to make such allocation:

-# Fill in #VmaVirtualAllocationCreateInfo structure.
-# Call vmaVirtualAllocate(). Get new #VmaVirtualAllocation object that represents the allocation.
   You can also receive `VkDeviceSize offset` that was assigned to the allocation.

Example:

\code
VmaVirtualAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.size = 4096; // 4 KB

VmaVirtualAllocation alloc;
VkDeviceSize offset;
res = vmaVirtualAllocate(block, &allocCreateInfo, &alloc, &offset);
if(res == VK_SUCCESS)
{
    // Use the 4 KB of your memory starting at offset.
}
else
{
    // Allocation failed - no space for it could be found. Handle this error!
}
\endcode

\section virtual_allocator_deallocation Deallocation

When no longer needed, an allocation can be freed by calling vmaVirtualFree().
You can only pass to this function an allocation that was previously returned by vmaVirtualAllocate()
called for the same #VmaVirtualBlock.

When whole block is no longer needed, the block object can be released by calling vmaDestroyVirtualBlock().
All allocations must be freed before the block is destroyed, which is checked internally by an assert.
However, if you don't want to call vmaVirtualFree() for each allocation, you can use vmaClearVirtualBlock() to free them all at once -
a feature not available in normal Vulkan memory allocator. Example:

\code
vmaVirtualFree(block, alloc);
vmaDestroyVirtualBlock(block);
\endcode

\section virtual_allocator_allocation_parameters Allocation parameters

You can attach a custom pointer to each allocation by using vmaSetVirtualAllocationUserData().
Its default value is null.
It can be used to store any data that needs to be associated with that allocation - e.g. an index, a handle, or a pointer to some
larger data structure containing more information. Example:

\code
struct CustomAllocData
{
    std::string m_AllocName;
};
CustomAllocData* allocData = new CustomAllocData();
allocData->m_AllocName = "My allocation 1";
vmaSetVirtualAllocationUserData(block, alloc, allocData);
\endcode

The pointer can later be fetched, along with allocation offset and size, by passing the allocation handle to function
vmaGetVirtualAllocationInfo() and inspecting returned structure #VmaVirtualAllocationInfo.
If you allocated a new object to be used as the custom pointer, don't forget to delete that object before freeing the allocation!
Example:

\code
VmaVirtualAllocationInfo allocInfo;
vmaGetVirtualAllocationInfo(block, alloc, &allocInfo);
delete (CustomAllocData*)allocInfo.pUserData;

vmaVirtualFree(block, alloc);
\endcode

\section virtual_allocator_alignment_and_units Alignment and units

It feels natural to express sizes and offsets in bytes.
If an offset of an allocation needs to be aligned to a multiply of some number (e.g. 4 bytes), you can fill optional member
VmaVirtualAllocationCreateInfo::alignment to request it. Example:

\code
VmaVirtualAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.size = 4096; // 4 KB
allocCreateInfo.alignment = 4; // Returned offset must be a multiply of 4 B

VmaVirtualAllocation alloc;
res = vmaVirtualAllocate(block, &allocCreateInfo, &alloc, nullptr);
\endcode

Alignments of different allocations made from one block may vary.
However, if all alignments and sizes are always multiply of some size e.g. 4 B or `sizeof(MyDataStruct)`,
you can express all sizes, alignments, and offsets in multiples of that size instead of individual bytes.
It might be more convenient, but you need to make sure to use this new unit consistently in all the places:

- VmaVirtualBlockCreateInfo::size
- VmaVirtualAllocationCreateInfo::size and VmaVirtualAllocationCreateInfo::alignment
- Using offset returned by vmaVirtualAllocate() or in VmaVirtualAllocationInfo::offset

\section virtual_allocator_statistics Statistics

You can obtain statistics of a virtual block using vmaGetVirtualBlockStatistics()
(to get brief statistics that are fast to calculate)
or vmaCalculateVirtualBlockStatistics() (to get more detailed statistics, slower to calculate).
The functions fill structures #VmaStatistics, #VmaDetailedStatistics respectively - same as used by the normal Vulkan memory allocator.
Example:

\code
VmaStatistics stats;
vmaGetVirtualBlockStatistics(block, &stats);
printf("My virtual block has %llu bytes used by %u virtual allocations\n",
    stats.allocationBytes, stats.allocationCount);
\endcode

You can also request a full list of allocations and free regions as a string in JSON format by calling
vmaBuildVirtualBlockStatsString().
Returned string must be later freed using vmaFreeVirtualBlockStatsString().
The format of this string differs from the one returned by the main Vulkan allocator, but it is similar.

\section virtual_allocator_additional_considerations Additional considerations

The "virtual allocator" functionality is implemented on a level of individual memory blocks.
Keeping track of a whole collection of blocks, allocating new ones when out of free space,
deleting empty ones, and deciding which one to try first for a new allocation must be implemented by the user.

Alternative allocation algorithms are supported, just like in custom pools of the real GPU memory.
See enum #VmaVirtualBlockCreateFlagBits to learn how to specify them (e.g. #VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT).
You can find their description in chapter \ref custom_memory_pools.
Allocation strategies are also supported.
See enum #VmaVirtualAllocationCreateFlagBits to learn how to specify them (e.g. #VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT).

Following features are supported only by the allocator of the real GPU memory and not by virtual allocations:
buffer-image granularity, `VMA_DEBUG_MARGIN`, `VMA_MIN_ALIGNMENT`.


\page debugging_memory_usage Debugging incorrect memory usage

If you suspect a bug with memory usage, like usage of uninitialized memory or
memory being overwritten out of bounds of an allocation,
you can use debug features of this library to verify this.

\section debugging_memory_usage_initialization Memory initialization

If you experience a bug with incorrect and nondeterministic data in your program and you suspect uninitialized memory to be used,
you can enable automatic memory initialization to verify this.
To do it, define macro `VMA_DEBUG_INITIALIZE_ALLOCATIONS` to 1.

\code
#define VMA_DEBUG_INITIALIZE_ALLOCATIONS 1
#include "vk_mem_alloc.h"
\endcode

It makes memory of new allocations initialized to bit pattern `0xDCDCDCDC`.
Before an allocation is destroyed, its memory is filled with bit pattern `0xEFEFEFEF`.
Memory is automatically mapped and unmapped if necessary.

If you find these values while debugging your program, good chances are that you incorrectly
read Vulkan memory that is allocated but not initialized, or already freed, respectively.

Memory initialization works only with memory types that are `HOST_VISIBLE` and with allocations that can be mapped.
It works also with dedicated allocations.

\section debugging_memory_usage_margins Margins

By default, allocations are laid out in memory blocks next to each other if possible
(considering required alignment, `bufferImageGranularity`, and `nonCoherentAtomSize`).

![Allocations without margin](../gfx/Margins_1.png)

Define macro `VMA_DEBUG_MARGIN` to some non-zero value (e.g. 16) to enforce specified
number of bytes as a margin after every allocation.

\code
#define VMA_DEBUG_MARGIN 16
#include "vk_mem_alloc.h"
\endcode

![Allocations with margin](../gfx/Margins_2.png)

If your bug goes away after enabling margins, it means it may be caused by memory
being overwritten outside of allocation boundaries. It is not 100% certain though.
Change in application behavior may also be caused by different order and distribution
of allocations across memory blocks after margins are applied.

Margins work with all types of memory.

Margin is applied only to allocations made out of memory blocks and not to dedicated
allocations, which have their own memory block of specific size.
It is thus not applied to allocations made using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT flag
or those automatically decided to put into dedicated allocations, e.g. due to its
large size or recommended by VK_KHR_dedicated_allocation extension.

Margins appear in [JSON dump](@ref statistics_json_dump) as part of free space.

Note that enabling margins increases memory usage and fragmentation.

Margins do not apply to \ref virtual_allocator.

\section debugging_memory_usage_corruption_detection Corruption detection

You can additionally define macro `VMA_DEBUG_DETECT_CORRUPTION` to 1 to enable validation
of contents of the margins.

\code
#define VMA_DEBUG_MARGIN 16
#define VMA_DEBUG_DETECT_CORRUPTION 1
#include "vk_mem_alloc.h"
\endcode

When this feature is enabled, number of bytes specified as `VMA_DEBUG_MARGIN`
(it must be multiply of 4) after every allocation is filled with a magic number.
This idea is also know as "canary".
Memory is automatically mapped and unmapped if necessary.

This number is validated automatically when the allocation is destroyed.
If it is not equal to the expected value, `VMA_ASSERT()` is executed.
It clearly means that either CPU or GPU overwritten the memory outside of boundaries of the allocation,
which indicates a serious bug.

You can also explicitly request checking margins of all allocations in all memory blocks
that belong to specified memory types by using function vmaCheckCorruption(),
or in memory blocks that belong to specified custom pool, by using function
vmaCheckPoolCorruption().

Margin validation (corruption detection) works only for memory types that are
`HOST_VISIBLE` and `HOST_COHERENT`.


\page opengl_interop OpenGL Interop

VMA provides some features that help with interoperability with OpenGL.

\section opengl_interop_exporting_memory Exporting memory

If you want to attach `VkExportMemoryAllocateInfoKHR` structure to `pNext` chain of memory allocations made by the library:

It is recommended to create \ref custom_memory_pools for such allocations.
Define and fill in your `VkExportMemoryAllocateInfoKHR` structure and attach it to VmaPoolCreateInfo::pMemoryAllocateNext
while creating the custom pool.
Please note that the structure must remain alive and unchanged for the whole lifetime of the #VmaPool,
not only while creating it, as no copy of the structure is made,
but its original pointer is used for each allocation instead.

If you want to export all memory allocated by the library from certain memory types,
also dedicated allocations or other allocations made from default pools,
an alternative solution is to fill in VmaAllocatorCreateInfo::pTypeExternalMemoryHandleTypes.
It should point to an array with `VkExternalMemoryHandleTypeFlagsKHR` to be automatically passed by the library
through `VkExportMemoryAllocateInfoKHR` on each allocation made from a specific memory type.
Please note that new versions of the library also support dedicated allocations created in custom pools.

You should not mix these two methods in a way that allows to apply both to the same memory type.
Otherwise, `VkExportMemoryAllocateInfoKHR` structure would be attached twice to the `pNext` chain of `VkMemoryAllocateInfo`.


\section opengl_interop_custom_alignment Custom alignment

Buffers or images exported to a different API like OpenGL may require a different alignment,
higher than the one used by the library automatically, queried from functions like `vkGetBufferMemoryRequirements`.
To impose such alignment:

It is recommended to create \ref custom_memory_pools for such allocations.
Set VmaPoolCreateInfo::minAllocationAlignment member to the minimum alignment required for each allocation
to be made out of this pool.
The alignment actually used will be the maximum of this member and the alignment returned for the specific buffer or image
from a function like `vkGetBufferMemoryRequirements`, which is called by VMA automatically.

If you want to create a buffer with a specific minimum alignment out of default pools,
use special function vmaCreateBufferWithAlignment(), which takes additional parameter `minAlignment`.

Note the problem of alignment affects only resources placed inside bigger `VkDeviceMemory` blocks and not dedicated
allocations, as these, by definition, always have alignment = 0 because the resource is bound to the beginning of its dedicated block.
Contrary to Direct3D 12, Vulkan doesn't have a concept of alignment of the entire memory block passed on its allocation.


\page usage_patterns Recommended usage patterns

Vulkan gives great flexibility in memory allocation.
This chapter shows the most common patterns.

See also slides from talk:
[Sawicki, Adam. Advanced Graphics Techniques Tutorial: Memory management in Vulkan and DX12. Game Developers Conference, 2018](https://www.gdcvault.com/play/1025458/Advanced-Graphics-Techniques-Tutorial-New)


\section usage_patterns_gpu_only GPU-only resource

<b>When:</b>
Any resources that you frequently write and read on GPU,
e.g. images used as color attachments (aka "render targets"), depth-stencil attachments,
images/buffers used as storage image/buffer (aka "Unordered Access View (UAV)").

<b>What to do:</b>
Let the library select the optimal memory type, which will likely have `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.

\code
VkImageCreateInfo imgCreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
imgCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imgCreateInfo.extent.width = 3840;
imgCreateInfo.extent.height = 2160;
imgCreateInfo.extent.depth = 1;
imgCreateInfo.mipLevels = 1;
imgCreateInfo.arrayLayers = 1;
imgCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
imgCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imgCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imgCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
imgCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
allocCreateInfo.flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
allocCreateInfo.priority = 1.0f;

VkImage img;
VmaAllocation alloc;
vmaCreateImage(allocator, &imgCreateInfo, &allocCreateInfo, &img, &alloc, nullptr);
\endcode

<b>Also consider:</b>
Consider creating them as dedicated allocations using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
especially if they are large or if you plan to destroy and recreate them with different sizes
e.g. when display resolution changes.
Prefer to create such resources first and all other GPU resources (like textures and vertex buffers) later.
When VK_EXT_memory_priority extension is enabled, it is also worth setting high priority to such allocation
to decrease chances to be evicted to system memory by the operating system.

\section usage_patterns_staging_copy_upload Staging copy for upload

<b>When:</b>
A "staging" buffer than you want to map and fill from CPU code, then use as a source of transfer
to some GPU resource.

<b>What to do:</b>
Use flag #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT.
Let the library select the optimal memory type, which will always have `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`.

\code
VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
bufCreateInfo.size = 65536;
bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
    VMA_ALLOCATION_CREATE_MAPPED_BIT;

VkBuffer buf;
VmaAllocation alloc;
VmaAllocationInfo allocInfo;
vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

...

memcpy(allocInfo.pMappedData, myData, myDataSize);
\endcode

<b>Also consider:</b>
You can map the allocation using vmaMapMemory() or you can create it as persistenly mapped
using #VMA_ALLOCATION_CREATE_MAPPED_BIT, as in the example above.


\section usage_patterns_readback Readback

<b>When:</b>
Buffers for data written by or transferred from the GPU that you want to read back on the CPU,
e.g. results of some computations.

<b>What to do:</b>
Use flag #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.
Let the library select the optimal memory type, which will always have `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`
and `VK_MEMORY_PROPERTY_HOST_CACHED_BIT`.

\code
VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
bufCreateInfo.size = 65536;
bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT |
    VMA_ALLOCATION_CREATE_MAPPED_BIT;

VkBuffer buf;
VmaAllocation alloc;
VmaAllocationInfo allocInfo;
vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

...

const float* downloadedData = (const float*)allocInfo.pMappedData;
\endcode


\section usage_patterns_advanced_data_uploading Advanced data uploading

For resources that you frequently write on CPU via mapped pointer and
frequently read on GPU e.g. as a uniform buffer (also called "dynamic"), multiple options are possible:

-# Easiest solution is to have one copy of the resource in `HOST_VISIBLE` memory,
   even if it means system RAM (not `DEVICE_LOCAL`) on systems with a discrete graphics card,
   and make the device reach out to that resource directly.
   - Reads performed by the device will then go through PCI Express bus.
     The performance of this access may be limited, but it may be fine depending on the size
     of this resource (whether it is small enough to quickly end up in GPU cache) and the sparsity
     of access.
-# On systems with unified memory (e.g. AMD APU or Intel integrated graphics, mobile chips),
   a memory type may be available that is both `HOST_VISIBLE` (available for mapping) and `DEVICE_LOCAL`
   (fast to access from the GPU). Then, it is likely the best choice for such type of resource.
-# Systems with a discrete graphics card and separate video memory may or may not expose
   a memory type that is both `HOST_VISIBLE` and `DEVICE_LOCAL`, also known as Base Address Register (BAR).
   If they do, it represents a piece of VRAM (or entire VRAM, if ReBAR is enabled in the motherboard BIOS)
   that is available to CPU for mapping.
   - Writes performed by the host to that memory go through PCI Express bus.
     The performance of these writes may be limited, but it may be fine, especially on PCIe 4.0,
     as long as rules of using uncached and write-combined memory are followed - only sequential writes and no reads.
-# Finally, you may need or prefer to create a separate copy of the resource in `DEVICE_LOCAL` memory,
   a separate "staging" copy in `HOST_VISIBLE` memory and perform an explicit transfer command between them.

Thankfully, VMA offers an aid to create and use such resources in the the way optimal
for the current Vulkan device. To help the library make the best choice,
use flag #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT together with
#VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT.
It will then prefer a memory type that is both `DEVICE_LOCAL` and `HOST_VISIBLE` (integrated memory or BAR),
but if no such memory type is available or allocation from it fails
(PC graphics cards have only 256 MB of BAR by default, unless ReBAR is supported and enabled in BIOS),
it will fall back to `DEVICE_LOCAL` memory for fast GPU access.
It is then up to you to detect that the allocation ended up in a memory type that is not `HOST_VISIBLE`,
so you need to create another "staging" allocation and perform explicit transfers.

\code
VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
bufCreateInfo.size = 65536;
bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
    VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT |
    VMA_ALLOCATION_CREATE_MAPPED_BIT;

VkBuffer buf;
VmaAllocation alloc;
VmaAllocationInfo allocInfo;
vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

VkMemoryPropertyFlags memPropFlags;
vmaGetAllocationMemoryProperties(allocator, alloc, &memPropFlags);

if(memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
{
    // Allocation ended up in a mappable memory and is already mapped - write to it directly.

    // [Executed in runtime]:
    memcpy(allocInfo.pMappedData, myData, myDataSize);
}
else
{
    // Allocation ended up in a non-mappable memory - need to transfer.
    VkBufferCreateInfo stagingBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
    stagingBufCreateInfo.size = 65536;
    stagingBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;

    VmaAllocationCreateInfo stagingAllocCreateInfo = {};
    stagingAllocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
    stagingAllocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
        VMA_ALLOCATION_CREATE_MAPPED_BIT;

    VkBuffer stagingBuf;
    VmaAllocation stagingAlloc;
    VmaAllocationInfo stagingAllocInfo;
    vmaCreateBuffer(allocator, &stagingBufCreateInfo, &stagingAllocCreateInfo,
        &stagingBuf, &stagingAlloc, stagingAllocInfo);

    // [Executed in runtime]:
    memcpy(stagingAllocInfo.pMappedData, myData, myDataSize);
    //vkCmdPipelineBarrier: VK_ACCESS_HOST_WRITE_BIT --> VK_ACCESS_TRANSFER_READ_BIT
    VkBufferCopy bufCopy = {
        0, // srcOffset
        0, // dstOffset,
        myDataSize); // size
    vkCmdCopyBuffer(cmdBuf, stagingBuf, buf, 1, &bufCopy);
}
\endcode

\section usage_patterns_other_use_cases Other use cases

Here are some other, less obvious use cases and their recommended settings:

- An image that is used only as transfer source and destination, but it should stay on the device,
  as it is used to temporarily store a copy of some texture, e.g. from the current to the next frame,
  for temporal antialiasing or other temporal effects.
  - Use `VkImageCreateInfo::usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT`
  - Use VmaAllocationCreateInfo::usage = #VMA_MEMORY_USAGE_AUTO
- An image that is used only as transfer source and destination, but it should be placed
  in the system RAM despite it doesn't need to be mapped, because it serves as a "swap" copy to evict
  least recently used textures from VRAM.
  - Use `VkImageCreateInfo::usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT`
  - Use VmaAllocationCreateInfo::usage = #VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
    as VMA needs a hint here to differentiate from the previous case.
- A buffer that you want to map and write from the CPU, directly read from the GPU
  (e.g. as a uniform or vertex buffer), but you have a clear preference to place it in device or
  host memory due to its large size.
  - Use `VkBufferCreateInfo::usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT`
  - Use VmaAllocationCreateInfo::usage = #VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE or #VMA_MEMORY_USAGE_AUTO_PREFER_HOST
  - Use VmaAllocationCreateInfo::flags = #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT


\page configuration Configuration

Please check "CONFIGURATION SECTION" in the code to find macros that you can define
before each include of this file or change directly in this file to provide
your own implementation of basic facilities like assert, `min()` and `max()` functions,
mutex, atomic etc.
The library uses its own implementation of containers by default, but you can switch to using
STL containers instead.

For example, define `VMA_ASSERT(expr)` before including the library to provide
custom implementation of the assertion, compatible with your project.
By default it is defined to standard C `assert(expr)` in `_DEBUG` configuration
and empty otherwise.

\section config_Vulkan_functions Pointers to Vulkan functions

There are multiple ways to import pointers to Vulkan functions in the library.
In the simplest case you don't need to do anything.
If the compilation or linking of your program or the initialization of the #VmaAllocator
doesn't work for you, you can try to reconfigure it.

First, the allocator tries to fetch pointers to Vulkan functions linked statically,
like this:

\code
m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
\endcode

If you want to disable this feature, set configuration macro: `#define VMA_STATIC_VULKAN_FUNCTIONS 0`.

Second, you can provide the pointers yourself by setting member VmaAllocatorCreateInfo::pVulkanFunctions.
You can fetch them e.g. using functions `vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` or
by using a helper library like [volk](https://github.com/zeux/volk).

Third, VMA tries to fetch remaining pointers that are still null by calling
`vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` on its own.
You need to only fill in VmaVulkanFunctions::vkGetInstanceProcAddr and VmaVulkanFunctions::vkGetDeviceProcAddr.
Other pointers will be fetched automatically.
If you want to disable this feature, set configuration macro: `#define VMA_DYNAMIC_VULKAN_FUNCTIONS 0`.

Finally, all the function pointers required by the library (considering selected
Vulkan version and enabled extensions) are checked with `VMA_ASSERT` if they are not null.


\section custom_memory_allocator Custom host memory allocator

If you use custom allocator for CPU memory rather than default operator `new`
and `delete` from C++, you can make this library using your allocator as well
by filling optional member VmaAllocatorCreateInfo::pAllocationCallbacks. These
functions will be passed to Vulkan, as well as used by the library itself to
make any CPU-side allocations.

\section allocation_callbacks Device memory allocation callbacks

The library makes calls to `vkAllocateMemory()` and `vkFreeMemory()` internally.
You can setup callbacks to be informed about these calls, e.g. for the purpose
of gathering some statistics. To do it, fill optional member
VmaAllocatorCreateInfo::pDeviceMemoryCallbacks.

\section heap_memory_limit Device heap memory limit

When device memory of certain heap runs out of free space, new allocations may
fail (returning error code) or they may succeed, silently pushing some existing_
memory blocks from GPU VRAM to system RAM (which degrades performance). This
behavior is implementation-dependent - it depends on GPU vendor and graphics
driver.

On AMD cards it can be controlled while creating Vulkan device object by using
VK_AMD_memory_overallocation_behavior extension, if available.

Alternatively, if you want to test how your program behaves with limited amount of Vulkan device
memory available without switching your graphics card to one that really has
smaller VRAM, you can use a feature of this library intended for this purpose.
To do it, fill optional member VmaAllocatorCreateInfo::pHeapSizeLimit.



\page vk_khr_dedicated_allocation VK_KHR_dedicated_allocation

VK_KHR_dedicated_allocation is a Vulkan extension which can be used to improve
performance on some GPUs. It augments Vulkan API with possibility to query
driver whether it prefers particular buffer or image to have its own, dedicated
allocation (separate `VkDeviceMemory` block) for better efficiency - to be able
to do some internal optimizations. The extension is supported by this library.
It will be used automatically when enabled.

It has been promoted to core Vulkan 1.1, so if you use eligible Vulkan version
and inform VMA about it by setting VmaAllocatorCreateInfo::vulkanApiVersion,
you are all set.

Otherwise, if you want to use it as an extension:

1 . When creating Vulkan device, check if following 2 device extensions are
supported (call `vkEnumerateDeviceExtensionProperties()`).
If yes, enable them (fill `VkDeviceCreateInfo::ppEnabledExtensionNames`).

- VK_KHR_get_memory_requirements2
- VK_KHR_dedicated_allocation

If you enabled these extensions:

2 . Use #VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag when creating
your #VmaAllocator to inform the library that you enabled required extensions
and you want the library to use them.

\code
allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT;

vmaCreateAllocator(&allocatorInfo, &allocator);
\endcode

That is all. The extension will be automatically used whenever you create a
buffer using vmaCreateBuffer() or image using vmaCreateImage().

When using the extension together with Vulkan Validation Layer, you will receive
warnings like this:

_vkBindBufferMemory(): Binding memory to buffer 0x33 but vkGetBufferMemoryRequirements() has not been called on that buffer._

It is OK, you should just ignore it. It happens because you use function
`vkGetBufferMemoryRequirements2KHR()` instead of standard
`vkGetBufferMemoryRequirements()`, while the validation layer seems to be
unaware of it.

To learn more about this extension, see:

- [VK_KHR_dedicated_allocation in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/chap50.html#VK_KHR_dedicated_allocation)
- [VK_KHR_dedicated_allocation unofficial manual](http://asawicki.info/articles/VK_KHR_dedicated_allocation.php5)



\page vk_ext_memory_priority VK_EXT_memory_priority

VK_EXT_memory_priority is a device extension that allows to pass additional "priority"
value to Vulkan memory allocations that the implementation may use prefer certain
buffers and images that are critical for performance to stay in device-local memory
in cases when the memory is over-subscribed, while some others may be moved to the system memory.

VMA offers convenient usage of this extension.
If you enable it, you can pass "priority" parameter when creating allocations or custom pools
and the library automatically passes the value to Vulkan using this extension.

If you want to use this extension in connection with VMA, follow these steps:

\section vk_ext_memory_priority_initialization Initialization

1) Call `vkEnumerateDeviceExtensionProperties` for the physical device.
Check if the extension is supported - if returned array of `VkExtensionProperties` contains "VK_EXT_memory_priority".

2) Call `vkGetPhysicalDeviceFeatures2` for the physical device instead of old `vkGetPhysicalDeviceFeatures`.
Attach additional structure `VkPhysicalDeviceMemoryPriorityFeaturesEXT` to `VkPhysicalDeviceFeatures2::pNext` to be returned.
Check if the device feature is really supported - check if `VkPhysicalDeviceMemoryPriorityFeaturesEXT::memoryPriority` is true.

3) While creating device with `vkCreateDevice`, enable this extension - add "VK_EXT_memory_priority"
to the list passed as `VkDeviceCreateInfo::ppEnabledExtensionNames`.

4) While creating the device, also don't set `VkDeviceCreateInfo::pEnabledFeatures`.
Fill in `VkPhysicalDeviceFeatures2` structure instead and pass it as `VkDeviceCreateInfo::pNext`.
Enable this device feature - attach additional structure `VkPhysicalDeviceMemoryPriorityFeaturesEXT` to
`VkPhysicalDeviceFeatures2::pNext` chain and set its member `memoryPriority` to `VK_TRUE`.

5) While creating #VmaAllocator with vmaCreateAllocator() inform VMA that you
have enabled this extension and feature - add #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT
to VmaAllocatorCreateInfo::flags.

\section vk_ext_memory_priority_usage Usage

When using this extension, you should initialize following member:

- VmaAllocationCreateInfo::priority when creating a dedicated allocation with #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
- VmaPoolCreateInfo::priority when creating a custom pool.

It should be a floating-point value between `0.0f` and `1.0f`, where recommended default is `0.5f`.
Memory allocated with higher value can be treated by the Vulkan implementation as higher priority
and so it can have lower chances of being pushed out to system memory, experiencing degraded performance.

It might be a good idea to create performance-critical resources like color-attachment or depth-stencil images
as dedicated and set high priority to them. For example:

\code
VkImageCreateInfo imgCreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
imgCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imgCreateInfo.extent.width = 3840;
imgCreateInfo.extent.height = 2160;
imgCreateInfo.extent.depth = 1;
imgCreateInfo.mipLevels = 1;
imgCreateInfo.arrayLayers = 1;
imgCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
imgCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imgCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imgCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
imgCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;

VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
allocCreateInfo.flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
allocCreateInfo.priority = 1.0f;

VkImage img;
VmaAllocation alloc;
vmaCreateImage(allocator, &imgCreateInfo, &allocCreateInfo, &img, &alloc, nullptr);
\endcode

`priority` member is ignored in the following situations:

- Allocations created in custom pools: They inherit the priority, along with all other allocation parameters
  from the parametrs passed in #VmaPoolCreateInfo when the pool was created.
- Allocations created in default pools: They inherit the priority from the parameters
  VMA used when creating default pools, which means `priority == 0.5f`.


\page vk_amd_device_coherent_memory VK_AMD_device_coherent_memory

VK_AMD_device_coherent_memory is a device extension that enables access to
additional memory types with `VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD` and
`VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD` flag. It is useful mostly for
allocation of buffers intended for writing "breadcrumb markers" in between passes
or draw calls, which in turn are useful for debugging GPU crash/hang/TDR cases.

When the extension is available but has not been enabled, Vulkan physical device
still exposes those memory types, but their usage is forbidden. VMA automatically
takes care of that - it returns `VK_ERROR_FEATURE_NOT_PRESENT` when an attempt
to allocate memory of such type is made.

If you want to use this extension in connection with VMA, follow these steps:

\section vk_amd_device_coherent_memory_initialization Initialization

1) Call `vkEnumerateDeviceExtensionProperties` for the physical device.
Check if the extension is supported - if returned array of `VkExtensionProperties` contains "VK_AMD_device_coherent_memory".

2) Call `vkGetPhysicalDeviceFeatures2` for the physical device instead of old `vkGetPhysicalDeviceFeatures`.
Attach additional structure `VkPhysicalDeviceCoherentMemoryFeaturesAMD` to `VkPhysicalDeviceFeatures2::pNext` to be returned.
Check if the device feature is really supported - check if `VkPhysicalDeviceCoherentMemoryFeaturesAMD::deviceCoherentMemory` is true.

3) While creating device with `vkCreateDevice`, enable this extension - add "VK_AMD_device_coherent_memory"
to the list passed as `VkDeviceCreateInfo::ppEnabledExtensionNames`.

4) While creating the device, also don't set `VkDeviceCreateInfo::pEnabledFeatures`.
Fill in `VkPhysicalDeviceFeatures2` structure instead and pass it as `VkDeviceCreateInfo::pNext`.
Enable this device feature - attach additional structure `VkPhysicalDeviceCoherentMemoryFeaturesAMD` to
`VkPhysicalDeviceFeatures2::pNext` and set its member `deviceCoherentMemory` to `VK_TRUE`.

5) While creating #VmaAllocator with vmaCreateAllocator() inform VMA that you
have enabled this extension and feature - add #VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT
to VmaAllocatorCreateInfo::flags.

\section vk_amd_device_coherent_memory_usage Usage

After following steps described above, you can create VMA allocations and custom pools
out of the special `DEVICE_COHERENT` and `DEVICE_UNCACHED` memory types on eligible
devices. There are multiple ways to do it, for example:

- You can request or prefer to allocate out of such memory types by adding
  `VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD` to VmaAllocationCreateInfo::requiredFlags
  or VmaAllocationCreateInfo::preferredFlags. Those flags can be freely mixed with
  other ways of \ref choosing_memory_type, like setting VmaAllocationCreateInfo::usage.
- If you manually found memory type index to use for this purpose, force allocation
  from this specific index by setting VmaAllocationCreateInfo::memoryTypeBits `= 1u << index`.

\section vk_amd_device_coherent_memory_more_information More information

To learn more about this extension, see [VK_AMD_device_coherent_memory in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_device_coherent_memory.html)

Example use of this extension can be found in the code of the sample and test suite
accompanying this library.


\page enabling_buffer_device_address Enabling buffer device address

Device extension VK_KHR_buffer_device_address
allow to fetch raw GPU pointer to a buffer and pass it for usage in a shader code.
It has been promoted to core Vulkan 1.2.

If you want to use this feature in connection with VMA, follow these steps:

\section enabling_buffer_device_address_initialization Initialization

1) (For Vulkan version < 1.2) Call `vkEnumerateDeviceExtensionProperties` for the physical device.
Check if the extension is supported - if returned array of `VkExtensionProperties` contains
"VK_KHR_buffer_device_address".

2) Call `vkGetPhysicalDeviceFeatures2` for the physical device instead of old `vkGetPhysicalDeviceFeatures`.
Attach additional structure `VkPhysicalDeviceBufferDeviceAddressFeatures*` to `VkPhysicalDeviceFeatures2::pNext` to be returned.
Check if the device feature is really supported - check if `VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress` is true.

3) (For Vulkan version < 1.2) While creating device with `vkCreateDevice`, enable this extension - add
"VK_KHR_buffer_device_address" to the list passed as `VkDeviceCreateInfo::ppEnabledExtensionNames`.

4) While creating the device, also don't set `VkDeviceCreateInfo::pEnabledFeatures`.
Fill in `VkPhysicalDeviceFeatures2` structure instead and pass it as `VkDeviceCreateInfo::pNext`.
Enable this device feature - attach additional structure `VkPhysicalDeviceBufferDeviceAddressFeatures*` to
`VkPhysicalDeviceFeatures2::pNext` and set its member `bufferDeviceAddress` to `VK_TRUE`.

5) While creating #VmaAllocator with vmaCreateAllocator() inform VMA that you
have enabled this feature - add #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT
to VmaAllocatorCreateInfo::flags.

\section enabling_buffer_device_address_usage Usage

After following steps described above, you can create buffers with `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT*` using VMA.
The library automatically adds `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT*` to
allocated memory blocks wherever it might be needed.

Please note that the library supports only `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT*`.
The second part of this functionality related to "capture and replay" is not supported,
as it is intended for usage in debugging tools like RenderDoc, not in everyday Vulkan usage.

\section enabling_buffer_device_address_more_information More information

To learn more about this extension, see [VK_KHR_buffer_device_address in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/chap46.html#VK_KHR_buffer_device_address)

Example use of this extension can be found in the code of the sample and test suite
accompanying this library.

\page general_considerations General considerations

\section general_considerations_thread_safety Thread safety

- The library has no global state, so separate #VmaAllocator objects can be used
  independently.
  There should be no need to create multiple such objects though - one per `VkDevice` is enough.
- By default, all calls to functions that take #VmaAllocator as first parameter
  are safe to call from multiple threads simultaneously because they are
  synchronized internally when needed.
  This includes allocation and deallocation from default memory pool, as well as custom #VmaPool.
- When the allocator is created with #VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
  flag, calls to functions that take such #VmaAllocator object must be
  synchronized externally.
- Access to a #VmaAllocation object must be externally synchronized. For example,
  you must not call vmaGetAllocationInfo() and vmaMapMemory() from different
  threads at the same time if you pass the same #VmaAllocation object to these
  functions.
- #VmaVirtualBlock is not safe to be used from multiple threads simultaneously.

\section general_considerations_versioning_and_compatibility Versioning and compatibility

The library uses [**Semantic Versioning**](https://semver.org/),
which means version numbers follow convention: Major.Minor.Patch (e.g. 2.3.0), where:

- Incremented Patch version means a release is backward- and forward-compatible,
  introducing only some internal improvements, bug fixes, optimizations etc.
  or changes that are out of scope of the official API described in this documentation.
- Incremented Minor version means a release is backward-compatible,
  so existing code that uses the library should continue to work, while some new
  symbols could have been added: new structures, functions, new values in existing
  enums and bit flags, new structure members, but not new function parameters.
- Incrementing Major version means a release could break some backward compatibility.

All changes between official releases are documented in file "CHANGELOG.md".

\warning Backward compatibility is considered on the level of C++ source code, not binary linkage.
Adding new members to existing structures is treated as backward compatible if initializing
the new members to binary zero results in the old behavior.
You should always fully initialize all library structures to zeros and not rely on their
exact binary size.

\section general_considerations_validation_layer_warnings Validation layer warnings

When using this library, you can meet following types of warnings issued by
Vulkan validation layer. They don't necessarily indicate a bug, so you may need
to just ignore them.

- *vkBindBufferMemory(): Binding memory to buffer 0xeb8e4 but vkGetBufferMemoryRequirements() has not been called on that buffer.*
  - It happens when VK_KHR_dedicated_allocation extension is enabled.
    `vkGetBufferMemoryRequirements2KHR` function is used instead, while validation layer seems to be unaware of it.
- *Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.*
  - It happens when you map a buffer or image, because the library maps entire
    `VkDeviceMemory` block, where different types of images and buffers may end
    up together, especially on GPUs with unified memory like Intel.
- *Non-linear image 0xebc91 is aliased with linear buffer 0xeb8e4 which may indicate a bug.*
  - It may happen when you use [defragmentation](@ref defragmentation).

\section general_considerations_allocation_algorithm Allocation algorithm

The library uses following algorithm for allocation, in order:

-# Try to find free range of memory in existing blocks.
-# If failed, try to create a new block of `VkDeviceMemory`, with preferred block size.
-# If failed, try to create such block with size / 2, size / 4, size / 8.
-# If failed, try to allocate separate `VkDeviceMemory` for this allocation,
   just like when you use #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
-# If failed, choose other memory type that meets the requirements specified in
   VmaAllocationCreateInfo and go to point 1.
-# If failed, return `VK_ERROR_OUT_OF_DEVICE_MEMORY`.

\section general_considerations_features_not_supported Features not supported

Features deliberately excluded from the scope of this library:

-# **Data transfer.** Uploading (streaming) and downloading data of buffers and images
   between CPU and GPU memory and related synchronization is responsibility of the user.
   Defining some "texture" object that would automatically stream its data from a
   staging copy in CPU memory to GPU memory would rather be a feature of another,
   higher-level library implemented on top of VMA.
   VMA doesn't record any commands to a `VkCommandBuffer`. It just allocates memory.
-# **Recreation of buffers and images.** Although the library has functions for
   buffer and image creation: vmaCreateBuffer(), vmaCreateImage(), you need to
   recreate these objects yourself after defragmentation. That is because the big
   structures `VkBufferCreateInfo`, `VkImageCreateInfo` are not stored in
   #VmaAllocation object.
-# **Handling CPU memory allocation failures.** When dynamically creating small C++
   objects in CPU memory (not Vulkan memory), allocation failures are not checked
   and handled gracefully, because that would complicate code significantly and
   is usually not needed in desktop PC applications anyway.
   Success of an allocation is just checked with an assert.
-# **Code free of any compiler warnings.** Maintaining the library to compile and
   work correctly on so many different platforms is hard enough. Being free of
   any warnings, on any version of any compiler, is simply not feasible.
   There are many preprocessor macros that make some variables unused, function parameters unreferenced,
   or conditional expressions constant in some configurations.
   The code of this library should not be bigger or more complicated just to silence these warnings.
   It is recommended to disable such warnings instead.
-# This is a C++ library with C interface. **Bindings or ports to any other programming languages** are welcome as external projects but
   are not going to be included into this repository.
*/


================================================
FILE: Source/Plugin/RHI/xmake.lua
================================================
target("RHI.Vulkan")
    set_kind("shared")

    add_options("CUDA_ENABLE")
    if has_config("CUDA_ENABLE") then
        add_links("advapi32")
    end

    add_rules("plugin")
    add_defines("VK_NO_PROTOTYPES")

    if is_plat("windows") then
        add_defines("VK_USE_PLATFORM_WIN32_KHR")
    end

    add_files("Vulkan/**.cpp")
    add_headerfiles("Vulkan/**.hpp")

    add_deps("Core", "RHI")
    add_packages("volk")

    target("Plugin")
        add_deps("RHI.Vulkan")
    target_end()

    set_group("Plugin/RHI")
target_end()

if has_config("CUDA_ENABLE") and is_plat("windows")  then
    target("RHI.CUDA")
        set_kind("shared")

        add_rules("plugin")

        add_files("CUDA/**.cpp")
        add_headerfiles("CUDA/**.hpp")

        add_deps("Core", "RHI")
        add_packages("volk", "cuda")
        add_links("cudart", "cuda")
        
        target("Plugin")
            add_deps("RHI.CUDA")
        target_end()

        set_group("Plugin/RHI")
    target_end()
end


================================================
FILE: Source/Plugin/RenderPass/Bloom.cpp
================================================
#include "IPass.hpp"

#include <bitset>

using namespace Ilum;

class Bloom : public RenderPass<Bloom>
{
	struct Config
	{
		float threshold = 0.75f;
		float radius    = 0.75f;
		float intensity = 1.f;
	};

	struct PipelineDesc
	{
		std::shared_ptr<RHIPipelineState> pipeline_state = nullptr;
		ShaderMeta                        shader_meta;
	};

	struct BloomPassData
	{
		std::unique_ptr<RHITexture>                mask = nullptr;
		std::array<std::unique_ptr<RHITexture>, 4> level{nullptr};
		std::array<std::unique_ptr<RHITexture>, 4> blur{nullptr};
	};

  public:
	Bloom() = default;

	~Bloom() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Compute)
		    .SetName("Bloom")
		    .SetCategory("PostProcess")
		    .SetConfig(Config())
		    .ReadTexture2D(handle++, "Input", RHIResourceState::ShaderResource)
		    .WriteTexture2D(handle++, "Output", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		auto *rhi_context = renderer->GetRHIContext();

		auto bloom_mask          = CreatePipelineDesc(renderer, "BloomMask");
		auto bloom_down_sampling = CreatePipelineDesc(renderer, "BloomDownSampling");
		auto bloom_blur          = CreatePipelineDesc(renderer, "BloomBlur");
		auto bloom_up_sampling   = CreatePipelineDesc(renderer, "BloomUpSampling");
		auto bloom_blend         = CreatePipelineDesc(renderer, "BloomBlend");

		std::shared_ptr<RHIBuffer> uniform_buffer = rhi_context->CreateBuffer<Config>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto input  = render_graph.GetTexture(desc.GetPin("Input").handle);
			auto output = render_graph.GetTexture(desc.GetPin("Output").handle);

			auto *gpu_scene  = black_board.Get<GPUScene>();
			auto *view       = black_board.Get<View>();
			auto *bloom_data = black_board.Get<BloomPassData>();

			if (!bloom_data->mask ||
			    (bloom_data->mask->GetDesc().width != input->GetDesc().width ||
			     bloom_data->mask->GetDesc().height != input->GetDesc().height))
			{
				bloom_data->mask = rhi_context->CreateTexture2D(input->GetDesc().width, input->GetDesc().height, RHIFormat::R32G32B32A32_FLOAT, RHITextureUsage::UnorderedAccess | RHITextureUsage::ShaderResource, false);
				cmd_buffer->ResourceStateTransition({TextureStateTransition{bloom_data->mask.get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess}}, {});
			}

			if (!bloom_data->level[0] ||
			    (bloom_data->level[0]->GetDesc().width != (input->GetDesc().width >> 1) ||
			     bloom_data->level[0]->GetDesc().height != (input->GetDesc().height >> 1)))
			{
				for (uint32_t i = 0; i < 4; i++)
				{
					bloom_data->level[i] = rhi_context->CreateTexture2D(input->GetDesc().width >> (i + 1), input->GetDesc().height >> (i + 1), RHIFormat::R32G32B32A32_FLOAT, RHITextureUsage::UnorderedAccess | RHITextureUsage::ShaderResource, false);
				}
				cmd_buffer->ResourceStateTransition(
				    {TextureStateTransition{bloom_data->level[0].get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess},
				     TextureStateTransition{bloom_data->level[1].get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess},
				     TextureStateTransition{bloom_data->level[2].get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess},
				     TextureStateTransition{bloom_data->level[3].get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess}},
				    {});
			}

			if (!bloom_data->blur[0] ||
			    (bloom_data->blur[0]->GetDesc().width != (input->GetDesc().width >> 1) ||
			     bloom_data->blur[0]->GetDesc().height != (input->GetDesc().height >> 1)))
			{
				for (uint32_t i = 0; i < 4; i++)
				{
					bloom_data->blur[i] = rhi_context->CreateTexture2D(input->GetDesc().width >> (i + 1), input->GetDesc().height >> (i + 1), RHIFormat::R32G32B32A32_FLOAT, RHITextureUsage::UnorderedAccess | RHITextureUsage::ShaderResource, false);
				}
				cmd_buffer->ResourceStateTransition(
				    {TextureStateTransition{bloom_data->blur[0].get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess},
				     TextureStateTransition{bloom_data->blur[1].get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess},
				     TextureStateTransition{bloom_data->blur[2].get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess},
				     TextureStateTransition{bloom_data->blur[3].get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess}},
				    {});
			}

			uniform_buffer->CopyToDevice(config.Convert<Config>(), sizeof(Config));

			// Masking
			{
				cmd_buffer->BeginMarker("Bloom Mask");
				auto descriptor = rhi_context->CreateDescriptor(bloom_mask.shader_meta);
				descriptor->BindTexture("BloomMaskInput", input, RHITextureDimension::Texture2D)
				    .BindTexture("BloomMaskOutput", bloom_data->mask.get(), RHITextureDimension::Texture2D)
				    .BindBuffer("ConfigBuffer", uniform_buffer.get());
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(bloom_mask.pipeline_state.get());
				cmd_buffer->Dispatch(input->GetDesc().width, input->GetDesc().height, 1, 8, 8, 1);
				cmd_buffer->EndMarker();
			}

			// Resource Transition
			{
				cmd_buffer->ResourceStateTransition({TextureStateTransition{bloom_data->mask.get(), RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource}}, {});
			}

			// Down Sampling
			{
				cmd_buffer->BeginMarker("Bloom Down Sampling");
				for (uint32_t i = 0; i < 4; i++)
				{
					cmd_buffer->BeginMarker(fmt::format("Bloom Down Sampling - {}", i));
					auto descriptor = rhi_context->CreateDescriptor(bloom_down_sampling.shader_meta);
					descriptor->BindTexture("BloomDownSamplingInput", i == 0 ? bloom_data->mask.get() : bloom_data->level[i - 1].get(), RHITextureDimension::Texture2D)
					    .BindTexture("BloomDownSamplingOutput", bloom_data->level[i].get(), RHITextureDimension::Texture2D)
					    .BindSampler("BloomDownSampleSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()));
					cmd_buffer->BindDescriptor(descriptor);
					cmd_buffer->BindPipelineState(bloom_down_sampling.pipeline_state.get());
					cmd_buffer->Dispatch(bloom_data->level[i]->GetDesc().width, bloom_data->level[i]->GetDesc().height, 1, 8, 8, 1);
					cmd_buffer->ResourceStateTransition({TextureStateTransition{bloom_data->level[i].get(), RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource}}, {});
					cmd_buffer->EndMarker();
				}
				cmd_buffer->EndMarker();
			}

			// Blurring
			{
				cmd_buffer->BeginMarker("Bloom Blur");
				for (uint32_t i = 0; i < 4; i++)
				{
					cmd_buffer->BeginMarker(fmt::format("Bloom Blur - {}", i));
					auto descriptor = rhi_context->CreateDescriptor(bloom_blur.shader_meta);
					descriptor->BindTexture("BloomBlurInput", bloom_data->level[i].get(), RHITextureDimension::Texture2D)
					    .BindTexture("BloomBlurOutput", bloom_data->blur[i].get(), RHITextureDimension::Texture2D);
					cmd_buffer->BindDescriptor(descriptor);
					cmd_buffer->BindPipelineState(bloom_blur.pipeline_state.get());
					cmd_buffer->Dispatch(bloom_data->blur[i]->GetDesc().width, bloom_data->blur[i]->GetDesc().height, 1, 8, 8, 1);
					cmd_buffer->EndMarker();
				}
				cmd_buffer->EndMarker();
			}

			// Resource Transition
			{
				cmd_buffer->ResourceStateTransition(
				    {
				        TextureStateTransition{bloom_data->blur[0].get(), RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource},
				        TextureStateTransition{bloom_data->blur[1].get(), RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource},
				        TextureStateTransition{bloom_data->blur[2].get(), RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource},
				        TextureStateTransition{bloom_data->blur[3].get(), RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource},
				        TextureStateTransition{bloom_data->level[0].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->level[1].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->level[2].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->level[3].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				    },
				    {});
			}

			// Up Sampling
			{
				cmd_buffer->BeginMarker("Bloom Up Sampling");
				for (uint32_t i = 3; i >= 1; i--)
				{
					cmd_buffer->BeginMarker(fmt::format("Bloom Up Sampling - {}", i));
					auto descriptor = rhi_context->CreateDescriptor(bloom_up_sampling.shader_meta);
					descriptor->BindTexture("BloomUpSamplingLow", i == 3 ? bloom_data->blur[i].get() : bloom_data->level[i].get(), RHITextureDimension::Texture2D)
					    .BindTexture("BloomUpSamplingHigh", bloom_data->blur[i - 1].get(), RHITextureDimension::Texture2D)
					    .BindTexture("BloomUpSamplingOutput", bloom_data->level[i - 1].get(), RHITextureDimension::Texture2D)
					    .BindBuffer("ConfigBuffer", uniform_buffer.get());
					cmd_buffer->BindDescriptor(descriptor);
					cmd_buffer->BindPipelineState(bloom_up_sampling.pipeline_state.get());
					cmd_buffer->Dispatch(bloom_data->level[i - 1]->GetDesc().width, bloom_data->level[i - 1]->GetDesc().height, 1, 8, 8, 1);
					cmd_buffer->ResourceStateTransition({TextureStateTransition{bloom_data->level[i - 1].get(), RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource}}, {});
					cmd_buffer->EndMarker();
				}
				cmd_buffer->EndMarker();
			}

			// Blend
			{
				cmd_buffer->BeginMarker("Bloom Blend");
				auto descriptor = rhi_context->CreateDescriptor(bloom_blend.shader_meta);
				descriptor->BindTexture("BloomBlendBloom", bloom_data->level[0].get(), RHITextureDimension::Texture2D)
				    .BindTexture("BloomBlendInput", input, RHITextureDimension::Texture2D)
				    .BindTexture("BloomBlendOutput", output, RHITextureDimension::Texture2D)
				    .BindBuffer("ConfigBuffer", uniform_buffer.get());
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(bloom_blend.pipeline_state.get());
				cmd_buffer->Dispatch(output->GetDesc().width, output->GetDesc().height, 1, 8, 8, 1);
				cmd_buffer->EndMarker();
			}

			// Resource Transition
			{
				cmd_buffer->ResourceStateTransition(
				    {
				        TextureStateTransition{bloom_data->level[0].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->level[1].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->level[2].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->blur[0].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->blur[1].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->blur[2].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->blur[3].get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				        TextureStateTransition{bloom_data->mask.get(), RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess},
				    },
				    {});
			}
		};
	}

	virtual void OnImGui(Variant *config)
	{
		auto *config_data = config->Convert<Config>();

		ImGui::DragFloat("Threshold", &config_data->threshold, 0.01f, 0.f, std::numeric_limits<float>::max());
		ImGui::DragFloat("Radius", &config_data->radius, 0.01f, 0.f, 1.f);
		ImGui::DragFloat("Intensity", &config_data->intensity, 0.01f, 0.f, std::numeric_limits<float>::max());
	}

	PipelineDesc CreatePipelineDesc(Renderer *renderer, const std::string &entry_point)
	{
		PipelineDesc pipeline_desc;

		auto shader               = renderer->RequireShader("Source/Shaders/PostProcess/Bloom.hlsl", entry_point, RHIShaderStage::Compute);
		pipeline_desc.shader_meta = renderer->RequireShaderMeta(shader);

		pipeline_desc.pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(renderer->GetRHIContext()->CreatePipelineState()));
		pipeline_desc.pipeline_state->SetShader(RHIShaderStage::Compute, shader);

		return pipeline_desc;
	}
};

CONFIGURATION_PASS(Bloom)

================================================
FILE: Source/Plugin/RenderPass/CompositePass.cpp
================================================
#include "IPass.hpp"

#include <bitset>

using namespace Ilum;

class CompositePass : public RenderPass<CompositePass>
{
  public:
	CompositePass() = default;

	~CompositePass() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Compute)
		    .SetName("CompositePass")
		    .SetCategory("Shading")
		    .ReadTexture2D(handle++, "Env DI", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "Light DI", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "Environment", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "AO", RHIResourceState::ShaderResource)
		    .WriteTexture2D(handle++, "Output", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		auto *rhi_context = renderer->GetRHIContext();

		auto pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto light_direct_illumination = render_graph.GetTexture(desc.GetPin("Light DI").handle);
			auto env_direct_illumination   = render_graph.GetTexture(desc.GetPin("Env DI").handle);
			auto environment               = render_graph.GetTexture(desc.GetPin("Environment").handle);
			auto ao                        = render_graph.GetTexture(desc.GetPin("AO").handle);
			auto output                    = render_graph.GetTexture(desc.GetPin("Output").handle);

			auto *gpu_scene = black_board.Get<GPUScene>();
			auto *view      = black_board.Get<View>();

			auto shader = renderer->RequireShader("Source/Shaders/Shading/Composite.hlsl", "CSmain", RHIShaderStage::Compute,
			                                      {
			                                          light_direct_illumination ? "HAS_LIGHT_DIRECT_ILLUMINATION" : "NO_LIGHT_DIRECT_ILLUMINATION",
			                                          env_direct_illumination ? "HAS_ENV_DIRECT_ILLUMINATION" : "NO_ENV_DIRECT_ILLUMINATION",
			                                          ao ? "HAS_AMBIENT_OCCLUSION" : "NO_AMBIENT_OCCLUSION",
			                                          environment ? "HAS_ENVIRONMENT" : "NO_ENVIRONMENT",
			                                      });

			ShaderMeta shader_meta = renderer->RequireShaderMeta(shader);

			pipeline_state->ClearShader();
			pipeline_state->SetShader(RHIShaderStage::Compute, shader);

			auto descriptor = rhi_context->CreateDescriptor(shader_meta);

			descriptor->BindTexture("Output", output, RHITextureDimension::Texture2D);

			if (light_direct_illumination)
			{
				descriptor->BindTexture("LightDirectIllumination", light_direct_illumination, RHITextureDimension::Texture2D);
			}

			if (env_direct_illumination)
			{
				descriptor->BindTexture("EnvDirectIllumination", env_direct_illumination, RHITextureDimension::Texture2D);
			}

			if (environment)
			{
				descriptor->BindTexture("Environment", environment, RHITextureDimension::Texture2D);
			}

			if (ao)
			{
				descriptor->BindTexture("AmbientOcclusion", ao, RHITextureDimension::Texture2D);
			}

			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(pipeline_state.get());
			cmd_buffer->Dispatch(output->GetDesc().width, output->GetDesc().height, 1, 8, 8, 1);
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

CONFIGURATION_PASS(CompositePass)

================================================
FILE: Source/Plugin/RenderPass/CopyImageRGBA16.cpp
================================================
#include "IPass.hpp"

#include <Core/Core.hpp>
#include <RenderGraph/RenderGraph.hpp>
#include <RenderGraph/RenderGraphBuilder.hpp>
#include <Renderer/Renderer.hpp>

#include <imgui.h>

using namespace Ilum;

class CopyImageRGBA16 : public RenderPass<CopyImageRGBA16>
{
  public:
	CopyImageRGBA16() = default;

	~CopyImageRGBA16() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Rasterization)
		    .SetName("CopyImageRGBA16")
		    .SetCategory("Transfer")
		    .ReadTexture2D(handle++, "Input", RHIResourceState::TransferSource)
		    .WriteTexture2D(handle++, "Output", RHIFormat::R16G16B16A16_FLOAT, RHIResourceState::TransferDest);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto input = render_graph.GetTexture(desc.GetPin("Input").handle);
			auto output = render_graph.GetTexture(desc.GetPin("Output").handle);
			cmd_buffer->BlitTexture(input, TextureRange{}, RHIResourceState::TransferSource,
			                        output, TextureRange{}, RHIResourceState::TransferDest);
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

CONFIGURATION_PASS(CopyImageRGBA16)

================================================
FILE: Source/Plugin/RenderPass/Debug.cpp
================================================


================================================
FILE: Source/Plugin/RenderPass/Deferred.cpp
================================================


================================================
FILE: Source/Plugin/RenderPass/FXAA.cpp
================================================
#include "IPass.hpp"

#include <bitset>

using namespace Ilum;

class FXAA : public RenderPass<FXAA>
{
	enum class Quality
	{
		Low,
		Medium,
		High
	};

	struct Config
	{
		float   fixed_threshold    = 0.8333f;
		float   relative_threshold = 0.166f;
		float   subpixel_blending  = 0.7f;
		Quality quality            = Quality::High;
	};

  public:
	FXAA() = default;

	~FXAA() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Compute)
		    .SetName("FXAA")
		    .SetCategory("PostProcess")
		    .SetConfig(Config())
		    .ReadTexture2D(handle++, "Input", RHIResourceState::ShaderResource)
		    .WriteTexture2D(handle++, "Output", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		const char *fxaa_qualities[] = {"FXAA_QUALITY_LOW", "FXAA_QUALITY_MEDIUM", "FXAA_QUALITY_HIGH"};

		auto *rhi_context = renderer->GetRHIContext();

		auto pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));

		std::shared_ptr<RHIBuffer> config_buffer = rhi_context->CreateBuffer<Config>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto input  = render_graph.GetTexture(desc.GetPin("Input").handle);
			auto output = render_graph.GetTexture(desc.GetPin("Output").handle);

			auto *gpu_scene = black_board.Get<GPUScene>();
			auto *view      = black_board.Get<View>();

			config_buffer->CopyToDevice(config.Convert<Config>(), sizeof(Config));

			auto       shader      = renderer->RequireShader("Source/Shaders/PostProcess/FXAA.hlsl", "CSmain", RHIShaderStage::Compute, {fxaa_qualities[static_cast<int32_t>(config.Convert<Config>()->quality)]});
			ShaderMeta shader_meta = renderer->RequireShaderMeta(shader);
			auto       descriptor  = rhi_context->CreateDescriptor(shader_meta);

			pipeline_state->ClearShader();
			pipeline_state->SetShader(RHIShaderStage::Compute, shader);

			descriptor->BindTexture("Input", input, RHITextureDimension::Texture2D)
			    .BindTexture("Output", output, RHITextureDimension::Texture2D)
			    .BindSampler("Sampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()))
			    .BindBuffer("ConfigBuffer", config_buffer.get());

			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(pipeline_state.get());
			cmd_buffer->Dispatch(output->GetDesc().width, output->GetDesc().height, 1, 8, 8, 1);
		};
	}

	virtual void OnImGui(Variant *config)
	{
		auto *config_data = config->Convert<Config>();

		const char *qualities[] = {"Low", "Medium", "High"};

		ImGui::Combo("Quality", reinterpret_cast<int32_t *>(&config_data->quality), qualities, 3);
		ImGui::SliderFloat("Fixed Threshold", &config_data->fixed_threshold, 0.0312f, 0.0833f, "%.4f");
		ImGui::SliderFloat("Relative Threshold", &config_data->relative_threshold, 0.063f, 0.333f, "%.4f");
		ImGui::SliderFloat("Subpixel Blending", &config_data->subpixel_blending, 0.f, 1.f, "%.2f");
	}
};

CONFIGURATION_PASS(FXAA)

================================================
FILE: Source/Plugin/RenderPass/Forward.cpp
================================================


================================================
FILE: Source/Plugin/RenderPass/ForwardPlus.cpp
================================================


================================================
FILE: Source/Plugin/RenderPass/IBL.cpp
================================================
#include "IPass.hpp"

using namespace Ilum;

#define IRRADIANCE_CUBEMAP_SIZE 128
#define IRRADIANCE_WORK_GROUP_SIZE 8
#define SH_INTERMEDIATE_SIZE (IRRADIANCE_CUBEMAP_SIZE / IRRADIANCE_WORK_GROUP_SIZE)
#define CUBEMAP_FACE_NUM 6
#define PREFILTER_MAP_SIZE 256
#define PREFILTER_MIP_LEVELS 5

class IBL : public RenderPass<IBL>
{
	enum class EnvironmentMapType
	{
		Skybox,
		Procedure
	};

	struct Config
	{
		EnvironmentMapType type = EnvironmentMapType::Skybox;

		size_t hash = 0;
	};

  public:
	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Rasterization)
		    .SetName("IBL")
		    .SetCategory("Shading")
		    .SetConfig(Config())
		    .WriteTexture2D(handle++, "IrradianceSH", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess, 9, 1)
		    .WriteTexture2D(handle++, "PrefilterMap", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess, PREFILTER_MAP_SIZE, PREFILTER_MAP_SIZE, CUBEMAP_FACE_NUM, PREFILTER_MIP_LEVELS);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		auto *rhi_context = renderer->GetRHIContext();

		struct PipelineInfo
		{
			std::shared_ptr<RHIPipelineState> pipeline_state = nullptr;

			ShaderMeta shader_meta;
		};

		PipelineInfo cubemap_sh_projection;
		PipelineInfo cubemap_sh_add;
		PipelineInfo cubemap_prefilter;

		{
			auto shader = renderer->RequireShader("Source/Shaders/Shading/IBL.hlsl", "CubemapSHProjection", RHIShaderStage::Compute);

			cubemap_sh_projection.pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));
			cubemap_sh_projection.pipeline_state->SetShader(RHIShaderStage::Compute, shader);
			cubemap_sh_projection.shader_meta = renderer->RequireShaderMeta(shader);
		}

		{
			auto shader = renderer->RequireShader("Source/Shaders/Shading/IBL.hlsl", "CubemapSHAdd", RHIShaderStage::Compute);

			cubemap_sh_add.pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));
			cubemap_sh_add.pipeline_state->SetShader(RHIShaderStage::Compute, shader);
			cubemap_sh_add.shader_meta = renderer->RequireShaderMeta(shader);
		}

		{
			auto shader = renderer->RequireShader("Source/Shaders/Shading/IBL.hlsl", "CubmapPrefilter", RHIShaderStage::Compute);

			cubemap_prefilter.pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));
			cubemap_prefilter.pipeline_state->SetShader(RHIShaderStage::Compute, shader);
			cubemap_prefilter.shader_meta = renderer->RequireShaderMeta(shader);
		}

		std::shared_ptr<RHIBuffer>  config_buffer   = std::move(rhi_context->CreateBuffer<Config>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU));
		std::shared_ptr<RHITexture> sh_intermediate = std::move(rhi_context->CreateTexture2DArray(SH_INTERMEDIATE_SIZE * 9, SH_INTERMEDIATE_SIZE, 6, RHIFormat::R32G32B32A32_FLOAT, RHITextureUsage::UnorderedAccess | RHITextureUsage::ShaderResource, false));

		{
			auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Compute);
			cmd_buffer->Begin();
			cmd_buffer->ResourceStateTransition({
			                                        TextureStateTransition{
			                                            sh_intermediate.get(),
			                                            RHIResourceState::Undefined,
			                                            RHIResourceState::ShaderResource,
			                                        },
			                                    },
			                                    {});
			cmd_buffer->End();
			rhi_context->Execute(cmd_buffer);
		}

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto irradiance_sh = render_graph.GetTexture(desc.GetPin("IrradianceSH").handle);
			auto prefilter_map = render_graph.GetTexture(desc.GetPin("PrefilterMap").handle);

			auto   *gpu_scene   = black_board.Get<GPUScene>();
			auto   *view        = black_board.Get<View>();
			Config *config_data = config.Convert<Config>();

			if (gpu_scene->texture.texture_cube)
			{
				if (config_data->hash != Hash(gpu_scene->texture.texture_cube, irradiance_sh, prefilter_map))
				{
					config_data->hash = Hash(gpu_scene->texture.texture_cube, irradiance_sh, prefilter_map);
				}
				else
				{
					return;
				}

				// Diffuse Environment PRT
				{
					cmd_buffer->BeginMarker("Diffuse Environment PRT");

					// Resource Transition
					{
						cmd_buffer->ResourceStateTransition({
						                                        TextureStateTransition{
						                                            sh_intermediate.get(),
						                                            RHIResourceState::ShaderResource,
						                                            RHIResourceState::UnorderedAccess,
						                                        },
						                                    },
						                                    {});
					}

					// Cubemap SH Projection
					{
						cmd_buffer->BeginMarker("Cubemap SH Projection");
						auto descriptor = rhi_context->CreateDescriptor(cubemap_sh_projection.shader_meta);
						descriptor->BindTexture("Skybox", gpu_scene->texture.texture_cube, RHITextureDimension::TextureCube)
						    .BindSampler("SkyboxSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()))
						    .BindTexture("SHIntermediate", sh_intermediate.get(), RHITextureDimension::Texture2DArray);
						cmd_buffer->BindDescriptor(descriptor);
						cmd_buffer->BindPipelineState(cubemap_sh_projection.pipeline_state.get());
						cmd_buffer->Dispatch(IRRADIANCE_CUBEMAP_SIZE, IRRADIANCE_CUBEMAP_SIZE, 6, IRRADIANCE_WORK_GROUP_SIZE, IRRADIANCE_WORK_GROUP_SIZE, 1);
						cmd_buffer->EndMarker();
					}

					// Resource Transition
					{
						cmd_buffer->ResourceStateTransition({
						                                        TextureStateTransition{
						                                            sh_intermediate.get(),
						                                            RHIResourceState::UnorderedAccess,
						                                            RHIResourceState::ShaderResource,
						                                        },
						                                    },
						                                    {});
					}

					// Cubemap SH Add
					{
						cmd_buffer->BeginMarker("Cubemap SH Add");
						auto descriptor = rhi_context->CreateDescriptor(cubemap_sh_add.shader_meta);
						descriptor->BindTexture("IrradianceSH", irradiance_sh, RHITextureDimension::Texture2D)
						    .BindTexture("SHIntermediate", sh_intermediate.get(), RHITextureDimension::Texture2DArray);
						cmd_buffer->BindDescriptor(descriptor);
						cmd_buffer->BindPipelineState(cubemap_sh_add.pipeline_state.get());
						cmd_buffer->Dispatch(9, SH_INTERMEDIATE_SIZE, CUBEMAP_FACE_NUM, 1, SH_INTERMEDIATE_SIZE, CUBEMAP_FACE_NUM);
						cmd_buffer->EndMarker();
					}
					cmd_buffer->EndMarker();
				}

				// Specular Prefilter
				{
					cmd_buffer->BeginMarker("Cubemap Prefilter");
					for (uint32_t i = 0; i < PREFILTER_MIP_LEVELS; i++)
					{
						auto *descriptor = rhi_context->CreateDescriptor(cubemap_prefilter.shader_meta);
						descriptor->BindTexture("Skybox", gpu_scene->texture.texture_cube, RHITextureDimension::TextureCube)
						    .BindSampler("SkyboxSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()))
						    .BindTexture("PrefilterMap", prefilter_map, TextureRange{RHITextureDimension::Texture2DArray, i, 1, 0, 6});
						cmd_buffer->BindDescriptor(descriptor);
						cmd_buffer->BindPipelineState(cubemap_prefilter.pipeline_state.get());
						cmd_buffer->Dispatch(PREFILTER_MAP_SIZE << i, PREFILTER_MAP_SIZE << i, 6, 8, 8, 1);
					}
					cmd_buffer->EndMarker();
				}
			}
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

CONFIGURATION_PASS(IBL)

================================================
FILE: Source/Plugin/RenderPass/IPass.hpp
================================================
#pragma once

#include <Core/Core.hpp>
#include <RenderGraph/RenderGraph.hpp>
#include <RenderGraph/RenderGraphBlackboard.hpp>
#include <RenderGraph/RenderGraphBuilder.hpp>
#include <Renderer/RenderData.hpp>
#include <Renderer/Renderer.hpp>

#include <imgui.h>

namespace Ilum
{
class RenderPassDesc;
class RenderGraphBuilder;
class Renderer;
}        // namespace Ilum

struct ImGuiContext;

using namespace Ilum;

template <typename T>
class RenderPass
{
  public:
	RenderPass() = default;

	~RenderPass() = default;

	static T &GetInstance()
	{
		static T instance;
		return instance;
	}

	virtual RenderPassDesc Create(size_t &handle)
	{
		return RenderPassDesc{};
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

#define CONFIGURATION_PASS(Pass)                                                                                                                   \
	extern "C"                                                                                                                                     \
	{                                                                                                                                              \
		EXPORT_API void Create(RenderPassDesc *desc, size_t &handle)                                                                           \
		{                                                                                                                                          \
			*desc = Pass::GetInstance().Create(handle);                                                                                        \
		}                                                                                                                                          \
		EXPORT_API void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer) \
		{                                                                                                                                          \
			Pass::GetInstance().CreateCallback(task, desc, builder, renderer);                                                                     \
		}                                                                                                                                          \
		EXPORT_API void OnImGui(Variant *config, ImGuiContext *context)                                                                            \
		{                                                                                                                                          \
			ImGui::SetCurrentContext(context);                                                                                                     \
			Pass::GetInstance().OnImGui(config);                                                                                                   \
		}                                                                                                                                          \
	}

================================================
FILE: Source/Plugin/RenderPass/PassData.hpp
================================================
#pragma once

#include <RHI/RHIContext.hpp>

namespace Ilum
{
struct ShadowMapCache
{
	// Texture2D Array
	std::unique_ptr<RHITexture> shadow_map = nullptr;

	// Texture2D Array
	std::unique_ptr<RHITexture> cascade_shadow_map = nullptr;

	// TextureCube Array
	std::unique_ptr<RHITexture> omni_shadow_map = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Plugin/RenderPass/PathTracing.cpp
================================================
#include "IPass.hpp"

#include <Material/MaterialData.hpp>
#include <Resource/Resource/Mesh.hpp>
#include <Resource/Resource/SkinnedMesh.hpp>
#include <Resource/ResourceManager.hpp>
#include <Scene/Components/AllComponents.hpp>
#include <Scene/Scene.hpp>

using namespace Ilum;

class PathTracing : public RenderPass<PathTracing>
{
	struct Config
	{
		uint32_t max_bounce      = 5;
		uint32_t max_spp         = 100;
		uint32_t frame_count     = 0;
		float    clamp_threshold = 4.f;
		uint32_t     anti_aliasing   = 1;
	};

  public:
	PathTracing() = default;

	~PathTracing() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::RayTracing)
		    .SetName("PathTracing")
		    .SetCategory("RayTracing")
		    .SetConfig(Config())
		    .WriteTexture2D(handle++, "Output", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		struct
		{
			std::shared_ptr<RHIPipelineState> pipeline = nullptr;
		} pipeline;

		pipeline.pipeline = std::shared_ptr<RHIPipelineState>(std::move(renderer->GetRHIContext()->CreatePipelineState()));

		std::shared_ptr<RHIBuffer> config_buffer = std::shared_ptr<RHIBuffer>(std::move(renderer->GetRHIContext()->CreateBuffer(sizeof(Config), RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU)));

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto  output      = render_graph.GetTexture(desc.GetPin("Output").handle);
			auto *gpu_scene   = black_board.Get<GPUScene>();
			auto *view        = black_board.Get<View>();
			auto *rhi_context = renderer->GetRHIContext();
			auto *config_data = config.Convert<Config>();

			config_buffer->CopyToDevice(config_data, sizeof(Config));

			if (renderer->GetScene()->IsUpdate())
			{
				config_data->frame_count = 0;
			}
			else
			{
				config_data->frame_count = glm::clamp(config_data->frame_count, 0u, config_data->max_spp);
			}

			if (config_data->frame_count == config_data->max_spp)
			{
				return;
			}

			// Setup material pipeline
			ShaderMeta meta;
			{
				pipeline.pipeline->ClearShader();

				auto *raygen_shader     = renderer->RequireShader("Source/Shaders/RayTracing/PathTracing.hlsl", "RayGenMain", RHIShaderStage::RayGen, {"RAYGEN_SHADER", "RAYTRACING_PIPELINE", gpu_scene->texture.texture_cube ? "USE_SKYBOX" : "NO_SKYBOX"});
				auto *closesthit_shader = renderer->RequireShader("Source/Shaders/RayTracing/PathTracing.hlsl", "ClosesthitMain", RHIShaderStage::ClosestHit, {"CLOSESTHIT_SHADER", "RAYTRACING_PIPELINE"}, {"Material/Material.hlsli"});
				auto *miss_shader       = renderer->RequireShader("Source/Shaders/RayTracing/PathTracing.hlsl", "MissMain", RHIShaderStage::Miss, {"MISS_SHADER", "RAYTRACING_PIPELINE"});

				meta += renderer->RequireShaderMeta(raygen_shader);
				meta += renderer->RequireShaderMeta(closesthit_shader);
				meta += renderer->RequireShaderMeta(miss_shader);

				pipeline.pipeline->SetShader(RHIShaderStage::RayGen, raygen_shader);
				pipeline.pipeline->SetShader(RHIShaderStage::ClosestHit, closesthit_shader);
				pipeline.pipeline->SetShader(RHIShaderStage::Miss, miss_shader);

				for (const auto &data : gpu_scene->material.data)
				{
					auto *material_closesthit_shader = renderer->RequireShader("Source/Shaders/RayTracing/PathTracing.hlsl", "ClosesthitMain", RHIShaderStage::ClosestHit, {"CLOSESTHIT_SHADER", "RAYTRACING_PIPELINE", data->signature}, {data->shader});
					pipeline.pipeline->SetShader(RHIShaderStage::ClosestHit, material_closesthit_shader);
					meta += renderer->RequireShaderMeta(material_closesthit_shader);
				}
			}

			if (gpu_scene->opaque_mesh.instance_count > 0)
			{
				auto *descriptor = rhi_context->CreateDescriptor(meta);
				descriptor->BindAccelerationStructure("TopLevelAS", gpu_scene->opaque_tlas.get())
				    .BindTexture("Output", output, RHITextureDimension::Texture2D)
				    .BindBuffer("ConfigBuffer", config_buffer.get())
				    .BindBuffer("InstanceBuffer", gpu_scene->opaque_mesh.instances.get())
				    .BindBuffer("ViewBuffer", view->buffer.get())
				    .BindBuffer("VertexBuffer", gpu_scene->mesh_buffer.vertex_buffers)
				    .BindBuffer("IndexBuffer", gpu_scene->mesh_buffer.index_buffers)
				    .BindTexture("Textures", gpu_scene->texture.texture_2d, RHITextureDimension::Texture2D)
				    .BindSampler("Samplers", gpu_scene->samplers)
				    .BindBuffer("MaterialOffsets", gpu_scene->material.material_offset.get())
				    .BindBuffer("MaterialBuffer", gpu_scene->material.material_buffer.get())
				    .BindBuffer("PointLightBuffer", gpu_scene->light.point_light_buffer.get())
				    .BindBuffer("SpotLightBuffer", gpu_scene->light.spot_light_buffer.get())
				    .BindBuffer("DirectionalLightBuffer", gpu_scene->light.directional_light_buffer.get())
				    .BindBuffer("RectLightBuffer", gpu_scene->light.rect_light_buffer.get())
				    .BindBuffer("LightInfoBuffer", gpu_scene->light.light_info_buffer.get());

				if (gpu_scene->texture.texture_cube)
				{
					descriptor->BindTexture("Skybox", gpu_scene->texture.texture_cube, RHITextureDimension::TextureCube)
					    .BindSampler("SkyboxSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()));
				}

				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(pipeline.pipeline.get());
				cmd_buffer->TraceRay(output->GetDesc().width, output->GetDesc().height, 1);

				config_data->frame_count++;
			}
			else
			{
				config_data->frame_count = 0;
			}
		};
	}

	virtual void OnImGui(Variant *config)
	{
		auto *config_data = config->Convert<Config>();

		ImGui::Text("SPP: %d", config_data->frame_count);

		 if (ImGui::Checkbox("Anti-Aliasing", reinterpret_cast<bool *>(&config_data->anti_aliasing)))
		{
			config_data->frame_count = 0;
		 }

		if (ImGui::SliderInt("Max Bounce", reinterpret_cast<int32_t *>(&config_data->max_bounce), 1, 100))
		{
			config_data->frame_count = 0;
		}

		if (ImGui::DragInt("Max SPP", reinterpret_cast<int32_t *>(&config_data->max_spp), 0.1f, 1, std::numeric_limits<int32_t>::max()))
		{
			config_data->frame_count = 0;
		}

		ImGui::ProgressBar(static_cast<float>(config_data->frame_count) / static_cast<float>(config_data->max_spp),
		                   ImVec2(0.f, 0.f),
		                   (std::to_string(config_data->frame_count) + "/" + std::to_string(config_data->max_spp)).c_str());

		if (ImGui::DragFloat("Clamp Threshold", &config_data->clamp_threshold, 0.1f, 0.0f, std::numeric_limits<float>::max()))
		{
			config_data->frame_count = 0;
		}
	}
};

CONFIGURATION_PASS(PathTracing)

================================================
FILE: Source/Plugin/RenderPass/Present.cpp
================================================
#include "IPass.hpp"

#include <Core/Core.hpp>
#include <RenderGraph/RenderGraph.hpp>
#include <RenderGraph/RenderGraphBuilder.hpp>
#include <Renderer/Renderer.hpp>

#include <imgui.h>

using namespace Ilum;

class Present : public RenderPass<Present>
{
  public:
	Present() = default;

	~Present() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::None)
		    .SetName("Present")
		    .SetCategory("Output")
		    .ReadTexture2D(handle++, "Present", RHIResourceState::ShaderResource);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard& black_board) {
			auto  texture = render_graph.GetTexture(desc.GetPin("Present").handle);
			renderer->SetPresentTexture(texture);
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

CONFIGURATION_PASS(Present)

================================================
FILE: Source/Plugin/RenderPass/RayTracedAO.cpp
================================================
#include "IPass.hpp"

#include <Material/MaterialData.hpp>
#include <Resource/Resource/Mesh.hpp>
#include <Resource/Resource/SkinnedMesh.hpp>
#include <Resource/ResourceManager.hpp>
#include <Scene/Components/AllComponents.hpp>
#include <Scene/Scene.hpp>

using namespace Ilum;

class RayTracedAO : public RenderPass<RayTracedAO>
{
	struct Config
	{
		uint32_t max_bounce      = 5;
		uint32_t max_spp         = 100;
		uint32_t frame_count     = 0;
		float    clamp_threshold = 4.f;
		uint32_t anti_aliasing   = 1;
	};

	struct PipelineDesc
	{
		std::shared_ptr<RHIPipelineState> pipeline_state = nullptr;
		ShaderMeta                        shader_meta;
	};

	struct RayTracedPassData
	{
		std::unique_ptr<RHITexture>                raytrace = nullptr;
		std::array<std::unique_ptr<RHITexture>, 2> ao{nullptr};
		std::array<std::unique_ptr<RHITexture>, 2> history_length{nullptr};
		std::array<std::unique_ptr<RHITexture>, 2> bilateral_blur{nullptr};
	};

  public:
	RayTracedAO() = default;

	~RayTracedAO() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::RayTracing)
		    .SetName("RayTracedAO")
		    .SetCategory("AO")
		    .SetConfig(Config())
		    .WriteTexture2D(handle++, "Output", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		struct
		{
			std::shared_ptr<RHIPipelineState> pipeline = nullptr;
		} pipeline;

		pipeline.pipeline = std::shared_ptr<RHIPipelineState>(std::move(renderer->GetRHIContext()->CreatePipelineState()));

		std::shared_ptr<RHIBuffer> config_buffer = std::shared_ptr<RHIBuffer>(std::move(renderer->GetRHIContext()->CreateBuffer(sizeof(Config), RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU)));

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto  output      = render_graph.GetTexture(desc.GetPin("Output").handle);
			auto *gpu_scene   = black_board.Get<GPUScene>();
			auto *view        = black_board.Get<View>();
			auto *rhi_context = renderer->GetRHIContext();
			auto *config_data = config.Convert<Config>();

			config_buffer->CopyToDevice(config_data, sizeof(Config));
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

CONFIGURATION_PASS(RayTracedAO)

================================================
FILE: Source/Plugin/RenderPass/RayTracingReflection.cpp
================================================


================================================
FILE: Source/Plugin/RenderPass/RayTracingShadow.cpp
================================================


================================================
FILE: Source/Plugin/RenderPass/SSAO.cpp
================================================
#include "IPass.hpp"

#include <random>

using namespace Ilum;

#define SSAO_NOISE_DIM 4
#define SSAO_KERNEL_SIZE 64

class SSAO : public RenderPass<SSAO>
{
  public:
	SSAO() = default;

	~SSAO() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Compute)
		    .SetName("SSAO")
		    .SetCategory("AO")
		    .ReadTexture2D(handle++, "PositionDepth", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "Normal", RHIResourceState::ShaderResource)
		    .WriteTexture2D(handle++, "Output", RHIFormat::R32_FLOAT, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		auto *rhi_context = renderer->GetRHIContext();

		struct PipelineInfo
		{
			std::shared_ptr<RHIPipelineState> pipeline_state = nullptr;
			ShaderMeta                        shader_meta;
		};

		PipelineInfo ssao_pipeline;
		PipelineInfo blur_pipeline;

		{
			auto shader = renderer->RequireShader("Source/Shaders/AmbientOcclusion/SSAO.hlsl", "SSAO", RHIShaderStage::Compute);

			ssao_pipeline.shader_meta    = renderer->RequireShaderMeta(shader);
			ssao_pipeline.pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));
			ssao_pipeline.pipeline_state->SetShader(RHIShaderStage::Compute, shader);
		}

		{
			auto shader = renderer->RequireShader("Source/Shaders/AmbientOcclusion/SSAO.hlsl", "SSAOBlur", RHIShaderStage::Compute);

			blur_pipeline.shader_meta    = renderer->RequireShaderMeta(shader);
			blur_pipeline.pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));
			blur_pipeline.pipeline_state->SetShader(RHIShaderStage::Compute, shader);
		}

		std::default_random_engine            rnd_engine(0);
		std::uniform_real_distribution<float> rnd_dist(0.0f, 1.0f);

		std::shared_ptr<RHIBuffer> sample_buffer = rhi_context->CreateBuffer<glm::vec4>(SSAO_KERNEL_SIZE, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
		// Update sample buffer
		{
			std::vector<glm::vec4> ssao_kernal(SSAO_KERNEL_SIZE);
			for (uint32_t i = 0; i < SSAO_KERNEL_SIZE; ++i)
			{
				glm::vec3 sample(rnd_dist(rnd_engine) * 2.0 - 1.0, rnd_dist(rnd_engine) * 2.0 - 1.0, rnd_dist(rnd_engine));
				sample = glm::normalize(sample);
				sample *= rnd_dist(rnd_engine);
				float scale    = float(i) / float(SSAO_KERNEL_SIZE);
				scale          = glm::mix(0.1f, 1.0f, scale * scale);
				ssao_kernal[i] = glm::vec4(sample * scale, 0.0f);
			}
			sample_buffer->CopyToDevice(ssao_kernal.data(), ssao_kernal.size() * sizeof(glm::vec4));
		}

		std::shared_ptr<RHITexture> noise_texture = rhi_context->CreateTexture2D(SSAO_NOISE_DIM, SSAO_NOISE_DIM, RHIFormat::R32G32B32A32_FLOAT, RHITextureUsage::Transfer | RHITextureUsage::ShaderResource, false);
		// Update noise texture
		{
			std::vector<glm::vec4> ssao_noise(SSAO_NOISE_DIM * SSAO_NOISE_DIM);
			for (unsigned int i = 0; i < SSAO_NOISE_DIM * SSAO_NOISE_DIM; i++)
			{
				ssao_noise[i] = glm::vec4(rnd_dist(rnd_engine) * 2.0f - 1.0f, rnd_dist(rnd_engine) * 2.0f - 1.0f, 0.0f, 0.0f);
			}
			auto staging_buffer = rhi_context->CreateBuffer<glm::vec4>(SSAO_NOISE_DIM * SSAO_NOISE_DIM, RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
			staging_buffer->CopyToDevice(ssao_noise.data(), ssao_noise.size() * sizeof(glm::vec4));
			{
				auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Transfer);
				cmd_buffer->Begin();
				cmd_buffer->ResourceStateTransition({
				                                        TextureStateTransition{noise_texture.get(), RHIResourceState::Undefined, RHIResourceState::TransferDest},
				                                    },
				                                    {});
				cmd_buffer->CopyBufferToTexture(staging_buffer.get(), noise_texture.get(), 0, 0, 1);
				cmd_buffer->ResourceStateTransition({
				                                        TextureStateTransition{noise_texture.get(), RHIResourceState::TransferDest, RHIResourceState::ShaderResource},
				                                    },
				                                    {});
				cmd_buffer->End();
				rhi_context->Execute(cmd_buffer);
			}
		}

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto normal         = render_graph.GetTexture(desc.GetPin("Normal").handle);
			auto position_depth = render_graph.GetTexture(desc.GetPin("PositionDepth").handle);
			auto output         = render_graph.GetTexture(desc.GetPin("Output").handle);

			auto *view = black_board.Get<View>();

			// SSAO
			{
				cmd_buffer->BeginMarker("SSAO");
				auto descriptor = rhi_context->CreateDescriptor(ssao_pipeline.shader_meta);
				descriptor->BindTexture("Normal", normal, RHITextureDimension::Texture2D)
				    .BindTexture("PositionDepth", position_depth, RHITextureDimension::Texture2D)
				    .BindTexture("NoiseTexture", noise_texture.get(), RHITextureDimension::Texture2D)
				    .BindTexture("SSAOMap", output, RHITextureDimension::Texture2D)
				    .BindBuffer("SampleBuffer", sample_buffer.get())
				    .BindBuffer("ViewBuffer", view->buffer.get())
				    .BindSampler("TexSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()));
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(ssao_pipeline.pipeline_state.get());
				cmd_buffer->Dispatch(output->GetDesc().width, output->GetDesc().height, 1, 8, 8, 1);
				cmd_buffer->EndMarker();
			}

			// Sync
			{
				cmd_buffer->ResourceStateTransition({
				                                        TextureStateTransition{output, RHIResourceState::UnorderedAccess, RHIResourceState::UnorderedAccess},
				                                    },
				                                    {});
			}

			// SSAO Blur
			{
				cmd_buffer->BeginMarker("SSAO Blur");
				auto descriptor = rhi_context->CreateDescriptor(blur_pipeline.shader_meta);
				descriptor->BindTexture("SSAOMap", output, RHITextureDimension::Texture2D);
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(blur_pipeline.pipeline_state.get());
				cmd_buffer->Dispatch(output->GetDesc().width, output->GetDesc().height, 1, 8, 8, 1);
				cmd_buffer->EndMarker();
			}
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

CONFIGURATION_PASS(SSAO)

================================================
FILE: Source/Plugin/RenderPass/ShadowMapPass.cpp
================================================
#include "IPass.hpp"
#include "PassData.hpp"

#include <Resource/Resource/Mesh.hpp>
#include <Resource/Resource/SkinnedMesh.hpp>
#include <Resource/ResourceManager.hpp>
#include <Scene/Components/AllComponents.hpp>
#include <Scene/Scene.hpp>

using namespace Ilum;

class ShadowMapPass : public RenderPass<ShadowMapPass>
{
	struct PipelineDesc
	{
		std::shared_ptr<RHIPipelineState> pipeline = nullptr;

		ShaderMeta meta;
	};

	enum class ShadowMapResolution
	{
		VeryLow,
		Low,
		Medium,
		High,
		VeryHigh
	};

	const std::unordered_map<ShadowMapResolution, uint32_t> shadow_map_resolution =
	    {
	        {ShadowMapResolution::VeryHigh, 2048},
	        {ShadowMapResolution::High, 1536},
	        {ShadowMapResolution::Medium, 1024},
	        {ShadowMapResolution::Low, 682},
	        {ShadowMapResolution::VeryLow, 341},
	    };

	struct Config
	{
		ShadowMapResolution shadow_map_resolution         = ShadowMapResolution::Medium;
		ShadowMapResolution cascade_shadow_map_resolution = ShadowMapResolution::Medium;
		ShadowMapResolution omni_map_resolution           = ShadowMapResolution::Medium;

		float bias  = 16.f;
		float slope = 4.5f;
	};

  public:
	ShadowMapPass() = default;

	~ShadowMapPass() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Rasterization)
		    .SetConfig(Config())
		    .SetName("ShadowMapPass")
		    .SetCategory("Shadow")
		    .WriteTexture2D(handle++, "ShadowMap", RHIFormat::D32_FLOAT, RHIResourceState::DepthWrite, 1024, 1024)
		    .WriteTexture2D(handle++, "CascadeShadowMap", RHIFormat::D32_FLOAT, RHIResourceState::DepthWrite, 1024, 1024, 4)
		    .WriteTexture2D(handle++, "OmniShadowMap", RHIFormat::D32_FLOAT, RHIResourceState::DepthWrite, 1024, 1024, 6);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		auto mesh_shadow_pipeline                 = CreatePipeline("Source/Shaders/Shadow/ShadowMap.hlsl", renderer, false);
		auto skinned_mesh_shadow_pipeline         = CreatePipeline("Source/Shaders/Shadow/ShadowMap.hlsl", renderer, true);
		auto mesh_cascade_shadow_pipeline         = CreatePipeline("Source/Shaders/Shadow/CascadeShadowMap.hlsl", renderer, false);
		auto skinned_mesh_cascade_shadow_pipeline = CreatePipeline("Source/Shaders/Shadow/CascadeShadowMap.hlsl", renderer, true);
		auto mesh_omni_shadow_pipeline            = CreatePipeline("Source/Shaders/Shadow/OmniShadowMap.hlsl", renderer, false);
		auto skinned_mesh_omni_shadow_pipeline    = CreatePipeline("Source/Shaders/Shadow/OmniShadowMap.hlsl", renderer, true);

		std::shared_ptr<RHIRenderTarget> shadowmap_render_target         = std::shared_ptr<RHIRenderTarget>(std::move(renderer->GetRHIContext()->CreateRenderTarget()));
		std::shared_ptr<RHIRenderTarget> cascade_shadowmap_render_target = std::shared_ptr<RHIRenderTarget>(std::move(renderer->GetRHIContext()->CreateRenderTarget()));
		std::shared_ptr<RHIRenderTarget> omni_shadowmap_render_target    = std::shared_ptr<RHIRenderTarget>(std::move(renderer->GetRHIContext()->CreateRenderTarget()));

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto   *rhi_context = renderer->GetRHIContext();
			auto   *scene       = renderer->GetScene();
			auto   *gpu_scene   = black_board.Get<GPUScene>();
			Config *config_data = config.Convert<Config>();

			auto *shadow_map         = render_graph.GetTexture(desc.GetPin("ShadowMap").handle);
			auto *cascade_shadow_map = render_graph.GetTexture(desc.GetPin("CascadeShadowMap").handle);
			auto *omni_shadow_map    = render_graph.GetTexture(desc.GetPin("OmniShadowMap").handle);

			auto *shadow_map_cache = black_board.Has<ShadowMapCache>() ? black_board.Get<ShadowMapCache>() : black_board.Add<ShadowMapCache>();

			// Release old shadow map
			{
				if (shadow_map_cache->shadow_map)
				{
					shadow_map_cache->shadow_map = nullptr;
				}

				if (shadow_map_cache->cascade_shadow_map)
				{
					shadow_map_cache->cascade_shadow_map = nullptr;
				}

				if (shadow_map_cache->omni_shadow_map)
				{
					shadow_map_cache->omni_shadow_map = nullptr;
				}
			}

			// Render shadow map for spot light
			{
				auto     spot_lights = scene->GetComponents<Cmpt::SpotLight>();
				uint32_t layers      = 0;
				for (auto &light : spot_lights)
				{
					layers += static_cast<uint32_t>(light->CastShadow());
				}
				uint32_t size = shadow_map_resolution.at(config_data->shadow_map_resolution);

				if (!shadow_map ||
				    shadow_map->GetDesc().width != size ||
				    shadow_map->GetDesc().layers < spot_lights.size())
				{
					shadow_map_cache->shadow_map = render_graph.SetTexture(desc.GetPin("ShadowMap").handle, std::move(rhi_context->CreateTexture2DArray(size, size, layers, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget | RHITextureUsage::ShaderResource, false)));
					shadow_map                   = render_graph.GetTexture(desc.GetPin("ShadowMap").handle);

					cmd_buffer->ResourceStateTransition({TextureStateTransition{
					                                        shadow_map,
					                                        RHIResourceState::Undefined,
					                                        RHIResourceState::DepthWrite,
					                                        TextureRange{RHITextureDimension::Texture2DArray, 0, 1, 0, layers}}},
					                                    {});
				}

				RenderShadowMap(cmd_buffer, mesh_shadow_pipeline, skinned_mesh_shadow_pipeline, renderer, scene, gpu_scene, config_data, shadow_map, shadowmap_render_target.get());
			}

			// Render cascade shadow map for directional light
			{
				auto     directional_lights = scene->GetComponents<Cmpt::DirectionalLight>();
				uint32_t size               = shadow_map_resolution.at(config_data->cascade_shadow_map_resolution);
				uint32_t layers             = glm::max(static_cast<uint32_t>(directional_lights.size() * 4ull), 1u);

				if (!cascade_shadow_map ||
				    cascade_shadow_map->GetDesc().width != size ||
				    cascade_shadow_map->GetDesc().layers < directional_lights.size() * 4)
				{
					shadow_map_cache->cascade_shadow_map = render_graph.SetTexture(desc.GetPin("CascadeShadowMap").handle, std::move(rhi_context->CreateTexture2DArray(size, size, layers, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget | RHITextureUsage::ShaderResource, false)));
					cascade_shadow_map                   = render_graph.GetTexture(desc.GetPin("CascadeShadowMap").handle);
					cmd_buffer->ResourceStateTransition({TextureStateTransition{
					                                        cascade_shadow_map,
					                                        RHIResourceState::Undefined,
					                                        RHIResourceState::DepthWrite,
					                                        TextureRange{RHITextureDimension::Texture2DArray, 0, 1, 0, layers}}},
					                                    {});
				}

				RenderCascadeShadowMap(cmd_buffer, mesh_cascade_shadow_pipeline, skinned_mesh_cascade_shadow_pipeline, renderer, scene, gpu_scene, config_data, cascade_shadow_map, cascade_shadowmap_render_target.get());
			}

			// Render omnidirection shadow map for point light
			{
				auto     point_lights = scene->GetComponents<Cmpt::PointLight>();
				uint32_t layers       = glm::max(static_cast<uint32_t>(point_lights.size() * 6ull), 1u);
				uint32_t size         = shadow_map_resolution.at(config_data->omni_map_resolution);

				if (!omni_shadow_map ||
				    omni_shadow_map->GetDesc().width != size ||
				    omni_shadow_map->GetDesc().layers < point_lights.size() * 6)
				{
					shadow_map_cache->omni_shadow_map = render_graph.SetTexture(desc.GetPin("OmniShadowMap").handle, std::move(rhi_context->CreateTexture2DArray(size, size, layers, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget | RHITextureUsage::ShaderResource, false)));
					omni_shadow_map                   = render_graph.GetTexture(desc.GetPin("OmniShadowMap").handle);
					cmd_buffer->ResourceStateTransition({TextureStateTransition{
					                                        omni_shadow_map,
					                                        RHIResourceState::Undefined,
					                                        RHIResourceState::DepthWrite,
					                                        TextureRange{RHITextureDimension::Texture2DArray, 0, 1, 0, layers}}},
					                                    {});
				}
				RenderOmniShadowMap(cmd_buffer, mesh_omni_shadow_pipeline, skinned_mesh_omni_shadow_pipeline, renderer, scene, gpu_scene, config_data, omni_shadow_map, omni_shadowmap_render_target.get());
			}
		};
	}

	PipelineDesc
	    CreatePipeline(const std::string &path, Renderer *renderer, bool has_skinned)
	{
		PipelineDesc pipeline_desc;

		pipeline_desc.pipeline = std::shared_ptr<RHIPipelineState>(std::move(renderer->GetRHIContext()->CreatePipelineState()));

		RasterizationState rasterization_state;
		rasterization_state.cull_mode  = RHICullMode::None;
		rasterization_state.front_face = RHIFrontFace::Clockwise;
		pipeline_desc.pipeline->SetRasterizationState(rasterization_state);

		DepthStencilState depth_stencil_state  = {};
		depth_stencil_state.depth_write_enable = true;
		depth_stencil_state.depth_test_enable  = true;
		pipeline_desc.pipeline->SetDepthStencilState(depth_stencil_state);

		if (renderer->GetRHIContext()->IsFeatureSupport(RHIFeature::MeshShading))
		{
			auto *task_shader = renderer->RequireShader(path, "ASmain", RHIShaderStage::Task, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});
			auto *mesh_shader = renderer->RequireShader(path, "MSmain", RHIShaderStage::Mesh, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});
			auto *frag_shader = renderer->RequireShader(path, "PSmain", RHIShaderStage::Fragment, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});

			pipeline_desc.pipeline->SetShader(RHIShaderStage::Task, task_shader);
			pipeline_desc.pipeline->SetShader(RHIShaderStage::Mesh, mesh_shader);
			pipeline_desc.pipeline->SetShader(RHIShaderStage::Fragment, frag_shader);

			pipeline_desc.meta = renderer->RequireShaderMeta(task_shader);
			pipeline_desc.meta += renderer->RequireShaderMeta(mesh_shader);
			pipeline_desc.meta += renderer->RequireShaderMeta(frag_shader);
		}
		else
		{
			auto *vertex_shader = renderer->RequireShader(path, "VSmain", RHIShaderStage::Vertex, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});
			auto *frag_shader   = renderer->RequireShader(path, "FSmain", RHIShaderStage::Fragment, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});

			pipeline_desc.pipeline->SetShader(RHIShaderStage::Vertex, vertex_shader);
			pipeline_desc.pipeline->SetShader(RHIShaderStage::Fragment, frag_shader);

			if (has_skinned)
			{
				VertexInputState vertex_input_state = {};
				vertex_input_state.input_bindings   = {
                    VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex), RHIVertexInputRate::Vertex}};
				vertex_input_state.input_attributes = {
				    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, position)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 3, 0, RHIFormat::R32G32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, texcoord0)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Indices, 5, 0, RHIFormat::R32G32B32A32_SINT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, bones[0])},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Indices, 6, 0, RHIFormat::R32G32B32A32_SINT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, bones[4])},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Weights, 7, 0, RHIFormat::R32G32B32A32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, weights[0])},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Weights, 8, 0, RHIFormat::R32G32B32A32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, weights[4])},
				};

				pipeline_desc.pipeline->SetVertexInputState(vertex_input_state);
			}
			else
			{
				VertexInputState vertex_input_state = {};
				vertex_input_state.input_bindings   = {
                    VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::Mesh>::Vertex), RHIVertexInputRate::Vertex}};
				vertex_input_state.input_attributes = {
				    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, position)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 3, 0, RHIFormat::R32G32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, texcoord0)},
				};

				pipeline_desc.pipeline->SetVertexInputState(vertex_input_state);
			}

			pipeline_desc.meta = renderer->RequireShaderMeta(vertex_shader);
			pipeline_desc.meta += renderer->RequireShaderMeta(frag_shader);
		}

		return pipeline_desc;
	}

	void RenderShadowMap(
	    RHICommand         *cmd_buffer,
	    const PipelineDesc &mesh_pipeline,
	    const PipelineDesc &skinned_mesh_pipeline,
	    Renderer           *renderer,
	    Scene              *scene,
	    GPUScene           *gpu_scene,
	    Config             *config,
	    RHITexture         *shadow_map,
	    RHIRenderTarget    *render_target)
	{
		auto *rhi_context = renderer->GetRHIContext();
		auto  spot_lights = scene->GetComponents<Cmpt::SpotLight>();

		RasterizationState rasterization_state;
		rasterization_state.cull_mode         = RHICullMode::None;
		rasterization_state.front_face        = RHIFrontFace::Clockwise;
		rasterization_state.depth_bias_enable = true;
		rasterization_state.depth_bias        = config->bias;
		rasterization_state.depth_bias_slope  = config->slope;
		mesh_pipeline.pipeline->SetRasterizationState(rasterization_state);
		skinned_mesh_pipeline.pipeline->SetRasterizationState(rasterization_state);

		render_target->Clear();
		render_target->Set(shadow_map, RHITextureDimension::Texture2DArray, DepthStencilAttachment{});

		if (rhi_context->IsFeatureSupport(RHIFeature::MeshShading))
		{
			cmd_buffer->BeginMarker("Spot Light Shadow Mapping [Mesh Shader]");

			cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
			cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());

			cmd_buffer->BeginRenderPass(render_target);

			// Draw Opaque Mesh
			if (gpu_scene->opaque_mesh.instance_count > 0)
			{
				auto *descriptor = rhi_context->CreateDescriptor(mesh_pipeline.meta);
				descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_mesh.instances.get())
				    .BindBuffer("VertexBuffer", gpu_scene->mesh_buffer.vertex_buffers)
				    .BindBuffer("IndexBuffer", gpu_scene->mesh_buffer.index_buffers)
				    .BindBuffer("MeshletBuffer", gpu_scene->mesh_buffer.meshlet_buffers)
				    .BindBuffer("MeshletDataBuffer", gpu_scene->mesh_buffer.meshlet_data_buffers)
				    .BindBuffer("SpotLightBuffer", gpu_scene->light.spot_light_buffer.get())
				    .BindBuffer("LightInfoBuffer", gpu_scene->light.light_info_buffer.get());

				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(mesh_pipeline.pipeline.get());
				cmd_buffer->DrawMeshTask(gpu_scene->opaque_mesh.max_meshlet_count, gpu_scene->opaque_mesh.instance_count, static_cast<uint32_t>(spot_lights.size()), 32, 1, 1);
			}

			// Draw Skinned Mesh
			if (gpu_scene->opaque_skinned_mesh.instance_count > 0)
			{
				auto *descriptor = rhi_context->CreateDescriptor(skinned_mesh_pipeline.meta);
				descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_skinned_mesh.instances.get())
				    .BindBuffer("BoneMatrices", gpu_scene->animation.bone_matrics)
				    .BindBuffer("VertexBuffer", gpu_scene->skinned_mesh_buffer.vertex_buffers)
				    .BindBuffer("IndexBuffer", gpu_scene->skinned_mesh_buffer.index_buffers)
				    .BindBuffer("MeshletBuffer", gpu_scene->skinned_mesh_buffer.meshlet_buffers)
				    .BindBuffer("MeshletDataBuffer", gpu_scene->skinned_mesh_buffer.meshlet_data_buffers)
				    .BindBuffer("SpotLightBuffer", gpu_scene->light.spot_light_buffer.get())
				    .BindBuffer("LightInfoBuffer", gpu_scene->light.light_info_buffer.get());

				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(skinned_mesh_pipeline.pipeline.get());
				cmd_buffer->DrawMeshTask(gpu_scene->opaque_skinned_mesh.max_meshlet_count, gpu_scene->opaque_skinned_mesh.instance_count, static_cast<uint32_t>(spot_lights.size()), 32, 1, 1);
			}

			cmd_buffer->EndRenderPass();
			cmd_buffer->EndMarker();
		}
		else
		{
			// cmd_buffer->BeginMarker("Spot Light Shadow Mapping");

			// cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
			// cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());
			// cmd_buffer->BeginRenderPass(render_target);

			//// Draw Mesh
			// if (gpu_scene->mesh_buffer.instance_count > 0)
			//{
			//	auto meshes = renderer->GetScene()->GetComponents<Cmpt::MeshRenderer>();

			//	auto *descriptor = rhi_context->CreateDescriptor(mesh_pipeline.meta);
			//	descriptor->BindBuffer("InstanceBuffer", gpu_scene->mesh_buffer.instances.get());

			//	cmd_buffer->BindDescriptor(descriptor);
			//	cmd_buffer->BindPipelineState(mesh_pipeline.pipeline.get());

			//	uint32_t instance_id = 0;
			//	for (auto &mesh : meshes)
			//	{
			//		auto &submeshes = mesh->GetSubmeshes();
			//		for (auto &submesh : submeshes)
			//		{
			//			auto *resource = renderer->GetResourceManager()->Get<ResourceType::Mesh>(submesh);
			//			if (resource)
			//			{
			//				cmd_buffer->BindVertexBuffer(0, resource->GetVertexBuffer());
			//				cmd_buffer->BindIndexBuffer(resource->GetIndexBuffer());
			//				cmd_buffer->DrawIndexed(static_cast<uint32_t>(resource->GetIndexCount()), 1, 0, 0, instance_id);
			//				instance_id++;
			//			}
			//		}
			//	}
			//}

			//// Draw Skinned Mesh
			// if (gpu_scene->skinned_mesh_buffer.instance_count > 0)
			//{
			//	auto skinned_meshes = renderer->GetScene()->GetComponents<Cmpt::SkinnedMeshRenderer>();

			//	auto *descriptor = rhi_context->CreateDescriptor(skinned_mesh_pipeline.meta);
			//	descriptor->BindBuffer("InstanceBuffer", gpu_scene->skinned_mesh_buffer.instances.get())
			//	    .BindBuffer("BoneMatrices", gpu_scene->animation_buffer.bone_matrics);

			//	cmd_buffer->BindDescriptor(descriptor);
			//	cmd_buffer->BindPipelineState(skinned_mesh_pipeline.pipeline.get());

			//	uint32_t instance_id = 0;
			//	for (auto &skinned_mesh : skinned_meshes)
			//	{
			//		auto &submeshes = skinned_mesh->GetSubmeshes();
			//		for (auto &submesh : submeshes)
			//		{
			//			auto *resource = renderer->GetResourceManager()->Get<ResourceType::SkinnedMesh>(submesh);
			//			if (resource)
			//			{
			//				cmd_buffer->BindVertexBuffer(0, resource->GetVertexBuffer());
			//				cmd_buffer->BindIndexBuffer(resource->GetIndexBuffer());
			//				cmd_buffer->DrawIndexed(static_cast<uint32_t>(resource->GetIndexCount()), 1, 0, 0, instance_id);
			//				instance_id++;
			//			}
			//		}
			//	}
			//}

			// cmd_buffer->EndRenderPass();
			// cmd_buffer->EndMarker();
		}
	}

	void RenderCascadeShadowMap(
	    RHICommand         *cmd_buffer,
	    const PipelineDesc &mesh_pipeline,
	    const PipelineDesc &skinned_mesh_pipeline,
	    Renderer           *renderer,
	    Scene              *scene,
	    GPUScene           *gpu_scene,
	    Config             *config,
	    RHITexture         *cascade_shadow_map,
	    RHIRenderTarget    *render_target)
	{
		auto *rhi_context        = renderer->GetRHIContext();
		auto  directional_lights = scene->GetComponents<Cmpt::DirectionalLight>();

		RasterizationState rasterization_state;
		rasterization_state.cull_mode         = RHICullMode::None;
		rasterization_state.front_face        = RHIFrontFace::Clockwise;
		rasterization_state.depth_bias_enable = true;
		rasterization_state.depth_bias        = config->bias;
		rasterization_state.depth_bias_slope  = config->slope;
		mesh_pipeline.pipeline->SetRasterizationState(rasterization_state);
		skinned_mesh_pipeline.pipeline->SetRasterizationState(rasterization_state);

		render_target->Clear();
		render_target->Set(cascade_shadow_map, RHITextureDimension::Texture2DArray, DepthStencilAttachment{});

		if (rhi_context->IsFeatureSupport(RHIFeature::MeshShading))
		{
			cmd_buffer->BeginMarker("Directional Light Shadow Mapping [Mesh Shader]");

			cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
			cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());

			cmd_buffer->BeginRenderPass(render_target);

			// Draw Mesh
			if (gpu_scene->opaque_mesh.instance_count > 0)
			{
				auto *descriptor = rhi_context->CreateDescriptor(mesh_pipeline.meta);
				descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_mesh.instances.get())
				    .BindBuffer("VertexBuffer", gpu_scene->mesh_buffer.vertex_buffers)
				    .BindBuffer("IndexBuffer", gpu_scene->mesh_buffer.index_buffers)
				    .BindBuffer("MeshletBuffer", gpu_scene->mesh_buffer.meshlet_buffers)
				    .BindBuffer("MeshletDataBuffer", gpu_scene->mesh_buffer.meshlet_data_buffers)
				    .BindBuffer("DirectionalLightBuffer", gpu_scene->light.directional_light_buffer.get())
				    .BindBuffer("LightInfoBuffer", gpu_scene->light.light_info_buffer.get());

				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(mesh_pipeline.pipeline.get());
				cmd_buffer->DrawMeshTask(gpu_scene->opaque_mesh.max_meshlet_count, gpu_scene->opaque_mesh.instance_count, static_cast<uint32_t>(directional_lights.size() * 4), 32, 1, 1);
			}

			// Draw Opaque Skinned Mesh
			if (gpu_scene->opaque_skinned_mesh.instance_count > 0)
			{
				auto *descriptor = rhi_context->CreateDescriptor(skinned_mesh_pipeline.meta);
				descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_skinned_mesh.instances.get())
				    .BindBuffer("BoneMatrices", gpu_scene->animation.bone_matrics)
				    .BindBuffer("VertexBuffer", gpu_scene->skinned_mesh_buffer.vertex_buffers)
				    .BindBuffer("IndexBuffer", gpu_scene->skinned_mesh_buffer.index_buffers)
				    .BindBuffer("MeshletBuffer", gpu_scene->skinned_mesh_buffer.meshlet_buffers)
				    .BindBuffer("MeshletDataBuffer", gpu_scene->skinned_mesh_buffer.meshlet_data_buffers)
				    .BindBuffer("DirectionalLightBuffer", gpu_scene->light.directional_light_buffer.get())
				    .BindBuffer("LightInfoBuffer", gpu_scene->light.light_info_buffer.get());

				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(skinned_mesh_pipeline.pipeline.get());
				cmd_buffer->DrawMeshTask(gpu_scene->opaque_skinned_mesh.max_meshlet_count, gpu_scene->opaque_skinned_mesh.instance_count, static_cast<uint32_t>(directional_lights.size() * 4), 32, 1, 1);
			}

			cmd_buffer->EndRenderPass();
			cmd_buffer->EndMarker();
		}
		else
		{
			// cmd_buffer->BeginMarker("Spot Light Shadow Mapping");

			// cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
			// cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());
			// cmd_buffer->BeginRenderPass(render_target);

			//// Draw Mesh
			// if (gpu_scene->mesh_buffer.instance_count > 0)
			//{
			//	auto meshes = renderer->GetScene()->GetComponents<Cmpt::MeshRenderer>();

			//	auto *descriptor = rhi_context->CreateDescriptor(mesh_pipeline.meta);
			//	descriptor->BindBuffer("InstanceBuffer", gpu_scene->mesh_buffer.instances.get());

			//	cmd_buffer->BindDescriptor(descriptor);
			//	cmd_buffer->BindPipelineState(mesh_pipeline.pipeline.get());

			//	uint32_t instance_id = 0;
			//	for (auto &mesh : meshes)
			//	{
			//		auto &submeshes = mesh->GetSubmeshes();
			//		for (auto &submesh : submeshes)
			//		{
			//			auto *resource = renderer->GetResourceManager()->Get<ResourceType::Mesh>(submesh);
			//			if (resource)
			//			{
			//				cmd_buffer->BindVertexBuffer(0, resource->GetVertexBuffer());
			//				cmd_buffer->BindIndexBuffer(resource->GetIndexBuffer());
			//				cmd_buffer->DrawIndexed(static_cast<uint32_t>(resource->GetIndexCount()), 1, 0, 0, instance_id);
			//				instance_id++;
			//			}
			//		}
			//	}
			//}

			//// Draw Skinned Mesh
			// if (gpu_scene->skinned_mesh_buffer.instance_count > 0)
			//{
			//	auto skinned_meshes = renderer->GetScene()->GetComponents<Cmpt::SkinnedMeshRenderer>();

			//	auto *descriptor = rhi_context->CreateDescriptor(skinned_mesh_pipeline.meta);
			//	descriptor->BindBuffer("InstanceBuffer", gpu_scene->skinned_mesh_buffer.instances.get())
			//	    .BindBuffer("BoneMatrices", gpu_scene->animation_buffer.bone_matrics);

			//	cmd_buffer->BindDescriptor(descriptor);
			//	cmd_buffer->BindPipelineState(skinned_mesh_pipeline.pipeline.get());

			//	uint32_t instance_id = 0;
			//	for (auto &skinned_mesh : skinned_meshes)
			//	{
			//		auto &submeshes = skinned_mesh->GetSubmeshes();
			//		for (auto &submesh : submeshes)
			//		{
			//			auto *resource = renderer->GetResourceManager()->Get<ResourceType::SkinnedMesh>(submesh);
			//			if (resource)
			//			{
			//				cmd_buffer->BindVertexBuffer(0, resource->GetVertexBuffer());
			//				cmd_buffer->BindIndexBuffer(resource->GetIndexBuffer());
			//				cmd_buffer->DrawIndexed(static_cast<uint32_t>(resource->GetIndexCount()), 1, 0, 0, instance_id);
			//				instance_id++;
			//			}
			//		}
			//	}
			//}

			// cmd_buffer->EndRenderPass();
			// cmd_buffer->EndMarker();
		}
		// cmd_buffer->ResourceStateTransition({TextureStateTransition{
		//                                         shadow_map_data->cascade_shadow_map.get(),
		//                                         RHIResourceState::DepthWrite,
		//                                         RHIResourceState::ShaderResource,
		//                                         TextureRange{RHITextureDimension::Texture2DArray, 0, 1, 0, layers}}},
		//                                     {});
	}

	void RenderOmniShadowMap(
	    RHICommand         *cmd_buffer,
	    const PipelineDesc &mesh_pipeline,
	    const PipelineDesc &skinned_mesh_pipeline,
	    Renderer           *renderer,
	    Scene              *scene,
	    GPUScene           *gpu_scene,
	    Config             *config,
	    RHITexture         *omni_shadow_map,
	    RHIRenderTarget    *render_target)
	{
		auto *rhi_context  = renderer->GetRHIContext();
		auto  point_lights = scene->GetComponents<Cmpt::PointLight>();

		render_target->Clear();
		render_target->Set(omni_shadow_map, RHITextureDimension::Texture2DArray, DepthStencilAttachment{});

		if (rhi_context->IsFeatureSupport(RHIFeature::MeshShading))
		{
			cmd_buffer->BeginMarker("Point Light Shadow Mapping [Mesh Shader]");

			cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
			cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());

			cmd_buffer->BeginRenderPass(render_target);

			// Draw Opaque Mesh
			if (gpu_scene->opaque_mesh.instance_count > 0)
			{
				auto *descriptor = rhi_context->CreateDescriptor(mesh_pipeline.meta);
				descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_mesh.instances.get())
				    .BindBuffer("VertexBuffer", gpu_scene->mesh_buffer.vertex_buffers)
				    .BindBuffer("IndexBuffer", gpu_scene->mesh_buffer.index_buffers)
				    .BindBuffer("MeshletBuffer", gpu_scene->mesh_buffer.meshlet_buffers)
				    .BindBuffer("MeshletDataBuffer", gpu_scene->mesh_buffer.meshlet_data_buffers)
				    .BindBuffer("PointLightBuffer", gpu_scene->light.point_light_buffer.get())
				    .BindBuffer("LightInfoBuffer", gpu_scene->light.light_info_buffer.get());

				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(mesh_pipeline.pipeline.get());
				cmd_buffer->DrawMeshTask(gpu_scene->opaque_mesh.max_meshlet_count, gpu_scene->opaque_mesh.instance_count, static_cast<uint32_t>(point_lights.size() * 6), 32, 1, 1);
			}

			// Draw Opaque Skinned Mesh
			if (gpu_scene->opaque_skinned_mesh.instance_count > 0)
			{
				auto *descriptor = rhi_context->CreateDescriptor(skinned_mesh_pipeline.meta);
				descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_skinned_mesh.instances.get())
				    .BindBuffer("BoneMatrices", gpu_scene->animation.bone_matrics)
				    .BindBuffer("VertexBuffer", gpu_scene->skinned_mesh_buffer.vertex_buffers)
				    .BindBuffer("IndexBuffer", gpu_scene->skinned_mesh_buffer.index_buffers)
				    .BindBuffer("MeshletBuffer", gpu_scene->skinned_mesh_buffer.meshlet_buffers)
				    .BindBuffer("MeshletDataBuffer", gpu_scene->skinned_mesh_buffer.meshlet_data_buffers)
				    .BindBuffer("PointLightBuffer", gpu_scene->light.point_light_buffer.get())
				    .BindBuffer("LightInfoBuffer", gpu_scene->light.light_info_buffer.get());

				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(skinned_mesh_pipeline.pipeline.get());
				cmd_buffer->DrawMeshTask(gpu_scene->opaque_skinned_mesh.max_meshlet_count, gpu_scene->opaque_skinned_mesh.instance_count, static_cast<uint32_t>(point_lights.size() * 6), 32, 1, 1);
			}

			cmd_buffer->EndRenderPass();
			cmd_buffer->EndMarker();
		}
		else
		{
			// cmd_buffer->BeginMarker("Spot Light Shadow Mapping");

			// cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
			// cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());
			// cmd_buffer->BeginRenderPass(render_target);

			//// Draw Mesh
			// if (gpu_scene->mesh_buffer.instance_count > 0)
			//{
			//	auto meshes = renderer->GetScene()->GetComponents<Cmpt::MeshRenderer>();

			//	auto *descriptor = rhi_context->CreateDescriptor(mesh_pipeline.meta);
			//	descriptor->BindBuffer("InstanceBuffer", gpu_scene->mesh_buffer.instances.get());

			//	cmd_buffer->BindDescriptor(descriptor);
			//	cmd_buffer->BindPipelineState(mesh_pipeline.pipeline.get());

			//	uint32_t instance_id = 0;
			//	for (auto &mesh : meshes)
			//	{
			//		auto &submeshes = mesh->GetSubmeshes();
			//		for (auto &submesh : submeshes)
			//		{
			//			auto *resource = renderer->GetResourceManager()->Get<ResourceType::Mesh>(submesh);
			//			if (resource)
			//			{
			//				cmd_buffer->BindVertexBuffer(0, resource->GetVertexBuffer());
			//				cmd_buffer->BindIndexBuffer(resource->GetIndexBuffer());
			//				cmd_buffer->DrawIndexed(static_cast<uint32_t>(resource->GetIndexCount()), 1, 0, 0, instance_id);
			//				instance_id++;
			//			}
			//		}
			//	}
			//}

			//// Draw Skinned Mesh
			// if (gpu_scene->skinned_mesh_buffer.instance_count > 0)
			//{
			//	auto skinned_meshes = renderer->GetScene()->GetComponents<Cmpt::SkinnedMeshRenderer>();

			//	auto *descriptor = rhi_context->CreateDescriptor(skinned_mesh_pipeline.meta);
			//	descriptor->BindBuffer("InstanceBuffer", gpu_scene->skinned_mesh_buffer.instances.get())
			//	    .BindBuffer("BoneMatrices", gpu_scene->animation_buffer.bone_matrics);

			//	cmd_buffer->BindDescriptor(descriptor);
			//	cmd_buffer->BindPipelineState(skinned_mesh_pipeline.pipeline.get());

			//	uint32_t instance_id = 0;
			//	for (auto &skinned_mesh : skinned_meshes)
			//	{
			//		auto &submeshes = skinned_mesh->GetSubmeshes();
			//		for (auto &submesh : submeshes)
			//		{
			//			auto *resource = renderer->GetResourceManager()->Get<ResourceType::SkinnedMesh>(submesh);
			//			if (resource)
			//			{
			//				cmd_buffer->BindVertexBuffer(0, resource->GetVertexBuffer());
			//				cmd_buffer->BindIndexBuffer(resource->GetIndexBuffer());
			//				cmd_buffer->DrawIndexed(static_cast<uint32_t>(resource->GetIndexCount()), 1, 0, 0, instance_id);
			//				instance_id++;
			//			}
			//		}
			//	}
			//}

			// cmd_buffer->EndRenderPass();
			// cmd_buffer->EndMarker();
		}
	}

	virtual void OnImGui(Variant *config)
	{
		Config *config_data = config->Convert<Config>();

		ImGui::PushItemWidth(ImGui::GetContentRegionAvail().x / 2.f);
		ImGui::DragFloat("Depth Bias", &config_data->bias, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
		ImGui::DragFloat("Depth Slope", &config_data->slope, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");

		const char *resolution[] = {"VeryLow", "Low", "Medium", "High", "VeryHigh"};
		ImGui::Text("Shadow Map Resolution");
		ImGui::Combo("Spot Light", reinterpret_cast<int32_t *>(&config_data->shadow_map_resolution), resolution, 5);
		ImGui::Combo("Point Light", reinterpret_cast<int32_t *>(&config_data->omni_map_resolution), resolution, 5);
		ImGui::Combo("Directional Light", reinterpret_cast<int32_t *>(&config_data->cascade_shadow_map_resolution), resolution, 5);

		ImGui::PopItemWidth();
	}
};

CONFIGURATION_PASS(ShadowMapPass)

================================================
FILE: Source/Plugin/RenderPass/SkyboxPass.cpp
================================================
#include "IPass.hpp"

#include <imgui.h>

using namespace Ilum;

class SkyboxPass : public RenderPass<SkyboxPass>
{
  public:
	SkyboxPass() = default;

	~SkyboxPass() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Rasterization)
		    .SetName("SkyboxPass")
		    .SetCategory("Shading")
		    .ReadTexture2D(handle++, "Depth", RHIResourceState::DepthRead)
		    .WriteTexture2D(handle++, "Output", RHIFormat::R16G16B16A16_FLOAT, RHIResourceState::RenderTarget);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		auto *rhi_context    = renderer->GetRHIContext();
		auto  pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));
		auto  render_target  = std::shared_ptr<RHIRenderTarget>(std::move(rhi_context->CreateRenderTarget()));

		auto vertex_shader   = renderer->RequireShader("Source/Shaders/Shading/Skybox.hlsl", "VSmain", RHIShaderStage::Vertex);
		auto fragment_shader = renderer->RequireShader("Source/Shaders/Shading/Skybox.hlsl", "PSmain", RHIShaderStage::Fragment);

		ShaderMeta shader_meta = renderer->RequireShaderMeta(vertex_shader);
		shader_meta += renderer->RequireShaderMeta(fragment_shader);

		BlendState blend_state;
		blend_state.attachment_states.resize(1);

		DepthStencilState depth_stencil_state;
		depth_stencil_state.depth_test_enable  = true;
		depth_stencil_state.depth_write_enable = false;
		depth_stencil_state.compare            = RHICompareOp::Less;

		RasterizationState rasterization_state;
		rasterization_state.cull_mode = RHICullMode::None;
		rasterization_state.front_face = RHIFrontFace::Clockwise;

		pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader);
		pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader);
		pipeline_state->SetBlendState(blend_state);
		pipeline_state->SetDepthStencilState(depth_stencil_state);
		pipeline_state->SetRasterizationState(rasterization_state);

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto depth = render_graph.GetTexture(desc.GetPin("Depth").handle);
			auto output = render_graph.GetTexture(desc.GetPin("Output").handle);

			auto *gpu_scene = black_board.Get<GPUScene>();
			auto *view = black_board.Get<View>();

			render_target->Clear();
			render_target->Set(0, output, TextureRange{}, ColorAttachment{});
			render_target->Set(depth, TextureRange{}, DepthStencilAttachment{RHILoadAction::Load});

			if (gpu_scene->texture.texture_cube)
			{
				auto descriptor = rhi_context->CreateDescriptor(shader_meta);

				descriptor->BindTexture("Skybox", gpu_scene->texture.texture_cube, RHITextureDimension::TextureCube)
				    .BindSampler("SkyboxSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()))
					.BindBuffer("ViewBuffer", view->buffer.get());

				cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
				cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());
				cmd_buffer->BeginRenderPass(render_target.get());
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(pipeline_state.get());
				cmd_buffer->Draw(36);
				cmd_buffer->EndRenderPass();
			}
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

CONFIGURATION_PASS(SkyboxPass)

================================================
FILE: Source/Plugin/RenderPass/Tonemapping.cpp
================================================
#include "IPass.hpp"

#include <bitset>

using namespace Ilum;

class Tonemapping : public RenderPass<Tonemapping>
{
	struct Config
	{
		float   brightness    = 1.f;
		float   contrast      = 1.f;
		float   saturation    = 1.f;
		float   vignette      = 0.f;
		float   avg_lum       = 1.f;
		int32_t auto_exposure = 0;
		float   Ywhite        = 0.5f;        // Burning white
		float   key           = 0.5f;        // Log-average luminance
	};

  public:
	Tonemapping() = default;

	~Tonemapping() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Compute)
		    .SetName("Tonemapping")
		    .SetCategory("PostProcess")
		    .SetConfig(Config())
		    .ReadTexture2D(handle++, "Input", RHIResourceState::ShaderResource)
		    .WriteTexture2D(handle++, "Output", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		auto *rhi_context    = renderer->GetRHIContext();
		auto  shader      = renderer->RequireShader("Source/Shaders/PostProcess/Tonemapping.hlsl", "CSmain", RHIShaderStage::Compute);
		ShaderMeta shader_meta    = renderer->RequireShaderMeta(shader);

		auto  pipeline_state = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));
		pipeline_state->SetShader(RHIShaderStage::Compute, shader);

		std::shared_ptr<RHIBuffer> uniform_buffer = rhi_context->CreateBuffer<Config>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto input  = render_graph.GetTexture(desc.GetPin("Input").handle);
			auto output = render_graph.GetTexture(desc.GetPin("Output").handle);

			auto *gpu_scene = black_board.Get<GPUScene>();
			auto *view      = black_board.Get<View>();

			uniform_buffer->CopyToDevice(config.Convert<Config>(), sizeof(Config));

			auto descriptor = rhi_context->CreateDescriptor(shader_meta);

			descriptor->BindTexture("Input", input, RHITextureDimension::Texture2D)
			    .BindTexture("Output", output, RHITextureDimension::Texture2D)
			    .BindSampler("TexSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()))
				.BindBuffer("UniformBuffer", uniform_buffer.get());

			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(pipeline_state.get());
			cmd_buffer->Dispatch(output->GetDesc().width, output->GetDesc().height, 1, 8, 8, 1);
		};
	}

	virtual void OnImGui(Variant *config)
	{
		auto *config_data = config->Convert<Config>();

		std::bitset<8> b(config_data->auto_exposure);

		bool auto_exposure = b.test(0);

		//ImGui::Checkbox("Auto Exposure", &auto_exposure);
		ImGui::SliderFloat("Exposure", &config_data->avg_lum, 0.001f, 5.0f, "%.3f");
		ImGui::SliderFloat("Brightness", &config_data->brightness, 0.0f, 2.0f, "%.3f");
		ImGui::SliderFloat("Contrast", &config_data->contrast, 0.0f, 2.0f, "%.3f");
		ImGui::SliderFloat("Saturation", &config_data->saturation, 0.0f, 5.0f, "%.3f");
		ImGui::SliderFloat("Vignette", &config_data->vignette, 0.0f, 2.0f, "%.3f");

		if (auto_exposure)
		{
			bool localExposure = b.test(1);
			if (ImGui::TreeNode("Auto Settings"))
			{
				ImGui::Checkbox("Local", &localExposure);
				ImGui::SliderFloat("Burning White", &config_data->Ywhite, 0.f, 1.f, "%.3f");
				ImGui::SliderFloat("Brightness", &config_data->key, 0.f, 1.f, "%.3f");
				b.set(1, localExposure);
				ImGui::End();
			}
		}

		b.set(0, auto_exposure);

		config_data->auto_exposure = b.to_ulong();
	}
};

CONFIGURATION_PASS(Tonemapping)

================================================
FILE: Source/Plugin/RenderPass/Triangle.cpp
================================================
#include <RenderGraph/RenderGraph.hpp>
#include <RenderGraph/RenderGraphBuilder.hpp>
#include <Renderer/Renderer.hpp>
#include <Scene/Component/AllComponent.hpp>
#include <Scene/Entity.hpp>
#include <Scene/Scene.hpp>

#include <imgui.h>

#include <iostream>

using namespace Ilum;

struct Config
{
	float a = 1.f;
};

extern "C"
{
	__declspec(dllexport) void CreateDesc(RenderPassDesc *desc)
	{
		desc->SetBindPoint(BindPoint::Rasterization)
		    .Write("Output", RenderResourceDesc::Type::Texture, RHIResourceState::RenderTarget)
		    .SetConfig(Config());
	}

	__declspec(dllexport) void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		auto *vertex_shader   = renderer->RequireShader("Source/Shaders/DrawUV.hlsl", "VSmain", RHIShaderStage::Vertex);
		auto *fragment_shader = renderer->RequireShader("Source/Shaders/DrawUV.hlsl", "PSmain", RHIShaderStage::Fragment);

		ShaderMeta meta;
		meta += renderer->RequireShaderMeta(vertex_shader);
		meta += renderer->RequireShaderMeta(fragment_shader);

		std::shared_ptr<RHIDescriptor>    descriptor     = std::move(renderer->GetRHIContext()->CreateDescriptor(meta));
		std::shared_ptr<RHIPipelineState> pipeline_state = std::move(renderer->GetRHIContext()->CreatePipelineState());
		std::shared_ptr<RHIRenderTarget>  render_target  = std::move(renderer->GetRHIContext()->CreateRenderTarget());

		pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader);
		pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader);

		BlendState bend_state;
		bend_state.attachment_states.resize(1);
		pipeline_state->SetBlendState(bend_state);

		RasterizationState rasterization_state;
		rasterization_state.cull_mode  = RHICullMode::None;
		rasterization_state.front_face = RHIFrontFace::Clockwise;
		pipeline_state->SetRasterizationState(rasterization_state);

		float factor = 1.f;

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, rttr::variant &config) {
			Config config_ = config.convert<Config>();

			render_target->Clear()
			    .Set(0, render_graph.GetTexture(desc.resources.at("Output").handle), RHITextureDimension::Texture2D, ColorAttachment{});
			cmd_buffer->BindDescriptor(descriptor.get());
			cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
			cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());
			cmd_buffer->BeginRenderPass(render_target.get());
			descriptor->SetConstant("a", config_.a).BindBuffer("View", renderer->GetViewBuffer());
			renderer->GetScene()->Execute([&](Entity &entity) {
				auto transform = entity.GetComponent<TransformComponent>().world_transform;
				descriptor->SetConstant("transform", transform);
				cmd_buffer->BindPipelineState(pipeline_state.get());
				cmd_buffer->Draw(3, 1);
			});
			cmd_buffer->EndRenderPass();
		};
	}

	__declspec(dllexport) bool OnImGui(rttr::variant *config, ImGuiContext *context)
	{
		ImGui::SetCurrentContext(context);

		Config config_ = config->convert<Config>();

		bool update = ImGui::DragFloat("a", &config_.a, 0.01f, 0.f, 100.f, "%.3f");

		if (update)
		{
			*config = config_;
		}

		return update;
	}
}

================================================
FILE: Source/Plugin/RenderPass/VisibilityBufferVisualization.cpp
================================================
#include "IPass.hpp"

using namespace Ilum;

class VisibilityBufferVisualization : public RenderPass<VisibilityBufferVisualization>
{
  public:
	VisibilityBufferVisualization() = default;

	~VisibilityBufferVisualization() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Compute)
		    .SetName("VisibilityBufferVisualization")
		    .SetCategory("RenderPath")
		    .ReadTexture2D(handle++, "Visibility Buffer", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "Depth Buffer", RHIResourceState::ShaderResource)
		    .WriteTexture2D(handle++, "Instance ID", RHIFormat::R8G8B8A8_UNORM, RHIResourceState::UnorderedAccess)
		    .WriteTexture2D(handle++, "Primitive ID", RHIFormat::R8G8B8A8_UNORM, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		ShaderMeta meta;

		auto *shader = renderer->RequireShader("Source/Shaders/RenderPath/VisibilityBufferVisualization.hlsl", "CSmain", RHIShaderStage::Compute);
		meta += renderer->RequireShaderMeta(shader);

		std::shared_ptr<RHIPipelineState> pipeline_state = std::move(renderer->GetRHIContext()->CreatePipelineState());

		pipeline_state->SetShader(RHIShaderStage::Compute, shader);

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto *visibility_buffer   = render_graph.GetTexture(desc.GetPin("Visibility Buffer").handle);
			auto *depth_buffer        = render_graph.GetTexture(desc.GetPin("Depth Buffer").handle);
			auto *instance_id_buffer  = render_graph.GetTexture(desc.GetPin("Instance ID").handle);
			auto *primitive_id_buffer = render_graph.GetTexture(desc.GetPin("Primitive ID").handle);

			auto *descriptor = renderer->GetRHIContext()->CreateDescriptor(meta);

			descriptor->BindTexture("VisibilityBuffer", visibility_buffer, RHITextureDimension::Texture2D)
			    .BindTexture("DepthBuffer", depth_buffer, RHITextureDimension::Texture2D)
			    .BindTexture("InstanceID", instance_id_buffer, RHITextureDimension::Texture2D)
			    .BindTexture("PrimitiveID", primitive_id_buffer, RHITextureDimension::Texture2D);

			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(pipeline_state.get());
			cmd_buffer->Dispatch(visibility_buffer->GetDesc().width, visibility_buffer->GetDesc().height, 1, 32, 32, 1);
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}
};

CONFIGURATION_PASS(VisibilityBufferVisualization)


================================================
FILE: Source/Plugin/RenderPass/VisibilityGeometryPass.cpp
================================================
#include "IPass.hpp"

#include <Resource/Resource/Mesh.hpp>
#include <Resource/Resource/SkinnedMesh.hpp>
#include <Resource/ResourceManager.hpp>
#include <Scene/Components/AllComponents.hpp>
#include <Scene/Scene.hpp>

using namespace Ilum;

class VisibilityGeometryPass : public RenderPass<VisibilityGeometryPass>
{
	struct PipelineDesc
	{
		std::shared_ptr<RHIPipelineState> pipeline = nullptr;
		ShaderMeta                        meta;
	};

  public:
	VisibilityGeometryPass() = default;

	~VisibilityGeometryPass() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Rasterization)
		    .SetName("VisibilityGeometryPass")
		    .SetCategory("RenderPath")
		    .WriteTexture2D(handle++, "Visibility Buffer", RHIFormat::R32_UINT, RHIResourceState::RenderTarget)
		    .WriteTexture2D(handle++, "Depth Buffer", RHIFormat::D32_FLOAT, RHIResourceState::DepthWrite);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		std::shared_ptr<RHIRenderTarget> render_target = std::shared_ptr<RHIRenderTarget>(std::move(renderer->GetRHIContext()->CreateRenderTarget()));

		auto mesh_pipeline = CreatePipeline(renderer, false);
		auto skinned_mesh_pipeline = CreatePipeline(renderer, true);

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto  visibility_buffer = render_graph.GetTexture(desc.GetPin("Visibility Buffer").handle);
			auto  depth_stencil     = render_graph.GetTexture(desc.GetPin("Depth Buffer").handle);
			auto *rhi_context       = renderer->GetRHIContext();
			auto *gpu_scene         = black_board.Get<GPUScene>();
			auto *view              = black_board.Get<View>();

			render_target->Clear();
			render_target->Set(0, visibility_buffer, TextureRange{}, ColorAttachment{});
			render_target->Set(depth_stencil, TextureRange{}, DepthStencilAttachment{});

			// Mesh Shading
			if (rhi_context->IsFeatureSupport(RHIFeature::MeshShading))
			{
				cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
				cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());
				cmd_buffer->BeginRenderPass(render_target.get());

				// Draw Opaque Mesh
				if (gpu_scene->opaque_mesh.instance_count > 0)
				{
					auto *descriptor = rhi_context->CreateDescriptor(mesh_pipeline.meta);
					descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_mesh.instances.get())
					    .BindBuffer("ViewBuffer", view->buffer.get())
					    .BindBuffer("VertexBuffer", gpu_scene->mesh_buffer.vertex_buffers)
					    .BindBuffer("IndexBuffer", gpu_scene->mesh_buffer.index_buffers)
					    .BindBuffer("MeshletBuffer", gpu_scene->mesh_buffer.meshlet_buffers)
					    .BindBuffer("MeshletDataBuffer", gpu_scene->mesh_buffer.meshlet_data_buffers);

					cmd_buffer->BindDescriptor(descriptor);
					cmd_buffer->BindPipelineState(mesh_pipeline.pipeline.get());
					cmd_buffer->DrawMeshTask(gpu_scene->opaque_mesh.max_meshlet_count, gpu_scene->opaque_mesh.instance_count, 1, 32, 1, 1);
				}

				// Draw Opaque Skinned Mesh
				if (gpu_scene->opaque_skinned_mesh.instance_count > 0)
				{
					auto *descriptor = rhi_context->CreateDescriptor(skinned_mesh_pipeline.meta);
					descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_skinned_mesh.instances.get())
					    .BindBuffer("ViewBuffer", view->buffer.get())
					    .BindBuffer("BoneMatrices", gpu_scene->animation.bone_matrics)
					    .BindBuffer("VertexBuffer", gpu_scene->skinned_mesh_buffer.vertex_buffers)
					    .BindBuffer("IndexBuffer", gpu_scene->skinned_mesh_buffer.index_buffers)
					    .BindBuffer("MeshletBuffer", gpu_scene->skinned_mesh_buffer.meshlet_buffers)
					    .BindBuffer("MeshletDataBuffer", gpu_scene->skinned_mesh_buffer.meshlet_data_buffers);

					cmd_buffer->BindDescriptor(descriptor);
					cmd_buffer->BindPipelineState(skinned_mesh_pipeline.pipeline.get());
					cmd_buffer->DrawMeshTask(gpu_scene->opaque_skinned_mesh.max_meshlet_count, gpu_scene->opaque_skinned_mesh.instance_count, 1, 32, 1, 1);
				}

				cmd_buffer->EndRenderPass();
			}
			else
			{
				cmd_buffer->SetViewport(static_cast<float>(render_target->GetWidth()), static_cast<float>(render_target->GetHeight()));
				cmd_buffer->SetScissor(render_target->GetWidth(), render_target->GetHeight());
				cmd_buffer->BeginRenderPass(render_target.get());

				// Draw Opaque Mesh
				if (gpu_scene->opaque_mesh.instance_count > 0)
				{
					auto meshes = renderer->GetScene()->GetComponents<Cmpt::MeshRenderer>();

					auto *descriptor = rhi_context->CreateDescriptor(mesh_pipeline.meta);
					descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_mesh.instances.get())
					    .BindBuffer("ViewBuffer", view->buffer.get());

					cmd_buffer->BindDescriptor(descriptor);
					cmd_buffer->BindPipelineState(mesh_pipeline.pipeline.get());

					uint32_t instance_id = 0;
					for (auto &mesh : meshes)
					{
						auto &submeshes = mesh->GetSubmeshes();
						for (auto &submesh : submeshes)
						{
							auto *resource = renderer->GetResourceManager()->Get<ResourceType::Mesh>(submesh);
							if (resource)
							{
								cmd_buffer->BindVertexBuffer(0, resource->GetVertexBuffer());
								cmd_buffer->BindIndexBuffer(resource->GetIndexBuffer());
								cmd_buffer->DrawIndexed(static_cast<uint32_t>(resource->GetIndexCount()), 1, 0, 0, instance_id);
								instance_id++;
							}
						}
					}
				}

				// Draw Opaque Skinned Mesh
				if (gpu_scene->opaque_skinned_mesh.instance_count > 0)
				{
					auto skinned_meshes = renderer->GetScene()->GetComponents<Cmpt::SkinnedMeshRenderer>();

					auto *descriptor = rhi_context->CreateDescriptor(skinned_mesh_pipeline.meta);
					descriptor->BindBuffer("InstanceBuffer", gpu_scene->opaque_skinned_mesh.instances.get())
					    .BindBuffer("ViewBuffer", view->buffer.get())
					    .BindBuffer("BoneMatrices", gpu_scene->animation.bone_matrics);

					cmd_buffer->BindDescriptor(descriptor);
					cmd_buffer->BindPipelineState(skinned_mesh_pipeline.pipeline.get());

					uint32_t instance_id = 0;
					for (auto &skinned_mesh : skinned_meshes)
					{
						auto &submeshes = skinned_mesh->GetSubmeshes();
						for (auto &submesh : submeshes)
						{
							auto *resource = renderer->GetResourceManager()->Get<ResourceType::SkinnedMesh>(submesh);
							if (resource)
							{
								cmd_buffer->BindVertexBuffer(0, resource->GetVertexBuffer());
								cmd_buffer->BindIndexBuffer(resource->GetIndexBuffer());
								cmd_buffer->DrawIndexed(static_cast<uint32_t>(resource->GetIndexCount()), 1, 0, 0, instance_id);
								instance_id++;
							}
						}
					}
				}

				cmd_buffer->EndRenderPass();
			}
		};
	}

	virtual void OnImGui(Variant *config)
	{
	}

	PipelineDesc CreatePipeline(Renderer *renderer, bool has_skinned)
	{
		auto *rhi_context = renderer->GetRHIContext();

		PipelineDesc pipeline_desc;
		pipeline_desc.pipeline = std::shared_ptr<RHIPipelineState>(std::move(rhi_context->CreatePipelineState()));

		if (rhi_context->IsFeatureSupport(RHIFeature::MeshShading))
		{
			auto *task_shader = renderer->RequireShader("Source/Shaders/RenderPath/VisibilityGeometryPass.hlsl", "ASmain", RHIShaderStage::Task, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});
			auto *mesh_shader = renderer->RequireShader("Source/Shaders/RenderPath/VisibilityGeometryPass.hlsl", "MSmain", RHIShaderStage::Mesh, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});
			auto *frag_shader = renderer->RequireShader("Source/Shaders/RenderPath/VisibilityGeometryPass.hlsl", "PSmain", RHIShaderStage::Fragment, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});

			pipeline_desc.pipeline->SetShader(RHIShaderStage::Task, task_shader);
			pipeline_desc.pipeline->SetShader(RHIShaderStage::Mesh, mesh_shader);
			pipeline_desc.pipeline->SetShader(RHIShaderStage::Fragment, frag_shader);

			BlendState blend_state;
			blend_state.attachment_states.resize(1);
			pipeline_desc.pipeline->SetBlendState(blend_state);

			RasterizationState rasterization_state;
			rasterization_state.cull_mode  = RHICullMode::None;
			rasterization_state.front_face = RHIFrontFace::Clockwise;
			pipeline_desc.pipeline->SetRasterizationState(rasterization_state);

			DepthStencilState depth_stencil_state  = {};
			depth_stencil_state.depth_write_enable = true;
			depth_stencil_state.depth_test_enable  = true;
			pipeline_desc.pipeline->SetDepthStencilState(depth_stencil_state);

			pipeline_desc.meta += renderer->RequireShaderMeta(task_shader);
			pipeline_desc.meta += renderer->RequireShaderMeta(mesh_shader);
			pipeline_desc.meta += renderer->RequireShaderMeta(frag_shader);
		}
		else
		{
			auto *vertex_shader = renderer->RequireShader("Source/Shaders/RenderPath/VisibilityGeometryPass.hlsl", "VSmain", RHIShaderStage::Vertex, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});
			auto *frag_shader   = renderer->RequireShader("Source/Shaders/RenderPath/VisibilityGeometryPass.hlsl", "FSmain", RHIShaderStage::Fragment, {has_skinned ? "HAS_SKINNED" : "NO_SKINNED"});

			pipeline_desc.pipeline->SetShader(RHIShaderStage::Vertex, vertex_shader);
			pipeline_desc.pipeline->SetShader(RHIShaderStage::Fragment, frag_shader);

			BlendState blend_state;
			blend_state.attachment_states.resize(1);
			pipeline_desc.pipeline->SetBlendState(blend_state);

			RasterizationState rasterization_state;
			rasterization_state.cull_mode  = RHICullMode::None;
			rasterization_state.front_face = RHIFrontFace::Clockwise;
			pipeline_desc.pipeline->SetRasterizationState(rasterization_state);

			DepthStencilState depth_stencil_state  = {};
			depth_stencil_state.depth_write_enable = true;
			depth_stencil_state.depth_test_enable  = true;
			pipeline_desc.pipeline->SetDepthStencilState(depth_stencil_state);

			VertexInputState vertex_input_state = {};
			if (has_skinned)
			{
				vertex_input_state.input_bindings = {
				    VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex), RHIVertexInputRate::Vertex}};
				vertex_input_state.input_attributes = {
				    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, position)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 3, 0, RHIFormat::R32G32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, texcoord0)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Indices, 5, 0, RHIFormat::R32G32B32A32_SINT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, bones[0])},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Indices, 6, 0, RHIFormat::R32G32B32A32_SINT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, bones[4])},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Weights, 7, 0, RHIFormat::R32G32B32A32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, weights[0])},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Blend_Weights, 8, 0, RHIFormat::R32G32B32A32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, weights[4])},
				};
			}
			else
			{
				vertex_input_state.input_bindings = {
				    VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::Mesh>::Vertex), RHIVertexInputRate::Vertex}};
				vertex_input_state.input_attributes = {
				    VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, position)},
				    VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 3, 0, RHIFormat::R32G32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, texcoord0)},
				};
			}

			pipeline_desc.pipeline->SetVertexInputState(vertex_input_state);
			pipeline_desc.meta += renderer->RequireShaderMeta(vertex_shader);
			pipeline_desc.meta += renderer->RequireShaderMeta(frag_shader);
		}

		return pipeline_desc;
	}
};

CONFIGURATION_PASS(VisibilityGeometryPass)

================================================
FILE: Source/Plugin/RenderPass/VisibilityLightingPass.cpp
================================================
#include "IPass.hpp"
#include "PassData.hpp"

#include <Material/MaterialData.hpp>
#include <Resource/ResourceManager.hpp>

using namespace Ilum;

class VisibilityLightingPass : public RenderPass<VisibilityLightingPass>
{
	enum class ShadowFilterMode
	{
		None,
		Hard,
		PCF,
		PCSS
	};

	struct Config
	{
		ShadowFilterMode shadow_filter_mode = ShadowFilterMode::PCF;
	};

	std::unordered_map<ShadowFilterMode, const char *> shadow_filter_modes = {
	    {ShadowFilterMode::None, "SHADOW_FILTER_NONE"},
	    {ShadowFilterMode::Hard, "SHADOW_FILTER_HARD"},
	    {ShadowFilterMode::PCF, "SHADOW_FILTER_PCF"},
	    {ShadowFilterMode::PCSS, "SHADOW_FILTER_PCSS"},
	};

  public:
	VisibilityLightingPass() = default;

	~VisibilityLightingPass() = default;

	virtual RenderPassDesc Create(size_t &handle)
	{
		RenderPassDesc desc;
		return desc.SetBindPoint(BindPoint::Compute)
		    .SetName("VisibilityLightingPass")
		    .SetCategory("RenderPath")
		    .SetConfig(Config())
		    .ReadTexture2D(handle++, "Visibility Buffer", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "Depth Buffer", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "ShadowMap", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "CascadeShadowMap", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "OmniShadowMap", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "IrradianceSH", RHIResourceState::ShaderResource)
		    .ReadTexture2D(handle++, "PrefilterMap", RHIResourceState::ShaderResource)
		    .WriteTexture2D(handle++, "Position Depth", RHIFormat::R32G32B32A32_FLOAT, RHIResourceState::UnorderedAccess)
		    .WriteTexture2D(handle++, "Normal Roughness", RHIFormat::R8G8B8A8_UNORM, RHIResourceState::UnorderedAccess)
		    .WriteTexture2D(handle++, "Albedo Metallic", RHIFormat::R8G8B8A8_UNORM, RHIResourceState::UnorderedAccess)
		    .WriteTexture2D(handle++, "Env DI", RHIFormat::R16G16B16A16_FLOAT, RHIResourceState::UnorderedAccess)
		    .WriteTexture2D(handle++, "Light DI", RHIFormat::R16G16B16A16_FLOAT, RHIResourceState::UnorderedAccess);
	}

	virtual void CreateCallback(RenderGraph::RenderTask *task, const RenderPassDesc &desc, RenderGraphBuilder &builder, Renderer *renderer)
	{
		std::shared_ptr<RHIPipelineState> pipeline_state = std::move(renderer->GetRHIContext()->CreatePipelineState());

		struct LightingPassData
		{
			std::unique_ptr<RHIBuffer> material_count_buffer   = nullptr;
			std::unique_ptr<RHIBuffer> material_offset_buffer  = nullptr;
			std::unique_ptr<RHIBuffer> material_pixel_buffer   = nullptr;
			std::unique_ptr<RHIBuffer> indirect_command_buffer = nullptr;
		};

		*task = [=](RenderGraph &render_graph, RHICommand *cmd_buffer, Variant &config, RenderGraphBlackboard &black_board) {
			auto *visibility_buffer         = render_graph.GetTexture(desc.GetPin("Visibility Buffer").handle);
			auto *depth_buffer              = render_graph.GetTexture(desc.GetPin("Depth Buffer").handle);
			auto *shadow_map                = render_graph.GetTexture(desc.GetPin("ShadowMap").handle);
			auto *cascade_shadow_map        = render_graph.GetTexture(desc.GetPin("CascadeShadowMap").handle);
			auto *omni_shadow_map           = render_graph.GetTexture(desc.GetPin("OmniShadowMap").handle);
			auto *irradiance_sh             = render_graph.GetTexture(desc.GetPin("IrradianceSH").handle);
			auto *prefilter_map             = render_graph.GetTexture(desc.GetPin("PrefilterMap").handle);
			auto *env_direct_illumination   = render_graph.GetTexture(desc.GetPin("Env DI").handle);
			auto *light_direct_illumination = render_graph.GetTexture(desc.GetPin("Light DI").handle);
			auto *position_depth            = render_graph.GetTexture(desc.GetPin("Position Depth").handle);
			auto *normal_roughness          = render_graph.GetTexture(desc.GetPin("Normal Roughness").handle);
			auto *albedo_metallic           = render_graph.GetTexture(desc.GetPin("Albedo Metallic").handle);

			Config *config_data = config.Convert<Config>();

			GPUScene   *gpu_scene   = black_board.Get<GPUScene>();
			View       *view        = black_board.Get<View>();
			RHIContext *rhi_context = renderer->GetRHIContext();

			LightingPassData *pass_data = black_board.Has<LightingPassData>() ? black_board.Get<LightingPassData>() : black_board.Add<LightingPassData>();

			size_t material_count = renderer->GetResourceManager()->GetValidResourceCount<ResourceType::Material>() + 1;

			bool has_mesh              = gpu_scene->opaque_mesh.instance_count != 0;
			bool has_skinned_mesh      = gpu_scene->opaque_skinned_mesh.instance_count != 0;
			bool has_point_light       = gpu_scene->light.info.point_light_count != 0;
			bool has_spot_light        = gpu_scene->light.info.spot_light_count != 0;
			bool has_directional_light = gpu_scene->light.info.directional_light_count != 0;
			bool has_rect_light        = gpu_scene->light.info.rect_light_count != 0;
			bool has_env_light         = gpu_scene->texture.texture_cube != nullptr;

			if (!pass_data->material_count_buffer ||
			    pass_data->material_count_buffer->GetDesc().size != material_count * sizeof(uint32_t))
			{
				pass_data->material_count_buffer = rhi_context->CreateBuffer<uint32_t>(material_count, RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
			}

			if (!pass_data->material_offset_buffer ||
			    pass_data->material_offset_buffer->GetDesc().size != material_count * sizeof(uint32_t))
			{
				pass_data->material_offset_buffer = rhi_context->CreateBuffer<uint32_t>(material_count, RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
			}

			if (!pass_data->material_pixel_buffer ||
			    pass_data->material_pixel_buffer->GetDesc().size != static_cast<size_t>(visibility_buffer->GetDesc().width * visibility_buffer->GetDesc().height) * sizeof(uint32_t))
			{
				pass_data->material_pixel_buffer = rhi_context->CreateBuffer<uint32_t>(visibility_buffer->GetDesc().width * visibility_buffer->GetDesc().height, RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
			}

			if (!pass_data->indirect_command_buffer ||
			    pass_data->indirect_command_buffer->GetDesc().size != material_count * sizeof(RHIDispatchIndirectCommand))
			{
				pass_data->indirect_command_buffer = rhi_context->CreateBuffer<RHIDispatchIndirectCommand>(material_count, RHIBufferUsage::Indirect | RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
				cmd_buffer->ResourceStateTransition(
				    {},
				    {BufferStateTransition{
				        pass_data->indirect_command_buffer.get(),
				        RHIResourceState::Undefined,
				        RHIResourceState::IndirectBuffer}});
			}

			cmd_buffer->ResourceStateTransition(
			    {TextureStateTransition{
			         light_direct_illumination,
			         RHIResourceState::UnorderedAccess,
			         RHIResourceState::TransferDest},
			     TextureStateTransition{
			         position_depth,
			         RHIResourceState::UnorderedAccess,
			         RHIResourceState::TransferDest},
			     TextureStateTransition{
			         normal_roughness,
			         RHIResourceState::UnorderedAccess,
			         RHIResourceState::TransferDest},
			     TextureStateTransition{
			         albedo_metallic,
			         RHIResourceState::UnorderedAccess,
			         RHIResourceState::TransferDest}},
			    {BufferStateTransition{
			         pass_data->indirect_command_buffer.get(),
			         RHIResourceState::IndirectBuffer,
			         RHIResourceState::TransferDest},
			     BufferStateTransition{
			         pass_data->material_offset_buffer.get(),
			         RHIResourceState::UnorderedAccess,
			         RHIResourceState::TransferDest},
			     BufferStateTransition{
			         pass_data->material_count_buffer.get(),
			         RHIResourceState::UnorderedAccess,
			         RHIResourceState::TransferDest}});

			cmd_buffer->FillTexture(light_direct_illumination, RHIResourceState::TransferDest, TextureRange{}, glm::vec4(0.f));
			cmd_buffer->FillTexture(position_depth, RHIResourceState::TransferDest, TextureRange{}, glm::vec4(0.f));
			cmd_buffer->FillTexture(normal_roughness, RHIResourceState::TransferDest, TextureRange{}, glm::vec4(0.f));
			cmd_buffer->FillTexture(albedo_metallic, RHIResourceState::TransferDest, TextureRange{}, glm::vec4(0.f));
			cmd_buffer->FillBuffer(pass_data->material_offset_buffer.get(), RHIResourceState::TransferDest, pass_data->material_offset_buffer->GetDesc().size);
			cmd_buffer->FillBuffer(pass_data->material_count_buffer.get(), RHIResourceState::TransferDest, pass_data->material_count_buffer->GetDesc().size);
			cmd_buffer->FillBuffer(pass_data->indirect_command_buffer.get(), RHIResourceState::TransferDest, pass_data->indirect_command_buffer->GetDesc().size);

			cmd_buffer->ResourceStateTransition(
			    {TextureStateTransition{
			         light_direct_illumination,
			         RHIResourceState::TransferDest,
			         RHIResourceState::UnorderedAccess},
			     TextureStateTransition{
			         position_depth,
			         RHIResourceState::TransferDest,
			         RHIResourceState::UnorderedAccess},
			     TextureStateTransition{
			         normal_roughness,
			         RHIResourceState::TransferDest,
			         RHIResourceState::UnorderedAccess},
			     TextureStateTransition{
			         albedo_metallic,
			         RHIResourceState::TransferDest,
			         RHIResourceState::UnorderedAccess}},
			    {BufferStateTransition{
			         pass_data->material_offset_buffer.get(),
			         RHIResourceState::TransferDest,
			         RHIResourceState::UnorderedAccess},
			     BufferStateTransition{
			         pass_data->indirect_command_buffer.get(),
			         RHIResourceState::TransferDest,
			         RHIResourceState::UnorderedAccess},
			     BufferStateTransition{
			         pass_data->material_count_buffer.get(),
			         RHIResourceState::TransferDest,
			         RHIResourceState::UnorderedAccess}});

			// Collect material count
			{
				cmd_buffer->BeginMarker("Collect Material Count");
				auto *shader = renderer->RequireShader(
				    "Source/Shaders/RenderPath/VisibilityLightingPass.hlsl",
				    "CollectMaterialCount",
				    RHIShaderStage::Compute,
				    {
				        has_mesh ? "HAS_MESH" : "NO_MESH",
				        has_skinned_mesh ? "HAS_SKINNED_MESH" : "NO_SKINNED_MESH",
				    });
				auto meta = renderer->RequireShaderMeta(shader);
				pipeline_state->ClearShader().SetShader(RHIShaderStage::Compute, shader);
				auto descriptor = rhi_context->CreateDescriptor(meta);
				descriptor->BindTexture("VisibilityBuffer", visibility_buffer, RHITextureDimension::Texture2D)
				    .BindTexture("DepthBuffer", depth_buffer, RHITextureDimension::Texture2D)
				    .BindBuffer("MeshInstanceBuffer", gpu_scene->opaque_mesh.instances.get())
				    .BindBuffer("SkinnedMeshInstanceBuffer", gpu_scene->opaque_skinned_mesh.instances.get())
				    .BindBuffer("MaterialCountBuffer", pass_data->material_count_buffer.get());
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(pipeline_state.get());
				cmd_buffer->Dispatch(visibility_buffer->GetDesc().width, visibility_buffer->GetDesc().height, 1, 8, 8, 1);
				cmd_buffer->EndMarker();
			}

			{
				cmd_buffer->ResourceStateTransition(
				    {},
				    {BufferStateTransition{
				        pass_data->material_count_buffer.get(),
				        RHIResourceState::UnorderedAccess,
				        RHIResourceState::ShaderResource}});
			}

			// Calculate material offset
			{
				cmd_buffer->BeginMarker("Calculate Material Offset");
				auto *shader = renderer->RequireShader(
				    "Source/Shaders/RenderPath/VisibilityLightingPass.hlsl",
				    "CalculateMaterialOffset",
				    RHIShaderStage::Compute);
				auto meta = renderer->RequireShaderMeta(shader);
				pipeline_state->ClearShader().SetShader(RHIShaderStage::Compute, shader);
				auto descriptor = rhi_context->CreateDescriptor(meta);
				descriptor->BindBuffer("MaterialCountBuffer", pass_data->material_count_buffer.get())
				    .BindBuffer("MaterialOffsetBuffer", pass_data->material_offset_buffer.get());
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(pipeline_state.get());
				cmd_buffer->Dispatch(static_cast<uint32_t>(material_count), 1, 1, 128, 1, 1);
				cmd_buffer->EndMarker();
			}

			// Write -> Read
			{
				cmd_buffer->ResourceStateTransition(
				    {},
				    {BufferStateTransition{
				        pass_data->material_offset_buffer.get(),
				        RHIResourceState::UnorderedAccess,
				        RHIResourceState::ShaderResource}});
			}

			// Calculate pixel buffer
			{
				cmd_buffer->BeginMarker("Calculate Pixel Buffer");
				auto *shader = renderer->RequireShader(
				    "Source/Shaders/RenderPath/VisibilityLightingPass.hlsl",
				    "CalculatePixelBuffer",
				    RHIShaderStage::Compute,
				    {
				        has_mesh ? "HAS_MESH" : "NO_MESH",
				        has_skinned_mesh ? "HAS_SKINNED_MESH" : "NO_SKINNED_MESH",
				    });
				auto meta = renderer->RequireShaderMeta(shader);
				pipeline_state->ClearShader().SetShader(RHIShaderStage::Compute, shader);
				auto descriptor = rhi_context->CreateDescriptor(meta);
				descriptor->BindTexture("VisibilityBuffer", visibility_buffer, RHITextureDimension::Texture2D)
				    .BindTexture("DepthBuffer", depth_buffer, RHITextureDimension::Texture2D)
				    .BindBuffer("MeshInstanceBuffer", gpu_scene->opaque_mesh.instances.get())
				    .BindBuffer("SkinnedMeshInstanceBuffer", gpu_scene->opaque_skinned_mesh.instances.get())
				    .BindBuffer("MaterialCountBuffer", pass_data->material_count_buffer.get())
				    .BindBuffer("MaterialOffsetBuffer", pass_data->material_offset_buffer.get())
				    .BindBuffer("MaterialPixelBuffer", pass_data->material_pixel_buffer.get())
				    .BindBuffer("IndirectCommandBuffer", pass_data->indirect_command_buffer.get());
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(pipeline_state.get());
				cmd_buffer->Dispatch(visibility_buffer->GetDesc().width, visibility_buffer->GetDesc().height, 1, 8, 8, 1);
				cmd_buffer->EndMarker();
			}

			{
				cmd_buffer->ResourceStateTransition(
				    {},
				    {BufferStateTransition{
				        pass_data->indirect_command_buffer.get(),
				        RHIResourceState::UnorderedAccess,
				        RHIResourceState::UnorderedAccess}});
			}

			// Calculate indirect argument
			{
				cmd_buffer->BeginMarker("Calculate Indirect Argument");
				auto *shader = renderer->RequireShader(
				    "Source/Shaders/RenderPath/VisibilityLightingPass.hlsl",
				    "CalculateIndirectArgument",
				    RHIShaderStage::Compute);
				auto meta = renderer->RequireShaderMeta(shader);
				pipeline_state->ClearShader().SetShader(RHIShaderStage::Compute, shader);
				auto descriptor = rhi_context->CreateDescriptor(meta);
				descriptor->BindBuffer("IndirectCommandBuffer", pass_data->indirect_command_buffer.get());
				cmd_buffer->BindDescriptor(descriptor);
				cmd_buffer->BindPipelineState(pipeline_state.get());
				cmd_buffer->Dispatch(static_cast<uint32_t>(material_count), 1, 1, 8, 1, 1);
				cmd_buffer->EndMarker();
			}

			// Write -> Read
			{
				cmd_buffer->ResourceStateTransition(
				    {},
				    {BufferStateTransition{
				         pass_data->material_pixel_buffer.get(),
				         RHIResourceState::UnorderedAccess,
				         RHIResourceState::ShaderResource},
				     BufferStateTransition{
				         pass_data->indirect_command_buffer.get(),
				         RHIResourceState::UnorderedAccess,
				         RHIResourceState::IndirectBuffer}});
			}

			// Dispatch
			{
				cmd_buffer->BeginMarker("Dispatch Indirect");
				for (size_t i = 0; i < material_count; i++)
				{
					auto *shader = renderer->RequireShader(
					    "Source/Shaders/RenderPath/VisibilityLightingPass.hlsl",
					    "DispatchIndirect",
					    RHIShaderStage::Compute,
					    {
					        has_mesh ? "HAS_MESH" : "NO_MESH",
					        has_skinned_mesh ? "HAS_SKINNED_MESH" : "NO_SKINNED_MESH",
					        has_point_light ? "HAS_POINT_LIGHT" : "NO_POINT_LIGHT",
					        has_spot_light ? "HAS_SPOT_LIGHT" : "NO_SPOT_LIGHT",
					        has_directional_light ? "HAS_DIRECTIONAL_LIGHT" : "NO_DIRECTIONAL_LIGHT",
					        has_rect_light ? "HAS_RECT_LIGHT" : "NO_RECT_LIGHT",
					        has_env_light ? "HAS_ENV_LIGHT" : "NO_ENV_LIGHT",
					        shadow_map ? "HAS_SHADOW_MAP" : "NO_SHADOW_MAP",
					        cascade_shadow_map ? "HAS_CASCADE_SHADOW_MAP" : "NO_CASCADE_SHADOW_MAP",
					        omni_shadow_map ? "HAS_OMNI_SHADOW_MAP" : "NO_OMNI_SHADOW_MAP",
					        irradiance_sh ? "HAS_IRRADIANCE_SH" : "NO_IRRADIANCE_SH",
					        prefilter_map ? "HAS_PREFILTER_MAP" : "NO_PREFILTER_MAP",
					        shadow_filter_modes.at(config_data->shadow_filter_mode),
					        "DISPATCH_INDIRECT",
					        "MATERIAL_ID=" + std::to_string(i),
					        i == 0 ? "DEFAULT_MATERIAL" : gpu_scene->material.data[i - 1]->signature,
					    },
					    {
					        i == 0 ? "../Material/Material.hlsli" : gpu_scene->material.data[i - 1]->shader,
					    });
					auto meta = renderer->RequireShaderMeta(shader);
					pipeline_state->ClearShader().SetShader(RHIShaderStage::Compute, shader);
					auto descriptor = rhi_context->CreateDescriptor(meta);
					descriptor->BindTexture("VisibilityBuffer", visibility_buffer, RHITextureDimension::Texture2D)
					    .BindBuffer("ViewBuffer", view->buffer.get())
					    .BindBuffer("LightInfoBuffer", gpu_scene->light.light_info_buffer.get())
					    .BindSampler("ShadowMapSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()))
					    .BindBuffer("MaterialPixelBuffer", pass_data->material_pixel_buffer.get())
					    .BindBuffer("MaterialCountBuffer", pass_data->material_count_buffer.get())
					    .BindBuffer("MaterialOffsetBuffer", pass_data->material_offset_buffer.get())
					    .BindTexture("Textures", gpu_scene->texture.texture_2d, RHITextureDimension::Texture2D)
					    .BindSampler("Samplers", gpu_scene->samplers)
					    .BindBuffer("MaterialOffsets", gpu_scene->material.material_offset.get())
					    .BindBuffer("MaterialBuffer", gpu_scene->material.material_buffer.get())
					    .BindTexture("LightDirectIllumination", light_direct_illumination, RHITextureDimension::Texture2D)
					    .BindTexture("EnvDirectIllumination", env_direct_illumination, RHITextureDimension::Texture2D)
					    .BindTexture("PositionDepth", position_depth, RHITextureDimension::Texture2D)
					    .BindTexture("NormalRoughness", normal_roughness, RHITextureDimension::Texture2D)
					    .BindTexture("AlbedoMetallic", albedo_metallic, RHITextureDimension::Texture2D);

					if (has_mesh)
					{
						descriptor->BindBuffer("MeshVertexBuffer", gpu_scene->mesh_buffer.vertex_buffers)
						    .BindBuffer("MeshIndexBuffer", gpu_scene->mesh_buffer.index_buffers)
						    .BindBuffer("MeshInstanceBuffer", gpu_scene->opaque_mesh.instances.get());
					}

					if (has_skinned_mesh)
					{
						descriptor->BindBuffer("SkinnedMeshVertexBuffer", gpu_scene->skinned_mesh_buffer.vertex_buffers)
						    .BindBuffer("SkinnedMeshIndexBuffer", gpu_scene->skinned_mesh_buffer.index_buffers)
						    .BindBuffer("BoneMatrices", gpu_scene->animation.bone_matrics)
						    .BindBuffer("SkinnedMeshInstanceBuffer", gpu_scene->opaque_skinned_mesh.instances.get());
					}

					if (has_point_light)
					{
						descriptor->BindBuffer("PointLightBuffer", gpu_scene->light.point_light_buffer.get());
						if (omni_shadow_map)
						{
							descriptor->BindTexture("PointLightShadow", omni_shadow_map, RHITextureDimension::TextureCubeArray);
						}
					}

					if (has_spot_light)
					{
						descriptor->BindBuffer("SpotLightBuffer", gpu_scene->light.spot_light_buffer.get());
						if (shadow_map)
						{
							descriptor->BindTexture("SpotLightShadow", shadow_map, RHITextureDimension::Texture2DArray);
						}
					}

					if (has_directional_light)
					{
						descriptor->BindBuffer("DirectionalLightBuffer", gpu_scene->light.directional_light_buffer.get());
						if (cascade_shadow_map)
						{
							descriptor->BindTexture("DirectionalLightShadow", cascade_shadow_map, RHITextureDimension::Texture2DArray);
						}
					}

					if (has_rect_light)
					{
						descriptor->BindBuffer("RectLightBuffer", gpu_scene->light.rect_light_buffer.get());
					}

					if (has_env_light)
					{
						if (irradiance_sh)
						{
							descriptor->BindTexture("IrradianceSH", irradiance_sh, RHITextureDimension::Texture2D);
						}
						if (prefilter_map)
						{
							descriptor->BindTexture("PrefilterMap", prefilter_map, RHITextureDimension::TextureCube)
							    .BindSampler("PrefilterMapSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()))
							    .BindTexture("GGXPreintegration", black_board.Get<LUT>()->ggx.get(), RHITextureDimension::Texture2D);
						}
					}

					cmd_buffer->BindDescriptor(descriptor);
					cmd_buffer->BindPipelineState(pipeline_state.get());
					cmd_buffer->DispatchIndirect(pass_data->indirect_command_buffer.get(), i * sizeof(RHIDispatchIndirectCommand));
				}
				cmd_buffer->EndMarker();
			}

			cmd_buffer->ResourceStateTransition(
			    {},
			    {BufferStateTransition{
			         pass_data->indirect_command_buffer.get(),
			         RHIResourceState::IndirectBuffer,
			         RHIResourceState::UnorderedAccess},
			     BufferStateTransition{
			         pass_data->material_offset_buffer.get(),
			         RHIResourceState::ShaderResource,
			         RHIResourceState::UnorderedAccess},
			     BufferStateTransition{
			         pass_data->material_pixel_buffer.get(),
			         RHIResourceState::ShaderResource,
			         RHIResourceState::UnorderedAccess},
			     BufferStateTransition{
			         pass_data->material_count_buffer.get(),
			         RHIResourceState::ShaderResource,
			         RHIResourceState::UnorderedAccess}});
		};
	}

	virtual void OnImGui(Variant *config)
	{
		Config *config_data = config->Convert<Config>();

		const char *const shadow_filter_modes[] = {"None", "Hard", "PCF", "PCSS"};
		ImGui::Combo("Shadow Filter Mode", reinterpret_cast<int32_t *>(&config_data->shadow_filter_mode), shadow_filter_modes, 4);
	}
};

CONFIGURATION_PASS(VisibilityLightingPass)


================================================
FILE: Source/Plugin/RenderPass/xmake.lua
================================================
function add_pass_plugin(category, name)
    target(string.format("RenderPass.%s.%s", category, name))

    set_kind("shared")
    set_group(string.format("Plugin/RenderPass/%s", category))

    add_rules("plugin")
    add_files(string.format("%s.cpp", name))
    add_headerfiles("IPass.hpp", "PassData.hpp")
    add_includedirs("./")
    add_deps("Core", "RHI", "RenderGraph", "Renderer", "Scene", "Resource", "Geometry", "Material")
    add_packages("imgui")

    target("Plugin")
        add_deps(string.format("RenderPass.%s.%s", category, name))
    target_end()

    target_end()
end

add_pass_plugin("Output", "Present")
add_pass_plugin("Transfer", "CopyImageRGBA16")
add_pass_plugin("RayTracing", "PathTracing")
add_pass_plugin("RenderPath", "VisibilityGeometryPass")
add_pass_plugin("RenderPath", "VisibilityLightingPass")
add_pass_plugin("RenderPath", "VisibilityBufferVisualization")
add_pass_plugin("Shading", "IBL")
add_pass_plugin("Shading", "SkyBoxPass")
add_pass_plugin("Shading", "ShadowMapPass")
add_pass_plugin("Shading", "CompositePass")
add_pass_plugin("PostProcess", "Bloom")
add_pass_plugin("PostProcess", "FXAA")
add_pass_plugin("PostProcess", "Tonemapping")
add_pass_plugin("Shadow", "ShadowMapPass")
add_pass_plugin("AO", "SSAO")
add_pass_plugin("AO", "RayTracedAO")


================================================
FILE: Source/Plugin/xmake.lua
================================================
includes("RHI")
includes("Editor")
includes("Importer")
includes("Geometry")
includes("RenderPass")
includes("MaterialNode")

================================================
FILE: Source/Runtime/Core/Private/JobSystem.cpp
================================================
#include "JobSystem.hpp"
#include "Precompile.hpp"

namespace Ilum
{
SpinLock::SpinLock() :
    m_flag{ATOMIC_FLAG_INIT}
{
}

void SpinLock::Lock()
{
	while (m_flag.test_and_set(std::memory_order_acquire))
		;
}

void SpinLock::Unlock()
{
	m_flag.clear(std::memory_order_release);
}

ThreadPool::ThreadPool(uint32_t max_threads_num)
{
	for (uint32_t i = 0; i < max_threads_num; i++)
	{
		m_workers.emplace_back(
		    [this]() {
			    while (true)
			    {
				    std::function<void()> task;

				    {
					    std::unique_lock<std::mutex> lock(m_mutex);
					    m_condition.wait(lock, [this]() { return m_stop || !m_task_queue.Empty(); });
					    if (m_stop && m_task_queue.Empty())
					    {
						    return;
					    }
					    m_task_queue.TryPop(task);
				    }

				    task();
			    }
		    });
	}
}

ThreadPool ::~ThreadPool()
{
	{
		std::unique_lock<std::mutex> lock(m_mutex);
		m_stop = true;
	}

	m_condition.notify_all();
	for (auto &worker : m_workers)
	{
		worker.join();
	}
}

size_t ThreadPool::GetThreadCount() const
{
	return m_workers.size();
}

void ThreadPool::WaitAll()
{
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		m_condition.notify_all();
	}

	for (auto &worker : m_workers)
	{
		if (worker.joinable())
		{
			worker.join();
		}
	}
}

JobNode::JobNode(std::function<void()> &&task) :
    m_task(task)
{
}

std::type_index JobNode::GetType()
{
	return typeid(JobNode);
}

void JobNode::Percede(JobNode *node)
{
	if (!node)
	{
		return;
	}

	m_successors.push_back(node);
	node->m_dependents.push_back(this);
	node->m_unfinish_dependents++;
}

void JobNode::Succeed(JobNode *node)
{
	if (!node)
	{
		return;
	}

	node->m_successors.push_back(this);
	this->m_dependents.push_back(node);
	this->m_unfinish_dependents++;
}

bool JobNode::Compile()
{
	return true;
}

void JobNode::Run()
{
	assert(m_unfinish_dependents == 0 && "Some dependents haven't completed yet");

	m_task();

	m_unfinish_dependents = static_cast<uint32_t>(m_dependents.size());

	for (auto *node : m_successors)
	{
		node->m_unfinish_dependents.fetch_sub(1, std::memory_order_relaxed);
	}
}

std::type_index JobGraph::GetType()
{
	return typeid(JobGraph);
}

JobGraph &JobGraph::AddNode(JobNode *node)
{
	m_nodes.push_back(node);
	return *this;
}

bool JobGraph::Compile()
{
	std::queue<JobNode *>  queue;
	std::vector<JobNode *> result;

	std::unordered_map<JobNode *, uint32_t> in_degree;

	for (auto *node : m_nodes)
	{
		if (in_degree.find(node) != in_degree.end())
		{
			return false;
		}

		in_degree[node] = static_cast<uint32_t>(node->m_dependents.size());
		if (in_degree[node] == 0)
		{
			queue.push(node);
		}
	}

	while (!queue.empty())
	{
		auto *t = queue.front();
		queue.pop();

		if (!t->Compile())
		{
			return false;
		}

		result.push_back(t);

		for (auto *node : t->m_successors)
		{
			in_degree[node]--;
			if (in_degree[node] == 0)
			{
				queue.push(node);
			}
		}
	}

	if (result.size() == m_nodes.size())
	{
		m_nodes = std::move(result);
		return true;
	}

	return false;
}

void JobGraph::Run()
{
	Compile();

	for (auto &node : m_nodes)
	{
		node->Run();
	}
}

JobSystem::JobSystem()
{
	m_thread_pool = std::make_unique<ThreadPool>(std::thread::hardware_concurrency() - 1);
}

JobSystem::~JobSystem()
{
	m_thread_pool.reset();
}

JobSystem &JobSystem::GetInstance()
{
	static JobSystem job_system;
	return job_system;
}

size_t JobSystem::GetThreadCount()
{
	return m_thread_pool->GetThreadCount();
}

void JobSystem::Execute(JobHandle &handle, JobGraph &graph)
{
	std::unordered_set<JobNode *> finished_nodes;

	handle.m_counter.fetch_add(static_cast<uint32_t>(graph.m_nodes.size()));

	while (handle.m_counter > 0)
	{
		for (auto &node : graph.m_nodes)
		{
			if (node->m_unfinish_dependents == 0 && finished_nodes.find(node) == finished_nodes.end())
			{
				finished_nodes.insert(node);

				if (node->GetType() == typeid(JobNode))
				{
					m_thread_pool->AddTask([&node, &handle]() {
						node->Run();
						handle.m_counter.fetch_sub(1);
					});
				}
				else
				{
					m_thread_pool->AddTask([&node, &handle, this]() {
						handle.m_counter.fetch_sub(1);
						Execute(handle, *static_cast<JobGraph *>(node));
					});
				}
			}
		}
	}
}

void JobSystem::Execute(JobHandle &handle, JobNode &node)
{
	handle.m_counter.fetch_add(1);

	m_thread_pool->AddTask([&node, &handle]() { node.Run();handle.m_counter.fetch_sub(1); });
}

void JobSystem::Dispatch(JobHandle &handle, uint32_t job_count, uint32_t group_size, const std::function<void(uint32_t)> &task)
{
	uint32_t group_count = (job_count + group_size - 1) / group_size;

	handle.m_counter.fetch_add(group_count);

	for (uint32_t group_id = 0; group_id < group_count; group_id++)
	{
		m_thread_pool->AddTask([task, &handle, group_id]() {
			task(group_id);
			handle.m_counter.fetch_sub(1);
		});
	}
}

bool JobSystem::IsBusy(const JobHandle &handle)
{
	return handle.m_counter.load() > 0;
}

void JobSystem::Wait(const JobHandle &handle)
{
	while (IsBusy(handle))
	{
		// wait...
	}
}

void JobSystem::WaitAll()
{
	m_thread_pool->WaitAll();
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Private/Log.cpp
================================================
#include "Log.hpp"

#include <spdlog/async.h>
#include <spdlog/details/log_msg_buffer.h>
#include <spdlog/sinks/basic_file_sink.h>

namespace Ilum
{
class Sink : public spdlog::sinks::base_sink<std::mutex>
{
  public:
	struct LogMsg
	{
		spdlog::level::level_enum level;
		std::string               msg;
	};

  public:
	// Thread unsafe
	const std::deque<LogMsg> &GetLogs() const
	{
		return m_log_msgs;
	}

	// Thread safe
	std::vector<LogMsg> CopyLogs() const
	{
		std::lock_guard<std::mutex> lock(const_cast<std::mutex &>(base_sink<std::mutex>::mutex_));
		std::vector<LogMsg>         res(m_log_msgs.begin(), m_log_msgs.end());
		return res;
	}

	void Clear()
	{
		std::lock_guard<std::mutex> lock(base_sink<std::mutex>::mutex_);
		m_log_msgs.clear();
	}

  protected:
	virtual void sink_it_(const spdlog::details::log_msg &msg) override
	{
		spdlog::details::log_msg_buffer buffer(msg);
		spdlog::memory_buf_t            formatted;
		base_sink<std::mutex>::formatter_->format(buffer, formatted);
		m_log_msgs.push_back({msg.level, fmt::to_string(formatted)});
		std::cout << fmt::to_string(formatted);
	}

	virtual void flush_() override
	{
		std::cout << std::flush;
	}

  private:
	std::deque<LogMsg> m_log_msgs;
};

LogSystem::LogSystem()
{
	m_logger = spdlog::synchronous_factory::create<Sink>("Ilum");

	m_logger->set_level(spdlog::level::trace);
}

LogSystem::~LogSystem()
{
	m_logger->flush();
	spdlog::drop_all();
}

LogSystem &LogSystem::GetInstance()
{
	static LogSystem log_system;
	return log_system;
}

}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Private/Path.cpp
================================================
#include "Path.hpp"
#include "Core.hpp"

namespace Ilum
{
Path &Path::GetInstance()
{
	static Path path;
	return path;
}

bool Path::IsExist(const std::string &path)
{
	try
	{
		if (std::filesystem::exists(path))
		{
			return true;
		}
	}
	catch (std::filesystem::filesystem_error &e)
	{
		LOG_WARN("%s. %s", e.what(), path.c_str());
	}
	return false;
}

bool Path::IsFile(const std::string &path)
{
	try
	{
		if (std::filesystem::exists(path) && std::filesystem::is_regular_file(path))
		{
			return true;
		}
	}
	catch (std::filesystem::filesystem_error &e)
	{
		LOG_WARN("%s. %s", e.what(), path.c_str());
	}
	return false;
}

bool Path::IsDirectory(const std::string &path)
{
	try
	{
		if (std::filesystem::exists(path) && std::filesystem::is_directory(path))
		{
			return true;
		}
	}
	catch (std::filesystem::filesystem_error &e)
	{
		LOG_WARN("%s. %s", e.what(), path.c_str());
	}
	return false;
}

bool Path::CreatePath(const std::string &path)
{
	try
	{
		if (std::filesystem::exists(path) || std::filesystem::create_directories(path))
		{
			return true;
		}
	}
	catch (std::filesystem::filesystem_error &e)
	{
		LOG_WARN("{}. {}", e.what(), path.c_str());
	}
	return false;
}

bool Path::DeletePath(const std::string &path)
{
	try
	{
		if (std::filesystem::exists(path) && std::filesystem::remove_all(path))
		{
			return true;
		}
	}
	catch (std::filesystem::filesystem_error &e)
	{
		LOG_WARN("%s. %s", e.what(), path.c_str());
	}
	return false;
}

bool Path::Copy(const std::string &src, const std::string &dst)
{
	if (src == dst)
	{
		return true;
	}
	if (!IsExist(GetFileDirectory(dst)))
	{
		CreatePath(GetFileDirectory(dst));
	}
	try
	{
		return std::filesystem::copy_file(src, dst, std::filesystem::copy_options::overwrite_existing);
	}
	catch (std::filesystem::filesystem_error &e)
	{
		LOG_WARN("%s", e.what());
	}
	return false;
}

void Path::SetCurrent(const std::string &path)
{
	std::filesystem::current_path(path);
}

const std::string Path::GetCurrent(bool convert)
{
	std::string current = std::filesystem::current_path().string();
	if (convert)
	{
		std::replace(current.begin(), current.end(), '\\', '/');
	}
	return current;
}

const std::string Path::GetFileName(const std::string &path, bool has_extension)
{
	auto filename = std::filesystem::u8path(path).filename().generic_string();

	if (has_extension)
	{
		return filename;
	}
	else
	{
		size_t last_index = filename.find_last_of('.');

		if (last_index != std::string::npos)
		{
			return filename.substr(0, last_index);
		}

		return filename;
	}
}

const std::string Path::GetFileDirectory(const std::string &path)
{
	if (IsDirectory(path))
	{
		return path;
	}

	size_t last_index = path.find_last_of("\\/");

	if (last_index != std::string::npos)
	{
		return path.substr(0, last_index + 1);
	}

	return "";
}

const std::string Path::GetFileExtension(const std::string &path)
{
	try
	{
		return std::filesystem::u8path(path).extension().generic_string();
	}
	catch (std::system_error &e)
	{
		LOG_WARN("Failed: %s", e.what());
	}
	return "";
}

const std::string Path::GetRelativePath(const std::string &path)
{
	if (!IsExist(path))
	{
		return "";
	}

	return std::filesystem::relative(path, std::filesystem::current_path()).u8string();
}

bool Path::Save(const std::string &path, const std::vector<uint8_t> &data, bool binary)
{
	std::string dir = GetFileDirectory(path);
	if (!IsExist(dir))
	{
		CreatePath(dir);
	}
	std::ofstream output(path, binary ? std::ofstream::binary : 2);
	output.write(reinterpret_cast<const char *>(data.data()), data.size() * sizeof(uint8_t));
	output.flush();
	output.close();
	return true;
}

bool Path::Read(const std::string &path, std::vector<uint8_t> &data, bool binary, uint32_t begin, uint32_t end)
{
	if (!IsFile(path))
	{
		LOG_ERROR("Failed to read file {}", path);
		return false;
	}

	data.clear();

	std::ifstream file;

	file.open(path, std::ios::in | (binary ? std::ios::binary : 0));

	if (!file.is_open())
	{
		LOG_ERROR("Failed to read file {}", path);
		return false;
	}

	uint64_t read_count = end - begin;

	if ((end == begin && begin == 0) || end < begin)
	{
		file.seekg(0, std::ios::end);
		read_count = static_cast<uint64_t>(file.tellg());
		file.seekg(0, std::ios::beg);
	}

	data.resize(static_cast<size_t>(read_count));
	file.read(reinterpret_cast<char *>(data.data()), read_count);
	file.close();

	return true;
}

std::string Path::Toupper(const std::string &str)
{
	std::locale loc;
	std::string upper;
	for (const auto &word : str)
	{
		upper += std::toupper(word, loc);
	}

	return upper;
}

std::string Path::Replace(const std::string &str, char from, char to)
{
	std::string result = str;
	std::replace(result.begin(), result.end(), from, to);
	return result;
}

std::string Path::ValidFileName(const std::string &str)
{
	std::string result = str;

	std::unordered_set<char> invalid_char = {'\\', '/', ':', '*', '?', '"', '<', '>', '|'};
	
	for (auto& c : result)
	{
		if (invalid_char.find(c) != invalid_char.end())
		{
			c = '_';
		}
	}

	return result;
}

std::vector<std::string> Path::Split(const std::string &str, char delim)
{
	std::vector<std::string> tokens;

	std::stringstream sstream(str);
	std::string       token;
	while (std::getline(sstream, token, delim))
	{
		tokens.push_back(token);
	}

	return tokens;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Private/Plugin.cpp
================================================
#include "Plugin.hpp"

namespace Ilum
{
struct PluginManager::Impl
{
	std::unordered_map<std::string, HMODULE> modules;
};

PluginManager::PluginManager()
{
	m_impl = new Impl;
}

PluginManager::~PluginManager()
{
	for (auto& [name, h_module] : m_impl->modules)
	{
		FreeLibrary(h_module);
	}
	delete m_impl;
}

PluginManager &PluginManager::GetInstance()
{
	static PluginManager plugin_manager;
	return plugin_manager;
}

HMODULE PluginManager::GetLibrary(const std::string &lib_path)
{
	if (m_impl->modules.find(lib_path) == m_impl->modules.end())
	{
		m_impl->modules.emplace(lib_path, LoadLibraryA(lib_path.c_str()));
	}
	return m_impl->modules.at(lib_path);
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Private/Time.cpp
================================================
#include "Time.hpp"

namespace Ilum
{
struct Timer::Impl
{
	Timer::Impl(std::chrono::high_resolution_clock::time_point start, std::chrono::high_resolution_clock::time_point end):
	    start(start), tick_end(end)
	{
	}

	std::chrono::high_resolution_clock::time_point start;
	std::chrono::high_resolution_clock::time_point tick_start;
	std::chrono::high_resolution_clock::time_point tick_end;

	float    time                = 0.f;
	float    delta_time          = 0.f;
	float    delta_time_smoothed = 0.f;
	float    accumlate_time      = 0.f;
	float    frame_rate          = 0.f;
	uint32_t frame_count         = 0u;

	const uint32_t accumulate = 5u;
	const float    duration   = 500.f;
};

Timer::Timer()
{
	p_impl = new Impl(std::chrono::high_resolution_clock::now(), std::chrono::high_resolution_clock::now());
}

Timer::~Timer()
{
	delete p_impl;
	p_impl = nullptr;
}

Timer &Timer::GetInstance()
{
	static Timer timer;
	return timer;
}

float Timer::TotalTime()
{
	return p_impl->time;
}

float Timer::DeltaTime()
{
	return p_impl->delta_time;
}

float Timer::DeltaTimeSmoothed()
{
	return p_impl->delta_time_smoothed;
}

float Timer::FrameRate()
{
	return p_impl->frame_rate;
}

void Timer::Tick()
{
	p_impl->tick_start                                    = std::chrono::high_resolution_clock::now();
	std::chrono::duration<float, std::milli> delta = p_impl->tick_start - p_impl->tick_end;

	p_impl->delta_time = delta.count();
	p_impl->time       = std::chrono::duration<float, std::milli>(p_impl->tick_start - p_impl->start).count();
	p_impl->tick_end   = std::chrono::high_resolution_clock::now();

	p_impl->delta_time_smoothed = p_impl->delta_time_smoothed * (1.f - 1.f / p_impl->accumulate) + p_impl->delta_time / p_impl->accumulate;

	if (p_impl->accumlate_time < p_impl->duration)
	{
		p_impl->accumlate_time += p_impl->delta_time;
		p_impl->frame_count++;
	}
	else
	{
		p_impl->frame_rate            = static_cast<float>(p_impl->frame_count) / (p_impl->accumlate_time / 1000.f);
		p_impl->accumlate_time = 0.f;
		p_impl->frame_count    = 0;
	}
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Private/Variant.cpp
================================================
#include "Variant.hpp"

#include <any>

namespace Ilum
{
Variant::~Variant()
{
	if (m_data)
	{
		m_data.reset();
		m_size = 0;
	}
}

Variant::Variant(Variant &&other) noexcept :
    m_data(std::move(other.m_data)),
    m_size(other.m_size)
{
	other.m_data = nullptr;
}

Variant::Variant(const Variant &other) :
    m_size(other.m_size), m_data(other.m_data)
{
}

Variant &Variant::operator=(Variant &&other) noexcept
{
	m_data = std::move(other.m_data);
	m_size = other.m_size;

	other.m_data = nullptr;

	return *this;
}

Variant &Variant::operator=(const Variant &other)
{
	m_data = other.m_data;
	m_size = other.m_size;

	return *this;
}

bool Variant::Empty() const
{
	return m_data == nullptr;
}

void Variant::Set(const void *data, size_t size)
{
	if (m_size < size)
	{
		m_data = std::shared_ptr<void>(malloc(size));
		m_size = size;
	}

	if (m_data)
	{
		std::memcpy(m_data.get(), data, size);
	}
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Private/Window.cpp
================================================
#include "Window.hpp"
#include "Path.hpp"

#include <GLFW/glfw3.h>

#ifdef _WIN32
#	define GLFW_EXPOSE_NATIVE_WIN32
#endif        // WIN32
#include <GLFW/glfw3native.h>

#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>

namespace Ilum
{
Window::Window(const std::string &title, const std::string &icon, uint32_t width, uint32_t height) :
    m_width(width), m_height(height), m_title(title)
{
	if (!glfwInit())
	{
		return;
	}

	if (width == 0 || height == 0)
	{
		auto *video_mode = glfwGetVideoMode(glfwGetPrimaryMonitor());

		m_width  = static_cast<uint32_t>(video_mode->width * 3 / 4);
		m_height = static_cast<uint32_t>(video_mode->height * 3 / 4);
	}

	glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
	m_handle = glfwCreateWindow(m_width, m_height, title.c_str(), NULL, NULL);
	if (!m_handle)
	{
		glfwTerminate();
		return;
	}

	if (Path::GetInstance().IsFile(icon))
	{
		GLFWimage window_icon = {};
		window_icon.pixels    = stbi_load(icon.data(), &window_icon.width, &window_icon.height, 0, 4);
		glfwSetWindowIcon(m_handle, 1, &window_icon);
		stbi_image_free(window_icon.pixels);
	}

	glfwSetWindowUserPointer(m_handle, this);

	glfwSetKeyCallback(m_handle, [](GLFWwindow *window, int32_t key, int32_t scancode, int32_t action, int32_t mods) {
		Window *handle = (Window *) glfwGetWindowUserPointer(window);
		handle->OnKeyFunc.Invoke(key, scancode, action, mods);
	});

	glfwSetCharCallback(m_handle, [](GLFWwindow *window, uint32_t codepoint) {
		Window *handle = (Window *) glfwGetWindowUserPointer(window);
		handle->OnCharFunc.Invoke(codepoint);
	});

	glfwSetCharModsCallback(m_handle, [](GLFWwindow *window, uint32_t codepoint, int32_t mods) {
		Window *handle = (Window *) glfwGetWindowUserPointer(window);
		handle->OnCharModsFunc.Invoke(codepoint, mods);
	});

	glfwSetMouseButtonCallback(m_handle, [](GLFWwindow *window, int32_t button, int32_t action, int32_t mods) {
		Window *handle = (Window *) glfwGetWindowUserPointer(window);
		handle->OnMouseButtonFunc.Invoke(button, action, mods);
	});

	glfwSetCursorPosCallback(m_handle, [](GLFWwindow *window, double xpos, double ypos) {
		Window *handle        = (Window *) glfwGetWindowUserPointer(window);
		handle->m_pos_delta_x = static_cast<float>(xpos) - handle->m_pos_last_x;
		handle->m_pos_delta_y = static_cast<float>(ypos) - handle->m_pos_last_y;
		handle->OnCursorPosFunc.Invoke(xpos, ypos);
		handle->m_pos_last_x = static_cast<float>(xpos);
		handle->m_pos_last_y = static_cast<float>(ypos);
	});

	glfwSetCursorEnterCallback(m_handle, [](GLFWwindow *window, int32_t entered) {
		Window *handle = (Window *) glfwGetWindowUserPointer(window);
		handle->OnCursorEnterFunc.Invoke(entered);
	});

	glfwSetScrollCallback(m_handle, [](GLFWwindow *window, double xoffset, double yoffset) {
		Window *handle = (Window *) glfwGetWindowUserPointer(window);
		handle->OnScrollFunc.Invoke(xoffset, yoffset);
	});

	glfwSetDropCallback(m_handle, [](GLFWwindow *window, int32_t count, const char **paths) {
		Window *handle = (Window *) glfwGetWindowUserPointer(window);
		handle->OnDropFunc.Invoke(count, paths);
	});

	glfwSetWindowSizeCallback(m_handle, [](GLFWwindow *window, int32_t width, int32_t height) {
		Window *handle = (Window *) glfwGetWindowUserPointer(window);
		handle->OnWindowSizeFunc.Invoke(width, height);
		handle->m_width  = static_cast<uint32_t>(width);
		handle->m_height = static_cast<uint32_t>(height);
	});

	glfwSetWindowCloseCallback(m_handle, [](GLFWwindow *window) {
		glfwSetWindowShouldClose(window, true);
	});

	glfwSetInputMode(m_handle, GLFW_RAW_MOUSE_MOTION, GLFW_FALSE);
}

Window::~Window()
{
	glfwDestroyWindow(m_handle);
	glfwTerminate();
}

bool Window::Tick()
{
	if (!glfwWindowShouldClose(m_handle))
	{
		m_pos_delta_x = 0.f;
		m_pos_delta_y = 0.f;
		glfwPollEvents();
		return true;
	}
	return false;
}

bool Window::IsKeyDown(int32_t key) const
{
	if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
	{
		return false;
	}
	return glfwGetKey(m_handle, key) == GLFW_PRESS;
}

bool Window::IsMouseButtonDown(int32_t button) const
{
	if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
	{
		return false;
	}

	return glfwGetMouseButton(m_handle, button) == GLFW_PRESS;
}

void Window::SetTitle(const std::string &title)
{
	glfwSetWindowTitle(m_handle, title.c_str());
	m_title = title;
}

GLFWwindow *Window::GetHandle() const
{
	return m_handle;
}

void *Window::GetNativeHandle() const
{
	return glfwGetWin32Window(m_handle);
}

uint32_t Window::GetWidth() const
{
	return m_width;
}

uint32_t Window::GetHeight() const
{
	return m_height;
}

bool Window::IsKeyPressed(KeyCode keycode)
{
	auto state = glfwGetKey(m_handle, static_cast<int32_t>(keycode));
	return state == GLFW_PRESS || state == GLFW_REPEAT;
}

bool Window::IsMouseButtonPressed(MouseCode button)
{
	auto state = glfwGetMouseButton(m_handle, static_cast<int32_t>(button));
	return state == GLFW_PRESS;
}

glm::vec2 Window::GetMousePosition()
{
	double xpos, ypos;
	glfwGetCursorPos(m_handle, &xpos, &ypos);
	return glm::vec2{float(xpos), float(ypos)};
}

void Window::SetCursorPosition(const glm::vec2 &pos)
{
	glfwSetCursorPos(m_handle, static_cast<double>(pos.x), static_cast<double>(pos.y));
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/API.hpp
================================================
#pragma once

#define EXPORT_API __declspec(dllexport)
#define IMPORT_API __declspec(dllimport)


================================================
FILE: Source/Runtime/Core/Public/Core/Container.hpp
================================================
#pragma once

#include "Precompile.hpp"

namespace Ilum
{
template <typename _Ty>
class RandomSet
{
  public:
	RandomSet()  = default;
	~RandomSet() = default;

	void insert(_Ty data)
	{
		assert(!has(data));
		m_lookup.emplace(data, m_data.size());
		m_data.push_back(data);
	}

	void erase(_Ty data)
	{
		auto target = m_lookup.find(data);
		assert(target != m_lookup.end());
		auto idx = target->second;
		if (idx != m_data.size() - 1)
		{
			m_lookup[m_data.back()] = idx;
			m_data[idx]             = m_data.back();
		}
		m_data.pop_back();
		m_lookup.erase(target);
	}

	auto begin() noexcept
	{
		return m_data.begin();
	}

	auto begin() const noexcept
	{
		return m_data.begin();
	}

	auto end() noexcept
	{
		return m_data.end();
	}

	auto end() const noexcept
	{
		return m_data.end();
	}

	_Ty operator[](size_t idx) const
	{
		return m_data[idx];
	}

	_Ty &operator[](size_t idx)
	{
		return m_data[idx];
	}

	_Ty at(size_t idx)
	{
		return m_data.at(idx);
	}

	size_t size() const noexcept
	{
		return m_data.size();
	}

	void reserve(size_t n)
	{
		m_data.reserve(n);
		m_lookup.reserve(n);
	}

	void clear() noexcept
	{
		m_data.clear();
		m_lookup.clear();
	}

	const std::vector<_Ty> &vec() const noexcept
	{
		return m_data;
	}

	std::vector<_Ty> &vec() noexcept
	{
		return m_data;
	}

	size_t idx(_Ty data) const
	{
		return m_lookup.at(data);
	}

	bool has(_Ty data) const
	{
		return m_lookup.find(data) != m_lookup.end();
	}

	bool empty() const noexcept
	{
		return m_data.empty();
	}

  private:
	std::unordered_map<_Ty, std::size_t> m_lookup;
	std::vector<_Ty>                     m_data;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/Core.hpp
================================================
#pragma once

#include "Container.hpp"
#include "Hash.hpp"
#include "Log.hpp"
#include "Path.hpp"
#include "Plugin.hpp"
#include "Precompile.hpp"
#include "Variant.hpp"

#include <cereal/types/array.hpp>
#include <cereal/types/map.hpp>
#include <cereal/types/set.hpp>
#include <cereal/types/string.hpp>
#include <cereal/types/unordered_map.hpp>
#include <cereal/types/unordered_set.hpp>
#include <cereal/types/vector.hpp>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtx/matrix_decompose.hpp>
#include <glm/gtx/quaternion.hpp>

#define SERIALIZER_TYPE_JSON 0
#define SERIALIZER_TYPE_BINARY 1
#define SERIALIZER_TYPE_XML 2
#define SERIALIZER_TYPE SERIALIZER_TYPE_BINARY

#define LOG_HELPER(LOG_LEVEL, ...) \
	Ilum::LogSystem::GetInstance().Log(LOG_LEVEL, "[" + std::string(__FUNCTION__) + "] " + __VA_ARGS__);

// Logging
#define LOG_DEBUG(...) LOG_HELPER(Ilum::LogSystem::LogLevel::Debug, __VA_ARGS__);
#define LOG_INFO(...) LOG_HELPER(Ilum::LogSystem::LogLevel::Info, __VA_ARGS__);
#define LOG_WARN(...) LOG_HELPER(Ilum::LogSystem::LogLevel::Warn, __VA_ARGS__);
#define LOG_ERROR(...) LOG_HELPER(Ilum::LogSystem::LogLevel::Error, __VA_ARGS__);
#define LOG_FATAL(...) LOG_HELPER(Ilum::LogSystem::LogLevel::Fatal, __VA_ARGS__);

#if SERIALIZER_TYPE == SERIALIZER_TYPE_JSON
#	include <cereal/archives/json.hpp>
using InputArchive  = cereal::JSONInputArchive;
using OutputArchive = cereal::JSONOutputArchive;
#elif SERIALIZER_TYPE == SERIALIZER_TYPE_BINARY
#	include <cereal/archives/binary.hpp>
using InputArchive  = cereal::BinaryInputArchive;
using OutputArchive = cereal::BinaryOutputArchive;
#elif SERIALIZER_TYPE == SERIALIZER_TYPE_XML
#	include <cereal/archives/xml.hpp>
using InputArchive  = cereal::XMLInputArchive;
using OutputArchive = cereal::XMLOutputArchive;
#else
#	error Must specify a type of serializer!
#endif

#define SERIALIZE(FILE, DATA, ...)                \
	{                                             \
		std::ofstream os(FILE, std::ios::binary); \
		OutputArchive archive(os);                \
		archive(DATA, __VA_ARGS__);               \
	}

#define DESERIALIZE(FILE, DATA, ...)              \
	{                                             \
		std::ifstream is(FILE, std::ios::binary); \
		InputArchive  archive(is);                \
		archive(DATA, __VA_ARGS__);               \
	}

#if defined(__REFLECTION_PARSER__)
#	define META(...) __attribute__((annotate(#__VA_ARGS__)))
#	define CLASS(class_name, ...) class __attribute__((annotate(#__VA_ARGS__))) class_name
#	define STRUCT(struct_name, ...) struct __attribute__((annotate(#__VA_ARGS__))) struct_name
#	define ENUM(enum_name, ...) enum class __attribute__((annotate(#__VA_ARGS__))) enum_name
#else
#	define META(...)
#	define CLASS(class_name, ...) class class_name
#	define STRUCT(struct_name, ...) struct struct_name
#	define ENUM(enum_name, ...) enum class enum_name
#endif        // __REFLECTION_PARSER__

#define DEFINE_ENUMCLASS_OPERATION(EnumClass)                   \
	inline EnumClass operator|(EnumClass lhs, EnumClass rhs)    \
	{                                                           \
		return (EnumClass) ((uint64_t) lhs | (uint64_t) rhs);   \
	}                                                           \
	inline bool operator&(EnumClass lhs, EnumClass rhs)         \
	{                                                           \
		return (bool) ((uint64_t) lhs & (uint64_t) rhs);        \
	}                                                           \
	inline EnumClass &operator|=(EnumClass &lhs, EnumClass rhs) \
	{                                                           \
		return lhs = lhs | rhs;                                 \
	}

namespace glm
{
template <class Archive>
void serialize(Archive &archive, glm::vec2 &m)
{
	archive(m.x, m.y);
}

template <class Archive>
void serialize(Archive &archive, glm::vec3 &m)
{
	archive(m.x, m.y, m.z);
}

template <class Archive>
void serialize(Archive &archive, glm::vec4 &m)
{
	archive(m.x, m.y, m.z, m.w);
}

template <class Archive>
void serialize(Archive &archive, glm::mat4 &m)
{
	archive(
	    m[0][0], m[0][1], m[0][2], m[0][3],
	    m[1][0], m[1][1], m[1][2], m[1][3],
	    m[2][0], m[2][1], m[2][2], m[2][3],
	    m[3][0], m[3][1], m[3][2], m[3][3]);
}

template <class Archive>
void serialize(Archive &archive, glm::quat &m)
{
	archive(m.x, m.y, m.z, m.w);
}
}        // namespace glm


================================================
FILE: Source/Runtime/Core/Public/Core/Delegates.hpp
================================================
#pragma once

#include "Precompile.hpp"

namespace Ilum
{
using DelegateHandle = uint32_t;

template <typename... Args>
class  MulticastDelegate
{
  public:
	using Delegate = std::function<void(Args...)>;

	DelegateHandle Subscribe(Delegate &&delegate)
	{
		while (IsLock())
		{
			std::this_thread::sleep_for(std::chrono::milliseconds(16));
		}

		DelegateHandle id = m_avaliable_id++;
		m_subscribers.emplace(id, std::move(delegate));
		return id;
	}

	DelegateHandle operator+=(Delegate &&delegate)
	{
		return Subscribe(std::move(delegate));
	}

	bool UnSubscribe(const DelegateHandle &handle)
	{
		while (IsLock())
		{
			std::this_thread::sleep_for(std::chrono::milliseconds(16));
		}

		if (m_subscribers.find(handle) != m_subscribers.end())
		{
			m_subscribers.erase(handle);
			return true;
		}
		return false;
	}

	bool operator-=(const DelegateHandle &handle)
	{
		return UnSubscribe(handle);
	}

	void Clear()
	{
		while (IsLock())
		{
			std::this_thread::sleep_for(std::chrono::milliseconds(16));
		}

		m_subscribers.clear();
	}

	void Invoke(Args... args)
	{
		Lock();
		for (auto const &[key, val] : m_subscribers)
		{
			val(args...);
		}
		Unlock();
	}

  private:
	void Lock()
	{
		m_lock++;
	}

	void Unlock()
	{
		assert(m_lock > 0);
		m_lock--;
	}

	bool IsLock()
	{
		return m_lock > 0;
	}

  private:
	std::unordered_map<DelegateHandle, Delegate> m_subscribers;

	DelegateHandle m_avaliable_id = 0;

	int32_t m_lock = 0;
};

}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/Hash.hpp
================================================
#pragma once

#include "Precompile.hpp"

namespace Ilum
{
template <class T>
inline void HashCombine(size_t &seed, const T &v)
{
	std::hash<T> hasher;
	seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

template <typename T>
inline void HashCombine(size_t &seed, const std::vector<T> &v)
{
	for (auto &data : v)
	{
		HashCombine(seed, data);
	}
}

template <class T1, class... T2>
inline void HashCombine(size_t &seed, const T1 &v1, const T2 &...v2)
{
	HashCombine(seed, v1);
	HashCombine(seed, v2...);
}

template <typename T>
inline size_t Hash(const T &v)
{
	size_t hash = 0;
	HashCombine(hash, v);
	return hash;
}

template <typename T1, typename... T2>
inline size_t Hash(const T1 &v1, const T2 &...v2)
{
	size_t hash = 0;
	HashCombine(hash, v1, v2...);
	return hash;
}

struct PairHash
{
	template <class T1, class T2>
	std::size_t operator()(const std::pair<T1, T2> &p) const
	{
		return Hash(p.first, p.second);
	}
};
}        // namespace Ilum


================================================
FILE: Source/Runtime/Core/Public/Core/Input.hpp
================================================
#pragma once

#include "Precompile.hpp"

#include <glm/glm.hpp>

namespace Ilum
{
/*KeyCode*/
typedef enum class KeyCode : uint16_t
{
	// From glfw3.h
	Space      = 32,
	Apostrophe = 39, /* ' */
	Comma      = 44, /* , */
	Minus      = 45, /* - */
	Period     = 46, /* . */
	Slash      = 47, /* / */

	D0 = 48, /* 0 */
	D1 = 49, /* 1 */
	D2 = 50, /* 2 */
	D3 = 51, /* 3 */
	D4 = 52, /* 4 */
	D5 = 53, /* 5 */
	D6 = 54, /* 6 */
	D7 = 55, /* 7 */
	D8 = 56, /* 8 */
	D9 = 57, /* 9 */

	Semicolon = 59, /* ; */
	Equal     = 61, /* = */

	A = 65,
	B = 66,
	C = 67,
	D = 68,
	E = 69,
	F = 70,
	G = 71,
	H = 72,
	I = 73,
	J = 74,
	K = 75,
	L = 76,
	M = 77,
	N = 78,
	O = 79,
	P = 80,
	Q = 81,
	R = 82,
	S = 83,
	T = 84,
	U = 85,
	V = 86,
	W = 87,
	X = 88,
	Y = 89,
	Z = 90,

	LeftBracket  = 91, /* [ */
	Backslash    = 92, /* \ */
	RightBracket = 93, /* ] */
	GraveAccent  = 96, /* ` */

	World1 = 161, /* non-US #1 */
	World2 = 162, /* non-US #2 */

	/* Function keys */
	Escape      = 256,
	Enter       = 257,
	Tab         = 258,
	Backspace   = 259,
	Insert      = 260,
	Delete      = 261,
	Right       = 262,
	Left        = 263,
	Down        = 264,
	Up          = 265,
	PageUp      = 266,
	PageDown    = 267,
	Home        = 268,
	End         = 269,
	CapsLock    = 280,
	ScrollLock  = 281,
	NumLock     = 282,
	PrintScreen = 283,
	Pause       = 284,
	F1          = 290,
	F2          = 291,
	F3          = 292,
	F4          = 293,
	F5          = 294,
	F6          = 295,
	F7          = 296,
	F8          = 297,
	F9          = 298,
	F10         = 299,
	F11         = 300,
	F12         = 301,
	F13         = 302,
	F14         = 303,
	F15         = 304,
	F16         = 305,
	F17         = 306,
	F18         = 307,
	F19         = 308,
	F20         = 309,
	F21         = 310,
	F22         = 311,
	F23         = 312,
	F24         = 313,
	F25         = 314,

	/* Keypad */
	KP0        = 320,
	KP1        = 321,
	KP2        = 322,
	KP3        = 323,
	KP4        = 324,
	KP5        = 325,
	KP6        = 326,
	KP7        = 327,
	KP8        = 328,
	KP9        = 329,
	KPDecimal  = 330,
	KPDivide   = 331,
	KPMultiply = 332,
	KPSubtract = 333,
	KPAdd      = 334,
	KPEnter    = 335,
	KPEqual    = 336,

	LeftShift    = 340,
	LeftControl  = 341,
	LeftAlt      = 342,
	LeftSuper    = 343,
	RightShift   = 344,
	RightControl = 345,
	RightAlt     = 346,
	RightSuper   = 347,
	Menu         = 348
} Key;

inline std::ostream &operator<<(std::ostream &os, KeyCode keyCode)
{
	os << static_cast<int32_t>(keyCode);
	return os;
}

// From glfw3.h
#define KEY_SPACE ::Key::Space
#define KEY_APOSTROPHE ::Key::Apostrophe /* ' */
#define KEY_COMMA ::Key::Comma           /* , */
#define KEY_MINUS ::Key::Minus           /* - */
#define KEY_PERIOD ::Key::Period         /* . */
#define KEY_SLASH ::Key::Slash           /* / */
#define KEY_0 ::Key::D0
#define KEY_1 ::Key::D1
#define KEY_2 ::Key::D2
#define KEY_3 ::Key::D3
#define KEY_4 ::Key::D4
#define KEY_5 ::Key::D5
#define KEY_6 ::Key::D6
#define KEY_7 ::Key::D7
#define KEY_8 ::Key::D8
#define KEY_9 ::Key::D9
#define KEY_SEMICOLON ::Key::Semicolon /* ; */
#define KEY_EQUAL ::Key::Equal         /* = */
#define KEY_A ::Key::A
#define KEY_B ::Key::B
#define KEY_C ::Key::C
#define KEY_D ::Key::D
#define KEY_E ::Key::E
#define KEY_F ::Key::F
#define KEY_G ::Key::G
#define KEY_H ::Key::H
#define KEY_I ::Key::I
#define KEY_J ::Key::J
#define KEY_K ::Key::K
#define KEY_L ::Key::L
#define KEY_M ::Key::M
#define KEY_N ::Key::N
#define KEY_O ::Key::O
#define KEY_P ::Key::P
#define KEY_Q ::Key::Q
#define KEY_R ::Key::R
#define KEY_S ::Key::S
#define KEY_T ::Key::T
#define KEY_U ::Key::U
#define KEY_V ::Key::V
#define KEY_W ::Key::W
#define KEY_X ::Key::X
#define KEY_Y ::Key::Y
#define KEY_Z ::Key::Z
#define KEY_LEFT_BRACKET ::Key::LeftBracket   /* [ */
#define KEY_BACKSLASH ::Key::Backslash        /* \ */
#define KEY_RIGHT_BRACKET ::Key::RightBracket /* ] */
#define KEY_GRAVE_ACCENT ::Key::GraveAccent   /* ` */
#define KEY_WORLD_1 ::Key::World1             /* non-US #1 */
#define KEY_WORLD_2 ::Key::World2             /* non-US #2 */

/* Function keys */
#define KEY_ESCAPE ::Key::Escape
#define KEY_ENTER ::Key::Enter
#define KEY_TAB ::Key::Tab
#define KEY_BACKSPACE ::Key::Backspace
#define KEY_INSERT ::Key::Insert
#define KEY_DELETE ::Key::Delete
#define KEY_RIGHT ::Key::Right
#define KEY_LEFT ::Key::Left
#define KEY_DOWN ::Key::Down
#define KEY_UP ::Key::Up
#define KEY_PAGE_UP ::Key::PageUp
#define KEY_PAGE_DOWN ::Key::PageDown
#define KEY_HOME ::Key::Home
#define KEY_END ::Key::End
#define KEY_CAPS_LOCK ::Key::CapsLock
#define KEY_SCROLL_LOCK ::Key::ScrollLock
#define KEY_NUM_LOCK ::Key::NumLock
#define KEY_PRINT_SCREEN ::Key::PrintScreen
#define KEY_PAUSE ::Key::Pause
#define KEY_F1 ::Key::F1
#define KEY_F2 ::Key::F2
#define KEY_F3 ::Key::F3
#define KEY_F4 ::Key::F4
#define KEY_F5 ::Key::F5
#define KEY_F6 ::Key::F6
#define KEY_F7 ::Key::F7
#define KEY_F8 ::Key::F8
#define KEY_F9 ::Key::F9
#define KEY_F10 ::Key::F10
#define KEY_F11 ::Key::F11
#define KEY_F12 ::Key::F12
#define KEY_F13 ::Key::F13
#define KEY_F14 ::Key::F14
#define KEY_F15 ::Key::F15
#define KEY_F16 ::Key::F16
#define KEY_F17 ::Key::F17
#define KEY_F18 ::Key::F18
#define KEY_F19 ::Key::F19
#define KEY_F20 ::Key::F20
#define KEY_F21 ::Key::F21
#define KEY_F22 ::Key::F22
#define KEY_F23 ::Key::F23
#define KEY_F24 ::Key::F24
#define KEY_F25 ::Key::F25

/* Keypad */
#define KEY_KP_0 ::Key::KP0
#define KEY_KP_1 ::Key::KP1
#define KEY_KP_2 ::Key::KP2
#define KEY_KP_3 ::Key::KP3
#define KEY_KP_4 ::Key::KP4
#define KEY_KP_5 ::Key::KP5
#define KEY_KP_6 ::Key::KP6
#define KEY_KP_7 ::Key::KP7
#define KEY_KP_8 ::Key::KP8
#define KEY_KP_9 ::Key::KP9
#define KEY_KP_DECIMAL ::Key::KPDecimal
#define KEY_KP_DIVIDE ::Key::KPDivide
#define KEY_KP_MULTIPLY ::Key::KPMultiply
#define KEY_KP_SUBTRACT ::Key::KPSubtract
#define KEY_KP_ADD ::Key::KPAdd
#define KEY_KP_ENTER ::Key::KPEnter
#define KEY_KP_EQUAL ::Key::KPEqual

#define KEY_LEFT_SHIFT ::Key::LeftShift
#define KEY_LEFT_CONTROL ::Key::LeftControl
#define KEY_LEFT_ALT ::Key::LeftAlt
#define KEY_LEFT_SUPER ::Key::LeftSuper
#define KEY_RIGHT_SHIFT ::Key::RightShift
#define KEY_RIGHT_CONTROL ::Key::RightControl
#define KEY_RIGHT_ALT ::Key::RightAlt
#define KEY_RIGHT_SUPER ::Key::RightSuper
#define KEY_MENU ::Key::Menu

////////////////////////////////////////////////////////////////////////////

/*Mouse Code*/
typedef enum class MouseCode : uint16_t
{
	// From glfw3.h
	Button0 = 0,
	Button1 = 1,
	Button2 = 2,
	Button3 = 3,
	Button4 = 4,
	Button5 = 5,
	Button6 = 6,
	Button7 = 7,

	ButtonLast   = Button7,
	ButtonLeft   = Button0,
	ButtonRight  = Button1,
	ButtonMiddle = Button2
} Mouse;

inline std::ostream &operator<<(std::ostream &os, MouseCode mouseCode)
{
	os << static_cast<int32_t>(mouseCode);
	return os;
}

#define MOUSE_BUTTON_0 ::Mouse::Button0
#define MOUSE_BUTTON_1 ::Mouse::Button1
#define MOUSE_BUTTON_2 ::Mouse::Button2
#define MOUSE_BUTTON_3 ::Mouse::Button3
#define MOUSE_BUTTON_4 ::Mouse::Button4
#define MOUSE_BUTTON_5 ::Mouse::Button5
#define MOUSE_BUTTON_6 ::Mouse::Button6
#define MOUSE_BUTTON_7 ::Mouse::Button7
#define MOUSE_BUTTON_LAST ::Mouse::ButtonLast
#define MOUSE_BUTTON_LEFT ::Mouse::ButtonLeft
#define MOUSE_BUTTON_RIGHT ::Mouse::ButtonRight
#define MOUSE_BUTTON_MIDDLE ::Mouse::ButtonMiddle
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/JobSystem.hpp
================================================
#pragma once

#include "Precompile.hpp"

namespace Ilum
{
class SpinLock
{
  public:
	SpinLock();
	~SpinLock() = default;

	void Lock();
	void Unlock();

  private:
	std::atomic_flag m_flag;
};

template <typename T, size_t capacity>
class RingBuffer
{
  public:
	RingBuffer()  = default;
	~RingBuffer() = default;

	RingBuffer(const RingBuffer &)            = delete;
	RingBuffer &operator=(const RingBuffer &) = delete;
	RingBuffer(RingBuffer &&)                 = delete;
	RingBuffer &operator=(RingBuffer &&)      = delete;

	void Push(const T &data)
	{
		size_t current_tail             = m_run_tail.fetch_add(1, std::memory_order_relaxed);
		m_data[current_tail % capacity] = data;
		m_tail.fetch_add(1, std::memory_order_relaxed);
	}

	bool TryPop(T &data)
	{
		size_t current_head = 0;

		{
			m_lock.Lock();
			if (m_tail <= m_head)
			{
				return false;
			}
			current_head = m_head++;
			m_lock.Unlock();
		}

		data = m_data[current_head % capacity];
		return true;
	}

	bool Empty() const
	{
		return m_tail <= m_head;
	}

  private:
	T                   m_data[capacity] = {};
	size_t              m_head           = 0;
	std::atomic<size_t> m_tail           = 0;
	std::atomic<size_t> m_run_tail       = 0;
	SpinLock            m_lock;
};

class ThreadPool
{
  public:
	ThreadPool(uint32_t max_threads_num);
	~ThreadPool();

	ThreadPool(const ThreadPool &)            = delete;
	ThreadPool &operator=(const ThreadPool &) = delete;
	ThreadPool(ThreadPool &&)                 = delete;
	ThreadPool &operator=(ThreadPool &&)      = delete;

	size_t GetThreadCount() const;

	template <typename Task, typename... Args>
	inline auto AddTask(Task &&task, Args &&...args)
	    -> std::future<decltype(task(args...))>
	{
		using return_type = decltype(task(args...));

		auto pack = std::make_shared<std::packaged_task<return_type()>>(
		    std::bind(std::forward<Task>(task), std::forward<Args>(args)...));
		m_task_queue.Push([pack]() { (*pack)(); });

		{
			std::unique_lock<std::mutex> lock(m_mutex);
			m_condition.notify_one();
		}

		return pack->get_future();
	}

	void WaitAll();

  private:
	RingBuffer<std::function<void()>, 1024>           m_task_queue;
	std::unordered_map<std::thread::id, const char *> m_thread_names;

	std::vector<std::thread> m_workers;
	std::mutex               m_mutex;
	std::atomic<bool>        m_stop = false;
	std::condition_variable  m_condition;
};

class JobNode
{
	friend class JobSystem;
	friend class JobGraph;

  public:
	// Job Graph won't provide return value
	explicit JobNode(std::function<void()> &&task);

	JobNode() = default;

	~JobNode() = default;

	virtual std::type_index GetType();

	// A.percede(B) => B depend on A
	void Percede(JobNode *node);

	// A.succeed(B) => A depend on B
	void Succeed(JobNode *node);

	virtual bool Compile();

	virtual void Run();

  protected:
	std::vector<JobNode *> m_successors;
	std::vector<JobNode *> m_dependents;
	std::atomic<uint32_t>  m_unfinish_dependents = 0;

  private:
	std::function<void()> m_task;
};

class JobGraph : public JobNode
{
	friend class JobSystem;

  public:
	explicit JobGraph() = default;

	~JobGraph() = default;

	virtual std::type_index GetType() override;

	JobGraph &AddNode(JobNode *node);

	// Validation and topology sorting
	virtual bool Compile() override;

	// Single thread job graph execute
	// You must compile job graph before it runs
	virtual void Run() override;

  private:
	std::vector<JobNode *> m_nodes;
};

class JobSystem;

class JobHandle
{
	friend class JobSystem;
	// The number of subjob current job is dealing
	std::atomic<uint32_t> m_counter = 0;
};

class JobSystem
{
  public:
	JobSystem();

	~JobSystem();

	static JobSystem &GetInstance();

	size_t GetThreadCount();

	// You must compile job graph before it executed
	void Execute(JobHandle &handle, JobGraph &graph);
	void Execute(JobHandle &handle, JobNode &node);

	// Async execute, can be used in resource loading
	template <typename Task, typename... Args>
	inline auto ExecuteAsync(Task &&task, Args &&...args)
	    -> std::future<decltype(task(args...))>
	{
		return m_thread_pool->AddTask([task, args...]() {
			return task(std::forward<Args>(args)...);
		});
	}

	template <typename Task>
	inline auto ExecuteAsync(Task &&task)
	    -> std::future<decltype(task())>
	{
		return m_thread_pool->AddTask([task]() {
			return task();
		});
	}

	// Using dispatch method, task need group id as parameter
	void Dispatch(JobHandle &handle, uint32_t job_count, uint32_t group_size, const std::function<void(uint32_t)> &task);
	bool IsBusy(const JobHandle &handle);
	void Wait(const JobHandle &handle);
	void WaitAll();

  private:
	std::unique_ptr<ThreadPool> m_thread_pool = nullptr;
};

}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/Log.hpp
================================================
#pragma once

#include "Precompile.hpp"

#include <spdlog/spdlog.h>

namespace Ilum
{
class  LogSystem final
{
  public:
	enum class LogLevel : uint8_t
	{
		Debug,
		Info,
		Warn,
		Error,
		Fatal
	};

  public:
	LogSystem();

	~LogSystem();

	static LogSystem &GetInstance();

	template <typename... Args>
	void Log(LogLevel level, Args &&...args)
	{
		switch (level)
		{
			case Ilum::LogSystem::LogLevel::Debug:
				m_logger->debug(std::forward<Args>(args)...);
				break;
			case Ilum::LogSystem::LogLevel::Info:
				m_logger->info(std::forward<Args>(args)...);
				break;
			case Ilum::LogSystem::LogLevel::Warn:
				m_logger->warn(std::forward<Args>(args)...);
				break;
			case Ilum::LogSystem::LogLevel::Error:
				m_logger->error(std::forward<Args>(args)...);
				break;
			case Ilum::LogSystem::LogLevel::Fatal:
				m_logger->critical(std::forward<Args>(args)...);
				throw std::runtime_error(fmt::format(std::forward<Args>(args)...));
				break;
			default:
				break;
		}
	}

  private:
	std::shared_ptr<spdlog::logger> m_logger;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/PRECOMPILE.HPP
================================================
#pragma once

#include <algorithm>
#include <array>
#include <atomic>
#include <cassert>
#include <chrono>
#include <filesystem>
#include <fstream>
#include <functional>
#include <future>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <memory_resource>
#include <optional>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>

#include "API.hpp"


================================================
FILE: Source/Runtime/Core/Public/Core/Path.hpp
================================================
#pragma once

#include "Precompile.hpp"

namespace Ilum
{
class  Path
{
  public:
	static Path &GetInstance();

	bool IsExist(const std::string &path);
	bool IsFile(const std::string &path);
	bool IsDirectory(const std::string &path);
	bool CreatePath(const std::string &path);
	bool DeletePath(const std::string &path);
	bool Copy(const std::string &src, const std::string &dst);
	void SetCurrent(const std::string &path);

	const std::string GetCurrent(bool convert = true);
	const std::string GetFileName(const std::string &path, bool has_extension = true);
	const std::string GetFileDirectory(const std::string &path);
	const std::string GetFileExtension(const std::string &path);
	const std::string GetRelativePath(const std::string &path);

	bool Save(const std::string &path, const std::vector<uint8_t> &data, bool binary = false);
	bool Read(const std::string &path, std::vector<uint8_t> &data, bool binary = false, uint32_t begin = 0, uint32_t end = 0);

	std::string Toupper(const std::string &str);
	std::string Replace(const std::string &str, char from, char to);
	std::string ValidFileName(const std::string &str);

	std::vector<std::string> Split(const std::string &str, char delim);
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/Plugin.hpp
================================================
#pragma once

#include "Precompile.hpp"

#include <string>

#ifdef _WIN64
#	include <Windows.h>
#	include <libloaderapi.h>
#else
#	error("Windows only for now")
#endif

namespace Ilum
{
class  PluginManager
{
  public:
	PluginManager();

	~PluginManager();

	static PluginManager &GetInstance();

	template <typename _Ty = void, typename... Args>
	_Ty Call(const std::string &lib_path, const std::string &func_name, Args... args)
	{
		typedef _Ty(CALLBACK * FUNC)(Args...);

		auto lib_handle = GetLibrary(lib_path);

		auto func = (FUNC) GetProcAddress(lib_handle, func_name.c_str());

		if (!func)
		{
			if constexpr (std::is_same_v<_Ty, void>)
			{
				return;
			}
			else
			{
				return _Ty();
			}
		}

		if constexpr (std::is_same_v<_Ty, void>)
		{
			func(args...);
			return;
		}
		else if constexpr (sizeof...(Args) == 0)
		{
			return func();
		}
		else
		{
			return func(args...);
		}
	}

  private:
	HMODULE GetLibrary(const std::string &lib_path);

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/Time.hpp
================================================
#pragma once

#include "Precompile.hpp"

namespace Ilum
{
class  Timer
{
  public:
	Timer();

	~Timer();

	static Timer &GetInstance();

	float TotalTime();

	float DeltaTime();

	float DeltaTimeSmoothed();

	float FrameRate();

	void  Tick();

  private:
	struct Impl;
	Impl *p_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/Variant.hpp
================================================
#pragma once

#include "Precompile.hpp"

namespace Ilum
{
class  Variant
{
  public:
	Variant() = default;

	~Variant();

	Variant(Variant &&other) noexcept;

	Variant(const Variant &other);

	template <typename _Ty>
	Variant(const _Ty& var)
	{
		Set(&var, sizeof(_Ty));
	}

	Variant &operator=(Variant &&other) noexcept;

	Variant &operator=(const Variant &other);

	bool Empty() const;

	template <typename _Ty>
	void operator=(const _Ty &var)
	{
		Set(&var, sizeof(_Ty));
	}

	template <typename _Ty>
	_Ty *Convert() const
	{
		return std::static_pointer_cast<_Ty>(m_data).get();
	}

	template <class Archive>
	void save(Archive &archive) const
	{
		std::vector<uint8_t> data(m_size);
		std::memcpy(data.data(), m_data.get(), m_size);
		archive(data);
	}

	template <class Archive>
	void load(Archive &archive)
	{
		std::vector<uint8_t> data;
		archive(data);
		Set(data.data(), data.size());
	}

  private:
	void Set(const void *data, size_t size);

  private:
	std::shared_ptr<void> m_data = nullptr;

	size_t m_size = 0;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/Public/Core/Window.hpp
================================================
#pragma once

#include "Precompile.hpp"
#include "Delegates.hpp"
#include "Input.hpp"

struct GLFWwindow;

namespace Ilum
{
class  Window
{
  public:
	Window(const std::string &title, const std::string &icon, uint32_t width = 0, uint32_t height = 0);

	~Window();

	bool Tick();

	bool IsKeyDown(int32_t key) const;

	bool IsMouseButtonDown(int32_t button) const;

	void SetTitle(const std::string &title);

	GLFWwindow *GetHandle() const;

	void *GetNativeHandle() const;

	uint32_t GetWidth() const;

	uint32_t GetHeight() const;

	bool IsKeyPressed(KeyCode keycode);

	bool IsMouseButtonPressed(MouseCode button);

	glm::vec2 GetMousePosition();

	void SetCursorPosition(const glm::vec2 &pos);

  public:
	MulticastDelegate<>                                   OnResetFunc;
	MulticastDelegate<int32_t, int32_t, int32_t, int32_t> OnKeyFunc;
	MulticastDelegate<uint32_t>                           OnCharFunc;
	MulticastDelegate<int32_t, uint32_t>                  OnCharModsFunc;
	MulticastDelegate<int32_t, int32_t, int32_t>          OnMouseButtonFunc;
	MulticastDelegate<double, double>                     OnCursorPosFunc;
	MulticastDelegate<int32_t>                            OnCursorEnterFunc;
	MulticastDelegate<double, double>                     OnScrollFunc;
	MulticastDelegate<int32_t, const char **>             OnDropFunc;
	MulticastDelegate<int32_t, int32_t>                   OnWindowSizeFunc;
	MulticastDelegate<>                                   OnWindowCloseFunc;

  private:
	GLFWwindow *m_handle = nullptr;

	uint32_t    m_width;
	uint32_t    m_height;
	std::string m_title;
	float       m_mouse_wheel_h = 0.0f;
	float       m_mouse_wheel   = 0.0f;
	float       m_pos_delta_x   = 0.f;
	float       m_pos_delta_y   = 0.f;
	float       m_pos_last_x    = 0.f;
	float       m_pos_last_y    = 0.f;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Core/xmake.lua
================================================


================================================
FILE: Source/Runtime/Geometry/Private/AABB.cpp
================================================
#include "AABB.hpp"

namespace Ilum
{
AABB::AABB(const glm::vec3 &min, const glm::vec3 &max) :
    min(min), max(max)
{
}

void AABB::Merge(const glm::vec3 &point)
{
	min = glm::min(min, point);
	max = glm::max(max, point);
}

void AABB::Merge(const std::vector<glm::vec3> &points)
{
	for (auto &point : points)
	{
		Merge(point);
	}
}

void AABB::Merge(const AABB &aabb)
{
	min = glm::min(min, aabb.min);
	max = glm::max(max, aabb.max);
}

AABB AABB::Transform(const glm::mat4 &transform) const
{
	glm::vec3 v[2] = {}, xa, xb, ya, yb, za, zb;

	xa = transform[0] * min[0];
	xb = transform[0] * max[0];

	ya = transform[1] * min[1];
	yb = transform[1] * max[1];

	za = transform[2] * min[2];
	zb = transform[2] * max[2];

	v[0] = transform[3];
	v[0] += glm::min(xa, xb);
	v[0] += glm::min(ya, yb);
	v[0] += glm::min(za, zb);

	v[1] = transform[3];
	v[1] += glm::max(xa, xb);
	v[1] += glm::max(ya, yb);
	v[1] += glm::max(za, zb);

	return AABB(v[0], v[1]);
}

const glm::vec3 AABB::Center() const
{
	return 0.5f * (min + max);
}

const glm::vec3 AABB::Scale() const
{
	return max - min;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Private/Mesh/EMesh.cpp
================================================
#include "Mesh/EMesh.hpp"

namespace Ilum
{
EMesh::EMesh(const std::vector<VertexData> &vertices, const std::vector<uint32_t> &indices, uint32_t stride) :
    m_stride(stride)
{
	// Create new vertices
	for (auto &v : vertices)
	{
		Vertex *nv = (Vertex *) m_pool.allocate(sizeof(Vertex), alignof(Vertex));
		new (nv) Vertex(v, nullptr);

		m_vertices.insert(nv);
	}

	std::unordered_map<std::pair<Vertex *, Vertex *>, Edge *, PairHash> vertex_edge_map;

	// Create new edge
	for (size_t i = 0; i < indices.size(); i += stride)
	{
		Face *nf = (Face *) m_pool.allocate(sizeof(Face), alignof(Face));
		new (nf) Face(nullptr);

		std::vector<Edge *> fe;

		for (size_t j = 0; j < stride; j++)
		{
			Vertex *v1 = m_vertices[indices[i + j]];
			Vertex *v2 = m_vertices[indices[i + (j + 1) % stride]];

			if (vertex_edge_map.find(std::make_pair(v1, v2)) == vertex_edge_map.end() &&
			    vertex_edge_map.find(std::make_pair(v2, v1)) == vertex_edge_map.end())
			{
				Edge *ne = (Edge *) m_pool.allocate(sizeof(Edge), alignof(Edge));
				new (ne) Edge(v1, v2, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);

				vertex_edge_map[std::make_pair(v1, v2)] = ne;
				vertex_edge_map[std::make_pair(v2, v1)] = ne;

				m_edges.insert(ne);
				fe.push_back(ne);
			}
			else
			{
				auto *ne = vertex_edge_map[std::make_pair(v1, v2)];
				fe.push_back(ne);
			}
		}

		nf->edge = fe[0];

		for (size_t j = 0; j < fe.size(); j++)
		{
			fe[j]->face[0] == nullptr ? fe[j]->face[0] = nf : fe[j]->face[1] = nf;

			Edge *e1 = fe[j];
			Edge *e2 = fe[(j + 1) % fe.size()];

			if (e1 && e2)
			{
				e2->prev[0] == nullptr ? e2->prev[0] = e1 : e2->prev[1] = e1;
				e1->next[0] == nullptr ? e1->next[0] = e2 : e1->next[1] = e2;
			}
		}

		m_faces.insert(nf);
	}
}

EMesh::~EMesh()
{
	m_pool.release();
	m_vertices.clear();
	m_faces.clear();
	m_edges.clear();
}

TriMesh EMesh::ToTriMesh() const
{
	std::vector<VertexData> vertices;
	std::vector<uint32_t>  indices;

	vertices.reserve(m_vertices.size());
	for (auto &v : m_vertices)
	{
		vertices.push_back(v->data);
	}

	// Convert to triangle mesh
	indices.reserve(m_faces.size() * (m_stride - 2) * 3);
	for (auto &f : m_faces)
	{
		Edge    *e        = f->edge;
		uint32_t face_idx = e->face[0] == f ? 0 : 1;
		Vertex  *start_v  = e->vertex[face_idx];

		e = f->edge->next[face_idx];

		while (e->vertex[0] != start_v && e->vertex[1] != start_v)
		{
			indices.push_back(static_cast<uint32_t>(m_vertices.idx(start_v)));
			indices.push_back(static_cast<uint32_t>(m_vertices.idx(e->vertex[face_idx])));
			indices.push_back(static_cast<uint32_t>(m_vertices.idx(e->vertex[(face_idx + 1) % 2])));

			face_idx = e->face[0] == f ? 0 : 1;

			e = e->next[face_idx];
		}
	}

	TriMesh mesh;
	mesh.vertices = std::move(vertices);
	mesh.indices  = std::move(indices);

	return mesh;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Private/Mesh/FMesh.cpp
================================================
#include "Mesh/FMesh.hpp"

namespace Ilum
{
FMesh::FMesh(const std::vector<VertexData> &vertices, const std::vector<uint32_t> &indices)
{
	// Create new vertices
	for (auto &v : vertices)
	{
		Vertex *nv = (Vertex *) m_pool.allocate(sizeof(Vertex), alignof(Vertex));
		new (nv) Vertex(v, nullptr);

		m_vertices.insert(nv);
	}

	std::unordered_map<std::pair<Vertex *, Vertex *>, Face *, PairHash> edge_face_map;
	std::unordered_map<Face *, uint32_t>                                 face_count;

	for (size_t idx = 0; idx < indices.size(); idx += 3)
	{
		Face *nf = (Face *) m_pool.allocate(sizeof(Face), alignof(Face));
		new (nf) Face(m_vertices[indices[idx]], m_vertices[indices[idx + 1]], m_vertices[indices[idx + 2]], nullptr, nullptr, nullptr);

		m_faces.insert(nf);

		face_count[nf] = 0;

		for (size_t i = 0; i < 3; i++)
		{
			if (!m_vertices[indices[idx + i]]->face)
			{
				m_vertices[indices[idx + i]]->face = nf;
			}

			auto e1 = std::make_pair(nf->vertex[i], nf->vertex[(i + 1) % 3]);
			auto e2 = std::make_pair(nf->vertex[(i + 1) % 3], nf->vertex[i]);

			if (edge_face_map.find(e1) != edge_face_map.end())
			{
				nf->face[face_count[nf]++]                               = edge_face_map[e1];
				edge_face_map[e1]->face[face_count[edge_face_map[e1]]++] = nf;
			}

			edge_face_map[e1] = nf;
			edge_face_map[e2] = nf;
		}
	}
}

FMesh::~FMesh()
{
	m_pool.release();
	m_vertices.clear();
	m_faces.clear();
}

TriMesh FMesh::ToTriMesh() const
{
	std::vector<VertexData> vertices;
	std::vector<uint32_t>  indices;

	vertices.reserve(m_vertices.size());
	for (auto &v : m_vertices)
	{
		vertices.push_back(v->data);
	}

	indices.reserve(m_faces.size() * 3);
	for (auto &f : m_faces)
	{
		for (uint32_t i = 0; i < 3; i++)
		{
			indices.push_back(static_cast<uint32_t>(m_vertices.idx(f->vertex[i])));
		}
	}

	TriMesh mesh;
	mesh.vertices = std::move(vertices);
	mesh.indices  = std::move(indices);

	return mesh;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Private/Mesh/HEMesh.cpp
================================================
#include "Mesh/HEMesh.hpp"

namespace Ilum
{
HEMesh::HEMesh(const std::vector<VertexData> &vertices, const std::vector<uint32_t> &indices, uint32_t stride)
{
	// Create new vertices
	for (auto &v : vertices)
	{
		Vertex *nv = (Vertex *) m_pool.allocate(sizeof(Vertex), alignof(Vertex));
		new (nv) Vertex(v, nullptr);

		m_vertices.insert(nv);
	}

	std::unordered_map<std::pair<Vertex *, Vertex *>, HalfEdge *, PairHash> vertex_edge_map;

	// Create new edge
	for (size_t i = 0; i < indices.size(); i += stride)
	{
		Face *nf = (Face *) m_pool.allocate(sizeof(Face), alignof(Face));
		new (nf) Face(nullptr);

		m_faces.insert(nf);

		std::vector<HalfEdge *> fe;

		for (size_t j = 0; j < stride; j++)
		{
			Vertex *v1 = m_vertices[indices[i + j]];
			Vertex *v2 = m_vertices[indices[i + (j + 1) % stride]];

			// Not find v1 -> v2, create new one
			if (vertex_edge_map.find(std::make_pair(v1, v2)) == vertex_edge_map.end())
			{
				HalfEdge *ne = (HalfEdge *) m_pool.allocate(sizeof(HalfEdge), alignof(HalfEdge));
				new (ne) HalfEdge(v2, nf, nullptr, nullptr, nullptr);

				v1->half_edge = ne;

				vertex_edge_map[std::make_pair(v1, v2)] = ne;
				m_halfedges.insert(ne);
				fe.push_back(ne);

				if (vertex_edge_map.find(std::make_pair(v2, v1)) != vertex_edge_map.end())
				{
					auto *opposite     = vertex_edge_map[std::make_pair(v2, v1)];
					ne->opposite       = opposite;
					opposite->opposite = ne;
				}
				else
				{
					HalfEdge *opposite = (HalfEdge *) m_pool.allocate(sizeof(HalfEdge), alignof(HalfEdge));
					new (opposite) HalfEdge(v1, nullptr, nullptr, nullptr, nullptr);
					ne->opposite       = opposite;
					opposite->opposite = ne;

					vertex_edge_map[std::make_pair(v2, v1)] = opposite;
					m_halfedges.insert(opposite);
				}
			}
			else
			{
				auto *ne = vertex_edge_map[std::make_pair(v1, v2)];
				ne->face = nf;
				fe.push_back(ne);
			}
		}

		nf->half_edge = fe[0];

		for (size_t i = 0; i < fe.size(); i++)
		{
			fe[i]->next = fe[(i + 1) % fe.size()];
			fe[i]->prev = fe[(i + fe.size() - 1) % fe.size()];
		}
	}

	for (auto *he : m_halfedges)
	{
		if (!he->face)
		{
			he->next = he->opposite->prev->opposite;
			while (he->next->face)
			{
				he->next = he->next->prev->opposite;
			}

			he->prev = he->opposite->next->opposite;
			while (he->prev->face)
			{
				he->prev = he->prev->next->opposite;
			}
		}
	}
}

HEMesh::~HEMesh()
{
	m_pool.release();
	m_vertices.clear();
	m_faces.clear();
	m_halfedges.clear();
}

const std::vector<HEMesh::Vertex *> &HEMesh::Vertices() const
{
	return m_vertices.vec();
}

const std::vector<HEMesh::Face *> &HEMesh::Faces() const
{
	return m_faces.vec();
}

const std::vector<HEMesh::HalfEdge *> &HEMesh::HalfEdges() const
{
	return m_halfedges.vec();
}

std::vector<HEMesh::Vertex *> &HEMesh::Vertices()
{
	return m_vertices.vec();
}

std::vector<HEMesh::Face *> &HEMesh::Faces()
{
	return m_faces.vec();
}

std::vector<HEMesh::HalfEdge *> &HEMesh::HalfEdges()
{
	return m_halfedges.vec();
}

bool HEMesh::HasBoundary() const
{
	for (auto &he : m_halfedges)
	{
		if (!he->face)
		{
			return true;
		}
	}

	return false;
}

bool HEMesh::IsOnBoundary(HalfEdge *he) const
{
	return !he->face || !he->opposite->face;
}

bool HEMesh::IsOnBoundary(Vertex *v) const
{
	auto *he = v->half_edge;
	auto *h  = he;
	do
	{
		if (h->opposite->face)
		{
			h = h->opposite->next;
		}
		else
		{
			return true;
		}
	} while (he != h);

	return false;
}

uint32_t HEMesh::Degree(Vertex *v) const
{
	auto *he = v->half_edge;
	auto *h  = he;

	uint32_t deg = 0;

	do
	{
		deg++;
		h = h->opposite->next;
	} while (h != he);

	return deg;
}

std::vector<std::vector<HEMesh::Vertex *>> HEMesh::Boundary() const
{
	std::unordered_set<HEMesh::HalfEdge *>     boundary_halfedges;
	std::vector<std::vector<HEMesh::Vertex *>> boundaries;

	for (auto *he : m_halfedges)
	{
		if (!he->face && boundary_halfedges.find(he) == boundary_halfedges.end())
		{
			std::vector<HEMesh::Vertex *> boundary;

			auto *h = he;

			do
			{
				boundary_halfedges.insert(h);
				boundary.push_back(h->vertex);
				h = h->next;
			} while (h != he);

			boundaries.push_back(boundary);
		}
	}

	return boundaries;
}

std::vector<HEMesh::Vertex *> HEMesh::AdjVertices(Vertex *v) const
{
	auto *he = v->half_edge;
	auto *h  = he;

	std::vector<HEMesh::Vertex *> adj_vertices;

	do
	{
		adj_vertices.push_back(h->vertex);
		h = h->opposite->next;
	} while (h != he);

	return adj_vertices;
}

size_t HEMesh::VertexIndex(Vertex *v) const
{
	return m_vertices.idx(v);
}

TriMesh HEMesh::ToTriMesh() const
{
	std::vector<VertexData> vertices;
	std::vector<uint32_t>  indices;

	vertices.reserve(m_vertices.size());
	for (auto &v : m_vertices)
	{
		vertices.push_back(v->data);
	}

	// Convert to triangle mesh
	indices.reserve(m_faces.size() * (m_stride - 2) * 3);
	for (auto &f : m_faces)
	{
		auto *he = f->half_edge;
		auto *h  = he;

		do
		{
			indices.push_back(static_cast<uint32_t>(m_vertices.idx(he->vertex)));
			he = he->next;
		} while (h != he);
	}

	TriMesh mesh;
	mesh.vertices = std::move(vertices);
	mesh.indices  = std::move(indices);

	return mesh;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Private/Mesh/Mesh.cpp
================================================
#include "Mesh/Mesh.hpp"

#include <glm/gtc/constants.hpp>

namespace Ilum
{
void TriMesh::GenerateNormal()
{
	for (size_t i = 0; i < vertices.size(); i++)
	{
		vertices[i].normal = glm::vec3(0.f);
	}

	for (size_t i = 0; i < indices.size(); i += 3)
	{
		glm::vec3 e2 = vertices[indices[i + 1]].position - vertices[indices[i]].position;
		glm::vec3 e1 = vertices[indices[i]].position - vertices[indices[i + 2]].position;

		glm::vec3 normal = glm::normalize(glm::cross(e1, e2));
		vertices[indices[i]].normal += normal;
		vertices[indices[i + 1]].normal += normal;
		vertices[indices[i + 2]].normal += normal;
	}

	for (size_t i = 0; i < vertices.size(); i++)
	{
		vertices[i].normal = glm::normalize(vertices[i].normal);
	}
}

float Mesh::Area(const glm::vec3 &v1, const glm::vec3 &v2, const glm::vec3 &v3) const
{
	glm::vec3 e1 = v2 - v1;
	glm::vec3 e2 = v3 - v1;

	return glm::length(glm::cross(e1, e2));
}

float Mesh::LocalAverageLegion(const glm::vec3 &center, const std::vector<glm::vec3> &neighbors, LocalAverageLegionOption option) const
{
	if (option == LocalAverageLegionOption::BarycentricCell)
	{
		float local_average_legion = 0.f;
		for (size_t i = 0; i < neighbors.size() - 1; i++)
		{
			local_average_legion += Area(center, neighbors[i], neighbors[i + 1]) / 3.f;
		}
		return local_average_legion;
	}
	else if (option == LocalAverageLegionOption::VoronoiCell)
	{
		float local_average_legion = 0.f;
		for (size_t i = 0; i < neighbors.size() - 1; i++)
		{
			glm::vec3 e1 = neighbors[i] - center;
			glm::vec3 e2 = neighbors[i + 1] - center;
			glm::vec3 n  = Normal(center, neighbors[i], neighbors[i + 1]);

			glm::vec3 vb1 = glm::normalize(glm::cross(n, e1));
			glm::vec3 vb2 = glm::normalize(glm::cross(e2, n));

			glm::vec3 mp1 = (neighbors[i] + center) * 0.5f;
			glm::vec3 mp2 = (neighbors[i + 1] + center) * 0.5f;

			float     t = ((vb1.y * mp1.x - vb1.x * mp1.y) - (vb1.y * mp2.x - vb1.x * mp2.y)) / (vb1.y * vb2.x - vb1.x * vb2.y);
			glm::vec3 p = mp2 + vb2 * t;

			local_average_legion += Area(p, mp1, center) + Area(p, mp2, center);
		}
		return local_average_legion;
	}
	else if (option == LocalAverageLegionOption::MixVoronoiCell)
	{
		float local_average_legion = 0.f;
		for (size_t i = 0; i < neighbors.size() - 1; i++)
		{
			glm::vec3 e1 = neighbors[i] - center;
			glm::vec3 e2 = neighbors[i + 1] - center;

			if (glm::dot(e1, e2) < 0.f)
			{
				glm::vec3 mp  = (neighbors[i] + neighbors[i + 1]) * 0.5f;
				glm::vec3 mp1 = (neighbors[i] + center) * 0.5f;
				glm::vec3 mp2 = (neighbors[i + 1] + center) * 0.5f;

				local_average_legion += Area(mp, mp1, center) + Area(mp, mp2, center);
			}
			else
			{
				glm::vec3 n = Normal(center, neighbors[i], neighbors[i + 1]);

				glm::vec3 vb1 = glm::normalize(glm::cross(n, e1));
				glm::vec3 vb2 = glm::normalize(glm::cross(e2, n));

				glm::vec3 mp1 = (neighbors[i] + center) * 0.5f;
				glm::vec3 mp2 = (neighbors[i + 1] + center) * 0.5f;

				float     t = ((vb1.y * mp1.x - vb1.x * mp1.y) - (vb1.y * mp2.x - vb1.x * mp2.y)) / (vb1.y * vb2.x - vb1.x * vb2.y);
				glm::vec3 p = mp2 + vb2 * t;

				local_average_legion += Area(p, mp1, center) + Area(p, mp2, center);
			}
		}
		return local_average_legion;
	}

	return 0.0f;
}

glm::vec3 Mesh::Laplace(const glm::vec3 &center, const std::vector<glm::vec3> &neighbors, LaplaceOption option) const
{
	if (option == LaplaceOption::Uniform)
	{
		glm::vec3 result = glm::vec3(0.f);
		for (auto &neighbor : neighbors)
		{
			result += (neighbor - center);
		}
		return result / static_cast<float>(neighbors.size());
	}
	else if (option == LaplaceOption::CotangentFormula)
	{
		glm::vec3 result = glm::vec3(0.f);
		for (size_t i = 0; i < neighbors.size(); i++)
		{
			glm::vec3 current = neighbors[i];
			glm::vec3 next    = neighbors[(i + 1) % neighbors.size()];
			glm::vec3 prev    = neighbors[(i + neighbors.size() - 1) % neighbors.size()];

			float cos_alpha = glm::dot(center - next, current - next) / (glm::length(center - next), glm::length(current - next));
			float cos_beta  = glm::dot(center - prev, current - prev) / (glm::length(center - prev), glm::length(current - prev));

			float cot_alpha = cos_alpha / glm::sqrt(1 - cos_alpha * cos_alpha);
			float cot_beta  = cos_beta / glm::sqrt(1 - cos_beta * cos_beta);

			result += (cot_alpha + cot_beta) * (current - center);
		}
		return result / (2.f * LocalAverageLegion(center, neighbors));
	}

	return glm::vec3(0.f);
}

glm::vec3 Mesh::Normal(const glm::vec3 &v1, const glm::vec3 &v2, const glm::vec3 &v3) const
{
	glm::vec3 e1 = v2 - v1;
	glm::vec3 e2 = v3 - v1;

	return glm::normalize(glm::cross(e1, e2));
}

glm::vec3 Mesh::Normal(const glm::vec3 &center, const std::vector<glm::vec3> &neighbors, VertexNormalOption option) const
{
	if (option == VertexNormalOption::Uniform)
	{
		glm::vec3 norm = glm::vec3(0.f);
		for (size_t i = 0; i < neighbors.size() - 1; i++)
		{
			norm += Normal(center, neighbors[i], neighbors[i + 1]);
		}
		return glm::normalize(norm);
	}
	else if (option == VertexNormalOption::Area)
	{
		glm::vec3 norm = glm::vec3(0.f);
		for (size_t i = 0; i < neighbors.size() - 1; i++)
		{
			norm += Area(center, neighbors[i], neighbors[i + 1]) * Normal(center, neighbors[i], neighbors[i + 1]);
		}
		return glm::normalize(norm);
	}
	else if (option == VertexNormalOption::Angle)
	{
		glm::vec3 norm = glm::vec3(0.f);
		for (size_t i = 0; i < neighbors.size() - 1; i++)
		{
			glm::vec3 e1    = neighbors[i] - center;
			glm::vec3 e2    = neighbors[i + 1] - center;
			float     angle = glm::acos(glm::dot(e1, e2) / (glm::length(e1) * glm::length(e2)));
			norm += angle * Normal(center, neighbors[i], neighbors[i + 1]);
		}
		return glm::normalize(norm);
	}

	return glm::vec3(0.f);
}

float Mesh::Curvature(const glm::vec3 &center, const std::vector<glm::vec3> &neighbors, CurvatureOption option)
{
	if (option == CurvatureOption::Mean)
	{
		glm::vec3 laplacian = Laplace(center, neighbors);
		glm::vec3 norm      = Normal(center, neighbors);
		return -0.5f * glm::dot(laplacian, norm);
	}
	else if (option == CurvatureOption::AbsoluteMean)
	{
		glm::vec3 laplacian = Laplace(center, neighbors);
		glm::vec3 norm      = Normal(center, neighbors);
		return glm::abs(-0.5f * glm::dot(laplacian, norm));
	}
	else if (option == CurvatureOption::Gaussian)
	{
		float result = 2.f * glm::pi<float>();
		for (size_t i = 0; i < neighbors.size() - 1; i++)
		{
			glm::vec3 e1    = neighbors[i] - center;
			glm::vec3 e2    = neighbors[i + 1] - center;
			float     angle = glm::acos(glm::dot(e1, e2) / (glm::length(e1) * glm::length(e2)));
			result -= angle;
		}
		return result / LocalAverageLegion(center, neighbors);
	}

	return 0.0f;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Private/MeshProcess.cpp
================================================
#include "MeshProcess.hpp"

namespace Ilum
{
template <typename _Ty>
std::unique_ptr<_Ty> &MeshProcess<_Ty>::GetInstance(const std::string &plugin)
{
	static std::unique_ptr<_Ty> ptr = std::unique_ptr<_Ty>(PluginManager::GetInstance().Call<_Ty *>(plugin, "Create"));
	return ptr;
}

template  class MeshProcess<Subdivision>;
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Public/Geometry/AABB.hpp
================================================
#pragma once

#include <glm/glm.hpp>
#include <glm/vec3.hpp>

#include <vector>

namespace Ilum
{
struct AABB
{
  public:
	glm::vec3 min = glm::vec3(std::numeric_limits<float>::max());
	glm::vec3 max = glm::vec3(-std::numeric_limits<float>::min());

  public:
	AABB() = default;

	AABB(const glm::vec3 &min, const glm::vec3 &max);

	~AABB() = default;

	void Merge(const glm::vec3 &point);

	void Merge(const std::vector<glm::vec3> &points);

	void Merge(const AABB &aabb);

	AABB Transform(const glm::mat4 &transform) const;

	const glm::vec3 Center() const;

	const glm::vec3 Scale() const;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Public/Geometry/Mesh/EMesh.hpp
================================================
#pragma once

#include "Mesh/Mesh.hpp"

namespace Ilum
{
// Edge based data structure
class  EMesh : public Mesh
{
  public:
	struct Vertex;
	struct Edge;
	struct Face;

	struct Vertex
	{
		VertexData data;
		Edge      *edge = nullptr;

		Vertex(const VertexData &data, Edge *edge) :
		    data(data), edge(edge)
		{}
	};

	struct Face
	{
		Edge *edge = nullptr;

		Face(Edge *edge) :
		    edge(edge)
		{}
	};

	struct Edge
	{
		Vertex *vertex[2];
		Face   *face[2];
		Edge   *next[2];
		Edge   *prev[2];

		Edge(Vertex *v1, Vertex *v2, Face *f1, Face *f2, Edge *next_e1, Edge *next_e2, Edge *prev_e1, Edge *prev_e2) :
		    vertex{v1, v2}, face{f1, f2}, next{next_e1, next_e2}, prev{prev_e1, prev_e2}
		{}
	};

  public:
	EMesh(const std::vector<VertexData> &vertices, const std::vector<uint32_t> &indices, uint32_t stride = 3);

	~EMesh();

	virtual TriMesh ToTriMesh() const override;

  private:
	uint32_t m_stride;

	RandomSet<Vertex *> m_vertices;
	RandomSet<Face *>   m_faces;
	RandomSet<Edge *>   m_edges;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Public/Geometry/Mesh/FMesh.hpp
================================================
#pragma once

#include "Mesh.hpp"

namespace Ilum
{
// Face based data structure only support triangle mesh
class  FMesh : public Mesh
{
  public:
	struct Face;
	struct Vertex;

	struct Vertex
	{
		VertexData data;
		Face      *face;

		Vertex(const VertexData &data, Face *face) :
		    data(data), face(face)
		{}
	};

	struct Face
	{
		Vertex *vertex[3];
		Face   *face[3];

		Face(Vertex *v1, Vertex *v2, Vertex *v3, Face *f1, Face *f2, Face *f3) :
		    vertex{v1, v2, v3}, face{f1, f2, f3}
		{}
	};

  public:
	FMesh(const std::vector<VertexData> &vertices, const std::vector<uint32_t> &indices);

	~FMesh();

	virtual TriMesh ToTriMesh() const override;

  private:
	RandomSet<Vertex *> m_vertices;
	RandomSet<Face *>   m_faces;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Public/Geometry/Mesh/HEMesh.hpp
================================================
#pragma once

#include "Mesh.hpp"

namespace Ilum
{
class  HEMesh : public Mesh
{
  public:
	struct Vertex;
	struct Face;
	struct HalfEdge;

	struct Vertex
	{
		VertexData data;
		HalfEdge  *half_edge;

		Vertex(const VertexData &data, HalfEdge *half_edge) :
		    data(data), half_edge(half_edge)
		{}
	};

	struct Face
	{
		HalfEdge *half_edge;

		Face(HalfEdge *half_edge) :
		    half_edge(half_edge)
		{}
	};

	struct HalfEdge
	{
		Vertex   *vertex;
		Face     *face;
		HalfEdge *next;
		HalfEdge *prev;
		HalfEdge *opposite;

		HalfEdge(Vertex *vertex, Face *face, HalfEdge *next, HalfEdge *prev, HalfEdge *opposite) :
		    vertex(vertex), face(face), next(next), prev(prev), opposite(opposite)
		{}
	};

	HEMesh(const std::vector<VertexData> &vertices, const std::vector<uint32_t> &indices, uint32_t stride = 3);

	~HEMesh();

	const std::vector<Vertex *> &Vertices() const;

	const std::vector<Face *> &Faces() const;

	const std::vector<HalfEdge *> &HalfEdges() const;

	std::vector<Vertex *> &Vertices();

	std::vector<Face *> &Faces();

	std::vector<HalfEdge *> &HalfEdges();

	bool HasBoundary() const;

	bool IsOnBoundary(HalfEdge *he) const;

	bool IsOnBoundary(Vertex *v) const;

	uint32_t Degree(Vertex *v) const;

	std::vector<std::vector<Vertex *>> Boundary() const;

	std::vector<Vertex *> AdjVertices(Vertex *v) const;

	size_t VertexIndex(Vertex *v) const;

	virtual TriMesh ToTriMesh() const override;

  private:
	uint32_t m_stride;

	RandomSet<Vertex *>   m_vertices;
	RandomSet<HalfEdge *> m_halfedges;
	RandomSet<Face *>     m_faces;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Public/Geometry/Mesh/Mesh.hpp
================================================
#pragma once

#include "../Precompile.hpp"

#include <glm/glm.hpp>

namespace Ilum
{
struct VertexData
{
	glm::vec3 position = glm::vec3(0.f);
	glm::vec3 normal   = glm::vec3(0.f);
	glm::vec2 uv       = glm::vec2(0.f);
};

struct  TriMesh
{
	std::vector<VertexData> vertices;
	std::vector<uint32_t>   indices;

	void GenerateNormal();
};

class  Mesh
{
  public:
	enum class VertexNormalOption
	{
		Uniform,
		Area,
		Angle
	};

	enum class LaplaceOption
	{
		Uniform,
		CotangentFormula
	};

	enum class CurvatureOption
	{
		Mean,
		AbsoluteMean,
		Gaussian
	};

	enum class LocalAverageLegionOption
	{
		BarycentricCell,
		VoronoiCell,
		MixVoronoiCell
	};

  public:
	Mesh() = default;

	~Mesh() = default;

	virtual TriMesh ToTriMesh() const = 0;

  protected:
	float Area(const glm::vec3 &v1, const glm::vec3 &v2, const glm::vec3 &v3) const;

	float LocalAverageLegion(const glm::vec3 &center, const std::vector<glm::vec3> &neighbors, LocalAverageLegionOption option = LocalAverageLegionOption::MixVoronoiCell) const;

	// neighbor points must in order
	glm::vec3 Laplace(const glm::vec3 &center, const std::vector<glm::vec3> &neighbors, LaplaceOption option = LaplaceOption::CotangentFormula) const;

	glm::vec3 Normal(const glm::vec3 &v1, const glm::vec3 &v2, const glm::vec3 &v3) const;

	glm::vec3 Normal(const glm::vec3 &center, const std::vector<glm::vec3> &neighbors, VertexNormalOption option = VertexNormalOption::Angle) const;

	float Curvature(const glm::vec3 &center, const std::vector<glm::vec3> &neighbors, CurvatureOption option = CurvatureOption::Gaussian);

  protected:
	std::pmr::unsynchronized_pool_resource m_pool;
};

}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Public/Geometry/MeshProcess.hpp
================================================
#pragma once

#include "Mesh/Mesh.hpp"
#include "Precompile.hpp"

namespace Ilum
{
template <typename _Ty>
class  MeshProcess
{
  public:
	static std::unique_ptr<_Ty> &GetInstance(const std::string &plugin);
};

class  Subdivision : public MeshProcess<Subdivision>
{
  public:
	virtual TriMesh Execute(const TriMesh &mesh) = 0;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Public/Geometry/Meshlet.hpp
================================================
#pragma once

#include <glm/glm.hpp>

namespace Ilum
{
struct Meshlet
{
	glm::vec3 center;
	float     radius;

	uint32_t data_offset;
	uint32_t vertex_offset;
	uint32_t vertex_count;
	uint32_t triangle_count;

	glm::vec3 cone_axis;
	float     cone_cutoff;

	glm::vec3 cone_apex;
	uint32_t  visible = false;

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(center, radius, cone_axis, cone_cutoff, cone_apex, data_offset, vertex_offset, vertex_count, triangle_count);
	}
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Geometry/Public/Geometry/Precompile.hpp
================================================
#pragma once

#include <Core/Core.hpp>


================================================
FILE: Source/Runtime/Geometry/xmake.lua
================================================
target("Geometry")
    set_kind("$(kind)")
    add_files("Private/**.cpp")
    set_pcxxheader("Public/Geometry/Precompile.hpp")

    add_includedirs("Public/Geometry")
    add_includedirs("Public", {public  = true})

    add_deps("Core")
    add_packages("spdlog", "glm", "cereal")
target_end()


================================================
FILE: Source/Runtime/RHI/Private/RHIAccelerationStructure.cpp
================================================
#include "RHIAccelerationStructure.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIAccelerationStructure::RHIAccelerationStructure(RHIDevice *device):
    p_device(device)
{
}

std::unique_ptr<RHIAccelerationStructure> RHIAccelerationStructure::Create(RHIDevice *rhi_device)
{
	return std::unique_ptr<RHIAccelerationStructure>(std::move(PluginManager::GetInstance().Call<RHIAccelerationStructure *>(fmt::format("RHI.{}.dll", rhi_device->GetBackend()), "CreateAccelerationStructure", rhi_device)));
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIBuffer.cpp
================================================
#include "RHIBuffer.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIBuffer::RHIBuffer(RHIDevice *device, const BufferDesc &desc) :
    p_device(device), m_desc(desc)
{
}

const std::string RHIBuffer::GetBackend() const
{
	return p_device->GetBackend();
}

std::unique_ptr<RHIBuffer> RHIBuffer::Create(RHIDevice *device, const BufferDesc &desc)
{
	return std::unique_ptr<RHIBuffer>(std::move(PluginManager::GetInstance().Call<RHIBuffer *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateBuffer", device, desc)));
}

const BufferDesc &RHIBuffer::GetDesc() const
{
	return m_desc;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHICommand.cpp
================================================
#include "RHICommand.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHICommand::RHICommand(RHIDevice *device, RHIQueueFamily family) :
    p_device(device), m_family(family)
{
}

RHIQueueFamily RHICommand::GetQueueFamily() const
{
	return m_family;
}

const std::string RHICommand::GetBackend() const
{
	return p_device->GetBackend();
}

CommandState RHICommand::GetState() const
{
	return m_state;
}

void RHICommand::Init()
{
	assert(m_state == CommandState::Available);
	m_state = CommandState::Initial;
}

std::unique_ptr<RHICommand> RHICommand::Create(RHIDevice *device, RHIQueueFamily family)
{
	return std::unique_ptr<RHICommand>(std::move(PluginManager::GetInstance().Call<RHICommand *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateCommand", device, family)));
}

}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIContext.cpp
================================================
#include "RHIContext.hpp"

#include <Core/Path.hpp>
#include <Core/Plugin.hpp>
#include <Core/Time.hpp>

#undef CreateSemaphore

namespace Ilum
{
RHIContext::RHIContext(Window *window, const std::string &backend, bool vsync) :
    p_window(window), m_vsync(vsync)
{
	if (Path::GetInstance().IsExist("shared/RHI/RHI.CUDA.dll"))
	{
		m_cuda_device = RHIDevice::Create("CUDA");
	}

	m_device = RHIDevice::Create(backend);

	m_swapchain = RHISwapchain::Create(m_device.get(), p_window->GetNativeHandle(), p_window->GetWidth(), p_window->GetHeight(), m_vsync);

	m_queue = RHIQueue::Create(m_device.get());

	if (m_cuda_device)
	{
		m_cuda_queue = RHIQueue::Create(m_cuda_device.get());
	}

	for (uint32_t i = 0; i < m_swapchain->GetTextureCount(); i++)
	{
		m_frames.emplace_back(RHIFrame::Create(m_device.get()));

		if (m_cuda_device)
		{
			m_cuda_frames.emplace_back(RHIFrame::Create(m_cuda_device.get()));
		}

		m_present_complete.emplace_back(RHISemaphore::Create(m_device.get()));
		m_render_complete.emplace_back(RHISemaphore::Create(m_device.get()));
	}
}

RHIContext::~RHIContext()
{
	m_device->WaitIdle();

	for (auto &frame : m_frames)
	{
		frame->Reset();
	}

	m_frames.clear();
	m_cuda_frames.clear();

	m_present_complete.clear();
	m_render_complete.clear();

	m_swapchain.reset();

	m_samplers.clear();

	m_queue.reset();

	m_cuda_device.reset();

	m_device.reset();
}

const std::string &RHIContext::GetDeviceName() const
{
	return m_device->GetName();
}

const std::string RHIContext::GetBackend() const
{
	return m_device->GetBackend();
}

bool RHIContext::HasCUDA() const
{
	return m_cuda_device != nullptr;
}

bool RHIContext::IsVsync() const
{
	return m_vsync;
}

void RHIContext::SetVsync(bool vsync)
{
	m_vsync = vsync;
}

bool RHIContext::IsFeatureSupport(RHIFeature feature) const
{
	return m_device->IsFeatureSupport(feature);
}

void RHIContext::WaitIdle() const
{
	m_device->WaitIdle();
}

RHISwapchain *RHIContext::GetSwapchain() const
{
	return m_swapchain.get();
}

std::unique_ptr<RHISwapchain> RHIContext::CreateSwapchain(void *window_handle, uint32_t width, uint32_t height, bool sync)
{
	return RHISwapchain::Create(m_device.get(), window_handle, width, height, sync);
}

std::unique_ptr<RHITexture> RHIContext::CreateTexture(const TextureDesc &desc)
{
	return RHITexture::Create(m_device.get(), desc);
}

std::unique_ptr<RHITexture> RHIContext::CreateTexture2D(uint32_t width, uint32_t height, RHIFormat format, RHITextureUsage usage, bool mipmap, uint32_t samples)
{
	return RHITexture::Create2D(m_device.get(), width, height, format, usage, mipmap, samples);
}

std::unique_ptr<RHITexture> RHIContext::CreateTexture3D(uint32_t width, uint32_t height, uint32_t depth, RHIFormat format, RHITextureUsage usage)
{
	return RHITexture::Create3D(m_device.get(), width, height, depth, format, usage);
}

std::unique_ptr<RHITexture> RHIContext::CreateTextureCube(uint32_t width, uint32_t height, RHIFormat format, RHITextureUsage usage, bool mipmap)
{
	return RHITexture::CreateCube(m_device.get(), width, height, format, usage, mipmap);
}

std::unique_ptr<RHITexture> RHIContext::CreateTexture2DArray(uint32_t width, uint32_t height, uint32_t layers, RHIFormat format, RHITextureUsage usage, bool mipmap, uint32_t samples)
{
	return RHITexture::Create2DArray(m_device.get(), width, height, layers, format, usage, mipmap, samples);
}

std::unique_ptr<RHITexture> RHIContext::MapToCUDATexture(RHITexture *texture)
{
	if (m_cuda_device)
	{
		HANDLE mem_handle = PluginManager::GetInstance().Call<HANDLE>(fmt::format("RHI.{}.dll", m_device->GetBackend()), "GetTextureMemHandle", m_device.get(), texture);
		return std::unique_ptr<RHITexture>(std::move(PluginManager::GetInstance().Call<RHITexture *>("RHI.CUDA.dll", fmt::format("MapTexture{}ToCUDA", m_device->GetBackend()), m_device.get(), texture->GetDesc(), mem_handle, texture->GetMemorySize())));
	}
	return nullptr;
}

std::unique_ptr<RHIBuffer> RHIContext::CreateBuffer(const BufferDesc &desc)
{
	return RHIBuffer::Create(m_device.get(), desc);
}

std::unique_ptr<RHIBuffer> RHIContext::CreateBuffer(size_t size, RHIBufferUsage usage, RHIMemoryUsage memory)
{
	BufferDesc desc = {};
	desc.size       = size;
	desc.usage      = usage;
	desc.memory     = memory;

	return RHIBuffer::Create(m_device.get(), desc);
}

std::unique_ptr<RHIBuffer> RHIContext::MapToCUDABuffer(RHIBuffer *buffer)
{
	if (m_cuda_device)
	{
		HANDLE mem_handle = PluginManager::GetInstance().Call<HANDLE>(fmt::format("RHI.{}.dll", m_device->GetBackend()), "GetBufferMemHandle", m_device.get(), buffer);
		return std::unique_ptr<RHIBuffer>(std::move(PluginManager::GetInstance().Call<RHIBuffer *>("RHI.CUDA.dll", fmt::format("MapBuffer{}ToCUDA", m_device->GetBackend()), m_device.get(), buffer->GetDesc(), mem_handle)));
	}
	return nullptr;
}

RHISampler *RHIContext::CreateSampler(const SamplerDesc &desc)
{
	size_t hash = Hash(desc.address_mode_u, desc.address_mode_v, desc.address_mode_w, desc.anisotropic, desc.border_color, desc.mag_filter, desc.max_lod, desc.min_filter, desc.min_lod, desc.mipmap_mode, desc.mip_lod_bias);

	if (m_sampler_lookup.find(hash) == m_sampler_lookup.end())
	{
		m_sampler_lookup.emplace(hash, m_samplers.size());
		m_samplers.emplace_back(RHISampler::Create(m_device.get(), desc));
	}

	return m_samplers.at(m_sampler_lookup.at(hash)).get();
}

uint32_t RHIContext::GetSamplerIndex(const SamplerDesc &desc)
{
	size_t hash = Hash(desc.address_mode_u, desc.address_mode_v, desc.address_mode_w, desc.anisotropic, desc.border_color, desc.mag_filter, desc.max_lod, desc.min_filter, desc.min_lod, desc.mipmap_mode, desc.mip_lod_bias);
	if (m_sampler_lookup.find(hash) == m_sampler_lookup.end())
	{
		CreateSampler(desc);
	}
	return static_cast<uint32_t>(m_sampler_lookup.at(hash));
}

std::vector<RHISampler *> RHIContext::GetSamplers() const
{
	std::vector<RHISampler *>samplers(m_samplers.size());
	std::transform(m_samplers.begin(), m_samplers.end(), samplers.begin(), [](const std::unique_ptr<RHISampler> &sampler) { return sampler.get(); });
	return samplers;
}

size_t RHIContext::GetSamplerCount() const
{
	return m_samplers.size();
}

RHICommand *RHIContext::CreateCommand(RHIQueueFamily family, bool cuda)
{
	return cuda ? m_cuda_frames[m_current_frame]->AllocateCommand(family) : m_frames[m_current_frame]->AllocateCommand(family);
}

RHIDescriptor *RHIContext::CreateDescriptor(const ShaderMeta &meta, bool cuda)
{
	return cuda ? m_cuda_frames[m_current_frame]->AllocateDescriptor(meta) : m_frames[m_current_frame]->AllocateDescriptor(meta);
}

std::unique_ptr<RHIPipelineState> RHIContext::CreatePipelineState(bool cuda)
{
	return RHIPipelineState::Create(cuda ? m_cuda_device.get() : m_device.get());
}

std::unique_ptr<RHIShader> RHIContext::CreateShader(const std::string &entry_point, const std::vector<uint8_t> &source, bool cuda)
{
	return RHIShader::Create(cuda ? m_cuda_device.get() : m_device.get(), entry_point, source);
}

std::unique_ptr<RHIRenderTarget> RHIContext::CreateRenderTarget(bool cuda)
{
	return RHIRenderTarget::Create(m_device.get());
}

std::unique_ptr<RHIProfiler> RHIContext::CreateProfiler(bool cuda)
{
	return RHIProfiler::Create(cuda ? m_cuda_device.get() : m_device.get(), m_swapchain->GetTextureCount());
}

std::unique_ptr<RHIFence> RHIContext::CreateFence()
{
	return RHIFence::Create(m_device.get());
}

RHIFence *RHIContext::CreateFrameFence()
{
	return m_frames[m_current_frame]->AllocateFence();
}

std::unique_ptr<RHISemaphore> RHIContext::CreateSemaphore(bool cuda)
{
	return RHISemaphore::Create(m_device.get());
}

RHISemaphore *RHIContext::CreateFrameSemaphore()
{
	return m_frames[m_current_frame]->AllocateSemaphore();
}

std::unique_ptr<RHISemaphore> RHIContext::MapToCUDASemaphore(RHISemaphore *semaphore)
{
	if (m_cuda_device)
	{
		HANDLE mem_handle = PluginManager::GetInstance().Call<HANDLE>(fmt::format("RHI.{}.dll", m_device->GetBackend()), "GetSemaphoreHandle", m_device.get(), semaphore);
		return std::unique_ptr<RHISemaphore>(std::move(PluginManager::GetInstance().Call<RHISemaphore *>("RHI.CUDA.dll", fmt::format("MapSemaphore{}ToCUDA", m_device->GetBackend()), m_device.get(), mem_handle)));
	}
	return nullptr;
}

std::unique_ptr<RHIAccelerationStructure> RHIContext::CreateAcccelerationStructure()
{
	return RHIAccelerationStructure::Create(m_device.get());
}

void RHIContext::Submit(std::vector<RHICommand *> &&cmd_buffers, std::vector<RHISemaphore *> &&wait_semaphores, std::vector<RHISemaphore *> &&signal_semaphores)
{
	SubmitInfo submit_info        = {};
	submit_info.is_cuda           = cmd_buffers.empty() ? false : cmd_buffers[0]->GetBackend() == "CUDA";
	submit_info.queue_family      = cmd_buffers.empty() ? RHIQueueFamily::Graphics : cmd_buffers[0]->GetQueueFamily();
	submit_info.cmd_buffers       = std::move(cmd_buffers);
	submit_info.wait_semaphores   = std::move(wait_semaphores);
	submit_info.signal_semaphores = std::move(signal_semaphores);
	m_submit_infos.emplace_back(std::move(submit_info));
}

void RHIContext::Execute(RHICommand *cmd_buffer)
{
	if (cmd_buffer->GetBackend() == "CUDA")
	{
		m_cuda_queue->Execute(cmd_buffer);
	}
	else
	{
		m_queue->Execute(cmd_buffer);
	}
}

void RHIContext::Execute(std::vector<RHICommand *> &&cmd_buffers, std::vector<RHISemaphore *> &&wait_semaphores, std::vector<RHISemaphore *> &&signal_semaphores, RHIFence *fence)
{
	SubmitInfo submit_info        = {};
	submit_info.is_cuda           = cmd_buffers.empty() ? false : cmd_buffers[0]->GetBackend() == "CUDA";
	submit_info.queue_family      = cmd_buffers.empty() ? RHIQueueFamily::Graphics : cmd_buffers[0]->GetQueueFamily();
	submit_info.cmd_buffers       = std::move(cmd_buffers);
	submit_info.wait_semaphores   = std::move(wait_semaphores);
	submit_info.signal_semaphores = std::move(signal_semaphores);

	if (submit_info.is_cuda)
	{
		m_cuda_queue->Execute(submit_info.queue_family, {submit_info}, fence);
	}
	else
	{
		m_queue->Execute(submit_info.queue_family, {submit_info}, fence);
	}
}

void RHIContext::Reset()
{
	m_submit_infos.clear();
}

RHITexture *RHIContext::GetBackBuffer()
{
	return m_swapchain->GetCurrentTexture();
}

void RHIContext::BeginFrame()
{
	m_swapchain->AcquireNextTexture(m_present_complete[m_current_frame].get(), nullptr);
	m_frames[m_current_frame]->Reset();
}

void RHIContext::EndFrame()
{
	if (!m_submit_infos.empty())
	{
		for (int32_t i = static_cast<int32_t>(m_submit_infos.size()) - 1; i >= 0; i--)
		{
			if (!m_submit_infos[i].is_cuda)
			{
				m_submit_infos[i].signal_semaphores.push_back(m_render_complete[m_current_frame].get());
				m_submit_infos[i].wait_semaphores.push_back(m_present_complete[m_current_frame].get());
				break;
			}
		}

		std::vector<SubmitInfo> pack_submit_infos;
		pack_submit_infos.reserve(m_submit_infos.size());
		RHIQueueFamily last_queue_family = m_submit_infos[0].queue_family;
		bool           last_is_cuda      = m_submit_infos[0].is_cuda;

		for (auto &submit_info : m_submit_infos)
		{
			if (last_queue_family != submit_info.queue_family || last_is_cuda != submit_info.is_cuda)
			{
				if (last_is_cuda)
				{
					m_cuda_queue->Execute(last_queue_family, pack_submit_infos);
				}
				else
				{
					m_queue->Execute(last_queue_family, pack_submit_infos, m_frames[m_current_frame]->AllocateFence());
				}
				pack_submit_infos.clear();
				last_queue_family = submit_info.queue_family;
				last_is_cuda      = submit_info.is_cuda;
			}
			pack_submit_infos.push_back(submit_info);
		}
		if (!pack_submit_infos.empty())
		{
			m_queue->Execute(last_queue_family, pack_submit_infos, m_frames[m_current_frame]->AllocateFence());
		}
		m_submit_infos.clear();
	}

	if (!m_swapchain->Present(m_render_complete[m_current_frame].get()) ||
	    p_window->GetWidth() != m_swapchain->GetWidth() ||
	    p_window->GetHeight() != m_swapchain->GetHeight() ||
	    m_vsync != m_swapchain->GetVsync())
	{
		m_swapchain->Resize(p_window->GetWidth(), p_window->GetHeight(), m_vsync);
		LOG_INFO("Swapchain resize to {} x {}", p_window->GetWidth(), p_window->GetHeight());
	}

	m_current_frame = (m_current_frame + 1) % m_swapchain->GetTextureCount();
}

}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIDescriptor.cpp
================================================
#include "RHI/RHIDescriptor.hpp"
#include "RHI/RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIDescriptor::RHIDescriptor(RHIDevice *device, const ShaderMeta &meta) :
    p_device(device), m_meta(meta)
{
}

const ShaderMeta &RHIDescriptor::GetShaderMeta() const
{
	return m_meta;
}

std::unique_ptr<RHIDescriptor> RHIDescriptor::Create(RHIDevice *device, const ShaderMeta &meta)
{
	return std::unique_ptr<RHIDescriptor>(std::move(PluginManager::GetInstance().Call<RHIDescriptor *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateDescriptor", device, meta)));
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIDevice.cpp
================================================
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIDevice::RHIDevice(const std::string &backend) :
    m_backend(backend)
{
}

std::unique_ptr<RHIDevice> RHIDevice::Create(const std::string &backend)
{
	return std::unique_ptr<RHIDevice>(std::move(PluginManager::GetInstance().Call<RHIDevice *>(fmt::format("shared/RHI/RHI.{}.dll", backend), "CreateDevice")));
}

const std::string &RHIDevice::GetName() const
{
	return m_name;
}

const std::string RHIDevice::GetBackend() const
{
	return m_backend;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIFrame.cpp
================================================
#include "RHIFrame.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIFrame::RHIFrame(RHIDevice *device) :
    p_device(device)
{
}

std::unique_ptr<RHIFrame> RHIFrame::Create(RHIDevice *device)
{
	return std::unique_ptr<RHIFrame>(std::move(PluginManager::GetInstance().Call<RHIFrame *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateFrame", device)));
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIPipelineState.cpp
================================================
#include "RHIPipelineState.hpp"
#include "RHIDevice.hpp"

#include <Core/Hash.hpp>
#include <Core/Plugin.hpp>

namespace Ilum
{
RHIPipelineState::RHIPipelineState(RHIDevice *device) :
    p_device(device)
{
}

std::unique_ptr<RHIPipelineState> RHIPipelineState::Create(RHIDevice *device)
{
	return std::unique_ptr<RHIPipelineState>(std::move(PluginManager::GetInstance().Call<RHIPipelineState *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreatePipelineState", device)));
}

RHIPipelineState &RHIPipelineState::SetShader(RHIShaderStage stage, RHIShader *shader)
{
	m_shaders.emplace_back(std::make_pair(stage, shader));
	m_dirty = true;
	return *this;
}

RHIPipelineState &RHIPipelineState::SetDepthStencilState(const DepthStencilState &state)
{
	if (m_depth_stencil_state != state)
	{
		m_depth_stencil_state = state;
		m_dirty               = true;
	}
	return *this;
}

RHIPipelineState &RHIPipelineState::SetBlendState(const BlendState &state)
{
	if (m_blend_state != state)
	{
		m_blend_state = state;
		m_dirty       = true;
	}
	return *this;
}

RHIPipelineState &RHIPipelineState::SetRasterizationState(const RasterizationState &state)
{
	if (m_rasterization_state != state)
	{
		m_rasterization_state = state;
		m_dirty               = true;
	}
	return *this;
}

RHIPipelineState &RHIPipelineState::SetMultisampleState(const MultisampleState &state)
{
	if (m_multisample_state != state)
	{
		m_multisample_state = state;
		m_dirty             = true;
	}
	return *this;
}

RHIPipelineState &RHIPipelineState::SetVertexInputState(const VertexInputState &state)
{
	if (m_vertex_input_state != state)
	{
		m_vertex_input_state = state;
		m_dirty              = true;
	}
	return *this;
}

RHIPipelineState &RHIPipelineState::SetInputAssemblyState(const InputAssemblyState &state)
{
	if (m_input_assembly_state != state)
	{
		m_input_assembly_state = state;
		m_dirty                = true;
	}
	return *this;
}

RHIPipelineState& RHIPipelineState::ClearShader()
{
	m_shaders.clear();
	return *this;
}

const std::vector<std::pair<RHIShaderStage, RHIShader *>> &RHIPipelineState::GetShaders() const
{
	return m_shaders;
}

const DepthStencilState &RHIPipelineState::GetDepthStencilState() const
{
	return m_depth_stencil_state;
}

const BlendState &RHIPipelineState::GetBlendState() const
{
	return m_blend_state;
}

const RasterizationState &RHIPipelineState::GetRasterizationState() const
{
	return m_rasterization_state;
}

const MultisampleState &RHIPipelineState::GetMultisampleState() const
{
	return m_multisample_state;
}

const VertexInputState &RHIPipelineState::GetVertexInputState() const
{
	return m_vertex_input_state;
}

const InputAssemblyState &RHIPipelineState::GetInputAssemblyState() const
{
	return m_input_assembly_state;
}

size_t RHIPipelineState::GetHash()
{
	if (m_dirty)
	{
		m_hash = 0;

		// Hash Shader
		for (auto &[stage, shader] : m_shaders)
		{
			HashCombine(m_hash, stage, shader);
		}

		// Hash Depth Stencil State
		HashCombine(m_hash,
		            m_depth_stencil_state.compare,
		            m_depth_stencil_state.depth_test_enable,
		            m_depth_stencil_state.depth_write_enable);

		// Hash Blend State
		HashCombine(m_hash, m_blend_state.enable, m_blend_state.logic_op);
		for (auto &attachment_state : m_blend_state.attachment_states)
		{
			HashCombine(m_hash,
			            attachment_state.blend_enable,
			            attachment_state.src_color_blend,
			            attachment_state.dst_color_blend,
			            attachment_state.color_blend_op,
			            attachment_state.color_write_mask,
			            attachment_state.src_alpha_blend,
			            attachment_state.dst_alpha_blend,
			            attachment_state.alpha_blend_op);
		}

		// Hash Rasterization State
		HashCombine(m_hash,
		            m_rasterization_state.cull_mode,
		            m_rasterization_state.front_face,
		            m_rasterization_state.polygon_mode,
		            m_rasterization_state.depth_bias_enable,
		            m_rasterization_state.depth_clamp_enable,
		            m_rasterization_state.depth_bias,
		            m_rasterization_state.depth_bias_clamp,
		            m_rasterization_state.depth_bias_slope);

		// Hash Multisample State
		HashCombine(m_hash,
		            m_multisample_state.enable,
		            m_multisample_state.samples,
		            m_multisample_state.sample_mask);

		// Hash Vertex Input State
		for (auto &input_attribute : m_vertex_input_state.input_attributes)
		{
			HashCombine(m_hash,
			            input_attribute.location,
			            input_attribute.binding,
			            input_attribute.format,
			            input_attribute.offset);
		}

		// Hash Input Assembly State
		HashCombine(m_hash, m_input_assembly_state.topology);

		m_dirty = false;
	}
	return m_hash;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIProfiler.cpp
================================================
#include "RHIProfiler.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIProfiler::RHIProfiler(RHIDevice *device, uint32_t frame_count) :
    p_device(device), m_frame_count(frame_count)
{
}

std::unique_ptr<RHIProfiler> RHIProfiler::Create(RHIDevice *device, uint32_t frame_count)
{
	return std::unique_ptr<RHIProfiler>(std::move(PluginManager::GetInstance().Call<RHIProfiler *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateProfiler", device, frame_count)));
}

const ProfileState &RHIProfiler::GetProfileState() const
{
	return m_state;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIQueue.cpp
================================================
#include "RHIQueue.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIQueue::RHIQueue(RHIDevice *device)
{
}

std::unique_ptr<RHIQueue> RHIQueue::Create(RHIDevice *device)
{
	return std::unique_ptr<RHIQueue>(std::move(PluginManager::GetInstance().Call<RHIQueue *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateQueue", device)));
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIRenderTarget.cpp
================================================
#include "RHIRenderTarget.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIRenderTarget::RHIRenderTarget(RHIDevice *device) :
    p_device(device)
{
}

std::unique_ptr<RHIRenderTarget> RHIRenderTarget::Create(RHIDevice *device)
{
	return std::unique_ptr<RHIRenderTarget>(std::move(PluginManager::GetInstance().Call<RHIRenderTarget *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateRenderTarget", device)));
}

uint32_t RHIRenderTarget::GetWidth() const
{
	return m_width;
}

uint32_t RHIRenderTarget::GetHeight() const
{
	return m_height;
}

uint32_t RHIRenderTarget::GetLayers() const
{
	return m_layers;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHISampler.cpp
================================================
#include "RHISampler.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
SamplerDesc SamplerDesc::LinearClamp()
{
	return SamplerDesc{
	    RHIFilter::Linear,
	    RHIFilter::Linear,
	    RHIAddressMode::Clamp_To_Edge,
	    RHIAddressMode::Clamp_To_Edge,
	    RHIAddressMode::Clamp_To_Edge,
	    RHIMipmapMode::Linear};
}

SamplerDesc SamplerDesc::LinearWarp()
{
	return SamplerDesc{
	    RHIFilter::Linear,
	    RHIFilter::Linear,
	    RHIAddressMode::Repeat,
	    RHIAddressMode::Repeat,
	    RHIAddressMode::Repeat,
	    RHIMipmapMode::Linear};
}

SamplerDesc SamplerDesc::NearestClamp()
{
	return SamplerDesc{
	    RHIFilter::Nearest,
	    RHIFilter::Nearest,
	    RHIAddressMode::Clamp_To_Edge,
	    RHIAddressMode::Clamp_To_Edge,
	    RHIAddressMode::Clamp_To_Edge,
	    RHIMipmapMode::Nearest};
}

SamplerDesc SamplerDesc::NearestWarp()
{
	return SamplerDesc{
	    RHIFilter::Nearest,
	    RHIFilter::Nearest,
	    RHIAddressMode::Repeat,
	    RHIAddressMode::Repeat,
	    RHIAddressMode::Repeat,
	    RHIMipmapMode::Nearest};
}

RHISampler::RHISampler(RHIDevice *device, const SamplerDesc &desc) :
    p_device(device), m_desc(desc)
{
}

std::unique_ptr<RHISampler> RHISampler::Create(RHIDevice *device, const SamplerDesc &desc)
{
	return std::unique_ptr<RHISampler>(std::move(PluginManager::GetInstance().Call<RHISampler *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateSampler", device, desc)));
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHIShader.cpp
================================================
#include "RHIShader.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIShader::RHIShader(RHIDevice *device, const std::string &entry_point, const std::vector<uint8_t> &source) :
    p_device(device), m_entry_point(entry_point)
{
}

std::unique_ptr<RHIShader> RHIShader::Create(RHIDevice *device, const std::string &entry_point, const std::vector<uint8_t> &source)
{
	return std::unique_ptr<RHIShader>(std::move(PluginManager::GetInstance().Call<RHIShader *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateShader", device, entry_point, source)));
}

const std::string &RHIShader::GetEntryPoint() const
{
	return m_entry_point;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHISwapchain.cpp
================================================
#include "RHISwapchain.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHISwapchain::RHISwapchain(RHIDevice *device, uint32_t width, uint32_t height, bool vsync) :
    p_device(device), m_width(width), m_height(height), m_vsync(vsync)
{
}

bool RHISwapchain::GetVsync() const
{
	return m_vsync;
}

uint32_t RHISwapchain::GetWidth() const
{
	return m_width;
}

uint32_t RHISwapchain::GetHeight() const
{
	return m_height;
}

std::unique_ptr<RHISwapchain> RHISwapchain::Create(RHIDevice *device, void *window_handle, uint32_t width, uint32_t height, bool vsync)
{
	return std::unique_ptr<RHISwapchain>(std::move(PluginManager::GetInstance().Call<RHISwapchain *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateSwapchain", device, window_handle, width, height, vsync)));
}

}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHISynchronization.cpp
================================================
#include "RHISynchronization.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHIFence::RHIFence(RHIDevice *device) :
    p_device(device)
{
}

std::unique_ptr<RHIFence> RHIFence::Create(RHIDevice *device)
{
	return std::unique_ptr<RHIFence>(std::move(PluginManager::GetInstance().Call<RHIFence *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateFence", device)));
}

RHISemaphore::RHISemaphore(RHIDevice *device) :
    p_device(device)
{
}

std::unique_ptr<RHISemaphore> RHISemaphore::Create(RHIDevice *device)
{
	return std::unique_ptr<RHISemaphore>(std::move(PluginManager::GetInstance().Call<RHISemaphore *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateSemaphore", device)));
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Private/RHITexture.cpp
================================================
#include "RHITexture.hpp"
#include "RHIDevice.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
RHITexture::RHITexture(RHIDevice *device, const TextureDesc &desc) :
    p_device(device), m_desc(desc)
{
}

const TextureDesc &RHITexture::GetDesc() const
{
	return m_desc;
}

const std::string RHITexture::GetBackend() const
{
	return p_device->GetBackend();
}

std::unique_ptr<RHITexture> RHITexture::Alias(const TextureDesc &desc)
{
	return nullptr;
}

std::unique_ptr<RHITexture> RHITexture::Create(RHIDevice *device, const TextureDesc &desc)
{
	return std::unique_ptr<RHITexture>(std::move(PluginManager::GetInstance().Call<RHITexture *>(fmt::format("shared/RHI/RHI.{}.dll", device->GetBackend()), "CreateTexture", device, desc)));
}

std::unique_ptr<RHITexture> RHITexture::Create2D(RHIDevice *device, uint32_t width, uint32_t height, RHIFormat format, RHITextureUsage usage, bool mipmap, uint32_t samples)
{
	TextureDesc desc = {};
	desc.width       = width;
	desc.height      = height;
	desc.depth       = 1;
	desc.layers      = 1;
	desc.mips        = mipmap ? static_cast<uint32_t>(std::floor(std::log2(std::max(width, height)))) + 1 : 1;
	desc.samples     = samples;
	desc.format      = format;
	desc.usage       = usage;

	return Create(device, desc);
}

std::unique_ptr<RHITexture> RHITexture::Create3D(RHIDevice *device, uint32_t width, uint32_t height, uint32_t depth, RHIFormat format, RHITextureUsage usage)
{
	TextureDesc desc = {};
	desc.width       = width;
	desc.height      = height;
	desc.depth       = depth;
	desc.layers      = 1;
	desc.mips        = 1;
	desc.samples     = 1;
	desc.format      = format;
	desc.usage       = usage;

	return Create(device, desc);
}

std::unique_ptr<RHITexture> RHITexture::CreateCube(RHIDevice *device, uint32_t width, uint32_t height, RHIFormat format, RHITextureUsage usage, bool mipmap)
{
	TextureDesc desc = {};
	desc.width       = width;
	desc.height      = height;
	desc.depth       = 1;
	desc.layers      = 6;
	desc.mips        = mipmap ? static_cast<uint32_t>(std::floor(std::log2(std::max(width, height)))) + 1 : 1;
	desc.samples     = 1;
	desc.format      = format;
	desc.usage       = usage;

	return Create(device, desc);
}

std::unique_ptr<RHITexture> RHITexture::Create2DArray(RHIDevice *device, uint32_t width, uint32_t height, uint32_t layers, RHIFormat format, RHITextureUsage usage, bool mipmap, uint32_t samples)
{
	TextureDesc desc = {};
	desc.width       = width;
	desc.height      = height;
	desc.depth       = 1;
	desc.layers      = layers;
	desc.mips        = mipmap ? static_cast<uint32_t>(std::floor(std::log2(std::max(width, height)))) + 1 : 1;
	desc.samples     = samples;
	desc.format      = format;
	desc.usage       = usage;

	return Create(device, desc);
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/Fwd.hpp
================================================
#pragma once

#include "RHIDefinitions.hpp"

#include <Core/Core.hpp>
#include <Core/Hash.hpp>
#include <Core/Window.hpp>

#include <array>
#include <chrono>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>

#include <glm/glm.hpp>

namespace Ilum
{
class RHIAccelerationStructure;
class RHIBuffer;
class RHICommand;
class RHIDescriptor;
class RHIDevice;
class RHIFrame;
class RHIPipelineState;
class RHIProfiler;
class RHIQueue;
class RHIRenderTarget;
class RHISampler;
class RHIShader;
class RHISwapchain;
class RHIFence;
class RHISemaphore;
class RHITexture;
struct ShaderMeta;
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIAccelerationStructure.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
struct TLASDesc
{
	struct InstanceInfo
	{
		glm::mat4 transform;
		uint32_t  material_id;

		RHIAccelerationStructure *blas = nullptr;
	};

	std::string name;

	std::vector<InstanceInfo> instances;
};

struct BLASDesc
{
	std::string name;

	RHIBuffer *vertex_buffer = nullptr;
	RHIBuffer *index_buffer  = nullptr;

	uint32_t vertices_count  = 0;
	uint32_t indices_count   = 0;
	uint32_t vertices_offset = 0;
	uint32_t indices_offset  = 0;
};

class RHIAccelerationStructure
{
  public:
	RHIAccelerationStructure(RHIDevice *device);

	virtual ~RHIAccelerationStructure() = default;

	static std::unique_ptr<RHIAccelerationStructure> Create(RHIDevice *rhi_device);

	virtual void Update(RHICommand *cmd_buffer, const TLASDesc &desc) = 0;

	virtual void Update(RHICommand *cmd_buffer, const BLASDesc &desc) = 0;

  protected:
	RHIDevice *p_device = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIBuffer.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
STRUCT(BufferDesc, Enable)
{
	std::string    name;
	RHIBufferUsage usage;
	RHIMemoryUsage memory;

	META(Min(1))
	size_t size;

	META(Min(0))
	size_t stride;

	META(Min(0))
	size_t count;

	template <typename Archive>
	void serialize(Archive & archive)
	{
		archive(name, usage, memory, size, stride, count);
	}
};

class RHIBuffer
{
  public:
	RHIBuffer(RHIDevice *device, const BufferDesc &desc);

	virtual ~RHIBuffer() = default;

	const std::string GetBackend() const;

	static std::unique_ptr<RHIBuffer> Create(RHIDevice *device, const BufferDesc &desc);

	const BufferDesc &GetDesc() const;

	virtual void CopyToDevice(const void *data, size_t size, size_t offset = 0) = 0;

	virtual void CopyToHost(void *data, size_t size, size_t offset = 0) = 0;

	virtual void *Map()   = 0;
	virtual void  Unmap() = 0;

	virtual void Flush(size_t offset, size_t size) = 0;

  protected:
	RHIDevice *p_device = nullptr;
	BufferDesc m_desc;
};

struct BufferStateTransition
{
	RHIBuffer       *buffer;
	RHIResourceState src;
	RHIResourceState dst;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHICommand.hpp
================================================
#pragma once

#include "Fwd.hpp"
#include "RHIBuffer.hpp"
#include "RHITexture.hpp"

namespace Ilum
{
enum class CommandState
{
	Available,
	Initial,
	Recording,
	Executable,
	Pending
};

struct RHIDrawIndirectCommand
{
	uint32_t vertex_count;
	uint32_t instance_count;
	uint32_t vertex_offset;
	uint32_t instance_offset;
};

struct RHIDrawIndexedIndirectCommand
{
	uint32_t index_count;
	uint32_t instance_count;
	uint32_t index_offset;
	int32_t  vertex_offset;
	uint32_t instance_offset;
};

struct RHIDispatchIndirectCommand
{
	uint32_t x;
	uint32_t y;
	uint32_t z;
};

struct RHIDrawMeshTasksIndirectCommand
{
	uint32_t group_count_x;
	uint32_t group_count_y;
	uint32_t group_count_z;
};

class RHICommand
{
  public:
	RHICommand(RHIDevice *device, RHIQueueFamily family);

	virtual ~RHICommand() = default;

	RHIQueueFamily GetQueueFamily() const;

	const std::string GetBackend() const;

	CommandState GetState() const;

	void Init();

	static std::unique_ptr<RHICommand> Create(RHIDevice *device, RHIQueueFamily family);

	virtual void SetName(const std::string &name) = 0;

	virtual void Begin() = 0;
	virtual void End()   = 0;

	virtual void BeginMarker(const std::string &name, float r = 1.f, float g = 1.f, float b = 1.f, float a = 1.f) = 0;
	virtual void EndMarker()                                                                                      = 0;

	virtual void BeginRenderPass(RHIRenderTarget *render_target) = 0;
	virtual void EndRenderPass()                                 = 0;

	virtual void BindVertexBuffer(uint32_t binding, RHIBuffer *vertex_buffer)    = 0;
	virtual void BindIndexBuffer(RHIBuffer *index_buffer, bool is_short = false) = 0;

	virtual void BindDescriptor(RHIDescriptor *descriptor)           = 0;
	virtual void BindPipelineState(RHIPipelineState *pipeline_state) = 0;

	virtual void SetViewport(float width, float height, float x = 0.f, float y = 0.f)                    = 0;
	virtual void SetScissor(uint32_t width, uint32_t height, int32_t offset_x = 0, int32_t offset_y = 0) = 0;

	// Drawcall
	virtual void Dispatch(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z) = 0;
	virtual void DispatchIndirect(RHIBuffer *buffer, size_t offset)                                                                      = 0;

	virtual void Draw(uint32_t vertex_count, uint32_t instance_count = 1, uint32_t first_vertex = 0, uint32_t first_instance = 0)                                   = 0;
	virtual void DrawIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)                                                               = 0;
	virtual void DrawIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) = 0;

	virtual void DrawIndexed(uint32_t index_count, uint32_t instance_count = 1, uint32_t first_index = 0, uint32_t vertex_offset = 0, uint32_t first_instance = 0)         = 0;
	virtual void DrawIndexedIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)                                                               = 0;
	virtual void DrawIndexedIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) = 0;

	virtual void DrawMeshTask(uint32_t thread_x, uint32_t thread_y, uint32_t thread_z, uint32_t block_x, uint32_t block_y, uint32_t block_z)                                 = 0;
	virtual void DrawMeshTasksIndirect(RHIBuffer *buffer, size_t offset, uint32_t draw_count, uint32_t stride)                                                               = 0;
	virtual void DrawMeshTasksIndirectCount(RHIBuffer *buffer, size_t offset, RHIBuffer *count_buffer, size_t count_buffer_offset, uint32_t max_draw_count, uint32_t stride) = 0;

	// RayTracing
	virtual void TraceRay(uint32_t width, uint32_t height, uint32_t depth) = 0;

	// Resource Copy
	virtual void CopyBufferToTexture(RHIBuffer *src_buffer, RHITexture *dst_texture, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count) = 0;
	virtual void CopyTextureToBuffer(RHITexture *src_texture, RHIBuffer *dst_buffer, uint32_t mip_level, uint32_t base_layer, uint32_t layer_count) = 0;
	virtual void CopyBufferToBuffer(RHIBuffer *src_buffer, RHIBuffer *dst_buffer, size_t size, size_t src_offset = 0, size_t dst_offset = 0)        = 0;

	virtual void GenerateMipmaps(RHITexture *texture, RHIResourceState initial_state, RHIFilter filter)                                                                                                                                                  = 0;
	virtual void BlitTexture(RHITexture *src_texture, const TextureRange &src_range, const RHIResourceState &src_state, RHITexture *dst_texture, const TextureRange &dst_range, const RHIResourceState &dst_state, RHIFilter filter = RHIFilter::Linear) = 0;

	// Resource Reset
	virtual void FillBuffer(RHIBuffer *buffer, RHIResourceState state, size_t size, size_t offset = 0, uint32_t data = 0)    = 0;
	virtual void FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, const glm::vec4 &color) = 0;
	virtual void FillTexture(RHITexture *texture, RHIResourceState state, const TextureRange &range, float depth) = 0;

	// Resource Barrier
	virtual void ResourceStateTransition(const std::vector<TextureStateTransition> &texture_transitions, const std::vector<BufferStateTransition> &buffer_transitions) = 0;

  protected:
	RHIDevice     *p_device = nullptr;
	RHIQueueFamily m_family;
	CommandState   m_state = CommandState::Available;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIContext.hpp
================================================
#pragma once

#include "Fwd.hpp"

#include "RHIAccelerationStructure.hpp"
#include "RHIBuffer.hpp"
#include "RHICommand.hpp"
#include "RHIDescriptor.hpp"
#include "RHIDevice.hpp"
#include "RHIFrame.hpp"
#include "RHIPipelineState.hpp"
#include "RHIProfiler.hpp"
#include "RHIQueue.hpp"
#include "RHIRenderTarget.hpp"
#include "RHISampler.hpp"
#include "RHIShader.hpp"
#include "RHISwapchain.hpp"
#include "RHISynchronization.hpp"
#include "RHITexture.hpp"

namespace Ilum
{
#undef CreateSemaphore

class RHIContext
{
  public:
	RHIContext(Window *window, const std::string &backend = "Vulkan", bool vsync = false);

	~RHIContext();

	const std::string &GetDeviceName() const;

	const std::string GetBackend() const;

	bool HasCUDA() const;

	bool IsVsync() const;

	void SetVsync(bool vsync);

	bool IsFeatureSupport(RHIFeature feature) const;

	void WaitIdle() const;

	RHISwapchain *GetSwapchain() const;

	std::unique_ptr<RHISwapchain> CreateSwapchain(void *window_handle, uint32_t width, uint32_t height, bool sync);

	// Create Texture
	std::unique_ptr<RHITexture> CreateTexture(const TextureDesc &desc);
	std::unique_ptr<RHITexture> CreateTexture2D(uint32_t width, uint32_t height, RHIFormat format, RHITextureUsage usage, bool mipmap, uint32_t samples = 1);
	std::unique_ptr<RHITexture> CreateTexture3D(uint32_t width, uint32_t height, uint32_t depth, RHIFormat format, RHITextureUsage usage);
	std::unique_ptr<RHITexture> CreateTextureCube(uint32_t width, uint32_t height, RHIFormat format, RHITextureUsage usage, bool mipmap);
	std::unique_ptr<RHITexture> CreateTexture2DArray(uint32_t width, uint32_t height, uint32_t layers, RHIFormat format, RHITextureUsage usage, bool mipmap, uint32_t samples = 1);

	// Texture Conversion
	std::unique_ptr<RHITexture> MapToCUDATexture(RHITexture *texture);

	// Create Buffer
	std::unique_ptr<RHIBuffer> CreateBuffer(const BufferDesc &desc);
	std::unique_ptr<RHIBuffer> CreateBuffer(size_t size, RHIBufferUsage usage, RHIMemoryUsage memory);

	template <typename T>
	std::unique_ptr<RHIBuffer> CreateBuffer(size_t count, RHIBufferUsage usage, RHIMemoryUsage memory)
	{
		BufferDesc desc = {};
		desc.count      = count;
		desc.stride     = sizeof(T);
		desc.usage      = usage;
		desc.memory     = memory;
		desc.size       = desc.count * desc.stride;

		return CreateBuffer(desc);
	}

	// Buffer Conversion
	std::unique_ptr<RHIBuffer> MapToCUDABuffer(RHIBuffer *buffer);

	// Create Sampler
	RHISampler *CreateSampler(const SamplerDesc &desc);

	uint32_t GetSamplerIndex(const SamplerDesc &desc);

	std::vector<RHISampler *> GetSamplers() const;

	size_t GetSamplerCount() const;

	// Create Command
	RHICommand *CreateCommand(RHIQueueFamily family, bool cuda = false);

	// Create Descriptor
	RHIDescriptor *CreateDescriptor(const ShaderMeta &meta, bool cuda = false);

	// Create PipelineState
	std::unique_ptr<RHIPipelineState> CreatePipelineState(bool cuda = false);

	// Create Shader
	std::unique_ptr<RHIShader> CreateShader(const std::string &entry_point, const std::vector<uint8_t> &source, bool cuda = false);

	// Create Render Target
	std::unique_ptr<RHIRenderTarget> CreateRenderTarget(bool cuda = false);

	// Create Profiler
	std::unique_ptr<RHIProfiler> CreateProfiler(bool cuda = false);

	// Create Fence
	std::unique_ptr<RHIFence> CreateFence();

	// Create Fence that will reset every frame
	RHIFence *CreateFrameFence();

	// Create Semaphore
	std::unique_ptr<RHISemaphore> CreateSemaphore(bool cuda = false);

	// Create Frame Semaphore
	RHISemaphore *CreateFrameSemaphore();

	std::unique_ptr<RHISemaphore> MapToCUDASemaphore(RHISemaphore *semaphore);

	// Create Acceleration Structure
	std::unique_ptr<RHIAccelerationStructure> CreateAcccelerationStructure();

	// Submit command buffer
	void Submit(std::vector<RHICommand *> &&cmd_buffers, std::vector<RHISemaphore *> &&wait_semaphores = {}, std::vector<RHISemaphore *> &&signal_semaphores = {});

	// Execute immediate command buffer
	void Execute(RHICommand *cmd_buffer);

	void Execute(std::vector<RHICommand *> &&cmd_buffers, std::vector<RHISemaphore *> &&wait_semaphores, std::vector<RHISemaphore *> &&signal_semaphores, RHIFence *fence = nullptr);

	void Reset();

	// Get Back Buffer
	RHITexture *GetBackBuffer();

	// Frame
	void BeginFrame();

	void EndFrame();

  private:
	uint32_t m_current_frame = 0;
	bool     m_vsync         = false;

  private:
	Window *p_window = nullptr;

	std::unique_ptr<RHIDevice> m_device      = nullptr;
	std::unique_ptr<RHIDevice> m_cuda_device = nullptr;

	std::unique_ptr<RHISwapchain> m_swapchain = nullptr;

	std::unique_ptr<RHIQueue> m_queue      = nullptr;
	std::unique_ptr<RHIQueue> m_cuda_queue = nullptr;

	std::vector<std::unique_ptr<RHISemaphore>> m_present_complete;
	std::vector<std::unique_ptr<RHISemaphore>> m_render_complete;

	std::vector<std::unique_ptr<RHIFrame>> m_frames;
	std::vector<std::unique_ptr<RHIFrame>> m_cuda_frames;

	std::vector<SubmitInfo> m_submit_infos;

	std::vector<std::unique_ptr<RHISampler>> m_samplers;
	std::unordered_map<size_t, size_t>       m_sampler_lookup;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIDefinitions.hpp
================================================
#pragma once

#include <Core/Core.hpp>

namespace Ilum
{
ENUM(RHIShaderStage, Enable){
    Vertex                 = 1,
    TessellationControl    = 1 << 1,
    TessellationEvaluation = 1 << 2,
    Geometry               = 1 << 3,
    Fragment               = 1 << 4,
    Compute                = 1 << 5,
    RayGen                 = 1 << 6,
    AnyHit                 = 1 << 7,
    ClosestHit             = 1 << 8,
    Miss                   = 1 << 9,
    Intersection           = 1 << 10,
    Callable               = 1 << 11,
    Mesh                   = 1 << 12,
    Task                   = 1 << 13};

DEFINE_ENUMCLASS_OPERATION(RHIShaderStage);

ENUM(RHIFeature, Enable){
    RayTracing,
    MeshShading,
    BufferDeviceAddress,
    Bindless};

ENUM(RHIQueueFamily, Enable){
    Graphics,
    Compute,
    Transfer};

ENUM(RHIFormat, Enable){
    Undefined          = 0,
    R16_UINT           = 1,
    R16_SINT           = 1 << 1,
    R16_FLOAT          = 1 << 2,
    R8G8B8A8_UNORM     = 1 << 3,
    B8G8R8A8_UNORM     = 1 << 4,
    R32_UINT           = 1 << 5,
    R32_SINT           = 1 << 6,
    R32_FLOAT          = 1 << 7,
    D32_FLOAT          = 1 << 8,
    D24_UNORM_S8_UINT  = 1 << 9,
    R16G16_UINT        = 1 << 10,
    R16G16_SINT        = 1 << 11,
    R16G16_FLOAT       = 1 << 12,
    R10G10B10A2_UNORM  = 1 << 13,
    R10G10B10A2_UINT   = 1 << 14,
    R11G11B10_FLOAT    = 1 << 15,
    R16G16B16A16_UINT  = 1 << 16,
    R16G16B16A16_SINT  = 1 << 17,
    R16G16B16A16_FLOAT = 1 << 18,
    R32G32_UINT        = 1 << 19,
    R32G32_SINT        = 1 << 20,
    R32G32_FLOAT       = 1 << 21,
    R32G32B32_UINT     = 1 << 22,
    R32G32B32_SINT     = 1 << 23,
    R32G32B32_FLOAT    = 1 << 24,
    R32G32B32A32_UINT  = 1 << 25,
    R32G32B32A32_SINT  = 1 << 26,
    R32G32B32A32_FLOAT = 1 << 27,
};

DEFINE_ENUMCLASS_OPERATION(RHIFormat);

inline uint32_t GetFormatStride(RHIFormat format)
{
	switch (format)
	{
		case RHIFormat::Undefined:
			return 0;
		case RHIFormat::R16_UINT:
		case RHIFormat::R16_SINT:
		case RHIFormat::R16_FLOAT:
			return 2;
		case RHIFormat::R32_UINT:
		case RHIFormat::R32_SINT:
		case RHIFormat::R32_FLOAT:
		case RHIFormat::D32_FLOAT:
		case RHIFormat::R16G16_UINT:
		case RHIFormat::R16G16_SINT:
		case RHIFormat::R16G16_FLOAT:
		case RHIFormat::R8G8B8A8_UNORM:
		case RHIFormat::B8G8R8A8_UNORM:
		case RHIFormat::D24_UNORM_S8_UINT:
		case RHIFormat::R10G10B10A2_UNORM:
		case RHIFormat::R10G10B10A2_UINT:
		case RHIFormat::R11G11B10_FLOAT:
			return 4;
		case RHIFormat::R16G16B16A16_UINT:
		case RHIFormat::R16G16B16A16_SINT:
		case RHIFormat::R16G16B16A16_FLOAT:
		case RHIFormat::R32G32_UINT:
		case RHIFormat::R32G32_SINT:
		case RHIFormat::R32G32_FLOAT:
			return 8;
		case RHIFormat::R32G32B32_UINT:
		case RHIFormat::R32G32B32_SINT:
		case RHIFormat::R32G32B32_FLOAT:
			return 12;
		case RHIFormat::R32G32B32A32_UINT:
		case RHIFormat::R32G32B32A32_SINT:
		case RHIFormat::R32G32B32A32_FLOAT:
			return 16;
		default:
			return 0;
	}
}

inline bool IsDepthFormat(RHIFormat format)
{
	return format == RHIFormat::D32_FLOAT ||
	       format == RHIFormat::D24_UNORM_S8_UINT;
}

inline bool IsStencilFormat(RHIFormat format)
{
	return format == RHIFormat::D24_UNORM_S8_UINT;
}

ENUM(RHIVertexSemantics, Enable){
    Binormal,
    Blend_Indices,
    Blend_Weights,
    Color,
    Normal,
    Position,
    Tangent,
    Texcoord};

ENUM(RHIMemoryUsage, Enable){
    GPU_Only,
    CPU_TO_GPU,
    GPU_TO_CPU};

// Texture
ENUM(RHITextureDimension, Enable) :
    uint64_t{
        Texture1D        = 1,
        Texture2D        = 1 << 1,
        Texture3D        = 1 << 2,
        TextureCube      = 1 << 3,
        Texture1DArray   = 1 << 4,
        Texture2DArray   = 1 << 5,
        TextureCubeArray = 1 << 6,
    };

inline RHITextureDimension GetTextureDimension(uint32_t width, uint32_t height, uint32_t depth, uint32_t layers)
{
	if (layers == 1)
	{
		if (depth == 1)
		{
			if (height == 1)
			{
				return RHITextureDimension::Texture1D;
			}
			else
			{
				return RHITextureDimension::Texture2D;
			}
		}
		else
		{
			return RHITextureDimension::Texture3D;
		}
	}

	if (layers == 6)
	{
		return RHITextureDimension::TextureCube;
	}

	if (layers % 6 == 0)
	{
		return RHITextureDimension::TextureCubeArray;
	}

	if (height == 1)
	{
		return RHITextureDimension::Texture1DArray;
	}
	else
	{
		return RHITextureDimension::Texture2DArray;
	}
}

// Buffer
ENUM(RHIBufferUsage, Enable){
    Undefined             = 0,
    Vertex                = 1,
    Index                 = 1 << 1,
    Indirect              = 1 << 2,
    Transfer              = 1 << 3,
    AccelerationStructure = 1 << 4,
    ShaderResource        = 1 << 5,
    UnorderedAccess       = 1 << 6,
    ConstantBuffer        = 1 << 7};
DEFINE_ENUMCLASS_OPERATION(RHIBufferUsage);

ENUM(RHITextureUsage, Enable){
    Undefined       = 0,
    Transfer        = 1,
    ShaderResource  = 1 << 1,
    UnorderedAccess = 1 << 2,
    RenderTarget    = 1 << 3};

DEFINE_ENUMCLASS_OPERATION(RHITextureUsage);

ENUM(RHIResourceState, Enable){
    Undefined,
    VertexBuffer,
    ConstantBuffer,
    IndexBuffer,
    IndirectBuffer,
    TransferSource,
    TransferDest,
    ShaderResource,
    UnorderedAccess,
    RenderTarget,
    DepthWrite,
    DepthRead,
    AccelerationStructure,
    Present};

inline RHITextureUsage ResourceStateToTextureUsage(RHIResourceState state)
{
	switch (state)
	{
		case RHIResourceState::TransferSource:
		case RHIResourceState::TransferDest:
			return RHITextureUsage::Transfer;
		case RHIResourceState::ShaderResource:
			return RHITextureUsage::ShaderResource;
		case RHIResourceState::UnorderedAccess:
			return RHITextureUsage::UnorderedAccess;
		case RHIResourceState::RenderTarget:
		case RHIResourceState::DepthWrite:
			return RHITextureUsage::RenderTarget;
		case RHIResourceState::DepthRead:
			return RHITextureUsage::ShaderResource;
		default:
			break;
	}

	return RHITextureUsage::Undefined;
}

inline RHIBufferUsage ResourceStateToBufferUsage(RHIResourceState state)
{
	switch (state)
	{
		case RHIResourceState::VertexBuffer:
			return RHIBufferUsage::Vertex;
		case RHIResourceState::ConstantBuffer:
			return RHIBufferUsage::ConstantBuffer;
		case RHIResourceState::IndexBuffer:
			return RHIBufferUsage::Index;
		case RHIResourceState::IndirectBuffer:
		case RHIResourceState::TransferSource:
		case RHIResourceState::TransferDest:
			return RHIBufferUsage::Transfer;
		case RHIResourceState::ShaderResource:
			return RHIBufferUsage::ShaderResource;
		case RHIResourceState::UnorderedAccess:
			return RHIBufferUsage::UnorderedAccess;
		case RHIResourceState::AccelerationStructure:
			return RHIBufferUsage::AccelerationStructure;
		default:
			break;
	}
	return RHIBufferUsage::Undefined;
}

// Sampler
ENUM(RHIFilter, Enable){
    Nearest,
    Linear};

ENUM(RHIAddressMode, Enable){
    Repeat,
    Mirrored_Repeat,
    Clamp_To_Edge,
    Clamp_To_Border,
    Mirror_Clamp_To_Edge};

ENUM(RHIMipmapMode, Enable){
    Nearest,
    Linear};

ENUM(RHISamplerBorderColor, Enable){
    Float_Transparent_Black,
    Int_Transparent_Black,
    Float_Opaque_Black,
    Int_Opaque_Black,
    Float_Opaque_White,
    Int_Opaque_White};

// Pipeline State
ENUM(RHICompareOp, Enable){
    Never,
    Less,
    Equal,
    Less_Or_Equal,
    Greater,
    Not_Equal,
    Greater_Or_Equal,
    Always};

ENUM(RHILogicOp, Enable){
    Clear,
    And,
    And_Reverse,
    Copy,
    And_Inverted,
    No_Op,
    XOR,
    Or,
    Nor,
    Equivalent,
    Invert,
    Or_Reverse,
    Copy_Inverted,
    Or_Inverted,
    Nand,
    Set};

ENUM(RHIBlendFactor, Enable){
    Zero,
    One,
    Src_Color,
    One_Minus_Src_Color,
    Dst_Color,
    One_Minus_Dst_Color,
    Src_Alpha,
    One_Minus_Src_Alpha,
    Dst_Alpha,
    One_Minus_Dst_Alpha,
    Constant_Color,
    One_Minus_Constant_Color,
    Constant_Alpha,
    One_Minus_Constant_Alpha,
    Src_Alpha_Saturate,
    Src1_Color,
    One_Minus_Src1_Color,
    Src1_Alpha,
    One_Minus_Src1_Alpha};

ENUM(RHIBlendOp, Enable){
    Add,
    Subtract,
    Reverse_Subtract,
    Min,
    Max};

ENUM(RHICullMode, Enable){
    None,
    Front,
    Back};

ENUM(RHIFrontFace, Enable){
    Counter_Clockwise,
    Clockwise};

ENUM(RHIPolygonMode, Enable){
    Wireframe,
    Solid};

ENUM(RHIPrimitiveTopology, Enable){
    Point,
    Line,
    Triangle,
    Patch};

ENUM(RHIVertexInputRate, Enable){
    Vertex,
    Instance};

ENUM(RHILoadAction, Enable){
    DontCare,
    Load,
    Clear};

ENUM(RHIStoreAction, Enable){
    DontCare,
    Store};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIDescriptor.hpp
================================================
#pragma once

#include "Fwd.hpp"
#include "RHIShader.hpp"
#include "RHITexture.hpp"

namespace Ilum
{
class RHIDescriptor
{
  public:
	RHIDescriptor(RHIDevice *device, const ShaderMeta &meta);

	virtual ~RHIDescriptor() = default;

	const ShaderMeta &GetShaderMeta() const;

	static std::unique_ptr<RHIDescriptor> Create(RHIDevice *device, const ShaderMeta &meta);

	virtual RHIDescriptor &BindTexture(const std::string &name, RHITexture *texture, RHITextureDimension dimension)                       = 0;
	virtual RHIDescriptor &BindTexture(const std::string &name, RHITexture *texture, const TextureRange &range)                           = 0;
	virtual RHIDescriptor &BindTexture(const std::string &name, const std::vector<RHITexture *> &textures, RHITextureDimension dimension) = 0;

	virtual RHIDescriptor &BindSampler(const std::string &name, RHISampler *sampler)                       = 0;
	virtual RHIDescriptor &BindSampler(const std::string &name, const std::vector<RHISampler *> &samplers) = 0;

	virtual RHIDescriptor &BindBuffer(const std::string &name, RHIBuffer *buffer)                              = 0;
	virtual RHIDescriptor &BindBuffer(const std::string &name, RHIBuffer *buffer, size_t offset, size_t range) = 0;
	virtual RHIDescriptor &BindBuffer(const std::string &name, const std::vector<RHIBuffer *> &buffers)        = 0;

	virtual RHIDescriptor &BindConstant(const std::string &name, const void *constant) = 0;

	template <typename T>
	RHIDescriptor &SetConstant(const std::string &name, const T &constant)
	{
		return BindConstant(name, &constant);
	}

	virtual RHIDescriptor &BindAccelerationStructure(const std::string &name, RHIAccelerationStructure *acceleration_structure) = 0;

  protected:
	RHIDevice       *p_device = nullptr;
	const ShaderMeta m_meta;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIDevice.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
class RHIDevice
{
  public:
	RHIDevice(const std::string &backend = "Vulkan");

	virtual ~RHIDevice() = default;

	static std::unique_ptr<RHIDevice> Create(const std::string &backend = "Vulkan");

	const std::string &GetName() const;

	const std::string GetBackend() const;

	virtual void WaitIdle() = 0;

	virtual bool IsFeatureSupport(RHIFeature feature) = 0;

  protected:
	const std::string m_backend;
	std::string m_name;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIFrame.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
struct ShaderMeta;

class RHIFrame
{
  public:
	RHIFrame(RHIDevice *device);

	virtual ~RHIFrame() = default;

	static std::unique_ptr<RHIFrame> Create(RHIDevice *device);

	virtual RHIFence *AllocateFence() = 0;

	virtual RHISemaphore *AllocateSemaphore() = 0;

	virtual RHICommand *AllocateCommand(RHIQueueFamily family) = 0;

	virtual RHIDescriptor *AllocateDescriptor(const ShaderMeta &meta) = 0;

	virtual void Reset() = 0;

  protected:
	RHIDevice *p_device = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIPipelineState.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
struct DepthStencilState
{
	bool depth_test_enable  = true;
	bool depth_write_enable = true;

	RHICompareOp compare = RHICompareOp::Less_Or_Equal;
	// TODO: Stencil Test

	inline bool operator==(const DepthStencilState &state) const
	{
		return depth_test_enable == state.depth_test_enable &&
		       depth_write_enable == state.depth_write_enable &&
		       compare == state.compare;
	}

	inline bool operator!=(const DepthStencilState &state) const
	{
		return !(*this == state);
	}
};

struct BlendState
{
	bool                 enable          = false;
	RHILogicOp           logic_op        = RHILogicOp::Or;
	std::array<float, 4> blend_constants = {0.f};

	struct AttachmentState
	{
		bool           blend_enable     = false;
		RHIBlendFactor src_color_blend  = RHIBlendFactor::Src_Alpha;
		RHIBlendFactor dst_color_blend  = RHIBlendFactor::One_Minus_Src_Alpha;
		RHIBlendOp     color_blend_op   = RHIBlendOp::Add;
		RHIBlendFactor src_alpha_blend  = RHIBlendFactor::One;
		RHIBlendFactor dst_alpha_blend  = RHIBlendFactor::Zero;
		RHIBlendOp     alpha_blend_op   = RHIBlendOp::Add;
		uint8_t        color_write_mask = 1 | 2 | 4 | 8;

		inline bool operator==(const AttachmentState &state) const
		{
			return blend_enable == state.blend_enable &&
			       src_color_blend == state.src_color_blend &&
			       dst_color_blend == state.dst_color_blend &&
			       color_blend_op == state.color_blend_op &&
			       src_alpha_blend == state.src_alpha_blend &&
			       dst_alpha_blend == state.dst_alpha_blend &&
			       alpha_blend_op == state.alpha_blend_op &&
			       color_write_mask == state.color_write_mask;
		}
		inline bool operator!=(const AttachmentState &state) const
		{
			return !(*this == state);
		}
	};

	std::vector<AttachmentState> attachment_states;

	inline bool operator==(const BlendState &state) const
	{
		if (enable != state.enable ||
		    logic_op != state.logic_op ||
		    blend_constants[0] != state.blend_constants[0] ||
		    blend_constants[1] != state.blend_constants[1] ||
		    blend_constants[2] != state.blend_constants[2] ||
		    blend_constants[3] != state.blend_constants[3])
		{
			return false;
		}

		if (attachment_states.size() == state.attachment_states.size())
		{
			for (uint32_t i = 0; i < attachment_states.size(); i++)
			{
				if (attachment_states[i] != state.attachment_states[i])
				{
					return false;
				}
			}
			return true;
		}
		else
		{
			return false;
		}
	}
	inline bool operator!=(const BlendState &state) const
	{
		return !(*this == state);
	}
};

struct RasterizationState
{
	RHICullMode    cull_mode         = RHICullMode::Back;
	RHIFrontFace   front_face        = RHIFrontFace::Counter_Clockwise;
	RHIPolygonMode polygon_mode      = RHIPolygonMode::Solid;
	bool           depth_bias_enable = false;
	bool           depth_clamp_enable  = false;
	float          line_width        = 1.f;
	float          depth_bias        = 0.f;
	float          depth_bias_clamp  = 0.f;
	float          depth_bias_slope  = 0.f;

	inline bool operator==(const RasterizationState &state) const
	{
		return cull_mode == state.cull_mode &&
		       front_face == state.front_face &&
		       polygon_mode == state.polygon_mode &&
		       line_width == state.line_width &&
		       depth_bias_enable == state.depth_bias_enable &&
		       depth_clamp_enable == state.depth_clamp_enable &&
		       depth_bias == state.depth_bias &&
		       depth_bias_clamp == state.depth_bias_clamp &&
		       depth_bias_slope == state.depth_bias_slope;
	}
	inline bool operator!=(const RasterizationState &state) const
	{
		return !(*this == state);
	}
};

struct MultisampleState
{
	bool     enable      = false;
	uint32_t samples     = 1;
	uint32_t sample_mask = 0;

	inline bool operator==(const MultisampleState &state) const
	{
		return enable == state.enable &&
		       samples == state.samples &&
		       sample_mask == state.sample_mask;
	}
	inline bool operator!=(const MultisampleState &state) const
	{
		return !(*this == state);
	}
};

struct VertexInputState
{
	struct InputBinding
	{
		uint32_t           binding;
		uint32_t           stride;
		RHIVertexInputRate rate;

		inline bool operator==(const InputBinding &desc) const
		{
			return binding == desc.binding &&
			       stride == desc.stride &&
			       rate == desc.rate;
		}
		inline bool operator!=(const InputBinding &state) const
		{
			return !(*this == state);
		}
	};

	struct InputAttribute
	{
		RHIVertexSemantics semantics;
		uint32_t           location;
		uint32_t           binding;
		RHIFormat          format;
		uint32_t           offset;

		inline bool operator==(const InputAttribute &desc) const
		{
			return semantics == desc.semantics &&
			       location == desc.location &&
			       binding == desc.binding &&
			       format == desc.format &&
			       offset == desc.offset;
		}
		inline bool operator!=(const InputAttribute &state) const
		{
			return !(*this == state);
		}
	};

	std::vector<InputAttribute> input_attributes;
	std::vector<InputBinding>   input_bindings;

	inline bool operator==(const VertexInputState &state) const
	{
		bool same_input_attributes = false;
		bool same_input_bindings   = false;

		if (input_attributes.size() == state.input_attributes.size())
		{
			for (uint32_t i = 0; i < input_attributes.size(); i++)
			{
				if (input_attributes[i] != state.input_attributes[i])
				{
					return false;
				}
			}
			same_input_attributes = true;
		}

		if (input_bindings.size() == state.input_bindings.size())
		{
			for (uint32_t i = 0; i < input_bindings.size(); i++)
			{
				if (input_bindings[i] != state.input_bindings[i])
				{
					return false;
				}
			}
			same_input_bindings = true;
		}

		return same_input_attributes && same_input_bindings;
	}

	inline bool operator!=(const VertexInputState &state) const
	{
		return !(*this == state);
	}
};

struct InputAssemblyState
{
	RHIPrimitiveTopology topology = RHIPrimitiveTopology::Triangle;

	inline bool operator==(const InputAssemblyState &state) const
	{
		return topology == state.topology;
	}

	inline bool operator!=(const InputAssemblyState &state) const
	{
		return !(*this == state);
	}
};

// TODO: Tessellation

class RHIPipelineState
{
  public:
	RHIPipelineState(RHIDevice *device);

	virtual ~RHIPipelineState() = default;

	static std::unique_ptr<RHIPipelineState> Create(RHIDevice *device);

	RHIPipelineState &SetShader(RHIShaderStage stage, RHIShader *shader);
	RHIPipelineState &SetDepthStencilState(const DepthStencilState &state);
	RHIPipelineState &SetBlendState(const BlendState &state);
	RHIPipelineState &SetRasterizationState(const RasterizationState &state);
	RHIPipelineState &SetMultisampleState(const MultisampleState &state);
	RHIPipelineState &SetVertexInputState(const VertexInputState &state);
	RHIPipelineState &SetInputAssemblyState(const InputAssemblyState &state);

	RHIPipelineState &ClearShader();

	const std::vector<std::pair<RHIShaderStage, RHIShader *>> &GetShaders() const;
	const DepthStencilState                                   &GetDepthStencilState() const;
	const BlendState                                          &GetBlendState() const;
	const RasterizationState                                  &GetRasterizationState() const;
	const MultisampleState                                    &GetMultisampleState() const;
	const VertexInputState                                    &GetVertexInputState() const;
	const InputAssemblyState                                  &GetInputAssemblyState() const;

	size_t GetHash();

  protected:
	RHIDevice *p_device = nullptr;

	std::vector<std::pair<RHIShaderStage, RHIShader *>> m_shaders;

	DepthStencilState  m_depth_stencil_state;
	BlendState         m_blend_state;
	RasterizationState m_rasterization_state;
	MultisampleState   m_multisample_state;
	InputAssemblyState m_input_assembly_state;
	VertexInputState   m_vertex_input_state;

	bool   m_dirty = false;
	size_t m_hash  = 0;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIProfiler.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
struct ProfileState
{
	std::chrono::time_point<std::chrono::high_resolution_clock> cpu_start;
	std::chrono::time_point<std::chrono::high_resolution_clock> cpu_end;

	uint64_t gpu_start = 0;
	uint64_t gpu_end   = 0;

	float cpu_time = 0.f;
	float gpu_time = 0.f;

	std::thread::id thread_id;
};

class RHIProfiler
{
  public:
	RHIProfiler(RHIDevice *device, uint32_t frame_count = 3);

	virtual ~RHIProfiler() = default;

	static std::unique_ptr<RHIProfiler> Create(RHIDevice *device, uint32_t frame_count = 3);

	const ProfileState &GetProfileState() const;

	virtual void Begin(RHICommand *cmd_buffer, uint32_t frame_index) = 0;

	virtual void End(RHICommand *cmd_buffer) = 0;

  protected:
	RHIDevice *p_device = nullptr;
	uint32_t   m_frame_count;
	uint32_t   m_current_index = 0;
	ProfileState m_state;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIQueue.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
struct SubmitInfo
{
	RHIQueueFamily queue_family;
	bool           is_cuda;

	std::vector<RHICommand *>   cmd_buffers;
	std::vector<RHISemaphore *> wait_semaphores;
	std::vector<RHISemaphore *> signal_semaphores;
};

class RHIQueue
{
  public:
	RHIQueue(RHIDevice *device);

	virtual ~RHIQueue() = default;

	static std::unique_ptr<RHIQueue> Create(RHIDevice *device);

	virtual void Execute(RHIQueueFamily family, const std::vector<SubmitInfo> &submit_infos, RHIFence* fence = nullptr) = 0;

	// Immediate execution
	virtual void Execute(RHICommand *cmd_buffer) = 0;

	virtual void Wait() = 0;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIRenderTarget.hpp
================================================
#pragma once

#include "Fwd.hpp"
#include "RHITexture.hpp"

namespace Ilum
{
struct ColorAttachment
{
	RHILoadAction  load  = RHILoadAction::Clear;
	RHIStoreAction store = RHIStoreAction::Store;

	std::array<float, 4> clear_value = {0.f};
};

struct DepthStencilAttachment
{
	RHILoadAction  depth_load    = RHILoadAction::Clear;
	RHIStoreAction depth_store   = RHIStoreAction::Store;
	RHILoadAction  stencil_load  = RHILoadAction::DontCare;
	RHIStoreAction stencil_store = RHIStoreAction::DontCare;

	float    clear_depth   = std::numeric_limits<float>::max();
	uint32_t clear_stencil = 0;
};

class RHIRenderTarget
{
  public:
	RHIRenderTarget(RHIDevice *device);

	virtual ~RHIRenderTarget() = default;

	static std::unique_ptr<RHIRenderTarget> Create(RHIDevice *device);

	virtual RHIRenderTarget &Set(uint32_t slot, RHITexture *texture, RHITextureDimension dimension, const ColorAttachment &attachment) = 0;
	virtual RHIRenderTarget &Set(uint32_t slot, RHITexture *texture, const TextureRange &range, const ColorAttachment &attachment)     = 0;
	virtual RHIRenderTarget &Set(RHITexture *texture, RHITextureDimension dimension, const DepthStencilAttachment &attachment)         = 0;
	virtual RHIRenderTarget &Set(RHITexture *texture, const TextureRange &range, const DepthStencilAttachment &attachment)             = 0;

	uint32_t GetWidth() const;

	uint32_t GetHeight() const;

	uint32_t GetLayers() const;

	virtual RHIRenderTarget &Clear() = 0;

  protected:
	RHIDevice *p_device = nullptr;

	uint32_t m_width  = 0;
	uint32_t m_height = 0;
	uint32_t m_layers = 0;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHISampler.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
ENUM(SamplerStateType, Enable){
    LinearClamp,
    LinearWarp,
    NearestClamp,
    NearestWarp,
};

struct SamplerDesc
{
	RHIFilter min_filter;
	RHIFilter mag_filter;

	RHIAddressMode address_mode_u;
	RHIAddressMode address_mode_v;
	RHIAddressMode address_mode_w;
	RHIMipmapMode  mipmap_mode;

	RHISamplerBorderColor border_color = RHISamplerBorderColor::Float_Transparent_Black;

	bool anisotropic = true;

	float mip_lod_bias = 0.f;
	float min_lod      = 0.f;
	float max_lod      = 100.f;

	template<typename Archive>
	void serialize(Archive& archive)
	{
		archive(min_filter, mag_filter, address_mode_u, address_mode_v, address_mode_w, mipmap_mode, border_color, anisotropic, mip_lod_bias, min_lod, max_lod);
	}

	static SamplerDesc LinearClamp();
	static SamplerDesc LinearWarp();
	static SamplerDesc NearestClamp();
	static SamplerDesc NearestWarp();
};

class RHISampler
{
  public:
	RHISampler(RHIDevice *device, const SamplerDesc &desc);

	virtual ~RHISampler() = default;

	static std::unique_ptr<RHISampler> Create(RHIDevice *device, const SamplerDesc &desc);

  protected:
	RHIDevice  *p_device = nullptr;
	SamplerDesc m_desc;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHIShader.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
ENUM(DescriptorType, Enable){
    Sampler,
    TextureSRV,
    TextureUAV,
    ConstantBuffer,
    StructuredBuffer,
    AccelerationStructure};

STRUCT(ShaderMeta, Enable)
{
	STRUCT(Variable, Enable)
	{
		uint32_t  spirv_id;
		uint32_t  location;
		RHIFormat format;

		inline bool operator==(const Variable &other) const
		{
			return location == other.location &&
			       format == other.format;
		}

		template <typename Archive>
		void serialize(Archive & archive)
		{
			archive(spirv_id, location, format);
		}
	};

	STRUCT(Constant, Enable)
	{
		uint32_t       spirv_id;
		std::string    name;
		uint32_t       size   = 0;
		uint32_t       offset = 0;
		RHIShaderStage stage;

		inline bool operator==(const Constant &other) const
		{
			return size == other.size &&
			       offset == other.offset &&
			       stage == other.stage;
		}

		template <typename Archive>
		void serialize(Archive & archive)
		{
			archive(spirv_id, name, size, offset, stage);
		}
	};

	STRUCT(Descriptor, Enable)
	{
		uint32_t       spirv_id;
		std::string    name;
		uint32_t       array_size;
		uint32_t       set;
		uint32_t       binding;
		DescriptorType type;
		RHIShaderStage stage;

		inline bool operator==(const Descriptor &other) const
		{
			return array_size == other.array_size &&
			       set == other.set &&
			       binding == other.binding &&
			       type == other.type;
		}

		template <typename Archive>
		void serialize(Archive & archive)
		{
			archive(spirv_id, name, array_size, set, binding, type, stage);
		}
	};

	inline ShaderMeta &operator+=(const ShaderMeta &rhs)
	{
		HashCombine(hash, rhs.hash);

		for (auto &rhs_descriptor : rhs.descriptors)
		{
			bool should_add = true;
			for (auto &descriptor : descriptors)
			{
				if (descriptor == rhs_descriptor)
				{
					descriptor.stage = descriptor.stage | rhs_descriptor.stage;
					should_add       = false;
				}
			}
			if (should_add)
			{
				descriptors.push_back(rhs_descriptor);
			}
		}

		for (auto &rhs_constant : rhs.constants)
		{
			bool should_add = true;
			for (auto &constant : constants)
			{
				if (constant == rhs_constant)
				{
					constant.stage = constant.stage | rhs_constant.stage;
				}
			}
			if (should_add)
			{
				constants.push_back(rhs_constant);
			}
		}

		for (auto &input : rhs.inputs)
		{
			inputs.push_back(input);
		}
		for (auto &output : rhs.outputs)
		{
			outputs.push_back(output);
		}

		return *this;
	}

	std::vector<Descriptor> descriptors;
	std::vector<Constant>   constants;
	std::vector<Variable>   inputs;
	std::vector<Variable>   outputs;

	size_t hash = 0;

	template <typename Archive>
	void serialize(Archive & archive)
	{
		archive(descriptors, constants, inputs, outputs, hash);
	}
};

class RHIShader
{
  public:
	RHIShader(RHIDevice *device, const std::string &entry_point, const std::vector<uint8_t> &source);

	virtual ~RHIShader() = default;

	static std::unique_ptr<RHIShader> Create(RHIDevice *device, const std::string &entry_point, const std::vector<uint8_t> &source);

	const std::string &GetEntryPoint() const;

  protected:
	RHIDevice  *p_device = nullptr;
	std::string m_entry_point;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHISwapchain.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
class RHISwapchain
{
  public:
	RHISwapchain(RHIDevice *device, uint32_t width, uint32_t height, bool vsync = false);

	virtual ~RHISwapchain() = default;

	bool GetVsync() const;

	uint32_t GetWidth() const;

	uint32_t GetHeight() const;

	static std::unique_ptr<RHISwapchain> Create(RHIDevice *device, void *window_handle, uint32_t width, uint32_t height, bool sync);

	virtual uint32_t GetTextureCount() = 0;

	virtual void AcquireNextTexture(RHISemaphore *signal_semaphore, RHIFence* signal_fence) = 0;

	virtual RHITexture *GetCurrentTexture() = 0;

	virtual uint32_t GetCurrentFrameIndex() = 0;

	virtual bool Present(RHISemaphore *semaphore) = 0;

	virtual void Resize(uint32_t width, uint32_t height, bool vsync) = 0;

  protected:
	RHIDevice *p_device = nullptr;
	uint32_t   m_width  = 0;
	uint32_t   m_height = 0;
	bool       m_vsync  = false;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHISynchronization.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
class RHIFence
{
  public:
	RHIFence(RHIDevice *device);
	virtual ~RHIFence() = default;

	static std::unique_ptr<RHIFence> Create(RHIDevice *device);

	virtual void Wait(uint64_t timeout = std::numeric_limits<uint64_t>::max()) = 0;
	virtual void Reset()                = 0;

  protected:
	RHIDevice *p_device = nullptr;
};

class RHISemaphore
{
  public:
	RHISemaphore(RHIDevice *device);

	virtual ~RHISemaphore() = default;

	virtual void SetName(const std::string &name) = 0;

	static std::unique_ptr<RHISemaphore> Create(RHIDevice *device);

  protected:
	RHIDevice *p_device = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/RHI/Public/RHI/RHITexture.hpp
================================================
#pragma once

#include "Fwd.hpp"

namespace Ilum
{
STRUCT(TextureDesc, Enable)
{
	std::string name;

	META(Min(1))
	uint32_t width = 1;

	META(Min(1))
	uint32_t height = 1;

	META(Min(1))
	uint32_t depth = 1;

	META(Min(1))
	uint32_t mips = 1;

	META(Min(1))
	uint32_t layers = 1;

	META(Min(1))
	uint32_t samples = 1;

	RHIFormat       format = RHIFormat::Undefined;
	RHITextureUsage usage  = RHITextureUsage::Undefined;

	template<typename Archive>
	void serialize(Archive & archive)
	{
		archive(name, width, height, depth, mips, layers, samples, format, usage);
	}
};

struct TextureRange
{
	RHITextureDimension dimension   = RHITextureDimension::Texture2D;
	uint32_t            base_mip    = 0;
	uint32_t            mip_count   = 1;
	uint32_t            base_layer  = 0;
	uint32_t            layer_count = 1;

	size_t Hash() const
	{
		size_t hash = 0;
		HashCombine(hash, dimension, base_mip, mip_count, base_layer, layer_count);
		return hash;
	}
};

class RHITexture
{
  public:
	RHITexture(RHIDevice *device, const TextureDesc &desc);

	virtual ~RHITexture() = default;

	const TextureDesc &GetDesc() const;

	const std::string GetBackend() const;

	virtual std::unique_ptr<RHITexture> Alias(const TextureDesc &desc);

	virtual size_t GetMemorySize() const = 0;

	static std::unique_ptr<RHITexture> Create(RHIDevice *device, const TextureDesc &desc);
	static std::unique_ptr<RHITexture> Create2D(RHIDevice *device, uint32_t width, uint32_t height, RHIFormat format, RHITextureUsage usage, bool mipmap, uint32_t samples = 1);
	static std::unique_ptr<RHITexture> Create3D(RHIDevice *device, uint32_t width, uint32_t height, uint32_t depth, RHIFormat format, RHITextureUsage usage);
	static std::unique_ptr<RHITexture> CreateCube(RHIDevice *device, uint32_t width, uint32_t height, RHIFormat format, RHITextureUsage usage, bool mipmap);
	static std::unique_ptr<RHITexture> Create2DArray(RHIDevice *device, uint32_t width, uint32_t height, uint32_t layers, RHIFormat format, RHITextureUsage usage, bool mipmap, uint32_t samples = 1);

  protected:
	RHIDevice  *p_device = nullptr;
	TextureDesc m_desc;
};

struct TextureStateTransition
{
	RHITexture *texture;

	RHIResourceState src;
	RHIResourceState dst;

	TextureRange range;

	RHIQueueFamily src_family = RHIQueueFamily::Graphics;
	RHIQueueFamily dst_family = RHIQueueFamily::Graphics;
};
}        // namespace Ilum


================================================
FILE: Source/Runtime/Render/Material/Private/Material/MaterialCompiler.cpp
================================================


================================================
FILE: Source/Runtime/Render/Material/Private/Material/MaterialData.cpp
================================================


================================================
FILE: Source/Runtime/Render/Material/Private/Material/MaterialGraph.cpp
================================================
#include "MaterialGraph.hpp"

namespace Ilum
{
MaterialGraphDesc &MaterialGraphDesc::SetName(const std::string &name)
{
	m_name = name;
	return *this;
}

MaterialNodeDesc &MaterialGraphDesc::AddNode(size_t handle, MaterialNodeDesc &&desc)
{
	for (auto &[pin_handle, pin] : desc.GetPins())
	{
		m_node_lookup[pin_handle] = handle;
	}

	m_node_lookup[handle] = handle;
	desc.SetHandle(handle);
	m_nodes.emplace(handle, std::move(desc));
	return m_nodes.at(handle);
}

void MaterialGraphDesc::EraseNode(size_t handle)
{
	const auto &desc = m_nodes.at(handle);
	const auto &pins = desc.GetPins();

	for (auto iter = m_edges.begin(); iter != m_edges.end();)
	{
		if (pins.find(iter->first) != pins.end() ||
		    pins.find(iter->second) != pins.end())
		{
			iter = m_edges.erase(iter);
		}
		else
		{
			iter++;
		}
	}

	for (auto &[handle, name] : pins)
	{
		m_node_lookup.erase(handle);
	}

	m_nodes.erase(handle);
}

void MaterialGraphDesc::EraseLink(size_t source, size_t target)
{
	if (m_edges.find(target) != m_edges.end() &&
	    m_edges.at(target) == source)
	{
		m_edges.erase(target);
	}
}

MaterialGraphDesc &MaterialGraphDesc::Link(size_t source, size_t target)
{
	const auto &src_node = m_nodes.at(m_node_lookup.at(source));
	const auto &dst_node = m_nodes.at(m_node_lookup.at(target));

	const auto &src_pin = src_node.GetPin(source);
	const auto &dst_pin = dst_node.GetPin(target);

	if ((src_pin.type & dst_pin.accept) &&
	    src_pin.attribute != dst_pin.attribute)
	{
		m_edges[target] = source;
	}

	return *this;
}

bool MaterialGraphDesc::HasLink(size_t target) const
{
	return m_edges.find(target) != m_edges.end();
}

size_t MaterialGraphDesc::LinkFrom(size_t target) const
{
	return m_edges.at(target);
}

const MaterialNodeDesc &MaterialGraphDesc::GetNode(size_t handle) const
{
	return m_nodes.at(m_node_lookup.at(handle));
}

const std::string &MaterialGraphDesc::GetName() const
{
	return m_name;
}

const std::map<size_t, MaterialNodeDesc> &MaterialGraphDesc::GetNodes() const
{
	return m_nodes;
}

const std::map<size_t, size_t> &MaterialGraphDesc::GetEdges() const
{
	return m_edges;
}

void MaterialGraphDesc::Clear()
{
	m_nodes.clear();
	m_edges.clear();
	m_node_lookup.clear();
}

}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Material/Private/Material/MaterialNode.cpp
================================================
#include "MaterialNode.hpp"
#include "MaterialGraph.hpp"

namespace Ilum
{
MaterialNodeDesc &MaterialNodeDesc::SetName(const std::string &name)
{
	m_name = name;
	return *this;
}

MaterialNodeDesc &MaterialNodeDesc::SetCategory(const std::string &category)
{
	m_category = category;
	return *this;
}

MaterialNodeDesc &MaterialNodeDesc::SetHandle(size_t handle)
{
	m_handle = handle;
	return *this;
}

MaterialNodeDesc &MaterialNodeDesc::Input(size_t handle, const std::string &name, MaterialNodePin::Type type, MaterialNodePin::Type accept, Variant &&variant)
{
	MaterialNodePin pin{type, accept == MaterialNodePin::Type::Unknown ? type : accept, MaterialNodePin::Attribute::Input, name, handle, std::move(variant)};
	m_pins.emplace(handle, pin);
	m_pin_indices.emplace(name, handle);
	return *this;
}

MaterialNodeDesc &MaterialNodeDesc::Output(size_t handle, const std::string &name, MaterialNodePin::Type type, Variant &&variant)
{
	MaterialNodePin pin{type, MaterialNodePin::Type::Unknown, MaterialNodePin::Attribute::Output, name, handle, std::move(variant)};
	m_pins.emplace(handle, pin);
	m_pin_indices.emplace(name, handle);
	return *this;
}

MaterialNodePin &MaterialNodeDesc::GetPin(size_t handle)
{
	return m_pins.at(handle);
}

const MaterialNodePin &MaterialNodeDesc::GetPin(size_t handle) const
{
	return m_pins.at(handle);
}

MaterialNodePin &MaterialNodeDesc::GetPin(const std::string &name)
{
	return m_pins.at(m_pin_indices.at(name));
}

const MaterialNodePin &MaterialNodeDesc::GetPin(const std::string &name) const
{
	return m_pins.at(m_pin_indices.at(name));
}

MaterialNodeDesc &MaterialNodeDesc::SetVariant(Variant variant)
{
	m_variant = variant;
	return *this;
}

const Variant &MaterialNodeDesc::GetVariant() const
{
	return m_variant;
}

const std::string &MaterialNodeDesc::GetName() const
{
	return m_name;
}

const std::string &MaterialNodeDesc::GetCategory() const
{
	return m_category;
}

const std::map<size_t, MaterialNodePin> &MaterialNodeDesc::GetPins() const
{
	return m_pins;
}

size_t MaterialNodeDesc::GetHandle() const
{
	return m_handle;
}

void MaterialNodeDesc::EmitHLSL(const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) const
{
	PluginManager::GetInstance().Call(fmt::format("shared/Material/Material.{}.{}.dll", m_category, m_name), "EmitHLSL", *this, graph_desc, manager, context);
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Material/Private/Material/Spectrum.cpp
================================================
#include "Spectrum.hpp"

namespace Ilum
{
template <typename Predicate>
int32_t Findint32_terval(int32_t size, const Predicate &pred)
{
	int32_t first = 0, len = size;
	while (len > 0)
	{
		int32_t half = len >> 1, middle = first + half;
		// Bisect range based on value of _pred_ at _middle_
		if (pred(middle))
		{
			first = middle + 1;
			len -= half + 1;
		}
		else
			len = half;
	}
	return glm::clamp(first - 1, 0, size - 2);
}

void XYZToRGB(const float xyz[3], float rgb[3])
{
	rgb[0] = 3.240479f * xyz[0] - 1.537150f * xyz[1] - 0.498535f * xyz[2];
	rgb[1] = -0.969256f * xyz[0] + 1.875991f * xyz[1] + 0.041556f * xyz[2];
	rgb[2] = 0.055648f * xyz[0] - 0.204043f * xyz[1] + 1.057311f * xyz[2];
}

void RGBToXYZ(const float rgb[3], float xyz[3])
{
	xyz[0] = 0.412453f * rgb[0] + 0.357580f * rgb[1] + 0.180423f * rgb[2];
	xyz[1] = 0.212671f * rgb[0] + 0.715160f * rgb[1] + 0.072169f * rgb[2];
	xyz[2] = 0.019334f * rgb[0] + 0.119193f * rgb[1] + 0.950227f * rgb[2];
}

bool SpectrumSamplesSorted(const float *lambda, const float *vals, int32_t n)
{
	for (int32_t i = 0; i < n - 1; ++i)
    {
        if (lambda[i] > lambda[i + 1])
        {
			return false;
        }
    }
	return true;
}

void SortSpectrumSamples(float *lambda, float *vals, int32_t n)
{
	std::vector<std::pair<float, float>> sort_vec;
	sort_vec.reserve(n);
    for (int32_t i = 0; i < n; ++i)
    {
		sort_vec.push_back(std::make_pair(lambda[i], vals[i]));
    }
	std::sort(sort_vec.begin(), sort_vec.end());
	for (int32_t i = 0; i < n; ++i)
	{
		lambda[i] = sort_vec[i].first;
		vals[i]   = sort_vec[i].second;
	}
}

float InterpolateSpectrumSamples(const float *lambda, const float *vals, int32_t n, float l)
{
    if (l <= lambda[0])
    {
		return vals[0];
    }
    if (l >= lambda[n - 1])
    {
		return vals[n - 1];
    }
	int32_t offset = Findint32_terval(n, [&](int32_t index) { return lambda[index] <= l; });

	float t = (l - lambda[offset]) / (lambda[offset + 1] - lambda[offset]);

	return glm::mix(vals[offset], vals[offset + 1], t);
}

glm::vec3 FromSampled(const float *lambda, const float *v, int32_t n)
{
	// Sort samples if unordered, use sorted for returned spectrum
	if (!SpectrumSamplesSorted(lambda, v, n))
	{
		std::vector<float> slambda(&lambda[0], &lambda[n]);
		std::vector<float> sv(&v[0], &v[n]);
		SortSpectrumSamples(&slambda[0], &sv[0], n);
		return FromSampled(&slambda[0], &sv[0], n);
	}
	float xyz[3] = {0, 0, 0};
	for (int i = 0; i < nCIESamples; ++i)
	{
		float val = InterpolateSpectrumSamples(lambda, v, n, CIE_lambda[i]);
		xyz[0] += val * CIE_X[i];
		xyz[1] += val * CIE_Y[i];
		xyz[2] += val * CIE_Z[i];
	}
	float scale = float(CIE_lambda[nCIESamples - 1] - CIE_lambda[0]) /
	              float(CIE_Y_integral * nCIESamples);
	xyz[0] *= scale;
	xyz[1] *= scale;
	xyz[2] *= scale;

    glm::vec3 rgb = glm::vec3(0.f);
	XYZToRGB(xyz, &rgb.x);
	return rgb;
}

const float CIE_X[nCIESamples] = {
    // CIE X function values
    0.0001299000f, 0.0001458470f, 0.0001638021f, 0.0001840037f,
    0.0002066902f, 0.0002321000f, 0.0002607280f, 0.0002930750f,
    0.0003293880f, 0.0003699140f, 0.0004149000f, 0.0004641587f,
    0.0005189860f, 0.0005818540f, 0.0006552347f, 0.0007416000f,
    0.0008450296f, 0.0009645268f, 0.001094949f, 0.001231154f,
    0.001368000f, 0.001502050f, 0.001642328f, 0.001802382f,
    0.001995757f, 0.002236000f, 0.002535385f, 0.002892603f,
    0.003300829f, 0.003753236f, 0.004243000f, 0.004762389f,
    0.005330048f, 0.005978712f, 0.006741117f, 0.007650000f,
    0.008751373f, 0.01002888f, 0.01142170f, 0.01286901f,
    0.01431000f, 0.01570443f, 0.01714744f, 0.01878122f,
    0.02074801f, 0.02319000f, 0.02620736f, 0.02978248f,
    0.03388092f, 0.03846824f, 0.04351000f, 0.04899560f,
    0.05502260f, 0.06171880f, 0.06921200f, 0.07763000f,
    0.08695811f, 0.09717672f, 0.1084063f, 0.1207672f,
    0.1343800f, 0.1493582f, 0.1653957f, 0.1819831f,
    0.1986110f, 0.2147700f, 0.2301868f, 0.2448797f,
    0.2587773f, 0.2718079f, 0.2839000f, 0.2949438f,
    0.3048965f, 0.3137873f, 0.3216454f, 0.3285000f,
    0.3343513f, 0.3392101f, 0.3431213f, 0.3461296f,
    0.3482800f, 0.3495999f, 0.3501474f, 0.3500130f,
    0.3492870f, 0.3480600f, 0.3463733f, 0.3442624f,
    0.3418088f, 0.3390941f, 0.3362000f, 0.3331977f,
    0.3300411f, 0.3266357f, 0.3228868f, 0.3187000f,
    0.3140251f, 0.3088840f, 0.3032904f, 0.2972579f,
    0.2908000f, 0.2839701f, 0.2767214f, 0.2689178f,
    0.2604227f, 0.2511000f, 0.2408475f, 0.2298512f,
    0.2184072f, 0.2068115f, 0.1953600f, 0.1842136f,
    0.1733273f, 0.1626881f, 0.1522833f, 0.1421000f,
    0.1321786f, 0.1225696f, 0.1132752f, 0.1042979f,
    0.09564000f, 0.08729955f, 0.07930804f, 0.07171776f,
    0.06458099f, 0.05795001f, 0.05186211f, 0.04628152f,
    0.04115088f, 0.03641283f, 0.03201000f, 0.02791720f,
    0.02414440f, 0.02068700f, 0.01754040f, 0.01470000f,
    0.01216179f, 0.009919960f, 0.007967240f, 0.006296346f,
    0.004900000f, 0.003777173f, 0.002945320f, 0.002424880f,
    0.002236293f, 0.002400000f, 0.002925520f, 0.003836560f,
    0.005174840f, 0.006982080f, 0.009300000f, 0.01214949f,
    0.01553588f, 0.01947752f, 0.02399277f, 0.02910000f,
    0.03481485f, 0.04112016f, 0.04798504f, 0.05537861f,
    0.06327000f, 0.07163501f, 0.08046224f, 0.08973996f,
    0.09945645f, 0.1096000f, 0.1201674f, 0.1311145f,
    0.1423679f, 0.1538542f, 0.1655000f, 0.1772571f,
    0.1891400f, 0.2011694f, 0.2133658f, 0.2257499f,
    0.2383209f, 0.2510668f, 0.2639922f, 0.2771017f,
    0.2904000f, 0.3038912f, 0.3175726f, 0.3314384f,
    0.3454828f, 0.3597000f, 0.3740839f, 0.3886396f,
    0.4033784f, 0.4183115f, 0.4334499f, 0.4487953f,
    0.4643360f, 0.4800640f, 0.4959713f, 0.5120501f,
    0.5282959f, 0.5446916f, 0.5612094f, 0.5778215f,
    0.5945000f, 0.6112209f, 0.6279758f, 0.6447602f,
    0.6615697f, 0.6784000f, 0.6952392f, 0.7120586f,
    0.7288284f, 0.7455188f, 0.7621000f, 0.7785432f,
    0.7948256f, 0.8109264f, 0.8268248f, 0.8425000f,
    0.8579325f, 0.8730816f, 0.8878944f, 0.9023181f,
    0.9163000f, 0.9297995f, 0.9427984f, 0.9552776f,
    0.9672179f, 0.9786000f, 0.9893856f, 0.9995488f,
    1.0090892f, 1.0180064f, 1.0263000f, 1.0339827f,
    1.0409860f, 1.0471880f, 1.0524667f, 1.0567000f,
    1.0597944f, 1.0617992f, 1.0628068f, 1.0629096f,
    1.0622000f, 1.0607352f, 1.0584436f, 1.0552244f,
    1.0509768f, 1.0456000f, 1.0390369f, 1.0313608f,
    1.0226662f, 1.0130477f, 1.0026000f, 0.9913675f,
    0.9793314f, 0.9664916f, 0.9528479f, 0.9384000f,
    0.9231940f, 0.9072440f, 0.8905020f, 0.8729200f,
    0.8544499f, 0.8350840f, 0.8149460f, 0.7941860f,
    0.7729540f, 0.7514000f, 0.7295836f, 0.7075888f,
    0.6856022f, 0.6638104f, 0.6424000f, 0.6215149f,
    0.6011138f, 0.5811052f, 0.5613977f, 0.5419000f,
    0.5225995f, 0.5035464f, 0.4847436f, 0.4661939f,
    0.4479000f, 0.4298613f, 0.4120980f, 0.3946440f,
    0.3775333f, 0.3608000f, 0.3444563f, 0.3285168f,
    0.3130192f, 0.2980011f, 0.2835000f, 0.2695448f,
    0.2561184f, 0.2431896f, 0.2307272f, 0.2187000f,
    0.2070971f, 0.1959232f, 0.1851708f, 0.1748323f,
    0.1649000f, 0.1553667f, 0.1462300f, 0.1374900f,
    0.1291467f, 0.1212000f, 0.1136397f, 0.1064650f,
    0.09969044f, 0.09333061f, 0.08740000f, 0.08190096f,
    0.07680428f, 0.07207712f, 0.06768664f, 0.06360000f,
    0.05980685f, 0.05628216f, 0.05297104f, 0.04981861f,
    0.04677000f, 0.04378405f, 0.04087536f, 0.03807264f,
    0.03540461f, 0.03290000f, 0.03056419f, 0.02838056f,
    0.02634484f, 0.02445275f, 0.02270000f, 0.02108429f,
    0.01959988f, 0.01823732f, 0.01698717f, 0.01584000f,
    0.01479064f, 0.01383132f, 0.01294868f, 0.01212920f,
    0.01135916f, 0.01062935f, 0.009938846f, 0.009288422f,
    0.008678854f, 0.008110916f, 0.007582388f, 0.007088746f,
    0.006627313f, 0.006195408f, 0.005790346f, 0.005409826f,
    0.005052583f, 0.004717512f, 0.004403507f, 0.004109457f,
    0.003833913f, 0.003575748f, 0.003334342f, 0.003109075f,
    0.002899327f, 0.002704348f, 0.002523020f, 0.002354168f,
    0.002196616f, 0.002049190f, 0.001910960f, 0.001781438f,
    0.001660110f, 0.001546459f, 0.001439971f, 0.001340042f,
    0.001246275f, 0.001158471f, 0.001076430f, 0.0009999493f,
    0.0009287358f, 0.0008624332f, 0.0008007503f, 0.0007433960f,
    0.0006900786f, 0.0006405156f, 0.0005945021f, 0.0005518646f,
    0.0005124290f, 0.0004760213f, 0.0004424536f, 0.0004115117f,
    0.0003829814f, 0.0003566491f, 0.0003323011f, 0.0003097586f,
    0.0002888871f, 0.0002695394f, 0.0002515682f, 0.0002348261f,
    0.0002191710f, 0.0002045258f, 0.0001908405f, 0.0001780654f,
    0.0001661505f, 0.0001550236f, 0.0001446219f, 0.0001349098f,
    0.0001258520f, 0.0001174130f, 0.0001095515f, 0.0001022245f,
    0.00009539445f, 0.00008902390f, 0.00008307527f, 0.00007751269f,
    0.00007231304f, 0.00006745778f, 0.00006292844f, 0.00005870652f,
    0.00005477028f, 0.00005109918f, 0.00004767654f, 0.00004448567f,
    0.00004150994f, 0.00003873324f, 0.00003614203f, 0.00003372352f,
    0.00003146487f, 0.00002935326f, 0.00002737573f, 0.00002552433f,
    0.00002379376f, 0.00002217870f, 0.00002067383f, 0.00001927226f,
    0.00001796640f, 0.00001674991f, 0.00001561648f, 0.00001455977f,
    0.00001357387f, 0.00001265436f, 0.00001179723f, 0.00001099844f,
    0.00001025398f, 0.000009559646f, 0.000008912044f, 0.000008308358f,
    0.000007745769f, 0.000007221456f, 0.000006732475f, 0.000006276423f,
    0.000005851304f, 0.000005455118f, 0.000005085868f, 0.000004741466f,
    0.000004420236f, 0.000004120783f, 0.000003841716f, 0.000003581652f,
    0.000003339127f, 0.000003112949f, 0.000002902121f, 0.000002705645f,
    0.000002522525f, 0.000002351726f, 0.000002192415f, 0.000002043902f,
    0.000001905497f, 0.000001776509f, 0.000001656215f, 0.000001544022f,
    0.000001439440f, 0.000001341977f, 0.000001251141f};

const float CIE_Y[nCIESamples] = {
    // CIE Y function values
    0.000003917000f, 0.000004393581f, 0.000004929604f, 0.000005532136f,
    0.000006208245f, 0.000006965000f, 0.000007813219f, 0.000008767336f,
    0.000009839844f, 0.00001104323f, 0.00001239000f, 0.00001388641f,
    0.00001555728f, 0.00001744296f, 0.00001958375f, 0.00002202000f,
    0.00002483965f, 0.00002804126f, 0.00003153104f, 0.00003521521f,
    0.00003900000f, 0.00004282640f, 0.00004691460f, 0.00005158960f,
    0.00005717640f, 0.00006400000f, 0.00007234421f, 0.00008221224f,
    0.00009350816f, 0.0001061361f, 0.0001200000f, 0.0001349840f,
    0.0001514920f, 0.0001702080f, 0.0001918160f, 0.0002170000f,
    0.0002469067f, 0.0002812400f, 0.0003185200f, 0.0003572667f,
    0.0003960000f, 0.0004337147f, 0.0004730240f, 0.0005178760f,
    0.0005722187f, 0.0006400000f, 0.0007245600f, 0.0008255000f,
    0.0009411600f, 0.001069880f, 0.001210000f, 0.001362091f,
    0.001530752f, 0.001720368f, 0.001935323f, 0.002180000f,
    0.002454800f, 0.002764000f, 0.003117800f, 0.003526400f,
    0.004000000f, 0.004546240f, 0.005159320f, 0.005829280f,
    0.006546160f, 0.007300000f, 0.008086507f, 0.008908720f,
    0.009767680f, 0.01066443f, 0.01160000f, 0.01257317f,
    0.01358272f, 0.01462968f, 0.01571509f, 0.01684000f,
    0.01800736f, 0.01921448f, 0.02045392f, 0.02171824f,
    0.02300000f, 0.02429461f, 0.02561024f, 0.02695857f,
    0.02835125f, 0.02980000f, 0.03131083f, 0.03288368f,
    0.03452112f, 0.03622571f, 0.03800000f, 0.03984667f,
    0.04176800f, 0.04376600f, 0.04584267f, 0.04800000f,
    0.05024368f, 0.05257304f, 0.05498056f, 0.05745872f,
    0.06000000f, 0.06260197f, 0.06527752f, 0.06804208f,
    0.07091109f, 0.07390000f, 0.07701600f, 0.08026640f,
    0.08366680f, 0.08723280f, 0.09098000f, 0.09491755f,
    0.09904584f, 0.1033674f, 0.1078846f, 0.1126000f,
    0.1175320f, 0.1226744f, 0.1279928f, 0.1334528f,
    0.1390200f, 0.1446764f, 0.1504693f, 0.1564619f,
    0.1627177f, 0.1693000f, 0.1762431f, 0.1835581f,
    0.1912735f, 0.1994180f, 0.2080200f, 0.2171199f,
    0.2267345f, 0.2368571f, 0.2474812f, 0.2586000f,
    0.2701849f, 0.2822939f, 0.2950505f, 0.3085780f,
    0.3230000f, 0.3384021f, 0.3546858f, 0.3716986f,
    0.3892875f, 0.4073000f, 0.4256299f, 0.4443096f,
    0.4633944f, 0.4829395f, 0.5030000f, 0.5235693f,
    0.5445120f, 0.5656900f, 0.5869653f, 0.6082000f,
    0.6293456f, 0.6503068f, 0.6708752f, 0.6908424f,
    0.7100000f, 0.7281852f, 0.7454636f, 0.7619694f,
    0.7778368f, 0.7932000f, 0.8081104f, 0.8224962f,
    0.8363068f, 0.8494916f, 0.8620000f, 0.8738108f,
    0.8849624f, 0.8954936f, 0.9054432f, 0.9148501f,
    0.9237348f, 0.9320924f, 0.9399226f, 0.9472252f,
    0.9540000f, 0.9602561f, 0.9660074f, 0.9712606f,
    0.9760225f, 0.9803000f, 0.9840924f, 0.9874812f,
    0.9903128f, 0.9928116f, 0.9949501f, 0.9967108f,
    0.9980983f, 0.9991120f, 0.9997482f, 1.0000000f,
    0.9998567f, 0.9993046f, 0.9983255f, 0.9968987f,
    0.9950000f, 0.9926005f, 0.9897426f, 0.9864444f,
    0.9827241f, 0.9786000f, 0.9740837f, 0.9691712f,
    0.9638568f, 0.9581349f, 0.9520000f, 0.9454504f,
    0.9384992f, 0.9311628f, 0.9234576f, 0.9154000f,
    0.9070064f, 0.8982772f, 0.8892048f, 0.8797816f,
    0.8700000f, 0.8598613f, 0.8493920f, 0.8386220f,
    0.8275813f, 0.8163000f, 0.8047947f, 0.7930820f,
    0.7811920f, 0.7691547f, 0.7570000f, 0.7447541f,
    0.7324224f, 0.7200036f, 0.7074965f, 0.6949000f,
    0.6822192f, 0.6694716f, 0.6566744f, 0.6438448f,
    0.6310000f, 0.6181555f, 0.6053144f, 0.5924756f,
    0.5796379f, 0.5668000f, 0.5539611f, 0.5411372f,
    0.5283528f, 0.5156323f, 0.5030000f, 0.4904688f,
    0.4780304f, 0.4656776f, 0.4534032f, 0.4412000f,
    0.4290800f, 0.4170360f, 0.4050320f, 0.3930320f,
    0.3810000f, 0.3689184f, 0.3568272f, 0.3447768f,
    0.3328176f, 0.3210000f, 0.3093381f, 0.2978504f,
    0.2865936f, 0.2756245f, 0.2650000f, 0.2547632f,
    0.2448896f, 0.2353344f, 0.2260528f, 0.2170000f,
    0.2081616f, 0.1995488f, 0.1911552f, 0.1829744f,
    0.1750000f, 0.1672235f, 0.1596464f, 0.1522776f,
    0.1451259f, 0.1382000f, 0.1315003f, 0.1250248f,
    0.1187792f, 0.1127691f, 0.1070000f, 0.1014762f,
    0.09618864f, 0.09112296f, 0.08626485f, 0.08160000f,
    0.07712064f, 0.07282552f, 0.06871008f, 0.06476976f,
    0.06100000f, 0.05739621f, 0.05395504f, 0.05067376f,
    0.04754965f, 0.04458000f, 0.04175872f, 0.03908496f,
    0.03656384f, 0.03420048f, 0.03200000f, 0.02996261f,
    0.02807664f, 0.02632936f, 0.02470805f, 0.02320000f,
    0.02180077f, 0.02050112f, 0.01928108f, 0.01812069f,
    0.01700000f, 0.01590379f, 0.01483718f, 0.01381068f,
    0.01283478f, 0.01192000f, 0.01106831f, 0.01027339f,
    0.009533311f, 0.008846157f, 0.008210000f, 0.007623781f,
    0.007085424f, 0.006591476f, 0.006138485f, 0.005723000f,
    0.005343059f, 0.004995796f, 0.004676404f, 0.004380075f,
    0.004102000f, 0.003838453f, 0.003589099f, 0.003354219f,
    0.003134093f, 0.002929000f, 0.002738139f, 0.002559876f,
    0.002393244f, 0.002237275f, 0.002091000f, 0.001953587f,
    0.001824580f, 0.001703580f, 0.001590187f, 0.001484000f,
    0.001384496f, 0.001291268f, 0.001204092f, 0.001122744f,
    0.001047000f, 0.0009765896f, 0.0009111088f, 0.0008501332f,
    0.0007932384f, 0.0007400000f, 0.0006900827f, 0.0006433100f,
    0.0005994960f, 0.0005584547f, 0.0005200000f, 0.0004839136f,
    0.0004500528f, 0.0004183452f, 0.0003887184f, 0.0003611000f,
    0.0003353835f, 0.0003114404f, 0.0002891656f, 0.0002684539f,
    0.0002492000f, 0.0002313019f, 0.0002146856f, 0.0001992884f,
    0.0001850475f, 0.0001719000f, 0.0001597781f, 0.0001486044f,
    0.0001383016f, 0.0001287925f, 0.0001200000f, 0.0001118595f,
    0.0001043224f, 0.00009733560f, 0.00009084587f, 0.00008480000f,
    0.00007914667f, 0.00007385800f, 0.00006891600f, 0.00006430267f,
    0.00006000000f, 0.00005598187f, 0.00005222560f, 0.00004871840f,
    0.00004544747f, 0.00004240000f, 0.00003956104f, 0.00003691512f,
    0.00003444868f, 0.00003214816f, 0.00003000000f, 0.00002799125f,
    0.00002611356f, 0.00002436024f, 0.00002272461f, 0.00002120000f,
    0.00001977855f, 0.00001845285f, 0.00001721687f, 0.00001606459f,
    0.00001499000f, 0.00001398728f, 0.00001305155f, 0.00001217818f,
    0.00001136254f, 0.00001060000f, 0.000009885877f, 0.000009217304f,
    0.000008592362f, 0.000008009133f, 0.000007465700f, 0.000006959567f,
    0.000006487995f, 0.000006048699f, 0.000005639396f, 0.000005257800f,
    0.000004901771f, 0.000004569720f, 0.000004260194f, 0.000003971739f,
    0.000003702900f, 0.000003452163f, 0.000003218302f, 0.000003000300f,
    0.000002797139f, 0.000002607800f, 0.000002431220f, 0.000002266531f,
    0.000002113013f, 0.000001969943f, 0.000001836600f, 0.000001712230f,
    0.000001596228f, 0.000001488090f, 0.000001387314f, 0.000001293400f,
    0.000001205820f, 0.000001124143f, 0.000001048009f, 0.0000009770578f,
    0.0000009109300f, 0.0000008492513f, 0.0000007917212f, 0.0000007380904f,
    0.0000006881098f, 0.0000006415300f, 0.0000005980895f, 0.0000005575746f,
    0.0000005198080f, 0.0000004846123f, 0.0000004518100f};

const float CIE_Z[nCIESamples] = {
    // CIE Z function values
    0.0006061000f,
    0.0006808792f,
    0.0007651456f,
    0.0008600124f,
    0.0009665928f,
    0.001086000f,
    0.001220586f,
    0.001372729f,
    0.001543579f,
    0.001734286f,
    0.001946000f,
    0.002177777f,
    0.002435809f,
    0.002731953f,
    0.003078064f,
    0.003486000f,
    0.003975227f,
    0.004540880f,
    0.005158320f,
    0.005802907f,
    0.006450001f,
    0.007083216f,
    0.007745488f,
    0.008501152f,
    0.009414544f,
    0.01054999f,
    0.01196580f,
    0.01365587f,
    0.01558805f,
    0.01773015f,
    0.02005001f,
    0.02251136f,
    0.02520288f,
    0.02827972f,
    0.03189704f,
    0.03621000f,
    0.04143771f,
    0.04750372f,
    0.05411988f,
    0.06099803f,
    0.06785001f,
    0.07448632f,
    0.08136156f,
    0.08915364f,
    0.09854048f,
    0.1102000f,
    0.1246133f,
    0.1417017f,
    0.1613035f,
    0.1832568f,
    0.2074000f,
    0.2336921f,
    0.2626114f,
    0.2947746f,
    0.3307985f,
    0.3713000f,
    0.4162091f,
    0.4654642f,
    0.5196948f,
    0.5795303f,
    0.6456000f,
    0.7184838f,
    0.7967133f,
    0.8778459f,
    0.9594390f,
    1.0390501f,
    1.1153673f,
    1.1884971f,
    1.2581233f,
    1.3239296f,
    1.3856000f,
    1.4426352f,
    1.4948035f,
    1.5421903f,
    1.5848807f,
    1.6229600f,
    1.6564048f,
    1.6852959f,
    1.7098745f,
    1.7303821f,
    1.7470600f,
    1.7600446f,
    1.7696233f,
    1.7762637f,
    1.7804334f,
    1.7826000f,
    1.7829682f,
    1.7816998f,
    1.7791982f,
    1.7758671f,
    1.7721100f,
    1.7682589f,
    1.7640390f,
    1.7589438f,
    1.7524663f,
    1.7441000f,
    1.7335595f,
    1.7208581f,
    1.7059369f,
    1.6887372f,
    1.6692000f,
    1.6475287f,
    1.6234127f,
    1.5960223f,
    1.5645280f,
    1.5281000f,
    1.4861114f,
    1.4395215f,
    1.3898799f,
    1.3387362f,
    1.2876400f,
    1.2374223f,
    1.1878243f,
    1.1387611f,
    1.0901480f,
    1.0419000f,
    0.9941976f,
    0.9473473f,
    0.9014531f,
    0.8566193f,
    0.8129501f,
    0.7705173f,
    0.7294448f,
    0.6899136f,
    0.6521049f,
    0.6162000f,
    0.5823286f,
    0.5504162f,
    0.5203376f,
    0.4919673f,
    0.4651800f,
    0.4399246f,
    0.4161836f,
    0.3938822f,
    0.3729459f,
    0.3533000f,
    0.3348578f,
    0.3175521f,
    0.3013375f,
    0.2861686f,
    0.2720000f,
    0.2588171f,
    0.2464838f,
    0.2347718f,
    0.2234533f,
    0.2123000f,
    0.2011692f,
    0.1901196f,
    0.1792254f,
    0.1685608f,
    0.1582000f,
    0.1481383f,
    0.1383758f,
    0.1289942f,
    0.1200751f,
    0.1117000f,
    0.1039048f,
    0.09666748f,
    0.08998272f,
    0.08384531f,
    0.07824999f,
    0.07320899f,
    0.06867816f,
    0.06456784f,
    0.06078835f,
    0.05725001f,
    0.05390435f,
    0.05074664f,
    0.04775276f,
    0.04489859f,
    0.04216000f,
    0.03950728f,
    0.03693564f,
    0.03445836f,
    0.03208872f,
    0.02984000f,
    0.02771181f,
    0.02569444f,
    0.02378716f,
    0.02198925f,
    0.02030000f,
    0.01871805f,
    0.01724036f,
    0.01586364f,
    0.01458461f,
    0.01340000f,
    0.01230723f,
    0.01130188f,
    0.01037792f,
    0.009529306f,
    0.008749999f,
    0.008035200f,
    0.007381600f,
    0.006785400f,
    0.006242800f,
    0.005749999f,
    0.005303600f,
    0.004899800f,
    0.004534200f,
    0.004202400f,
    0.003900000f,
    0.003623200f,
    0.003370600f,
    0.003141400f,
    0.002934800f,
    0.002749999f,
    0.002585200f,
    0.002438600f,
    0.002309400f,
    0.002196800f,
    0.002100000f,
    0.002017733f,
    0.001948200f,
    0.001889800f,
    0.001840933f,
    0.001800000f,
    0.001766267f,
    0.001737800f,
    0.001711200f,
    0.001683067f,
    0.001650001f,
    0.001610133f,
    0.001564400f,
    0.001513600f,
    0.001458533f,
    0.001400000f,
    0.001336667f,
    0.001270000f,
    0.001205000f,
    0.001146667f,
    0.001100000f,
    0.001068800f,
    0.001049400f,
    0.001035600f,
    0.001021200f,
    0.001000000f,
    0.0009686400f,
    0.0009299200f,
    0.0008868800f,
    0.0008425600f,
    0.0008000000f,
    0.0007609600f,
    0.0007236800f,
    0.0006859200f,
    0.0006454400f,
    0.0006000000f,
    0.0005478667f,
    0.0004916000f,
    0.0004354000f,
    0.0003834667f,
    0.0003400000f,
    0.0003072533f,
    0.0002831600f,
    0.0002654400f,
    0.0002518133f,
    0.0002400000f,
    0.0002295467f,
    0.0002206400f,
    0.0002119600f,
    0.0002021867f,
    0.0001900000f,
    0.0001742133f,
    0.0001556400f,
    0.0001359600f,
    0.0001168533f,
    0.0001000000f,
    0.00008613333f,
    0.00007460000f,
    0.00006500000f,
    0.00005693333f,
    0.00004999999f,
    0.00004416000f,
    0.00003948000f,
    0.00003572000f,
    0.00003264000f,
    0.00003000000f,
    0.00002765333f,
    0.00002556000f,
    0.00002364000f,
    0.00002181333f,
    0.00002000000f,
    0.00001813333f,
    0.00001620000f,
    0.00001420000f,
    0.00001213333f,
    0.00001000000f,
    0.000007733333f,
    0.000005400000f,
    0.000003200000f,
    0.000001333333f,
    0.000000000000f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    0.0f};

const float CIE_lambda[nCIESamples] = {
    360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
    375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389,
    390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
    405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419,
    420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434,
    435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449,
    450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
    465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479,
    480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494,
    495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509,
    510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524,
    525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539,
    540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554,
    555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569,
    570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584,
    585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599,
    600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614,
    615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629,
    630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644,
    645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659,
    660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674,
    675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689,
    690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
    705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719,
    720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734,
    735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749,
    750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764,
    765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779,
    780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794,
    795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809,
    810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824,
    825, 826, 827, 828, 829, 830};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Material/Public/Material/MaterialCompiler.hpp
================================================
#pragma once

#include <Core/Core.hpp>
#include <RHI/RHISampler.hpp>

#include "MaterialGraph.hpp"
#include "MaterialNode.hpp"

namespace Ilum
{
struct MaterialCompilationContext
{
	struct BSDF
	{
		std::string name = "";
		std::string type = "";

		std::string initialization = "";

		template <typename Archive>
		void serialize(Archive &archive)
		{
			archive(name, type, initialization);
		}
	};

	std::vector<std::string> variables;

	std::map<std::string, std::string> textures;

	std::map<std::string, SamplerDesc> samplers;

	std::vector<BSDF> bsdfs;

	struct
	{
		std::string bsdf = "";
	} output;

	std::unordered_set<size_t> finish_nodes;

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(variables, textures, samplers, bsdfs, output.bsdf, finish_nodes);
	}

	void Reset()
	{
		variables.clear();
		textures.clear();
		samplers.clear();
		bsdfs.clear();
		finish_nodes.clear();
	}

	bool IsCompiled(const MaterialNodeDesc &desc)
	{
		if (finish_nodes.find(desc.GetHandle()) == finish_nodes.end())
		{
			finish_nodes.insert(desc.GetHandle());
			return false;
		}
		return true;
	}

	template <typename T>
	inline void SetParameter(const std::string &name, std::map<std::string, std::string> &parameters, T var)
	{
	}

	template <>
	inline void SetParameter(const std::string &name, std::map<std::string, std::string> &parameters, float var)
	{
		parameters[name] = fmt::format("{}", var);
	}

	template <>
	inline void SetParameter(const std::string &name, std::map<std::string, std::string> &parameters, bool var)
	{
		parameters[name] = fmt::format("{}", var);
	}

	template <>
	inline void SetParameter(const std::string &name, std::map<std::string, std::string> &parameters, glm::vec3 var)
	{
		parameters[name] = fmt::format("float3({}, {}, {})", var.x, var.y, var.z);
	}

	template <typename T>
	inline bool HasParameter(std::map<std::string, std::string> &parameters, const MaterialNodePin &node_pin, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context)
	{
		if (graph_desc.HasLink(node_pin.handle))
		{
			auto &src_node = graph_desc.GetNode(graph_desc.LinkFrom(node_pin.handle));
			src_node.EmitHLSL(graph_desc, manager, context);
			auto &src_pin = src_node.GetPin(graph_desc.LinkFrom(node_pin.handle));
			if (src_pin.type != node_pin.type && src_pin.type == MaterialNodePin::Type::Float)
			{
				parameters[node_pin.name] = fmt::format("float3(S_{}, S_{}, S_{})", src_pin.handle, src_pin.handle, src_pin.handle);
			}
			else if (src_pin.type != node_pin.type && node_pin.type == MaterialNodePin::Type::Float)
			{
				parameters[node_pin.name] = fmt::format("S_{}.x", src_pin.handle);
			}
			else
			{
				parameters[node_pin.name] = fmt::format("S_{}", src_pin.handle);
			}
			return true;
		}
		return false;
	}

	template <typename T>
	inline void SetParameter(std::map<std::string, std::string> &parameters, const MaterialNodePin &node_pin, const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context)
	{
		if (!HasParameter<T>(parameters, node_pin, graph_desc, manager, context))
		{
			SetParameter<T>(node_pin.name, parameters, *node_pin.variant.Convert<T>());
		}
	}
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Material/Public/Material/MaterialData.hpp
================================================
#pragma once

#include <RHI/RHIContext.hpp>

namespace Ilum
{
enum class BlendMode
{
	Opaque,
	Mask,
	Blend
};

struct MaterialData
{
	std::vector<uint32_t> textures;
	std::vector<uint32_t> samplers;

	std::string shader    = "Material/Material.hlsli";
	std::string signature = "Signature_0";

	BlendMode blend_mode = BlendMode::Opaque;

	void Reset()
	{
		textures.clear();
		samplers.clear();
		shader    = "Material/Material.hlsli";
		signature = "Signature_0";
	}

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(textures, samplers, shader, signature, blend_mode);
	}
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Material/Public/Material/MaterialGraph.hpp
================================================
#pragma once

#include "MaterialNode.hpp"

namespace Ilum
{
class MaterialGraphDesc
{
  public:
	MaterialGraphDesc() = default;

	~MaterialGraphDesc() = default;

	MaterialGraphDesc &SetName(const std::string &name);

	MaterialNodeDesc &AddNode(size_t handle, MaterialNodeDesc &&desc);

	void EraseNode(size_t handle);

	void EraseLink(size_t source, size_t target);

	MaterialGraphDesc &Link(size_t source, size_t target);

	bool HasLink(size_t target) const;

	size_t LinkFrom(size_t target) const;

	const MaterialNodeDesc &GetNode(size_t handle) const;

	const std::string &GetName() const;

	const std::map<size_t, MaterialNodeDesc> &GetNodes() const;

	const std::map<size_t, size_t> &GetEdges() const;

	void Clear();

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(m_name, m_nodes, m_edges, m_node_lookup);
	}

  private:
	std::string m_name;

	std::map<size_t, MaterialNodeDesc> m_nodes;

	std::map<size_t, size_t> m_edges;        // Target - Source

	std::map<size_t, size_t> m_node_lookup;        // Pin ID - Node ID
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Material/Public/Material/MaterialNode.hpp
================================================
#pragma once

#include <Core/Core.hpp>

namespace Ilum
{
class MaterialGraphDesc;
class Editor;
class ResourceManager;
struct MaterialCompilationContext;

struct MaterialNodePin
{
	enum class Type : uint64_t
	{
		Unknown = 0,
		Bool    = 1,
		Float   = 1 << 2,
		Float3  = 1 << 3,
		RGB     = 1 << 4,
		BSDF    = 1 << 5,
		Media   = 1 << 6,
	};

	enum class Attribute
	{
		Input,
		Output
	};

	Type        type;
	Type        accept;        //	for input pin
	Attribute   attribute;
	std::string name;
	size_t      handle;
	Variant     variant;

	bool enable = true;

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(type, accept, attribute, name, handle, variant, enable);
	}
};

DEFINE_ENUMCLASS_OPERATION(MaterialNodePin::Type)

class MaterialNodeDesc
{
  public:
	MaterialNodeDesc() = default;

	~MaterialNodeDesc() = default;

	MaterialNodeDesc &SetName(const std::string &name);

	MaterialNodeDesc &SetCategory(const std::string &category);

	MaterialNodeDesc &SetHandle(size_t handle);

	MaterialNodeDesc &Input(size_t handle, const std::string &name, MaterialNodePin::Type type, MaterialNodePin::Type accept = MaterialNodePin::Type::Unknown, Variant &&variant = {});

	MaterialNodeDesc &Output(size_t handle, const std::string &name, MaterialNodePin::Type type, Variant &&variant = {});

	const MaterialNodePin &GetPin(size_t handle) const;

	MaterialNodePin &GetPin(size_t handle);

	const MaterialNodePin &GetPin(const std::string &name) const;

	MaterialNodePin &GetPin(const std::string &name);

	MaterialNodeDesc &SetVariant(Variant variant);

	const Variant &GetVariant() const;

	const std::string &GetName() const;

	const std::string &GetCategory() const;

	const std::map<size_t, MaterialNodePin> &GetPins() const;

	size_t GetHandle() const;

	void EmitHLSL(const MaterialGraphDesc &graph_desc, ResourceManager *manager, MaterialCompilationContext *context) const;

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(m_name, m_category, m_handle, m_pins, m_pin_indices, m_variant);
	}

  private:
	std::string m_name;
	std::string m_category;

	size_t m_handle = ~0ull;

	std::map<size_t, MaterialNodePin> m_pins;
	std::map<std::string, size_t>     m_pin_indices;

	Variant m_variant;
};

}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Material/Public/Material/Spectrum.hpp
================================================
#pragma once

#include <Core/Core.hpp>

#include <glm/glm.hpp>

namespace Ilum
{
static const int sampledLambdaStart = 400;
static const int sampledLambdaEnd   = 700;
static const int nSpectralSamples   = 60;

extern void XYZToRGB(const float xyz[3], float rgb[3]);
extern void RGBToXYZ(const float rgb[3], float xyz[3]);

static const int   nCIESamples = 471;
extern const float CIE_X[nCIESamples];
extern const float CIE_Y[nCIESamples];
extern const float CIE_Z[nCIESamples];
extern const float CIE_lambda[nCIESamples];
static const float CIE_Y_integral    = 106.856895f;

extern bool  SpectrumSamplesSorted(const float *lambda, const float *vals, int32_t n);
extern void  SortSpectrumSamples(float *lambda, float *vals, int32_t n);
extern float InterpolateSpectrumSamples(const float *lambda, const float *vals, int32_t n, float l);

glm::vec3 FromSampled(const float *lambda, const float *v, int32_t n);
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/RenderGraph/Private/RenderGraph.cpp
================================================
#include "RenderGraph.hpp"

#include <Core/JobSystem.hpp>

namespace Ilum
{
RenderGraphDesc &RenderGraphDesc::SetName(const std::string &name)
{
	m_name = name;
	return *this;
}

RenderGraphDesc &RenderGraphDesc::AddPass(size_t handle, RenderPassDesc &&desc)
{
	for (auto &[pin_handle, pin] : desc.GetPins())
	{
		m_pass_lookup[pin_handle] = handle;
	}

	m_pass_lookup[handle] = handle;
	m_pass_lookup[handle] = handle;
	m_pass_lookup[handle] = handle;
	desc.SetHandle(handle);
	m_passes.emplace(handle, std::move(desc));
	return *this;
}

void RenderGraphDesc::ErasePass(size_t handle)
{
	auto &desc = m_passes.at(handle);
	auto &pins = desc.GetPins();

	for (auto iter = m_edges.begin(); iter != m_edges.end();)
	{
		if (pins.find(iter->first) != pins.end() ||
		    pins.find(iter->second) != pins.end() ||
		    iter->first == handle ||
		    iter->second == handle)
		{
			iter = m_edges.erase(iter);
		}
		else
		{
			iter++;
		}
	}

	for (auto &[handle, name] : pins)
	{
		m_pass_lookup.erase(handle);
	}

	m_passes.erase(handle);
}

void RenderGraphDesc::EraseLink(size_t source, size_t target)
{
	if (m_edges.find(target) != m_edges.end() &&
	    m_edges.at(target) == source)
	{
		m_edges.erase(target);
	}
}

RenderGraphDesc &RenderGraphDesc::Link(size_t source, size_t target)
{
	const auto &src_node = m_passes.at(m_pass_lookup.at(source));
	const auto &dst_node = m_passes.at(m_pass_lookup.at(target));

	if ((source == src_node.GetHandle()) &&
	    (target == dst_node.GetHandle()))
	{
		// Link Node
		m_edges[target] = source;
	}
	else if ((source != src_node.GetHandle()) &&
	         (target != dst_node.GetHandle()))
	{
		// Link Pin
		const auto &src_pin = src_node.GetPin(source);
		const auto &dst_pin = dst_node.GetPin(target);

		if ((src_pin.type == dst_pin.type) &&
		    src_pin.attribute != dst_pin.attribute)
		{
			m_edges[target] = source;
		}
	}

	return *this;
}

bool RenderGraphDesc::HasLink(size_t target) const
{
	return m_edges.find(target) != m_edges.end();
}

size_t RenderGraphDesc::LinkFrom(size_t target) const
{
	return m_edges.at(target);
}

std::set<size_t> RenderGraphDesc::LinkTo(size_t source) const
{
	std::set<size_t> result;
	for (auto &[dst, src] : m_edges)
	{
		if (src == source)
		{
			result.insert(dst);
		}
	}
	return result;
}

bool RenderGraphDesc::HasPass(size_t handle) const
{
	return m_passes.find(handle) != m_passes.end();
}

RenderPassDesc &RenderGraphDesc::GetPass(size_t handle)
{
	return m_passes.at(m_pass_lookup.at(handle));
}

const std::string &RenderGraphDesc::GetName() const
{
	return m_name;
}

std::map<size_t, RenderPassDesc> &RenderGraphDesc::GetPasses()
{
	return m_passes;
}

const std::map<size_t, size_t> &RenderGraphDesc::GetEdges() const
{
	return m_edges;
}

void RenderGraphDesc::Clear()
{
	m_passes.clear();
	m_edges.clear();
	m_pass_lookup.clear();
}

struct RenderGraph::Impl
{
	RHIContext *rhi_context = nullptr;

	InitializeBarrierTask initialize_barrier;

	std::vector<RenderPassInfo> render_passes;

	std::vector<std::unique_ptr<RHITexture>> textures;
	std::map<size_t, RHITexture *>           texture_lookup;
	std::map<size_t, RHITexture *>           cuda_textures;

	std::vector<std::unique_ptr<RHIBuffer>> buffers;
	std::map<size_t, RHIBuffer *>           buffer_lookup;

	std::map<RHISemaphore *, std::unique_ptr<RHISemaphore>> cuda_semaphore_map;

	bool init = false;
};

RenderGraph::RenderGraph(RHIContext *rhi_context)
{
	m_impl              = new Impl;
	m_impl->rhi_context = rhi_context;
}

RenderGraph::~RenderGraph()
{
	m_impl->rhi_context->Reset();
	m_impl->rhi_context->WaitIdle();

	delete m_impl;
}

std::unique_ptr<RHITexture> RenderGraph::SetTexture(size_t handle, std::unique_ptr<RHITexture> &&texture)
{
	if (texture->GetBackend() == "CUDA")
	{
		if (m_impl->cuda_textures.find(handle) != m_impl->cuda_textures.end())
		{
			size_t idx    = 0;
			auto  *target = m_impl->cuda_textures.at(handle);

			for (auto &it : m_impl->textures)
			{
				if (it.get() == target)
				{
					break;
				}
				idx++;
			}

			for (auto &[handle, tex] : m_impl->cuda_textures)
			{
				if (tex == target)
				{
					tex = texture.get();
				}
			}

			std::unique_ptr<RHITexture> old = std::move(m_impl->textures[idx]);
			m_impl->textures[idx] = std::move(texture);
			return old;
		}
	}
	else
	{
		if (m_impl->texture_lookup.find(handle) != m_impl->texture_lookup.end())
		{
			size_t idx    = 0;
			auto  *target = m_impl->texture_lookup.at(handle);

			for (auto &it : m_impl->textures)
			{
				if (it.get() == target)
				{
					break;
				}
				idx++;
			}

			for (auto &[handle, tex] : m_impl->texture_lookup)
			{
				if (tex == target)
				{
					tex = texture.get();
				}
			}

			std::unique_ptr<RHITexture> old = std::move(m_impl->textures[idx]);
			m_impl->textures[idx]           = std::move(texture);
			return old;
		}
	}

	return nullptr;
}

RHITexture *RenderGraph::GetTexture(size_t handle)
{
	auto iter = m_impl->texture_lookup.find(handle);
	return iter == m_impl->texture_lookup.end() ? nullptr : iter->second;
}

RHIBuffer *RenderGraph::GetBuffer(size_t handle)
{
	auto iter = m_impl->buffer_lookup.find(handle);
	return iter == m_impl->buffer_lookup.end() ? nullptr : iter->second;
}

RHITexture *RenderGraph::GetCUDATexture(size_t handle)
{
	if (m_impl->cuda_textures.find(handle) == m_impl->cuda_textures.end())
	{
		m_impl->textures.emplace_back(m_impl->rhi_context->MapToCUDATexture(m_impl->texture_lookup.at(handle)));
		m_impl->cuda_textures.emplace(handle, m_impl->textures.back().get());
	}
	return m_impl->cuda_textures.at(handle);
}

void RenderGraph::Execute(RenderGraphBlackboard &black_board)
{
	if (m_impl->render_passes.empty())
	{
		return;
	}

	if (!m_impl->init)
	{
		auto *graphics_cmd_buffer = m_impl->rhi_context->CreateCommand(RHIQueueFamily::Graphics);
		auto *compute_cmd_buffer  = m_impl->rhi_context->CreateCommand(RHIQueueFamily::Compute);
		graphics_cmd_buffer->Begin();
		compute_cmd_buffer->Begin();
		graphics_cmd_buffer->BeginMarker("Initialize - Graphics Queue");
		compute_cmd_buffer->BeginMarker("Initialize - Compute Queue");
		m_impl->initialize_barrier(*this, graphics_cmd_buffer, compute_cmd_buffer);
		m_impl->init = true;
		graphics_cmd_buffer->EndMarker();
		compute_cmd_buffer->EndMarker();
		graphics_cmd_buffer->End();
		compute_cmd_buffer->End();
		m_impl->rhi_context->Execute({graphics_cmd_buffer});
		m_impl->rhi_context->Execute({compute_cmd_buffer});
	}

	// Collect cmd buffers
	/*std::vector<std::future<RHICommand *>> cmd_buffer_futures;
	for (auto &pass : m_impl->render_passes)
	{
	    auto future = JobSystem::GetInstance().ExecuteAsync([&]() {
	        if (pass.bind_point == BindPoint::CUDA)
	        {
	            auto *cmd_buffer = m_impl->rhi_context->CreateCommand(RHIQueueFamily::Compute, true);
	            cmd_buffer->Begin();
	            pass.profiler->Begin(cmd_buffer, m_impl->rhi_context->GetSwapchain()->GetCurrentFrameIndex());
	            pass.execute(*this, cmd_buffer, pass.config, black_board);
	            pass.profiler->End(cmd_buffer);
	            cmd_buffer->End();
	            return cmd_buffer;
	        }
	        else
	        {
	            RHIQueueFamily family = RHIQueueFamily::Graphics;
	            if (pass.bind_point == BindPoint::Rasterization)
	            {
	                family = RHIQueueFamily::Graphics;
	            }
	            else
	            {
	                family = RHIQueueFamily::Compute;
	            }

	            auto *cmd_buffer = m_impl->rhi_context->CreateCommand(family);
	            cmd_buffer->SetName(pass.name);
	            cmd_buffer->Begin();
	            cmd_buffer->BeginMarker(pass.name);
	            pass.profiler->Begin(cmd_buffer, m_impl->rhi_context->GetSwapchain()->GetCurrentFrameIndex());
	            pass.barrier(*this, cmd_buffer);
	            pass.execute(*this, cmd_buffer, pass.config, black_board);
	            pass.profiler->End(cmd_buffer);
	            cmd_buffer->EndMarker();
	            cmd_buffer->End();
	            return cmd_buffer;
	        }
	    });
	    cmd_buffer_futures.emplace_back(std::move(future));
	}

	if (!cmd_buffer_futures.empty())
	{
	    std::vector<RHICommand *> cmd_buffers(cmd_buffer_futures.size());
	    std::transform(cmd_buffer_futures.begin(), cmd_buffer_futures.end(), cmd_buffers.begin(), [](std::future<RHICommand *> &iter) { return iter.get(); });

	    RHIQueueFamily            last_queue_family = cmd_buffers[0]->GetQueueFamily();
	    std::string               last_backend      = cmd_buffers[0]->GetBackend();
	    RHISemaphore             *last_semaphore    = nullptr;
	    std::vector<RHICommand *> submit_cmd_buffers;
	    for (auto &cmd_buffer : cmd_buffers)
	    {
	        if (last_queue_family != cmd_buffer->GetQueueFamily() ||
	            cmd_buffer->GetBackend() != last_backend &&
	                !submit_cmd_buffers.empty())
	        {
	            RHISemaphore *pass_semaphore   = m_impl->rhi_context->CreateFrameSemaphore();
	            RHISemaphore *signal_semaphore = last_backend == "CUDA" ? MapToCUDASemaphore(pass_semaphore) : pass_semaphore;
	            RHISemaphore *wait_semaphore   = last_semaphore ? last_backend == "CUDA" ? MapToCUDASemaphore(last_semaphore) : last_semaphore : nullptr;

	            m_impl->rhi_context->Submit(std::move(submit_cmd_buffers), wait_semaphore ? std::vector<RHISemaphore *>{wait_semaphore} : std::vector<RHISemaphore *>{}, {signal_semaphore});
	            submit_cmd_buffers.clear();
	            last_semaphore    = pass_semaphore;
	            last_queue_family = cmd_buffer->GetQueueFamily();
	        }

	        submit_cmd_buffers.push_back(cmd_buffer);
	    }
	    if (!submit_cmd_buffers.empty())
	    {
	        m_impl->rhi_context->Submit(std::move(submit_cmd_buffers), last_semaphore ? std::vector<RHISemaphore *>{last_semaphore} : std::vector<RHISemaphore *>{}, {});
	    }
	}*/

	std::vector<RHICommand *> cmd_buffers;
	for (auto &pass : m_impl->render_passes)
	{
		if (pass.bind_point == BindPoint::CUDA)
		{
			auto *cmd_buffer = m_impl->rhi_context->CreateCommand(RHIQueueFamily::Compute, true);
			cmd_buffer->Begin();
			pass.profiler->Begin(cmd_buffer, m_impl->rhi_context->GetSwapchain()->GetCurrentFrameIndex());
			pass.execute(*this, cmd_buffer, pass.config, black_board);
			pass.profiler->End(cmd_buffer);
			cmd_buffer->End();
			cmd_buffers.emplace_back(cmd_buffer);
		}
		else
		{
			RHIQueueFamily family = RHIQueueFamily::Graphics;
			if (pass.bind_point == BindPoint::Rasterization)
			{
				family = RHIQueueFamily::Graphics;
			}
			else
			{
				family = RHIQueueFamily::Compute;
			}

			auto *cmd_buffer = m_impl->rhi_context->CreateCommand(family);
			cmd_buffer->SetName(pass.name);
			cmd_buffer->Begin();
			cmd_buffer->BeginMarker(pass.name);
			pass.profiler->Begin(cmd_buffer, m_impl->rhi_context->GetSwapchain()->GetCurrentFrameIndex());
			pass.barrier(*this, cmd_buffer);
			pass.execute(*this, cmd_buffer, pass.config, black_board);
			pass.profiler->End(cmd_buffer);
			cmd_buffer->EndMarker();
			cmd_buffer->End();
			cmd_buffers.emplace_back(cmd_buffer);
		}
	}

	if (!cmd_buffers.empty())
	{
		RHIQueueFamily            last_queue_family = cmd_buffers[0]->GetQueueFamily();
		std::string               last_backend      = cmd_buffers[0]->GetBackend();
		RHISemaphore             *last_semaphore    = nullptr;
		std::vector<RHICommand *> submit_cmd_buffers;
		for (auto &cmd_buffer : cmd_buffers)
		{
			if (last_queue_family != cmd_buffer->GetQueueFamily() ||
			    cmd_buffer->GetBackend() != last_backend &&
			        !submit_cmd_buffers.empty())
			{
				RHISemaphore *pass_semaphore   = m_impl->rhi_context->CreateFrameSemaphore();
				RHISemaphore *signal_semaphore = last_backend == "CUDA" ? MapToCUDASemaphore(pass_semaphore) : pass_semaphore;
				RHISemaphore *wait_semaphore   = last_semaphore ? last_backend == "CUDA" ? MapToCUDASemaphore(last_semaphore) : last_semaphore : nullptr;

				m_impl->rhi_context->Submit(std::move(submit_cmd_buffers), wait_semaphore ? std::vector<RHISemaphore *>{wait_semaphore} : std::vector<RHISemaphore *>{}, {signal_semaphore});
				submit_cmd_buffers.clear();
				last_semaphore    = pass_semaphore;
				last_queue_family = cmd_buffer->GetQueueFamily();
			}

			submit_cmd_buffers.push_back(cmd_buffer);
		}
		if (!submit_cmd_buffers.empty())
		{
			m_impl->rhi_context->Submit(std::move(submit_cmd_buffers), last_semaphore ? std::vector<RHISemaphore *>{last_semaphore} : std::vector<RHISemaphore *>{}, {});
		}
	}
}

const std::vector<RenderGraph::RenderPassInfo> &RenderGraph::GetRenderPasses() const
{
	return m_impl->render_passes;
}

RenderGraph &RenderGraph::AddPass(
    const std::string &name,
    const std::string &category,
    BindPoint          bind_point,
    const Variant     &config,
    RenderTask       &&task,
    BarrierTask      &&barrier)
{
	m_impl->render_passes.emplace_back(RenderPassInfo{
	    name,
	    category,
	    bind_point,
	    config,
	    std::move(task),
	    std::move(barrier),
	    m_impl->rhi_context->CreateProfiler(bind_point == BindPoint::CUDA)});
	return *this;
}

RenderGraph &RenderGraph::AddInitializeBarrier(InitializeBarrierTask &&barrier)
{
	m_impl->initialize_barrier = std::move(barrier);
	return *this;
}

RenderGraph &RenderGraph::RegisterTexture(const TextureCreateInfo &create_info)
{
	TextureDesc desc    = create_info.desc;
	auto       &texture = m_impl->textures.emplace_back(m_impl->rhi_context->CreateTexture(desc));
	for (auto &handle : create_info.handles)
	{
		m_impl->texture_lookup.emplace(handle, texture.get());
	}
	return *this;
}

RenderGraph &RenderGraph::RegisterTexture(const std::vector<TextureCreateInfo> &create_infos)
{
	if (create_infos.size() == 1)
	{
		return RegisterTexture(create_infos[0]);
	}

	TextureDesc pool_desc = {};
	pool_desc.name        = "Pool Texture " + std::to_string(m_impl->textures.size());
	pool_desc.width       = 0;
	pool_desc.width       = 0;
	pool_desc.height      = 0;
	pool_desc.depth       = 0;
	pool_desc.mips        = 0;
	pool_desc.layers      = 0;
	pool_desc.samples     = 0;
	pool_desc.format      = (RHIFormat) 0;
	pool_desc.usage       = RHITextureUsage::Transfer | RHITextureUsage::ShaderResource;

	// Memory alias
	for (auto &info : create_infos)
	{
		pool_desc.width   = std::max(pool_desc.width, info.desc.width);
		pool_desc.height  = std::max(pool_desc.height, info.desc.height);
		pool_desc.depth   = std::max(pool_desc.depth, info.desc.depth);
		pool_desc.mips    = std::max(pool_desc.mips, info.desc.mips);
		pool_desc.layers  = std::max(pool_desc.layers, info.desc.layers);
		pool_desc.samples = std::max(pool_desc.samples, info.desc.samples);
		pool_desc.format  = (RHIFormat) std::max((uint64_t) pool_desc.format, (uint64_t) info.desc.format);
	}

	//m_impl->textures.emplace_back(m_impl->rhi_context->CreateTexture(pool_desc));
	//auto pool_texture = m_impl->textures.back().get();

	for (auto &info : create_infos)
	{
		TextureDesc desc = info.desc;
		desc.usage |= RHITextureUsage::ShaderResource | RHITextureUsage::Transfer;
		auto &texture = m_impl->textures.emplace_back(m_impl->rhi_context->CreateTexture(desc));
		//auto &texture = m_impl->textures.emplace_back(pool_texture->Alias(desc));
		for (auto &handle : info.handles)
		{
			m_impl->texture_lookup.emplace(handle, texture.get());
		}
	}

	return *this;
}

RenderGraph &RenderGraph::RegisterBuffer(const BufferCreateInfo &create_info)
{
	BufferDesc desc = create_info.desc;
	desc.usage      = desc.usage | RHIBufferUsage::Transfer | RHIBufferUsage::ConstantBuffer;
	auto &buffer    = m_impl->buffers.emplace_back(m_impl->rhi_context->CreateBuffer(desc));
	for (auto &handle : create_info.handles)
	{
		m_impl->buffer_lookup.emplace(handle, buffer.get());
	}
	return *this;
}

RHISemaphore *RenderGraph::MapToCUDASemaphore(RHISemaphore *semaphore)
{
	if (m_impl->cuda_semaphore_map.find(semaphore) != m_impl->cuda_semaphore_map.end())
	{
		return m_impl->cuda_semaphore_map.at(semaphore).get();
	}
	m_impl->cuda_semaphore_map.emplace(semaphore, m_impl->rhi_context->MapToCUDASemaphore(semaphore));
	return m_impl->cuda_semaphore_map.at(semaphore).get();
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/RenderGraph/Private/RenderGraphBlackboard.cpp
================================================
#include "RenderGraphBlackboard.hpp"

namespace Ilum
{
std::shared_ptr<void> &RenderGraphBlackboard::Add(std::type_index type, std::shared_ptr<void> &&ptr)
{
	{
		std::lock_guard<std::mutex> lock(m_mutex);

		if (m_data.find(type) == m_data.end())
		{
			m_data.emplace(type, std::move(ptr));
		}
	}

	return m_data.at(type);
}

bool RenderGraphBlackboard::Has(std::type_index type)
{
	return m_data.find(type) != m_data.end();
}

std::shared_ptr<void>& RenderGraphBlackboard::Get(std::type_index type)
{
	return m_data.at(type);
}

RenderGraphBlackboard &RenderGraphBlackboard::Erase(std::type_index type)
{
	if (Has(type))
	{
		m_data.erase(type);
	}
	return *this;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/RenderGraph/Private/RenderGraphBuilder.cpp
================================================
#include "RenderGraph/RenderGraphBuilder.hpp"

namespace Ilum
{
RenderGraphBuilder::RenderGraphBuilder(RHIContext *rhi_context) :
    p_rhi_context(rhi_context)
{
}

RenderGraphBuilder &RenderGraphBuilder::AddPass(RenderGraph &render_graph, const std::string &name, const std::string &category, BindPoint bind_point, const Variant &config, RenderGraph::RenderTask &&task, RenderGraph::BarrierTask &&barrier)
{
	render_graph.AddPass(name, category, bind_point, config, std::move(task), std::move(barrier));
	return *this;
}

bool RenderGraphBuilder::Validate(RenderGraphDesc &desc)
{
	bool result = true;

	std::set<size_t> used_pass;
	for (auto &[handle, pass] : desc.GetPasses())
	{
		if (desc.HasLink(handle))
		{
			used_pass.insert(handle);
			used_pass.insert(desc.GetPass(desc.LinkFrom(handle)).GetHandle());
		}
	}

	std::unordered_set<size_t> culling_passes;
	for (auto &[handle, pass] : desc.GetPasses())
	{
		if (used_pass.find(handle) == used_pass.end())
		{
			LOG_WARN("Pass <{}> is not used, culling it", pass.GetName());
			culling_passes.insert(handle);
		}
	}

	for (auto &pass : culling_passes)
	{
		desc.ErasePass(pass);
	}

	std::unordered_set<size_t> invalid_resources;
	for (auto &[pass_handle, pass] : desc.GetPasses())
	{
		for (auto &[pin_handle, pin] : pass.GetPins())
		{
			if (pin.attribute == RenderPassPin::Attribute::Input &&
			    !desc.HasLink(pin_handle))
			{
				invalid_resources.insert(pin_handle);
			}
		}
	}

	for (auto &resource : invalid_resources)
	{
		LOG_WARN("Input {} is not linked to a source", resource);
		result = false;
	}

	return result;
}

std::unique_ptr<RenderGraph> RenderGraphBuilder::Compile(RenderGraphDesc &desc, Renderer *renderer)
{
	// if (!Validate(desc))
	//{
	//	LOG_ERROR("Render graph compilation failed!");
	//	return nullptr;
	// }

	const std::unordered_map<BindPoint, RHIQueueFamily> queue_family_map = {
	    {BindPoint::None, RHIQueueFamily::Graphics},
	    {BindPoint::Rasterization, RHIQueueFamily::Graphics},
	    {BindPoint::RayTracing, RHIQueueFamily::Compute},
	    {BindPoint::Compute, RHIQueueFamily::Compute},
	    {BindPoint::CUDA, RHIQueueFamily::Compute},
	};

	struct ResourceState
	{
		RHIResourceState rhi_state;
		RHIQueueFamily   family;

		bool operator==(const ResourceState &lhs)
		{
			return this->rhi_state == lhs.rhi_state && this->family == lhs.family;
		}
	};

	// Sorting passes
	std::vector<size_t> ordered_passes;
	ordered_passes.reserve(desc.GetPasses().size());

	std::vector<size_t> pass_handles;

	std::map<size_t, std::map<uint32_t, ResourceState>> resource_lifetime;

	std::map<size_t, ResourceState> last_resource_state;

	for (auto &[pass_handle, pass] : desc.GetPasses())
	{
		pass_handles.push_back(pass_handle);
		for (auto &[pin_handle, pin] : pass.GetPins())
		{
			if (pin.attribute == RenderPassPin::Attribute::Output)
			{
				last_resource_state[pin_handle] = ResourceState{RHIResourceState::Undefined, queue_family_map.at(pass.GetBindPoint())};
			}
		}
	}

	std::vector<std::map<size_t, std::pair<ResourceState, ResourceState>>> resource_states;

	struct PassSemaphore
	{
		std::vector<RHISemaphore *> wait_semaphores;
		std::vector<RHISemaphore *> signal_semaphores;
	};

	std::map<size_t, PassSemaphore> pass_semaphores;        // [signal - wait]

	RenderGraphDesc tmp_desc = desc;

	std::set<size_t> collected_passes;

	// Create new render graph
	std::unique_ptr<RenderGraph> render_graph = std::make_unique<RenderGraph>(p_rhi_context);

	while (!pass_handles.empty())
	{
		uint32_t pass_idx = static_cast<uint32_t>(ordered_passes.size());

		for (auto iter = pass_handles.begin(); iter != pass_handles.end();)
		{
			auto &pass = desc.GetPass(*iter);

			if (!desc.HasLink(pass.GetHandle()) ||
			    collected_passes.find(desc.LinkFrom(pass.GetHandle())) != collected_passes.end())
			{
				std::map<size_t, std::pair<ResourceState, ResourceState>> pass_resource_state;

				for (auto &[pin_handle, pin] : pass.GetPins())
				{
					size_t resource_pin = (pin.attribute == RenderPassPin::Attribute::Output) ? pin_handle : (desc.HasLink(pin_handle) ? desc.LinkFrom(pin_handle) : ~0ull);
					if (resource_pin == ~0ull)
					{
						continue;
					}

					ResourceState resource_state = ResourceState{pin.resource_state, queue_family_map.at(pass.GetBindPoint())};

					// Record resource state
					if (pass.GetBindPoint() != BindPoint::CUDA)
					{
						pass_resource_state[resource_pin]         = std::make_pair(last_resource_state[resource_pin], resource_state);
						last_resource_state[resource_pin]         = resource_state;
						resource_lifetime[resource_pin][pass_idx] = resource_state;
					}
					else
					{
						ResourceState state = last_resource_state.find(resource_pin) != last_resource_state.end() ? last_resource_state[resource_pin] : ResourceState{RHIResourceState::Undefined, RHIQueueFamily::Graphics};

						resource_lifetime[resource_pin][pass_idx] = state;
						pass_resource_state[resource_pin]         = std::make_pair(state, state);
					}

					// Set resource info
					auto &resource = desc.GetPass(resource_pin).GetPin(resource_pin);
					if (resource.type == RenderPassPin::Type::Texture)
					{
						resource.texture.usage |= ResourceStateToTextureUsage(resource_state.rhi_state) | RHITextureUsage::Transfer;
					}
					else
					{
						resource.buffer.usage |= ResourceStateToBufferUsage(resource_state.rhi_state) | RHIBufferUsage::Transfer;
					}
				}

				// Add pass
				resource_states.push_back(pass_resource_state);
				ordered_passes.push_back(pass.GetHandle());
				collected_passes.insert(pass.GetHandle());
				pass_handles.erase(iter);
				break;
			}
			else
			{
				iter++;
			}
		}
	}

	std::set<size_t> alias_textures;

	// Register resource
	{
		// Collect texture alias info
		struct TexturePool
		{
			std::vector<size_t> handles;

			uint32_t start;
			uint32_t end;
		};

		std::vector<TexturePool> texture_pools;

		for (auto &[handle, resource_states] : resource_lifetime)
		{
			const auto &resource = desc.GetPass(handle).GetPin(handle);
			if (resource.type == RenderPassPin::Type::Texture)
			{
				bool alias = false;
				for (auto &pool : texture_pools)
				{
					if (pool.start > (--resource_states.end())->first ||
					    pool.end < resource_states.begin()->first)
					{
						pool.handles.push_back(handle);
						pool.start = std::min(pool.start, (--resource_states.end())->first);
						pool.end   = std::max(pool.end, resource_states.begin()->first);
						alias      = true;
						break;
					}
				}
				if (!alias)
				{
					texture_pools.push_back(TexturePool{{handle}, resource_states.begin()->first, (--resource_states.end())->first});
				}
			}
			else
			{
				std::set<size_t> handles = desc.LinkTo(handle);
				handles.insert(handle);
				render_graph->RegisterBuffer(RenderGraph::BufferCreateInfo{resource.buffer, handles});
			}
		}

		for (auto &pool : texture_pools)
		{
			std::vector<RenderGraph::TextureCreateInfo> texture_create_infos;
			texture_create_infos.reserve(pool.handles.size());
			for (auto &handle : pool.handles)
			{
				const auto      &resource = desc.GetPass(handle).GetPin(handle);
				std::set<size_t> handles  = desc.LinkTo(handle);
				handles.insert(handle);
				texture_create_infos.push_back(RenderGraph::TextureCreateInfo{resource.texture, handles});
				if (pool.handles.size() > 1)
				{
					alias_textures.insert(handle);
				}
			}
			render_graph->RegisterTexture(texture_create_infos);
		}
	}

	// Resource state tracking
	for (auto &resource_state : resource_states)
	{
		for (auto &[resource_handle, state_transition] : resource_state)
		{
			auto &[src, dst] = state_transition;
			if (src.rhi_state == RHIResourceState::Undefined)
			{
				if (alias_textures.find(resource_handle) == alias_textures.end())
				{
					src = (--resource_lifetime[resource_handle].end())->second;
				}
			}
		}
	}

	// Initialize Barrier
	{
		std::vector<BufferStateTransition>  buffer_state_transitions;
		std::vector<TextureStateTransition> texture_state_transitions;

		for (auto &[handle, resource_states] : resource_lifetime)
		{
			const auto &resource = desc.GetPass(handle).GetPin(handle);
			if ((--resource_states.end())->second.rhi_state != RHIResourceState::Undefined)
			{
				if (resource.type == RenderPassPin::Type::Texture)
				{
					auto *texture = render_graph->GetTexture(handle);

					const auto &texture_desc = texture->GetDesc();

					texture_state_transitions.push_back(TextureStateTransition{
					    texture,
					    RHIResourceState::Undefined,
					    (--resource_states.end())->second.rhi_state,
					    TextureRange{
					        GetTextureDimension(texture_desc.width, texture_desc.height, texture_desc.depth, texture_desc.layers),
					        0,
					        texture_desc.mips,
					        0,
					        texture_desc.layers},
					    (--resource_states.end())->second.family,
					    (--resource_states.end())->second.family});
				}
				else
				{
					auto *buffer = render_graph->GetBuffer(handle);

					const auto &buffer_desc = buffer->GetDesc();

					buffer_state_transitions.push_back(BufferStateTransition{
					    buffer,
					    RHIResourceState::Undefined,
					    (--resource_states.end())->second.rhi_state});
				}
			}
		}

		render_graph->AddInitializeBarrier([=](RenderGraph &render_graph, RHICommand *graphics_cmd_buffer, RHICommand *compute_cmd_buffer) {
			std::vector<TextureStateTransition> graphics_texture_transitions;
			std::vector<TextureStateTransition> compute_texture_transitions;
			for (auto &transition : texture_state_transitions)
			{
				if (transition.dst_family == RHIQueueFamily::Compute)
				{
					compute_texture_transitions.push_back(transition);
				}
				else
				{
					graphics_texture_transitions.push_back(transition);
				}
			}
			graphics_cmd_buffer->ResourceStateTransition(graphics_texture_transitions, buffer_state_transitions);
			compute_cmd_buffer->ResourceStateTransition(compute_texture_transitions, {});
		});
	}

	struct ResourceStateTransitionInfo
	{
		size_t           handle;
		RHIResourceState src_state;
		RHIResourceState dst_state;
	};

	for (uint32_t i = 0; i < ordered_passes.size(); i++)
	{
		const auto &pass = desc.GetPass(ordered_passes[i]);

		std::vector<ResourceStateTransitionInfo> buffer_state_transition_infos;
		std::vector<ResourceStateTransitionInfo> texture_state_transition_infos;

		for (auto &[handle, resource_transition] : resource_states[i])
		{
			const auto &resource = desc.GetPass(handle).GetPin(handle);

			if (resource_transition.first == resource_transition.second)
			{
				continue;
			}

			if (resource.type == RenderPassPin::Type::Texture)
			{
				texture_state_transition_infos.push_back(ResourceStateTransitionInfo{
				    handle,
				    resource_transition.first.rhi_state,
				    resource_transition.second.rhi_state});

				/*texture_state_transitions.push_back(TextureStateTransition{
				    texture,
				    resource_transition.first.rhi_state,
				    resource_transition.second.rhi_state,
				    TextureRange{
				        GetTextureDimension(texture_desc.width, texture_desc.height, texture_desc.depth, texture_desc.layers),
				        0,
				        texture_desc.mips,
				        0,
				        texture_desc.layers},
				    i == 0 ? resource_transition.second.family : resource_transition.first.family,
				    resource_transition.second.family});*/
			}
			else
			{
				buffer_state_transition_infos.push_back(ResourceStateTransitionInfo{
				    handle,
				    resource_transition.first.rhi_state,
				    resource_transition.second.rhi_state});

				// buffer_state_transitions.push_back(BufferStateTransition{
				//     buffer,
				//     resource_transition.first.rhi_state,
				//     resource_transition.second.rhi_state});
			}
		}

		RenderGraph::RenderTask render_task;

		PluginManager::GetInstance().Call(fmt::format("shared/RenderPass/RenderPass.{}.{}.dll", pass.GetCategory(), pass.GetName()), "CreateCallback", &render_task, pass, *this, renderer);

		render_graph->AddPass(
		    pass.GetName(),
		    pass.GetCategory(),
		    pass.GetBindPoint(),
		    pass.GetConfig(),
		    std::move(render_task),
		    [=](RenderGraph &render_graph, RHICommand *cmd_buffer) {
			    std::vector<BufferStateTransition>  buffer_state_transitions(buffer_state_transition_infos.size());
			    std::vector<TextureStateTransition> texture_state_transitions(texture_state_transition_infos.size());

			    std::transform(
			        texture_state_transition_infos.begin(),
			        texture_state_transition_infos.end(),
			        texture_state_transitions.begin(),
			        [&](const ResourceStateTransitionInfo &info) {
				        auto       *texture = render_graph.GetTexture(info.handle);
				        const auto &desc    = texture->GetDesc();
				        return TextureStateTransition{
				            texture,
				            info.src_state,
				            info.dst_state,
				            TextureRange{
				                GetTextureDimension(desc.width, desc.height, desc.depth, desc.layers),
				                0,
				                desc.mips,
				                0,
				                desc.layers}};
			        });

			    std::transform(
			        buffer_state_transition_infos.begin(),
			        buffer_state_transition_infos.end(),
			        buffer_state_transitions.begin(),
			        [&](const ResourceStateTransitionInfo &info) {
				        auto       *buffer = render_graph.GetBuffer(info.handle);
				        const auto &desc   = buffer->GetDesc();
				        return BufferStateTransition{
				            buffer,
				            info.src_state,
				            info.dst_state};
			        });

			    cmd_buffer->ResourceStateTransition(texture_state_transitions, buffer_state_transitions);
		    });
	}

	return render_graph;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/RenderGraph/Private/RenderPass.cpp
================================================
#include "RenderPass.hpp"

namespace Ilum
{
RenderPassDesc &RenderPassDesc::SetName(const std::string &name)
{
	m_name = name;
	return *this;
}

RenderPassDesc &RenderPassDesc::SetCategory(const std::string &category)
{
	m_category = category;
	return *this;
}

RenderPassDesc &RenderPassDesc::SetHandle(size_t handle)
{
	m_handle = handle;
	return *this;
}

RenderPassDesc &RenderPassDesc::WriteTexture2D(size_t handle, const std::string &name, RHIFormat format, RHIResourceState resource_state, uint32_t width, uint32_t height, uint32_t layer, uint32_t mips)
{
	RenderPassPin pin;
	pin.type           = RenderPassPin::Type::Texture;
	pin.attribute      = RenderPassPin::Attribute::Output;
	pin.name           = name;
	pin.handle         = handle;
	pin.texture        = TextureDesc{name, width, height, 1, mips, layer, 1, format, RHITextureUsage::Undefined};
	pin.resource_state = resource_state;

	m_pins.emplace(handle, pin);
	m_pin_indices.emplace(name, handle);
	return *this;
}

RenderPassDesc &RenderPassDesc::ReadTexture2D(size_t handle, const std::string &name, RHIResourceState resource_state)
{
	RenderPassPin pin;
	pin.type           = RenderPassPin::Type::Texture;
	pin.attribute      = RenderPassPin::Attribute::Input;
	pin.name           = name;
	pin.handle         = handle;
	pin.texture        = TextureDesc{name, 1, 1, 1, 1, 1, 1, RHIFormat::Undefined, RHITextureUsage::Undefined};
	pin.resource_state = resource_state;

	m_pins.emplace(handle, pin);
	m_pin_indices.emplace(name, handle);
	return *this;
}

RenderPassDesc &RenderPassDesc::WriteBuffer(size_t handle, const std::string &name, size_t size, RHIResourceState resource_state)
{
	RenderPassPin pin;
	pin.type           = RenderPassPin::Type::Buffer;
	pin.attribute      = RenderPassPin::Attribute::Output;
	pin.name           = name;
	pin.handle         = handle;
	pin.buffer         = BufferDesc{name, RHIBufferUsage::UnorderedAccess | RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::GPU_Only, size, 0, 0};
	pin.resource_state = resource_state;

	m_pins.emplace(handle, pin);
	m_pin_indices.emplace(name, handle);
	return *this;
}

RenderPassDesc &RenderPassDesc::ReadBuffer(size_t handle, const std::string &name, RHIResourceState resource_state)
{
	RenderPassPin pin;
	pin.type           = RenderPassPin::Type::Buffer;
	pin.attribute      = RenderPassPin::Attribute::Input;
	pin.name           = name;
	pin.handle         = handle;
	pin.buffer         = BufferDesc{name, RHIBufferUsage::UnorderedAccess | RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::GPU_Only, 0, 0, 0};
	pin.resource_state = resource_state;

	m_pins.emplace(handle, pin);
	m_pin_indices.emplace(name, handle);
	return *this;
}

const RenderPassPin &RenderPassDesc::GetPin(size_t handle) const
{
	return m_pins.at(handle);
}

RenderPassPin &RenderPassDesc::GetPin(size_t handle)
{
	return m_pins.at(handle);
}

RenderPassPin &RenderPassDesc::GetPin(const std::string &name)
{
	return m_pins.at(m_pin_indices.at(name));
}

const RenderPassPin &RenderPassDesc::GetPin(const std::string &name) const
{
	return m_pins.at(m_pin_indices.at(name));
}

RenderPassDesc &RenderPassDesc::SetConfig(Variant config)
{
	m_config = config;
	return *this;
}

const Variant &RenderPassDesc::GetConfig() const
{
	return m_config;
}

const std::string &RenderPassDesc::GetName() const
{
	return m_name;
}

const std::string &RenderPassDesc::GetCategory() const
{
	return m_category;
}

std::map<size_t, RenderPassPin> &RenderPassDesc::GetPins()
{
	return m_pins;
}

size_t RenderPassDesc::GetHandle() const
{
	return m_handle;
}

BindPoint RenderPassDesc::GetBindPoint() const
{
	return m_bind_point;
}

RenderPassDesc &RenderPassDesc::SetBindPoint(BindPoint bind_point)
{
	m_bind_point = bind_point;
	return *this;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/RenderGraph/Public/RenderGraph/Impl/RenderGraphBuilder.inl
================================================
//#pragma once
//
//#include "../RenderGraphBuilder.hpp"
//
//#include <Core/Plugin.hpp>
//
//#include <set>
//
//namespace Ilum
//{
//template <typename... Args>
//std::unique_ptr<RenderGraph> RenderGraphBuilder::Compile(RenderGraphDesc &desc, Args &&...args)
//{
//	if (!Validate(desc))
//	{
//		LOG_ERROR("Render graph compilation failed!");
//		return nullptr;
//	}
//
//	// Sorting passes
//	std::vector<RenderPassDesc> ordered_passes;
//	ordered_passes.reserve(desc.passes.size());
//
//	std::vector<RGHandle> pass_handles;
//
//	std::map<RGHandle, std::map<uint32_t, RHIResourceState>> resource_lifetime;
//	std::map<RGHandle, RHIResourceState>                     last_resource_state;
//	for (auto &[texture_handle, texture_desc] : desc.textures)
//	{
//		last_resource_state[texture_handle] = RHIResourceState::Undefined;
//	}
//	for (auto &[buffer_handle, buffer_desc] : desc.buffers)
//	{
//		last_resource_state[buffer_handle] = RHIResourceState::Undefined;
//	}
//
//	std::vector<std::map<RGHandle, std::pair<RHIResourceState, RHIResourceState>>> resource_states;
//
//	struct PassSemaphore
//	{
//		std::vector<RHISemaphore *> wait_semaphores;
//		std::vector<RHISemaphore *> signal_semaphores;
//	};
//
//	std::map<RGHandle, PassSemaphore> pass_semaphores;        // [signal - wait]
//
//	RenderGraphDesc tmp_desc = desc;
//
//	std::set<RGHandle> collected_passes;
//
//	// Create new render graph
//	std::unique_ptr<RenderGraph> render_graph = std::make_unique<RenderGraph>(p_rhi_context);
//
//	while (!tmp_desc.passes.empty())
//	{
//		uint32_t pass_idx = static_cast<uint32_t>(ordered_passes.size());
//
//		for (auto iter = tmp_desc.passes.begin(); iter != tmp_desc.passes.end();)
//		{
//			if (!iter->second.prev_pass.IsValid() || collected_passes.find(iter->second.prev_pass) != collected_passes.end())
//			{
//				// Select pass
//				std::map<RGHandle, std::pair<RHIResourceState, RHIResourceState>> pass_resource_state;
//				for (auto &[name, resource] : iter->second.resources)
//				{
//					if (resource.handle.IsValid())
//					{
//						// Record resource state
//						if (iter->second.bind_point != BindPoint::CUDA)
//						{
//							last_resource_state[resource.handle]         = resource.state;
//							resource_lifetime[resource.handle][pass_idx] = resource.state;
//							pass_resource_state[resource.handle]         = std::make_pair(last_resource_state[resource.handle], resource.state);
//						}
//						else
//						{
//							RHIResourceState state = last_resource_state.find(resource.handle) != last_resource_state.end() ? last_resource_state[resource.handle] : RHIResourceState::Undefined;
//
//							resource_lifetime[resource.handle][pass_idx] = state;
//							pass_resource_state[resource.handle]         = std::make_pair(state, state);
//						}
//
//						// Set resource info
//						if (desc.textures.find(resource.handle) != desc.textures.end())
//						{
//							desc.textures[resource.handle].usage |= ResourceStateToTextureUsage(resource.state);
//						}
//						else if (desc.buffers.find(resource.handle) != desc.buffers.end())
//						{
//							desc.buffers[resource.handle].usage |= ResourceStateToBufferUsage(resource.state);
//						}
//					}
//				}
//
//				// Add pass
//				resource_states.push_back(pass_resource_state);
//				ordered_passes.push_back(iter->second);
//				pass_handles.push_back(iter->first);
//				collected_passes.insert(iter->first);
//
//				iter = tmp_desc.passes.erase(iter);
//				break;
//			}
//			else
//			{
//				iter++;
//			}
//		}
//	}
//
//	std::set<RGHandle> alias_textures;
//
//	// Register resource
//	{
//		// Collect texture alias info
//		struct TexturePool
//		{
//			std::vector<RGHandle> handles;
//
//			uint32_t start;
//			uint32_t end;
//		};
//
//		std::vector<TexturePool> texture_pools;
//
//		for (auto &[handle, resource] : resource_lifetime)
//		{
//			if (desc.textures.find(handle) != desc.textures.end())
//			{
//				bool alias = false;
//				for (auto &pool : texture_pools)
//				{
//					if (pool.start > (--resource.end())->first ||
//					    pool.end < resource.begin()->first)
//					{
//						pool.handles.push_back(handle);
//						pool.start = std::min(pool.start, (--resource.end())->first);
//						pool.end   = std::max(pool.end, resource.begin()->first);
//						alias      = true;
//						break;
//					}
//				}
//				if (!alias)
//				{
//					texture_pools.push_back(TexturePool{{handle}, resource.begin()->first, (--resource.end())->first});
//				}
//			}
//			else
//			{
//				render_graph->RegisterBuffer(RenderGraph::BufferCreateInfo{desc.buffers[handle], handle});
//			}
//		}
//
//		for (auto &pool : texture_pools)
//		{
//			std::vector<RenderGraph::TextureCreateInfo> texture_create_infos;
//			texture_create_infos.reserve(pool.handles.size());
//			for (auto &handle : pool.handles)
//			{
//				texture_create_infos.push_back(RenderGraph::TextureCreateInfo{desc.textures[handle], handle});
//				if (pool.handles.size() > 1)
//				{
//					alias_textures.insert(handle);
//				}
//			}
//			render_graph->RegisterTexture(texture_create_infos);
//		}
//	}
//
//	// Resource state tracking
//	for (auto &resource_state : resource_states)
//	{
//		for (auto &[resource_handle, state_transition] : resource_state)
//		{
//			auto &[src, dst] = state_transition;
//			if (src == RHIResourceState::Undefined)
//			{
//				if (alias_textures.find(resource_handle) == alias_textures.end())
//				{
//					src = (--resource_lifetime[resource_handle].end())->second;
//				}
//			}
//		}
//	}
//
//	// Initialize Barrier
//	{
//		std::vector<BufferStateTransition>  buffer_state_transitions;
//		std::vector<TextureStateTransition> texture_state_transitions;
//
//		for (auto &[handle, resource] : resource_lifetime)
//		{
//			if ((--resource.end())->second != RHIResourceState::Undefined)
//			{
//				if (desc.textures.find(handle) != desc.textures.end())
//				{
//					auto *texture = render_graph->GetTexture(handle);
//
//					const auto &texture_desc = texture->GetDesc();
//
//					texture_state_transitions.push_back(TextureStateTransition{
//					    texture,
//					    RHIResourceState::Undefined,
//					    (--resource.end())->second,
//					    TextureRange{
//					        GetTextureDimension(texture_desc.width, texture_desc.height, texture_desc.depth, texture_desc.layers),
//					        0,
//					        texture_desc.mips,
//					        0,
//					        texture_desc.layers}});
//				}
//				else
//				{
//					auto *buffer = render_graph->GetBuffer(handle);
//
//					const auto &buffer_desc = buffer->GetDesc();
//
//					buffer_state_transitions.push_back(BufferStateTransition{
//					    buffer,
//					    RHIResourceState::Undefined,
//					    (--resource.end())->second});
//				}
//			}
//		}
//
//		render_graph->AddInitializeBarrier([=](RenderGraph &render_graph, RHICommand *cmd_buffer) {
//			cmd_buffer->ResourceStateTransition(texture_state_transitions, buffer_state_transitions);
//		});
//	}
//
//	for (uint32_t i = 0; i < ordered_passes.size(); i++)
//	{
//		const auto &pass = ordered_passes[i];
//
//		std::vector<BufferStateTransition>  buffer_state_transitions;
//		std::vector<TextureStateTransition> texture_state_transitions;
//
//		for (auto &[handle, resource_transition] : resource_states[i])
//		{
//			if (resource_transition.first == resource_transition.second)
//			{
//				continue;
//			}
//
//			if (desc.textures.find(handle) != desc.textures.end())
//			{
//				auto *texture = render_graph->GetTexture(handle);
//
//				const auto &texture_desc = texture->GetDesc();
//
//				texture_state_transitions.push_back(TextureStateTransition{
//				    texture,
//				    resource_transition.first,
//				    resource_transition.second,
//				    TextureRange{
//				        GetTextureDimension(texture_desc.width, texture_desc.height, texture_desc.depth, texture_desc.layers),
//				        0,
//				        texture_desc.mips,
//				        0,
//				        texture_desc.layers}});
//			}
//			else
//			{
//				auto *buffer = render_graph->GetBuffer(handle);
//
//				const auto &buffer_desc = buffer->GetDesc();
//
//				buffer_state_transitions.push_back(BufferStateTransition{
//				    buffer,
//				    resource_transition.first,
//				    resource_transition.second});
//			}
//		}
//
//		RenderGraph::RenderTask render_task;
//
//		PluginManager::GetInstance().Call(fmt::format("shared/RenderPass/RenderPass.{}.dll", pass.name), "CreateCallback", &render_task, pass, *this, std::forward<Args>(args)...);
//
//		render_graph->AddPass(
//		    pass.name,
//		    pass.bind_point,
//		    pass.config,
//		    std::move(render_task),
//		    [=](RenderGraph &render_graph, RHICommand *cmd_buffer) {
//			    cmd_buffer->ResourceStateTransition(texture_state_transitions, buffer_state_transitions);
//		    });
//	}
//
//	return render_graph;
//}
//}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/RenderGraph/Public/RenderGraph/Precompile.hpp
================================================
#pragma once

#include <Core/Core.hpp>

================================================
FILE: Source/Runtime/Render/RenderGraph/Public/RenderGraph/RenderGraph.hpp
================================================
#pragma once

#include "Precompile.hpp"
#include "RenderPass.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class RenderGraphBlackboard;

class  RenderGraphDesc
{
  public:
	RenderGraphDesc() = default;

	~RenderGraphDesc() = default;

	RenderGraphDesc &SetName(const std::string &name);

	RenderGraphDesc &AddPass(size_t handle, RenderPassDesc &&desc);

	void ErasePass(size_t handle);

	void EraseLink(size_t source, size_t target);

	RenderGraphDesc &Link(size_t source, size_t target);

	bool HasLink(size_t target) const;

	size_t LinkFrom(size_t target) const;

	std::set<size_t> LinkTo(size_t source) const;

	bool HasPass(size_t handle) const;

	RenderPassDesc &GetPass(size_t handle);

	const std::string &GetName() const;

	std::map<size_t, RenderPassDesc> &GetPasses();

	const std::map<size_t, size_t> &GetEdges() const;

	void Clear();

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(m_name, m_passes, m_edges, m_pass_lookup);
	}

  private:
	std::string m_name;

	std::map<size_t, RenderPassDesc> m_passes;

	std::map<size_t, size_t> m_edges;        // Target - Source

	std::map<size_t, size_t> m_pass_lookup;        // Pin ID - Node ID
};

class  RenderGraph
{
	friend class RenderGraphBuilder;

  public:
	using RenderTask  = std::function<void(RenderGraph &, RHICommand *, Variant &, RenderGraphBlackboard &)>;
	using BarrierTask = std::function<void(RenderGraph &, RHICommand *)>;
	using InitializeBarrierTask = std::function<void(RenderGraph &, RHICommand *, RHICommand *)>;

	struct RenderPassInfo
	{
		std::string name;
		std::string category;

		BindPoint bind_point;

		Variant config;

		RenderTask  execute;
		BarrierTask barrier;

		std::unique_ptr<RHIProfiler> profiler = nullptr;
	};

  public:
	RenderGraph(RHIContext *rhi_context);

	~RenderGraph();

	// Return the old one
	std::unique_ptr<RHITexture> SetTexture(size_t handle, std::unique_ptr<RHITexture> &&texture);

	RHITexture *GetTexture(size_t handle);

	RHIBuffer *GetBuffer(size_t handle);

	RHITexture *GetCUDATexture(size_t handle);

	void Execute(RenderGraphBlackboard &black_board);

	const std::vector<RenderPassInfo> &GetRenderPasses() const;

  private:
	struct TextureCreateInfo
	{
		TextureDesc      desc;
		std::set<size_t> handles;
	};

	struct BufferCreateInfo
	{
		BufferDesc       desc;
		std::set<size_t> handles;
	};

	RenderGraph &AddPass(
	    const std::string &name,
	    const std::string &category,
	    BindPoint          bind_point,
	    const Variant     &config,
	    RenderTask       &&execute,
	    BarrierTask      &&barrier);

	RenderGraph &AddInitializeBarrier(InitializeBarrierTask &&barrier);

	// Without memory alias
	RenderGraph &RegisterTexture(const TextureCreateInfo &create_infos);

	// With memory alias
	RenderGraph &RegisterTexture(const std::vector<TextureCreateInfo> &create_info);

	RenderGraph &RegisterBuffer(const BufferCreateInfo &create_info);

	RHISemaphore *MapToCUDASemaphore(RHISemaphore *semaphore);

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/RenderGraph/Public/RenderGraph/RenderGraphBlackboard.hpp
================================================
#pragma once

#include "Precompile.hpp"

namespace Ilum
{
class RenderGraphBlackboard
{
  public:
	RenderGraphBlackboard() = default;

	~RenderGraphBlackboard() = default;

	template <typename _Ty>
	_Ty *Add()
	{
		return std::static_pointer_cast<_Ty>(Add(typeid(_Ty), std::make_shared<_Ty>())).get();
	}

	template <typename _Ty>
	bool Has()
	{
		return Has(typeid(_Ty));
	}

	template <typename _Ty>
	_Ty *Get()
	{
		if (!Has<_Ty>())
		{
			Add<_Ty>();
		}

		return std::static_pointer_cast<_Ty>(Get(typeid(_Ty))).get();
	}

	template <typename _Ty>
	RenderGraphBlackboard &Erase()
	{
		return Erase(typeid(_Ty));
	}

  private:
	std::shared_ptr<void> &Add(std::type_index type, std::shared_ptr<void> &&ptr);

	bool Has(std::type_index type);

	std::shared_ptr<void> &Get(std::type_index type);

	RenderGraphBlackboard &Erase(std::type_index type);

  private:
	std::unordered_map<std::type_index, std::shared_ptr<void>> m_data;

	std::mutex m_mutex;
};
}        // namespace Ilum


================================================
FILE: Source/Runtime/Render/RenderGraph/Public/RenderGraph/RenderGraphBuilder.hpp
================================================
#pragma once

#include "Precompile.hpp"

#include "RenderGraph.hpp"

namespace Ilum
{
class RenderGraph;
class Renderer;

class  RenderGraphBuilder
{
  public:
	RenderGraphBuilder(RHIContext *rhi_context);

	~RenderGraphBuilder() = default;

	RenderGraphBuilder &AddPass(RenderGraph &render_graph, const std::string &name, const std::string &category, BindPoint bind_point, const Variant &config, RenderGraph::RenderTask &&task, RenderGraph::BarrierTask &&barrier);

	bool Validate(RenderGraphDesc &desc);

	std::unique_ptr<RenderGraph> Compile(RenderGraphDesc &desc, Renderer* renderer);

  private:
	RHIContext *p_rhi_context = nullptr;
};
}        // namespace Ilum

#include "Impl/RenderGraphBuilder.inl"

================================================
FILE: Source/Runtime/Render/RenderGraph/Public/RenderGraph/RenderPass.hpp
================================================
#pragma once

#include "Precompile.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class Editor;

enum class BindPoint
{
	None,
	Rasterization,
	Compute,
	RayTracing,
	CUDA
};

struct RenderPassPin
{
	enum class Type
	{
		Unknown,
		Texture,
		Buffer
	};

	enum class Attribute
	{
		Input,
		Output
	};

	// Common
	Type      type;
	Attribute attribute;

	std::string name;
	size_t      handle;

	TextureDesc texture;
	BufferDesc  buffer;

	RHIResourceState resource_state;

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(type, attribute, name, handle, texture, buffer, resource_state);
	}
};

class RenderPassDesc
{
  public:
	RenderPassDesc() = default;

	~RenderPassDesc() = default;

	RenderPassDesc &SetName(const std::string &name);

	RenderPassDesc &SetCategory(const std::string &category);

	RenderPassDesc &SetHandle(size_t handle);

	RenderPassDesc &WriteTexture2D(size_t handle, const std::string &name, RHIFormat format, RHIResourceState resource_state, uint32_t width = 0, uint32_t height = 0, uint32_t layer = 1, uint32_t mips = 1);

	RenderPassDesc &ReadTexture2D(size_t handle, const std::string &name, RHIResourceState resource_state);

	RenderPassDesc &WriteBuffer(size_t handle, const std::string &name, size_t size, RHIResourceState resource_state);

	RenderPassDesc &ReadBuffer(size_t handle, const std::string &name, RHIResourceState resource_state);

	const RenderPassPin &GetPin(size_t handle) const;

	RenderPassPin &GetPin(size_t handle);

	RenderPassPin &GetPin(const std::string &name);

	const RenderPassPin &GetPin(const std::string &name) const;

	RenderPassDesc &SetConfig(Variant config);

	const Variant &GetConfig() const;

	const std::string &GetName() const;

	const std::string &GetCategory() const;

	std::map<size_t, RenderPassPin> &GetPins();

	size_t GetHandle() const;

	BindPoint GetBindPoint() const;

	RenderPassDesc &SetBindPoint(BindPoint bind_point);

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(m_name, m_category, m_bind_point, m_handle, m_pins, m_pin_indices, m_config);
	}

  private:
	std::string m_name;
	std::string m_category;

	BindPoint m_bind_point = BindPoint::None;

	size_t m_handle = ~0ull;

	std::map<size_t, RenderPassPin> m_pins;
	std::map<std::string, size_t>   m_pin_indices;

	Variant m_config;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Renderer/Private/Renderer.cpp
================================================
#include "Renderer.hpp"
#include "RenderData.hpp"

#include <Core/Path.hpp>
#include <Material/MaterialCompiler.hpp>
#include <Material/MaterialData.hpp>
#include <RHI/RHIContext.hpp>
#include <RenderGraph/RenderGraph.hpp>
#include <RenderGraph/RenderGraphBlackboard.hpp>
#include <Resource/Resource/Animation.hpp>
#include <Resource/Resource/Material.hpp>
#include <Resource/Resource/Mesh.hpp>
#include <Resource/Resource/SkinnedMesh.hpp>
#include <Resource/Resource/Texture2D.hpp>
#include <Resource/Resource/TextureCube.hpp>
#include <Resource/ResourceManager.hpp>
#include <Scene/Components/AllComponents.hpp>
#include <Scene/Node.hpp>
#include <Scene/Scene.hpp>
#include <ShaderCompiler/ShaderBuilder.hpp>
#include <ShaderCompiler/ShaderCompiler.hpp>

#include <cereal/types/vector.hpp>

namespace Ilum
{
struct Renderer::Impl
{
	RHIContext *rhi_context = nullptr;

	Scene *scene = nullptr;

	ResourceManager *resource_manager = nullptr;

	glm::vec2 viewport = {1.f, 1.f};

	RHITexture *present_texture = nullptr;

	std::unique_ptr<RenderGraph> render_graph     = nullptr;
	std::unique_ptr<RenderGraph> new_render_graph = nullptr;

	RenderGraphBlackboard black_board;

	std::unique_ptr<ShaderBuilder> shader_builder = nullptr;

	std::unique_ptr<RHIPipelineState> gpu_skinning_pipeline = nullptr;

	ShaderMeta gpu_skinning_shader_meta;

	float animation_time   = 0.f;
	bool  update_animation = false;

	Cmpt::Camera *main_camera = nullptr;
};

Renderer::Renderer(RHIContext *rhi_context, Scene *scene, ResourceManager *resource_manager)
{
	m_impl                        = new Impl;
	m_impl->rhi_context           = rhi_context;
	m_impl->scene                 = scene;
	m_impl->resource_manager      = resource_manager;
	m_impl->shader_builder        = std::make_unique<ShaderBuilder>(rhi_context);
	m_impl->gpu_skinning_pipeline = rhi_context->CreatePipelineState();

	// GPU Skinning Pipeline
	{
		RHIShader *shader = m_impl->shader_builder->RequireShader("./Source/Shaders/UpdateBoneMatrics.hlsl", "CSmain", RHIShaderStage::Compute);
		m_impl->gpu_skinning_pipeline->SetShader(RHIShaderStage::Compute, shader);
		m_impl->gpu_skinning_shader_meta = m_impl->shader_builder->RequireShaderMeta(shader);
	}

	// View
	{
		auto *view   = m_impl->black_board.Add<View>();
		view->buffer = m_impl->rhi_context->CreateBuffer<View::Info>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
	}

	// GPU Scene
	{
		auto *gpu_scene            = m_impl->black_board.Add<GPUScene>();
		gpu_scene->opaque_tlas     = m_impl->rhi_context->CreateAcccelerationStructure();
		gpu_scene->non_opaque_tlas = m_impl->rhi_context->CreateAcccelerationStructure();

		gpu_scene->animation.update_info = m_impl->rhi_context->CreateBuffer<GPUScene::AnimationBuffer::UpdateInfo>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
	}

	// Dummy Textures
	{
		auto *dummy_texture              = m_impl->black_board.Add<DummyTexture>();
		dummy_texture->white_opaque      = m_impl->rhi_context->CreateTexture2D(1, 1, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::Transfer | RHITextureUsage::ShaderResource, false);
		dummy_texture->black_opaque      = m_impl->rhi_context->CreateTexture2D(1, 1, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::Transfer | RHITextureUsage::ShaderResource, false);
		dummy_texture->white_transparent = m_impl->rhi_context->CreateTexture2D(1, 1, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::Transfer | RHITextureUsage::ShaderResource, false);
		dummy_texture->black_transparent = m_impl->rhi_context->CreateTexture2D(1, 1, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::Transfer | RHITextureUsage::ShaderResource, false);

		auto white_opaque_buffer      = m_impl->rhi_context->CreateBuffer<glm::vec4>(1, RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
		auto black_opaque_buffer      = m_impl->rhi_context->CreateBuffer<glm::vec4>(1, RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
		auto white_transparent_buffer = m_impl->rhi_context->CreateBuffer<glm::vec4>(1, RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
		auto black_transparent_buffer = m_impl->rhi_context->CreateBuffer<glm::vec4>(1, RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);

		glm::vec4 white_opaque      = {1.f, 1.f, 1.f, 1.f};
		glm::vec4 black_opaque      = {0.f, 0.f, 0.f, 1.f};
		glm::vec4 white_transparent = {1.f, 1.f, 1.f, 0.f};
		glm::vec4 black_transparent = {0.f, 0.f, 0.f, 0.f};

		white_opaque_buffer->CopyToDevice(&white_opaque, sizeof(white_opaque));
		black_opaque_buffer->CopyToDevice(&black_opaque, sizeof(white_opaque));
		white_transparent_buffer->CopyToDevice(&white_transparent, sizeof(white_opaque));
		black_transparent_buffer->CopyToDevice(&black_transparent, sizeof(white_opaque));

		auto *cmd_buffer = m_impl->rhi_context->CreateCommand(RHIQueueFamily::Graphics);
		cmd_buffer->Begin();
		cmd_buffer->ResourceStateTransition({TextureStateTransition{dummy_texture->white_opaque.get(), RHIResourceState::Undefined, RHIResourceState::TransferDest, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
		                                     TextureStateTransition{dummy_texture->black_opaque.get(), RHIResourceState::Undefined, RHIResourceState::TransferDest, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
		                                     TextureStateTransition{dummy_texture->white_transparent.get(), RHIResourceState::Undefined, RHIResourceState::TransferDest, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
		                                     TextureStateTransition{dummy_texture->black_transparent.get(), RHIResourceState::Undefined, RHIResourceState::TransferDest, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
		                                    {});
		cmd_buffer->CopyBufferToTexture(white_opaque_buffer.get(), dummy_texture->white_opaque.get(), 0, 0, 1);
		cmd_buffer->CopyBufferToTexture(black_opaque_buffer.get(), dummy_texture->black_opaque.get(), 0, 0, 1);
		cmd_buffer->CopyBufferToTexture(white_transparent_buffer.get(), dummy_texture->white_transparent.get(), 0, 0, 1);
		cmd_buffer->CopyBufferToTexture(black_transparent_buffer.get(), dummy_texture->black_transparent.get(), 0, 0, 1);
		cmd_buffer->ResourceStateTransition({TextureStateTransition{dummy_texture->white_opaque.get(), RHIResourceState::TransferDest, RHIResourceState::ShaderResource, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
		                                     TextureStateTransition{dummy_texture->black_opaque.get(), RHIResourceState::TransferDest, RHIResourceState::ShaderResource, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
		                                     TextureStateTransition{dummy_texture->white_transparent.get(), RHIResourceState::TransferDest, RHIResourceState::ShaderResource, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
		                                     TextureStateTransition{dummy_texture->black_transparent.get(), RHIResourceState::TransferDest, RHIResourceState::ShaderResource, TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
		                                    {});
		cmd_buffer->End();
		m_impl->rhi_context->Execute(cmd_buffer);
	}

	// LUT
	{
		auto *lut = m_impl->black_board.Add<LUT>();
		lut->ggx  = rhi_context->CreateTexture2D(512, 512, RHIFormat::R16G16_FLOAT, RHITextureUsage::ShaderResource | RHITextureUsage::UnorderedAccess, false);

		{
			std::unique_ptr<RHIPipelineState> ggx_preintegration = rhi_context->CreatePipelineState();

			RHIShader *shader = RequireShader("Source/Shaders/PreProcess/GGXBRDFLUT.hlsl", "CSmain", RHIShaderStage::Compute);
			ggx_preintegration->SetShader(RHIShaderStage::Compute, shader);
			ShaderMeta meta = RequireShaderMeta(shader);

			auto *descriptor = rhi_context->CreateDescriptor(meta);
			descriptor->BindTexture("Output", lut->ggx.get(), RHITextureDimension::Texture2D);

			auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Compute);
			cmd_buffer->Begin();
			cmd_buffer->ResourceStateTransition({
			                                        TextureStateTransition{lut->ggx.get(), RHIResourceState::Undefined, RHIResourceState::UnorderedAccess},
			                                    },
			                                    {});
			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(ggx_preintegration.get());
			cmd_buffer->Dispatch(512, 512, 1, 8, 8, 1);
			cmd_buffer->ResourceStateTransition({
			                                        TextureStateTransition{lut->ggx.get(), RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource},
			                                    },
			                                    {});
			cmd_buffer->End();
			m_impl->rhi_context->Execute(cmd_buffer);
		}
	}
}

Renderer::~Renderer()
{
	delete m_impl;
}

void Renderer::Tick()
{
	m_impl->present_texture = nullptr;

	m_impl->scene->Update();

	UpdateGPUScene();

	if (m_impl->new_render_graph)
	{
		m_impl->rhi_context->WaitIdle();
		m_impl->render_graph = std::move(m_impl->new_render_graph);
		m_impl->new_render_graph.reset();
	}

	if (m_impl->render_graph)
	{
		m_impl->render_graph->Execute(m_impl->black_board);
	}

	m_impl->scene->Reset();
}

void Renderer::SetRenderGraph(std::unique_ptr<RenderGraph> &&render_graph)
{
	m_impl->new_render_graph = std::move(render_graph);
}

RenderGraph *Renderer::GetRenderGraph() const
{
	return m_impl->render_graph.get();
}

RHIContext *Renderer::GetRHIContext() const
{
	return m_impl->rhi_context;
}

ResourceManager *Renderer::GetResourceManager() const
{
	return m_impl->resource_manager;
}

RenderGraphBlackboard &Renderer::GetRenderGraphBlackboard()
{
	return m_impl->black_board;
}

void Renderer::SetViewport(float width, float height)
{
	m_impl->viewport = glm::vec2{width, height};
}

glm::vec2 Renderer::GetViewport() const
{
	return m_impl->viewport;
}

void Renderer::SetAnimationTime(float time)
{
	m_impl->animation_time   = time;
	m_impl->update_animation = true;
}

void Renderer::SetPresentTexture(RHITexture *present_texture)
{
	m_impl->present_texture = present_texture;
}

RHITexture *Renderer::GetPresentTexture() const
{
	return m_impl->present_texture ? m_impl->present_texture : m_impl->black_board.Get<DummyTexture>()->black_opaque.get();
}

float Renderer::GetMaxAnimationTime() const
{
	return static_cast<float>(m_impl->black_board.Get<GPUScene>()->animation.max_frame_count) / 30.f;
}

void Renderer::UpdateView(Cmpt::Camera *camera)
{
	m_impl->main_camera = camera;

	if (camera)
	{
		auto *view = m_impl->black_board.Get<View>();

		View::Info view_info = {};

		std::memcpy(view_info.frustum, camera->GetFrustumPlanes().data(), sizeof(glm::vec4) * 6);
		view_info.position                   = camera->GetNode()->GetComponent<Cmpt::Transform>()->GetWorldTransform()[3];
		view_info.projection_matrix          = camera->GetProjectionMatrix();
		view_info.view_matrix                = camera->GetViewMatrix();
		view_info.inv_projection_matrix      = camera->GetInvProjectionMatrix();
		view_info.inv_view_matrix            = camera->GetInvViewMatrix();
		view_info.view_projection_matrix     = camera->GetViewProjectionMatrix();
		view_info.inv_view_projection_matrix = camera->GetInvViewProjectionMatrix();
		view_info.viewport                   = m_impl->viewport;

		view->buffer->CopyToDevice(&view_info, sizeof(View::Info));
	}
}

Scene *Renderer::GetScene() const
{
	return m_impl->scene;
}

void Renderer::Reset()
{
	m_impl->rhi_context->WaitIdle();
}

RHIShader *Renderer::RequireShader(const std::string &filename, const std::string &entry_point, RHIShaderStage stage, std::vector<std::string> &&macros, std::vector<std::string> &&includes, bool cuda, bool force_recompile)
{
	return m_impl->shader_builder->RequireShader(filename, entry_point, stage, std::move(macros), std::move(includes), cuda, force_recompile);
}

ShaderMeta Renderer::RequireShaderMeta(RHIShader *shader) const
{
	return m_impl->shader_builder->RequireShaderMeta(shader);
}

void Renderer::UpdateLight()
{
	auto *gpu_scene = m_impl->black_board.Get<GPUScene>();

	auto point_lights       = m_impl->scene->GetComponents<Cmpt::PointLight>();
	auto spot_lights        = m_impl->scene->GetComponents<Cmpt::SpotLight>();
	auto directional_lights = m_impl->scene->GetComponents<Cmpt::DirectionalLight>();
	auto rectangle_lights   = m_impl->scene->GetComponents<Cmpt::RectLight>();
	auto environment_lights = m_impl->scene->GetComponents<Cmpt::EnvironmentLight>();

	if (!gpu_scene->light.light_info_buffer)
	{
		gpu_scene->light.light_info_buffer = m_impl->rhi_context->CreateBuffer<GPUScene::LightBuffer::Info>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
	}

#define COPY_LIGHT_DATA(DATA, BUFFER)                                                                                                             \
	if (!DATA.empty())                                                                                                                            \
	{                                                                                                                                             \
		size_t light_size = DATA.empty() ? 0 : DATA.size() * DATA[0]->GetDataSize();                                                              \
		if (!gpu_scene->light.BUFFER || gpu_scene->light.BUFFER->GetDesc().size != light_size)                                                    \
		{                                                                                                                                         \
			gpu_scene->light.BUFFER = m_impl->rhi_context->CreateBuffer(light_size, RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU); \
		}                                                                                                                                         \
		auto    *light_buffer = gpu_scene->light.BUFFER->Map();                                                                                   \
		size_t   offset       = 0;                                                                                                                \
		uint32_t shadow_id    = 0;                                                                                                                \
		for (auto &light : DATA)                                                                                                                  \
		{                                                                                                                                         \
			light->SetShadowID(shadow_id);                                                                                                        \
			std::memcpy((uint8_t *) light_buffer + offset, light->GetData(m_impl->main_camera), light->GetDataSize());                            \
			offset += light->GetDataSize();                                                                                                       \
		}                                                                                                                                         \
		gpu_scene->light.BUFFER->Unmap();                                                                                                         \
	}                                                                                                                                             \
	else                                                                                                                                          \
	{                                                                                                                                             \
		if (!gpu_scene->light.BUFFER)                                                                                                             \
		{                                                                                                                                         \
			gpu_scene->light.BUFFER = m_impl->rhi_context->CreateBuffer(1, RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);          \
		}                                                                                                                                         \
	}

	COPY_LIGHT_DATA(point_lights, point_light_buffer);
	COPY_LIGHT_DATA(spot_lights, spot_light_buffer);
	COPY_LIGHT_DATA(directional_lights, directional_light_buffer);
	COPY_LIGHT_DATA(rectangle_lights, rect_light_buffer);

	gpu_scene->light.info.point_light_count       = static_cast<uint32_t>(point_lights.size());
	gpu_scene->light.info.spot_light_count        = static_cast<uint32_t>(spot_lights.size());
	gpu_scene->light.info.directional_light_count = static_cast<uint32_t>(directional_lights.size());
	gpu_scene->light.info.rect_light_count        = static_cast<uint32_t>(rectangle_lights.size());
	gpu_scene->light.light_info_buffer->CopyToDevice(&gpu_scene->light.info, sizeof(gpu_scene->light.info));

	// Copy environment light data
	if (environment_lights.empty())
	{
		gpu_scene->texture.texture_cube = nullptr;
	}
	else
	{
		auto resource = m_impl->resource_manager->Get<ResourceType::TextureCube>(static_cast<const char *>(environment_lights.back()->GetData()));
		if (resource)
		{
			gpu_scene->texture.texture_cube = resource->GetTexture();
		}
		else
		{
			gpu_scene->texture.texture_cube = nullptr;
		}
	}
}

void Renderer::UpdateAnimation()
{
	auto *gpu_scene = m_impl->black_board.Get<GPUScene>();

	// Update animation
	if (gpu_scene->animation.max_bone_count > 0 && m_impl->update_animation)
	{
		{
			GPUScene::AnimationBuffer::UpdateInfo update_info = {};

			update_info.count = static_cast<uint32_t>(gpu_scene->animation.bone_matrics.size());
			update_info.time  = m_impl->animation_time;
			gpu_scene->animation.update_info->CopyToDevice(&update_info, sizeof(update_info));
		}

		std::vector<BufferStateTransition> begin_transitions(gpu_scene->animation.bone_matrics.size());
		std::vector<BufferStateTransition> end_transitions(gpu_scene->animation.bone_matrics.size());

		for (size_t i = 0; i < gpu_scene->animation.bone_matrics.size(); i++)
		{
			begin_transitions[i] = BufferStateTransition{gpu_scene->animation.bone_matrics[i], RHIResourceState::ShaderResource, RHIResourceState::UnorderedAccess};
			end_transitions[i]   = BufferStateTransition{gpu_scene->animation.bone_matrics[i], RHIResourceState::UnorderedAccess, RHIResourceState::ShaderResource};
		}

		auto *descriptor = m_impl->rhi_context->CreateDescriptor(m_impl->gpu_skinning_shader_meta);
		descriptor->BindBuffer("UpdateInfo", gpu_scene->animation.update_info.get());
		auto *cmd_buffer = m_impl->rhi_context->CreateCommand(RHIQueueFamily::Compute);
		cmd_buffer->Begin();
		cmd_buffer->ResourceStateTransition({}, begin_transitions);
		for (size_t i = 0; i < gpu_scene->animation.bone_matrics.size(); i++)
		{
			descriptor->BindBuffer("BoneMatrics", gpu_scene->animation.bone_matrics[i])
			    .BindTexture("SkinnedMatrics", gpu_scene->animation.skinned_matrics[i], RHITextureDimension::Texture2D);
			cmd_buffer->BindDescriptor(descriptor);
			cmd_buffer->BindPipelineState(m_impl->gpu_skinning_pipeline.get());
			cmd_buffer->Dispatch(gpu_scene->animation.max_bone_count, 1, 1, 8, 1, 1);
		}
		cmd_buffer->ResourceStateTransition({}, end_transitions);
		cmd_buffer->End();
		m_impl->rhi_context->Submit({cmd_buffer});
		m_impl->update_animation = false;
	}

	// Update resource
	if (m_impl->resource_manager->Update<ResourceType::Animation>())
	{
		m_impl->scene->Update(true);

		gpu_scene->animation.bone_matrics.clear();
		gpu_scene->animation.skinned_matrics.clear();

		auto resources = m_impl->resource_manager->GetResources<ResourceType::Animation>();

		gpu_scene->animation.max_bone_count  = 0;
		gpu_scene->animation.max_frame_count = 0;
		for (auto &resource : resources)
		{
			auto *animation = m_impl->resource_manager->Get<ResourceType::Animation>(resource);
			gpu_scene->animation.skinned_matrics.push_back(animation->GetSkinnedMatrics());
			gpu_scene->animation.bone_matrics.push_back(animation->GetBoneMatrics());
			gpu_scene->animation.max_bone_count  = glm::max(gpu_scene->animation.max_bone_count, animation->GetBoneCount());
			gpu_scene->animation.max_frame_count = glm::max(gpu_scene->animation.max_frame_count, animation->GetFrameCount());
		}
	}
}

void Renderer::UpdateMesh()
{
	auto *gpu_scene = m_impl->black_board.Get<GPUScene>();

	auto meshes = m_impl->scene->GetComponents<Cmpt::MeshRenderer>();

	TLASDesc opaque_tlas_desc     = {fmt::format("{} - Opaque", m_impl->scene->GetName())};
	TLASDesc non_opaque_tlas_desc = {fmt::format("{} - Non Opaque", m_impl->scene->GetName())};

	std::vector<GPUScene::Instance> opaque_instances;
	std::vector<GPUScene::Instance> non_opaque_instances;

	gpu_scene->opaque_mesh.max_meshlet_count     = 0;
	gpu_scene->non_opaque_mesh.max_meshlet_count = 0;

	// Update mesh instances
	{
		for (auto &mesh : meshes)
		{
			auto &submeshes = mesh->GetSubmeshes();
			auto &materials = mesh->GetMaterials();
			for (uint32_t i = 0; i < submeshes.size(); i++)
			{
				auto &submesh = submeshes[i];

				auto *resource = m_impl->resource_manager->Get<ResourceType::Mesh>(submesh);

				if (resource)
				{
					GPUScene::Instance instance = {};
					instance.transform          = mesh->GetNode()->GetComponent<Cmpt::Transform>()->GetWorldTransform();
					instance.mesh_id            = static_cast<uint32_t>(m_impl->resource_manager->Index<ResourceType::Mesh>(submesh));
					instance.material_id        = 0;

					if (i < materials.size())
					{
						instance.material_id = static_cast<uint32_t>(m_impl->resource_manager->Index<ResourceType::Material>(materials[i])) + 1;
						auto *material       = m_impl->resource_manager->Get<ResourceType::Material>(materials[i]);
						if (material->GetMaterialData().blend_mode == BlendMode::Opaque)
						{
							opaque_instances.push_back(instance);
							opaque_tlas_desc.instances.push_back(TLASDesc::InstanceInfo{instance.transform, instance.material_id, resource->GetBLAS()});
							gpu_scene->opaque_mesh.max_meshlet_count = glm::max(gpu_scene->opaque_mesh.max_meshlet_count, static_cast<uint32_t>(resource->GetMeshletCount()));
						}
						else
						{
							non_opaque_instances.push_back(instance);
							non_opaque_tlas_desc.instances.push_back(TLASDesc::InstanceInfo{instance.transform, instance.material_id, resource->GetBLAS()});
							gpu_scene->non_opaque_mesh.max_meshlet_count = glm::max(gpu_scene->non_opaque_mesh.max_meshlet_count, static_cast<uint32_t>(resource->GetMeshletCount()));
						}
					}
					else
					{
						opaque_instances.push_back(instance);
						opaque_tlas_desc.instances.push_back(TLASDesc::InstanceInfo{instance.transform, instance.material_id, resource->GetBLAS()});
						gpu_scene->opaque_mesh.max_meshlet_count = glm::max(gpu_scene->opaque_mesh.max_meshlet_count, static_cast<uint32_t>(resource->GetMeshletCount()));
					}
				}
			}
		}

		gpu_scene->opaque_mesh.instance_count     = static_cast<uint32_t>(opaque_instances.size());
		gpu_scene->non_opaque_mesh.instance_count = static_cast<uint32_t>(non_opaque_instances.size());
	}

	// Copy to device
	{
		if (!opaque_instances.empty())
		{
			if (!gpu_scene->opaque_mesh.instances ||
			    gpu_scene->opaque_mesh.instances->GetDesc().size < opaque_instances.size() * sizeof(GPUScene::Instance))
			{
				gpu_scene->opaque_mesh.instances = m_impl->rhi_context->CreateBuffer<GPUScene::Instance>(opaque_instances.size(), RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
			}
			gpu_scene->opaque_mesh.instances->CopyToDevice(opaque_instances.data(), opaque_instances.size() * sizeof(GPUScene::Instance));
		}

		if (!non_opaque_instances.empty())
		{
			if (!gpu_scene->non_opaque_mesh.instances ||
			    gpu_scene->non_opaque_mesh.instances->GetDesc().size < non_opaque_instances.size() * sizeof(GPUScene::Instance))
			{
				gpu_scene->non_opaque_mesh.instances = m_impl->rhi_context->CreateBuffer<GPUScene::Instance>(non_opaque_instances.size(), RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
			}
			gpu_scene->non_opaque_mesh.instances->CopyToDevice(non_opaque_instances.data(), non_opaque_instances.size() * sizeof(GPUScene::Instance));
		}
	}

	// Update TLAS
	{
		if (!opaque_tlas_desc.instances.empty())
		{
			auto *cmd_buffer = m_impl->rhi_context->CreateCommand(RHIQueueFamily::Compute);
			cmd_buffer->Begin();
			gpu_scene->opaque_tlas->Update(cmd_buffer, opaque_tlas_desc);
			cmd_buffer->End();
			m_impl->rhi_context->Submit({cmd_buffer});
		}

		if (!non_opaque_tlas_desc.instances.empty())
		{
			auto *cmd_buffer = m_impl->rhi_context->CreateCommand(RHIQueueFamily::Compute);
			cmd_buffer->Begin();
			gpu_scene->non_opaque_tlas->Update(cmd_buffer, non_opaque_tlas_desc);
			cmd_buffer->End();
			m_impl->rhi_context->Submit({cmd_buffer});
		}
	}

	// Update resource
	if (m_impl->resource_manager->Update<ResourceType::Mesh>())
	{
		m_impl->scene->Update(true);

		gpu_scene->mesh_buffer.vertex_buffers.clear();
		gpu_scene->mesh_buffer.index_buffers.clear();
		gpu_scene->mesh_buffer.meshlet_buffers.clear();
		gpu_scene->mesh_buffer.meshlet_data_buffers.clear();
		auto resources = m_impl->resource_manager->GetResources<ResourceType::Mesh>();
		for (auto &resource : resources)
		{
			auto *mesh = m_impl->resource_manager->Get<ResourceType::Mesh>(resource);
			gpu_scene->mesh_buffer.vertex_buffers.push_back(mesh->GetVertexBuffer());
			gpu_scene->mesh_buffer.index_buffers.push_back(mesh->GetIndexBuffer());
			gpu_scene->mesh_buffer.meshlet_buffers.push_back(mesh->GetMeshletBuffer());
			gpu_scene->mesh_buffer.meshlet_data_buffers.push_back(mesh->GetMeshletDataBuffer());
		}
	}
}

void Renderer::UpdateSkinnedMesh()
{
	auto *gpu_scene      = m_impl->black_board.Get<GPUScene>();
	auto  skinned_meshes = m_impl->scene->GetComponents<Cmpt::SkinnedMeshRenderer>();

	std::vector<GPUScene::Instance> opaque_instances;
	std::vector<GPUScene::Instance> non_opaque_instances;

	gpu_scene->opaque_skinned_mesh.max_meshlet_count     = 0;
	gpu_scene->non_opaque_skinned_mesh.max_meshlet_count = 0;

	// Update skinned mesh instances
	{
		for (auto &skinned_mesh : skinned_meshes)
		{
			auto &submeshes  = skinned_mesh->GetSubmeshes();
			auto &animations = skinned_mesh->GetAnimations();
			auto &materials  = skinned_mesh->GetMaterials();
			for (uint32_t i = 0; i < submeshes.size(); i++)
			{
				auto *resource = m_impl->resource_manager->Get<ResourceType::SkinnedMesh>(submeshes[i]);

				if (resource)
				{
					GPUScene::Instance instance = {};
					instance.transform          = skinned_mesh->GetNode()->GetComponent<Cmpt::Transform>()->GetWorldTransform();
					instance.mesh_id            = static_cast<uint32_t>(m_impl->resource_manager->Index<ResourceType::SkinnedMesh>(submeshes[i]));
					instance.material_id        = 0;

					if (i < animations.size())
					{
						instance.animation_id = static_cast<uint32_t>(m_impl->resource_manager->Index<ResourceType::Animation>(animations[i]));
					}

					if (i < materials.size())
					{
						instance.material_id = static_cast<uint32_t>(m_impl->resource_manager->Index<ResourceType::Material>(materials[i])) + 1;
						auto *material       = m_impl->resource_manager->Get<ResourceType::Material>(materials[i]);
						if (material->GetMaterialData().blend_mode == BlendMode::Opaque)
						{
							opaque_instances.push_back(instance);
							gpu_scene->opaque_skinned_mesh.max_meshlet_count = glm::max(gpu_scene->opaque_skinned_mesh.max_meshlet_count, static_cast<uint32_t>(resource->GetMeshletCount()));
						}
						else
						{
							non_opaque_instances.push_back(instance);
							gpu_scene->non_opaque_skinned_mesh.max_meshlet_count = glm::max(gpu_scene->non_opaque_skinned_mesh.max_meshlet_count, static_cast<uint32_t>(resource->GetMeshletCount()));
						}
					}
					else
					{
						opaque_instances.push_back(instance);
						gpu_scene->opaque_skinned_mesh.max_meshlet_count = glm::max(gpu_scene->opaque_skinned_mesh.max_meshlet_count, static_cast<uint32_t>(resource->GetMeshletCount()));
					}
				}
			}
		}

		gpu_scene->opaque_skinned_mesh.instance_count     = static_cast<uint32_t>(opaque_instances.size());
		gpu_scene->non_opaque_skinned_mesh.instance_count = static_cast<uint32_t>(non_opaque_instances.size());
	}

	// Copy to device
	{
		if (!opaque_instances.empty())
		{
			if (!gpu_scene->opaque_skinned_mesh.instances ||
			    gpu_scene->opaque_skinned_mesh.instances->GetDesc().size < opaque_instances.size() * sizeof(GPUScene::Instance))
			{
				gpu_scene->opaque_skinned_mesh.instances = m_impl->rhi_context->CreateBuffer<GPUScene::Instance>(opaque_instances.size(), RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
			}
			gpu_scene->opaque_skinned_mesh.instances->CopyToDevice(opaque_instances.data(), opaque_instances.size() * sizeof(GPUScene::Instance));
		}

		if (!non_opaque_instances.empty())
		{
			if (!gpu_scene->non_opaque_skinned_mesh.instances ||
			    gpu_scene->non_opaque_skinned_mesh.instances->GetDesc().size < non_opaque_instances.size() * sizeof(GPUScene::Instance))
			{
				gpu_scene->non_opaque_skinned_mesh.instances = m_impl->rhi_context->CreateBuffer<GPUScene::Instance>(non_opaque_instances.size(), RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
			}
			gpu_scene->non_opaque_skinned_mesh.instances->CopyToDevice(non_opaque_instances.data(), non_opaque_instances.size() * sizeof(GPUScene::Instance));
		}
	}

	// Update resource
	if (m_impl->resource_manager->Update<ResourceType::SkinnedMesh>())
	{
		m_impl->scene->Update(true);

		gpu_scene->skinned_mesh_buffer.vertex_buffers.clear();
		gpu_scene->skinned_mesh_buffer.index_buffers.clear();
		gpu_scene->skinned_mesh_buffer.meshlet_buffers.clear();
		gpu_scene->skinned_mesh_buffer.meshlet_data_buffers.clear();
		auto resources = m_impl->resource_manager->GetResources<ResourceType::SkinnedMesh>();
		for (auto &resource : resources)
		{
			auto *skinned_mesh = m_impl->resource_manager->Get<ResourceType::SkinnedMesh>(resource);
			gpu_scene->skinned_mesh_buffer.vertex_buffers.push_back(skinned_mesh->GetVertexBuffer());
			gpu_scene->skinned_mesh_buffer.index_buffers.push_back(skinned_mesh->GetIndexBuffer());
			gpu_scene->skinned_mesh_buffer.meshlet_buffers.push_back(skinned_mesh->GetMeshletBuffer());
			gpu_scene->skinned_mesh_buffer.meshlet_data_buffers.push_back(skinned_mesh->GetMeshletDataBuffer());
		}
	}
}

void Renderer::UpdateMaterial()
{
	auto *gpu_scene = m_impl->black_board.Get<GPUScene>();

	// Update Sampler
	if (m_impl->rhi_context->GetSamplerCount() != gpu_scene->samplers.size())
	{
		m_impl->scene->Update(true);

		gpu_scene->samplers = m_impl->rhi_context->GetSamplers();
	}

	// Update 2D Textures
	if (m_impl->resource_manager->Update<ResourceType::Texture2D>())
	{
		m_impl->scene->Update(true);
	}

	// Update Material & Texture
	if (m_impl->resource_manager->Update<ResourceType::Material>() ||
	    m_impl->resource_manager->Update<ResourceType::Texture2D>())
	{
		m_impl->scene->Update(true);

		// Flush Texture
		if (m_impl->resource_manager->Update<ResourceType::Material>())
		{
			auto resources = m_impl->resource_manager->GetResources<ResourceType::Material>();
			for (auto &resource : resources)
			{
				auto *material = m_impl->resource_manager->Get<ResourceType::Material>(resource);
				if (!material->IsValid())
				{
					material->Compile(
					    m_impl->rhi_context,
					    m_impl->resource_manager,
					    m_impl->black_board.Get<DummyTexture>()->black_opaque.get());
				}
				for (auto &[texture, texture_name] : material->GetCompilationContext().textures)
				{
					m_impl->resource_manager->Index<ResourceType::Texture2D>(texture_name);
				}
			}
		}

		// Update Texture
		if (m_impl->resource_manager->Update<ResourceType::Texture2D>())
		{
			gpu_scene->texture.texture_2d.clear();
			auto resources = m_impl->resource_manager->GetResources<ResourceType::Texture2D>();
			for (auto &resource : resources)
			{
				auto *texture2d = m_impl->resource_manager->Get<ResourceType::Texture2D>(resource);
				gpu_scene->texture.texture_2d.push_back(texture2d->GetTexture());
			}
		}

		// Update Material
		if (m_impl->resource_manager->Update<ResourceType::Material>())
		{
			gpu_scene->material.data.clear();
			auto resources = m_impl->resource_manager->GetResources<ResourceType::Material>();

			std::vector<uint32_t> material_data;
			std::vector<uint32_t> material_offset = {0};

			for (auto &resource : resources)
			{
				auto *material = m_impl->resource_manager->Get<ResourceType::Material>(resource);

				material->Update(
				    m_impl->rhi_context,
				    m_impl->resource_manager,
				    m_impl->black_board.Get<DummyTexture>()->black_opaque.get());

				const auto &data = material->GetMaterialData();

				material_offset.push_back(static_cast<uint32_t>(material_data.size() * sizeof(uint32_t)));
				material_data.insert(material_data.end(), data.textures.begin(), data.textures.end());
				material_data.insert(material_data.end(), data.samplers.begin(), data.samplers.end());

				gpu_scene->material.data.push_back(&data);
			}

			if (!material_data.empty())
			{
				if (!gpu_scene->material.material_buffer ||
				    material_data.size() * sizeof(uint32_t) != gpu_scene->material.material_buffer->GetDesc().size)
				{
					gpu_scene->material.material_buffer = m_impl->rhi_context->CreateBuffer<uint32_t>(material_data.size(), RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
				}
				gpu_scene->material.material_buffer->CopyToDevice(material_data.data(), material_data.size() * sizeof(uint32_t));
			}
			else if (!gpu_scene->material.material_buffer)
			{
				gpu_scene->material.material_buffer = m_impl->rhi_context->CreateBuffer<uint32_t>(1, RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
			}

			if (!material_offset.empty())
			{
				if (!gpu_scene->material.material_offset ||
				    material_offset.size() * sizeof(uint32_t) != gpu_scene->material.material_offset->GetDesc().size)
				{
					gpu_scene->material.material_offset = m_impl->rhi_context->CreateBuffer<uint32_t>(material_offset.size(), RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
				}
				gpu_scene->material.material_offset->CopyToDevice(material_offset.data(), material_offset.size() * sizeof(uint32_t));
			}
			else if (!gpu_scene->material.material_offset)
			{
				gpu_scene->material.material_offset = m_impl->rhi_context->CreateBuffer<uint32_t>(1, RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);
			}

			for (auto &resource : resources)
			{
				auto *material = m_impl->resource_manager->Get<ResourceType::Material>(resource);

				GPUScene *gpu_scene = m_impl->black_board.Get<GPUScene>();

				material->PostUpdate(
				    m_impl->rhi_context,
				    static_cast<uint32_t>(m_impl->resource_manager->Index<ResourceType::Material>(resource)),
				    gpu_scene->texture.texture_2d,
				    gpu_scene->samplers,
				    gpu_scene->material.material_buffer.get(),
				    gpu_scene->material.material_offset.get());
			}
		}
	}
}

void Renderer::UpdateGPUScene()
{
	auto *gpu_scene = m_impl->black_board.Get<GPUScene>();

	TLASDesc tlas_desc = {};
	tlas_desc.name     = m_impl->scene->GetName();

	auto meshes         = m_impl->scene->GetComponents<Cmpt::MeshRenderer>();
	auto skinned_meshes = m_impl->scene->GetComponents<Cmpt::SkinnedMeshRenderer>();

	UpdateLight();
	UpdateMesh();
	UpdateSkinnedMesh();
	UpdateAnimation();
	UpdateMaterial();
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Renderer/Public/Renderer/RenderData.hpp
================================================
#pragma once

#include <RHI/RHIContext.hpp>
#include <Resource/Resource/Material.hpp>

namespace Ilum
{
struct DummyTexture
{
	std::unique_ptr<RHITexture> white_opaque      = nullptr;
	std::unique_ptr<RHITexture> black_opaque      = nullptr;
	std::unique_ptr<RHITexture> white_transparent = nullptr;
	std::unique_ptr<RHITexture> black_transparent = nullptr;
};

struct LUT
{
	std::unique_ptr<RHITexture> ggx = nullptr;
};

struct View
{
	struct Info
	{
		glm::vec4 frustum[6];
		glm::mat4 view_matrix;
		glm::mat4 inv_view_matrix;
		glm::mat4 projection_matrix;
		glm::mat4 inv_projection_matrix;
		glm::mat4 view_projection_matrix;
		glm::mat4 inv_view_projection_matrix;
		glm::vec3 position;
		uint32_t  frame_count;
		glm::vec2 viewport;
	};

	std::unique_ptr<RHIBuffer> buffer = nullptr;
};

struct GPUScene
{
	struct Instance
	{
		glm::mat4 transform;
		uint32_t  mesh_id      = ~0U;
		uint32_t  material_id  = ~0U;
		uint32_t  animation_id = ~0U;
		uint32_t  visible      = 0U;
	};

	struct MeshInstance
	{
		std::unique_ptr<RHIBuffer> instances = nullptr;

		uint32_t max_meshlet_count = 0;
		uint32_t instance_count    = 0;
	};

	struct MeshBuffer
	{
		std::vector<RHIBuffer *> vertex_buffers;
		std::vector<RHIBuffer *> index_buffers;
		std::vector<RHIBuffer *> meshlet_data_buffers;
		std::vector<RHIBuffer *> meshlet_buffers;
	};

	struct SkinnedMeshInstance
	{
		std::unique_ptr<RHIBuffer> instances = nullptr;

		uint32_t max_meshlet_count = 0;
		uint32_t instance_count    = 0;
	};

	struct SkinnedMeshBuffer
	{
		std::vector<RHIBuffer *> vertex_buffers;
		std::vector<RHIBuffer *> index_buffers;
		std::vector<RHIBuffer *> meshlet_data_buffers;
		std::vector<RHIBuffer *> meshlet_buffers;
	};

	struct AnimationBuffer
	{
		struct UpdateInfo
		{
			uint32_t count;
			float    time;
		};

		std::vector<RHITexture *> skinned_matrics;
		std::vector<RHIBuffer *>  bone_matrics;

		std::unique_ptr<RHIBuffer> update_info = nullptr;

		uint32_t max_frame_count = 0;
		uint32_t max_bone_count  = 0;
	};

	struct LightBuffer
	{
		struct Info
		{
			uint32_t point_light_count       = 0;
			uint32_t spot_light_count        = 0;
			uint32_t directional_light_count = 0;
			uint32_t rect_light_count        = 0;
		} info;

		std::unique_ptr<RHIBuffer> point_light_buffer       = nullptr;
		std::unique_ptr<RHIBuffer> spot_light_buffer        = nullptr;
		std::unique_ptr<RHIBuffer> directional_light_buffer = nullptr;
		std::unique_ptr<RHIBuffer> rect_light_buffer        = nullptr;
		std::unique_ptr<RHIBuffer> light_info_buffer        = nullptr;
	};

	struct TextureBuffer
	{
		std::vector<RHITexture *> texture_2d;

		RHITexture *texture_cube = nullptr;
	};

	struct MaterialBuffer
	{
		std::vector<const MaterialData *> data;

		std::unique_ptr<RHIBuffer> material_buffer = nullptr;
		std::unique_ptr<RHIBuffer> material_offset = nullptr;
	};

	std::vector<RHISampler *> samplers;

	MeshInstance      opaque_mesh;
	MeshInstance      non_opaque_mesh;
	MeshBuffer        mesh_buffer;
	SkinnedMeshInstance opaque_skinned_mesh;
	SkinnedMeshInstance non_opaque_skinned_mesh;
	SkinnedMeshBuffer   skinned_mesh_buffer;
	AnimationBuffer   animation;
	MaterialBuffer    material;
	LightBuffer       light;
	TextureBuffer     texture;

	std::unique_ptr<RHIAccelerationStructure> opaque_tlas     = nullptr;
	std::unique_ptr<RHIAccelerationStructure> non_opaque_tlas = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/Renderer/Public/Renderer/Renderer.hpp
================================================
#pragma once

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class Scene;
class ResourceManager;
class MaterialGraph;
class RenderGraph;
class RenderGraphBlackboard;
class ShaderBuilder;

namespace Cmpt
{
class Camera;
}

class EXPORT_API Renderer
{
  public:
	Renderer(RHIContext *rhi_context, Scene *scene, ResourceManager *resource_manager);

	~Renderer();

	void Tick();

	void SetRenderGraph(std::unique_ptr<RenderGraph> &&render_graph);

	RenderGraph *GetRenderGraph() const;

	RHIContext *GetRHIContext() const;

	ResourceManager *GetResourceManager() const;

	RenderGraphBlackboard &GetRenderGraphBlackboard();

	void SetViewport(float width, float height);

	glm::vec2 GetViewport() const;

	void SetAnimationTime(float time);

	void SetPresentTexture(RHITexture *present_texture);

	RHITexture *GetPresentTexture() const;

	float GetMaxAnimationTime() const;

	void UpdateView(Cmpt::Camera *camera);

	Scene *GetScene() const;

	void Reset();

  public:
	// Shader utils
	RHIShader *RequireShader(const std::string &filename, const std::string &entry_point, RHIShaderStage stage, std::vector<std::string> &&macros = {}, std::vector<std::string> &&includes = {}, bool cuda = false, bool force_recompile = false);

	ShaderMeta RequireShaderMeta(RHIShader *shader) const;

	// RHIShader *RequireMaterialShader(MaterialGraph *material_graph, const std::string &filename, const std::string &entry_point, RHIShaderStage stage, std::vector<std::string> &&macros = {}, std::vector<std::string> &&includes = {});

  private:
	void UpdateLight();
	void UpdateAnimation();
	void UpdateMesh();
	void UpdateSkinnedMesh();
	void UpdateMaterial();
	void UpdateGPUScene();

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/ShaderCompiler/Private/ShaderBuilder.cpp
================================================
#include "ShaderBuilder.hpp"
#include "ShaderCompiler.hpp"

#include <RHI/RHIDefinitions.hpp>

namespace Ilum
{
struct ShaderBuilder::Impl
{
	std::unordered_map<size_t, std::unique_ptr<RHIShader>> shader_cache;
	std::unordered_map<RHIShader *, ShaderMeta>            shader_meta_cache;

	std::mutex mutex;
};

ShaderBuilder::ShaderBuilder(RHIContext *context) :
    p_rhi_context(context)
{
	m_impl = new Impl;
}

ShaderBuilder::~ShaderBuilder()
{
	p_rhi_context->WaitIdle();
	delete m_impl;
}

RHIShader *ShaderBuilder::RequireShader(const std::string &filename, const std::string &entry_point, RHIShaderStage stage, std::vector<std::string> &&macros, std::vector<std::string> &&includes, bool cuda, bool force_recompile)
{
	size_t hash = Hash(filename, entry_point, stage, macros, includes, cuda);

	if (!Path::GetInstance().IsExist("./bin/Shaders"))
	{
		Path::GetInstance().CreatePath("./bin/Shaders");
	}

	if (m_impl->shader_cache.find(hash) != m_impl->shader_cache.end() && !force_recompile)
	{
		return m_impl->shader_cache.at(hash).get();
	}

	std::string cache_path = "./bin/Shaders/" + std::to_string(hash) + ".shader";

	std::vector<uint8_t> shader_bin;
	ShaderMeta           meta;

	if (Path::GetInstance().IsExist(cache_path) && !force_recompile)
	{
		// Read from cache
		size_t last_write = 0;

		DESERIALIZE(
		    cache_path,
		    last_write,
		    shader_bin,
		    meta);

		if (last_write == std::filesystem::last_write_time(filename).time_since_epoch().count() && !shader_bin.empty())
		{
			std::unique_ptr<RHIShader> shader = p_rhi_context->CreateShader(entry_point, shader_bin, cuda);
			m_impl->shader_meta_cache.emplace(shader.get(), std::move(meta));
			m_impl->shader_cache.emplace(hash, std::move(shader));
			return m_impl->shader_cache.at(hash).get();
		}
	}

	{
		std::vector<uint8_t> shader_code;
		Path::GetInstance().Read(filename, shader_code);

		ShaderDesc desc = {};
		desc.path       = filename;
		desc.code.resize(shader_code.size());
		std::memcpy(desc.code.data(), shader_code.data(), shader_code.size());
		for (auto &include : includes)
		{
			desc.code = fmt::format("#include \"{}\"\n", include) + desc.code;
		}

		desc.source      = Path::GetInstance().GetFileExtension(filename) == ".hlsl" ? ShaderSource::HLSL : ShaderSource::GLSL;
		desc.stage       = stage;
		desc.entry_point = entry_point;
		desc.macros      = macros;

		if (cuda)
		{
			desc.target = ShaderTarget::PTX;
		}
		else
		{
			if (p_rhi_context->GetBackend() == "Vulkan")
			{
				desc.target = ShaderTarget::SPIRV;
			}
			else if (p_rhi_context->GetBackend() == "DX12")
			{
				desc.target = ShaderTarget::DXIL;
			}
		}

		shader_bin = ShaderCompiler::GetInstance().Compile(desc, meta);

		if (shader_bin.empty())
		{
			return nullptr;
		}

		SERIALIZE(
		    cache_path,
		    (size_t) std::filesystem::last_write_time(filename).time_since_epoch().count(),
		    shader_bin,
		    meta);

		std::unique_ptr<RHIShader> shader = p_rhi_context->CreateShader(entry_point, shader_bin, cuda);

		{
			std::lock_guard<std::mutex> lock(m_impl->mutex);
			m_impl->shader_meta_cache.emplace(shader.get(), std::move(meta));
			m_impl->shader_cache.emplace(hash, std::move(shader));
		}
		return m_impl->shader_cache.at(hash).get();
	}

	return nullptr;
}

ShaderMeta ShaderBuilder::RequireShaderMeta(RHIShader *shader) const
{
	return m_impl->shader_meta_cache.at(shader);
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/ShaderCompiler/Private/ShaderCompiler.cpp
================================================
#include "ShaderCompiler.hpp"
#include "SpirvReflection.hpp"

#include <glslang/Include/ResourceLimits.h>
#include <glslang/SPIRV/GLSL.std.450.h>
#include <glslang/SPIRV/GlslangToSpv.h>

#include <spirv_cross/spirv_hlsl.hpp>

#include <wrl.h>

#include <dxcapi.h>

#include <slang.h>

using Microsoft::WRL::ComPtr;

namespace glslang
{
const TBuiltInResource DefaultTBuiltInResource = {
    /* .MaxLights = */ 32,
    /* .MaxClipPlanes = */ 6,
    /* .MaxTextureUnits = */ 32,
    /* .MaxTextureCoords = */ 32,
    /* .MaxVertexAttribs = */ 64,
    /* .MaxVertexUniformComponents = */ 4096,
    /* .MaxVaryingFloats = */ 64,
    /* .MaxVertexTextureImageUnits = */ 32,
    /* .MaxCombinedTextureImageUnits = */ 80,
    /* .MaxTextureImageUnits = */ 32,
    /* .MaxFragmentUniformComponents = */ 4096,
    /* .MaxDrawBuffers = */ 32,
    /* .MaxVertexUniformVectors = */ 128,
    /* .MaxVaryingVectors = */ 8,
    /* .MaxFragmentUniformVectors = */ 16,
    /* .MaxVertexOutputVectors = */ 16,
    /* .MaxFragmentInputVectors = */ 15,
    /* .MinProgramTexelOffset = */ -8,
    /* .MaxProgramTexelOffset = */ 7,
    /* .MaxClipDistances = */ 8,
    /* .MaxComputeWorkGroupCountX = */ 65535,
    /* .MaxComputeWorkGroupCountY = */ 65535,
    /* .MaxComputeWorkGroupCountZ = */ 65535,
    /* .MaxComputeWorkGroupSizeX = */ 1024,
    /* .MaxComputeWorkGroupSizeY = */ 1024,
    /* .MaxComputeWorkGroupSizeZ = */ 64,
    /* .MaxComputeUniformComponents = */ 1024,
    /* .MaxComputeTextureImageUnits = */ 16,
    /* .MaxComputeImageUniforms = */ 8,
    /* .MaxComputeAtomicCounters = */ 8,
    /* .MaxComputeAtomicCounterBuffers = */ 1,
    /* .MaxVaryingComponents = */ 60,
    /* .MaxVertexOutputComponents = */ 64,
    /* .MaxGeometryInputComponents = */ 64,
    /* .MaxGeometryOutputComponents = */ 128,
    /* .MaxFragmentInputComponents = */ 128,
    /* .MaxImageUnits = */ 8,
    /* .MaxCombinedImageUnitsAndFragmentOutputs = */ 8,
    /* .MaxCombinedShaderOutputResources = */ 8,
    /* .MaxImageSamples = */ 0,
    /* .MaxVertexImageUniforms = */ 0,
    /* .MaxTessControlImageUniforms = */ 0,
    /* .MaxTessEvaluationImageUniforms = */ 0,
    /* .MaxGeometryImageUniforms = */ 0,
    /* .MaxFragmentImageUniforms = */ 8,
    /* .MaxCombinedImageUniforms = */ 8,
    /* .MaxGeometryTextureImageUnits = */ 16,
    /* .MaxGeometryOutputVertices = */ 256,
    /* .MaxGeometryTotalOutputComponents = */ 1024,
    /* .MaxGeometryUniformComponents = */ 1024,
    /* .MaxGeometryVaryingComponents = */ 64,
    /* .MaxTessControlInputComponents = */ 128,
    /* .MaxTessControlOutputComponents = */ 128,
    /* .MaxTessControlTextureImageUnits = */ 16,
    /* .MaxTessControlUniformComponents = */ 1024,
    /* .MaxTessControlTotalOutputComponents = */ 4096,
    /* .MaxTessEvaluationInputComponents = */ 128,
    /* .MaxTessEvaluationOutputComponents = */ 128,
    /* .MaxTessEvaluationTextureImageUnits = */ 16,
    /* .MaxTessEvaluationUniformComponents = */ 1024,
    /* .MaxTessPatchComponents = */ 120,
    /* .MaxPatchVertices = */ 32,
    /* .MaxTessGenLevel = */ 64,
    /* .MaxViewports = */ 16,
    /* .MaxVertexAtomicCounters = */ 0,
    /* .MaxTessControlAtomicCounters = */ 0,
    /* .MaxTessEvaluationAtomicCounters = */ 0,
    /* .MaxGeometryAtomicCounters = */ 0,
    /* .MaxFragmentAtomicCounters = */ 8,
    /* .MaxCombinedAtomicCounters = */ 8,
    /* .MaxAtomicCounterBindings = */ 1,
    /* .MaxVertexAtomicCounterBuffers = */ 0,
    /* .MaxTessControlAtomicCounterBuffers = */ 0,
    /* .MaxTessEvaluationAtomicCounterBuffers = */ 0,
    /* .MaxGeometryAtomicCounterBuffers = */ 0,
    /* .MaxFragmentAtomicCounterBuffers = */ 1,
    /* .MaxCombinedAtomicCounterBuffers = */ 1,
    /* .MaxAtomicCounterBufferSize = */ 16384,
    /* .MaxTransformFeedbackBuffers = */ 4,
    /* .MaxTransformFeedbackInterleavedComponents = */ 64,
    /* .MaxCullDistances = */ 8,
    /* .MaxCombinedClipAndCullDistances = */ 8,
    /* .MaxSamples = */ 4,
    /* .maxMeshOutputVerticesNV= */ 256,
    /* .maxMeshOutputPrimitivesNV= */ 512,
    /* .maxMeshWorkGroupSizeX_NV= */ 32,
    /* .maxMeshWorkGroupSizeY_NV= */ 1,
    /* .maxMeshWorkGroupSizeZ_NV= */ 1,
    /* .maxTaskWorkGroupSizeX_NV= */ 32,
    /* .maxTaskWorkGroupSizeY_NV= */ 1,
    /* .maxTaskWorkGroupSizeZ_NV= */ 1,
    /* .maxMeshViewCountNV= */ 4,
    /* .maxMeshOutputVerticesEXT= */ 256,
    /* .maxMeshOutputPrimitivesEXT= */ 512,
    /* .maxMeshWorkGroupSizeX_EXT= */ 32,
    /* .maxMeshWorkGroupSizeY_EXT= */ 32,
    /* .maxMeshWorkGroupSizeZ_EXT= */ 32,
    /* .maxTaskWorkGroupSizeX_EXT= */ 32,
    /* .maxTaskWorkGroupSizeY_EXT= */ 32,
    /* .maxTaskWorkGroupSizeZ_EXT= */ 32,
    /* .maxMeshViewCountEXT= */ 4,
    /* .maxDualSourceDrawBuffersEXT= */ 1,

    /* .limits = */ {
        /* .nonInductiveForLoops = */ true,
        /* .whileLoops = */ true,
        /* .doWhileLoops = */ 1,
        /* .generalUniformIndexing = */ 1,
        /* .generalAttributeMatrixVectorIndexing = */ 1,
        /* .generalVaryingIndexing = */ 1,
        /* .generalSamplerIndexing = */ 1,
        /* .generalVariableIndexing = */ 1,
        /* .generalConstantMatrixVectorIndexing = */ 1,
    }};
}

namespace Ilum
{
struct ShaderCompiler::Impl
{
	ComPtr<IDxcCompiler3>      DXCCompiler           = nullptr;
	ComPtr<IDxcUtils>          DXCUtils              = nullptr;
	ComPtr<IDxcIncludeHandler> DefaultIncludeHandler = nullptr;
	SlangSession              *Session               = nullptr;
};

std::wstring to_wstring(const std::string &str)
{
	const auto slength = static_cast<int>(str.length()) + 1;
	const auto len     = MultiByteToWideChar(CP_ACP, 0, str.c_str(), slength, nullptr, 0);
	const auto buf     = new wchar_t[len];
	MultiByteToWideChar(CP_ACP, 0, str.c_str(), slength, buf, len);
	std::wstring result(buf);
	delete[] buf;
	return result;
}

inline std::string GetTargetProfile(RHIShaderStage stage)
{
	switch (stage)
	{
		case RHIShaderStage::Vertex:
			return "vs_6_7";
		case RHIShaderStage::Fragment:
			return "ps_6_7";
		case RHIShaderStage::TessellationControl:
			return "hs_6_7";
		case RHIShaderStage::TessellationEvaluation:
			return "ds_6_7";
		case RHIShaderStage::Geometry:
			return "gs_6_7";
		case RHIShaderStage::Compute:
			return "cs_6_7";
		case RHIShaderStage::RayGen:
		case RHIShaderStage::AnyHit:
		case RHIShaderStage::ClosestHit:
		case RHIShaderStage::Miss:
		case RHIShaderStage::Intersection:
		case RHIShaderStage::Callable:
			return "lib_6_7";
		case RHIShaderStage::Mesh:
			return "ms_6_7";
		case RHIShaderStage::Task:
			return "as_6_7";
		default:
			break;
	}
	return "";
}

inline EShLanguage GetShaderLanguage(RHIShaderStage stage)
{
	switch (stage)
	{
		case RHIShaderStage::Vertex:
			return EShLangVertex;
		case RHIShaderStage::Fragment:
			return EShLangFragment;
		case RHIShaderStage::TessellationControl:
			return EShLangTessControl;
		case RHIShaderStage::TessellationEvaluation:
			return EShLangTessEvaluation;
		case RHIShaderStage::Geometry:
			return EShLangGeometry;
		case RHIShaderStage::Compute:
			return EShLangCompute;
		case RHIShaderStage::RayGen:
			return EShLangRayGen;
		case RHIShaderStage::AnyHit:
			return EShLangAnyHit;
		case RHIShaderStage::ClosestHit:
			return EShLangClosestHit;
		case RHIShaderStage::Miss:
			return EShLangMiss;
		case RHIShaderStage::Intersection:
			return EShLangIntersect;
		case RHIShaderStage::Callable:
			return EShLangCallable;
		case RHIShaderStage::Mesh:
			return EShLangMesh;
		case RHIShaderStage::Task:
			return EShLangTask;
		default:
			break;
	}
	return EShLangCount;
}

template <ShaderSource Src, ShaderTarget Tar>
inline std::vector<uint8_t> CompileShader(ShaderCompiler::Impl *impl, const ShaderDesc &desc)
{
	return {};
}

template <>
std::vector<uint8_t> CompileShader<ShaderSource::GLSL, ShaderTarget::SPIRV>(ShaderCompiler::Impl *impl, const ShaderDesc &desc)
{
	EShMessages msgs = static_cast<EShMessages>(EShMsgDefault | EShMsgVulkanRules | EShMsgSpvRules);

	EShLanguage lang = GetShaderLanguage(desc.stage);

	std::string info_log = "";

	const char *file_name_list[1] = {""};
	const char *shader_source     = reinterpret_cast<const char *>(desc.code.data());

	glslang::TShader shader(lang);
	shader.setStringsWithLengthsAndNames(&shader_source, nullptr, file_name_list, 1);
	shader.setEntryPoint(desc.entry_point.c_str());
	shader.setSourceEntryPoint(desc.entry_point.c_str());
	shader.setEnvTarget(glslang::EShTargetSpv, glslang::EShTargetSpv_1_5);
	shader.setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_3);
	for (const auto &macro : desc.macros)
	{
		shader.setPreamble(macro.c_str());
	}

	if (!shader.parse(&glslang::DefaultTBuiltInResource, 100, false, msgs))
	{
		info_log = std::string(shader.getInfoLog()) + "\n" + std::string(shader.getInfoDebugLog());
		LOG_ERROR(info_log);
		return {};
	}

	// Add shader to a new program
	glslang::TProgram program;
	program.addShader(&shader);

	// Link program
	if (!program.link(msgs))
	{
		info_log = std::string(program.getInfoLog()) + "\n" + std::string(program.getInfoDebugLog());
		LOG_ERROR(info_log);
		return {};
	}

	// Save info log
	if (shader.getInfoLog())
	{
		info_log = std::string(shader.getInfoLog()) + "\n" + std::string(shader.getInfoDebugLog());
	}

	if (program.getInfoLog())
	{
		info_log = std::string(program.getInfoLog()) + "\n" + std::string(program.getInfoDebugLog());
	}

	glslang::TIntermediate *intermediate = program.getIntermediate(lang);

	if (!intermediate)
	{
		info_log += "Failed to get shared intermediate code!\n";
		LOG_ERROR(info_log);
		return {};
	}

	spv::SpvBuildLogger logger;

	std::vector<uint32_t> spirv;
	std::vector<uint8_t>  result;

	glslang::GlslangToSpv(*intermediate, spirv, &logger);
	result.resize(spirv.size() * 4);
	std::memcpy(result.data(), spirv.data(), result.size());

	return result;
}

template <>
std::vector<uint8_t> CompileShader<ShaderSource::HLSL, ShaderTarget::SPIRV>(ShaderCompiler::Impl *impl, const ShaderDesc &desc)
{
	DxcBuffer                dxc_buffer    = {};
	ComPtr<IDxcBlobEncoding> blob_encoding = nullptr;

	std::string shader_code = std::string(desc.code.c_str());

	{
		if (FAILED(impl->DXCUtils->CreateBlobFromPinned(shader_code.data(), static_cast<uint32_t>(shader_code.size()), CP_UTF8, &blob_encoding)))
		{
			LOG_ERROR("Failed to load shader source.");
			return {};
		}

		dxc_buffer.Ptr      = blob_encoding->GetBufferPointer();
		dxc_buffer.Size     = blob_encoding->GetBufferSize();
		dxc_buffer.Encoding = DXC_CP_ACP;
	}

	std::vector<std::wstring> arguments;

	// Compile arguments
	arguments.emplace_back(L"-E");
	arguments.emplace_back(to_wstring(desc.entry_point));
	arguments.emplace_back(L"-T");
	arguments.emplace_back(to_wstring(GetTargetProfile(desc.stage)));
	arguments.emplace_back(L"-I");
	arguments.emplace_back(to_wstring(Path::GetInstance().GetCurrent() + "/Source/Shaders"));
	arguments.emplace_back(L"-I");
	arguments.emplace_back(to_wstring(Path::GetInstance().GetCurrent() + "/Asset/Material"));
	arguments.emplace_back(L"-I");
	arguments.emplace_back(to_wstring(Path::GetInstance().GetCurrent()));
	arguments.emplace_back(L"-I");
	arguments.emplace_back(to_wstring(Path::GetInstance().GetCurrent() + "/" + Path::GetInstance().GetFileDirectory(desc.path)));
	arguments.emplace_back(L"-HV 2021");
	arguments.emplace_back(to_wstring("-DRUNTIME"));
	arguments.emplace_back(L"-spirv");
	arguments.emplace_back(L"-fspv-target-env=vulkan1.3");
	arguments.emplace_back(L"-fspv-extension=SPV_KHR_ray_tracing");
	arguments.emplace_back(L"-fspv-extension=SPV_KHR_ray_query");
	arguments.emplace_back(L"-fspv-extension=SPV_KHR_shader_draw_parameters");
	arguments.emplace_back(L"-fspv-extension=SPV_EXT_descriptor_indexing");
	arguments.emplace_back(L"-fspv-extension=SPV_EXT_shader_viewport_index_layer");
	arguments.emplace_back(L"-fspv-extension=SPV_EXT_mesh_shader");
	arguments.emplace_back(L"-fspv-extension=SPV_AMD_shader_explicit_vertex_parameter");
	arguments.emplace_back(L"-disable-payload-qualifiers");

	for (const auto &macro : desc.macros)
	{
		arguments.emplace_back(to_wstring(std::string("-D") + macro));
	}

	// Convert arguments to LPCWSTR
	std::vector<LPCWSTR> arguments_lpcwstr;
	arguments_lpcwstr.reserve(arguments.size());
	for (const std::wstring &wstr : arguments)
	{
		arguments_lpcwstr.emplace_back(wstr.c_str());
	}

	// Compile
	IDxcResult *dxc_result = nullptr;
	impl->DXCCompiler->Compile(
	    &dxc_buffer,
	    arguments_lpcwstr.data(),
	    static_cast<uint32_t>(arguments_lpcwstr.size()),
	    impl->DefaultIncludeHandler.Get(),
	    IID_PPV_ARGS(&dxc_result));

	// Get error buffer
	IDxcBlobEncoding *error_buffer = nullptr;
	HRESULT           result       = dxc_result->GetErrorBuffer(&error_buffer);
	if (SUCCEEDED(result))
	{
		// Log info, warnings and errors
		std::stringstream ss(std::string(static_cast<char *>(error_buffer->GetBufferPointer()), error_buffer->GetBufferSize()));
		std::string       line;
		while (getline(ss, line, '\n'))
		{
			if (line.find("error") != std::string::npos)
			{
				LOG_ERROR("{}", line);
			}
			else if (line.find("warning") != std::string::npos)
			{
				LOG_WARN("{}", line);
			}
			else if (!line.empty())
			{
				LOG_INFO("{}", line);
			}
		}
	}
	else
	{
		LOG_ERROR("Failed to get error buffer");
	}

	// Release error buffer
	if (error_buffer)
	{
		error_buffer->Release();
		error_buffer = nullptr;
	}

	// Return status
	dxc_result->GetStatus(&result);

	// Check for errors
	if (result != S_OK)
	{
		LOG_ERROR("Failed to compile");

		if (dxc_result)
		{
			dxc_result->Release();
			dxc_result = nullptr;
		}
		else
		{
			return {};
		}
	}

	IDxcBlob *shader_buffer = nullptr;
	dxc_result->GetResult(&shader_buffer);

	std::vector<uint8_t> spirv(shader_buffer->GetBufferSize());
	std::memcpy(spirv.data(), shader_buffer->GetBufferPointer(), shader_buffer->GetBufferSize());

	return spirv;
}

template <>
std::vector<uint8_t> CompileShader<ShaderSource::HLSL, ShaderTarget::DXIL>(ShaderCompiler::Impl *impl, const ShaderDesc &desc)
{
	DxcBuffer                dxc_buffer    = {};
	ComPtr<IDxcBlobEncoding> blob_encoding = nullptr;

	std::string shader_code = std::string(desc.code.c_str());

	{
		if (FAILED(impl->DXCUtils->CreateBlobFromPinned(shader_code.c_str(), static_cast<uint32_t>(shader_code.size()), CP_UTF8, &blob_encoding)))
		{
			LOG_ERROR("Failed to load shader source.");
			return {};
		}

		dxc_buffer.Ptr      = blob_encoding->GetBufferPointer();
		dxc_buffer.Size     = blob_encoding->GetBufferSize();
		dxc_buffer.Encoding = DXC_CP_ACP;
	}

	std::vector<std::wstring> arguments;

	// Compile arguments
	arguments.emplace_back(L"-E");
	arguments.emplace_back(to_wstring(desc.entry_point));
	arguments.emplace_back(L"-T");
	arguments.emplace_back(to_wstring(GetTargetProfile(desc.stage)));
	arguments.emplace_back(L"-I");
	arguments.emplace_back(to_wstring(Path::GetInstance().GetCurrent() + "/Source/Shaders"));

	for (const auto &macro : desc.macros)
	{
		arguments.emplace_back(to_wstring(std::string("-D") + macro));
	}

	// Convert arguments to LPCWSTR
	std::vector<LPCWSTR> arguments_lpcwstr;
	arguments_lpcwstr.reserve(arguments.size());
	for (const std::wstring &wstr : arguments)
	{
		arguments_lpcwstr.emplace_back(wstr.c_str());
	}

	// Compile
	IDxcResult *dxc_result = nullptr;
	impl->DXCCompiler->Compile(
	    &dxc_buffer,
	    arguments_lpcwstr.data(),
	    static_cast<uint32_t>(arguments_lpcwstr.size()),
	    impl->DefaultIncludeHandler.Get(),
	    IID_PPV_ARGS(&dxc_result));

	// Get error buffer
	IDxcBlobEncoding *error_buffer = nullptr;
	HRESULT           result       = dxc_result->GetErrorBuffer(&error_buffer);
	if (SUCCEEDED(result))
	{
		// Log info, warnings and errors
		std::stringstream ss(std::string(static_cast<char *>(error_buffer->GetBufferPointer()), error_buffer->GetBufferSize()));
		std::string       line;
		while (getline(ss, line, '\n'))
		{
			if (line.find("error") != std::string::npos)
			{
				LOG_ERROR("{}", line);
			}
			else if (line.find("warning") != std::string::npos)
			{
				LOG_WARN("{}", line);
			}
			else if (!line.empty())
			{
				LOG_INFO("{}", line);
			}
		}
	}
	else
	{
		LOG_ERROR("Failed to get error buffer");
	}

	// Release error buffer
	if (error_buffer)
	{
		error_buffer->Release();
		error_buffer = nullptr;
	}

	// Return status
	dxc_result->GetStatus(&result);

	// Check for errors
	if (result != S_OK)
	{
		LOG_ERROR("Failed to compile");

		if (dxc_result)
		{
			dxc_result->Release();
			dxc_result = nullptr;
		}
		else
		{
			return {};
		}
	}

	IDxcBlob *shader_buffer = nullptr;
	dxc_result->GetResult(&shader_buffer);

	std::vector<uint8_t> dxil(shader_buffer->GetBufferSize());
	std::memcpy(dxil.data(), shader_buffer->GetBufferPointer(), shader_buffer->GetBufferSize());

	return dxil;
}

template <>
std::vector<uint8_t> CompileShader<ShaderSource::HLSL, ShaderTarget::PTX>(ShaderCompiler::Impl *impl, const ShaderDesc &desc)
{
	SlangCompileRequest *request = spCreateCompileRequest(impl->Session);

	spSetCodeGenTarget(request, SLANG_PTX);

	int translationUnitIndex = spAddTranslationUnit(request, SLANG_SOURCE_LANGUAGE_SLANG, "");
	spAddTranslationUnitSourceString(request, translationUnitIndex, nullptr, std::string(desc.code.c_str()).c_str());
	int entryPointIndex = spAddEntryPoint(request, translationUnitIndex, desc.entry_point.c_str(), SLANG_STAGE_COMPUTE);

	int anyErrors = spCompile(request);

	if (anyErrors != 0)
	{
		char const *diagnostics = spGetDiagnosticOutput(request);
		LOG_INFO("Shader Compile Error: {}", diagnostics);
		return {};
	}

	std::string ptx_str = spGetEntryPointSource(request, entryPointIndex);

	spDestroyCompileRequest(request);

	std::vector<uint8_t> ptx(ptx_str.size());
	std::memcpy(ptx.data(), ptx_str.data(), ptx_str.size());

	return ptx;
}

inline std::string SpirvCrossToHLSL(const std::vector<uint8_t> &spirv)
{
	std::vector<uint32_t> spirv32;
	spirv32.resize(spirv.size() / 4);
	std::memcpy(spirv32.data(), spirv.data(), spirv.size());

	spirv_cross::CompilerHLSL hlsl_compiler(spirv32);

	spirv_cross::CompilerHLSL::Options options;
	options.shader_model         = 66;
	options.use_entry_point_name = true;

	hlsl_compiler.set_hlsl_options(options);

	return hlsl_compiler.compile();
}

ShaderCompiler::ShaderCompiler()
{
	m_impl = new Impl;

	// Init glslang
	glslang::InitializeProcess();

	// Init dxc
	PluginManager::GetInstance().Call("Source/External/dxc/bin/x64/dxcompiler.dll", "DxcCreateInstance", CLSID_DxcUtils, IID_PPV_ARGS(&m_impl->DXCUtils));
	PluginManager::GetInstance().Call("Source/External/dxc/bin/x64/dxcompiler.dll", "DxcCreateInstance", CLSID_DxcCompiler, IID_PPV_ARGS(&m_impl->DXCCompiler));
	// DxcCreateInstance(CLSID_DxcUtils, IID_PPV_ARGS(&m_impl->DXCUtils));
	// DxcCreateInstance(CLSID_DxcCompiler, IID_PPV_ARGS(&m_impl->DXCCompiler));

	m_impl->DXCUtils->CreateDefaultIncludeHandler(&m_impl->DefaultIncludeHandler);

	// Init slang
	m_impl->Session = spCreateSession(NULL);
}

ShaderCompiler::~ShaderCompiler()
{
	glslang::FinalizeProcess();

	// It's weird
	m_impl->DXCUtils.Detach();
	m_impl->DXCCompiler.Detach();
	m_impl->DefaultIncludeHandler.Detach();

	spDestroySession(m_impl->Session);
	m_impl->Session = nullptr;

	delete m_impl;
	m_impl = nullptr;
}

ShaderCompiler &ShaderCompiler::GetInstance()
{
	static ShaderCompiler shader_compiler;
	return shader_compiler;
}

std::vector<uint8_t> ShaderCompiler::Compile(const ShaderDesc &desc, ShaderMeta &meta)
{
	// Compile to SPIRV
	std::vector<uint8_t> spirv;

	if (desc.source == ShaderSource::GLSL)
	{
		spirv = CompileShader<ShaderSource::GLSL, ShaderTarget::SPIRV>(m_impl, desc);
	}
	else if (desc.source == ShaderSource::HLSL)
	{
		spirv = CompileShader<ShaderSource::HLSL, ShaderTarget::SPIRV>(m_impl, desc);
	}

	meta = SpirvReflection::GetInstance().Reflect(spirv);

	if (desc.target == ShaderTarget::SPIRV)
	{
		return spirv;
	}
	else if (desc.target == ShaderTarget::DXIL)
	{
		if (desc.source == ShaderSource::GLSL)
		{
			return CompileShader<ShaderSource::GLSL, ShaderTarget::DXIL>(m_impl, desc);
		}
		else
		{
			return CompileShader<ShaderSource::HLSL, ShaderTarget::DXIL>(m_impl, desc);
		}
	}
	else if (desc.target == ShaderTarget::PTX)
	{
		if (desc.source == ShaderSource::GLSL)
		{
			return CompileShader<ShaderSource::GLSL, ShaderTarget::PTX>(m_impl, desc);
		}
		else
		{
			std::string hlsl = SpirvCrossToHLSL(spirv);

			{
				// Remove "packoffset"
				hlsl = std::regex_replace(hlsl, std::regex(": +packoffset*.+;"), ";");

				// Remove input parameter
				size_t pos   = hlsl.find("struct SPIRV_Cross_Input");
				size_t left  = hlsl.find_first_of("{", pos) + 1;
				size_t right = hlsl.find_first_of("}", left);

				std::string input_struct = hlsl.substr(left, right - left);

				right        = input_struct.find_last_of(";");
				input_struct = input_struct.substr(0, right);

				std::replace(input_struct.begin(), input_struct.end(), ';', ',');
				input_struct = std::regex_replace(input_struct, std::regex("gl_"), "glx");

				hlsl = std::regex_replace(hlsl, std::regex("SPIRV_Cross_Input stage_input"), input_struct);
				hlsl = std::regex_replace(hlsl, std::regex("stage_input.gl_"), "glx");

				// Order may change, so re-reflect it
				ShaderMeta before_meta = std::move(meta);

				ShaderDesc hlsl_desc = desc;
				hlsl_desc.code       = hlsl;
				meta                 = SpirvReflection::GetInstance().Reflect(CompileShader<ShaderSource::HLSL, ShaderTarget::SPIRV>(m_impl, hlsl_desc));

				// Fix name
				for (auto &descriptor : meta.descriptors)
				{
					for (auto &before_descriptor : before_meta.descriptors)
					{
						if (descriptor == before_descriptor)
						{
							descriptor.name = before_descriptor.name;
							break;
						}
					}
				}
			}

			ShaderDesc hlsl_desc = desc;
			hlsl_desc.code       = hlsl;
			return CompileShader<ShaderSource::HLSL, ShaderTarget::PTX>(m_impl, hlsl_desc);
		}
	}

	return {};
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/ShaderCompiler/Private/SpirvReflection.cpp
================================================
#include "SpirvReflection.hpp"

#include <spirv_reflect.h>

namespace Ilum
{
inline static std::unordered_map<SpvReflectShaderStageFlagBits, RHIShaderStage> ShaderStageMap = {
    {SPV_REFLECT_SHADER_STAGE_VERTEX_BIT, RHIShaderStage::Vertex},
    {SPV_REFLECT_SHADER_STAGE_TESSELLATION_CONTROL_BIT, RHIShaderStage::TessellationControl},
    {SPV_REFLECT_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, RHIShaderStage::TessellationEvaluation},
    {SPV_REFLECT_SHADER_STAGE_GEOMETRY_BIT, RHIShaderStage::Geometry},
    {SPV_REFLECT_SHADER_STAGE_FRAGMENT_BIT, RHIShaderStage::Fragment},
    {SPV_REFLECT_SHADER_STAGE_COMPUTE_BIT, RHIShaderStage::Compute},
    {SPV_REFLECT_SHADER_STAGE_TASK_BIT_NV, RHIShaderStage::Task},
    {SPV_REFLECT_SHADER_STAGE_MESH_BIT_NV, RHIShaderStage::Mesh},
    {SPV_REFLECT_SHADER_STAGE_RAYGEN_BIT_KHR, RHIShaderStage::RayGen},
    {SPV_REFLECT_SHADER_STAGE_ANY_HIT_BIT_KHR, RHIShaderStage::AnyHit},
    {SPV_REFLECT_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, RHIShaderStage::ClosestHit},
    {SPV_REFLECT_SHADER_STAGE_MISS_BIT_KHR, RHIShaderStage::Miss},
    {SPV_REFLECT_SHADER_STAGE_INTERSECTION_BIT_KHR, RHIShaderStage::Intersection},
    {SPV_REFLECT_SHADER_STAGE_CALLABLE_BIT_KHR, RHIShaderStage::Callable},
};

inline static std::unordered_map<SpvReflectDescriptorType, DescriptorType> DescriptorTypeMap = {
    {SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLER, DescriptorType::Sampler},
    {SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE, DescriptorType::TextureSRV},
    {SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE, DescriptorType::TextureUAV},
    {SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER, DescriptorType::ConstantBuffer},
    {SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER, DescriptorType::StructuredBuffer},
    {SPV_REFLECT_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, DescriptorType::AccelerationStructure},
};

inline static std::unordered_map<SpvReflectFormat, RHIFormat> FormatMap = {
    {SPV_REFLECT_FORMAT_UNDEFINED, RHIFormat::Undefined},
    {SPV_REFLECT_FORMAT_R32_UINT, RHIFormat::R32_UINT},
    {SPV_REFLECT_FORMAT_R32_SINT, RHIFormat::R32_SINT},
    {SPV_REFLECT_FORMAT_R32_SFLOAT, RHIFormat::R32_FLOAT},
    {SPV_REFLECT_FORMAT_R32G32_UINT, RHIFormat::R32G32_UINT},
    {SPV_REFLECT_FORMAT_R32G32_SINT, RHIFormat::R32G32_SINT},
    {SPV_REFLECT_FORMAT_R32G32_SFLOAT, RHIFormat::R32G32_FLOAT},
    {SPV_REFLECT_FORMAT_R32G32B32_UINT, RHIFormat::R32G32B32_UINT},
    {SPV_REFLECT_FORMAT_R32G32B32_SINT, RHIFormat::R32G32B32_SINT},
    {SPV_REFLECT_FORMAT_R32G32B32_SFLOAT, RHIFormat::R32G32B32_FLOAT},
    {SPV_REFLECT_FORMAT_R32G32B32A32_UINT, RHIFormat::R32G32B32A32_UINT},
    {SPV_REFLECT_FORMAT_R32G32B32A32_SINT, RHIFormat::R32G32B32A32_SINT},
    {SPV_REFLECT_FORMAT_R32G32B32A32_SFLOAT, RHIFormat::R32G32B32A32_FLOAT},
};

SpirvReflection &SpirvReflection::GetInstance()
{
	static SpirvReflection spirv_reflection;
	return spirv_reflection;
}

ShaderMeta SpirvReflection::Reflect(const std::vector<uint8_t> &spirv)
{
	SpvReflectShaderModule shader_module;
	spvReflectCreateShaderModule(spirv.size(), spirv.data(), &shader_module);

	ShaderMeta meta_info = {};

	// Descriptor
	for (uint32_t i = 0; i < shader_module.descriptor_binding_count; i++)
	{
		const auto &descriptor_binding = shader_module.descriptor_bindings[i];

		meta_info.descriptors.push_back(ShaderMeta::Descriptor{
			descriptor_binding.spirv_id,
		    descriptor_binding.name,
		    descriptor_binding.count,
		    descriptor_binding.set,
		    descriptor_binding.binding,
		    DescriptorTypeMap[descriptor_binding.descriptor_type],
		    ShaderStageMap[shader_module.shader_stage]});

		HashCombine(meta_info.hash,
		            descriptor_binding.name,
		            descriptor_binding.count,
		            descriptor_binding.set,
		            descriptor_binding.binding,
		            DescriptorTypeMap[descriptor_binding.descriptor_type],
		            ShaderStageMap[shader_module.shader_stage]);
	}

	// Constant
	for (uint32_t i = 0; i < shader_module.push_constant_block_count; i++)
	{
		for (uint32_t j = 0; j < shader_module.push_constant_blocks[i].member_count; j++)
		{
			auto member = shader_module.push_constant_blocks[i].members[j];

			meta_info.constants.push_back(ShaderMeta::Constant{
				member.spirv_id,
			    member.name,
			    member.size,
			    member.absolute_offset,
			    ShaderStageMap[shader_module.shader_stage]});

			HashCombine(
			    meta_info.hash,
			    member.name,
			    member.size,
			    member.absolute_offset,
			    ShaderStageMap[shader_module.shader_stage]);
		}
	}

	// Variable
	if (shader_module.shader_stage & SPV_REFLECT_SHADER_STAGE_VERTEX_BIT)
	{
		for (uint32_t i = 0; i < shader_module.input_variable_count; i++)
		{
			meta_info.inputs.push_back(ShaderMeta::Variable{
			    shader_module.input_variables[i]->spirv_id,
			    shader_module.input_variables[i]->location,
			    FormatMap[shader_module.input_variables[i]->format]
			});
		}
	}
	else if (shader_module.shader_stage & SPV_REFLECT_SHADER_STAGE_FRAGMENT_BIT)
	{
		for (uint32_t i = 0; i < shader_module.output_variable_count; i++)
		{
			meta_info.outputs.push_back(ShaderMeta::Variable{
			    shader_module.output_variables[i]->spirv_id,
			    shader_module.output_variables[i]->location,
			    FormatMap[shader_module.output_variables[i]->format]});
		}
	}

	spvReflectDestroyShaderModule(&shader_module);

	return meta_info;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/ShaderCompiler/Public/ShaderCompiler/Precompile.hpp
================================================
#pragma once

#include <Core/Core.hpp>


================================================
FILE: Source/Runtime/Render/ShaderCompiler/Public/ShaderCompiler/ShaderBuilder.hpp
================================================
#pragma once

#include "Precompile.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class  ShaderBuilder
{
  public:
	ShaderBuilder(RHIContext *context);

	~ShaderBuilder();

	RHIShader *RequireShader(const std::string &filename, const std::string &entry_point, RHIShaderStage stage, std::vector<std::string> &&macros = {}, std::vector<std::string> &&includes = {}, bool cuda = false, bool force_recompile = false);

	ShaderMeta RequireShaderMeta(RHIShader *shader) const;

  private:
	RHIContext *p_rhi_context = nullptr;

	struct Impl;

	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/ShaderCompiler/Public/ShaderCompiler/ShaderCompiler.hpp
================================================
#pragma once

#include "Precompile.hpp"

#include <RHI/RHIDefinitions.hpp>
#include <RHI/RHIShader.hpp>

namespace Ilum
{
enum class ShaderSource
{
	HLSL,
	GLSL
};

enum class ShaderTarget
{
	SPIRV,
	DXIL,
	PTX
};

struct ShaderDesc
{
	std::string    code;
	std::string    path;
	ShaderSource   source;
	ShaderTarget   target;
	RHIShaderStage stage;
	std::string    entry_point;

	std::vector<std::string> macros = {};
};

class ShaderCompiler
{
  public:
	ShaderCompiler();

	~ShaderCompiler();

	static ShaderCompiler &GetInstance();

	std::vector<uint8_t> Compile(const ShaderDesc &desc, ShaderMeta &meta);

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};

}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/ShaderCompiler/Public/ShaderCompiler/SpirvReflection.hpp
================================================
#pragma once

#include "Precompile.hpp"

#include <RHI/RHIShader.hpp>

namespace Ilum
{
class  SpirvReflection
{
  public:
	static SpirvReflection &GetInstance();

	ShaderMeta Reflect(const std::vector<uint8_t> &spirv);
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Render/xmake.lua
================================================
add_runtime_moulde(
    "ShaderCompiler",
    "Runtime/Render",
    false, 
    {"Core", "RHI"}, 
    {"glslang", "spirv-cross", "directxshadercompiler", "slang", "spirv-reflect"}
)

add_runtime_moulde(
    "RenderGraph",
    "Runtime/Render",
    false, 
    {"Core", "RHI", "ShaderCompiler"}, 
    {}
)

add_runtime_moulde(
    "Material",
    "Runtime/Render",
    false, 
    {"Core", "RHI"}, 
    {}
)

add_runtime_moulde(
    "Renderer",
    "Runtime/Render",
    false, 
    {"Core", "RHI", "ShaderCompiler", "RenderGraph", "Scene", "Geometry", "Resource", "Material"}, 
    {}
)


================================================
FILE: Source/Runtime/Resource/Private/Resource/Importer.cpp
================================================
#include "Importer.hpp"
#include "Resource/Prefab.hpp"
#include "Resource/Texture2D.hpp"
#include "Resource/Animation.hpp"

#include <Core/Plugin.hpp>

namespace Ilum
{
const std::map<ResourceType, std::map<std::string, std::string>> PluginMap = {
    {ResourceType::Texture2D,
     {
         {".png", "STB"},
         {".jpg", "STB"},
         {".jpeg", "STB"},
         {".bmp", "STB"},
         {".dds", "DDS"},
     }},
    {ResourceType::TextureCube,
     {
         {".hdr", "STB"},
     }},
    {ResourceType::Prefab,
     {
         {".obj", "Assimp"},
         {".gltf", "Assimp"},
         {".glb", "Assimp"},
         {".dae", "Assimp"},
         {".fbx", "Assimp"},
         {".ply", "Assimp"},
         {".blend", "Assimp"},
     }},
};

template <ResourceType Type>
std::unique_ptr<Importer<Type>> &Importer<Type>::GetInstance(const std::string &plugin)
{
	static std::unique_ptr<Importer<Type>> importer = std::unique_ptr<Importer<Type>>(PluginManager::GetInstance().Call<Importer<Type> *>(fmt::format("shared/Importer/Importer.{}.dll", plugin), "Create"));
	return importer;
}

template <ResourceType Type>
void Importer<Type>::Import(ResourceManager *manager, const std::string &path, RHIContext *rhi_context)
{
	return GetInstance(PluginMap.at(Type).at(Path::GetInstance().GetFileExtension(path)))->Import_(manager, path, rhi_context);
}

template class Importer<ResourceType::Prefab>;
template class Importer<ResourceType::Texture2D>;
template class Importer<ResourceType::TextureCube>;
template class Importer<ResourceType::Mesh>;
template class Importer<ResourceType::SkinnedMesh>;
template class Importer<ResourceType::Material>;
template class Importer<ResourceType::Animation>;
template class Importer<ResourceType::RenderPipeline>;
template class Importer<ResourceType::Scene>;
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/Animation.cpp
================================================
#include "Resource/Animation.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
struct Resource<ResourceType::Animation>::Impl
{
	std::vector<Bone> bones;

	std::unique_ptr<RHITexture> skinned_matrics = nullptr;
	std::unique_ptr<RHIBuffer>  bone_matrics    = nullptr;

	HierarchyNode hierarchy;

	float m_max_timestamp = 0.f;

	uint32_t m_bone_count = 0;

	uint32_t frame_count = 0;
};

Bone::Bone(
    const std::string         &name,
    uint32_t                   id,
    glm::mat4                  offset,
    std::vector<KeyPosition> &&positions,
    std::vector<KeyRotation> &&rotations,
    std::vector<KeyScale>    &&scales)
{
	m_name            = name;
	m_id              = id;
	m_offset          = offset;
	m_positions       = std::move(positions);
	m_rotations       = std::move(rotations);
	m_scales          = std::move(scales);
	m_local_transfrom = glm::mat4(1.f);

	if (!m_positions.empty())
	{
		m_max_timestamp = glm::max(m_max_timestamp, m_positions.back().time_stamp);
	}

	if (!m_rotations.empty())
	{
		m_max_timestamp = glm::max(m_max_timestamp, m_rotations.back().time_stamp);
	}

	if (!m_scales.empty())
	{
		m_max_timestamp = glm::max(m_max_timestamp, m_scales.back().time_stamp);
	}
}

void Bone::Update(float time)
{
	m_local_transfrom =
	    InterpolatePosition(time) *
	    InterpolateRotation(time) *
	    InterpolateScaling(time);
}

glm::mat4 Bone::GetLocalTransform() const
{
	return m_local_transfrom;
}

std::string Bone::GetBoneName() const
{
	return m_name;
}

uint32_t Bone::GetBoneID() const
{
	return m_id;
}

glm::mat4 Bone::GetBoneOffset() const
{
	return m_offset;
}

size_t Bone::GetPositionIndex(float time) const
{
	for (size_t index = 0; index < m_positions.size() - 1; index++)
	{
		if (time < m_positions[index + 1].time_stamp)
		{
			return index;
		}
	}
	return m_positions.size() - 2;
}

size_t Bone::GetRotationIndex(float time) const
{
	for (size_t index = 0; index < m_rotations.size() - 1; index++)
	{
		if (time < m_rotations[index + 1].time_stamp)
		{
			return index;
		}
	}
	return m_rotations.size() - 2;
}

size_t Bone::GetScaleIndex(float time) const
{
	for (size_t index = 0; index < m_scales.size() - 1; index++)
	{
		if (time < m_scales[index + 1].time_stamp)
		{
			return index;
		}
	}
	return m_scales.size() - 2;
}

glm::mat4 Bone::GetLocalTransform(float time) const
{
	glm::mat4 translation = InterpolatePosition(time);
	glm::mat4 rotation    = InterpolateRotation(time);
	glm::mat4 scale       = InterpolateScaling(time);
	return translation * rotation * scale;
}

glm::mat4 Bone::GetTransformedOffset(float time) const
{
	return GetLocalTransform() * m_offset;
}

float Bone::GetMaxTimeStamp() const
{
	return m_max_timestamp;
}

float Bone::GetScaleFactor(float last, float next, float time) const
{
	return (time - last) / (next - last);
}

glm::mat4 Bone::InterpolatePosition(float time) const
{
	if (m_positions.empty())
	{
		return glm::mat4(1.f);
	}

	if (m_positions.size() == 1)
	{
		return glm::translate(glm::mat4(1.f), m_positions[0].position);
	}

	size_t    p0             = GetPositionIndex(time);
	size_t    p1             = p0 + 1;
	float     scale_factor   = GetScaleFactor(m_positions[p0].time_stamp, m_positions[p1].time_stamp, glm::clamp(time, 0.f, m_positions.back().time_stamp));
	glm::vec3 final_position = glm::mix(m_positions[p0].position, m_positions[p1].position, scale_factor);

	return glm::translate(glm::mat4(1.f), final_position);
}

glm::mat4 Bone::InterpolateRotation(float time) const
{
	if (m_rotations.empty())
	{
		return glm::mat4(1.f);
	}

	if (m_rotations.size() == 1)
	{
		auto rotation = glm::normalize(m_rotations[0].orientation);
		return glm::toMat4(rotation);
	}

	size_t    p0             = GetRotationIndex(time);
	size_t    p1             = p0 + 1;
	float     scale_factor   = GetScaleFactor(m_rotations[p0].time_stamp, m_rotations[p1].time_stamp, glm::clamp(time, 0.f, m_rotations.back().time_stamp));
	glm::quat final_rotation = glm::slerp(m_rotations[p0].orientation, m_rotations[p1].orientation, scale_factor);
	final_rotation           = glm::normalize(final_rotation);

	return glm::toMat4(final_rotation);
}

glm::mat4 Bone::InterpolateScaling(float time) const
{
	if (m_scales.empty())
	{
		return glm::mat4(1.f);
	}

	if (m_scales.size() == 1)
	{
		return glm::scale(glm::mat4(1.f), m_scales[0].scale);
	}

	size_t    p0           = GetScaleIndex(time);
	size_t    p1           = p0 + 1;
	float     scale_factor = GetScaleFactor(m_scales[p0].time_stamp, m_scales[p1].time_stamp, glm::clamp(time, 0.f, m_scales.back().time_stamp));
	glm::vec3 final_scale  = glm::mix(m_scales[p0].scale, m_scales[p1].scale, scale_factor);

	return glm::scale(glm::mat4(1.f), final_scale);
}

Resource<ResourceType::Animation>::Resource(RHIContext *rhi_context, const std::string &name) :
    IResource(rhi_context, name, ResourceType::Animation)
{
}

Resource<ResourceType::Animation>::Resource(RHIContext *rhi_context, const std::string &name, std::vector<Bone> &&bones, HierarchyNode &&hierarchy) :
    IResource(name)
{
	m_impl = new Impl;

	m_impl->bones     = std::move(bones);
	m_impl->hierarchy = std::move(hierarchy);

	for (auto &bone : m_impl->bones)
	{
		m_impl->m_max_timestamp = glm::max(m_impl->m_max_timestamp, bone.GetMaxTimeStamp());
	}

	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE("Asset/BuildIn/animation.icon.asset", thumbnail_data);
	UpdateThumbnail(rhi_context, thumbnail_data);
	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Animation), thumbnail_data, m_impl->bones, m_impl->hierarchy, m_impl->m_max_timestamp);

	Bake(rhi_context);
}

const std::vector<Bone> &Resource<ResourceType::Animation>::GetBones() const
{
	return m_impl->bones;
}

Bone *Resource<ResourceType::Animation>::GetBone(const std::string &name)
{
	auto iter = std::find_if(m_impl->bones.begin(), m_impl->bones.end(), [&](const Bone &bone) { return bone.GetBoneName() == name; });
	return iter == m_impl->bones.end() ? nullptr : &(*iter);
}

uint32_t Resource<ResourceType::Animation>::GetBoneCount() const
{
	return m_impl->m_bone_count;
}

uint32_t Resource<ResourceType::Animation>::GetMaxBoneIndex() const
{
	uint32_t idx = 0;
	for (auto &bone : m_impl->bones)
	{
		idx = std::max(idx, bone.GetBoneID());
	}
	return idx;
}

float Resource<ResourceType::Animation>::GetMaxTimeStamp() const
{
	return m_impl->m_max_timestamp;
}

uint32_t Resource<ResourceType::Animation>::GetFrameCount() const
{
	return static_cast<uint32_t>(m_impl->m_max_timestamp * 30.f);
}

const HierarchyNode &Resource<ResourceType::Animation>::GetHierarchyNode() const
{
	return m_impl->hierarchy;
}

void Resource<ResourceType::Animation>::Bake(RHIContext *rhi_context)
{
	std::function<void(const HierarchyNode &, float time, std::vector<glm::mat4> &, glm::mat4, bool)> calculate_bone_transform = [&](const HierarchyNode &node, float time, std::vector<glm::mat4> &skinned_matrics, glm::mat4 parent, bool outside) {
		Bone *bone = GetBone(node.name);

		glm::mat4 global_transformation = outside ? glm::mat4(1.f) : parent * node.transform;

		if (bone)
		{
			global_transformation    = parent * bone->GetLocalTransform(time);
			uint32_t  bone_id        = bone->GetBoneID();
			glm::mat4 offset         = bone->GetBoneOffset();
			skinned_matrics[bone_id] = global_transformation * offset;

			outside = false;
		}

		for (auto &child : node.children)
		{
			calculate_bone_transform(child, time, skinned_matrics, global_transformation, outside);
		}
	};

	m_impl->m_bone_count = 0;
	for (auto &bone : m_impl->bones)
	{
		m_impl->m_bone_count = glm::max(m_impl->m_bone_count, bone.GetBoneID());
	}
	m_impl->m_bone_count++;

	// Bone matrics
	m_impl->bone_matrics = rhi_context->CreateBuffer(sizeof(glm::mat4) * m_impl->m_bone_count, RHIBufferUsage::ConstantBuffer | RHIBufferUsage::UnorderedAccess, RHIMemoryUsage::CPU_TO_GPU);

	// Skinned Matrics
	// X - bone id
	// Y - frame transform float4x3
	size_t frame_count      = static_cast<size_t>(m_impl->m_max_timestamp * 30.f);
	m_impl->skinned_matrics = rhi_context->CreateTexture2D((uint32_t) m_impl->m_bone_count * 3, (uint32_t) frame_count, RHIFormat::R32G32B32A32_FLOAT, RHITextureUsage::Transfer | RHITextureUsage::ShaderResource, false);

	std::vector<float> skinned_matrics(frame_count * 4ull * 3ull * m_impl->m_bone_count);

	for (size_t i = 0; i < frame_count; i++)
	{
		float time = static_cast<float>(i) / 30.f;

		std::vector<glm::mat4> frame_skinned_matrics(m_impl->m_bone_count);
		calculate_bone_transform(m_impl->hierarchy, time, frame_skinned_matrics, glm::mat4(1.f), true);

		if (i == 0)
		{
			m_impl->bone_matrics->CopyToDevice(frame_skinned_matrics.data(), frame_skinned_matrics.size() * sizeof(glm::mat4));
		}

		size_t offset = 4ull * 3ull * m_impl->m_bone_count * i;

		for (size_t j = 0; j < m_impl->m_bone_count; j++)
		{
			glm::mat4 transform = glm::transpose(frame_skinned_matrics[j]);

			skinned_matrics[offset + 4ull * 3ull * j]      = transform[0][0];
			skinned_matrics[offset + 4ull * 3ull * j + 1]  = transform[0][1];
			skinned_matrics[offset + 4ull * 3ull * j + 2]  = transform[0][2];
			skinned_matrics[offset + 4ull * 3ull * j + 3]  = transform[0][3];
			skinned_matrics[offset + 4ull * 3ull * j + 4]  = transform[1][0];
			skinned_matrics[offset + 4ull * 3ull * j + 5]  = transform[1][1];
			skinned_matrics[offset + 4ull * 3ull * j + 6]  = transform[1][2];
			skinned_matrics[offset + 4ull * 3ull * j + 7]  = transform[1][3];
			skinned_matrics[offset + 4ull * 3ull * j + 8]  = transform[2][0];
			skinned_matrics[offset + 4ull * 3ull * j + 9]  = transform[2][1];
			skinned_matrics[offset + 4ull * 3ull * j + 10] = transform[2][2];
			skinned_matrics[offset + 4ull * 3ull * j + 11] = transform[2][3];
		}
	}

	{
		auto staging_buffer = rhi_context->CreateBuffer(skinned_matrics.size() * sizeof(float), RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
		staging_buffer->CopyToDevice(skinned_matrics.data(), skinned_matrics.size() * sizeof(float));
		auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
		cmd_buffer->Begin();
		cmd_buffer->ResourceStateTransition({TextureStateTransition{m_impl->skinned_matrics.get(), RHIResourceState::Undefined, RHIResourceState::TransferDest}}, {});
		cmd_buffer->CopyBufferToTexture(staging_buffer.get(), m_impl->skinned_matrics.get(), 0, 0, 1);
		cmd_buffer->ResourceStateTransition({TextureStateTransition{m_impl->skinned_matrics.get(), RHIResourceState::TransferDest, RHIResourceState::ShaderResource}}, {});
		cmd_buffer->End();
		rhi_context->Execute(cmd_buffer);
	}
}

RHITexture *Resource<ResourceType::Animation>::GetSkinnedMatrics() const
{
	return m_impl->skinned_matrics.get();
}

RHIBuffer *Resource<ResourceType::Animation>::GetBoneMatrics() const
{
	return m_impl->bone_matrics.get();
}

Resource<ResourceType::Animation>::~Resource()
{
	delete m_impl;
}

bool Resource<ResourceType::Animation>::Validate() const
{
	return m_impl != nullptr;
}

void Resource<ResourceType::Animation>::Load(RHIContext *rhi_context)
{
	m_impl = new Impl;

	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Animation), thumbnail_data, m_impl->bones, m_impl->hierarchy, m_impl->m_max_timestamp);

	Bake(rhi_context);
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/Material.cpp
================================================
#include "Resource/Material.hpp"
#include "Resource/Mesh.hpp"
#include "Resource/Texture2D.hpp"
#include "ResourceManager.hpp"

#include <Material/MaterialCompiler.hpp>
#include <Material/MaterialData.hpp>
#include <ShaderCompiler/ShaderCompiler.hpp>

#include <mustache.hpp>

namespace Ilum
{
struct Resource<ResourceType::Material>::Impl
{
	MaterialGraphDesc desc;

	MaterialCompilationContext context;

	std::string layout;

	MaterialData data;

	bool valid = false;

	bool dirty = false;
};

Resource<ResourceType::Material>::Resource(RHIContext *rhi_context, const std::string &name) :
    IResource(rhi_context, name, ResourceType::Material)
{
}

Resource<ResourceType::Material>::Resource(RHIContext *rhi_context, const std::string &name, MaterialGraphDesc &&desc) :
    IResource(name)
{
	m_impl = new Impl;

	m_impl->desc = std::move(desc);

	std::vector<uint8_t> thumbnail_data;

	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Material), thumbnail_data, m_impl->desc, m_impl->layout, m_impl->context, m_impl->data);

	m_impl->dirty = true;
	m_impl->valid = false;
}

Resource<ResourceType::Material>::~Resource()
{
	delete m_impl;
}

bool Resource<ResourceType::Material>::Validate() const
{
	return m_impl != nullptr;
}

void Resource<ResourceType::Material>::Load(RHIContext *rhi_context)
{
	m_impl = new Impl;

	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Material), thumbnail_data, m_impl->desc, m_impl->layout, m_impl->context, m_impl->data);

	m_impl->valid = Path::GetInstance().IsExist(fmt::format("Asset/Material/{}", m_impl->data.shader));
}

void Resource<ResourceType::Material>::Compile(RHIContext *rhi_context, ResourceManager *manager, RHITexture *dummy_texture, const std::string &layout)
{
	if (!layout.empty())
	{
		m_impl->layout = layout;
	}

	m_impl->valid = false;

	m_impl->context.Reset();
	m_impl->data.Reset();

	for (auto &[node_handle, node] : m_impl->desc.GetNodes())
	{
		node.EmitHLSL(m_impl->desc, manager, &m_impl->context);
	}

	if (!m_impl->context.output.bsdf.empty())
	{
		std::vector<uint8_t> shader_data;
		Path::GetInstance().Read("Source/Shaders/Material.hlsli", shader_data);
		std::string shader(shader_data.begin(), shader_data.end());

		kainjow::mustache::mustache mustache = {shader};
		kainjow::mustache::data     mustache_data{kainjow::mustache::data::type::object};

		{
			kainjow::mustache::data headers{kainjow::mustache::data::type::list};
			kainjow::mustache::data initializations{kainjow::mustache::data::type::list};
			kainjow::mustache::data textures{kainjow::mustache::data::type::list};
			kainjow::mustache::data samplers{kainjow::mustache::data::type::list};
			for (auto &variable : m_impl->context.variables)
			{
				initializations << kainjow::mustache::data{"Initialization", variable};
			}
			for (auto &[texture, texture_name] : m_impl->context.textures)
			{
				textures << kainjow::mustache::data{"Texture", texture};
			}
			for (auto &[sampler, desc] : m_impl->context.samplers)
			{
				samplers << kainjow::mustache::data{"Sampler", sampler};
			}
			std::unordered_set<std::string> bsdf_types;
			for (auto &bsdf : m_impl->context.bsdfs)
			{
				if (bsdf.name != m_impl->context.output.bsdf)
				{
					initializations << kainjow::mustache::data{"Initialization", fmt::format("{} {};", bsdf.type, bsdf.name)};
					initializations << kainjow::mustache::data{"Initialization", fmt::format("{}", bsdf.initialization)};
				}
				else
				{
					mustache_data.set("BxDFType", bsdf.type);
					mustache_data.set("BxDFName", bsdf.name);
				}
				bsdf_types.insert(bsdf.type.substr(0, std::min(bsdf.type.find_first_of('<'), bsdf.type.find_first_of(' '))));
			}
			initializations << kainjow::mustache::data{"Initialization", m_impl->context.bsdfs.back().initialization};

			for (auto &bsdf_type : bsdf_types)
			{
				headers << kainjow::mustache::data{"MaterialHeader", fmt::format("#include \"Material/Material/{}.hlsli\"", bsdf_type)};
			}

			mustache_data.set("MaterialHeaders", headers);
			mustache_data.set("Initializations", initializations);
			mustache_data.set("Textures", textures);
			mustache_data.set("Samplers", samplers);
		}

		shader = mustache.render(mustache_data);
		shader = std::string(shader.c_str());

		m_impl->data.signature = fmt::format("Signature_{}", Hash(shader));

		shader_data.resize(shader.length());
		std::memcpy(shader_data.data(), shader.data(), shader_data.size());

		m_impl->data.shader = fmt::format("{}.material.hlsli", m_impl->desc.GetName());

		Path::GetInstance().Save(fmt::format("Asset/Material/{}", m_impl->data.shader), shader_data);
	}

	m_impl->valid = true;
	m_impl->dirty = true;

	Update(rhi_context, manager, dummy_texture);
}

void Resource<ResourceType::Material>::Update(RHIContext *rhi_context, ResourceManager *manager, RHITexture *dummy_texture)
{
	if (!m_impl->valid)
	{
		Compile(rhi_context, manager, dummy_texture);
	}
	else
	{
		manager->SetDirty<ResourceType::Material>();

		m_impl->data.textures.clear();
		for (auto &[texture, texture_name] : m_impl->context.textures)
		{
			m_impl->data.textures.push_back(static_cast<uint32_t>(manager->Index<ResourceType::Texture2D>(texture_name)));
		}

		m_impl->data.samplers.clear();
		for (auto &[sampler, desc] : m_impl->context.samplers)
		{
			m_impl->data.samplers.push_back(rhi_context->GetSamplerIndex(desc));
		}
	}
}

void Resource<ResourceType::Material>::PostUpdate(RHIContext *rhi_context, uint32_t material_id, const std::vector<RHITexture *> &scene_texture_2d, const std::vector<RHISampler *> &samplers, RHIBuffer *material_buffers, RHIBuffer *material_offsets)
{
	if (m_impl->dirty)
	{
		std::vector<uint8_t> thumbnail_data = RenderPreview(rhi_context, material_id, scene_texture_2d, samplers, material_buffers, material_offsets);
		SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Material), thumbnail_data, m_impl->desc, m_impl->layout, m_impl->context, m_impl->data);
		m_impl->dirty = false;
	}
}

const MaterialData &Resource<ResourceType::Material>::GetMaterialData() const
{
	return m_impl->data;
}

const MaterialCompilationContext &Resource<ResourceType::Material>::GetCompilationContext() const
{
	return m_impl->context;
}

const std::string &Resource<ResourceType::Material>::GetLayout() const
{
	return m_impl->layout;
}

MaterialGraphDesc &Resource<ResourceType::Material>::GetDesc()
{
	return m_impl->desc;
}

bool Resource<ResourceType::Material>::IsValid() const
{
	return m_impl->valid;
}

std::vector<uint8_t> Resource<ResourceType::Material>::RenderPreview(RHIContext *rhi_context, uint32_t material_id, const std::vector<RHITexture *> &scene_texture_2d, const std::vector<RHISampler *> &samplers, RHIBuffer *material_buffers, RHIBuffer *material_offsets)
{
	std::vector<Resource<ResourceType::Mesh>::Vertex> vertices;

	std::vector<uint32_t> indices;

	DESERIALIZE("Asset/BuildIn/MaterialBall.asset", vertices, indices);

	auto vertex_buffer = rhi_context->CreateBuffer<Resource<ResourceType::Mesh>::Vertex>(vertices.size(), RHIBufferUsage::Vertex, RHIMemoryUsage::CPU_TO_GPU);
	auto index_buffer  = rhi_context->CreateBuffer<uint32_t>(indices.size(), RHIBufferUsage::Index, RHIMemoryUsage::CPU_TO_GPU);

	vertex_buffer->CopyToDevice(vertices.data(), vertices.size() * sizeof(Resource<ResourceType::Mesh>::Vertex));
	index_buffer->CopyToDevice(indices.data(), indices.size() * sizeof(uint32_t));

	std::vector<uint8_t> raw_shader;
	Path::GetInstance().Read("./Source/Shaders/Editor/Preview/Material.hlsl", raw_shader);

	std::string shader_source;
	shader_source.resize(raw_shader.size());
	std::memcpy(shader_source.data(), raw_shader.data(), raw_shader.size());
	shader_source += "\n";

	ShaderDesc vertex_shader_desc  = {};
	vertex_shader_desc.path        = "./Source/Shaders/Editor/Preview/Material.hlsl";
	vertex_shader_desc.entry_point = "VSmain";
	vertex_shader_desc.stage       = RHIShaderStage::Vertex;
	vertex_shader_desc.source      = ShaderSource::HLSL;
	vertex_shader_desc.target      = ShaderTarget::SPIRV;
	vertex_shader_desc.code        = fmt::format("#include \"{}\"\n", m_impl->data.shader) + shader_source;
	vertex_shader_desc.macros      = {"USE_MATERIAL", m_impl->data.signature, "MATERIAL_ID = " + std::to_string(material_id)};

	ShaderDesc fragment_shader_desc  = {};
	fragment_shader_desc.path        = "./Source/Shaders/Editor/Preview/Material.hlsl";
	fragment_shader_desc.entry_point = "PSmain";
	fragment_shader_desc.stage       = RHIShaderStage::Fragment;
	fragment_shader_desc.source      = ShaderSource::HLSL;
	fragment_shader_desc.target      = ShaderTarget::SPIRV;
	fragment_shader_desc.code        = fmt::format("#include \"{}\"\n", m_impl->data.shader) + shader_source;
	fragment_shader_desc.macros      = {"USE_MATERIAL", m_impl->data.signature, "MATERIAL_ID = " + std::to_string(material_id)};

	ShaderMeta vertex_meta   = {};
	ShaderMeta fragment_meta = {};

	auto vertex_shader_spirv   = ShaderCompiler::GetInstance().Compile(vertex_shader_desc, vertex_meta);
	auto fragment_shader_spirv = ShaderCompiler::GetInstance().Compile(fragment_shader_desc, fragment_meta);

	auto vertex_shader   = rhi_context->CreateShader("VSmain", vertex_shader_spirv);
	auto fragment_shader = rhi_context->CreateShader("PSmain", fragment_shader_spirv);

	ShaderMeta shader_meta = vertex_meta;
	shader_meta += fragment_meta;

	BlendState blend_state = {};
	blend_state.attachment_states.resize(1);

	DepthStencilState depth_stencil_state  = {};
	depth_stencil_state.depth_test_enable  = true;
	depth_stencil_state.depth_write_enable = true;

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();

	if (!m_thumbnail)
	{
		m_thumbnail = rhi_context->CreateTexture2D(128, 128, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::ShaderResource | RHITextureUsage::Transfer | RHITextureUsage::RenderTarget, false);
		cmd_buffer->ResourceStateTransition({
		                                        TextureStateTransition{m_thumbnail.get(), RHIResourceState::Undefined, RHIResourceState::RenderTarget},
		                                    },
		                                    {});
	}
	else
	{
		cmd_buffer->ResourceStateTransition({
		                                        TextureStateTransition{m_thumbnail.get(), RHIResourceState::ShaderResource, RHIResourceState::RenderTarget},
		                                    },
		                                    {});
	}

	auto depth_buffer   = rhi_context->CreateTexture2D(128, 128, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget, false);
	auto uniform_buffer = rhi_context->CreateBuffer<glm::mat4>(2, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
	auto staging_buffer = rhi_context->CreateBuffer(128ull * 128ull * 4ull * sizeof(uint8_t), RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_TO_CPU);
	auto render_target  = rhi_context->CreateRenderTarget();
	auto pipeline_state = rhi_context->CreatePipelineState();

	pipeline_state->SetBlendState(blend_state);
	pipeline_state->SetDepthStencilState(depth_stencil_state);
	pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader.get());
	pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader.get());
	pipeline_state->SetVertexInputState(VertexInputState{
	    {
	        VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, position)},
	        VertexInputState::InputAttribute{RHIVertexSemantics::Normal, 1, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, normal)},
	        VertexInputState::InputAttribute{RHIVertexSemantics::Tangent, 2, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, tangent)},
	        VertexInputState::InputAttribute{RHIVertexSemantics::Texcoord, 3, 0, RHIFormat::R32G32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, texcoord0)},
	    },
	    {
	        VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::Mesh>::Vertex), RHIVertexInputRate::Vertex},
	    }});

	{
		glm::vec3 center = glm::vec3(0.f);

		float radius = 4.f;
		float theta  = 0.f;
		float phi    = 60.f;

		glm::vec3 position  = center + radius * glm::vec3(glm::sin(glm::radians(phi)) * glm::sin(glm::radians(theta)), glm::cos(glm::radians(phi)), glm::sin(glm::radians(phi)) * glm::cos(glm::radians(theta)));
		glm::vec3 direction = glm::normalize(center - position);
		glm::vec3 right     = glm::normalize(glm::cross(direction, glm::vec3{0.f, 1.f, 0.f}));
		glm::vec3 up        = glm::normalize(glm::cross(right, direction));
		glm::mat4 transform = glm::perspective(glm::radians(45.f), 1.f, 0.01f, 1000.f) * glm::lookAt(position, center, up);
		glm::mat4 model     = glm::mat4_cast(glm::qua<float>(glm::radians(glm::vec3(135.f, 0.f, 180.f))));

		uniform_buffer->CopyToDevice(glm::value_ptr(transform), sizeof(transform));
		uniform_buffer->CopyToDevice(glm::value_ptr(model), sizeof(model), sizeof(glm::mat4));
	}

	auto descriptor = rhi_context->CreateDescriptor(shader_meta);
	descriptor->BindBuffer("UniformBuffer", uniform_buffer.get())
	    .BindTexture("Textures", scene_texture_2d, RHITextureDimension::Texture2D)
	    .BindSampler("Samplers", samplers)
	    .BindBuffer("MaterialOffsets", material_offsets)
	    .BindBuffer("MaterialBuffer", material_buffers);

	render_target->Set(0, m_thumbnail.get(), TextureRange{}, ColorAttachment{RHILoadAction::Clear, RHIStoreAction::Store, {0.1f, 0.1f, 0.1f, 1.f}});
	render_target->Set(depth_buffer.get(), TextureRange{}, DepthStencilAttachment{});

	cmd_buffer->ResourceStateTransition({
	                                        TextureStateTransition{depth_buffer.get(), RHIResourceState::Undefined, RHIResourceState::DepthWrite},
	                                    },
	                                    {});
	cmd_buffer->BeginRenderPass(render_target.get());
	cmd_buffer->SetViewport(128, 128);
	cmd_buffer->SetScissor(128, 128);
	cmd_buffer->BindDescriptor(descriptor);
	cmd_buffer->BindPipelineState(pipeline_state.get());
	cmd_buffer->BindVertexBuffer(0, vertex_buffer.get());
	cmd_buffer->BindIndexBuffer(index_buffer.get());
	cmd_buffer->DrawIndexed(static_cast<uint32_t>(indices.size()));
	cmd_buffer->EndRenderPass();
	cmd_buffer->ResourceStateTransition({
	                                        TextureStateTransition{m_thumbnail.get(), RHIResourceState::RenderTarget, RHIResourceState::TransferSource},
	                                    },
	                                    {});
	cmd_buffer->CopyTextureToBuffer(m_thumbnail.get(), staging_buffer.get(), 0, 0, 1);
	cmd_buffer->ResourceStateTransition({
	                                        TextureStateTransition{m_thumbnail.get(), RHIResourceState::TransferSource, RHIResourceState::ShaderResource},
	                                    },
	                                    {});
	cmd_buffer->End();
	rhi_context->Execute(cmd_buffer);

	std::vector<uint8_t> staging_data(staging_buffer->GetDesc().size);
	staging_buffer->CopyToHost(staging_data.data(), staging_buffer->GetDesc().size);

	return staging_data;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/Mesh.cpp
================================================
#include "Resource/Mesh.hpp"

#include <RHI/RHIContext.hpp>
#include <ShaderCompiler/ShaderCompiler.hpp>

namespace Ilum
{
struct Resource<ResourceType::Mesh>::Impl
{
	size_t vertex_count  = 0;
	size_t index_count   = 0;
	size_t meshlet_count = 0;

	std::unique_ptr<RHIBuffer> vertex_buffer       = nullptr;
	std::unique_ptr<RHIBuffer> index_buffer        = nullptr;
	std::unique_ptr<RHIBuffer> meshlet_data_buffer = nullptr;
	std::unique_ptr<RHIBuffer> meshlet_buffer      = nullptr;

	std::unique_ptr<RHIAccelerationStructure> blas = nullptr;
};

Resource<ResourceType::Mesh>::Resource(RHIContext *rhi_context, const std::string &name) :
    IResource(rhi_context, name, ResourceType::Mesh)
{
}

Resource<ResourceType::Mesh>::Resource(RHIContext *rhi_context, const std::string &name, std::vector<Vertex> &&vertices, std::vector<uint32_t> &&indices, std::vector<Meshlet> &&meshlets, std::vector<uint32_t> &&meshlet_data) :
    IResource(name)
{
	m_impl = new Impl;
	Update(rhi_context, std::move(vertices), std::move(indices), std::move(meshlets), std::move(meshlet_data));
}

Resource<ResourceType::Mesh>::~Resource()
{
	delete m_impl;
}

bool Resource<ResourceType::Mesh>::Validate() const
{
	return m_impl != nullptr;
}

void Resource<ResourceType::Mesh>::Load(RHIContext *rhi_context)
{
	m_impl = new Impl;

	std::vector<uint8_t>  thumbnail_data;
	std::vector<Vertex>   vertices;
	std::vector<uint32_t> indices;
	std::vector<Meshlet>  meshlets;
	std::vector<uint32_t> meshlet_data;

	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Mesh), thumbnail_data, vertices, indices, meshlets, meshlet_data);

	Update(rhi_context, std::move(vertices), std::move(indices), std::move(meshlets), std::move(meshlet_data));
}

RHIBuffer *Resource<ResourceType::Mesh>::GetVertexBuffer() const
{
	return m_impl->vertex_buffer.get();
}

RHIBuffer *Resource<ResourceType::Mesh>::GetIndexBuffer() const
{
	return m_impl->index_buffer.get();
}

RHIBuffer *Resource<ResourceType::Mesh>::GetMeshletDataBuffer() const
{
	return m_impl->meshlet_data_buffer.get();
}

RHIBuffer *Resource<ResourceType::Mesh>::GetMeshletBuffer() const
{
	return m_impl->meshlet_buffer.get();
}

RHIAccelerationStructure *Resource<ResourceType::Mesh>::GetBLAS() const
{
	return m_impl->blas.get();
}

size_t Resource<ResourceType::Mesh>::GetVertexCount() const
{
	return m_impl->vertex_count;
}

size_t Resource<ResourceType::Mesh>::GetIndexCount() const
{
	return m_impl->index_count;
}

size_t Resource<ResourceType::Mesh>::GetMeshletCount() const
{
	return m_impl->meshlet_count;
}

void Resource<ResourceType::Mesh>::Update(RHIContext *rhi_context, std::vector<Vertex> &&vertices, std::vector<uint32_t> &&indices, std::vector<Meshlet> &&meshlets, std::vector<uint32_t> &&meshlet_data)
{
	m_impl->vertex_count  = vertices.size();
	m_impl->index_count   = indices.size();
	m_impl->meshlet_count = meshlets.size();

	m_impl->vertex_buffer       = rhi_context->CreateBuffer<Vertex>(vertices.size(), RHIBufferUsage::Vertex | RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
	m_impl->index_buffer        = rhi_context->CreateBuffer<uint32_t>(indices.size(), RHIBufferUsage::Index | RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
	m_impl->meshlet_data_buffer = rhi_context->CreateBuffer<uint32_t>(meshlet_data.size(), RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
	m_impl->meshlet_buffer      = rhi_context->CreateBuffer<Meshlet>(meshlets.size(), RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);

	m_impl->vertex_buffer->CopyToDevice(vertices.data(), vertices.size() * sizeof(Vertex));
	m_impl->index_buffer->CopyToDevice(indices.data(), indices.size() * sizeof(uint32_t));
	m_impl->meshlet_data_buffer->CopyToDevice(meshlet_data.data(), meshlet_data.size() * sizeof(uint32_t));
	m_impl->meshlet_buffer->CopyToDevice(meshlets.data(), meshlets.size() * sizeof(Meshlet));

	m_impl->blas = rhi_context->CreateAcccelerationStructure();

	BLASDesc desc        = {};
	desc.name            = m_name;
	desc.vertex_buffer   = m_impl->vertex_buffer.get();
	desc.index_buffer    = m_impl->index_buffer.get();
	desc.vertices_count  = static_cast<uint32_t>(vertices.size());
	desc.vertices_offset = 0;
	desc.indices_count   = static_cast<uint32_t>(indices.size());
	desc.indices_offset  = 0;

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Compute);
	cmd_buffer->Begin();
	m_impl->blas->Update(cmd_buffer, desc);
	cmd_buffer->End();
	rhi_context->Execute(cmd_buffer);

	glm::vec3 min_bound = glm::vec3(std::numeric_limits<float>::max());
	glm::vec3 max_bound = glm::vec3(-std::numeric_limits<float>::max());
	for (const auto &v : vertices)
	{
		min_bound = glm::min(min_bound, v.position);
		max_bound = glm::max(max_bound, v.position);
	}

	glm::vec3 center = (max_bound + min_bound) * 0.5f;
	float     radius = glm::length(max_bound - min_bound);

	std::vector<uint8_t> thumbnail_data = RenderPreview(rhi_context, center, radius);
	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Mesh), thumbnail_data, vertices, indices, meshlets, meshlet_data);
}

std::vector<uint8_t> Resource<ResourceType::Mesh>::RenderPreview(RHIContext *rhi_context, const glm::vec3 &center, float radius)
{
	/*{
	    std::vector<uint8_t> raw_shader;
	    Path::GetInstance().Read("./Source/Shaders/Preview/Editor/Mesh.hlsl", raw_shader);

	    std::string shader_source;
	    shader_source.resize(raw_shader.size());
	    std::memcpy(shader_source.data(), raw_shader.data(), raw_shader.size());
	    shader_source += "\n";

	    ShaderDesc vertex_shader_desc  = {};
	    vertex_shader_desc.path = "./Source/Shaders/Preview/Editor/Mesh.hlsl";
	    vertex_shader_desc.entry_point = "VSmain";
	    vertex_shader_desc.stage       = RHIShaderStage::Vertex;
	    vertex_shader_desc.source      = ShaderSource::HLSL;
	    vertex_shader_desc.target      = ShaderTarget::SPIRV;
	    vertex_shader_desc.code        = shader_source;

	    ShaderDesc fragment_shader_desc  = {};
	    fragment_shader_desc.path = "./Source/Shaders/Preview/Editor/Mesh.hlsl";
	    fragment_shader_desc.entry_point = "PSmain";
	    fragment_shader_desc.stage       = RHIShaderStage::Fragment;
	    fragment_shader_desc.source      = ShaderSource::HLSL;
	    fragment_shader_desc.target      = ShaderTarget::SPIRV;
	    fragment_shader_desc.code        = shader_source;

	    ShaderMeta vertex_meta   = {};
	    ShaderMeta fragment_meta = {};

	    auto vertex_shader_spirv   = ShaderCompiler::GetInstance().Compile(vertex_shader_desc, vertex_meta);
	    auto fragment_shader_spirv = ShaderCompiler::GetInstance().Compile(fragment_shader_desc, fragment_meta);

	    auto m_vertex_shader   = rhi_context->CreateShader("VSmain", vertex_shader_spirv);
	    auto m_fragment_shader = rhi_context->CreateShader("PSmain", fragment_shader_spirv);

	    ShaderMeta shader_meta = vertex_meta;
	    shader_meta += fragment_meta;

	    SERIALIZE("Asset/BuildIn/mesh.preview.asset", vertex_shader_spirv, fragment_shader_spirv, shader_meta);
	}*/
	bool has_thumbnail = (m_thumbnail != nullptr);
	if (!m_thumbnail)
	{
		m_thumbnail = rhi_context->CreateTexture2D(128, 128, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::ShaderResource | RHITextureUsage::Transfer | RHITextureUsage::RenderTarget, false);
	}

	ShaderMeta           shader_meta;
	std::vector<uint8_t> vertex_shader_spirv;
	std::vector<uint8_t> fragment_shader_spirv;
	DESERIALIZE("Asset/BuildIn/mesh.preview.asset", vertex_shader_spirv, fragment_shader_spirv, shader_meta);

	BlendState blend_state = {};
	blend_state.attachment_states.resize(1);

	DepthStencilState depth_stencil_state  = {};
	depth_stencil_state.depth_test_enable  = true;
	depth_stencil_state.depth_write_enable = true;

	auto depth_buffer    = rhi_context->CreateTexture2D(128, 128, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget, false);
	auto uniform_buffer  = rhi_context->CreateBuffer<glm::mat4>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
	auto staging_buffer  = rhi_context->CreateBuffer(128ull * 128ull * 4ull * sizeof(uint8_t), RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_TO_CPU);
	auto render_target   = rhi_context->CreateRenderTarget();
	auto pipeline_state  = rhi_context->CreatePipelineState();
	auto vertex_shader   = rhi_context->CreateShader("VSmain", vertex_shader_spirv);
	auto fragment_shader = rhi_context->CreateShader("PSmain", fragment_shader_spirv);
	pipeline_state->SetBlendState(blend_state);
	pipeline_state->SetDepthStencilState(depth_stencil_state);
	pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader.get());
	pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader.get());
	pipeline_state->SetVertexInputState(VertexInputState{
	    {
	        VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, position)},
	        VertexInputState::InputAttribute{RHIVertexSemantics::Normal, 1, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::Mesh>::Vertex, normal)},
	    },
	    {
	        VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::Mesh>::Vertex), RHIVertexInputRate::Vertex},
	    }});

	{
		glm::vec3 position  = center + radius * glm::vec3(0.f, 0.f, 1.f);
		glm::vec3 direction = glm::normalize(center - position);
		glm::vec3 right     = glm::normalize(glm::cross(direction, glm::vec3{0.f, 1.f, 0.f}));
		glm::vec3 up        = glm::normalize(glm::cross(right, direction));
		glm::mat4 transform = glm::perspective(glm::radians(45.f), 1.f, 0.01f, 1000.f) * glm::lookAt(position, center, up);
		uniform_buffer->CopyToDevice(glm::value_ptr(transform), sizeof(transform));
	}

	auto descriptor = rhi_context->CreateDescriptor(shader_meta);
	descriptor->BindBuffer("UniformBuffer", uniform_buffer.get());

	render_target->Set(0, m_thumbnail.get(), TextureRange{}, ColorAttachment{RHILoadAction::Clear, RHIStoreAction::Store, {0.1f, 0.1f, 0.1f, 1.f}});
	render_target->Set(depth_buffer.get(), TextureRange{}, DepthStencilAttachment{});

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();
	cmd_buffer->ResourceStateTransition({
	                                        TextureStateTransition{m_thumbnail.get(), has_thumbnail ? RHIResourceState::ShaderResource : RHIResourceState::Undefined, RHIResourceState::RenderTarget},
	                                        TextureStateTransition{depth_buffer.get(), RHIResourceState::Undefined, RHIResourceState::DepthWrite},
	                                    },
	                                    {});
	cmd_buffer->BeginRenderPass(render_target.get());
	cmd_buffer->SetViewport(128, 128);
	cmd_buffer->SetScissor(128, 128);
	cmd_buffer->BindDescriptor(descriptor);
	cmd_buffer->BindPipelineState(pipeline_state.get());
	cmd_buffer->BindVertexBuffer(0, m_impl->vertex_buffer.get());
	cmd_buffer->BindIndexBuffer(m_impl->index_buffer.get());
	cmd_buffer->DrawIndexed(static_cast<uint32_t>(m_impl->index_count));
	cmd_buffer->EndRenderPass();
	cmd_buffer->ResourceStateTransition({
	                                        TextureStateTransition{m_thumbnail.get(), RHIResourceState::RenderTarget, RHIResourceState::TransferSource},
	                                    },
	                                    {});
	cmd_buffer->CopyTextureToBuffer(m_thumbnail.get(), staging_buffer.get(), 0, 0, 1);
	cmd_buffer->End();
	rhi_context->Execute(cmd_buffer);

	std::vector<uint8_t> staging_data(staging_buffer->GetDesc().size);
	staging_buffer->CopyToHost(staging_data.data(), staging_buffer->GetDesc().size);

	return staging_data;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/Prefab.cpp
================================================
#include "Resource/Prefab.hpp"

namespace Ilum
{
struct Resource<ResourceType::Prefab>::Impl
{
	Node root;
};

Resource<ResourceType::Prefab>::Resource(RHIContext *rhi_context, const std::string &name):
    IResource(rhi_context, name, ResourceType::Prefab)
{
}

Resource<ResourceType::Prefab>::Resource(RHIContext *rhi_context, const std::string &name, Node &&root) :
    IResource(name)
{
	m_impl       = new Impl;
	m_impl->root = std::move(root);

	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE("Asset/BuildIn/prefab.icon.asset", thumbnail_data);
	UpdateThumbnail(rhi_context, thumbnail_data);
	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Prefab), thumbnail_data, m_impl->root);
}

Resource<ResourceType::Prefab>::~Resource()
{
	delete m_impl;
}

bool Resource<ResourceType::Prefab>::Validate() const
{
	return m_impl != nullptr;
}

void Resource<ResourceType::Prefab>::Load(RHIContext *rhi_context)
{
	m_impl = new Impl;

	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Prefab), thumbnail_data, m_impl->root);
}

const Resource<ResourceType::Prefab>::Node &Resource<ResourceType::Prefab>::GetRoot() const
{
	return m_impl->root;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/RenderPipeline.cpp
================================================
#include "Resource/RenderPipeline.hpp"

#include <RenderGraph/RenderGraph.hpp>
#include <RenderGraph/RenderGraphBuilder.hpp>

namespace Ilum
{
struct Resource<ResourceType::RenderPipeline>::Impl
{
	RenderGraphDesc desc;
	std::string     layout;
};

Resource<ResourceType::RenderPipeline>::Resource(RHIContext *rhi_context, const std::string &name) :
    IResource(rhi_context, name, ResourceType::RenderPipeline)
{
}

Resource<ResourceType::RenderPipeline>::Resource(RHIContext *rhi_context, const std::string &name, RenderGraphDesc &&desc) :
    IResource(name)
{
	m_impl       = new Impl;
	m_impl->desc = std::move(desc);

	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE("Asset/BuildIn/pipeline.icon.asset", thumbnail_data);
	UpdateThumbnail(rhi_context, thumbnail_data);
	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", name, (uint32_t) ResourceType::RenderPipeline), thumbnail_data, m_impl->desc, m_impl->layout);
}

Resource<ResourceType::RenderPipeline>::~Resource()
{
	delete m_impl;
}

bool Resource<ResourceType::RenderPipeline>::Validate() const
{
	return m_impl != nullptr;
}

void Resource<ResourceType::RenderPipeline>::Load(RHIContext *rhi_context)
{
	m_impl = new Impl;

	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::RenderPipeline), thumbnail_data, m_impl->desc, m_impl->layout);
}

std::unique_ptr<RenderGraph> Resource<ResourceType::RenderPipeline>::Compile(RHIContext *rhi_context, Renderer *renderer, glm::vec2 viewport, const std::string &layout)
{
	if (!layout.empty())
	{
		m_impl->layout = layout;
	}

	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::RenderPipeline), thumbnail_data);
	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::RenderPipeline), thumbnail_data, m_impl->desc, m_impl->layout);

	RenderGraphDesc desc = m_impl->desc;

	for (auto &[pass_handle, pass] : desc.GetPasses())
	{
		for (auto &[pin_handle, pin] : pass.GetPins())
		{
			if (pin.attribute == RenderPassPin::Attribute::Output &&
			    pin.type == RenderPassPin::Type::Texture &&
			    (pin.texture.width == 0 || pin.texture.height == 0))
			{
				if (viewport.x <= 0 || viewport.y <= 0)
				{
					return nullptr;
				}
				pin.texture.width  = static_cast<uint32_t>(viewport.x);
				pin.texture.height = static_cast<uint32_t>(viewport.y);
			}
		}
	}

	RenderGraphBuilder builder(rhi_context);

	auto render_graph = builder.Compile(desc, renderer);

	return render_graph;
}

const std::string &Resource<ResourceType::RenderPipeline>::GetLayout() const
{
	return m_impl->layout;
}

RenderGraphDesc &Resource<ResourceType::RenderPipeline>::GetDesc()
{
	return m_impl->desc;
}
}        // namespace Ilum


================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/Scene.cpp
================================================
#include "Resource/Scene.hpp"

#include <Scene/Scene.hpp>

namespace Ilum
{
Resource<ResourceType::Scene>::Resource(RHIContext *rhi_context, const std::string &name) :
    IResource(rhi_context, name, ResourceType::Scene)
{
}

Resource<ResourceType::Scene>::Resource(RHIContext *rhi_context, const std::string &name, Scene *scene) :
    IResource(name)
{
	Save(rhi_context, scene);
}

void Resource<ResourceType::Scene>::Update(Scene *scene)
{
	std::vector<uint8_t> thumbnail_data;

	scene->Clear();

	{
		std::ifstream is(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Scene), std::ios::binary);
		InputArchive input_archive(is);
		input_archive(thumbnail_data);
		scene->Load(input_archive);
	}
}

void Resource<ResourceType::Scene>::Save(RHIContext *rhi_context, Scene *scene)
{
	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE("Asset/BuildIn/scene.icon.asset", thumbnail_data);
	if (!m_thumbnail)
	{
		UpdateThumbnail(rhi_context, thumbnail_data);
	}

	{
		std::ofstream os(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Scene), std::ios::binary);
		OutputArchive output_archive(os);
		output_archive(thumbnail_data);
		scene->Save(output_archive);
	}
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/SkinnedMesh.cpp
================================================
#include "Resource/SkinnedMesh.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
struct Resource<ResourceType::SkinnedMesh>::Impl
{
	size_t vertex_count  = 0;
	size_t index_count   = 0;
	size_t meshlet_count = 0;
	size_t bone_count    = 0;

	std::unique_ptr<RHIBuffer> vertex_buffer       = nullptr;
	std::unique_ptr<RHIBuffer> index_buffer        = nullptr;
	std::unique_ptr<RHIBuffer> meshlet_buffer      = nullptr;
	std::unique_ptr<RHIBuffer> meshlet_data_buffer = nullptr;
};

Resource<ResourceType::SkinnedMesh>::Resource(RHIContext *rhi_context, const std::string &name) :
    IResource(rhi_context, name, ResourceType::SkinnedMesh)
{
}

Resource<ResourceType::SkinnedMesh>::Resource(RHIContext *rhi_context, const std::string &name, std::vector<SkinnedVertex> &&vertices, std::vector<uint32_t> &&indices, std::vector<Meshlet> &&meshlets, std::vector<uint32_t> &&meshletdata) :
    IResource(name)
{
	m_impl = new Impl;
	Update(rhi_context, std::move(vertices), std::move(indices), std::move(meshlets), std::move(meshletdata));
}

Resource<ResourceType::SkinnedMesh>::~Resource()
{
	delete m_impl;
}

bool Resource<ResourceType::SkinnedMesh>::Validate() const
{
	return m_impl != nullptr;
}

void Resource<ResourceType::SkinnedMesh>::Load(RHIContext *rhi_context)
{
	m_impl = new Impl;

	std::vector<uint8_t>       thumbnail_data;
	std::vector<SkinnedVertex> vertices;
	std::vector<uint32_t>      indices;
	std::vector<Meshlet>       meshlets;
	std::vector<uint32_t>      meshlet_data;

	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::SkinnedMesh), thumbnail_data, vertices, indices, meshlets, meshlet_data);

	Update(rhi_context, std::move(vertices), std::move(indices), std::move(meshlets), std::move(meshlet_data));
}

RHIBuffer *Resource<ResourceType::SkinnedMesh>::GetVertexBuffer() const
{
	return m_impl->vertex_buffer.get();
}

RHIBuffer *Resource<ResourceType::SkinnedMesh>::GetIndexBuffer() const
{
	return m_impl->index_buffer.get();
}

RHIBuffer *Resource<ResourceType::SkinnedMesh>::GetMeshletBuffer() const
{
	return m_impl->meshlet_buffer.get();
}

RHIBuffer *Resource<ResourceType::SkinnedMesh>::GetMeshletDataBuffer() const
{
	return m_impl->meshlet_data_buffer.get();
}

size_t Resource<ResourceType::SkinnedMesh>::GetVertexCount() const
{
	return m_impl->vertex_count;
}

size_t Resource<ResourceType::SkinnedMesh>::GetIndexCount() const
{
	return m_impl->index_count;
}

size_t Resource<ResourceType::SkinnedMesh>::GetMeshletCount() const
{
	return m_impl->meshlet_count;
}

size_t Resource<ResourceType::SkinnedMesh>::GetBoneCount() const
{
	return m_impl->bone_count;
}

void Resource<ResourceType::SkinnedMesh>::Update(RHIContext *rhi_context, std::vector<Resource<ResourceType::SkinnedMesh>::SkinnedVertex> &&vertices, std::vector<uint32_t> &&indices, std::vector<Meshlet> &&meshlets, std::vector<uint32_t> &&meshletdata)
{
	m_impl->vertex_count  = vertices.size();
	m_impl->index_count   = indices.size();
	m_impl->meshlet_count = meshlets.size();

	std::unordered_set<int32_t> bone_set;
	for (auto &v : vertices)
	{
		for (uint32_t i = 0; i < 4; i++)
		{
			if (v.bones[i] != -1)
			{
				bone_set.insert(v.bones[i]);
			}
		}
	}
	m_impl->bone_count = bone_set.size();

	m_impl->vertex_buffer       = rhi_context->CreateBuffer<SkinnedVertex>(vertices.size(), RHIBufferUsage::Vertex | RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
	m_impl->index_buffer        = rhi_context->CreateBuffer<uint32_t>(indices.size(), RHIBufferUsage::Index | RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
	m_impl->meshlet_data_buffer = rhi_context->CreateBuffer<uint32_t>(meshletdata.size(), RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);
	m_impl->meshlet_buffer      = rhi_context->CreateBuffer<Meshlet>(meshlets.size(), RHIBufferUsage::UnorderedAccess | RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_Only);

	m_impl->vertex_buffer->CopyToDevice(vertices.data(), vertices.size() * sizeof(SkinnedVertex));
	m_impl->index_buffer->CopyToDevice(indices.data(), indices.size() * sizeof(uint32_t));
	m_impl->meshlet_data_buffer->CopyToDevice(meshletdata.data(), meshletdata.size() * sizeof(uint32_t));
	m_impl->meshlet_buffer->CopyToDevice(meshlets.data(), meshlets.size() * sizeof(Meshlet));

	glm::vec3 min_bound = glm::vec3(std::numeric_limits<float>::max());
	glm::vec3 max_bound = glm::vec3(-std::numeric_limits<float>::max());
	for (const auto &v : vertices)
	{
		min_bound = glm::min(min_bound, v.position);
		max_bound = glm::max(max_bound, v.position);
	}

	glm::vec3 center = (max_bound + min_bound) * 0.5f;
	float     radius = glm::length(max_bound - min_bound);

	std::vector<uint8_t> thumbnail_data = RenderPreview(rhi_context, center, radius);
	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::SkinnedMesh), thumbnail_data, vertices, indices, meshlets, meshletdata);
}

std::vector<uint8_t> Resource<ResourceType::SkinnedMesh>::RenderPreview(RHIContext *rhi_context, const glm::vec3 &center, float radius)
{
	/*{
	    std::vector<uint8_t> raw_shader;
	    Path::GetInstance().Read("./Source/Shaders/Preview/Mesh.hlsl", raw_shader);

	    std::string shader_source;
	    shader_source.resize(raw_shader.size());
	    std::memcpy(shader_source.data(), raw_shader.data(), raw_shader.size());
	    shader_source += "\n";

	    ShaderDesc vertex_shader_desc  = {};
		vertex_shader_desc.path="./Source/Shaders/Preview/Mesh.hlsl";
	    vertex_shader_desc.entry_point = "VSmain";
	    vertex_shader_desc.stage       = RHIShaderStage::Vertex;
	    vertex_shader_desc.source      = ShaderSource::HLSL;
	    vertex_shader_desc.target      = ShaderTarget::SPIRV;
	    vertex_shader_desc.code        = shader_source;

	    ShaderDesc fragment_shader_desc  = {};
	    fragment_shader_desc.path="./Source/Shaders/Preview/Mesh.hlsl";
	    fragment_shader_desc.entry_point = "PSmain";
	    fragment_shader_desc.stage       = RHIShaderStage::Fragment;
	    fragment_shader_desc.source      = ShaderSource::HLSL;
	    fragment_shader_desc.target      = ShaderTarget::SPIRV;
	    fragment_shader_desc.code        = shader_source;

	    ShaderMeta vertex_meta   = {};
	    ShaderMeta fragment_meta = {};

	    auto vertex_shader_spirv   = ShaderCompiler::GetInstance().Compile(vertex_shader_desc, vertex_meta);
	    auto fragment_shader_spirv = ShaderCompiler::GetInstance().Compile(fragment_shader_desc, fragment_meta);

	    auto m_vertex_shader   = rhi_context->CreateShader("VSmain", vertex_shader_spirv);
	    auto m_fragment_shader = rhi_context->CreateShader("PSmain", fragment_shader_spirv);

	    ShaderMeta shader_meta = vertex_meta;
	    shader_meta += fragment_meta;

	    SERIALIZE("Asset/BuildIn/mesh.preview.asset", vertex_shader_spirv, fragment_shader_spirv, shader_meta);
	}*/

	ShaderMeta           shader_meta;
	std::vector<uint8_t> vertex_shader_spirv;
	std::vector<uint8_t> fragment_shader_spirv;
	DESERIALIZE("Asset/BuildIn/mesh.preview.asset", vertex_shader_spirv, fragment_shader_spirv, shader_meta);

	BlendState blend_state = {};
	blend_state.attachment_states.resize(1);

	DepthStencilState depth_stencil_state  = {};
	depth_stencil_state.depth_test_enable  = true;
	depth_stencil_state.depth_write_enable = true;

	if (!m_thumbnail)
	{
		m_thumbnail = rhi_context->CreateTexture2D(128, 128, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::ShaderResource | RHITextureUsage::Transfer | RHITextureUsage::RenderTarget, false);
	}

	auto depth_buffer    = rhi_context->CreateTexture2D(128, 128, RHIFormat::D32_FLOAT, RHITextureUsage::RenderTarget, false);
	auto uniform_buffer  = rhi_context->CreateBuffer<glm::mat4>(1, RHIBufferUsage::ConstantBuffer, RHIMemoryUsage::CPU_TO_GPU);
	auto staging_buffer  = rhi_context->CreateBuffer(128ull * 128ull * 4ull * sizeof(uint8_t), RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_TO_CPU);
	auto render_target   = rhi_context->CreateRenderTarget();
	auto pipeline_state  = rhi_context->CreatePipelineState();
	auto vertex_shader   = rhi_context->CreateShader("VSmain", vertex_shader_spirv);
	auto fragment_shader = rhi_context->CreateShader("PSmain", fragment_shader_spirv);
	pipeline_state->SetBlendState(blend_state);
	pipeline_state->SetDepthStencilState(depth_stencil_state);
	pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader.get());
	pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader.get());
	pipeline_state->SetVertexInputState(VertexInputState{
	    {
	        VertexInputState::InputAttribute{RHIVertexSemantics::Position, 0, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, position)},
	        VertexInputState::InputAttribute{RHIVertexSemantics::Normal, 1, 0, RHIFormat::R32G32B32_FLOAT, offsetof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex, normal)},
	    },
	    {
	        VertexInputState::InputBinding{0, sizeof(Resource<ResourceType::SkinnedMesh>::SkinnedVertex), RHIVertexInputRate::Vertex},
	    }});

	{
		glm::vec3 position  = center + radius * glm::vec3(0.f, 0.f, 1.f);
		glm::vec3 direction = glm::normalize(center - position);
		glm::vec3 right     = glm::normalize(glm::cross(direction, glm::vec3{0.f, 1.f, 0.f}));
		glm::vec3 up        = glm::normalize(glm::cross(right, direction));
		glm::mat4 transform = glm::perspective(glm::radians(45.f), 1.f, 0.01f, 1000.f) * glm::lookAt(position, center, up);
		uniform_buffer->CopyToDevice(glm::value_ptr(transform), sizeof(transform));
	}

	auto descriptor = rhi_context->CreateDescriptor(shader_meta);
	descriptor->BindBuffer("UniformBuffer", uniform_buffer.get());

	render_target->Set(0, m_thumbnail.get(), TextureRange{}, ColorAttachment{RHILoadAction::Clear, RHIStoreAction::Store, {0.1f, 0.1f, 0.1f, 1.f}});
	render_target->Set(depth_buffer.get(), TextureRange{}, DepthStencilAttachment{});

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();
	cmd_buffer->ResourceStateTransition({
	                                        TextureStateTransition{m_thumbnail.get(), RHIResourceState::Undefined, RHIResourceState::RenderTarget},
	                                        TextureStateTransition{depth_buffer.get(), RHIResourceState::Undefined, RHIResourceState::DepthWrite},
	                                    },
	                                    {});
	cmd_buffer->BeginRenderPass(render_target.get());
	cmd_buffer->SetViewport(128, 128);
	cmd_buffer->SetScissor(128, 128);
	cmd_buffer->BindDescriptor(descriptor);
	cmd_buffer->BindPipelineState(pipeline_state.get());
	cmd_buffer->BindVertexBuffer(0, m_impl->vertex_buffer.get());
	cmd_buffer->BindIndexBuffer(m_impl->index_buffer.get());
	cmd_buffer->DrawIndexed(static_cast<uint32_t>(m_impl->index_count));
	cmd_buffer->EndRenderPass();
	cmd_buffer->ResourceStateTransition({
	                                        TextureStateTransition{m_thumbnail.get(), RHIResourceState::RenderTarget, RHIResourceState::TransferSource},
	                                    },
	                                    {});
	cmd_buffer->CopyTextureToBuffer(m_thumbnail.get(), staging_buffer.get(), 0, 0, 1);
	cmd_buffer->End();
	rhi_context->Execute(cmd_buffer);

	std::vector<uint8_t> staging_data(staging_buffer->GetDesc().size);
	staging_buffer->CopyToHost(staging_data.data(), staging_buffer->GetDesc().size);

	return staging_data;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/Texture2D.cpp
================================================
#include "Resource/Texture2D.hpp"

#include <RHI/RHIContext.hpp>

#include <fstream>

namespace Ilum
{
struct Resource<ResourceType::Texture2D>::Impl
{
	std::unique_ptr<RHITexture> texture = nullptr;
};

Resource<ResourceType::Texture2D>::Resource(RHIContext *rhi_context, const std::string &name) :
    IResource(rhi_context, name, ResourceType::Texture2D)
{
}

Resource<ResourceType::Texture2D>::Resource(RHIContext *rhi_context, std::vector<uint8_t> &&data, const TextureDesc &desc) :
    IResource(desc.name)
{
	m_impl = std::make_unique<Impl>();

	m_impl->texture = rhi_context->CreateTexture(desc);
	m_thumbnail     = rhi_context->CreateTexture2D(128, 128, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::ShaderResource | RHITextureUsage::Transfer, false);

	BufferDesc buffer_desc = {};
	buffer_desc.size       = glm::max(data.size(), 4ull * 128ull * 128ull);
	buffer_desc.usage      = RHIBufferUsage::Transfer;
	buffer_desc.memory     = RHIMemoryUsage::CPU_TO_GPU;

	auto staging_buffer = rhi_context->CreateBuffer(buffer_desc);
	std::memcpy(staging_buffer->Map(), data.data(), data.size());
	staging_buffer->Unmap();

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	         m_impl->texture.get(),
	         RHIResourceState::Undefined,
	         RHIResourceState::TransferDest,
	         TextureRange{RHITextureDimension::Texture2D, 0, m_impl->texture.get()->GetDesc().mips, 0, 1}},
	     TextureStateTransition{
	         m_thumbnail.get(),
	         RHIResourceState::Undefined,
	         RHIResourceState::TransferDest,
	         TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
	    {});
	cmd_buffer->CopyBufferToTexture(staging_buffer.get(), m_impl->texture.get(), 0, 0, 1);
	cmd_buffer->GenerateMipmaps(m_impl->texture.get(), RHIResourceState::TransferDest, RHIFilter::Linear);
	cmd_buffer->BlitTexture(m_impl->texture.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, RHIResourceState::TransferDest,
	                        m_thumbnail.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, RHIResourceState::TransferDest);
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	         m_impl->texture.get(),
	         RHIResourceState::TransferDest,
	         RHIResourceState::ShaderResource,
	         TextureRange{RHITextureDimension::Texture2D, 0, m_impl->texture.get()->GetDesc().mips, 0, 1}},
	     TextureStateTransition{
	         m_thumbnail.get(),
	         RHIResourceState::TransferDest,
	         RHIResourceState::TransferSource,
	         TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
	    {});
	cmd_buffer->CopyTextureToBuffer(m_thumbnail.get(), staging_buffer.get(), 0, 0, 1);
	cmd_buffer->End();

	rhi_context->Execute(cmd_buffer);

	std::vector<uint8_t> thumbnail_data(4 * 128 * 128);
	std::memcpy(thumbnail_data.data(), staging_buffer->Map(), thumbnail_data.size());
	staging_buffer->Unmap();

	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Texture2D), thumbnail_data, desc, data);
}

Resource<ResourceType::Texture2D>::~Resource()
{
	m_impl.reset();
}

bool Resource<ResourceType::Texture2D>::Validate() const
{
	return m_impl != nullptr;
}

void Resource<ResourceType::Texture2D>::Load(RHIContext *rhi_context)
{
	std::vector<uint8_t> thumbnail_data, data;
	TextureDesc          desc;

	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::Texture2D), thumbnail_data, desc, data);

	m_impl = std::make_unique<Impl>();

	m_impl->texture = rhi_context->CreateTexture(desc);

	BufferDesc buffer_desc = {};
	buffer_desc.size       = data.size();
	buffer_desc.usage      = RHIBufferUsage::Transfer;
	buffer_desc.memory     = RHIMemoryUsage::CPU_TO_GPU;

	auto staging_buffer = rhi_context->CreateBuffer(buffer_desc);
	std::memcpy(staging_buffer->Map(), data.data(), buffer_desc.size);
	staging_buffer->Unmap();

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	        m_impl->texture.get(),
	        RHIResourceState::Undefined,
	        RHIResourceState::TransferDest,
	        TextureRange{RHITextureDimension::Texture2D, 0, m_impl->texture.get()->GetDesc().mips, 0, 1}}},
	    {});
	cmd_buffer->CopyBufferToTexture(staging_buffer.get(), m_impl->texture.get(), 0, 0, 1);
	cmd_buffer->GenerateMipmaps(m_impl->texture.get(), RHIResourceState::TransferDest, RHIFilter::Linear);
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	        m_impl->texture.get(),
	        RHIResourceState::TransferDest,
	        RHIResourceState::ShaderResource,
	        TextureRange{RHITextureDimension::Texture2D, 0, m_impl->texture.get()->GetDesc().mips, 0, 1}}},
	    {});
	cmd_buffer->End();

	rhi_context->Execute(cmd_buffer);
}

RHITexture *Resource<ResourceType::Texture2D>::GetTexture() const
{
	return m_impl->texture.get();
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource/TextureCube.cpp
================================================
#include "Resource/TextureCube.hpp"

#include <RHI/RHIContext.hpp>
#include <ShaderCompiler/ShaderCompiler.hpp>

#include <fstream>

namespace Ilum
{
struct Resource<ResourceType::TextureCube>::Impl
{
	std::unique_ptr<RHITexture> texture = nullptr;
};

Resource<ResourceType::TextureCube>::Resource(RHIContext *rhi_context, const std::string &name) :
    IResource(rhi_context, name, ResourceType::TextureCube)
{
}

Resource<ResourceType::TextureCube>::Resource(RHIContext *rhi_context, std::vector<uint8_t> &&data, const TextureDesc &desc) :
    IResource(desc.name)
{
	m_impl = std::make_unique<Impl>();

	auto cubemap2d = rhi_context->CreateTexture(desc);

	TextureDesc cubemap_desc = desc;
	cubemap_desc.width       = 512;
	cubemap_desc.height      = 512;
	cubemap_desc.depth       = 1;
	cubemap_desc.mips        = 5;
	cubemap_desc.layers      = 6;
	cubemap_desc.format      = RHIFormat::R32G32B32A32_FLOAT;
	cubemap_desc.usage |= RHITextureUsage::RenderTarget;

	m_impl->texture = rhi_context->CreateTexture(cubemap_desc);
	m_thumbnail     = rhi_context->CreateTextureCube(128, 128, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::ShaderResource | RHITextureUsage::Transfer, false);

	auto cubemap_buffer = rhi_context->CreateBuffer(4ull * 1024ull * 1024ull * 4ull * 6ull, RHIBufferUsage::Transfer, RHIMemoryUsage::GPU_TO_CPU);
	auto staging_buffer = rhi_context->CreateBuffer(glm::max(data.size(), 4ull * 128ull * 128ull), RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
	staging_buffer->CopyToDevice(data.data(), staging_buffer->GetDesc().size);

	// Convert equirectangular to cubemap
	// std::vector<uint8_t> raw_shader;
	// Path::GetInstance().Read("./Source/Shaders/PreProcess/EquirectangularToCubemap.hlsl", raw_shader);

	// std::string shader_source;
	// shader_source.resize(raw_shader.size());
	// std::memcpy(shader_source.data(), raw_shader.data(), raw_shader.size());
	// shader_source += "\n";

	// ShaderDesc vertex_shader_desc  = {};
	// vertex_shader_desc.path = "./Source/Shaders/PreProcess/EquirectangularToCubemap.hlsl";
	// vertex_shader_desc.entry_point = "VSmain";
	// vertex_shader_desc.stage       = RHIShaderStage::Vertex;
	// vertex_shader_desc.source      = ShaderSource::HLSL;
	// vertex_shader_desc.target      = ShaderTarget::SPIRV;
	// vertex_shader_desc.code        = shader_source;

	// ShaderDesc fragment_shader_desc  = {};
	// fragment_shader_desc.path = "./Source/Shaders/PreProcess/EquirectangularToCubemap.hlsl";
	// fragment_shader_desc.entry_point = "PSmain";
	// fragment_shader_desc.stage       = RHIShaderStage::Fragment;
	// fragment_shader_desc.source      = ShaderSource::HLSL;
	// fragment_shader_desc.target      = ShaderTarget::SPIRV;
	// fragment_shader_desc.code        = shader_source;

	// ShaderMeta vertex_meta   = {};
	// ShaderMeta fragment_meta = {};

	// auto vertex_shader_spirv   = ShaderCompiler::GetInstance().Compile(vertex_shader_desc, vertex_meta);
	// auto fragment_shader_spirv = ShaderCompiler::GetInstance().Compile(fragment_shader_desc, fragment_meta);

	// auto vertex_shader   = rhi_context->CreateShader("VSmain", vertex_shader_spirv);
	// auto fragment_shader = rhi_context->CreateShader("PSmain", fragment_shader_spirv);

	// ShaderMeta shader_meta = vertex_meta;
	// shader_meta += fragment_meta;

	// SERIALIZE("Asset/BuildIn/equirectangular_to_cubemap.shader.asset", vertex_shader_spirv, fragment_shader_spirv, shader_meta);

	std::vector<uint8_t> vertex_shader_spirv, fragment_shader_spirv;
	ShaderMeta           shader_meta;

	DESERIALIZE("Asset/BuildIn/equirectangular_to_cubemap.shader.asset", vertex_shader_spirv, fragment_shader_spirv, shader_meta);

	auto vertex_shader   = rhi_context->CreateShader("VSmain", vertex_shader_spirv);
	auto fragment_shader = rhi_context->CreateShader("PSmain", fragment_shader_spirv);

	BlendState blend_state = {};
	blend_state.attachment_states.resize(1);

	DepthStencilState depth_stencil_state  = {};
	depth_stencil_state.depth_test_enable  = false;
	depth_stencil_state.depth_write_enable = false;

	auto pipeline_state = rhi_context->CreatePipelineState();
	auto descriptor     = rhi_context->CreateDescriptor(shader_meta);
	auto render_target  = rhi_context->CreateRenderTarget();

	render_target->Set(0, m_impl->texture.get(), TextureRange{RHITextureDimension::Texture2DArray, 0, 1, 0, 6}, ColorAttachment{});

	pipeline_state->SetShader(RHIShaderStage::Vertex, vertex_shader.get());
	pipeline_state->SetShader(RHIShaderStage::Fragment, fragment_shader.get());
	pipeline_state->SetBlendState(blend_state);
	pipeline_state->SetDepthStencilState(depth_stencil_state);

	descriptor->BindTexture("InputTexture", cubemap2d.get(), RHITextureDimension::Texture2D)
	    .BindSampler("TexSampler", rhi_context->CreateSampler(SamplerDesc::LinearClamp()));

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	         cubemap2d.get(),
	         RHIResourceState::Undefined,
	         RHIResourceState::TransferDest,
	         TextureRange{RHITextureDimension::Texture2D, 0, cubemap2d.get()->GetDesc().mips, 0, 1}},
	     TextureStateTransition{
	         m_thumbnail.get(),
	         RHIResourceState::Undefined,
	         RHIResourceState::TransferDest,
	         TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
	    {});
	// Copy to thumbail
	cmd_buffer->CopyBufferToTexture(staging_buffer.get(), cubemap2d.get(), 0, 0, 1);
	cmd_buffer->BlitTexture(cubemap2d.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, RHIResourceState::TransferDest,
	                        m_thumbnail.get(), TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}, RHIResourceState::TransferDest);
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	         cubemap2d.get(),
	         RHIResourceState::TransferDest,
	         RHIResourceState::ShaderResource,
	         TextureRange{RHITextureDimension::Texture2D, 0, cubemap2d.get()->GetDesc().mips, 0, 1}},
	     TextureStateTransition{
	         m_thumbnail.get(),
	         RHIResourceState::TransferDest,
	         RHIResourceState::TransferSource,
	         TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}},
	     TextureStateTransition{
	         m_impl->texture.get(),
	         RHIResourceState::Undefined,
	         RHIResourceState::RenderTarget,
	         TextureRange{RHITextureDimension::Texture2DArray, 0, 5, 0, 6}}},
	    {});

	// Generate cubemap
	cmd_buffer->BeginRenderPass(render_target.get());
	cmd_buffer->SetViewport(512.f, 512.f);
	cmd_buffer->SetScissor(512, 512);
	cmd_buffer->BindDescriptor(descriptor);
	cmd_buffer->BindPipelineState(pipeline_state.get());
	cmd_buffer->Draw(3, 6);
	cmd_buffer->EndRenderPass();

	// Generate mipmap
	cmd_buffer->GenerateMipmaps(m_impl->texture.get(), RHIResourceState::RenderTarget, RHIFilter::Linear);

	cmd_buffer->CopyTextureToBuffer(m_thumbnail.get(), staging_buffer.get(), 0, 0, 1);
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	        m_impl->texture.get(),
	        RHIResourceState::TransferDest,
	        RHIResourceState::TransferSource,
	        TextureRange{RHITextureDimension::TextureCube, 0, 5, 0, 6}}},
	    {});
	cmd_buffer->CopyTextureToBuffer(m_impl->texture.get(), cubemap_buffer.get(), 0, 0, 6);
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	        m_impl->texture.get(),
	        RHIResourceState::TransferSource,
	        RHIResourceState::ShaderResource,
	        TextureRange{RHITextureDimension::TextureCube, 0, 5, 0, 6}}},
	    {});
	cmd_buffer->End();

	rhi_context->Execute(cmd_buffer);

	std::vector<uint8_t> thumbnail_data(4 * 128 * 128);
	staging_buffer->CopyToHost(thumbnail_data.data(), thumbnail_data.size());

	std::vector<uint8_t> cubemap_data(cubemap_buffer->GetDesc().size);
	cubemap_buffer->CopyToHost(cubemap_data.data(), cubemap_data.size());

	SERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::TextureCube), thumbnail_data, cubemap_desc, cubemap_data);
}

Resource<ResourceType::TextureCube>::~Resource()
{
	m_impl.reset();
}

bool Resource<ResourceType::TextureCube>::Validate() const
{
	return m_impl != nullptr;
}

void Resource<ResourceType::TextureCube>::Load(RHIContext *rhi_context)
{
	std::vector<uint8_t> thumbnail_data, cubemap_data;
	TextureDesc          desc;

	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) ResourceType::TextureCube), thumbnail_data, desc, cubemap_data);

	m_impl = std::make_unique<Impl>();

	m_impl->texture = rhi_context->CreateTexture(desc);

	auto staging_buffer = rhi_context->CreateBuffer(cubemap_data.size(), RHIBufferUsage::Transfer, RHIMemoryUsage::CPU_TO_GPU);
	staging_buffer->CopyToDevice(cubemap_data.data(), cubemap_data.size());

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	        m_impl->texture.get(),
	        RHIResourceState::Undefined,
	        RHIResourceState::TransferDest,
	        TextureRange{RHITextureDimension::TextureCube, 0, m_impl->texture.get()->GetDesc().mips, 0, m_impl->texture.get()->GetDesc().layers}}},
	    {});
	cmd_buffer->CopyBufferToTexture(staging_buffer.get(), m_impl->texture.get(), 0, 0, m_impl->texture.get()->GetDesc().layers);
	cmd_buffer->GenerateMipmaps(m_impl->texture.get(), RHIResourceState::TransferDest, RHIFilter::Linear);
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	        m_impl->texture.get(),
	        RHIResourceState::TransferDest,
	        RHIResourceState::ShaderResource,
	        TextureRange{RHITextureDimension::TextureCube, 0, m_impl->texture.get()->GetDesc().mips, 0, m_impl->texture.get()->GetDesc().layers}}},
	    {});
	cmd_buffer->End();

	rhi_context->Execute(cmd_buffer);
}

RHITexture *Resource<ResourceType::TextureCube>::GetTexture() const
{
	return m_impl->texture.get();
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/Resource.cpp
================================================
#include "Resource.hpp"
#include "Resource/Animation.hpp"
#include "Resource/Material.hpp"
#include "Resource/Mesh.hpp"
#include "Resource/Prefab.hpp"
#include "Resource/RenderPipeline.hpp"
#include "Resource/SkinnedMesh.hpp"
#include "Resource/Texture2D.hpp"
#include "Resource/TextureCube.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
IResource::IResource(const std::string &name) :
    m_name(name)
{
}

IResource::IResource(RHIContext *rhi_context, const std::string &name, ResourceType type) :
    m_name(name)
{
	std::vector<uint8_t> thumbnail_data;
	DESERIALIZE(fmt::format("Asset/Meta/{}.{}.asset", m_name, (uint32_t) type), thumbnail_data);

	if (thumbnail_data.empty())
	{
		return;
	}

	UpdateThumbnail(rhi_context, thumbnail_data);
}

const std::string &IResource::GetName() const
{
	return m_name;
}

size_t IResource::GetUUID() const
{
	return Hash(m_name);
}

RHITexture *IResource::GetThumbnail() const
{
	return m_thumbnail ? m_thumbnail.get() : nullptr;
}

void IResource::UpdateThumbnail(RHIContext *rhi_context, const std::vector<uint8_t> &thumbnail_data)
{
	m_thumbnail = rhi_context->CreateTexture2D(128, 128, RHIFormat::R8G8B8A8_UNORM, RHITextureUsage::ShaderResource | RHITextureUsage::Transfer | RHITextureUsage::RenderTarget, false);

	BufferDesc buffer_desc = {};
	buffer_desc.size       = thumbnail_data.size();
	buffer_desc.usage      = RHIBufferUsage::Transfer;
	buffer_desc.memory     = RHIMemoryUsage::CPU_TO_GPU;

	auto staging_buffer = rhi_context->CreateBuffer(buffer_desc);
	std::memcpy(staging_buffer->Map(), thumbnail_data.data(), buffer_desc.size);
	staging_buffer->Unmap();

	auto *cmd_buffer = rhi_context->CreateCommand(RHIQueueFamily::Graphics);
	cmd_buffer->Begin();
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	        m_thumbnail.get(),
	        RHIResourceState::Undefined,
	        RHIResourceState::TransferDest,
	        TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
	    {});
	cmd_buffer->CopyBufferToTexture(staging_buffer.get(), m_thumbnail.get(), 0, 0, 1);
	cmd_buffer->GenerateMipmaps(m_thumbnail.get(), RHIResourceState::TransferDest, RHIFilter::Linear);
	cmd_buffer->ResourceStateTransition(
	    {TextureStateTransition{
	        m_thumbnail.get(),
	        RHIResourceState::TransferDest,
	        RHIResourceState::ShaderResource,
	        TextureRange{RHITextureDimension::Texture2D, 0, 1, 0, 1}}},
	    {});
	cmd_buffer->End();

	rhi_context->Execute(cmd_buffer);
}

template class Resource<ResourceType::Mesh>;
template class Resource<ResourceType::SkinnedMesh>;
template class Resource<ResourceType::Material>;
template class Resource<ResourceType::Texture2D>;
template class Resource<ResourceType::TextureCube>;
template class Resource<ResourceType::Prefab>;
template class Resource<ResourceType::Animation>;
template class Resource<ResourceType::RenderPipeline>;
template class Resource<ResourceType::Scene>;
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Private/Resource/ResourceManager.cpp
================================================
#include "ResourceManager.hpp"
#include "Importer.hpp"
#include "Resource.hpp"
#include "Resource/Animation.hpp"
#include "Resource/Material.hpp"
#include "Resource/Mesh.hpp"
#include "Resource/Prefab.hpp"
#include "Resource/RenderPipeline.hpp"
#include "Resource/Scene.hpp"
#include "Resource/SkinnedMesh.hpp"
#include "Resource/Texture2D.hpp"
#include "Resource/TextureCube.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
struct IResourceManager
{
	IResourceManager(RHIContext *rhi_context) :
	    rhi_context(rhi_context)
	{
	}

	virtual ~IResourceManager() = default;

	virtual void Tick() = 0;

	virtual IResource *Get(size_t uuid) = 0;

	virtual size_t GetValidResourceCount() = 0;

	virtual const std::string GetName(size_t uuid) = 0;

	virtual RHITexture *GetThumbnail(size_t uuid) = 0;

	virtual bool Valid(size_t uuid) = 0;

	virtual bool Has(size_t uuid) = 0;

	virtual size_t Index(size_t uuid) = 0;

	virtual void Erase(size_t uuid) = 0;

	virtual void Import(ResourceManager *manager, const std::string &path) = 0;

	virtual void Add(std::unique_ptr<IResource> &&resource, size_t uuid) = 0;

	virtual const std::vector<std::string> GetResources(bool only_valid) const = 0;

	virtual bool Update() const = 0;

	virtual void SetDirty() = 0;

	RHIContext *rhi_context = nullptr;
};

template <ResourceType _Ty>
struct TResourceManager : public IResourceManager
{
	TResourceManager(RHIContext *rhi_context) :
	    IResourceManager(rhi_context)
	{
	}

	virtual ~TResourceManager() = default;

	virtual void Tick() override
	{
		deprecates.clear();
		update = false;
	}

	virtual Resource<_Ty> *Get(size_t uuid) override
	{
		if (valid_lookup.find(uuid) != valid_lookup.end())
		{
			auto *resource = valid_resources.at(valid_lookup.at(uuid));
			return resource;
		}
		else if (resource_lookup.find(uuid) != resource_lookup.end())
		{
			auto &resource = resources[resource_lookup[uuid]];
			resource->Load(rhi_context);
			valid_lookup.emplace(uuid, valid_resources.size());
			valid_resources.push_back(resource.get());
			update = true;
			return resource.get();
		}
		return nullptr;
	}

	virtual size_t GetValidResourceCount() override
	{
		return valid_resources.size();
	}

	virtual const std::string GetName(size_t uuid) override
	{
		return Has(uuid) ? resources[resource_lookup[uuid]]->GetName() : "";
	}

	virtual RHITexture *GetThumbnail(size_t uuid) override
	{
		return Has(uuid) ? resources.at(resource_lookup.at(uuid))->GetThumbnail() : nullptr;
	}

	virtual bool Valid(size_t uuid) override
	{
		return valid_lookup.find(uuid) != valid_lookup.end();
	}

	virtual bool Has(size_t uuid) override
	{
		return resource_lookup.find(uuid) != resource_lookup.end();
	}

	virtual size_t Index(size_t uuid) override
	{
		return (Valid(uuid) || Get(uuid)) ? valid_lookup.at(uuid) : ~0U;
	}

	virtual void Erase(size_t uuid) override
	{
		if (valid_lookup.find(uuid) != valid_lookup.end())
		{
			size_t last_uuid = ~0U;
			if (valid_resources.size() > 1)
			{
				for (auto &[uuid_, index] : valid_lookup)
				{
					if (index + 1 == valid_lookup.size())
					{
						last_uuid = uuid_;
						break;
					}
				}

				valid_lookup[last_uuid] = valid_lookup[uuid];
				std::swap(valid_resources.back(), valid_resources[valid_lookup[uuid]]);
			}

			valid_resources.pop_back();
			valid_lookup.erase(uuid);
			update = true;
		}

		if (resource_lookup.find(uuid) != resource_lookup.end())
		{
			size_t last_uuid = ~0U;
			if (resources.size() > 1)
			{
				for (auto &[uuid_, index] : resource_lookup)
				{
					if (index + 1 == resource_lookup.size())
					{
						last_uuid = uuid_;
						break;
					}
				}

				resource_lookup[last_uuid] = resource_lookup[uuid];
				std::swap(resources.back(), resources[resource_lookup[uuid]]);
			}

			deprecates.emplace_back(std::move(resources.back()));
			resources.pop_back();
			resource_lookup.erase(uuid);
			update = true;
		}
	}

	virtual void Import(ResourceManager *manager, const std::string &path) override
	{
		Importer<_Ty>::Import(manager, path, rhi_context);
	}

	virtual void Add(std::unique_ptr<IResource> &&resource, size_t uuid) override
	{
		if (resource_lookup.find(uuid) == resource_lookup.end())
		{
			resource_lookup.emplace(uuid, resources.size());
			resources.emplace_back(std::unique_ptr<Resource<_Ty>>(dynamic_cast<Resource<_Ty> *>(resource.release())));

			if (resources.back()->Validate())
			{
				valid_lookup.emplace(uuid, valid_resources.size());
				valid_resources.push_back(resources.back().get());
			}

			update = true;
		}
	}

	virtual const std::vector<std::string> GetResources(bool only_valid) const override
	{
		std::vector<std::string> handles;
		if (only_valid)
		{
			handles.resize(valid_resources.size());
			std::transform(valid_resources.begin(), valid_resources.end(), handles.begin(), [](const auto &resource) {
				return resource->GetName();
			});
		}
		else
		{
			handles.resize(resources.size());
			std::transform(resources.begin(), resources.end(), handles.begin(), [](const auto &resource) {
				return resource->GetName();
			});
		}

		return handles;
	}

	virtual bool Update() const override
	{
		return update;
	}

	virtual void SetDirty() override
	{
		update = true;
	}

	std::vector<std::unique_ptr<Resource<_Ty>>> resources;
	std::unordered_map<size_t, size_t>          resource_lookup;

	std::vector<Resource<_Ty> *>       valid_resources;
	std::unordered_map<size_t, size_t> valid_lookup;        // uuid - index

	std::vector<std::unique_ptr<Resource<_Ty>>> deprecates;

	bool update = false;
};

struct ResourceManager::Impl
{
	std::map<ResourceType, std::unique_ptr<IResourceManager>> managers;
};

ResourceManager::ResourceManager(RHIContext *rhi_context)
{
	m_impl = new Impl;
	m_impl->managers.emplace(ResourceType::Texture2D, std::make_unique<TResourceManager<ResourceType::Texture2D>>(rhi_context));
	m_impl->managers.emplace(ResourceType::TextureCube, std::make_unique<TResourceManager<ResourceType::TextureCube>>(rhi_context));
	m_impl->managers.emplace(ResourceType::Mesh, std::make_unique<TResourceManager<ResourceType::Mesh>>(rhi_context));
	m_impl->managers.emplace(ResourceType::SkinnedMesh, std::make_unique<TResourceManager<ResourceType::SkinnedMesh>>(rhi_context));
	m_impl->managers.emplace(ResourceType::Material, std::make_unique<TResourceManager<ResourceType::Material>>(rhi_context));
	m_impl->managers.emplace(ResourceType::Animation, std::make_unique<TResourceManager<ResourceType::Animation>>(rhi_context));
	m_impl->managers.emplace(ResourceType::Prefab, std::make_unique<TResourceManager<ResourceType::Prefab>>(rhi_context));
	m_impl->managers.emplace(ResourceType::RenderPipeline, std::make_unique<TResourceManager<ResourceType::RenderPipeline>>(rhi_context));
	m_impl->managers.emplace(ResourceType::Scene, std::make_unique<TResourceManager<ResourceType::Scene>>(rhi_context));

	std::unordered_map<ResourceType, std::function<void(RHIContext *, const std::string &)>> loading_meta = {
#define LOADING_META(RESOURCE_TYPE)                                                                                     \
	{                                                                                                                   \
		RESOURCE_TYPE, [&](RHIContext *rhi_context, const std::string &name) { Add<RESOURCE_TYPE>(rhi_context, name); } \
	}

	    LOADING_META(ResourceType::Texture2D),
	    LOADING_META(ResourceType::TextureCube),
	    LOADING_META(ResourceType::Mesh),
	    LOADING_META(ResourceType::SkinnedMesh),
	    LOADING_META(ResourceType::Texture2D),
	    LOADING_META(ResourceType::Material),
	    LOADING_META(ResourceType::Animation),
	    LOADING_META(ResourceType::Prefab),
	    LOADING_META(ResourceType::RenderPipeline),
	    LOADING_META(ResourceType::Scene),
	};

	for (const auto &file : std::filesystem::directory_iterator("Asset/Meta/"))
	{
		std::string filename = file.path().filename().string();
		if (Path::GetInstance().GetFileExtension(filename) == ".asset")
		{
			std::string  resource_name = "";
			ResourceType resource_type = ResourceType::Unknown;

			size_t last_pos        = filename.find_last_of('.');
			size_t second_last_pos = filename.substr(0, last_pos).find_last_of('.');

			resource_name = filename.substr(0, second_last_pos);
			resource_type = (ResourceType) (std::atoi(filename.substr(second_last_pos + 1, last_pos - second_last_pos).c_str()));

			loading_meta.at(resource_type)(rhi_context, resource_name);
		}
	}
}

ResourceManager::~ResourceManager()
{
	delete m_impl;
}

void ResourceManager::Tick()
{
	for (auto &[type, manager] : m_impl->managers)
	{
		manager->Tick();
	}
}

IResource *ResourceManager::Get(ResourceType type, size_t uuid)
{
	return m_impl->managers.at(type)->Get(uuid);
}

size_t ResourceManager::GetValidResourceCount(ResourceType type) const
{
	return m_impl->managers.at(type)->GetValidResourceCount();
}

RHITexture *ResourceManager::GetThumbnail(ResourceType type, size_t uuid)
{
	return m_impl->managers.at(type)->GetThumbnail(uuid);
}

bool ResourceManager::Valid(ResourceType type, size_t uuid)
{
	return m_impl->managers.at(type)->Valid(uuid);
}

bool ResourceManager::Has(ResourceType type, size_t uuid)
{
	return m_impl->managers.at(type)->Has(uuid);
}

size_t ResourceManager::Index(ResourceType type, size_t uuid)
{
	return m_impl->managers.at(type)->Index(uuid);
}

void ResourceManager::Import(ResourceType type, const std::string &path)
{
	m_impl->managers.at(type)->Import(this, path);
}

void ResourceManager::Erase(ResourceType type, size_t uuid)
{
	std::string asset_path = fmt::format("Asset/Meta/{}.{}.asset", m_impl->managers.at(type)->GetName(uuid), (uint32_t) type);
	if (Path::GetInstance().IsExist(asset_path))
	{
		Path::GetInstance().DeletePath(asset_path);
	}
	m_impl->managers.at(type)->Erase(uuid);
}

void ResourceManager::Add(ResourceType type, std::unique_ptr<IResource> &&resource)
{
	size_t uuid = resource->GetUUID();
	m_impl->managers.at(type)->Add(std::move(resource), uuid);
}

const std::vector<std::string> ResourceManager::GetResources(ResourceType type, bool only_valid) const
{
	return m_impl->managers.at(type)->GetResources(only_valid);
}

bool ResourceManager::Update(ResourceType type) const
{
	return m_impl->managers.at(type)->Update();
}

void ResourceManager::SetDirty(ResourceType type)
{
	return m_impl->managers.at(type)->SetDirty();
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Importer.hpp
================================================
#pragma once

#include "Resource.hpp"

namespace Ilum
{
class RHIContext;
class ResourceManager;

template <ResourceType Type>
class Importer
{
  public:
	Importer() = default;

	virtual ~Importer() = default;

	static std::unique_ptr<Importer<Type>> &GetInstance(const std::string &plugin);

	static void Import(ResourceManager* manager, const std::string &path, RHIContext *rhi_context);

  protected:
	virtual void Import_(ResourceManager *manager, const std::string &path, RHIContext *rhi_context) = 0;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/Animation.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/quaternion.hpp>

namespace Ilum
{
class Animation;
class RHIContext;
class RHIBuffer;
class RHITexture;

class Bone
{
  public:
	struct KeyPosition
	{
		glm::vec3 position;
		float     time_stamp;

		template <typename Archive>
		void serialize(Archive &archive)
		{
			archive(position, time_stamp);
		}
	};

	struct KeyRotation
	{
		glm::quat orientation;
		float     time_stamp;

		template <typename Archive>
		void serialize(Archive &archive)
		{
			archive(orientation, time_stamp);
		}
	};

	struct KeyScale
	{
		glm::vec3 scale;
		float     time_stamp;

		template <typename Archive>
		void serialize(Archive &archive)
		{
			archive(scale, time_stamp);
		}
	};

	struct BoneMatrix
	{
		float     frame;
		glm::mat4 transform = glm::mat4(1.f);

		template <typename Archive>
		void serialize(Archive &archive)
		{
			archive(frame, transform);
		}
	};

  public:
	Bone() = default;

	Bone(
	    const std::string         &name,
	    uint32_t                   id,
	    glm::mat4                  offset,
	    std::vector<KeyPosition> &&positions,
	    std::vector<KeyRotation> &&rotations,
	    std::vector<KeyScale>    &&scales);

	~Bone() = default;

	void Update(float time);

	glm::mat4 GetLocalTransform() const;

	std::string GetBoneName() const;

	uint32_t GetBoneID() const;

	glm::mat4 GetBoneOffset() const;

	size_t GetPositionIndex(float time) const;

	size_t GetRotationIndex(float time) const;

	size_t GetScaleIndex(float time) const;

	glm::mat4 GetLocalTransform(float time) const;

	glm::mat4 GetTransformedOffset(float time) const;

	float GetMaxTimeStamp() const;

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(m_name, m_id, m_offset, m_positions, m_rotations, m_scales, m_max_timestamp, m_local_transfrom);
	}

  private:
	float GetScaleFactor(float last, float next, float time) const;

	glm::mat4 InterpolatePosition(float time) const;

	glm::mat4 InterpolateRotation(float time) const;

	glm::mat4 InterpolateScaling(float time) const;

  private:
	std::string m_name;
	uint32_t    m_id;
	glm::mat4   m_offset;

	std::vector<KeyPosition> m_positions;
	std::vector<KeyRotation> m_rotations;
	std::vector<KeyScale>    m_scales;

	float m_max_timestamp = 0.f;

	glm::mat4 m_local_transfrom;
};

struct HierarchyNode
{
	std::string name;
	glm::mat4   transform;

	std::vector<HierarchyNode> children;

	template <typename Archive>
	void serialize(Archive &archive)
	{
		archive(name, transform, children);
	}
};

template <>
class Resource<ResourceType::Animation> final : public IResource
{
  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, const std::string &name, std::vector<Bone> &&bones, HierarchyNode &&hierarchy);

	virtual ~Resource() override;

	virtual bool Validate() const override;

	virtual void Load(RHIContext *rhi_context) override;

	const std::vector<Bone> &GetBones() const;

	Bone *GetBone(const std::string &name);

	uint32_t GetBoneCount() const;

	uint32_t GetMaxBoneIndex() const;

	float GetMaxTimeStamp() const;

	uint32_t GetFrameCount() const;

	const HierarchyNode &GetHierarchyNode() const;

	void Bake(RHIContext *rhi_context);

	RHITexture *GetSkinnedMatrics() const;

	RHIBuffer *GetBoneMatrics() const;

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/Material.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class MaterialGraphDesc;
class ResourceManager;
struct MaterialData;
struct MaterialCompilationContext;

template <>
class Resource<ResourceType::Material> final : public IResource
{
  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, const std::string &name, MaterialGraphDesc &&desc);

	virtual ~Resource() override;

	virtual bool Validate() const override;

	virtual void Load(RHIContext *rhi_context) override;

	void Compile(RHIContext *rhi_context, ResourceManager *manager, RHITexture *dummy_texture, const std::string &layout = "");

	void Update(RHIContext *rhi_context, ResourceManager *manager, RHITexture *dummy_texture);

	void PostUpdate(RHIContext *rhi_context, uint32_t material_id, const std::vector<RHITexture *> &scene_texture_2d, const std::vector<RHISampler *> &samplers, RHIBuffer *material_buffers, RHIBuffer *material_offsets);

	const MaterialData &GetMaterialData() const;

	const MaterialCompilationContext &GetCompilationContext() const;

	const std::string &GetLayout() const;

	MaterialGraphDesc &GetDesc();

	bool IsValid() const;

  private:
	std::vector<uint8_t> RenderPreview(RHIContext *rhi_context, uint32_t material_id, const std::vector<RHITexture *> &scene_texture_2d, const std::vector<RHISampler *> &samplers, RHIBuffer *material_buffers, RHIBuffer *material_offsets);

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/Mesh.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <Geometry/Meshlet.hpp>

namespace Ilum
{
class RHIContext;
class RHIBuffer;
class RHIAccelerationStructure;

template <>
class Resource<ResourceType::Mesh> final : public IResource
{
  public:
	struct Vertex
	{
		alignas(16) glm::vec3 position;
		alignas(16) glm::vec3 normal;
		alignas(16) glm::vec3 tangent;

		alignas(16) glm::vec2 texcoord0;
		glm::vec2 texcoord1;

		template <typename Archive>
		void serialize(Archive &archive)
		{
			archive(position, normal, tangent, texcoord0, texcoord1);
		}
	};

  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, const std::string &name, std::vector<Vertex> &&vertices, std::vector<uint32_t> &&indices, std::vector<Meshlet> &&meshlets, std::vector<uint32_t> &&meshlet_data);

	virtual ~Resource() override;

	virtual bool Validate() const override;

	virtual void Load(RHIContext *rhi_context) override;

	RHIBuffer *GetVertexBuffer() const;

	RHIBuffer *GetIndexBuffer() const;

	RHIBuffer *GetMeshletDataBuffer() const;

	RHIBuffer *GetMeshletBuffer() const;

	RHIAccelerationStructure *GetBLAS() const;

	size_t GetVertexCount() const;

	size_t GetIndexCount() const;

	size_t GetMeshletCount() const;

	void Update(RHIContext *rhi_context, std::vector<Vertex> &&vertices, std::vector<uint32_t> &&indices, std::vector<Meshlet> &&meshlets, std::vector<uint32_t> &&meshlet_data);

  private:
	std::vector<uint8_t> RenderPreview(RHIContext *rhi_context, const glm::vec3& center, float radius);

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/Prefab.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
template <>
class Resource<ResourceType::Prefab> final : public IResource
{
  public:
	template <typename Archive>
	void serialize(Archive &archive, std::pair<ResourceType, std::string> &m)
	{
		archive(m.first, m.second);
	}

	struct Node
	{
		std::string name      = "";
		glm::mat4   transform = glm::mat4(1.f);

		std::vector<Node> children;

		std::vector<std::pair<ResourceType, std::string>> resources;

		template <typename Archive>
		void save(Archive &archive) const
		{
			archive(name, transform, children);
			archive(resources.size());
			for (auto &[type, name] : resources)
			{
				archive(type, name);
			}
		}

		template <typename Archive>
		void load(Archive &archive)
		{
			archive(name, transform, children);
			size_t count = 0;
			archive(count);
			for (size_t i = 0; i < count; i++)
			{
				ResourceType type = ResourceType::Unknown;
				std::string  name;
				archive(type, name);
				resources.emplace_back(std::make_pair(type, name));
			}
		}
	};

  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, const std::string &name, Node &&root);

	virtual ~Resource() override;

	virtual bool Validate() const override;

	virtual void Load(RHIContext *rhi_context) override;

	const Node &GetRoot() const;

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/RenderPipeline.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class RenderGraphDesc;
class RenderGraph;
class Renderer;

template <>
class Resource<ResourceType::RenderPipeline> final : public IResource
{
  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, const std::string &name, RenderGraphDesc &&desc);

	virtual ~Resource() override;

	virtual bool Validate() const override;

	virtual void Load(RHIContext *rhi_context) override;

	std::unique_ptr<RenderGraph> Compile(RHIContext *rhi_context, Renderer* renderer, glm::vec2 viewport, const std::string &layout = "");

	const std::string &GetLayout() const;

	RenderGraphDesc &GetDesc();

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/Scene.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class Scene;

template <>
class Resource<ResourceType::Scene> final : public IResource
{
  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, const std::string &name, Scene *scene);

	virtual ~Resource() override = default;

	void Update(Scene *scene);

	void Save(RHIContext *rhi_context, Scene *scene);
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/SkinnedMesh.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <Geometry/Meshlet.hpp>

#define MAX_BONE_INFLUENCE 8

namespace Ilum
{
class RHIContext;
class RHIBuffer;
class RHIAccelerationStructure;

template <>
class Resource<ResourceType::SkinnedMesh> final : public IResource
{
  public:
	struct SkinnedVertex
	{
		alignas(16) glm::vec3 position;
		alignas(16) glm::vec3 normal;
		alignas(16) glm::vec3 tangent;

		alignas(16) glm::vec2 texcoord0;
		glm::vec2 texcoord1;

		int32_t bones[8]   = {-1, -1, -1, -1, -1, -1, -1, -1};
		float   weights[8] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};

		template <typename Archive>
		void serialize(Archive &archive)
		{
			archive(position, normal, tangent, texcoord0, texcoord1, bones, weights);
		}
	};

  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, const std::string &name, std::vector<SkinnedVertex> &&vertices, std::vector<uint32_t> &&indices, std::vector<Meshlet> &&meshlets, std::vector<uint32_t> &&meshletdata);

	virtual ~Resource() override;

	virtual bool Validate() const override;

	virtual void Load(RHIContext *rhi_context) override;

	RHIBuffer *GetVertexBuffer() const;

	RHIBuffer *GetIndexBuffer() const;

	RHIBuffer *GetMeshletBuffer() const;

	RHIBuffer *GetMeshletDataBuffer() const;

	size_t GetVertexCount() const;

	size_t GetIndexCount() const;

	size_t GetMeshletCount() const;

	size_t GetBoneCount() const;

	void Update(RHIContext *rhi_context, std::vector<SkinnedVertex> &&vertices, std::vector<uint32_t> &&indices, std::vector<Meshlet> &&meshlets, std::vector<uint32_t> &&meshletdata);

  private:
	std::vector<uint8_t> RenderPreview(RHIContext *rhi_context, const glm::vec3 &center, float radius);

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/Texture2D.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
template <>
class Resource<ResourceType::Texture2D> final : public IResource
{
  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, std::vector<uint8_t> &&data, const TextureDesc &desc);

	virtual ~Resource() override;

	virtual bool Validate() const override;

	virtual void Load(RHIContext *rhi_context) override;

	RHITexture *GetTexture() const;

  private:
	struct Impl;
	std::unique_ptr<Impl> m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource/TextureCube.hpp
================================================
#pragma once

#include "../Resource.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
template <>
class Resource<ResourceType::TextureCube> final : public IResource
{
  public:
	Resource(RHIContext *rhi_context, const std::string &name);

	Resource(RHIContext *rhi_context, std::vector<uint8_t> &&data, const TextureDesc &desc);

	virtual ~Resource() override;

	virtual bool Validate() const override;

	virtual void Load(RHIContext *rhi_context) override;

	RHITexture *GetTexture() const;

  private:
	struct Impl;
	std::unique_ptr<Impl> m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Resource/Public/Resource/Resource.hpp
================================================
#pragma once

#include <Core/Core.hpp>

namespace Ilum
{
class RHITexture;
class RHIContext;

enum class ResourceType
{
	Unknown,
	Prefab,
	Mesh,
	SkinnedMesh,
	Texture2D,
	Animation,
	Material,
	RenderPipeline,
	Scene,
	TextureCube,
};

class IResource
{
  public:
	explicit IResource(const std::string &name);

	explicit IResource(RHIContext *rhi_context, const std::string &name, ResourceType type);

	virtual ~IResource() = default;

	const std::string &GetName() const;

	virtual bool Validate() const
	{
		return true;
	}

	virtual void Load(RHIContext *rhi_context)
	{
	}

	size_t GetUUID() const;

	RHITexture *GetThumbnail() const;

  protected:
	void UpdateThumbnail(RHIContext *rhi_context, const std::vector<uint8_t> &thumbnail_data);

  protected:
	std::string m_name;

	std::unique_ptr<RHITexture> m_thumbnail = nullptr;
};

template <ResourceType Type>
class Resource : public IResource
{
  public:
	Resource() = default;

	virtual ~Resource() override = default;
};
}        // namespace Ilum


================================================
FILE: Source/Runtime/Resource/Public/Resource/ResourceManager.hpp
================================================
#pragma once

#include "Resource.hpp"

#include <RHI/RHIContext.hpp>

namespace Ilum
{
class ResourceManager
{
  public:
	ResourceManager(RHIContext *rhi_context);

	~ResourceManager();

	void Tick();

	template <ResourceType Type>
	Resource<Type> *Get(const std::string &name)
	{
		return static_cast<Resource<Type> *>(Get(Type, Hash(name)));
	}

	template <ResourceType Type>
	size_t GetValidResourceCount() const
	{
		return GetValidResourceCount(Type);
	}

	template <ResourceType Type>
	RHITexture *GetThumbnail(const std::string &name)
	{
		return GetThumbnail(Type, Hash(name));
	}

	template <ResourceType Type>
	bool Valid(const std::string &name)
	{
		return Valid(Type, Hash(name));
	}

	template <ResourceType Type>
	bool Has(const std::string &name)
	{
		return Has(Type, Hash(name));
	}

	template <ResourceType Type>
	size_t Index(const std::string &name)
	{
		return Index(Type, Hash(name));
	}

	template <ResourceType Type>
	void Import(const std::string &path)
	{
		Import(Type, path);
	}

	template <ResourceType Type>
	void Erase(const std::string &path)
	{
		Erase(Type, Hash(path));
	}

	template <ResourceType Type, typename... Args>
	void Add(Args &&...args)
	{
		Add(Type, std::make_unique<Resource<Type>>(std::forward<Args>(args)...));
	}

	template <ResourceType Type>
	const std::vector<std::string> GetResources(bool only_valid = true) const
	{
		return GetResources(Type, only_valid);
	}

	template <ResourceType Type>
	bool Update() const
	{
		return Update(Type);
	}

	template <ResourceType Type>
	void SetDirty()
	{
		SetDirty(Type);
	}

  private:
	IResource *Get(ResourceType type, size_t uuid);

	size_t GetValidResourceCount(ResourceType type) const;

	RHITexture* GetThumbnail(ResourceType type, size_t uuid);

	bool Valid(ResourceType type, size_t uuid);

	bool Has(ResourceType type, size_t uuid);

	size_t Index(ResourceType type, size_t uuid);

	void Import(ResourceType type, const std::string &path);

	void Erase(ResourceType type, size_t uuid);

	void Add(ResourceType type, std::unique_ptr<IResource> &&resource);

	const std::vector<std::string> GetResources(ResourceType type, bool only_valid) const;

	bool Update(ResourceType type) const;

	void SetDirty(ResourceType type);

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Component.cpp
================================================
#include "Component.hpp"
#include "Node.hpp"

namespace Ilum
{
Component::Component(const char *name, Node *node) :
    m_name(name), p_node(node)
{
	m_update = true;
}

Component::~Component()
{
	m_update = true;
}

const char *Component::GetName() const
{
	return m_name;
}

Node *Component::GetNode() const
{
	return p_node;
}

bool Component::IsUpdate()
{
	return m_update;
}

void Component::SetUpdate(bool update)
{
	m_update = update;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/AllComponents.cpp
================================================
#include "Components/AllComponents.hpp"

#include <imgui.h>

namespace Ilum
{
namespace Cmpt
{
void SetImGuiContext(ImGuiContext *context)
{
	return ImGui::SetCurrentContext(context);
}
}        // namespace Cmpt
}        // namespace Ilum


================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Camera/Camera.cpp
================================================
#include "Components/Camera/Camera.hpp"
#include "Components/Transform.hpp"

#include <Scene/Node.hpp>

namespace Ilum
{
namespace Cmpt
{
Camera::Camera(const char *name, Node *node) :
    Component(name, node)
{
}

void Camera::SetAspect(float aspect)
{
	m_update |= (m_aspect != aspect);
	m_aspect = aspect;
}

float Camera::GetAspect()
{
	return m_aspect;
}

void Camera::SetNearPlane(float near_plane)
{
	m_update |= (near_plane != m_near);
	m_near   = near_plane;
}

void Camera::SetFarPlane(float far_plane)
{
	m_update |= (far_plane != m_far);
	m_far    = far_plane;
}

float Camera::GetNearPlane() const
{
	return m_near;
}

float Camera::GetFarPlane() const
{
	return m_far;
}

glm::mat4 Camera::GetViewMatrix()
{
	UpdateView();
	return m_view;
}

glm::mat4 Camera::GetProjectionMatrix()
{
	UpdateProjection();
	return m_projection;
}

glm::mat4 Camera::GetViewProjectionMatrix()
{
	return GetProjectionMatrix() * GetViewMatrix();
}

glm::mat4 Camera::GetInvViewMatrix()
{
	UpdateView();
	return m_inv_view;
}

glm::mat4 Camera::GetInvProjectionMatrix()
{
	UpdateProjection();
	return m_inv_projection;
}

glm::mat4 Camera::GetInvViewProjectionMatrix()
{
	return GetInvViewMatrix() * GetInvProjectionMatrix();
}

const std::array<glm::vec4, 6> &Camera::GetFrustumPlanes()
{
	glm::mat4 view_projection = GetViewProjectionMatrix();

	// Left
	m_frustum_planes[0].x = view_projection[0].w + view_projection[0].x;
	m_frustum_planes[0].y = view_projection[1].w + view_projection[1].x;
	m_frustum_planes[0].z = view_projection[2].w + view_projection[2].x;
	m_frustum_planes[0].w = view_projection[3].w + view_projection[3].x;

	// Right
	m_frustum_planes[1].x = view_projection[0].w - view_projection[0].x;
	m_frustum_planes[1].y = view_projection[1].w - view_projection[1].x;
	m_frustum_planes[1].z = view_projection[2].w - view_projection[2].x;
	m_frustum_planes[1].w = view_projection[3].w - view_projection[3].x;

	// Top
	m_frustum_planes[2].x = view_projection[0].w - view_projection[0].y;
	m_frustum_planes[2].y = view_projection[1].w - view_projection[1].y;
	m_frustum_planes[2].z = view_projection[2].w - view_projection[2].y;
	m_frustum_planes[2].w = view_projection[3].w - view_projection[3].y;

	// Bottom
	m_frustum_planes[3].x = view_projection[0].w + view_projection[0].y;
	m_frustum_planes[3].y = view_projection[1].w + view_projection[1].y;
	m_frustum_planes[3].z = view_projection[2].w + view_projection[2].y;
	m_frustum_planes[3].w = view_projection[3].w + view_projection[3].y;

	// Near
	m_frustum_planes[4].x = view_projection[0].w + view_projection[0].z;
	m_frustum_planes[4].y = view_projection[1].w + view_projection[1].z;
	m_frustum_planes[4].z = view_projection[2].w + view_projection[2].z;
	m_frustum_planes[4].w = view_projection[3].w + view_projection[3].z;

	// Far
	m_frustum_planes[5].x = view_projection[0].w - view_projection[0].z;
	m_frustum_planes[5].y = view_projection[1].w - view_projection[1].z;
	m_frustum_planes[5].z = view_projection[2].w - view_projection[2].z;
	m_frustum_planes[5].w = view_projection[3].w - view_projection[3].z;

	for (auto &plane : m_frustum_planes)
	{
		float length = glm::length(glm::vec3(plane.x, plane.y, plane.z));
		plane /= length;
	}

	return m_frustum_planes;
}

void Camera::UpdateView()
{
	if (m_inv_view != p_node->GetComponent<Cmpt::Transform>()->GetWorldTransform())
	{
		m_inv_view = p_node->GetComponent<Cmpt::Transform>()->GetWorldTransform();
		m_view     = glm::inverse(m_inv_view);
	}
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Camera/OrthographicCamera.cpp
================================================
#include "Components/Camera/OrthographicCamera.hpp"
#include "Components/Transform.hpp"

#include <Scene/Node.hpp>

#include <glm/gtc/matrix_transform.hpp>

#include <imgui.h>

namespace Ilum
{
namespace Cmpt
{
OrthographicCamera::OrthographicCamera(Node *node) :
    Camera("Orthographic Camera", node)
{
}

bool OrthographicCamera::OnImGui()
{
	m_update |= ImGui::DragFloat("Aspect", &m_aspect, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	m_update |= ImGui::DragFloat("Scale", &m_scale, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	m_update |= ImGui::DragFloat("Offset X", &m_offset_x, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	m_update |= ImGui::DragFloat("Offset Y", &m_offset_y, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	m_update |= ImGui::DragFloat("Near Plane", &m_near, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	m_update |= ImGui::DragFloat("Far Plane", &m_far, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	
	return m_update;
}

std::type_index OrthographicCamera::GetType() const
{
	return typeid(OrthographicCamera);
}

void OrthographicCamera::Save(OutputArchive &archive) const
{
	archive(m_aspect, m_near, m_far, m_view, m_inv_view, m_projection, m_inv_projection, m_view_projection, m_inv_view_projection, m_scale, m_offset_x, m_offset_y);
}

void OrthographicCamera::Load(InputArchive &archive)
{
	archive(m_aspect, m_near, m_far, m_view, m_inv_view, m_projection, m_inv_projection, m_view_projection, m_inv_view_projection, m_scale, m_offset_x, m_offset_y);
	m_update = true;
}

void OrthographicCamera::SetScale(float scale)
{
	m_update = true;
	m_scale  = scale;
}

void OrthographicCamera::SetOffset(float x, float y)
{
	m_update   = true;
	m_offset_x = x;
	m_offset_y = y;
}

float OrthographicCamera::GetScale() const
{
	return m_scale;
}

float OrthographicCamera::GetOffsetX() const
{
	return m_offset_x;
}

float OrthographicCamera::GetOffsetY() const
{
	return m_offset_y;
}

void OrthographicCamera::UpdateProjection()
{
	if (!m_update)
	{
		return;
	}

	float left   = m_offset_x - m_scale * m_aspect * 0.5f;
	float right  = m_offset_x + m_scale * m_aspect * 0.5f;
	float top    = m_offset_y + m_scale * 0.5f;
	float bottom = m_offset_y - m_scale * 0.5f;

	m_projection     = glm::ortho(left, right, bottom, top, m_near, m_far);
	m_inv_projection = glm::inverse(m_projection);
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Camera/PerspectiveCamera.cpp
================================================
#include "Components/Camera/PerspectiveCamera.hpp"
#include "Components/Transform.hpp"

#include <Scene/Node.hpp>

#include <imgui.h>

#include <glm/gtc/matrix_transform.hpp>

namespace Ilum
{
namespace Cmpt
{
PerspectiveCamera::PerspectiveCamera(Node *node) :
    Camera("Perspective Camera", node)
{
}

bool PerspectiveCamera::OnImGui()
{
	m_update |= ImGui::DragFloat("Aspect", &m_aspect, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	m_update |= ImGui::DragFloat("Fov", &m_fov, 0.01f, 0.f, 90.f, "%.3f");
	m_update |= ImGui::DragFloat("Near Plane", &m_near, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	m_update |= ImGui::DragFloat("Far Plane", &m_far, 0.01f, 0.f, std::numeric_limits<float>::max(), "%.3f");
	
	return m_update;
}

void PerspectiveCamera::Save(OutputArchive &archive) const
{
	archive(m_aspect, m_near, m_far, m_view, m_inv_view, m_projection, m_inv_projection, m_view_projection, m_inv_view_projection, m_fov);
}

void PerspectiveCamera::Load(InputArchive &archive)
{
	archive(m_aspect, m_near, m_far, m_view, m_inv_view, m_projection, m_inv_projection, m_view_projection, m_inv_view_projection, m_fov);
	m_update = true;
}

std::type_index PerspectiveCamera::GetType() const
{
	return typeid(PerspectiveCamera);
}

void PerspectiveCamera::SetFov(float fov)
{
	m_update = true;
	m_fov    = fov;
}

float PerspectiveCamera::GetFov() const
{
	return m_fov;
}

void PerspectiveCamera::UpdateProjection()
{
	if (!m_update)
	{
		return;
	}

	m_projection     = glm::perspective(glm::radians(m_fov), m_aspect, m_near, m_far);
	m_inv_projection = glm::inverse(m_projection);
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Light/DirectionalLight.cpp
================================================
#include "Components/Light/DirectionalLight.hpp"
#include "Components/Camera/Camera.hpp"
#include "Components/Transform.hpp"
#include "Node.hpp"

#include <imgui.h>

namespace Ilum
{
namespace Cmpt
{
DirectionalLight::DirectionalLight(Node *node) :
    Light("Directional Light", node)
{
}

bool DirectionalLight::OnImGui()
{
	m_update |= ImGui::ColorEdit3("Color", &m_data.color.x);
	m_update |= ImGui::DragFloat("Intensity", &m_data.intensity, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
	ImGui::Text("Shadow Map Setting");
	m_update |= ImGui::Checkbox("Cast Shadow", reinterpret_cast<bool *>(&m_data.cast_shadow));
	m_update |= ImGui::SliderInt("Filter Sample", reinterpret_cast<int32_t *>(&m_data.filter_sample), 1, 100);
	m_update |= ImGui::DragFloat("Filter Scale", &m_data.filter_scale, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
	m_update |= ImGui::DragFloat("Light Scale", &m_data.light_scale, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");

	return m_update;
}

void DirectionalLight::Save(OutputArchive &archive) const
{
	archive(m_data.intensity, m_data.filter_sample, m_data.filter_scale, m_data.light_scale);
}

void DirectionalLight::Load(InputArchive &archive)
{
	archive(m_data.intensity, m_data.filter_sample, m_data.filter_scale, m_data.light_scale);
	m_update = true;
}

std::type_index DirectionalLight::GetType() const
{
	return typeid(DirectionalLight);
}

bool DirectionalLight::CastShadow() const
{
	return m_data.cast_shadow;
}

void DirectionalLight::SetShadowID(uint32_t &shadow_id)
{
	m_data.shadow_id = m_data.cast_shadow ? shadow_id++ : ~0u;
}

size_t DirectionalLight::GetDataSize() const
{
	return sizeof(m_data);
}

void *DirectionalLight::GetData(Camera *camera)
{
	auto *transform = p_node->GetComponent<Cmpt::Transform>();

	glm::vec3 scale;
	glm::quat rotation;
	glm::vec3 translation;
	glm::vec3 skew;
	glm::vec4 perspective;
	glm::decompose(transform->GetWorldTransform(), scale, rotation, translation, skew, perspective);

	m_data.direction = glm::mat3_cast(rotation) * glm::vec3(0.f, 0.f, -1.f);

	if (camera)
	{
		float cascade_splits[4] = {0.f};

		float near_clip  = camera->GetNearPlane();
		float far_clip   = camera->GetFarPlane();
		float clip_range = far_clip - near_clip;
		float ratio      = far_clip / near_clip;

		// Calculate split depths based on view camera frustum
		for (uint32_t i = 0; i < 4; i++)
		{
			float p           = (static_cast<float>(i) + 1.f) / 4.f;
			float log         = near_clip * std::pow(ratio, p);
			float uniform     = near_clip + clip_range * p;
			float d           = 0.95f * (log - uniform) + uniform;
			cascade_splits[i] = (d - near_clip) / clip_range;
		}

		// Calculate orthographic projection matrix for each cascade
		float last_split_dist = 0.f;
		for (uint32_t i = 0; i < 4; i++)
		{
			float split_dist = cascade_splits[i];

			glm::vec3 frustum_corners[8] = {
			    glm::vec3(-1.0f, 1.0f, 0.0f),
			    glm::vec3(1.0f, 1.0f, 0.0f),
			    glm::vec3(1.0f, -1.0f, 0.0f),
			    glm::vec3(-1.0f, -1.0f, 0.0f),
			    glm::vec3(-1.0f, 1.0f, 1.0f),
			    glm::vec3(1.0f, 1.0f, 1.0f),
			    glm::vec3(1.0f, -1.0f, 1.0f),
			    glm::vec3(-1.0f, -1.0f, 1.0f)};

			// Project frustum corners into world space
			glm::mat4 inv_cam = glm::inverse(camera->GetViewProjectionMatrix());
			for (uint32_t j = 0; j < 8; j++)
			{
				glm::vec4 inv_corner = inv_cam * glm::vec4(frustum_corners[j], 1.f);
				frustum_corners[j]   = glm::vec3(inv_corner / inv_corner.w);
			}

			for (uint32_t j = 0; j < 4; j++)
			{
				glm::vec3 corner_ray   = frustum_corners[j + 4] - frustum_corners[j];
				frustum_corners[j + 4] = frustum_corners[j] + corner_ray * split_dist;
				frustum_corners[j]     = frustum_corners[j] + corner_ray * last_split_dist;
			}

			// Get frustum center
			glm::vec3 frustum_center = glm::vec3(0.0f);
			for (uint32_t j = 0; j < 8; j++)
			{
				frustum_center += frustum_corners[j];
			}
			frustum_center /= 8.0f;

			float radius = 0.0f;
			for (uint32_t j = 0; j < 8; j++)
			{
				float distance = glm::length(frustum_corners[j] - frustum_center);
				radius         = glm::max(radius, distance);
			}
			radius = std::ceil(radius * 16.0f) / 16.0f;

			glm::vec3 max_extents = glm::vec3(radius);
			glm::vec3 min_extents = -max_extents;

			max_extents.z = 1000.f;

			glm::vec3 light_dir = glm::normalize(m_data.direction);

			m_data.shadow_cam_pos[i] = glm::vec4(frustum_center - light_dir * max_extents.z, 1.0);

			glm::mat4 light_view_matrix  = glm::lookAt(glm::vec3(m_data.shadow_cam_pos[i]), frustum_center, glm::vec3(0.0f, 1.0f, 0.0f));
			glm::mat4 light_ortho_matrix = glm::ortho(min_extents.x, max_extents.x, min_extents.y, max_extents.y, -2.f * (max_extents.z - min_extents.z), max_extents.z - min_extents.z);

			// Store split distance and matrix in cascade
			m_data.split_depth[i]     = -(near_clip + split_dist * clip_range);
			m_data.view_projection[i] = light_ortho_matrix * light_view_matrix;

			// Stablize
			// glm::vec3 shadow_origin = glm::vec3(0.0f);
			// shadow_origin           = (m_data.view_projection[i] * glm::vec4(shadow_origin, 1.0f));
			// shadow_origin *= 512.f;

			// glm::vec3 rounded_origin = glm::round(shadow_origin);
			// glm::vec3 round_offset   = rounded_origin - shadow_origin;
			// round_offset             = round_offset / 512.f;
			// round_offset.z           = 0.0f;

			// m_data.view_projection[i][3][0] += round_offset.x;
			// m_data.view_projection[i][3][1] += round_offset.y;

			last_split_dist = cascade_splits[i];
		}
	}

	return (void *) (&m_data);
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Light/EnvironmentLight.cpp
================================================
#include "Components/Light/EnvironmentLight.hpp"

#include <imgui.h>

namespace Ilum::Cmpt
{
EnvironmentLight::EnvironmentLight(Node *node) :
    Light("Environment Light", node)
{
}

bool EnvironmentLight::OnImGui()
{
	if (ImGui::Button(m_texture.c_str(), ImVec2(ImGui::GetContentRegionAvail().x * 0.8f, 30.f)))
	{
		m_texture = "";
		m_update  = true;
	}

	if (ImGui::BeginDragDropSource())
	{
		ImGui::SetDragDropPayload("TextureCube", m_texture.c_str(), m_texture.length() + 1);
		ImGui::EndDragDropSource();
	}

	if (ImGui::BeginDragDropTarget())
	{
		if (const auto *pay_load = ImGui::AcceptDragDropPayload("TextureCube"))
		{
			m_texture = static_cast<const char *>(pay_load->Data);
			m_update = true;
		}
	}

	return m_update;
}

void EnvironmentLight::Save(OutputArchive &archive) const
{
	archive(m_texture);
}

void EnvironmentLight::Load(InputArchive &archive)
{
	archive(m_texture);
	m_update = true;
}

std::type_index EnvironmentLight::GetType() const
{
	return typeid(EnvironmentLight);
}

size_t EnvironmentLight::GetDataSize() const
{
	return m_texture.length() + 1;
}

void *EnvironmentLight::GetData(Camera *camera)
{
	return m_texture.data();
}
}        // namespace Ilum::Cmpt

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Light/Light.cpp
================================================
#include "Components/Light/Light.hpp"

namespace Ilum
{
namespace Cmpt
{
Light::Light(const char *name, Node *node) :
    Component(name, node)
{
}

bool Light::CastShadow() const
{
	return false;
}

void Light::SetShadowID(uint32_t &shadow_id)
{
}

void Light::CalculateFrustum(const glm::mat4 &view_projection, std::array<glm::vec4, 6> &frustum)
{
	// Left
	frustum[0].x = view_projection[0].w + view_projection[0].x;
	frustum[0].y = view_projection[1].w + view_projection[1].x;
	frustum[0].z = view_projection[2].w + view_projection[2].x;
	frustum[0].w = view_projection[3].w + view_projection[3].x;

	// Right
	frustum[1].x = view_projection[0].w - view_projection[0].x;
	frustum[1].y = view_projection[1].w - view_projection[1].x;
	frustum[1].z = view_projection[2].w - view_projection[2].x;
	frustum[1].w = view_projection[3].w - view_projection[3].x;

	// Top
	frustum[2].x = view_projection[0].w - view_projection[0].y;
	frustum[2].y = view_projection[1].w - view_projection[1].y;
	frustum[2].z = view_projection[2].w - view_projection[2].y;
	frustum[2].w = view_projection[3].w - view_projection[3].y;

	// Bottom
	frustum[3].x = view_projection[0].w + view_projection[0].y;
	frustum[3].y = view_projection[1].w + view_projection[1].y;
	frustum[3].z = view_projection[2].w + view_projection[2].y;
	frustum[3].w = view_projection[3].w + view_projection[3].y;

	// Near
	frustum[4].x = view_projection[0].w + view_projection[0].z;
	frustum[4].y = view_projection[1].w + view_projection[1].z;
	frustum[4].z = view_projection[2].w + view_projection[2].z;
	frustum[4].w = view_projection[3].w + view_projection[3].z;

	// Far
	frustum[5].x = view_projection[0].w - view_projection[0].z;
	frustum[5].y = view_projection[1].w - view_projection[1].z;
	frustum[5].z = view_projection[2].w - view_projection[2].z;
	frustum[5].w = view_projection[3].w - view_projection[3].z;

	for (auto &plane : frustum)
	{
		float length = glm::length(glm::vec3(plane.x, plane.y, plane.z));
		plane /= length;
	}
}

}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Light/PointLight.cpp
================================================
#include "Components/Light/PointLight.hpp"
#include "Components/Transform.hpp"
#include "Node.hpp"

#include <imgui.h>

namespace Ilum
{
namespace Cmpt
{
PointLight::PointLight(Node *node) :
    Light("Point Light", node)
{
}

bool PointLight::OnImGui()
{
	m_update |= ImGui::ColorEdit3("Color", &m_data.color.x);
	m_update |= ImGui::DragFloat("Intensity", &m_data.intensity, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
	ImGui::Text("Shadow Map Setting");
	m_update |= ImGui::Checkbox("Cast Shadow", reinterpret_cast<bool *>(&m_data.cast_shadow));
	m_update |= ImGui::SliderInt("Filter Sample", reinterpret_cast<int32_t *>(&m_data.filter_sample), 1, 100);
	m_update |= ImGui::DragFloat("Filter Scale", &m_data.filter_scale, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
	m_update |= ImGui::DragFloat("Light Scale", &m_data.light_scale, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");

	return m_update;
}

void PointLight::Save(OutputArchive &archive) const
{
	archive(m_data.color, m_data.intensity, m_data.position, m_data.filter_sample, m_data.filter_scale, m_data.light_scale);
}

void PointLight::Load(InputArchive &archive)
{
	archive(m_data.color, m_data.intensity, m_data.position, m_data.filter_sample, m_data.filter_scale, m_data.light_scale);
	m_update = true;
}

std::type_index PointLight::GetType() const
{
	return typeid(PointLight);
}

bool PointLight::CastShadow() const
{
	return m_data.cast_shadow;
}

void PointLight::SetShadowID(uint32_t &shadow_id)
{
	m_data.shadow_id = m_data.cast_shadow ? shadow_id++ : ~0u;
}

size_t PointLight::GetDataSize() const
{
	return sizeof(m_data);
}

void *PointLight::GetData(Camera *camera)
{
	auto *transform = p_node->GetComponent<Cmpt::Transform>();

	glm::vec3 scale;
	glm::quat rotation;
	glm::vec3 translation;
	glm::vec3 skew;
	glm::vec4 perspective;
	glm::decompose(transform->GetWorldTransform(), scale, rotation, translation, skew, perspective);

	m_data.position = translation;
	return (void *) (&m_data);
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Light/RectLight.cpp
================================================
#include "Components/Light/RectLight.hpp"
#include "Components/Transform.hpp"
#include "Node.hpp"

#include <imgui.h>

namespace Ilum
{
namespace Cmpt
{
RectLight::RectLight(Node *node) :
    Light("Rect Light", node)
{
}

bool RectLight::OnImGui()
{
	m_update |= ImGui::ColorEdit3("Color", &m_data.color.x);
	m_update |= ImGui::DragFloat("Intensity", &m_data.intensity, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
	m_update |= ImGui::Checkbox("Two Side", reinterpret_cast<bool *>(&m_data.two_side));
	return m_update;
}

void RectLight::Save(OutputArchive &archive) const
{
	archive(m_data.color, m_data.intensity, m_data.texture_id, m_data.corner);
}

void RectLight::Load(InputArchive &archive)
{
	archive(m_data.color, m_data.intensity, m_data.texture_id, m_data.corner);
	m_update = true;
}

std::type_index RectLight::GetType() const
{
	return typeid(RectLight);
}

size_t RectLight::GetDataSize() const
{
	return sizeof(m_data);
}

void *RectLight::GetData(Camera *camera)
{
	glm::mat4 world_transform = p_node->GetComponent<Cmpt::Transform>()->GetWorldTransform();

	m_data.corner[0] = world_transform * glm::vec4(-0.5f, 0.f, -0.5f, 1.f);
	m_data.corner[1] = world_transform * glm::vec4(0.5f, 0.f, -0.5f, 1.f);
	m_data.corner[2] = world_transform * glm::vec4(0.5f, 0.f, 0.5f, 1.f);
	m_data.corner[3] = world_transform * glm::vec4(-0.5f, 0.f, 0.5f, 1.f);

	return (void *) (&m_data);
}
}        // namespace Cmpt
}        // namespace Ilum


================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Light/SpotLight.cpp
================================================
#include "Components/Light/SpotLight.hpp"
#include "Components/Transform.hpp"
#include "Node.hpp"

#include <imgui.h>

namespace Ilum
{
namespace Cmpt
{
SpotLight::SpotLight(Node *node) :
    Light("Spot Light", node)
{
}

bool SpotLight::OnImGui()
{
	float inner_angle = glm::degrees(m_data.inner_angle);
	float outer_angle = glm::degrees(m_data.outer_angle);

	m_update |= ImGui::ColorEdit3("Color", &m_data.color.x);
	m_update |= ImGui::DragFloat("Intensity", &m_data.intensity, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
	m_update |= ImGui::DragFloat("Inner Angle", &inner_angle, 0.1f, 0.f, outer_angle, "%.1f");
	m_update |= ImGui::DragFloat("Outer Angle", &outer_angle, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
	ImGui::Text("Shadow Map Setting");
	m_update |= ImGui::Checkbox("Cast Shadow", reinterpret_cast<bool *>(&m_data.cast_shadow));
	m_update |= ImGui::SliderInt("Filter Sample", reinterpret_cast<int32_t *>(&m_data.filter_sample), 1, 100);
	m_update |= ImGui::DragFloat("Filter Scale", &m_data.filter_scale, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");
	m_update |= ImGui::DragFloat("Light Scale", &m_data.light_scale, 0.1f, 0.f, std::numeric_limits<float>::max(), "%.1f");

	m_data.inner_angle = glm::radians(inner_angle);
	m_data.outer_angle = glm::radians(outer_angle);

	return m_update;
}

void SpotLight::Save(OutputArchive &archive) const
{
	archive(m_data.color, m_data.intensity, m_data.inner_angle, m_data.outer_angle, m_data.filter_sample, m_data.filter_scale, m_data.light_scale);
}

void SpotLight::Load(InputArchive &archive)
{
	archive(m_data.color, m_data.intensity, m_data.inner_angle, m_data.outer_angle, m_data.filter_sample, m_data.filter_scale, m_data.light_scale);
	m_update = true;
}

std::type_index SpotLight::GetType() const
{
	return typeid(SpotLight);
}

bool SpotLight::CastShadow() const
{
	return m_data.cast_shadow;
}

void SpotLight::SetShadowID(uint32_t &shadow_id)
{
	m_data.shadow_id = m_data.cast_shadow ? shadow_id++ : ~0u;
}

size_t SpotLight::GetDataSize() const
{
	return sizeof(m_data);
}

void *SpotLight::GetData(Camera *camera)
{
	auto *transform = p_node->GetComponent<Cmpt::Transform>();

	glm::vec3 scale;
	glm::quat rotation;
	glm::vec3 translation;
	glm::vec3 skew;
	glm::vec4 perspective;
	glm::decompose(transform->GetWorldTransform(), scale, rotation, translation, skew, perspective);

	m_data.position        = translation;
	m_data.direction       = glm::mat3_cast(rotation) * glm::vec3(0.f, 0.f, -1.f);
	m_data.view_projection = glm::perspective(2.f * m_data.outer_angle, 1.0f, 0.01f, 1000.f) * glm::lookAt(translation, translation + m_data.direction, glm::vec3(0.f, 1.f, 0.f));

	return (void *) (&m_data);
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Renderable/MeshRenderer.cpp
================================================
#include "Components/Renderable/MeshRenderer.hpp"
#include <Scene/Node.hpp>

#include <imgui.h>

namespace Ilum
{
namespace Cmpt
{
MeshRenderer::MeshRenderer(Node *node) :
    Renderable("Mesh Renderer", node)
{
}

bool MeshRenderer::OnImGui()
{
	if (ImGui::TreeNode("Submesh"))
	{
		for (auto &submesh : m_submeshes)
		{
			ImGui::PushID(submesh.c_str());

			if (ImGui::Button(submesh.c_str(), ImVec2(ImGui::GetContentRegionAvail().x * 0.8f, 30.f)))
			{
				submesh  = "";
				m_update = true;
			}

			if (ImGui::BeginDragDropSource())
			{
				ImGui::SetDragDropPayload("Mesh", submesh.c_str(), submesh.length() + 1);
				ImGui::EndDragDropSource();
			}

			if (ImGui::BeginDragDropTarget())
			{
				if (const auto *pay_load = ImGui::AcceptDragDropPayload("Mesh"))
				{
					submesh  = static_cast<const char *>(pay_load->Data);
					m_update = true;
				}
			}

			ImGui::PopID();
		}

		if (ImGui::Button("+"))
		{
			m_submeshes.emplace_back("");
			m_update = true;
		}

		ImGui::SameLine();

		if (ImGui::Button("-"))
		{
			m_submeshes.pop_back();
			m_update = true;
		}

		ImGui::TreePop();
	}

	m_update |= Renderable::OnImGui();

	return m_update;
}

std::type_index MeshRenderer::GetType() const
{
	return typeid(MeshRenderer);
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Renderable/Renderable.cpp
================================================
#include "Components/Renderable/Renderable.hpp"

#include <Scene/Node.hpp>

#include <imgui.h>
#include <imgui_internal.h>

namespace Ilum
{
namespace Cmpt
{
Renderable::Renderable(const char *name, Node *node) :
    Component(name, node)
{
}

bool Renderable::OnImGui()
{
	if (ImGui::TreeNode("Material"))
	{
		for (auto &material : m_materials)
		{
			ImGui::PushID(material.c_str());

			if (ImGui::Button(material.c_str(), ImVec2(ImGui::GetContentRegionAvail().x * 0.8f, 30.f)))
			{
				material = "";
				m_update = true;
			}

			if (ImGui::BeginDragDropSource())
			{
				ImGui::SetDragDropPayload("Material", material.c_str(), material.length() + 1);
				ImGui::EndDragDropSource();
			}

			if (ImGui::BeginDragDropTarget())
			{
				if (const auto *pay_load = ImGui::AcceptDragDropPayload("Material"))
				{
					material = static_cast<const char *>(pay_load->Data);
					m_update = true;
				}
			}

			ImGui::PopID();
		}

		if (ImGui::Button("+"))
		{
			m_materials.emplace_back("");
			m_update = true;
		}

		ImGui::SameLine();

		if (ImGui::Button("-"))
		{
			m_materials.pop_back();
			m_update = true;
		}

		ImGui::TreePop();
	}

	return m_update;
}

void Renderable::Save(OutputArchive &archive) const
{
	archive(m_submeshes, m_materials, m_animations);
}

void Renderable::Load(InputArchive &archive)
{
	archive(m_submeshes, m_materials, m_animations);
	m_update = true;
}

void Renderable::AddMaterial(const std::string &material)
{
	m_materials.emplace_back(material);
	m_update = true;
}

void Renderable::AddSubmesh(const std::string &submesh)
{
	m_submeshes.emplace_back(submesh);
	m_update = true;
}

void Renderable::AddAnimation(const std::string &animation)
{
	m_animations.emplace_back(animation);
	m_update = true;
}

const std::vector<std::string> &Renderable::GetSubmeshes() const
{
	return m_submeshes;
}

const std::vector<std::string> &Renderable::GetMaterials() const
{
	return m_materials;
}

const std::vector<std::string> &Renderable::GetAnimations() const
{
	return m_animations;
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Renderable/SkinnedMeshRenderer.cpp
================================================
#include "Components/Renderable/SkinnedMeshRenderer.hpp"
#include <Scene/Node.hpp>

#include <imgui.h>

namespace Ilum
{
namespace Cmpt
{
SkinnedMeshRenderer::SkinnedMeshRenderer(Node *node) :
    Renderable("Skinned Mesh Renderer", node)
{
}

bool SkinnedMeshRenderer::OnImGui()
{
	if (ImGui::TreeNode("Submesh"))
	{
		for (auto &submesh : m_submeshes)
		{
			ImGui::PushID(submesh.c_str());

			if (ImGui::Button(submesh.c_str(), ImVec2(ImGui::GetContentRegionAvail().x * 0.8f, 30.f)))
			{
				submesh  = "";
				m_update = true;
			}

			if (ImGui::BeginDragDropSource())
			{
				ImGui::SetDragDropPayload("SkinnedMesh", submesh.c_str(), submesh.length() + 1);
				ImGui::EndDragDropSource();
			}

			if (ImGui::BeginDragDropTarget())
			{
				if (const auto *pay_load = ImGui::AcceptDragDropPayload("SkinnedMesh"))
				{
					submesh  = static_cast<const char *>(pay_load->Data);
					m_update = true;
				}
			}

			ImGui::PopID();
		}

		if (ImGui::Button("+"))
		{
			m_submeshes.emplace_back("");
			m_update = true;
		}

		ImGui::SameLine();

		if (ImGui::Button("-"))
		{
			m_submeshes.pop_back();
			m_update = true;
		}

		ImGui::TreePop();
	}

	if (ImGui::TreeNode("Animation"))
	{
		for (auto &animation : m_animations)
		{
			ImGui::PushID(animation.c_str());

			if (ImGui::Button(animation.c_str(), ImVec2(ImGui::GetContentRegionAvail().x * 0.8f, 30.f)))
			{
				animation = "";
				m_update  = true;
			}

			if (ImGui::BeginDragDropSource())
			{
				ImGui::SetDragDropPayload("Animation", animation.c_str(), animation.length() + 1);
				ImGui::EndDragDropSource();
			}

			if (ImGui::BeginDragDropTarget())
			{
				if (const auto *pay_load = ImGui::AcceptDragDropPayload("Animation"))
				{
					animation = static_cast<const char *>(pay_load->Data);
					m_update  = true;
				}
			}

			ImGui::PopID();
		}

		if (ImGui::Button("+"))
		{
			m_animations.emplace_back("");
			m_update = true;
		}

		ImGui::SameLine();

		if (ImGui::Button("-"))
		{
			m_animations.pop_back();
			m_update = true;
		}

		ImGui::TreePop();
	}

	m_update |= Renderable::OnImGui();

	return m_update;
}

std::type_index SkinnedMeshRenderer::GetType() const
{
	return typeid(SkinnedMeshRenderer);
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Components/Transform.cpp
================================================
#include "Components/Transform.hpp"

#include <Scene/Node.hpp>

#include <imgui.h>
#include <imgui_internal.h>

#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>

namespace Ilum
{
namespace Cmpt
{
Transform::Transform(Node *node) :
    Component("Transform", node)
{
}

bool Transform::OnImGui()
{
	auto draw_vec3 =
	    [&](const std::string &label, glm::vec3 &values, float resetValue = 0.0f, float columnWidth = 100.0f) -> bool {
		ImGuiIO &io        = ImGui::GetIO();
		auto     bold_font = io.Fonts->Fonts[0];
		bool     update    = false;

		ImGui::PushID(label.c_str());

		ImGui::Columns(2);
		ImGui::SetColumnWidth(0, columnWidth);
		ImGui::Text(label.c_str());
		ImGui::NextColumn();

		ImGui::PushMultiItemsWidths(3, ImGui::CalcItemWidth());
		ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{0, 0});

		float  line_height = GImGui->Font->FontSize + GImGui->Style.FramePadding.y * 2.0f;
		ImVec2 button_size = {line_height + 3.0f, line_height};

		ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{0.8f, 0.1f, 0.15f, 1.0f});
		ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{0.9f, 0.2f, 0.2f, 1.0f});
		ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{0.8f, 0.1f, 0.15f, 1.0f});
		ImGui::PushFont(bold_font);
		if (ImGui::Button("X", button_size))
		{
			values.x = resetValue;
			update   = true;
		}
		ImGui::PopFont();
		ImGui::PopStyleColor(3);

		ImGui::SameLine();
		update |= ImGui::DragFloat("##X", &values.x, 0.1f, 0.0f, 0.0f, "%.3f");
		ImGui::PopItemWidth();
		ImGui::SameLine();

		ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{0.2f, 0.7f, 0.2f, 1.0f});
		ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{0.3f, 0.8f, 0.3f, 1.0f});
		ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{0.2f, 0.7f, 0.2f, 1.0f});
		ImGui::PushFont(bold_font);
		if (ImGui::Button("Y", button_size))
		{
			values.y = resetValue;
			update   = true;
		}
		ImGui::PopFont();
		ImGui::PopStyleColor(3);

		ImGui::SameLine();
		update |= ImGui::DragFloat("##Y", &values.y, 0.1f, 0.0f, 0.0f, "%.3f");
		ImGui::PopItemWidth();
		ImGui::SameLine();

		ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{0.1f, 0.25f, 0.8f, 1.0f});
		ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{0.2f, 0.35f, 0.9f, 1.0f});
		ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{0.1f, 0.25f, 0.8f, 1.0f});
		ImGui::PushFont(bold_font);
		if (ImGui::Button("Z", button_size))
		{
			values.z = resetValue;
			update   = true;
		}
		ImGui::PopFont();
		ImGui::PopStyleColor(3);

		ImGui::SameLine();
		update |= ImGui::DragFloat("##Z", &values.z, 0.1f, 0.0f, 0.0f, "%.3f");
		ImGui::PopItemWidth();

		ImGui::PopStyleVar();

		ImGui::Columns(1);

		ImGui::PopID();

		return update;
	};

	bool update = false;

	update |= draw_vec3("Translation", m_translation, 0.f);
	update |= draw_vec3("Rotation", m_rotation, 0.f);
	update |= draw_vec3("Scale", m_scale, 1.f);

	if (update)
	{
		SetDirty();
	}

	return update;
}

std::type_index Transform::GetType() const
{
	return typeid(Transform);
}

void Transform::Save(OutputArchive &archive) const
{
	archive(m_translation, m_rotation, m_scale, m_world_transform);
}

void Transform::Load(InputArchive &archive)
{
	archive(m_translation, m_rotation, m_scale, m_world_transform);
	SetDirty();
}

const glm::vec3 &Transform::GetTranslation() const
{
	return m_translation;
}

const glm::vec3 &Transform::GetRotation() const
{
	return m_rotation;
}

const glm::vec3 &Transform::GetScale() const
{
	return m_scale;
}

const glm::mat4 Transform::GetLocalTransform() const
{
	return glm::scale(glm::translate(glm::mat4(1.f), m_translation) * glm::mat4_cast(glm::qua<float>(glm::radians(m_rotation))), m_scale);
}

const glm::mat4 Transform::GetWorldTransform()
{
	Update();
	return m_world_transform;
}

void Transform::SetTranslation(const glm::vec3 &translation)
{
	m_translation = translation;
	SetDirty();
}

void Transform::SetRotation(const glm::vec3 &rotation)
{
	m_rotation = rotation;
	SetDirty();
}

void Transform::SetScale(const glm::vec3 &scale)
{
	m_scale = scale;
	SetDirty();
}

void Transform::SetDirty()
{
	m_update = true;
	if (!m_dirty)
	{
		m_dirty = true;
		for (auto *child : p_node->GetChildren())
		{
			if (child->HasComponent<Transform>())
			{
				child->GetComponent<Transform>()->SetDirty();
			}
		}
	}
}

void Transform::Update()
{
	if (!m_dirty)
	{
		return;
	}

	glm::mat4 local_matrix = GetLocalTransform();

	auto parent = GetNode()->GetParent();

	if (parent)
	{
		auto *transform   = parent->GetComponent<Transform>();
		m_world_transform = transform->GetWorldTransform() * local_matrix;
	}
	else
	{
		m_world_transform = local_matrix;
	}

	m_dirty = false;
}
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Node.cpp
================================================
#include "Node.hpp"
#include "Component.hpp"
#include "Scene.hpp"

namespace Ilum
{
struct Node::Impl
{
	Impl(Scene &scene) :
	    scene(scene)
	{
	}

	~Impl() = default;

	Scene &scene;

	size_t id = ~0U;

	std::string name;

	Node *parent = nullptr;

	std::vector<Node *> children;

	std::unordered_map<std::type_index, Component *> components;
};

Node::Node(size_t id, Scene &scene, const std::string &name)
{
	m_impl       = new Impl(scene);
	m_impl->id   = id;
	m_impl->name = name;
}

Node::~Node()
{
	for (auto &child : m_impl->children)
	{
		child->SetParent(nullptr);
	}

	if (m_impl->parent)
	{
		m_impl->parent->EraseChild(this);
	}

	for (auto &[type, cmpt] : m_impl->components)
	{
		auto &scene_components = m_impl->scene.GetComponents()[type];
		for (auto iter = scene_components.begin(); iter != scene_components.end(); iter++)
		{
			if (iter->get() == cmpt)
			{
				scene_components.erase(iter);
				break;
			}
		}
	}

	delete m_impl;
}

size_t Node::GetID() const
{
	return m_impl->id;
}

void Node::SetName(const std::string &name)
{
	m_impl->name = name;
}

const std::string &Node::GetName() const
{
	return m_impl->name;
}

Node *Node::GetParent()
{
	return m_impl->parent;
}

Scene &Node::GetScene()
{
	return m_impl->scene;
}

void Node::SetParent(Node *node)
{
	if (m_impl->parent)
	{
		m_impl->parent->EraseChild(this);
	}

	m_impl->parent = node;

	if (m_impl->parent)
	{
		m_impl->parent->AddChild(this);
	}
}

const std::vector<Node *> &Node::GetChildren() const
{
	return m_impl->children;
}

const std::unordered_map<std::type_index, Component *> &Node::GetComponents() const
{
	return m_impl->components;
}

void Node::Save(OutputArchive &archive) const
{
	archive(m_impl->id, m_impl->name);
}

void Node::Load(InputArchive &archive)
{
	archive(m_impl->id, m_impl->name);
}

void Node::EraseChild(Node *node)
{
	auto iter = std::find(m_impl->children.begin(), m_impl->children.end(), node);
	if (iter != m_impl->children.end())
	{
		m_impl->children.erase(iter);
	}
}

void Node::AddChild(Node *node)
{
	m_impl->children.push_back(node);
}

bool Node::HasComponent_(std::type_index index)
{
	return m_impl->components.find(index) != m_impl->components.end();
}

Component *Node::GetComponent_(std::type_index index)
{
	return HasComponent_(index) ? m_impl->components.at(index) : nullptr;
}

Component *Node::AddComponent_(std::unique_ptr<Component> &&component)
{
	auto &ptr = m_impl->scene.GetComponents()[component->GetType()].emplace_back(std::move(component));
	m_impl->components.emplace(ptr->GetType(), ptr.get());
	return ptr.get();
}

void Node::AddComponent_(Component *component)
{
	m_impl->components.emplace(component->GetType(), component);
}

void Node::EraseComponent(std::type_index index)
{
	auto cmpt_iter = m_impl->components.find(index);

	if (cmpt_iter == m_impl->components.end())
	{
		return;
	}

	auto &cmpt_list = m_impl->scene.GetComponents()[index];

	for (auto iter = cmpt_list.begin(); iter != cmpt_list.end(); iter++)
	{
		if (iter->get() == cmpt_iter->second)
		{
			cmpt_list.erase(iter);
			break;
		}
	}

	m_impl->components.erase(cmpt_iter);
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Private/Scene/Scene.cpp
================================================
#include "Scene.hpp"
#include "Component.hpp"
#include "Components/AllComponents.hpp"
#include "Node.hpp"

namespace Ilum
{
struct Scene::Impl
{
	Impl() = default;

	~Impl()
	{
		nodes.clear();
		components.clear();
	}

	std::string name;

	std::vector<std::unique_ptr<Node>> nodes;

	std::unordered_map<std::type_index, std::vector<std::unique_ptr<Component>>> components;

	bool update = false;
};

Scene::Scene(const std::string &name)
{
	m_impl = new Impl;

	m_impl->name = name;
}

Scene::~Scene()
{
	auto roots = GetRoots();
	for (auto &root : roots)
	{
		EraseNode(root);
	}

	delete m_impl;
	m_impl = nullptr;
}

void Scene::SetName(const std::string &name)
{
	m_impl->name = name;
}

const std::string &Scene::GetName() const
{
	return m_impl->name;
}

const std::vector<std::unique_ptr<Node>> &Scene::GetNodes() const
{
	return m_impl->nodes;
}

const std::vector<Node *> Scene::GetRoots() const
{
	std::vector<Node *> roots;
	roots.reserve(m_impl->nodes.size());
	for (auto &node : m_impl->nodes)
	{
		if (node->GetParent() == nullptr)
		{
			roots.emplace_back(node.get());
		}
	}
	return roots;
}

Node *Scene::CreateNode(const std::string &name)
{
	return m_impl->nodes.emplace_back(std::make_unique<Node>(m_impl->nodes.empty() ? 0 : m_impl->nodes.back()->GetID() + 1, *this, name)).get();
}

void Scene::EraseNode(Node *node)
{
	std::function<void(Node *, std::vector<Node *> &)> gather_nodes = [&](Node *node, std::vector<Node *> &nodes) {
		nodes.push_back(node);
		for (auto &child : node->GetChildren())
		{
			gather_nodes(child, nodes);
		}
	};

	std::vector<Node *> remove_nodes;
	gather_nodes(node, remove_nodes);
	std::reverse(remove_nodes.begin(), remove_nodes.end());

	for (auto *remove_node : remove_nodes)
	{
		for (auto iter = m_impl->nodes.begin(); iter != m_impl->nodes.end(); iter++)
		{
			if (iter->get() == remove_node)
			{
				m_impl->nodes.erase(iter);
				break;
			}
		}
	}
}

std::unordered_map<std::type_index, std::vector<std::unique_ptr<Component>>> &Scene::GetComponents()
{
	return m_impl->components;
}

void Scene::Save(OutputArchive &archive)
{
	archive(m_impl->name);

	// Nodes
	{
		archive(m_impl->nodes.size());
		for (auto &node : m_impl->nodes)
		{
			node->Save(archive);
		}
		for (auto &node : m_impl->nodes)
		{
			archive(node->GetParent() ? node->GetParent()->GetID() : ~0ull);
		}
	}

	// Components
	{
		archive(m_impl->components.size());
		for (auto &[type, components] : m_impl->components)
		{
			archive(std::string(type.name()));
			archive(components.size());
			for (auto &component : components)
			{
				archive(component->GetNode()->GetID());
				component->Save(archive);
			}
		}
	}
}

void Scene::Load(InputArchive &archive)
{
	archive(m_impl->name);

	std::unordered_map<size_t, Node *> node_map;
	// Nodes
	{
		m_impl->nodes.clear();
		size_t node_count = 0;
		archive(node_count);
		for (size_t i = 0; i < node_count; i++)
		{
			std::unique_ptr<Node> node = std::make_unique<Node>(0, *this);
			node->Load(archive);
			m_impl->nodes.emplace_back(std::move(node));
			node_map[m_impl->nodes.back()->GetID()] = m_impl->nodes.back().get();
		}
		for (auto &node : m_impl->nodes)
		{
			size_t parent = ~0ull;
			archive(parent);
			if (parent != ~0ull)
			{
				node->SetParent(node_map[parent]);
			}
		}
	}

	// Components
	{
		const std::unordered_map<std::string, std::function<void(Node *&, InputArchive &)>> load_component_map = {
#define LOAD_COMPONENT(Cmpt)                                                                                                                   \
	{                                                                                                                                          \
		typeid(Cmpt).name(), [](Node *&node, InputArchive &archive) { node->AddComponent<Cmpt>(std::make_unique<Cmpt>(node))->Load(archive); } \
	}

		    LOAD_COMPONENT(Cmpt::Transform),
		    LOAD_COMPONENT(Cmpt::PerspectiveCamera),
		    LOAD_COMPONENT(Cmpt::OrthographicCamera),
		    LOAD_COMPONENT(Cmpt::MeshRenderer),
		    LOAD_COMPONENT(Cmpt::SkinnedMeshRenderer),
		    LOAD_COMPONENT(Cmpt::SpotLight),
		    LOAD_COMPONENT(Cmpt::PointLight),
		    LOAD_COMPONENT(Cmpt::DirectionalLight),
		    LOAD_COMPONENT(Cmpt::RectLight),
		    LOAD_COMPONENT(Cmpt::EnvironmentLight),
		};

		size_t component_type_count = 0;
		archive(component_type_count);
		for (size_t i = 0; i < component_type_count; i++)
		{
			std::string type_name = "";
			archive(type_name);
			size_t compoent_count = 0;
			archive(compoent_count);
			for (size_t j = 0; j < compoent_count; j++)
			{
				size_t node_id = 0;
				archive(node_id);
				Node *node = node_map[node_id];
				load_component_map.at(type_name)(node, archive);
			}
		}
	}
}

void Scene::Clear()
{
	auto roots = GetRoots();
	for (auto &root : roots)
	{
		EraseNode(root);
	}
}

bool Scene::IsUpdate() const
{
	return m_impl->update;
}

void Scene::Update(bool update)
{
	if (update)
	{
		m_impl->update = true;
	}
	else
	{
		for (auto &[type, cmpts] : m_impl->components)
		{
			for (auto &cmpt : cmpts)
			{
				m_impl->update |= cmpt->IsUpdate();
				cmpt->SetUpdate(false);
			}
		}
	}
}

void Scene::Reset()
{
	m_impl->update = false;
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Component.hpp
================================================
#pragma once

#include <Core/Core.hpp>

#include <string>
#include <typeindex>

namespace Ilum
{
class Node;

class EXPORT_API Component
{
  public:
	Component(const char *name, Node *node);

	Component(Component &&) = default;

	virtual ~Component();

	virtual bool OnImGui() = 0;

	virtual std::type_index GetType() const = 0;

	const char *GetName() const;

	Node *GetNode() const;

	virtual void Save(OutputArchive &archive) const = 0;

	virtual void Load(InputArchive &archive) = 0;

	bool IsUpdate();

	void SetUpdate(bool update);

  protected:
	const char *m_name;

	bool m_update = false;

	Node *p_node = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/AllComponents.hpp
================================================
#pragma once

#include "Camera/OrthographicCamera.hpp"
#include "Camera/PerspectiveCamera.hpp"
#include "Light/DirectionalLight.hpp"
#include "Light/EnvironmentLight.hpp"
#include "Light/PointLight.hpp"
#include "Light/RectLight.hpp"
#include "Light/SpotLight.hpp"
#include "Renderable/MeshRenderer.hpp"
#include "Renderable/SkinnedMeshRenderer.hpp"
#include "Transform.hpp"

struct ImGuiContext;

namespace Ilum
{
namespace Cmpt
{
void SetImGuiContext(ImGuiContext *context);
}
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Camera/Camera.hpp
================================================
#pragma once

#include <Scene/Component.hpp>

#include <glm/glm.hpp>

namespace Ilum
{
namespace Cmpt
{
class Camera : public Component
{
  public:
	Camera(const char *name, Node *node);

	virtual ~Camera() = default;

	virtual bool OnImGui() override = 0;

	virtual std::type_index GetType() const = 0;

	virtual void Save(OutputArchive &archive) const = 0;

	virtual void Load(InputArchive &archive) = 0;

	void SetAspect(float aspect);

	float GetAspect();

	void SetNearPlane(float near_plane);

	void SetFarPlane(float far_plane);

	float GetNearPlane() const;

	float GetFarPlane() const;

	glm::mat4 GetViewMatrix();

	glm::mat4 GetProjectionMatrix();

	glm::mat4 GetViewProjectionMatrix();

	glm::mat4 GetInvViewMatrix();

	glm::mat4 GetInvProjectionMatrix();

	glm::mat4 GetInvViewProjectionMatrix();

	const std::array<glm::vec4, 6> &GetFrustumPlanes();

  protected:
	virtual void UpdateProjection() = 0;

	void UpdateView();

  protected:
	float m_aspect = 1.f;
	float m_near   = 0.1f;
	float m_far    = 500.f;

	std::array<glm::vec4, 6> m_frustum_planes;

	glm::mat4 m_view                = glm::mat4(1.f);
	glm::mat4 m_inv_view            = glm::mat4(1.f);
	glm::mat4 m_projection          = glm::mat4(1.f);
	glm::mat4 m_inv_projection      = glm::mat4(1.f);
	glm::mat4 m_view_projection     = glm::mat4(1.f);
	glm::mat4 m_inv_view_projection = glm::mat4(1.f);
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Camera/OrthographicCamera.hpp
================================================
#pragma once

#include "Camera.hpp"

namespace Ilum
{
namespace Cmpt
{
class OrthographicCamera : public Camera
{
  public:
	OrthographicCamera(Node *node);

	virtual ~OrthographicCamera() = default;

	virtual bool OnImGui() override;

	virtual std::type_index GetType() const override;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	void SetScale(float scale);

	void SetOffset(float x, float y);

	float GetScale() const;

	float GetOffsetX() const;

	float GetOffsetY() const;

  protected:
	virtual void UpdateProjection() override;

  private:
	float m_scale    = 1.f;
	float m_offset_x = 0.f;
	float m_offset_y = 0.f;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Camera/PerspectiveCamera.hpp
================================================
#pragma once

#include "Camera.hpp"

namespace Ilum
{
namespace Cmpt
{
class PerspectiveCamera : public Camera
{
  public:
	PerspectiveCamera(Node *node);

	virtual ~PerspectiveCamera() = default;

	virtual bool OnImGui() override;

	virtual std::type_index GetType() const override;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	void SetFov(float fov);

	float GetFov() const;

  protected:
	virtual void UpdateProjection() override;

  private:
	float m_fov   = 45.f;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Light/DirectionalLight.hpp
================================================
#pragma once

#include "Light.hpp"

#include <glm/glm.hpp>

namespace Ilum
{
namespace Cmpt
{
class DirectionalLight : public Light
{
  public:
	DirectionalLight(Node *node);

	virtual ~DirectionalLight() = default;

	virtual bool OnImGui() override;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	virtual std::type_index GetType() const override;

	bool CastShadow() const;

	void SetShadowID(uint32_t &shadow_id);

	virtual size_t GetDataSize() const override;

	virtual void *GetData(Camera *camera = nullptr) override;

  private:
	struct
	{
		glm::vec3 color = glm::vec3(1.f);

		float intensity = 100.f;

		glm::vec4 split_depth;
		glm::mat4 view_projection[4];
		glm::vec4 shadow_cam_pos[4];

		glm::vec3 direction = glm::vec3(1.f);

		float    filter_scale  = 2.f;
		float    light_scale   = 1.f;
		uint32_t filter_sample = 10;
		uint32_t cast_shadow   = 1;
		uint32_t shadow_id     = ~0u;
	} m_data;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Light/EnvironmentLight.hpp
================================================
#pragma once

#include "Light.hpp"

#include <glm/glm.hpp>

namespace Ilum
{
namespace Cmpt
{
class EnvironmentLight : public Light
{
  public:
	EnvironmentLight(Node *node);

	virtual ~EnvironmentLight() = default;

	virtual bool OnImGui() override;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	virtual std::type_index GetType() const override;

	virtual size_t GetDataSize() const override;

	virtual void *GetData(Camera *camera = nullptr) override;

  private:
	std::string m_texture = "";
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Light/Light.hpp
================================================
#pragma once

#include <Scene/Component.hpp>

namespace Ilum
{
namespace Cmpt
{
class Camera;

class Light : public Component
{
  public:
	Light(const char *name, Node *node);

	virtual ~Light() = default;

	virtual bool OnImGui() = 0;

	virtual std::type_index GetType() const = 0;

	virtual void Save(OutputArchive &archive) const = 0;

	virtual void Load(InputArchive &archive) = 0;

	virtual bool CastShadow() const;

	virtual void SetShadowID(uint32_t &shadow_id);

	// GPU data size
	virtual size_t GetDataSize() const = 0;

	// GPU data info
	virtual void *GetData(Camera *camera = nullptr) = 0;

  protected:
	void CalculateFrustum(const glm::mat4 &view_projection, std::array<glm::vec4, 6> &frustum);

  private:
	// Shadow
	bool  m_shadow_enabled = true;
	float m_shadow_bias    = 0.1f;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Light/PointLight.hpp
================================================
#pragma once

#include "Light.hpp"

#include <glm/glm.hpp>

namespace Ilum
{
namespace Cmpt
{
class PointLight : public Light
{
  public:
	PointLight(Node *node);

	virtual ~PointLight() = default;

	virtual bool OnImGui() override;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	virtual std::type_index GetType() const override;

	bool CastShadow() const;

	void SetShadowID(uint32_t &shadow_id);

	virtual size_t GetDataSize() const override;

	virtual void *GetData(Camera *camera = nullptr) override;

  private:
	struct
	{
		glm::vec3 color     = glm::vec3(1.f);
		float     intensity = 100.f;

		glm::vec3 position     = glm::vec3(0.f);
		float     filter_scale = 2.f;

		alignas(16) float light_scale = 1.f;
		uint32_t filter_sample        = 10;
		uint32_t cast_shadow          = 1;
		uint32_t shadow_id            = ~0u;
	} m_data;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Light/RectLight.hpp
================================================
#pragma once

#include "Light.hpp"

#include <glm/glm.hpp>

namespace Ilum
{
namespace Cmpt
{
class RectLight : public Light
{
  public:
	RectLight(Node *node);

	virtual ~RectLight() = default;

	virtual bool OnImGui() override;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	virtual std::type_index GetType() const override;

	virtual size_t GetDataSize() const override;

	virtual void *GetData(Camera *camera = nullptr) override;

  private:
	struct
	{
		glm::vec3 color = glm::vec3(1.f);

		float intensity = 100.f;

		glm::vec4 corner[4];

		alignas(16) uint32_t texture_id = ~0U;
		uint32_t two_side               = 0;
	} m_data;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Light/SpotLight.hpp
================================================
#pragma once

#include "Light.hpp"

#include <glm/glm.hpp>

namespace Ilum
{
namespace Cmpt
{
class SpotLight : public Light
{
  public:
	SpotLight(Node *node);

	virtual ~SpotLight() = default;

	virtual bool OnImGui() override;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	virtual std::type_index GetType() const override;

	bool CastShadow() const;

	void SetShadowID(uint32_t &shadow_id);

	virtual size_t GetDataSize() const override;

	virtual void *GetData(Camera *camera = nullptr) override;

  private:
	struct
	{
		glm::vec3 color = glm::vec3(1.f);

		float intensity = 100.f;

		glm::vec3 position = glm::vec3(0.f);

		float inner_angle = glm::radians(30.f);

		glm::vec3 direction = glm::vec3(0.f);

		float outer_angle = glm::radians(60.f);

		glm::mat4 view_projection = glm::mat4(1.f);

		// Shadow map setting
		float    filter_scale  = 2.f;
		float    light_scale   = 1.f;
		uint32_t filter_sample = 10;
		uint32_t cast_shadow   = 1;

		alignas(16) uint32_t shadow_id = ~0u;
	} m_data;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Renderable/MeshRenderer.hpp
================================================
#pragma once

#include "Renderable.hpp"

namespace Ilum
{
namespace Cmpt
{
class MeshRenderer : public Renderable
{
  public:
	MeshRenderer(Node *node);

	virtual ~MeshRenderer() = default;

	virtual bool OnImGui() override;

	virtual std::type_index GetType() const override;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Renderable/Renderable.hpp
================================================
#pragma once

#include <Scene/Component.hpp>

namespace Ilum
{
namespace Cmpt
{
class Renderable : public Component
{
  public:
	Renderable(const char *name, Node *node);

	virtual ~Renderable() = default;

	virtual bool OnImGui() override;

	virtual std::type_index GetType() const = 0;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	void AddMaterial(const std::string &material);

	void AddSubmesh(const std::string &submesh);

	void AddAnimation(const std::string &animation);

	const std::vector<std::string> &GetSubmeshes() const;

	const std::vector<std::string> &GetMaterials() const;

	const std::vector<std::string> &GetAnimations() const;

  protected:
	std::vector<std::string> m_submeshes;
	std::vector<std::string> m_materials;
	std::vector<std::string> m_animations;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Renderable/SkinnedMeshRenderer.hpp
================================================
#pragma once

#include "Renderable.hpp"

namespace Ilum
{
namespace Cmpt
{
class SkinnedMeshRenderer : public Renderable
{
  public:
	SkinnedMeshRenderer(Node *node);

	virtual ~SkinnedMeshRenderer() = default;

	virtual bool OnImGui() override;

	virtual std::type_index GetType() const override;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Components/Transform.hpp
================================================
#pragma once

#include <Scene/Component.hpp>

#include <glm/glm.hpp>

namespace Ilum
{
class Node;

namespace Cmpt
{
class Transform : public Component
{
  public:
	Transform(Node *node);

	~Transform() = default;

	virtual bool OnImGui() override;

	virtual std::type_index GetType() const override;

	virtual void Save(OutputArchive &archive) const override;

	virtual void Load(InputArchive &archive) override;

	const glm::vec3 &GetTranslation() const;

	const glm::vec3 &GetRotation() const;

	const glm::vec3 &GetScale() const;

	const glm::mat4 GetLocalTransform() const;

	const glm::mat4 GetWorldTransform();

	void SetTranslation(const glm::vec3 &translation);

	void SetRotation(const glm::vec3 &rotation);

	void SetScale(const glm::vec3 &scale);

	void SetDirty();

  private:
	void Update();

  private:
	glm::vec3 m_translation = {0.f, 0.f, 0.f};
	glm::vec3 m_rotation    = {0.f, 0.f, 0.f};
	glm::vec3 m_scale       = {1.f, 1.f, 1.f};

	glm::mat4 m_world_transform = glm::mat4(1.f);

	bool m_dirty = false;
};
}        // namespace Cmpt
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Node.hpp
================================================
#pragma once

#include <Core/Core.hpp>

#include <memory>
#include <string>
#include <typeindex>
#include <unordered_map>

namespace Ilum
{
class Component;
class Scene;

class Node
{
  public:
	Node(size_t id, Scene &scene, const std::string &name = "untitled node");

	~Node();

	size_t GetID() const;

	void SetName(const std::string &name);

	const std::string &GetName() const;

	Node *GetParent();

	Scene &GetScene();

	void SetParent(Node *node);

	const std::vector<Node *> &GetChildren() const;

	template <typename _Ty>
	bool HasComponent()
	{
		return HasComponent_(typeid(_Ty));
	}

	template <typename _Ty>
	void EraseComponent()
	{
		return EraseComponent(typeid(_Ty));
	}

	void EraseComponent(std::type_index index);

	template <typename _Ty, typename = std::is_base_of<Component, _Ty>>
	_Ty *GetComponent()
	{
		return static_cast<_Ty *>(GetComponent_(typeid(_Ty)));
	}

	template <typename _Ty, typename = std::is_base_of<Component, _Ty>>
	_Ty *AddComponent(std::unique_ptr<_Ty> &&component)
	{
		return static_cast<_Ty *>(AddComponent_(std::move(component)));
	}

	const std::unordered_map<std::type_index, Component *> &GetComponents() const;

	void Save(OutputArchive &archive) const;

	void Load(InputArchive &archive);

  private:
	void EraseChild(Node *node);

	void AddChild(Node *node);

	bool HasComponent_(std::type_index index);

	Component *GetComponent_(std::type_index index);

	Component *AddComponent_(std::unique_ptr<Component> &&component);

	void AddComponent_(Component *component);

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/Scene/Public/Scene/Scene.hpp
================================================
#pragma once

#include <Core/Core.hpp>

#include <algorithm>
#include <memory>
#include <string>
#include <typeindex>
#include <unordered_map>
#include <vector>

namespace Ilum
{
class Node;
class Component;
class RHIContext;

class Scene
{
	friend class Node;

  public:
	Scene(const std::string &name = "untitled scene");

	~Scene();

	void SetName(const std::string &name);

	const std::string &GetName() const;

	const std::vector<std::unique_ptr<Node>> &GetNodes() const;

	const std::vector<Node *> GetRoots() const;

	template <typename _Ty>
	std::vector<_Ty *> GetComponents()
	{
		std::vector<_Ty *> result;

		if (HasComponent<_Ty>())
		{
			auto &scene_components = GetComponents().at(typeid(_Ty));

			std::transform(scene_components.begin(), scene_components.end(), std::back_inserter(result),
			               [](const std::unique_ptr<Component> &component) -> _Ty * {
				               return static_cast<_Ty *>(component.get());
			               });
		}

		return result;
	}

	template <typename _Ty>
	bool HasComponent()
	{
		return GetComponents().find(typeid(_Ty)) != GetComponents().end();
	}

	Node *CreateNode(const std::string &name = "untitled node");

	void EraseNode(Node *node);

	void Save(OutputArchive &archive);

	void Load(InputArchive &archive);

	void Clear();

	bool IsUpdate() const;

	void Update(bool update = false);

	void Reset();

  private:
	std::unordered_map<std::type_index, std::vector<std::unique_ptr<Component>>> &GetComponents();

  private:
	struct Impl;
	Impl *m_impl = nullptr;
};
}        // namespace Ilum

================================================
FILE: Source/Runtime/xmake.lua
================================================
add_runtime_moulde(
    "Core",
    "Runtime",
    true, 
    {}, 
    {}
)

target("Core")
    add_packages("glfw", "spdlog", "glm", "cereal", "stb", {public = true})
target_end()

add_runtime_moulde(
    "RHI", 
    "Runtime",
    false, 
    {"Core"}, 
    {}
)

add_runtime_moulde(
    "Geometry", 
    "Runtime",
    false, 
    {"Core"}, 
    {"glm"}
)

add_runtime_moulde(
    "Scene", 
    "Runtime",
    false, 
    {"Core", "ImGui-Tools"},
    {"imgui"}
)

add_runtime_moulde(
    "Resource", 
    "Runtime",
    false, 
    {"Core", "RHI", "Geometry", "Material", "RenderGraph", "ShaderCompiler", "Scene"}, 
    {"imgui", "meshoptimizer", "mustache"}
)

-- Render
includes("Render")

================================================
FILE: Source/Shaders/AmbientOcclusion/RayTracedAO.hlsl
================================================


================================================
FILE: Source/Shaders/AmbientOcclusion/SSAO.hlsl
================================================
#include "../Common.hlsli"
#include "../Random.hlsli"

#define KERNAL_SIZE 64
#define RADIUS 0.5
#define NOISE_DIM 4

struct Sample
{
    float4 samples[KERNAL_SIZE];
};

Texture2D<float4> Normal;
Texture2D<float4> PositionDepth;
RWTexture2D<float> SSAOMap;
SamplerState TexSampler;
ConstantBuffer<View> ViewBuffer;
Texture2D<float4> NoiseTexture;
ConstantBuffer<Sample> SampleBuffer;

[numthreads(8, 8, 1)]
void SSAO(CSParam param)
{
    uint2 extent;
    SSAOMap.GetDimensions(extent.x, extent.y);
    
    if (param.DispatchThreadID.x >= extent.x ||
        param.DispatchThreadID.y >= extent.y)
    {
        return;
    }
    
    float2 uv = (float2(param.DispatchThreadID.xy) + 0.5f) / float2(extent);
    
    float3 position = PositionDepth[param.DispatchThreadID.xy].rgb;
    
    if (IsBlack(position))
    {
        SSAOMap[param.DispatchThreadID.xy] = 1.f;
        return;
    }
    
    position = mul(ViewBuffer.view_matrix, float4(position, 1.f)).xyz;
    float3 normal = Normal[param.DispatchThreadID.xy].rgb * 2.f - 1.f;
    normal = mul((float3x3) ViewBuffer.view_matrix, normal).xyz;
    
    PCGSampler rng;
    rng.Init(extent, param.DispatchThreadID.xy, 0);
    
    uint2 noise_extent;
    NoiseTexture.GetDimensions(noise_extent.x, noise_extent.y);
    
    const float2 noise_uv = float2(float(extent.x) / float(noise_extent.x), float(extent.y) / (noise_extent.y)) * uv;
    float3 random_vec = NoiseTexture.SampleLevel(TexSampler, noise_uv, 0).xyz * 2.0 - 1.0;
    
    float3 tangent = normalize(random_vec - normal * dot(random_vec, normal));
    float3 bitangent = cross(tangent, normal);
    float3x3 TBN = transpose(float3x3(tangent, bitangent, normal));
    
    float occlusion = 0.f;
    
    for (uint i = 0; i < KERNAL_SIZE; i++)
    {
        float3 sample_pos = mul(TBN, SampleBuffer.samples[i].xyz);
        sample_pos = position + sample_pos * RADIUS;
        
        float4 offset = float4(sample_pos, 1.f);
        offset = mul(ViewBuffer.projection_matrix, offset);
        offset.y = -offset.y;
        offset.xyz /= offset.w;
        offset.xyz = offset.xyz * 0.5f + 0.5f;

        float sample_depth = PositionDepth.SampleLevel(TexSampler, offset.xy, 0).w;
        float range = smoothstep(0.f, 1.f, RADIUS / abs(position.z - sample_depth));
        
        occlusion += (sample_depth >= sample_pos.z ? 1.0f : 0.0f) * range;
    }
    occlusion = 1.f - (occlusion / float(KERNAL_SIZE));
    SSAOMap[param.DispatchThreadID.xy] = occlusion;
}

groupshared float cache[8][8];

[numthreads(8, 8, 1)]
void SSAOBlur(CSParam param)
{
    uint2 extent;
    SSAOMap.GetDimensions(extent.x, extent.y);
    
    if (param.DispatchThreadID.x >= extent.x ||
        param.DispatchThreadID.y >= extent.y)
    {
        return;
    }
    
    float sum = 0;
    uint idx = 0;
    for (int i = -1; i <= 1; i++)
    {
        for (int j = -1; j <= 1; j++)
        {
            sum += SSAOMap[int2(clamp(param.DispatchThreadID.x + i, 0, extent.x), clamp(param.DispatchThreadID.y + j, 0, extent.y))];
        }
    }
    
    cache[param.GroupThreadID.x][param.GroupThreadID.y] = sum;
    
    GroupMemoryBarrierWithGroupSync();

    // Mean filter
    SSAOMap[param.GroupThreadID.xy] = cache[param.GroupThreadID.x][param.GroupThreadID.y] / 9.f;
}

================================================
FILE: Source/Shaders/Attribute.hlsli
================================================
#ifndef ATTRIBUTE_HLSLI
#define ATTRIBUTE_HLSLI

struct InstanceAttribute
{
    float instance_id;
    float material_id;
    float primitive_id;
};

struct VertexAttribute
{
    float3 position;
    float3 normal;
    float3 tangent;
    float3 texcoord0;
    float3 texcoord1;
};

static InstanceAttribute instance_attribute;
static VertexAttribute vertex_attribute;

#endif

================================================
FILE: Source/Shaders/Common.hlsli
================================================
#ifndef COMMON_HLSLI
#define COMMON_HLSLI

#include "Math.hlsli"

#define MAX_BONE_INFLUENCE 8

#define MESH_TYPE 0
#define SKINNED_MESH_TYPE 1

struct DrawIndirectCommand
{
    uint vertex_count;
    uint instance_count;
    uint vertex_offset;
    uint instance_offset;
};

struct DrawIndexedIndirectCommand
{
    uint index_count;
    uint instance_count;
    uint index_offset;
    int vertex_offset;
    uint instance_offset;
};

struct DispatchIndirectCommand
{
    uint x;
    uint y;
    uint z;
};

struct DrawMeshTasksIndirectCommand
{
    uint group_count_x;
    uint group_count_y;
    uint group_count_z;
};

struct Vertex
{
    float3 position;
    float3 normal;
    float3 tangent;
    float2 texcoord0;
    float2 texcoord1;
};

struct SkinnedVertex
{
    float3 position;
    float3 normal;
    float3 tangent;

    float2 texcoord0;
    float2 texcoord1;

    int bones[8];
    float weights[8];
};

struct Meshlet
{
    float3 center;
    float radius;

    uint data_offset;
    uint vertex_offset;
    uint vertex_count;
    uint triangle_count;
    
    float3 cone_axis;
    float cone_cutoff;
    float3 cone_apex;
    
    uint visible;
};

struct Instance
{
    float4x4 transform;

    uint mesh_id;
    uint material_id;
    uint animation_id;
    uint visible;
};

struct RayDiff
{
    float3 dOdx;
    float3 dOdy;
    float3 dDdx;
    float3 dDdy;
    
    void Propagate(float3 direction, float t, float3 normal)
    {
        float3 dodx = dOdx + t * dDdx;
        float3 dody = dOdy + t * dDdy;

        float rcpDN = 1.0f / dot(direction, normal);
        float dtdx = -dot(dodx, normal) * rcpDN;
        float dtdy = -dot(dody, normal) * rcpDN;
        dodx += direction * dtdx;
        dody += direction * dtdy;

        dOdx = dodx;
        dOdy = dody;
    }
};

bool IsInsideFrustum(Meshlet meshlet, float4x4 model, float4 frustum[6], float3 eye)
{
    float sx = length(float3(model[0][0], model[0][1], model[0][2]));
    float sy = length(float3(model[1][0], model[1][1], model[1][2]));
    float sz = length(float3(model[2][0], model[2][1], model[2][2]));
        
    float3 radius = meshlet.radius * float3(sx, sy, sz);
    float3 center = mul(model, float4(meshlet.center, 1.0)).xyz;
        
        // Frustum Culling
    for (uint i = 0; i < 6; i++)
    {
        if (dot(frustum[i], float4(center, 1)) + length(radius) < 0.0)
        {
            return false;
        }
    }
        
    // Cone Culling
    float3 cone_apex = mul(model, float4(meshlet.cone_apex, 1.0)).xyz;
        
    float3x3 rotation = float3x3(
            model[0].xyz / sx,
            model[1].xyz / sy,
            model[2].xyz / sz
        );

    float3 cone_axis = mul(rotation, meshlet.cone_axis);
    float result = dot(normalize(mul(model, float4(meshlet.cone_apex, 1.0)).xyz - eye), cone_axis);
    return result < meshlet.cone_cutoff || result > 0.f;
}

bool IsInsideFrustum(Meshlet meshlet, float4x4 model, float4 frustum[6], float3 eye, float3 offset)
{
    float sx = length(float3(model[0][0], model[0][1], model[0][2]));
    float sy = length(float3(model[1][0], model[1][1], model[1][2]));
    float sz = length(float3(model[2][0], model[2][1], model[2][2]));
        
    float3 radius = meshlet.radius * float3(sx, sy, sz);
    float3 center = mul(model, float4(meshlet.center, 1.0)).xyz - offset;
        
        // Frustum Culling
    for (uint i = 0; i < 6; i++)
    {
        if (dot(frustum[i], float4(center, 1)) + length(radius) < 0.0)
        {
            return false;
        }
    }
        
    // Cone Culling
    float3 cone_apex = mul(model, float4(meshlet.cone_apex, 1.0)).xyz - offset;
        
    float3x3 rotation = float3x3(
            model[0].xyz / sx,
            model[1].xyz / sy,
            model[2].xyz / sz
        );

    float3 cone_axis = mul(rotation, meshlet.cone_axis);
    float result = dot(normalize(mul(model, float4(meshlet.cone_apex, 1.0)).xyz - eye) - offset, cone_axis);
    return result < meshlet.cone_cutoff || result > 0.f;
}

struct View
{
    float4 frustum[6];
    float4x4 view_matrix;
    float4x4 inv_view_matrix;
    float4x4 projection_matrix;
    float4x4 inv_projection_matrix;
    float4x4 view_projection_matrix;
    float4x4 inv_view_projection_matrix;
    float3 position;
    uint frame_count;
    float2 viewport;
    
    bool IsVisible(Meshlet meshlet, float4x4 model)
    {
        return IsInsideFrustum(meshlet, model, frustum, position);
    }
    
    void CastRay(float2 scene_uv, float2 frame_dim, out RayDesc ray, out RayDiff ray_diff)
    {
        float yaw = atan2(-view_matrix[2][2], -view_matrix[0][2]);
        float pitch = asin(-clamp(view_matrix[1][2], -1.f, 1.f));
        float3 forward = normalize(float3(cos(yaw) * cos(pitch), sin(pitch), sin(yaw) * cos(pitch)));
        float3 right = normalize(cross(forward, float3(0, 1, 0)));
        float3 up = normalize(cross(right, forward));
        float3 target = mul(inv_projection_matrix, float4(scene_uv.x, scene_uv.y, 1, 1)).xyz;

        ray.Origin = mul(inv_view_matrix, float4(0, 0, 0, 1)).xyz;
        ray.Direction = normalize(mul(inv_view_matrix, float4(target, 0)).xyz);
        ray.TMin = 0.0;
        ray.TMax = Infinity;

        float3 dir = forward + right * scene_uv.x + up * scene_uv.y;
        ray_diff.dOdx = 0;
        ray_diff.dOdy = 0;
        float dd = dot(dir, dir);
        float divd = 2.0f / (dd * sqrt(dd));
        float dr = dot(dir, right);
        float du = dot(dir, up);
        ray_diff.dDdx = ((dd * right) - (dr * dir)) * divd / frame_dim.x;
        ray_diff.dDdy = -((dd * up) - (du * dir)) * divd / frame_dim.y;
    }
};

struct CSParam
{
    uint3 DispatchThreadID : SV_DispatchThreadID;
    uint3 GroupThreadID : SV_GroupThreadID;
    uint3 GroupID : SV_GroupID;
    uint GroupIndex : SV_GroupIndex;
};

void UnPackTriangle(uint encode, out uint v0, out uint v1, out uint v2)
{
    v0 = encode & 0xff;
    v1 = (encode >> 8) & 0xff;
    v2 = (encode >> 16) & 0xff;
}

uint PackVisibilityBuffer(uint mesh_type, uint instance_id, uint primitive_id)
{
    // Mesh Type 1
    // Instance ID 8
    // Primitive ID 23
    uint vbuffer = 0;
    vbuffer += mesh_type & 0x1;
    vbuffer += (instance_id & 0xff) << 1;
    vbuffer += (primitive_id & 0x7fffff) << 9;
    return vbuffer;
}

void UnPackVisibilityBuffer(uint visibility_buffer, out uint mesh_type, out uint instance_id, out uint primitive_id)
{
    // Mesh Type 1
    // Instance ID 8
    // Primitive ID 23
    mesh_type = visibility_buffer & 0x1;
    instance_id = (visibility_buffer >> 1) & 0xff;
    primitive_id = (visibility_buffer >> 9) & 0x7fffff;
}

uint PackXY(uint x, uint y)
{
    return (x & 0xffff) + ((y & 0xffff) << 16);
}

void UnpackXY(uint xy, out uint x, out uint y)
{
    x = xy & 0xffff;
    y = (xy >> 16) & 0xffff;
}

float Luminance(float3 color)
{
    return dot(color, float3(0.2126f, 0.7152f, 0.0722f)); //color.r * 0.2126 + color.g * 0.7152 + color.b * 0.0722;
}

void CalculateFrustum(float4x4 view_projection, out float4 frustum[6])
{
    view_projection = transpose(view_projection);
    
	// Left
    frustum[0].x = view_projection[0].w + view_projection[0].x;
    frustum[0].y = view_projection[1].w + view_projection[1].x;
    frustum[0].z = view_projection[2].w + view_projection[2].x;
    frustum[0].w = view_projection[3].w + view_projection[3].x;

	// Right
    frustum[1].x = view_projection[0].w - view_projection[0].x;
    frustum[1].y = view_projection[1].w - view_projection[1].x;
    frustum[1].z = view_projection[2].w - view_projection[2].x;
    frustum[1].w = view_projection[3].w - view_projection[3].x;

	// Top
    frustum[2].x = view_projection[0].w - view_projection[0].y;
    frustum[2].y = view_projection[1].w - view_projection[1].y;
    frustum[2].z = view_projection[2].w - view_projection[2].y;
    frustum[2].w = view_projection[3].w - view_projection[3].y;

	// Bottom
    frustum[3].x = view_projection[0].w + view_projection[0].y;
    frustum[3].y = view_projection[1].w + view_projection[1].y;
    frustum[3].z = view_projection[2].w + view_projection[2].y;
    frustum[3].w = view_projection[3].w + view_projection[3].y;

	// Near
    frustum[4].x = view_projection[0].w + view_projection[0].z;
    frustum[4].y = view_projection[1].w + view_projection[1].z;
    frustum[4].z = view_projection[2].w + view_projection[2].z;
    frustum[4].w = view_projection[3].w + view_projection[3].z;

	// Far
    frustum[5].x = view_projection[0].w - view_projection[0].z;
    frustum[5].y = view_projection[1].w - view_projection[1].z;
    frustum[5].z = view_projection[2].w - view_projection[2].z;
    frustum[5].w = view_projection[3].w - view_projection[3].z;

    for (uint i = 0; i < 6; i++)
    {
        float len = length(frustum[i].xyz);
        frustum[i] /= len;
    }
}

#endif

================================================
FILE: Source/Shaders/Complex.hlsli
================================================
#ifndef COMPLEX_HLSLI
#define COMPLEX_HLSLI

struct Complex
{
    float re;
    float im;
};

Complex CreateComplex(float re, float im)
{
    Complex result;
    result.re = re;
    result.im = im;
    return result;
}

Complex ComplexFromReal(float x)
{
    Complex result;
    result.re = x;
    result.im = 0;
    return result;
}

Complex Add(Complex lhs, Complex rhs)
{
    Complex result;
    result.re = lhs.re + rhs.re;
    result.im = lhs.im + rhs.im;
    return result;
}

Complex Sub(Complex lhs, Complex rhs)
{
    Complex result;
    result.re = lhs.re - rhs.re;
    result.im = lhs.im - rhs.im;
    return result;
}

Complex Mul(Complex lhs, Complex rhs)
{
    Complex result;
    float a = lhs.re;
    float b = lhs.im;
    float c = rhs.re;
    float d = rhs.im;
    
    result.re = a * c - b * d;
    result.im = a * d + b * c;
    
    return result;
}

Complex Div(Complex lhs, Complex rhs)
{
    Complex result;
    float a = lhs.re;
    float b = lhs.im;
    float c = rhs.re;
    float d = rhs.im;
    
    float s = rhs.re * rhs.re + rhs.im * rhs.im;
    result.re = (a * c + b * d) / s;
    result.im = (b * c - a * d) / s;
    
    return result;
}

float Norm(Complex x)
{
    return x.re * x.re + x.im * x.im;
}

float Abs(Complex x)
{
    return sqrt(Norm(x));
}

Complex Sqrt(Complex x)
{
    Complex result;
    
    float n = Abs(x);
    float t1 = sqrt(0.5 * (n + abs(x.re)));
    float t2 = 0.5 * x.im / t1;

    if (n == 0)
    {
        return ComplexFromReal(0);
    }

    if (x.re >= 0)
    {
        return CreateComplex(t1, t2);
    }
    else
    {
        return CreateComplex(abs(t2), sign(t1) * x.im);
    }
    
    return ComplexFromReal(0);
}

#endif

================================================
FILE: Source/Shaders/Editor/AnimationEditor/DrawSkeleton.hlsl
================================================
struct VSInput
{
    float3 Position : POSITIONT0;
    uint BoneID : BLENDINDICES0;
};

struct UniformBlock
{
    float4x4 transform;
};

ConstantBuffer<UniformBlock> UniformBuffer;
StructuredBuffer<float4x4> BoneMatrices;

struct VSOutput
{
    float4 Position : SV_Position;
    float4 Color : COLOR0;
};

uint Hash(uint a)
{
    a = (a + 0x7ed55d16) + (a << 12);
    a = (a ^ 0xc761c23c) ^ (a >> 19);
    a = (a + 0x165667b1) + (a << 5);
    a = (a + 0xd3a2646c) ^ (a << 9);
    a = (a + 0xfd7046c5) + (a << 3);
    a = (a ^ 0xb55a4f09) ^ (a >> 16);
    return a;
}

float4 GenerateColor(uint a)
{
    uint hash = Hash(a);
    return float4(float3(float(hash & 255), float((hash >> 8) & 255), float((hash >> 16) & 255)) / 255.0, 1.0);
}

VSOutput VSmain(VSInput input)
{
    VSOutput output = (VSOutput) 0;
    //output.Position = mul(UniformBuffer.transform, mul(BoneMatrices[input.BoneID], float4(input.Position, 1.0f)));
    output.Position = mul(UniformBuffer.transform, mul(BoneMatrices[input.BoneID], float4(input.Position, 1.0f)));
    output.Color = GenerateColor(input.BoneID);
    return output;
}

struct PSInput
{
    float4 Color : COLOR0;
};

float4 PSmain(PSInput input) : SV_TARGET
{
    return input.Color;
}


================================================
FILE: Source/Shaders/Editor/AnimationEditor.hlsl
================================================
#define MAX_BONE_INFLUENCE 8

struct VSInput
{
    float3 Position : POSITIONT0;
    int4 BoneID0 : BLENDINDICES0;
    int4 BoneID1 : BLENDINDICES1;
    float4 BoneWeight0 : BLENDWEIGHT0;
    float4 BoneWeight1 : BLENDWEIGHT1;
};

struct UniformBlock
{
    float4x4 transform;
};

ConstantBuffer<UniformBlock> UniformBuffer;
StructuredBuffer<float4x4> BoneMatrices;

struct VSOutput
{
    float4 Position : SV_Position;
    float4 Color : COLOR0;
};

uint Hash(uint a)
{
    a = (a + 0x7ed55d16) + (a << 12);
    a = (a ^ 0xc761c23c) ^ (a >> 19);
    a = (a + 0x165667b1) + (a << 5);
    a = (a + 0xd3a2646c) ^ (a << 9);
    a = (a + 0xfd7046c5) + (a << 3);
    a = (a ^ 0xb55a4f09) ^ (a >> 16);
    return a;
}

float4 GenerateColor(uint a)
{
    uint hash = Hash(a);
    return float4(float3(float(hash & 255), float((hash >> 8) & 255), float((hash >> 16) & 255)) / 255.0, 1.0);
}

VSOutput VSmain(VSInput input)
{
    VSOutput output = (VSOutput) 0;
    
    uint bone_count = 0;
    uint bone_stride = 0;
    BoneMatrices.GetDimensions(bone_count, bone_stride);
    
    float4 total_position = 0.f;
    for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
    {
        int bone = -1;
        float weight = 0.f;
        
        if (i < 4)
        {
            bone = input.BoneID0[i];
            weight = input.BoneWeight0[i];
        }
        else
        {
            bone = input.BoneID1[i - 4];
            weight = input.BoneWeight1[i - 4];
        }
        
        if (bone == -1)
        {
            continue;
        }
        
        if (bone >= bone_count)
        {
            total_position = float4(input.Position, 1.0f);
            break;
        }
        
        float4 local_position = mul(BoneMatrices[bone], float4(input.Position, 1.0f));
        total_position += local_position * weight;
    }
        
    output.Position = mul(UniformBuffer.transform, total_position);
    output.Color = GenerateColor(input.BoneID0[0]);
    return output;
}

struct PSInput
{
    float4 Color : COLOR0;
};

float4 PSmain(PSInput input) : SV_TARGET
{
    return input.Color;
}


================================================
FILE: Source/Shaders/Editor/MaterialEditor.hlsl
================================================
#ifndef USE_MATERIAL
#include "Material/Material.hlsli"
#endif
#include "Tonemapper.hlsli"

struct VSInput
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
};

struct UniformBlock
{
    float4x4 transform;
    float4x4 model;
    float3 camera_pos;
    uint material_id;
};

ConstantBuffer<UniformBlock> UniformBuffer;

struct VSOutput
{
    float4 Position_ : SV_Position;
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord : TEXCOORD0;
};

VSOutput VSmain(VSInput input)
{
    VSOutput output = (VSOutput) 0;
    output.Position_ = mul(UniformBuffer.transform, mul(UniformBuffer.model, float4(input.Position, 1.f)));
    output.Position = output.Position_.xyz/output.Position_.w;
    output.Normal = normalize(mul((float3x3) UniformBuffer.model, input.Normal));
    output.Tangent = normalize(mul((float3x3) UniformBuffer.model, input.Tangent));
    output.Texcoord = input.Texcoord0;
    return output;
}

struct PSInput
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord : TEXCOORD0;
};

float4 PSmain(PSInput input) : SV_TARGET
{
    SurfaceInteraction surface_interaction;
    surface_interaction.isect.p = input.Position;
    surface_interaction.isect.n = input.Normal;
    surface_interaction.isect.nt = input.Tangent;
    surface_interaction.isect.uv = input.Texcoord;
    surface_interaction.duvdx = ddx(input.Texcoord);
    surface_interaction.duvdy = ddy(input.Texcoord);
    surface_interaction.material = UniformBuffer.material_id;
    
    Material material;
    material.Init(surface_interaction);
    
    float3 wo = normalize(UniformBuffer.camera_pos - surface_interaction.isect.p);
    float3 wi = normalize(float3(0.f, 1.f, 3.f) - surface_interaction.isect.p);
    float intensity = 1.5f;
    
    float3 color = (material.bsdf.Eval(wo, wi, TransportMode_Radiance) * abs(dot(wo, input.Normal)) + material.bsdf.GetGBufferData().emissive) * intensity;
    return float4(ToneMapUncharted(color), 1.f);
}


================================================
FILE: Source/Shaders/Editor/MeshEditor.hlsl
================================================
//#define SHADING
//#define DRAW_NORMAL
//#define DRAW_UV
//#define DRAW_TEXTURE
//#define WIREFRAME

struct VSInput
{
    float3 Position : POSITIONT0;
#if !defined(DRAW_UV) && !defined(WIREFRAME)
    float3 Normal : NORMAL0;
#endif
#if defined(DRAW_UV) || defined(DRAW_TEXTURE)
    float2 UV : TEXCOORD0;
#endif
};

struct UniformBlock
{
    float4x4 transform;
    float3 color;
    float3 direction;
};

Texture2D UVTexture;
SamplerState UVSampler;
ConstantBuffer<UniformBlock> UniformBuffer;

struct VSOutput
{
    float4 Position : SV_Position;
#if !defined(DRAW_UV) && !defined(WIREFRAME)
    float3 Normal : NORMAL0;
#endif
#if defined(DRAW_UV) || defined(DRAW_TEXTURE)
    float2 UV : TEXCOORD0;
#endif
};

VSOutput VSmain(VSInput input)
{
    VSOutput output = (VSOutput) 0;
#if defined(DRAW_UV) || defined(DRAW_TEXTURE)
    output.UV = input.UV;
#endif
    output.Position = mul(UniformBuffer.transform, float4(input.Position, 1.0f));
#if !defined(DRAW_UV) && !defined(WIREFRAME)
    output.Normal = input.Normal;
#endif
    return output;
}

struct PSInput
{
#if !defined(DRAW_UV) && !defined(WIREFRAME)
    float3 Normal : NORMAL0;
#endif
#if defined(DRAW_UV) || defined(DRAW_TEXTURE)
    float2 UV : TEXCOORD0;
#endif
};

float4 PSmain(PSInput input) : SV_TARGET
{
#ifdef SHADING
    float3 ambient = 0.3f;
    float3 norm = normalize(input.Normal);

    float3 diffuse = max(dot(norm, UniformBuffer.direction), 0.0);
    
    float3 reflect_dir = reflect(-UniformBuffer.direction, norm);
    float specular = pow(max(dot(UniformBuffer.direction, reflect_dir), 0.0), 3.f);
    return float4((ambient + diffuse + specular) * UniformBuffer.color, 1.0f);
#endif
    
#ifdef DRAW_NORMAL
    return float4(input.Normal, 1.0f);
#endif
    
#ifdef DRAW_UV
    return float4(input.UV, 0.f, 1.0f);
#endif
    
#ifdef DRAW_TEXTURE
    float3 ambient = 0.3f;
    float3 norm = normalize(input.Normal);
    float3 texture_color = UVTexture.Sample(UVSampler, input.UV).rgb;

    float3 diffuse = max(dot(norm, UniformBuffer.direction), 0.0);
    
    float3 reflect_dir = reflect(-UniformBuffer.direction, norm);
    float specular = pow(max(dot(UniformBuffer.direction, reflect_dir), 0.0), 3.f);
    return float4((ambient + diffuse + specular) * texture_color, 1.0f);
#endif
    
#ifdef WIREFRAME
    return float4(0.f, 0.f, 0.f, 1.f);
#endif
}


================================================
FILE: Source/Shaders/Editor/Preview/Material.hlsl
================================================
#ifndef USE_MATERIAL
#include "../../Material/Material.hlsli"
#endif
#include "../../Tonemapper.hlsli"

#ifndef RUNTIME
#define MATERIAL_ID 0
#endif

struct VSInput
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    uint InstanceID : SV_InstanceID;
};

struct VSOutput
{
    float4 Position_ : SV_Position;
    float3 Position : POSITION0;
    float3 Tangent : TANGENT0;
    float3 Normal : NORMAL0;
    float2 Texcoord : TEXCOORD0;
};

struct PSInput
{
    float3 Position : POSITION0;
    float3 Tangent : TANGENT0;
    float3 Normal : NORMAL0;
    float2 Texcoord : TEXCOORD0;
};

struct UniformBlock
{
    float4x4 transform;
    float4x4 model;
};

ConstantBuffer<UniformBlock> UniformBuffer;

VSOutput VSmain(VSInput input)
{
    VSOutput output = (VSOutput) 0;
    output.Position_ = mul(UniformBuffer.transform, mul(UniformBuffer.model, float4(input.Position, 1.f)));
    output.Position = output.Position_.xyz / output.Position_.w;
    output.Normal = normalize(mul((float3x3) UniformBuffer.model, input.Normal));
    output.Tangent = normalize(mul((float3x3) UniformBuffer.model, input.Tangent));
    output.Texcoord = input.Texcoord0;
    return output;
}

float4 PSmain(PSInput input) : SV_TARGET
{
    SurfaceInteraction surface_interaction;
    surface_interaction.isect.p = input.Position;
    surface_interaction.isect.n = input.Normal;
    surface_interaction.isect.n = input.Normal;
    surface_interaction.isect.nt = input.Tangent;
    surface_interaction.isect.uv = input.Texcoord;
    surface_interaction.duvdx = ddx(input.Texcoord);
    surface_interaction.duvdy = ddy(input.Texcoord);
    surface_interaction.material = MATERIAL_ID;
    
    Material material;
    material.Init(surface_interaction);
    
    float3 wo = normalize(float3(0.f, 2.f, 3.46f) - surface_interaction.isect.p);
    float3 wi = normalize(float3(0.f, 1.f, 3.f) - surface_interaction.isect.p);
    float intensity = 1.5f;
    
    float3 color = (material.bsdf.Eval(wo, wi, TransportMode_Radiance) * abs(dot(wo, input.Normal)) + material.bsdf.GetGBufferData().emissive) * intensity;
    return float4(ToneMapUncharted(color), 1.f);
}

================================================
FILE: Source/Shaders/Editor/Preview/Mesh.hlsl
================================================
struct VSInput
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    uint InstanceID : SV_InstanceID;
};

struct VSOutput
{
    float4 Position : SV_Position;
    float3 Normal : NORMAL0;
};

struct PSInput
{
    float3 Normal : NORMAL0;
};

struct UniformBlock
{
    float4x4 transform;
};

ConstantBuffer<UniformBlock> UniformBuffer;

VSOutput VSmain(VSInput input)
{
    VSOutput output = (VSOutput) 0;
    float4 position = mul(UniformBuffer.transform, float4(input.Position, 1.0f));
    output.Position = position;
    output.Normal = input.Normal;
    return output;
}

float4 PSmain(PSInput input) : SV_TARGET
{
    float3 norm = normalize(input.Normal);
    float3 diffuse = max(dot(norm, normalize(float3(0, 1, 1))), 0.0);
    return float4(diffuse, 1.f);
}

================================================
FILE: Source/Shaders/GlobalIllumination/DDGI.hlsl
================================================


================================================
FILE: Source/Shaders/ImGui.hlsl
================================================
struct VSInput
{
    float2 Pos : POSITIONT0;
    float2 UV : TEXCOORD0;
    float4 Color : COLOR0;
};

struct Constant
{
    float2 scale;
    float2 translate;
};

ConstantBuffer<Constant> constant : register(b0);

Texture2D fontTexture : register(t1);
SamplerState fontSampler : register(s2);

struct VSOutput
{
    float4 Pos : SV_Position;
    float2 UV : TEXCOORD0;
    float4 Color : COLOR0;
};

VSOutput VSmain(VSInput input)
{
    VSOutput output = (VSOutput) 0;
    output.UV = input.UV;
    output.Color = input.Color;
    output.Pos = float4(input.Pos * constant.scale + constant.translate, 0.0, 1.0);
#ifdef VULKAN_BACKEND
    output.Pos.y *= -1.f;
#endif
    return output;
}

struct PSInput
{
    float2 UV : TEXCOORD0;
    float4 Color : COLOR0;
};

float4 PSmain(PSInput input) : SV_TARGET
{
    return input.Color * fontTexture.Sample(fontSampler, input.UV);
}


================================================
FILE: Source/Shaders/Interaction.hlsli
================================================
#ifndef INTERATION_HLSLI
#define INTERATION_HLSLI

#include "Math.hlsli"

float3 OffsetRayOrigin(float3 p, float3 n)
{
    const float intScale = 256.0f;
    const float floatScale = 1.0f / 65536.0f;
    const float origin = 1.0f / 32.0f;

    int3 of_i = int3(intScale * n.x, intScale * n.y, intScale * n.z);

    float3 p_i = float3(asfloat(asint(p.x) + ((p.x < 0) ? -of_i.x : of_i.x)),
                  asfloat(asint(p.y) + ((p.y < 0) ? -of_i.y : of_i.y)),
                  asfloat(asint(p.z) + ((p.z < 0) ? -of_i.z : of_i.z)));

    return float3(abs(p.x) < origin ? p.x + floatScale * n.x : p_i.x, //
              abs(p.y) < origin ? p.y + floatScale * n.y : p_i.y, //
              abs(p.z) < origin ? p.z + floatScale * n.z : p_i.z);
}

struct Frame
{
    float3 x, y, z;
    
    void FromXZ(float3 x_, float3 z_)
    {
        x = x_;
        y = cross(z_, x_);
        z = z_;
    }
    
    void FromXY(float3 x_, float3 y_)
    {
        x = x_;
        y = y_;
        z = cross(x, y);
    }

    void FromZ(float3 z_)
    {
        z = z_;
        CoordinateSystem(z, x, y);
    }

    void FromX(float3 x_)
    {
        x = x_;
        CoordinateSystem(x, y, z);
    }

    void FromY(float3 y_)
    {
        y = y_;
        CoordinateSystem(y, z, x);
    }

    float3 ToLocal(float3 v)
    {
        return float3(dot(v, x), dot(v, y), dot(v, z));
    }

    float3 ToWorld(float3 v)
    {
        return v.x * x + v.y * y + v.z * z;
    }
};

struct Interaction
{
    float3 p;
    float3 n;
    float3 nt;
    float2 uv;
    float3 wo;
    float t;
    
    void Init(float3 p_, float3 n_, float2 uv_, float3 wo_, float t_)
    {
        p = p_;
        n = n_;
        uv = uv_;
        wo = wo_;
        t = t_;
    }
        
    RayDesc SpawnRay(float3 dir)
    {
        RayDesc ray;
        ray.Direction = dir;
        ray.Origin = OffsetRayOrigin(p, FaceForward(n, dir));
        return ray;
    }
    
    RayDesc SpawnRayTo(float3 position)
    {
        return SpawnRay(normalize(position - p));
    }
};

struct MediumInteraction
{
    Interaction isect;
};

struct SurfaceInteraction
{
    Interaction isect;
    
    /*float3 dpdu, dpdv;
    float3 dndu, dndv;
    
    struct
    {
        float3 n;
        float3 dpdu, dpdv;
        float3 dndu, dndv;
    } shading;*/
  
    float3 shading_n;
    uint material;
    float3 dpdx, dpdy;
    float3 dndx, dndy;
    float2 duvdx, duvdy;
};

struct VisibilityTester
{
    SurfaceInteraction from;
    float3 dir;
    float dist;
};

#endif 

================================================
FILE: Source/Shaders/Light.hlsli
================================================
#ifndef LIGHT_HLSLI
#define LIGHT_HLSLI

#include "Interaction.hlsli"
#include "Math.hlsli"

#define POINT_LIGHT 0
#define SPOT_LIGHT 1
#define DIRECTIONAL_LIGHT 2
#define RECT_LIGHT 3

#define LIGHT_TYPE_COUNT 4

struct LightInfo
{
    uint point_light_count;
    uint spot_light_count;
    uint directional_light_count;
    uint rect_light_count;
};

struct LightLeSample
{
    float3 L;
    RayDesc ray;
    Interaction isect;
    float pdf_pos;
    float pdf_dir;
    
    void Create(float3 L_, RayDesc ray_, float pdf_pos_, float pdf_dir_)
    {
        L = L_;
        ray = ray_;
        pdf_pos = pdf_pos_;
        pdf_dir = pdf_dir_;
    }

    void Create(float3 L_, RayDesc ray_, Interaction isect_, float pdf_pos_, float pdf_dir_)
    {
        L = L_;
        ray = ray_;
        isect = isect_;
        pdf_pos = pdf_pos_;
        pdf_dir = pdf_dir_;
    }
};

struct LightLiSample
{
    float3 L;
    float3 wi;
    float pdf;
    Interaction isect;
    
    void Create(float3 L_, float3 wi_, float pdf_, Interaction isect_)
    {
        L = L_;
        wi = wi_;
        pdf = pdf_;
        isect = isect_;
    }
};

struct LightSampleContext
{
    float3 p;
    float3 n;
    float3 ns;
};

struct PointLight
{
    float3 color;
    float intensity;
    float3 position;
    
    float filter_scale;
    float light_scale;
    uint filter_sample;
    uint cast_shadow;
    uint shadow_id;
    
    LightLeSample SampleLe(float2 u1, float2 u2, float time)
    {
        RayDesc ray;
        ray.Origin = position;
        ray.Direction = UniformSampleSphere(u1);
        ray.TMin = 0.f;
        ray.TMax = time;
        
        LightLeSample le_sample;
        le_sample.Create(color * intensity, ray, 1, UniformSpherePdf());
        
        return le_sample;
    }
    
    void PDF_Le(RayDesc ray, out float pdf_pos, out float pdf_dir)
    {
        pdf_pos = 0;
        pdf_dir = UniformSpherePdf();
    }

    void PDF_Le(Interaction isect, float3 w, out float pdf_pos, out float pdf_dir)
    {
        
    }

    LightLiSample SampleLi(LightSampleContext ctx, float2 u)
    {
        float3 p = position;
        float3 wi = normalize(p - ctx.p);
        float3 L = color * intensity / DistanceSquared(p, ctx.p);
        
        Interaction isect;
        isect.p = p;
        
        LightLiSample li_sample;
        li_sample.Create(L, wi, 1, isect);
        
        return li_sample;
    }

    float PDF_Li(LightSampleContext ctx, float3 wi)
    {
        return 0.f;
    }
    
    bool IsDelta()
    {
        return true;
    }
};

struct SpotLight
{
    float3 color;
    float intensity;
    float3 position;
    float inner_angle;
    float3 direction;
    float outer_angle;
    float4x4 view_projection;
    
    float filter_scale;
    float light_scale;
    uint filter_sample;
    uint cast_shadow;
    uint shadow_id;
    
    float3 EvalL(float3 p, out float3 wi)
    {
        wi = normalize(position - p);
        float light_angle_scale = 1.0 / max(0.001, cos(inner_angle) - cos(outer_angle));
        float light_angle_offset = -cos(outer_angle) * light_angle_scale;
        float cd = max(dot(-direction, wi), 0.0);
        float angular_attenuation = saturate(cd * light_angle_scale + light_angle_offset);
        return color.rgb * intensity * angular_attenuation * angular_attenuation;
    }
    
    LightLeSample SampleLe(float2 u1, float2 u2, float time)
    {
        // TODO
        
        LightLeSample le_sample;
        
        return le_sample;
    }
    
    void PDF_Le(RayDesc ray, out float pdf_pos, out float pdf_dir)
    {
        // TODO
    }

    void PDF_Le(Interaction isect, float3 w, out float pdf_pos, out float pdf_dir)
    {
        // TODO
    }

    LightLiSample SampleLi(LightSampleContext ctx, float2 u)
    {
        float3 p = position;
        float3 wi;
        float3 L = EvalL(ctx.p, wi) / DistanceSquared(p, ctx.p);
        
        Interaction isect;
        isect.p = p;
        
        LightLiSample li_sample;
        li_sample.Create(L, wi, 1, isect);
        
        return li_sample;
    }

    float PDF_Li(LightSampleContext ctx, float3 wi)
    {
        return 0.f;
    }
    
    bool IsDelta()
    {
        return true;
    }
};

struct DirectionalLight
{
    float3 color;
    float intensity;
    float4 split_depth;
    float4x4 view_projection[4];
    float4 shadow_cam_pos[4];
    float3 direction;
    
    float filter_scale;
    float light_scale;
    uint filter_sample;
    uint cast_shadow;
    uint shadow_id;
    
    LightLiSample SampleLi(LightSampleContext ctx, float2 u)
    {
        float3 wi = normalize(-direction);
        
        Interaction isect;
        isect.p = ctx.p + 1e16 * wi;
        
        float3 L = color.rgb * intensity;
        
        LightLiSample li_sample;
        li_sample.Create(L, wi, 1, isect);
        
        return li_sample;
    }
    
    bool IsDelta()
    {
        return true;
    }
};

struct RectLight
{
    float3 color;
    float intensity;
    float4 corner[4];
    uint texture_id;
    uint two_side;

    LightLiSample SampleLi(LightSampleContext ctx, float2 u)
    {
        float3 v0 = (corner[1] - corner[0]).xyz;
        float3 v1 = (corner[3] - corner[0]).xyz;
        
        float3 n = cross(v0, v1);
        
        float area = length(cross(v0, v1));
        
        Interaction isect;
        isect.p = corner[0].xyz + v0 * u.x + v1 * u.y;
        
        float3 wi = normalize(isect.p - ctx.p);
        float3 L = (two_side || dot(wi, n)) > 0 ? color.rgb * intensity / DistanceSquared(isect.p, ctx.p) / area : 0.f;
        
        LightLiSample li_sample;
        li_sample.Create(L, wi, 1.f / area, isect);
        
        return li_sample;
    }
    
    bool IsDelta()
    {
        return true;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/BSDF/BSDF.hlsli
================================================
#ifndef BSDF_HLSLI
#define BSDF_HLSLI

// BxDF Flags
static uint BSDF_Reflection = 1 << 0;
static uint BSDF_Transmission = 1 << 1;
static uint BSDF_Diffuse = 1 << 2;
static uint BSDF_Glossy = 1 << 3;
static uint BSDF_Specular = 1 << 4;
static uint BSDF_DiffuseReflection = BSDF_Diffuse | BSDF_Reflection;
static uint BSDF_DiffuseTransmission = BSDF_Diffuse | BSDF_Transmission;
static uint BSDF_GlossyReflection = BSDF_Glossy | BSDF_Reflection;
static uint BSDF_GlossyTransmission = BSDF_Glossy | BSDF_Transmission;
static uint BSDF_SpecularReflection = BSDF_Specular | BSDF_Reflection;
static uint BSDF_SpecularTransmission = BSDF_Specular | BSDF_Transmission;
static uint BSDF_All = BSDF_Diffuse | BSDF_Glossy | BSDF_Specular | BSDF_Reflection | BSDF_Transmission;

// Sample Flag
static uint SampleFlags_Unset = 0;
static uint SampleFlags_Reflection = 1 << 0;
static uint SampleFlags_Transmission = 1 << 1;
static uint SampleFlags_All = SampleFlags_Reflection | SampleFlags_Transmission;

// Transport Mode
static uint TransportMode_Radiance = 0;
static uint TransportMode_Importance = 1;

#define SampleFlags uint
#define TransportMode uint
#define BxDFFlags uint

bool IsReflective(uint f)
{
    return f & BSDF_Reflection;
}

bool IsTransmissive(uint f)
{
    return f & BSDF_Transmission;
}

bool IsDiffuse(uint f)
{
    return f & BSDF_Diffuse;
}

bool IsGlossy(uint f)
{
    return f & BSDF_Glossy;
}

bool IsSpecular(uint f)
{
    return f & BSDF_Specular;
}

bool IsNonSpecular(uint f)
{
    return f & (BSDF_Diffuse | BSDF_Glossy);
}

struct BSDFSample
{
    float3 f;
    float3 wiW;
    float3 wi;
    float pdf;
    BxDFFlags flags;
    float eta;
    bool pdfIsProportional;
    
    void Init()
    {
        f = 0.f;
        wiW = 0.f;
        wi = 0.f;
        pdf = 0.f;
        flags = 0.f;
        eta = 1.f;
        pdfIsProportional = false;

    }
    
    bool IsReflection()
    {
        return flags & BSDF_Reflection;
    }
    
    bool IsTransmission()
    {
        return flags & BSDF_Transmission;
    }
    
    bool IsDiffuse()
    {
        return flags & BSDF_Diffuse;
    }
    
    bool IsGlossy()
    {
        return flags & BSDF_Glossy;
    }
    
    bool IsSpecular()
    {
        return flags & BSDF_Specular;
    }
};

float3 SRGBtoLINEAR(float3 srgb_in)
{
#ifdef SRGB_FAST_APPROXIMATION
  float3 linOut = pow(srgbIn, vec3(2.2));
#else  //SRGB_FAST_APPROXIMATION
    float3 bLess = step(0.04045, srgb_in);
    float3 linOut = lerp(srgb_in.xyz / 12.92, pow((srgb_in + 0.055) / 1.055, 2.4), bLess);
#endif  //SRGB_FAST_APPROXIMATION
    return linOut;
}

struct GBufferData
{
    float3 normal;
    float3 albedo;
    float3 emissive;
    float metallic;
    float roughness;
    float anisotropic;
};

// struct BSDF
// {
//     void Init();

//     float3 Eval(float3 wo, float3 wi, TransportMode mode);

//     float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags);

//     BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags);

//     GBufferData GetGBufferData();

// };

#endif

================================================
FILE: Source/Shaders/Material/BSDF/ConductorBSDF.hlsli
================================================
#ifndef CONDUCTOR_BSDF_HLSLI
#define CONDUCTOR_BSDF_HLSLI

#include "BSDF.hlsli"
#include "../Scattering.hlsli"
#include "../Fresnel.hlsli"
#include "../../Math.hlsli"
#include "../../Interaction.hlsli"

struct ConductorBSDF
{
    TrowbridgeReitzDistribution distribution;
    float3 eta;
    float3 k;
    float3 R;
    
    void Init(float3 R_, float roughness, float3 eta_, float3 k_)
    {
        R = R_;
        eta = eta_;
        k = k_;
        distribution.alpha_x = roughness;
        distribution.alpha_y = roughness;
        distribution.sample_visible_area = true;
    }

    uint Flags()
    {
        return distribution.EffectivelySmooth() ? BSDF_SpecularReflection : BSDF_GlossyReflection;
    }

    float3 Eval(float3 wo, float3 wi, TransportMode mode)
    {
        if(!SameHemisphere(wo, wi))
        {
            return 0.f;
        }

        if(distribution.EffectivelySmooth())
        {
            return 0.f;
        }

        float cos_theta_o = AbsCosTheta(wo);
        float cos_theta_i = AbsCosTheta(wi);

        if(cos_theta_i == 0 || cos_theta_o == 0)
        {
            return 0.f;
        }

        float3 wm = wi + wo;

        if(LengthSquared(wm) == 0)
        {
            return 0.f;
        }

        wm = normalize(wm);

        float3 F = FresnelConductor(abs(dot(wo, wm)), eta, k);

        return R * distribution.D(wm) * F * distribution.G(wo, wi) / (4 * cos_theta_i * cos_theta_o);
    }

    float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags)
    {
        if(!(flags & SampleFlags_Reflection))
        {
            return 0.f;
        }
        if(!SameHemisphere(wo, wi))
        {
            return 0.f;
        }
        if(distribution.EffectivelySmooth())
        {
            return 0.f;
        }

        float3 wm = wo + wi;

        if(LengthSquared(wm) == 0)
        {
            return 0.f;
        }

        wm = Faceforward(normalize(wm), float3(0, 0, 1));
        return distribution.Pdf(wo, wm) / (4 * abs(dot(wo, wm)));
    }

    BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample;
        bsdf_sample.Init();

        if(!(flags & SampleFlags_Reflection))
        {
            return bsdf_sample;
        }

        if(distribution.EffectivelySmooth())
        {
            float3 wi = float3(-wo.x, -wo.y, wo.z);
            
            bsdf_sample.f = R * FresnelConductor(AbsCosTheta(wi), eta, k) / AbsCosTheta(wi);
            bsdf_sample.wi = wi;
            bsdf_sample.pdf = 1;
            bsdf_sample.flags = BSDF_SpecularReflection;
            bsdf_sample.eta = 1;

            return bsdf_sample;
        }

        if(wo.z == 0)
        {
            return bsdf_sample;
        }

        float3 wm = distribution.SampleWm(wo, u);
        float3 wi = Reflect(wo, wm);

        if(!SameHemisphere(wo, wi))
        {
            return bsdf_sample;
        }

        float cos_theta_o = AbsCosTheta(wo);
        float cos_theta_i = AbsCosTheta(wi);
        if(cos_theta_i == 0 || cos_theta_o == 0)
        {
           return bsdf_sample;
        }

        float3 F = FresnelConductor(abs(dot(wo, wm)), eta, k);

        bsdf_sample.f = R * distribution.D(wm) * F * distribution.G(wo, wi) / (4 * cos_theta_i * cos_theta_o);
        bsdf_sample.wi = wi;
        bsdf_sample.pdf = distribution.Pdf(wo, wm) / (4 * abs(dot(wo, wm)));
        bsdf_sample.flags = BSDF_GlossyReflection;
        bsdf_sample.eta = 1;

        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/BSDF/DielectricBSDF.hlsli
================================================
#ifndef DIELECTRIC_BSDF_HLSLI
#define DIELECTRIC_BSDF_HLSLI

#include "BSDF.hlsli"
#include "../Scattering.hlsli"
#include "../Fresnel.hlsli"
#include "../../Math.hlsli"
#include "../../Interaction.hlsli"

struct DielectricBSDF
{
    float3 R;
    float3 T;
    float eta;
    TrowbridgeReitzDistribution distribution;

    void Init(float3 R_, float3 T_, float ior_, float roughness)
    {
        R = R_;
        T = T_;
        eta = ior_;

        distribution.alpha_x = roughness;
        distribution.alpha_y = roughness;
        distribution.sample_visible_area = true;
    }

    uint Flags()
    {
        uint flags = (eta == 1.f? BSDF_Transmission : BSDF_Reflection | BSDF_Transmission);
        return flags | (distribution.EffectivelySmooth()? BSDF_Specular : BSDF_Glossy);
    }

    float3 Eval(float3 wo, float3 wi, TransportMode mode)
    {
        if(eta == 1.f || distribution.EffectivelySmooth())
        {
            return 0.f;
        }

        float cos_theta_o = CosTheta(wo);
        float cos_theta_i = CosTheta(wi);
        bool reflection = cos_theta_o * cos_theta_i > 0;
        float etap = 1;
        if(!reflection)
        {
            etap = cos_theta_o > 0.f ? eta : (1 / eta);
        }

        float3 wm = wi * etap + wo;

        if(cos_theta_i == 0 || cos_theta_o == 0 || LengthSquared(wm) == 0)
        {
            return 0.f;
        }

        wm = FaceForward(normalize(wm), float3(0, 0, 1));

        if(dot(wm, wi) * cos_theta_i < 0 || dot(wm, wo) * cos_theta_o < 0)
        {
            return 0.f;
        }

        float F = FresnelDielectric(dot(wo, wm), eta);

        if(reflection)
        {
            return R * distribution.D(wm) * distribution.G(wo, wi) * F / 
                abs(4 * cos_theta_i * cos_theta_o);            
        }
        else
        {
            float denom = Sqr(dot(wi, wm) + dot(wo, wm) / etap) * cos_theta_i * cos_theta_o;
            float3 ft = T * distribution.D(wm) * (1.f - F) * distribution.G(wo, wi) * 
                abs(dot(wi, wm) * dot(wo, wm) / denom);
            if(mode == TransportMode_Radiance)
            {
                ft /= Sqr(etap);
            }
            return ft;
        }
    }

    float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags)
    {
        if(eta == 1.f || distribution.EffectivelySmooth())
        {
            return 0.f;
        }

        float cos_theta_o = CosTheta(wo);
        float cos_theta_i = CosTheta(wi);
        bool reflection = cos_theta_o * cos_theta_i > 0;
        float etap = 1;
        if(!reflection)
        {
            etap = cos_theta_o > 0.f ? eta : 1 / eta;
        }

        float3 wm = wi * etap + wo;

        if(cos_theta_i == 0 || cos_theta_o == 0 || LengthSquared(wm) == 0)
        {
            return 0.f;
        }

        wm = FaceForward(normalize(wm), float3(0, 0, 1));

        if(dot(wm, wi) * cos_theta_i < 0 || dot(wm, wo) * cos_theta_o < 0)
        {
            return 0.f;
        }

        float pr = FresnelDielectric(dot(wo, wm), eta);
        float pt = 1.f - pr;

        if(!(flags & SampleFlags_Reflection))
        {
            pr = 0;
        }
        if(!(flags & SampleFlags_Transmission))
        {
            pt = 0;
        }
        if(pr == 0 && pt == 0)
        {
            return 0.f;
        }

        float pdf = 0.f;
        if(reflection)
        {
            pdf = distribution.Pdf(wo, wm) / (4.0 * abs(dot(wo, wm))) * pr / (pr + pt);
        }
        else
        {
            float denom = Sqr(dot(wi, wm) + dot(wo, wm) / etap);
            float dwm_dwi = abs(dot(wi, wm)) / denom;
            pdf = distribution.Pdf(wo, wm) * dwm_dwi * pt / (pr + pt);
        }

        return pdf;
    }

    BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample;
        bsdf_sample.Init();

        if(eta == 1 || distribution.EffectivelySmooth())
        {
            // Smooth Dielectric
            float F = FresnelDielectric(CosTheta(wo), eta);
            float pr = F;
            float pt = 1.f - F;
            if(!(flags & SampleFlags_Reflection))
            {
                pr = 0.f;
            }
            if(!(flags & SampleFlags_Transmission))
            {
                pt = 0.f;
            }
            if(pr == 0.f && pt == 0.f)
            {
                return bsdf_sample;
            }

            if(uc < pr / (pr + pt))
            {
                float3 wi = float3(-wo.x, -wo.y, wo.z);
                float3 fr = R * F / abs(CosTheta(wi));
                
                bsdf_sample.f = fr;
                bsdf_sample.wi = wi;
                bsdf_sample.pdf = pr / (pr + pt);
                bsdf_sample.flags = BSDF_SpecularReflection;
                bsdf_sample.eta = 1;

                return bsdf_sample;
            }
            else
            {
                float etap = 0.f;
                float3 wi;
                if (!Refract(wo, float3(0.0, 0.0, 1.0), eta, etap, wi))
                {
                    return bsdf_sample;
                }

                float3 ft = (1.f - F) * T / abs(CosTheta(wi));
                if(mode == TransportMode_Radiance)
                {
                    ft /= Sqr(etap);
                }

                bsdf_sample.f = ft;
                bsdf_sample.wi = wi;
                bsdf_sample.pdf = pt / (pr + pt);
                bsdf_sample.flags = BSDF_SpecularTransmission;
                bsdf_sample.eta = etap;

                return bsdf_sample;
            }
        }
        else
        {
            // Rough Dielectric
            float3 wm = distribution.SampleWm(wo, u);
            float F = FresnelDielectric(CosTheta(wo), eta);
            float pr = F;
            float pt = 1.f - F;

            if(!(flags & SampleFlags_Reflection))
            {
                pr = 0.f;
            }
            if(!(flags & SampleFlags_Transmission))
            {
                pt = 0.f;
            }
            if(pr == 0.f && pt == 0.f)
            {
                return bsdf_sample;
            }

            if (uc < pr / (pr + pt))
            {
                float3 wi = Reflect(wo, wm);
                if(!SameHemisphere(wo, wi))
                {
                    return bsdf_sample;
                }

                bsdf_sample.f = distribution.D(wm) * distribution.G(wo, wi) * R * F / (4.f * CosTheta(wi) * CosTheta(wo));
                bsdf_sample.wi = wi;
                bsdf_sample.pdf = distribution.Pdf(wo, wm) / (4.f * abs(dot(wo, wm))) * pr / (pr + pt);
                bsdf_sample.flags = BSDF_GlossyReflection;
                bsdf_sample.eta = 1.f;

                return bsdf_sample;
            }
            else
            {
                float etap;
                float3 wi;
                if(!Refract(wo, Faceforward(wm, float3(0, 0, 1)), eta, etap, wi))
                {
                    return bsdf_sample;
                }

                float denom = Sqr(dot(wi, wm) + dot(wo, wm) / etap);
                float dwm_dwi = abs(dot(wi, wm)) / denom;
                float3 ft = T * (1.f - F) * distribution.D(wm) * distribution.G(wo, wi) * 
                        abs(dot(wi, wm) * dot(wo, wm) / 
                        (CosTheta(wi) * CosTheta(wo) * denom));

                if(mode == TransportMode_Radiance)
                {
                    ft /= Sqr(etap);
                }

                bsdf_sample.f = ft;
                bsdf_sample.wi = wi;
                bsdf_sample.pdf = distribution.Pdf(wo, wm) * dwm_dwi * pt / (pr + pt);
                bsdf_sample.flags = BSDF_GlossyTransmission;
                bsdf_sample.eta = etap;

                return bsdf_sample;
            }
        }

        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/BSDF/DiffuseBSDF.hlsli
================================================
#ifndef DIFFUSE_BSDF_HLSLI
#define DIFFUSE_BSDF_HLSLI

#include "BSDF.hlsli"
#include "../../Math.hlsli"
#include "../../Interaction.hlsli"

struct DiffuseBSDF
{
    float3 R;

    void Init(float3 R_)
    {
        R = R_;
    }
    
    uint Flags()
    {
        return BSDF_DiffuseReflection;
    }

    float3 Eval(float3 wo, float3 wi, TransportMode mode)
    {
        if (!SameHemisphere(wo, wi))
        {
            return 0.f;
        }
        
        return R * InvPI;
    }

    float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags)
    {
        if (!(flags & SampleFlags_Reflection) || !SameHemisphere(wo, wi))
        {
            return 0.f;
        }
        
        return AbsCosTheta(wi) * InvPI;
    }

    BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample;
        
        bsdf_sample.Init();
        
        if (!(flags & SampleFlags_Reflection))
        {
            return bsdf_sample;
        }

        float3 wi = SampleCosineHemisphere(u);
        
        if (wo.z < 0.f)
        {
            wi.z *= -1.f;
        }

        bsdf_sample.f = Eval(wo, wi, mode);
        bsdf_sample.wi = wi;
        bsdf_sample.pdf = PDF(wo, wi, mode, flags);
        bsdf_sample.flags = BSDF_DiffuseReflection;
        bsdf_sample.eta = 1;

        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/BSDF/DisneyBSDF.hlsli
================================================
#ifndef DISNEY_BSDF_HLSLI
#define DISNEY_BSDF_HLSLI

#include "BSDF.hlsli"
#include "../Scattering.hlsli"
#include "../Fresnel.hlsli"
#include "../../Math.hlsli"
#include "../../Common.hlsli"
#include "../../Interaction.hlsli"

float2 CalculateAnisotropicRoughness(float anisotropic, float roughness)
{
    float rough2 = Sqr(roughness);
    if (anisotropic == 0)
    {
        float a = max(0.001, rough2);
        return a;
    }
    float aspect = sqrt(1.0 - 0.9 * anisotropic);
    return float2(max(0.001, rough2 / aspect), max(0.001, rough2 * aspect));
}

// Schlick Fresnel Approximation
float SchlickWeight(float cos_theta)
{
    float m = clamp(1 - cos_theta, 0.0, 1.0);
    return pow(m, 5.0);
}

float FrSchlick(float R0, float cos_theta)
{
    return lerp(R0, 1.0, SchlickWeight(cos_theta));
}

float3 FrSchlick(float3 R0, float cos_theta)
{
    return lerp(R0, float3(1.0, 1.0, 1.0), SchlickWeight(cos_theta));
}

float SchlickR0FromEta(float eta)
{
    return ((eta - 1.0) * (eta - 1.0)) / ((eta + 1.0) * (eta + 1.0));
}

// Diffuse
float3 DisneyDiffuse(float3 base_color, float3 wo, float3 wi)
{
    float Fo = SchlickWeight(AbsCosTheta(wo));
    float Fi = SchlickWeight(AbsCosTheta(wi));
    return base_color * InvPI * (1 - Fo / 2) * (1 - Fi / 2);
}

// Fake subsurface
float3 DisneyFakeSS(float3 base_color, float roughness, float3 wo, float3 wi)
{
    float3 wh = wi + wo;
    if (IsBlack(wh))
    {
        return 0.f;
    }
    wh = normalize(wh);
    float cos_theta_d = dot(wi, wh);
    float Fss90 = cos_theta_d * cos_theta_d * roughness;
    float Fo = SchlickWeight(AbsCosTheta(wo));
    float Fi = SchlickWeight(AbsCosTheta(wi));
    float Fss = lerp(1.0, Fss90, Fo) * lerp(1.0, Fss90, Fi);
    float ss = 1.25f * (Fss * (1 / (AbsCosTheta(wo) + AbsCosTheta(wi)) - 0.5) + 0.5f);

    return base_color * InvPI * ss;
}

// Retro
float3 DisneyRetro(float3 base_color, float roughness, float3 wo, float3 wi)
{
    float3 wh = wi + wo;
    if (IsBlack(wh))
    {
        return 0.f;
    }
    wh = normalize(wh);
    float cos_theta_d = dot(wi, wh);
    float Fo = SchlickWeight(AbsCosTheta(wo));
    float Fi = SchlickWeight(AbsCosTheta(wi));
    float Rr = 2 * roughness * cos_theta_d * cos_theta_d;

    return base_color * InvPI * Rr * (Fo + Fi + Fo * Fi * (Rr - 1));
}

// Sheen
float3 DisneySheen(float3 base_color, float lum, float sheen_tint, float3 wo, float3 wi)
{
    float3 wh = wi + wo;
    if (IsBlack(wh))
    {
        return 0.f;
    }
    wh = normalize(wh);
    float cos_theta_d = dot(wi, wh);

    float3 c_tint = lum > 0 ? base_color / lum : 1;
    float3 c_sheen = (1 - sheen_tint) + sheen_tint * c_tint;

    return c_sheen * SchlickWeight(cos_theta_d);
}

float GTR1(float cos_theta, float alpha)
{
    float alpha2 = alpha * alpha;
    return (alpha2 - 1) / (PI * log(alpha2) * (1 + (alpha2 - 1) * cos_theta * cos_theta));
}

float SmithG_GGX(float cos_theta, float alpha)
{
    float alpha2 = alpha * alpha;
    float cos_theta_2 = cos_theta * cos_theta;
    return 1 / (cos_theta + sqrt(alpha2 + cos_theta_2 - alpha2 * cos_theta_2));
}

// Clearcoat
float3 DisneyClearcoat(float gloss, float3 wo, float3 wi)
{
    float3 wh = wi + wo;
    if (IsBlack(wh))
    {
        return 0.f;
    }
    wh = normalize(wh);
    float cos_theta_i = AbsCosTheta(wi);
    float cos_theta_o = AbsCosTheta(wo);
    float Dcc = GTR1(AbsCosTheta(wh), lerp(0.1f, 0.001f, gloss));
    float Fcc = FrSchlick(0.04, dot(wo, wh));
    float Gcc = SmithG_GGX(AbsCosTheta(wo), 0.25) * SmithG_GGX(AbsCosTheta(wi), 0.25);

    return Fcc * Dcc * Gcc / (4 * cos_theta_i * cos_theta_o);
}

float DisneyClearcoatPdf(float gloss, float3 wo, float3 wi)
{
    float3 wh = wi + wo;
    if (IsBlack(wh))
    {
        return 0.f;
    }
    wh = normalize(wh);
    float Dr = GTR1(AbsCosTheta(wh), lerp(0.1f, 0.001f, gloss));
    return Dr * AbsCosTheta(wh) / (4 * dot(wo, wh));
}

float3 DisneyClearcoatSample(float gloss, float3 wo, float2 u)
{
    if (wo.z == 0)
    {
        return 0.f;
    }

    float alpha2 = gloss * gloss;
    float cos_theta = sqrt(max(0, (1 - pow(alpha2, 1 - u.x)) / (1 - alpha2)));
    float sin_theta = sqrt(max(0, 1 - cos_theta * cos_theta));
    float phi = 2 * PI * u.y;
    float3 wh = SphericalDirection(sin_theta, cos_theta, phi);
    if (!SameHemisphere(wo, wh))
    {
        wh = -wh;
    }

    float3 wi = Reflect(wo, wh);

    return wi;
}

struct DisneyBSDF
{
    float3 base_color;
    float roughness;
    float anisotropic;
    float spec_trans;
    float eta;
    float sheen;
    float sheen_tint;
    float specular;
    float spec_tint;
    float metallic;
    float clearcoat;
    float clearcoat_gloss;
    float subsurface;
    float3 emissive;
    bool twoside;
    float2 alpha;

    void Init(
        float3 base_color_,
        float roughness_,
        float anisotropic_,
        float spec_trans_,
        float eta_,
        float sheen_,
        float sheen_tint_,
        float specular_,
        float spec_tint_,
        float metallic_,
        float clearcoat_,
        float clearcoat_gloss_,
        float subsurface_,
        float3 emissive_,
        bool twoside_)
    {
        base_color = base_color_;
        roughness = roughness_;
        anisotropic = anisotropic_;
        spec_trans = spec_trans_;
        eta = eta_;
        sheen = sheen_;
        sheen_tint = sheen_tint_;
        specular = specular_;
        spec_tint = spec_tint_;
        metallic = metallic_;
        clearcoat = clearcoat_;
        clearcoat_gloss = clearcoat_gloss_;
        subsurface = subsurface_;
        emissive = emissive_;
        twoside = twoside_;
    }

    uint Flags()
    {
        return BSDF_Diffuse | BSDF_Glossy | BSDF_Specular | BSDF_Reflection | BSDF_Transmission;
    }

    float3 Eval(float3 wo, float3 wi, TransportMode mode)
    {
        float3 f = 0.f;

        float cos_theta_i = CosTheta(wi);
        float cos_theta_o = CosTheta(wo);

        float brdf = (1.f - metallic) * (1.f - spec_trans);
        float bsdf = (1.f - metallic) * spec_trans;

        bool has_reflect = (cos_theta_i * cos_theta_o > 0.f);
        bool has_refract = (cos_theta_i * cos_theta_o < 0.f);

        float etap = 1;
        if (has_refract)
        {
            etap = cos_theta_o > 0.f ? eta : (1 / eta);
        }

        float3 wm = wi * etap + wo;

        if (cos_theta_i == 0 || cos_theta_o == 0 || LengthSquared(wm) == 0)
        {
            return 0.f;
        }

        wm = FaceForward(normalize(wm), float3(0, 0, 1));

        bool front_side = cos_theta_o > 0.f || twoside;

        float F_dielectric = FresnelDielectric(CosTheta(wo), eta);

        bool has_sheen = (sheen > 0.f) && has_reflect && (1.f - metallic > 0.f) && front_side;
        bool has_diffuse = (brdf > 0.f) && has_reflect && front_side;
        bool has_spec_reflect = has_reflect && (F_dielectric > 0.f);
        bool has_clearcoat = has_reflect && (clearcoat > 0.f) && front_side;
        bool has_spec_trans = (bsdf > 0.f) && has_refract && (F_dielectric < 1.f);

        float roughness2 = Sqr(roughness);
        alpha = max(0.001, roughness2);
        if (anisotropic > 0)
        {
            float aspect = sqrt(1.f - 0.9f * anisotropic);
            alpha.x = max(0.001, roughness2 / aspect);
            alpha.y = max(0.001, roughness2 * aspect);
        }
        TrowbridgeReitzDistribution spec_dist;
        spec_dist.alpha_x = alpha.x;
        spec_dist.alpha_y = alpha.y;
        spec_dist.sample_visible_area = true;

        float D = spec_dist.D(wm);
        float G = spec_dist.G1(wo) * spec_dist.G1(wi);
        float lum = Luminance(base_color);

        if (has_diffuse)
        {
            float3 f_diff = DisneyDiffuse(base_color, wo, wi);
            float3 f_retro = DisneyRetro(base_color, roughness, wo, wi);

            if (subsurface > 0)
            {
                float3 f_ss = DisneyFakeSS(base_color, roughness, wo, wi);
                f += brdf * lerp(f_diff + f_retro, f_ss, subsurface);
            }
            else
            {
                f += brdf * f_diff + f_retro;
            }
        }

        if (has_sheen)
        {
            f += sheen * (1.f - metallic) * DisneySheen(base_color, lum, sheen_tint, wo, wi);
        }

        if (has_clearcoat)
        {
            f += 0.25 * clearcoat * DisneyClearcoat(clearcoat_gloss, wo, wi);
        }

        if (has_spec_reflect)
        {
            float3 F_schlick = 0.f;
            if (metallic > 0)
            {
                F_schlick += metallic * FrSchlick(base_color, cos_theta_o);
            }
            if (spec_tint > 0)
            {
                float3 c_tint = lum > 0.f ? base_color / lum : 1.f;
                float3 F0_spec_tint = c_tint * SchlickR0FromEta(etap);
            }
            float3 F = front_side ?
                base_color * (1.f - metallic) * (1.f - spec_tint) * F_dielectric + F_schlick :
                bsdf * F_dielectric;
            f += F * D * G / abs(4.f * cos_theta_i * cos_theta_o);
        }

        if (has_spec_trans)
        {
            float denom = Sqr(dot(wi, wm) + dot(wo, wm) / etap) * cos_theta_i * cos_theta_o;
            float3 ft = sqrt(base_color) * bsdf * D * (1.f - F_dielectric) * G * abs(dot(wi, wm) * dot(wo, wm) / denom);
            if (mode == TransportMode_Radiance)
            {
                ft /= Sqr(etap);
            }
            f += ft;
        }

        return f;
    }

    float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags)
    {
        float cos_theta_i = CosTheta(wi);
        float cos_theta_o = CosTheta(wo);

        float brdf = (1.f - metallic) * (1.f - spec_trans);
        float bsdf = (1.f - metallic) * spec_trans;

        bool has_reflect = (cos_theta_i * cos_theta_o > 0.f);
        bool has_refract = (cos_theta_i * cos_theta_o < 0.f);

        float etap = 1;
        if (has_refract)
        {
            etap = cos_theta_o > 0.f ? eta : (1 / eta);
        }

        float3 wm = wi * etap + wo;

        if (cos_theta_i == 0 || cos_theta_o == 0 || LengthSquared(wm) == 0)
        {
            return 0.f;
        }

        wm = FaceForward(normalize(wm), float3(0, 0, 1));

        bool front_side = cos_theta_o > 0.f || twoside;

        float F_dielectric = FresnelDielectric(CosTheta(wo), eta);

        bool has_sheen = (sheen > 0.f) && has_reflect && (1.f - metallic > 0.f) && front_side;
        bool has_diffuse = (brdf > 0.f) && has_reflect && front_side;
        bool has_spec_reflect = has_reflect && (F_dielectric > 0.f);
        bool has_clearcoat = has_reflect && (clearcoat > 0.f) && front_side;
        bool has_spec_trans = (bsdf > 0.f) && has_refract && (F_dielectric < 1.f);

        float prob_spec_reflect = front_side ? 1.f - bsdf * (1.f - F_dielectric) : F_dielectric;
        float prob_spec_trans = has_spec_trans ? (front_side ? bsdf * (1.f - F_dielectric) : 1.f - F_dielectric) : 0.f;
        float prob_clearcoat = has_clearcoat ? (front_side ? 0.25f * clearcoat : 0.f) : 0.f;
        float prob_diffuse = front_side ? brdf : 0.f;
        float rcp_tot_prob = rcp(prob_spec_reflect + prob_spec_trans + prob_clearcoat + prob_diffuse);
        
        prob_spec_reflect *= rcp_tot_prob;
        prob_spec_trans *= rcp_tot_prob;
        prob_clearcoat *= rcp_tot_prob;
        prob_diffuse *= rcp_tot_prob;

        float roughness2 = Sqr(roughness);
        float2 alpha = max(0.001, roughness2);
        if (anisotropic > 0)
        {
            float aspect = sqrt(1.f - 0.9f * anisotropic);
            alpha.x = max(0.001, roughness2 / aspect);
            alpha.y = max(0.001, roughness2 * aspect);
        }
        TrowbridgeReitzDistribution spec_dist;
        spec_dist.alpha_x = alpha.x;
        spec_dist.alpha_y = alpha.y;
        spec_dist.sample_visible_area = true;

        float pdf = 0.f;

        if (has_diffuse)
        {
            pdf += prob_diffuse * AbsCosTheta(wi) * InvPI;
        }

        if (has_clearcoat)
        {
            pdf += prob_clearcoat * DisneyClearcoatPdf(clearcoat_gloss, wo, wi);
        }

        if (has_spec_reflect)
        {
            pdf += prob_spec_reflect * spec_dist.Pdf(wo, wm) / (4.0 * abs(dot(wo, wm)));
        }

        if (has_spec_trans)
        {
            float denom = Sqr(dot(wi, wm) + dot(wo, wm) / etap);
            float dwm_dwi = abs(dot(wi, wm)) / denom;
            pdf += prob_spec_trans * spec_dist.Pdf(wo, wm) * dwm_dwi;
        }
        
        return pdf;
    }

    BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample;
        bsdf_sample.Init();

        float cos_theta_o = CosTheta(wo);

        float brdf = (1.f - metallic) * (1.f - spec_trans);
        float bsdf = (1.f - metallic) * spec_trans;

        bool has_reflect = (flags & SampleFlags_Reflection);
        bool has_refract = (flags & SampleFlags_Transmission);

        bool front_side = cos_theta_o > 0.f || twoside;

        float F_dielectric = FresnelDielectric(CosTheta(wo), eta);

        bool has_sheen = (sheen > 0.f) && has_reflect && (1.f - metallic > 0.f) && front_side;
        bool has_diffuse = (brdf > 0.f) && has_reflect && front_side;
        bool has_spec_reflect = has_reflect && (F_dielectric > 0.f);
        bool has_clearcoat = has_reflect && (clearcoat > 0.f) && front_side;
        bool has_spec_trans = (bsdf > 0.f) && has_refract && (F_dielectric < 1.f);

        float prob_spec_reflect = front_side ? 1.f - bsdf * (1.f - F_dielectric) : F_dielectric;
        float prob_spec_trans = has_spec_trans ? (front_side ? bsdf * (1.f - F_dielectric) : 1.f - F_dielectric) : 0.f;
        float prob_clearcoat = has_clearcoat ? (front_side ? 0.25f * clearcoat : 0.f) : 0.f;
        float prob_diffuse = front_side ? brdf : 0.f;

        float rcp_tot_prob = rcp(prob_spec_reflect + prob_spec_trans + prob_clearcoat + prob_diffuse);
        prob_spec_reflect *= rcp_tot_prob;
        prob_spec_trans *= rcp_tot_prob;
        prob_clearcoat *= rcp_tot_prob;
        prob_diffuse *= rcp_tot_prob;

        if (uc < prob_spec_reflect)
        {
            float roughness2 = Sqr(roughness);
            float2 alpha = max(0.001, roughness2);
            if (anisotropic > 0)
            {
                float aspect = sqrt(1.f - 0.9f * anisotropic);
                alpha.x = max(0.001, roughness2 / aspect);
                alpha.y = max(0.001, roughness2 * aspect);
            }
            TrowbridgeReitzDistribution spec_dist;
            spec_dist.alpha_x = alpha.x;
            spec_dist.alpha_y = alpha.y;
            spec_dist.sample_visible_area = true;

            float3 wm = spec_dist.SampleWm(wo, u);

            // Sample specular reflection
            bsdf_sample.wi = Reflect(wo, FaceForward(wm, wo));
            bsdf_sample.flags = BSDF_GlossyReflection;
            bsdf_sample.eta = 1;
        }
        else if (uc < prob_spec_reflect + prob_spec_trans)
        {
            // Sample specular transmission
            float roughness2 = Sqr(roughness);
            float2 alpha = max(0.001, roughness2);
            if (anisotropic > 0)
            {
                float aspect = sqrt(1.f - 0.9f * anisotropic);
                alpha.x = max(0.001, roughness2 / aspect);
                alpha.y = max(0.001, roughness2 * aspect);
            }
            TrowbridgeReitzDistribution spec_dist;
            spec_dist.alpha_x = alpha.x;
            spec_dist.alpha_y = alpha.y;
            spec_dist.sample_visible_area = true;

            float3 wm = spec_dist.SampleWm(wo, u);

            float etap = 0.f;
            float3 wi;
            if (!Refract(wo, Faceforward(wm, float3(0, 0, 1)), eta, etap, wi))
            {
                return bsdf_sample;
            }
            bsdf_sample.wi = wi;
            bsdf_sample.flags = BSDF_GlossyReflection;
            bsdf_sample.eta = etap;
        }
        else if (uc < prob_spec_reflect + prob_spec_trans + prob_clearcoat)
        {
            // Sample clearcoat
            bsdf_sample.wi = DisneyClearcoatSample(clearcoat_gloss, wo, u);
            bsdf_sample.flags = BSDF_GlossyReflection;
            bsdf_sample.eta = 1;
        }
        else
        {
            // Sample diffuse
            bsdf_sample.wi = SampleCosineHemisphere(u);
            bsdf_sample.flags = BSDF_DiffuseReflection;
            bsdf_sample.eta = 1;
        }

        bsdf_sample.f = Eval(wo, bsdf_sample.wi, mode);
        bsdf_sample.pdf = PDF(wo, bsdf_sample.wi, mode, flags);

        return bsdf_sample;
    }

};

#endif

================================================
FILE: Source/Shaders/Material/BSDF/LayeredBSDF.hlsli
================================================
#ifndef LAYERED_BSDF_HLSLI
#define LAYERED_BSDF_HLSLI

#include "DiffuseBSDF.hlsli"
#include "../../Random.hlsli"

#define TopBxDF DiffuseBSDF
#define BottomBxDF DiffuseBSDF

// template<typename TopBxDF, typename BottomBxDF>
struct TopOrBottomBSDF
{
    TopBxDF top;
    BottomBxDF bottom;
    bool has_top;

    void SetTop(TopBxDF top_)
    {
        top = top_;
        has_top = true;
    }

    void SetBottom(BottomBxDF bottom_)
    {
        bottom = bottom_;
        has_top = false;
    }

    float3 Eval(float3 wo, float3 wi, TransportMode mode)
    {
        return has_top ? top.Eval(wo, wi, mode) : bottom.Eval(wo, wi, mode);
    }

    float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags)
    {
        return has_top ? top.PDF(wo, wi, mode, flags) : bottom.PDF(wo, wi, mode, flags);
    }

    BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        return has_top ? top.Samplef(wo, uc, u, mode, flags) : bottom.Samplef(wo, uc, u, mode, flags);
    }
};

// template<typename TopBxDF, typename BottomBxDF>
struct LayeredBSDF
{
    TopBxDF top;
    BottomBxDF bottom;
    bool two_side;

    float thickness;
    uint max_depth;
    float3 albedo;
    float g;
    uint sample_count;

    void Init()
    {

    }

    uint Flags()
    {
        uint top_flags = top.Flags();
        uint bottom_flags = bottom.Flags();
        uint flags = BSDF_Reflection;
 
        if(IsSpecular(top_flags))
        {
            flags |= BSDF_Specular;
        }

        if(IsDiffuse(top_flags) || IsDiffuse(bottom_flags) || !IsBlack(albedo))
        {
            flags |= BSDF_Glossy;
        }

        if(IsTransmissive(top_flags) && IsTransmissive(bottom_flags))
        {
            flags |= BSDF_Transmission;
        }

        return flags;
    }

    float3 Eval(float3 wo, float3 wi, TransportMode mode)
    {
        float3 f = 0.f;
        if(two_side && wo.z < 0)
        {
            wo = -wo;
            wi = -wi;
        }

        // Entrance interface
        TopOrBottomBSDF enter_interface;
        bool entered_top = two_side || wo.z > 0;
        if(entered_top)
        {
            enter_interface.SetTop(top);
        }
        else
        {
            enter_interface.SetBottom(bottom);
        }

        // Exit interface and exit Z
        TopOrBottomBSDF exit_interface, non_exit_interface;
        if(SameHemisphere(wo, wi) ^ entered_top)
        {
            exit_interface.SetBottom(bottom);
            non_exit_interface.SetTop(top);
        }
        else
        {
            exit_interface.SetTop(top);
            non_exit_interface.SetBottom(bottom);
        }

        float exit_z = (SameHemisphere(wo, wi) ^ entered_top) ? 0 : thickness;

        // Setup RNG
        PCGSampler rng;
        rng.seed = HashCombine(Hash(wo), Hash(wi));

        for(int s = 0; s < sample_count; s++)
        {
            // Random walk
            float uc = rng.Get1D();
            BSDFSample wos = enter_interface.Samplef(wo, uc, float2(rng.Get1D(), rng.Get1D()), mode, SampleFlags_Transmission);
            if(wos.pdf == 0 || IsBlack(wos.f) || wos.wi || wos.wi.z == 0)
            {
                continue;
            }

            uc = rng.Get1D();
            BSDFSample wis = enter_interface.Samplef(wi, uc, float2(rng.Get1D(), rng.Get1D()), !mode, SampleFlags_Transmission);
            if(wis.pdf == 0 || IsBlack(wis.f) || wis.wi || wis.wi.z == 0)
            {
                continue;
            }

            float3 beta = wos.f * AbsCosTheta(wos.wi) / wos.pdf;
            float z = entered_top ? thickness : 0;
            float3 w = wos.wi;
        }

    }

    float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags)
    {

    }

    BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {

    }
};

#endif

================================================
FILE: Source/Shaders/Material/BSDF/ThinDielectricBSDF.hlsli
================================================
#ifndef THIN_DIELECTRIC_BSDF_HLSLI
#define THIN_DIELECTRIC_BSDF_HLSLI

#include "BSDF.hlsli"
#include "../Scattering.hlsli"
#include "../Fresnel.hlsli"
#include "../../Math.hlsli"
#include "../../Interaction.hlsli"

struct ThinDielectricBSDF
{
    float3 R;
    float3 T;
    float eta;

    void Init(float3 R_, float3 T_, float eta_)
    {
        R = R_;
        T = T_;
        eta = eta_;
    }

    uint Flags()
    {
        return BSDF_Reflection | BSDF_Transmission | BSDF_Specular;
    }

    float3 Eval(float3 wo, float3 wi, TransportMode mode)
    {
        return 0.f;
    }

    float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags)
    {
        return 0.f;
    }

    BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample;
        bsdf_sample.Init();

        float F = FresnelDielectric(AbsCosTheta(wo), eta);

        if(F < 1)
        {
            F += Sqr(1 - F) * F / (1 - Sqr(F));
        }

        float pr = F;
        float pt = 1 - F;

        if(!(flags & BSDF_Reflection))
        {
            pr = 0.f;
        }
        if(!(flags & BSDF_Transmission))
        {
            pt = 0.f;
        }
        if(pr == 0 && pt == 0)
        {
            return bsdf_sample;
        }

        if(uc < pr / (pr + pt))
        {
            float3 wi = float3(-wo.x, -wo.y, wo.z);
            
            bsdf_sample.f = R * F / AbsCosTheta(wi);
            bsdf_sample.wi = wi;
            bsdf_sample.pdf = pr / (pr + pt);
            bsdf_sample.flags = BSDF_SpecularReflection;
            bsdf_sample.eta = 1;

            return bsdf_sample;
        }
        else
        {
            float3 wi = -wo;

            bsdf_sample.f = T * (1 - F) / AbsCosTheta(wi);
            bsdf_sample.wi = wi;
            bsdf_sample.pdf = pt / (pr + pt);
            bsdf_sample.flags = BSDF_SpecularTransmission;
            bsdf_sample.eta = 1;

            return bsdf_sample;
        }

        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Fresnel.hlsli
================================================
#ifndef FRESNEL_HLSLI
#define FRESNEL_HLSLI

#include "../Math.hlsli"

struct FresnelOp
{
    float3 Eval(float cos_theta_i)
    {
        return 1.f;
    }
};

float FresnelDielectric(float cos_theta_i, float eta)
{
   cos_theta_i = clamp(cos_theta_i, -1, 1);
   // Potentially flip interface orientation for Fresnel equations
   if (cos_theta_i < 0)
   {
       eta = 1 / eta;
       cos_theta_i = -cos_theta_i;
   }

   // Compute $\cos\,\theta_\roman{t}$ for Fresnel equations using Snell's law
   float sin2Theta_i = 1 - Sqr(cos_theta_i);
   float sin2Theta_t = sin2Theta_i / Sqr(eta);
   if (sin2Theta_t >= 1)
   {
       return 1.f;
   }
   float cos_theta_t = sqrt(1 - sin2Theta_t);

   float r_parl = (eta * cos_theta_i - cos_theta_t) / (eta * cos_theta_i + cos_theta_t);
   float r_perp = (cos_theta_i - eta * cos_theta_t) / (cos_theta_i + eta * cos_theta_t);
   return (Sqr(r_parl) + Sqr(r_perp)) / 2;
}

// struct FresnelDielectric
// {
//     float eta_i;
//     float eta_t;
    
//     float Eval(float cos_theta_i)
//     {
//         cos_theta_i = clamp(cos_theta_i, -1.0, 1.0);

// 	    // Potentially swap indices of refraction
//         if (cos_theta_i <= 0.f)
//         {
// 		// Swap
//             float temp = eta_i;
//             eta_i = eta_t;
//             eta_t = temp;
//             cos_theta_i = abs(cos_theta_i);
//         }

//         float sin_theta_i = sqrt(max(0.0, 1.0 - cos_theta_i * cos_theta_i));
//         float sin_theta_t = eta_i / eta_t * sin_theta_i;
//         if (sin_theta_t >= 1.0)
//         {
//             return 1.f;
//         }

//         float cos_theta_t = sqrt(max(0.0, 1.0 - sin_theta_t * sin_theta_t));
//         float Rparl = ((eta_t * cos_theta_i) - (eta_i * cos_theta_t)) /
// 	              ((eta_t * cos_theta_i) + (eta_i * cos_theta_t));
//         float Rperp = ((eta_i * cos_theta_i) - (eta_t * cos_theta_t)) /
// 	              ((eta_i * cos_theta_i) + (eta_t * cos_theta_t));

//         return (Rparl * Rparl + Rperp * Rperp) * 0.5f;
//     }
// };

float3 FresnelConductor(float cos_theta_i, float3 eta, float3 k)
{
    cos_theta_i = clamp(cos_theta_i, -1.0, 1.0);

    float cos_theta_i2 = cos_theta_i * cos_theta_i;
    float sin_theta_i2 = 1.0 - cos_theta_i2;
    float3 eta2 = eta * eta;
    float3 etak2 = k * k;

    float3 t0 = eta2 - etak2 - sin_theta_i2;
    float3 a2plusb2 = sqrt(t0 * t0 + 4.0 * eta2 * etak2);
    float3 t1 = a2plusb2 + cos_theta_i2;
    float3 a = sqrt(0.5 * (a2plusb2 + t0));
    float3 t2 = 2.0 * cos_theta_i * a;
    float3 Rs = (t1 - t2) / (t1 + t2);

    float3 t3 = cos_theta_i2 * a2plusb2 + sin_theta_i2 * sin_theta_i2;
    float3 t4 = t2 * sin_theta_i2;
    float3 Rp = Rs * (t3 - t4) / (t3 + t4);

    return 0.5 * (Rp + Rs);
}

//struct FresnelConductor
//{
//    float3 eta_i;
//    float3 eta_t;
//    float3 k;
//        
//    float3 Eval(float cos_theta_i)
//    {
//        cos_theta_i = clamp(cos_theta_i, -1.0, 1.0);
//
//        float3 eta = eta_t / eta_i;
//        float3 etak = k / eta_i;
//
//        float cos_theta_i2 = cos_theta_i * cos_theta_i;
//        float sin_theta_i2 = 1.0 - cos_theta_i2;
//        float3 eta2 = eta * eta;
//        float3 etak2 = etak * etak;
//
//        float3 t0 = eta2 - etak2 - sin_theta_i2;
//        float3 a2plusb2 = sqrt(t0 * t0 + 4.0 * eta2 * etak2);
//        float3 t1 = a2plusb2 + cos_theta_i2;
//        float3 a = sqrt(0.5 * (a2plusb2 + t0));
//        float3 t2 = 2.0 * cos_theta_i * a;
//        float3 Rs = (t1 - t2) / (t1 + t2);
//
//        float3 t3 = cos_theta_i2 * a2plusb2 + sin_theta_i2 * sin_theta_i2;
//        float3 t4 = t2 * sin_theta_i2;
//        float3 Rp = Rs * (t3 - t4) / (t3 + t4);
//
//        return 0.5 * (Rp + Rs);
//    }
//};

#endif

================================================
FILE: Source/Shaders/Material/Material/ConductorMaterial.hlsli
================================================
#ifndef CONDUCTOR_MATERIAL_HLSLI
#define CONDUCTOR_MATERIAL_HLSLI

#include "../BSDF/ConductorBSDF.hlsli"
#include "../../Math.hlsli"
#include "../../Interaction.hlsli"

struct ConductorMaterial
{
    ConductorBSDF conductor;
    Frame frame;

    GBufferData GetGBufferData()
    {
        GBufferData data;
        data.albedo = conductor.R;
        data.metallic = 1.f;
        data.roughness = conductor.distribution.alpha_x;
        data.anisotropic = 0.f;
        data.normal = frame.z;
        data.emissive = 0.f;
        return data;
    }

    void Init(float3 R, float roughness, float3 eta, float3 k, float3 normal)
    {
        conductor.Init(SRGBtoLINEAR(R), roughness, eta, k);
        frame.FromZ(normal);
    }
    
    uint Flags()
    {
        return conductor.Flags();
    }

    float3 Eval(float3 woW, float3 wiW, TransportMode mode)
    {
        return conductor.Eval(frame.ToLocal(woW), frame.ToLocal(wiW), mode) * abs(dot(wiW, frame.z));
    }

    float PDF(float3 woW, float3 wiW, TransportMode mode, SampleFlags flags)
    {
        return conductor.PDF(frame.ToLocal(woW), frame.ToLocal(wiW), mode, flags);
    }

    BSDFSample Samplef(float3 woW, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample = conductor.Samplef(frame.ToLocal(woW), uc, u, mode, flags);
        bsdf_sample.wiW = frame.ToWorld(bsdf_sample.wi);
        bsdf_sample.f *= abs(dot(bsdf_sample.wiW, frame.z));
        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Material/DielectricMaterial.hlsli
================================================
#ifndef DIELECTRIC_MATERIAL_HLSLI
#define DIELECTRIC_MATERIAL_HLSLI

#include "../BSDF/DielectricBSDF.hlsli"

struct DielectricMaterial
{
    DielectricBSDF dielectric;
    Frame frame;

    GBufferData GetGBufferData()
    {
        GBufferData data;
        data.albedo = dielectric.R;
        data.metallic = 0.f;
        data.roughness = dielectric.distribution.alpha_x;
        data.anisotropic = 0.f;
        data.normal = frame.z;
        data.emissive = 0.f;
        return data;
    }

    void Init(float3 R, float3 T, float ior, float roughness, float3 normal)
    {
        dielectric.Init(SRGBtoLINEAR(R), SRGBtoLINEAR(T), ior, roughness);
        frame.FromZ(normal);
    }

    uint Flags()
    {
        return dielectric.Flags();
    }

    float3 Eval(float3 woW, float3 wiW, TransportMode mode)
    {
        return dielectric.Eval(frame.ToLocal(woW), frame.ToLocal(wiW), mode) * abs(dot(wiW, frame.z));
    }

    float PDF(float3 woW, float3 wiW, TransportMode mode, SampleFlags flags)
    {
        return dielectric.PDF(frame.ToLocal(woW), frame.ToLocal(wiW), mode, flags);
    }

    BSDFSample Samplef(float3 woW, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample = dielectric.Samplef(frame.ToLocal(woW), uc, u, mode, flags);
        bsdf_sample.wiW = frame.ToWorld(bsdf_sample.wi);
        bsdf_sample.f *= abs(dot(bsdf_sample.wiW, frame.z));
        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Material/DiffuseMaterial.hlsli
================================================
#ifndef DIFFUSE_MATERIAL_HLSLI
#define DIFFUSE_MATERIAL_HLSLI

#include "../BSDF/DiffuseBSDF.hlsli"
#include "../../Math.hlsli"
#include "../../Interaction.hlsli"

struct DiffuseMaterial
{
    DiffuseBSDF diffuse;
    Frame frame;

    GBufferData GetGBufferData()
    {
        GBufferData data;
        data.albedo = diffuse.R;
        data.metallic = 0.f;
        data.roughness = 1.f;
        data.anisotropic = 0.f;
        data.normal = frame.z;
        data.emissive = 0.f;
        return data;
    }
    
    void Init(float3 R, float3 normal)
    {
        diffuse.Init(SRGBtoLINEAR(R));
        frame.FromZ(normal);
    }
    
    uint Flags()
    {
        return diffuse.Flags();
    }

    float3 Eval(float3 woW, float3 wiW, TransportMode mode)
    {
      //  return frame.z;
        return diffuse.Eval(frame.ToLocal(woW), frame.ToLocal(wiW), mode) * abs(dot(wiW, frame.z));
    }

    float PDF(float3 woW, float3 wiW, TransportMode mode, SampleFlags flags)
    {
        return diffuse.PDF(frame.ToLocal(woW), frame.ToLocal(wiW), mode, flags);
    }

    BSDFSample Samplef(float3 woW, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample = diffuse.Samplef(frame.ToLocal(woW), uc, u, mode, flags);
        bsdf_sample.wiW = frame.ToWorld(bsdf_sample.wi);
        bsdf_sample.f *= abs(dot(bsdf_sample.wiW, frame.z));
        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Material/DisneyMaterial.hlsli
================================================
#ifndef PRINCIPLED_MATERIAL_HLSLI
#define PRINCIPLED_MATERIAL_HLSLI

#include "../BSDF/DisneyBSDF.hlsli"
#include "../Scattering.hlsli"
#include "../Fresnel.hlsli"
#include "../../Math.hlsli"
#include "../../Common.hlsli"
#include "../../Interaction.hlsli"

struct DisneyMaterial
{
    DisneyBSDF disney;
    Frame frame;

    void Init(
        float3 base_color,
        float metallic,
        float roughness,
        float anisotropic,
        float sheen,
        float sheen_tint,
        float specular,
        float spec_tint,
        float clearcoat,
        float clearcoat_gloss,
        float flatness,
        float spec_trans,
        float eta,
        float3 emissive,
        bool twoside,
        float3 normal)
    {
        frame.FromZ(normal);
        disney.Init(base_color, roughness, anisotropic, 
            spec_trans, eta, sheen, sheen_tint, specular, spec_tint, metallic, clearcoat,
            clearcoat_gloss, flatness, emissive, twoside);
    }

    GBufferData GetGBufferData()
    {
        GBufferData data;
        data.albedo = disney.base_color;
        data.metallic = disney.metallic;
        data.roughness = disney.roughness;
        data.anisotropic = disney.anisotropic;
        data.normal = frame.z;
        data.emissive = disney.emissive;
        return data;
    }

    uint Flags()
    {
        return disney.Flags();
    }

    float3 Eval(float3 woW, float3 wiW, TransportMode mode)
    {
        return disney.Eval(frame.ToLocal(woW), frame.ToLocal(wiW), mode) * abs(dot(wiW, frame.z));
    }

    float PDF(float3 woW, float3 wiW, TransportMode mode, SampleFlags flags)
    {
        return disney.PDF(frame.ToLocal(woW), frame.ToLocal(wiW), mode, flags);
    }

    BSDFSample Samplef(float3 woW, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample = disney.Samplef(frame.ToLocal(woW), uc, u, mode, flags);
        bsdf_sample.wiW = frame.ToWorld(bsdf_sample.wi);
        bsdf_sample.f *= abs(dot(bsdf_sample.wiW, frame.z));
        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Material/MaskedMaterial.hlsli
================================================
#ifndef MASK_MATERIAL_HLSLI
#define MASK_MATERIAL_HLSLI

#include "../BSDF/BSDF.hlsli"
#include "../Scattering.hlsli"
#include "../Fresnel.hlsli"
#include "../../Math.hlsli"
#include "../../Interaction.hlsli"

template<typename T>
struct MaskedMaterial
{
    T material;
    float alpha;
    float threshold;
    
    GBufferData GetGBufferData()
    {
        return material.GetGBufferData();
    }

    void Init(T material_, float alpha_, float threshold_)
    {
        material = material_;
        alpha = alpha_;
        threshold = threshold_;
    }

    uint Flags()
    {
        return threshold < alpha ? material.Flags() : BSDF_Transmission;
    }

    float3 Eval(float3 woW, float3 wiW, TransportMode mode)
    {
        return threshold < alpha ?
            material.Eval(woW, wiW, mode) :
            1.f;
    }

    float PDF(float3 woW, float3 wiW, TransportMode mode, SampleFlags flags)
    {
        return threshold < alpha ?
            material.PDF(woW, wiW, mode, flags) :
            1.f;
    }

    BSDFSample Samplef(float3 woW, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample;
        if(threshold < alpha)
        {
            bsdf_sample = material.Samplef(woW, uc, u, mode, flags);
        }
        else
        {
            float3 wi = material.frame.ToLocal(-woW);
            bsdf_sample.f = 1.f;
            bsdf_sample.wiW = -woW;
            bsdf_sample.pdf = 1.f;
            bsdf_sample.flags = BSDF_SpecularTransmission;
            bsdf_sample.eta = 1.f;
        }
        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Material/MixMaterial.hlsli
================================================
#ifndef MIX_BSDF_HLSLI
#define MIX_BSDF_HLSLI

#include "../BSDF/BSDF.hlsli"
#include "../../Math.hlsli"
#include "../../Random.hlsli"
#include "../../Interaction.hlsli"

template<typename T1, typename T2>
struct MixMaterial
{
    T1 material1;
    T2 material2;
    float weight;

    GBufferData GetGBufferData()
    {
        GBufferData data1 = material1.GetGBufferData();
        GBufferData data2 = material2.GetGBufferData();
        GBufferData data;
        data.normal = lerp(data1.normal, data2.normal, weight);
        data.albedo = lerp(data1.albedo, data2.albedo, weight);
        data.emissive = lerp(data1.emissive, data2.emissive, weight);
        data.metallic = lerp(data1.metallic, data2.metallic, weight);
        data.roughness = lerp(data1.roughness, data2.roughness, weight);
        data.anisotropic = lerp(data1.anisotropic, data2.anisotropic, weight);
        return data;

    }

    void Init(T1 material1_, T2 material2_, float weight_)
    {
        material1 = material1_;
        material2 = material2_;
        weight = weight_;
    }

    uint Flags()
    {
        return material1.Flags() | material2.Flags();
    }

    float3 Eval(float3 woW, float3 wiW, TransportMode mode)
    {
        if(weight <= 0)
        {
            return material1.Eval(woW, wiW, mode);
        }
        else if(weight >= 1)
        {
            return material2.Eval(woW, wiW, mode);
        }
        return lerp(material1.Eval(woW, wiW, mode), material2.Eval(woW, wiW, mode), weight);
        // PCGSampler rng;
        // rng.seed = HashCombine(Hash(woW), Hash(wiW));

        // if(rng.Get1D() < weight)
        // {
        //     return material1.Eval(woW, wiW, mode);
        // }
        // else
        // {
        //     return material2.Eval(woW, wiW, mode);
        // }
    }

    float PDF(float3 woW, float3 wiW, TransportMode mode, SampleFlags flags)
    {
        if(weight <= 0)
        {
            return material1.PDF(woW, wiW, mode, flags);
        }
        else if(weight >= 1)
        {
            return material2.PDF(woW, wiW, mode, flags);
        }
        return lerp(material1.PDF(woW, wiW, mode, flags), material2.PDF(woW, wiW, mode, flags), weight);

        // PCGSampler rng;
        // rng.seed = HashCombine(Hash(woW), Hash(wiW));

        // if(rng.Get1D() < weight)
        // {
        //     return material1.PDF(woW, wiW, mode, flags);
        // }
        // else
        // {
        //     return material2.PDF(woW, wiW, mode, flags);
        // }
    }

    BSDFSample Samplef(float3 woW, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        if(weight <= 0)
        {
            return material1.Samplef(woW, uc, u, mode, flags);
        }
        else if(weight >= 1)
        {
            return material2.Samplef(woW, uc, u, mode, flags);
        }

        BSDFSample bsdf_sample;
        bsdf_sample.Init();

        if(uc < weight)
        {
            bsdf_sample = material1.Samplef(woW, uc, u, mode, flags);
            bsdf_sample.pdf *= weight;
        }
        else
        {
            bsdf_sample = material2.Samplef(woW, uc, u, mode, flags);
            bsdf_sample.pdf *= 1 - weight;
        }

        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Material/ThinDielectricMaterial.hlsli
================================================
#ifndef THIN_DIELECTRIC_MATERIAL_HLSLI
#define THIN_DIELECTRIC_MATERIAL_HLSLI

#include "../BSDF/ThinDielectricBSDF.hlsli"

struct ThinDielectricMaterial
{
    ThinDielectricBSDF thin_dielectric;
    Frame frame;

    GBufferData GetGBufferData()
    {
        GBufferData data;
        data.albedo = thin_dielectric.R;
        data.metallic = 0.f;
        data.roughness = 0.f;
        data.anisotropic = 0.f;
        data.normal = frame.z;
        data.emissive = 0.f;
        return data;
    }

    void Init(float3 R, float3 T, float eta, float3 normal)
    {
        thin_dielectric.Init(SRGBtoLINEAR(R), SRGBtoLINEAR(T), eta);
        frame.FromZ(normal);
    }

    uint Flags()
    {
        return thin_dielectric.Flags();
    }

    float3 Eval(float3 woW, float3 wiW, TransportMode mode)
    {
        return thin_dielectric.Eval(frame.ToLocal(woW), frame.ToLocal(wiW), mode) * abs(dot(wiW, frame.z));
    }

    float PDF(float3 woW, float3 wiW, TransportMode mode, SampleFlags flags)
    {
        return thin_dielectric.PDF(frame.ToLocal(woW), frame.ToLocal(wiW), mode, flags);
    }

    BSDFSample Samplef(float3 woW, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample bsdf_sample = thin_dielectric.Samplef(frame.ToLocal(woW), uc, u, mode, flags);
        bsdf_sample.wiW = frame.ToWorld(bsdf_sample.wi);
        bsdf_sample.f *= abs(dot(bsdf_sample.wiW, frame.z));
        return bsdf_sample;
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Material.hlsli
================================================
#ifndef MATERIAL_HLSLI
#define MATERIAL_HLSLI

#include "BSDF/BSDF.hlsli"
#include "../Interaction.hlsli"

struct BSDF
{
    void Init()
    {
        
    }
    
    uint Flags()
    {
        return 0;
    }

    float3 Eval(float3 wo, float3 wi, TransportMode mode)
    {
        return 0;
    }

    float PDF(float3 wo, float3 wi, TransportMode mode, SampleFlags flags)
    {
        return 0;
    }

    BSDFSample Samplef(float3 wo, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        BSDFSample sample_;
        return sample_;
    }
    
    // For GBuffer generation
    GBufferData GetGBufferData()
    {
        GBufferData data;
        data.normal = 0.f;
        data.albedo = 0.f;
        data.emissive = 0.f;
        data.metallic = 0.f;
        data.roughness = 0.f;
        data.anisotropic = 0.f;
        return data;
    }
};

struct Material
{
    BSDF bsdf;
    
    void Init(SurfaceInteraction surface_interaction)
    {
        bsdf.Init();
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Scattering.hlsli
================================================
#ifndef MICROFACET_HLSLI
#define MICROFACET_HLSLI

#include "../Math.hlsli"
#include "../Interaction.hlsli"

//bool Refract(float3 wi, float3 n, float eta, out float3 wt)
//{
//    float cos_theta_i = dot(wi, n);
//    float sin_2_theta_i = max(0.0, 1.0 - cos_theta_i * cos_theta_i);
//    float sin_2_theta_t = eta * eta * sin_2_theta_i;
//
//    if (sin_2_theta_t >= 1.0)
//    {
//        return false;
//    }
//
//    float cos_theta_t = sqrt(1.0 - sin_2_theta_t);
//
//    wt = eta * (-wi) + (eta * cos_theta_i - cos_theta_t) * n;
//
//    return true;
//}

bool Refract(float3 wi, float3 n, float eta, out float etap, out float3 wt)
{
    float cos_theta_i = dot(n, wi);
    // Potentially flip interface orientation for Snell's law
    if (cos_theta_i < 0)
    {
        eta = 1 / eta;
        cos_theta_i = -cos_theta_i;
        n = -n;
    }

    // Compute $\cos\,\theta_\roman{t}$ using Snell's law
    float sin2Theta_i = max(0, 1 - Sqr(cos_theta_i));
    float sin2Theta_t = sin2Theta_i / Sqr(eta);
    // Handle total internal reflection case
    if (sin2Theta_t >= 1)
    {
        return false;
    }
    
    float cos_theta_t = sqrt(1 - sin2Theta_t);

    wt = -wi / eta + (cos_theta_i / eta - cos_theta_t) * n;
    // Provide relative IOR along ray to caller
    etap = eta;
    
    return true;
}

float3 Reflect(float3 wo, float3 n)
{
    return -wo + 2 * dot(wo, n) * n;
}

//float HenyeyGreenstein(float cos_theta, float g)
//{
//    float denom = 1 + Sqr(g) + 2 * g * cos_theta;
//    return Inv4PI * (1 - Sqr(g)) / (denom * sqrt(denom));
//}

//float FresnelDielectric(float cos_theta_i, float eta)
//{
//    cos_theta_i = clamp(cos_theta_i, -1, 1);
//    // Potentially flip interface orientation for Fresnel equations
//    if (cos_theta_i < 0)
//    {
//        eta = 1 / eta;
//        cos_theta_i = -cos_theta_i;
//    }
//
//    // Compute $\cos\,\theta_\roman{t}$ for Fresnel equations using Snell's law
//    float sin2Theta_i = 1 - Sqr(cos_theta_i);
//    float sin2Theta_t = sin2Theta_i / Sqr(eta);
//    if (sin2Theta_t >= 1)
//    {
//        return 1.f;
//    }
//    float cos_theta_t = sqrt(1 - sin2Theta_t);
//
//    float r_parl = (eta * cos_theta_i - cos_theta_t) / (eta * cos_theta_i + cos_theta_t);
//    float r_perp = (cos_theta_i - eta * cos_theta_t) / (cos_theta_i + eta * cos_theta_t);
//    return (Sqr(r_parl) + Sqr(r_perp)) / 2;
//}
//
//float FresnelComplex(float cos_theta_i, Complex eta)
//{
//    Complex cos_theta_i_ = ComplexFromReal(clamp(cos_theta_i, 0, 1));
//    // Compute complex $\cos\,\theta_\roman{t}$ for Fresnel equations using Snell's law
//    Complex sin2Theta_i = Sub(ComplexFromReal(1), Mul(cos_theta_i_, cos_theta_i_));
//    Complex sin2Theta_t = Div(sin2Theta_i, Mul(eta, eta));
//    Complex cos_theta_t = Sqrt(Sub(ComplexFromReal(1), sin2Theta_t));
//    
//    Complex r_parl = Div(Sub(Mul(eta, cos_theta_i_), cos_theta_t), Add(Mul(eta, cos_theta_i_), cos_theta_t));
//    Complex r_perp = Div(Sub(cos_theta_i_, Mul(eta, cos_theta_t)), Add(Mul(eta, cos_theta_t), cos_theta_i_));
//
//    return (Norm(r_parl) + Norm(r_perp)) / 2;
//}
//
//float3 FresnelComplex(float cos_theta_i, float3 eta, float3 k)
//{
//    float3 result;
//    result.x = FresnelComplex(cos_theta_i, CreateComplex(eta.x, k.x));
//    result.y = FresnelComplex(cos_theta_i, CreateComplex(eta.y, k.y));
//    result.z = FresnelComplex(cos_theta_i, CreateComplex(eta.z, k.z));
//    return result;
//}

//struct TrowbridgeReitzDistribution
//{
//    float alpha_x, alpha_y;
//    
//    bool EffectivelySmooth()
//    {
//        return max(alpha_x, alpha_y) < 1e-3f;
//    }
//    
//    void Init(float ax, float ay)
//    {
//        alpha_x = ax;
//        alpha_y = ay;
//        if (!EffectivelySmooth())
//        {
//            alpha_x = max(alpha_x, 1e-4f);
//            alpha_y = max(alpha_y, 1e-4f);
//        }
//    }
//    
//    float D(float3 wm)
//    {
//        float tan_2_theta = Tan2Theta(wm);
//        if (isinf(tan_2_theta))
//        {
//            return 0;
//        }
//        float cos_4_theta = Sqr(Cos2Theta(wm));
//        if (cos_4_theta < 1e-16f)
//        {
//            return 0;
//        }
//        float e = tan_2_theta * (Sqr(CosPhi(wm) / alpha_x) + Sqr(SinPhi(wm) / alpha_y));
//        return 1 / (PI * alpha_x * alpha_y * cos_4_theta * Sqr(1 + e));
//    }
//    
//    float Lambda(float3 w)
//    {
//        float tan_2_theta = Tan2Theta(w);
//        if (isinf(tan_2_theta))
//        {
//            return 0;
//        }
//        float alpha2 = Sqr(CosPhi(w) * alpha_x) + Sqr(SinPhi(w) * alpha_y);
//        return (sqrt(1 + alpha2 * tan_2_theta) - 1) / 2;
//    }
//    
//    float G1(float3 w)
//    {
//        return 1 / (1 + Lambda(w));
//    }
//    
//    float G(float3 wo, float3 wi)
//    {
//        return 1 / (1 + Lambda(wo) + Lambda(wi));
//    }
//    
//    float D(float3 w, float3 wm)
//    {
//        return G1(w) / AbsCosTheta(w) * D(wm) * abs(dot(w, wm));
//    }
//    
//    float PDF(float3 w, float3 wm)
//    {
//        return D(w, wm);
//    }
//    
//    float3 Sample_wm(float3 w, float2 u)
//    {
//        // Reference: https://jcgt.org/published/0007/04/01/paper.pdf
//        float3 vh = normalize(float3(alpha_x * w.x, alpha_y * w.y, w.z));
//        
//        float len = vh.x * vh.x + vh.y * vh.y;
//        float3 T1 = len > 0 ? float3(-vh.y, -vh.x, 0.f) / sqrt(len) : float3(1, 0, 0);
//        float3 T2 = cross(vh, T1);
//        
//        float2 p = UniformSampleDisk(u);
//        float s = 0.5 * (1.0 + vh.z);
//        p.y = (1.0 - s) * sqrt(1.0 - p.x * p.x) + s * p.y;
//        float3 nh = p.x * T1 + p.y * T2 + sqrt(max(0, 1.0 - p.x * p.x - p.y * p.y)) * vh;
//        
//        return normalize(float3(alpha_x * nh.x, alpha_y * nh.y, max(0, nh.z)));
//    }
//    
//    float RoughnessToAlpha(float roughness)
//    {
//        return sqrt(roughness);
//    }
//    
//    void Regularize()
//    {
//        if (alpha_x < 0.3f)
//        {
//            alpha_x = clamp(2 * alpha_x, 0.1f, 0.3f);
//        }
//        if (alpha_y < 0.3f)
//        {
//            alpha_y = clamp(2 * alpha_y, 0.1f, 0.3f);
//        }
//    }
//};

// Beckmann Distribution
void BeckmannSample11(float cos_theta_i, float u1, float u2, out float slope_x, out float slope_y)
{
    if (cos_theta_i > .9999)
    {
        float r = sqrt(-log(1.0 - u1));
        float sin_phi = sin(2 * PI * u2);
        float cos_phi = cos(2 * PI * u2);
        slope_x = r * cos_phi;
        slope_y = r * sin_phi;
        return;
    }

    float sin_theta_i = sqrt(max(0.0, 1.0 - cos_theta_i * cos_theta_i));
    float tan_theta_i = sin_theta_i / cos_theta_i;
    float cot_theta_i = 1.0 / tan_theta_i;

    float a = -1.0;
    float c = Erf(cot_theta_i);
    float sample_x = max(u1, float(1e-6));

    float theta_i = acos(cos_theta_i);
    float fit = 1 + theta_i * (-0.876 + theta_i * (0.4265 - 0.0594 * theta_i));
    float b = c - (1 + c) * pow(1 - sample_x, fit);

    const float sqrt_inv_PI = 1.0 / sqrt(PI);
    float normalization = 1.0 / (1.0 + c + sqrt_inv_PI * tan_theta_i * exp(-cot_theta_i * cot_theta_i));

    int it = 0;
    while (++it < 10)
    {
        if (!(b >= a && b <= c))
        {
            b = 0.5 * (a + c);
        }

        float inv_erf = ErfInv(b);
        float value = normalization * (1 + b + sqrt_inv_PI * tan_theta_i * exp(-inv_erf * inv_erf)) - sample_x;
        float derivative = normalization * (1 - inv_erf * tan_theta_i);

        if (abs(value) < 1e-5)
        {
            break;
        }

        if (value > 0)
        {
            c = b;
        }
        else
        {
            a = b;
        }

        b -= value / derivative;
    }

    slope_x = ErfInv(b);
    slope_y = ErfInv(2.0 * max(u2, float(1e-6)) - 1.0);
}

float3 BeckmannSample(float3 wi, float alpha_x, float alpha_y, float u1, float u2)
{
	// stretch wi
    float3 wiStretched = normalize(float3(alpha_x * wi.x, alpha_y * wi.y, wi.z));

	// simulate P22_{wi}(x_slope, y_slope, 1, 1)
    float slope_x, slope_y;
    BeckmannSample11(CosTheta(wiStretched), u1, u2, slope_x, slope_y);

	// rotate
    float tmp = CosPhi(wiStretched) * slope_x - SinPhi(wiStretched) * slope_y;
    slope_y = SinPhi(wiStretched) * slope_x + CosPhi(wiStretched) * slope_y;
    slope_x = tmp;

	// unstretch
    slope_x = alpha_x * slope_x;
    slope_y = alpha_y * slope_y;

	// compute normal
    return normalize(float3(-slope_x, -slope_y, 1.0));
}

struct BeckmannDistribution
{
    float alpha_x;
    float alpha_y;
    bool sample_visible_area;

    bool EffectivelySmooth() 
    { 
        return max(alpha_x, alpha_y) < 1e-3f; 
    }
    
    float D(float3 wm)
    {
        float tan_2_theta = Tan2Theta(wm);
        if (isinf(tan_2_theta))
        {
            return 0.0;
        }

        float cos_4_theta = Cos2Theta(wm) * Cos2Theta(wm);
        return exp(-tan_2_theta * (Cos2Phi(wm) / (alpha_x * alpha_x) + Sin2Phi(wm) / (alpha_y * alpha_y))) / (PI * alpha_x * alpha_y * cos_4_theta);
    }
    
    float Lambda(float3 w)
    {
        float abs_tan_theta = abs(TanTheta(w));
        if (isinf(abs_tan_theta))
        {
            return 0.;
        }

        float alpha = sqrt(Cos2Phi(w) * alpha_x * alpha_x + Sin2Phi(w) * alpha_y * alpha_y);
        float a = 1.0 / (alpha * abs_tan_theta);
        if (a >= 1.6)
        {
            return 0;
        }
        return (1.0 - 1.259 * a + 0.396 * a * a) / (3.535 * a + 2.181 * a * a);
    }
    
    float G1(float3 w)
    {
        return 1.0 / (1.0 + Lambda(w));
    }

    float G(float3 wo, float3 wi)
    {
        return 1.0 / (1.0 + Lambda(wo) + Lambda(wi));
    }
    
    float Pdf(float3 wo, float3 wm)
    {
        if (sample_visible_area)
        {
            return D(wm) * G1(wo) * abs(dot(wo, wm)) / AbsCosTheta(wo);
        }
        else
        {
            return D(wm) * AbsCosTheta(wm);
        }
    }
    
    float3 SampleWm(float3 wo, float2 u)
    {
        if (!sample_visible_area)
        {
            float tan_2_theta, phi;
            if (alpha_x == alpha_y)
            {
                float log_sample = log(1 - u.x);
                tan_2_theta = -alpha_x * alpha_x * log_sample;
                phi = u.y * 2 * PI;
            }
            else
            {
                float log_sample = log(1 - u.x);
                phi = atan(alpha_y / alpha_x * tan(2.0 * PI * u.y + 0.5 * PI));
                if (u.y > 0.5)
                {
                    phi += PI;
                }

                float sin_phi = sin(phi);
                float cos_phi = cos(phi);
                float alphax2 = alpha_x * alpha_x;
                float alphay2 = alpha_y * alpha_y;
                tan_2_theta = -log_sample / (cos_phi * cos_phi / alphax2 + sin_phi * sin_phi / alphay2);
            }

            float cos_theta = 1.0 / sqrt(1.0 + tan_2_theta);
            float sin_theta = sqrt(max(0.0, 1.0 - cos_theta * cos_theta));
            float3 wm = SphericalDirection(sin_theta, cos_theta, phi);
            if (!SameHemisphere(wo, wm))
            {
                wm = -wm;
            }
            return wm;
        }
        else
        {
            float3 wm;
            bool flip = wo.z < 0.0;
            wm = BeckmannSample(flip ? -wo : wo, alpha_x, alpha_y, u.x, u.y);
            if (flip)
            {
                wm = -wm;
            }

            return wm;
        }

        return float3(0.0, 0.0, 0.0);
    }
};

// Trowbridge Reitz Distribution
void TrowbridgeReitzSample11(float cos_theta, float u1, float u2, out float slope_x, out float slope_y)
{
    if (cos_theta > .9999)
    {
        float r = sqrt(u1 / (1 - u1));
        float phi = 6.28318530718 * u2;
        slope_x = r * cos(phi);
        slope_y = r * sin(phi);
        return;
    }

    float sin_theta = sqrt(max(0.0, 1.0 - cos_theta * cos_theta));
    float tan_theta = sin_theta / cos_theta;
    float a = 1.0 / tan_theta;
    float G1 = 2.0 / (1.0 + sqrt(1.0 + 1.0 / (a * a)));

    float A = 2 * u1 / G1 - 1;
    float tmp = 1.f / (A * A - 1.f);
    if (tmp > 1e10)
    {
        tmp = 1e10;
    }
    float B = tan_theta;
    float D = sqrt(max(float(B * B * tmp * tmp - (A * A - B * B) * tmp), float(0)));
    float slope_x_1 = B * tmp - D;
    float slope_x_2 = B * tmp + D;
    slope_x = (A < 0 || slope_x_2 > 1.f / tan_theta) ? slope_x_1 : slope_x_2;

    float S;
    if (u2 > 0.5)
    {
        S = 1.0;
        u2 = 2.0 * (u2 - 0.5);
    }
    else
    {
        S = -1.0;
        u2 = 2.0 * (0.5 - u2);
    }

    float z =
	    (u2 * (u2 * (u2 * 0.27385 - 0.73369) + 0.46341)) /
	    (u2 * (u2 * (u2 * 0.093073 + 0.309420) - 1.000000) + 0.597999);

    slope_y = S * z * sqrt(1.0 + slope_x * slope_x);
}

float3 TrowbridgeReitzSample(float3 wi, float alpha_x, float alpha_y, float u1, float u2)
{
	// stretch wi
    float3 wiStretched = normalize(float3(alpha_x * wi.x, alpha_y * wi.y, wi.z));

	// simulate P22_{wi}(x_slope, y_slope, 1, 1)
    float slope_x, slope_y;
    TrowbridgeReitzSample11(CosTheta(wiStretched), u1, u2, slope_x, slope_y);

	// rotate
    float tmp = CosPhi(wiStretched) * slope_x - SinPhi(wiStretched) * slope_y;
    slope_y = SinPhi(wiStretched) * slope_x + CosPhi(wiStretched) * slope_y;
    slope_x = tmp;

	// unstretch
    slope_x = alpha_x * slope_x;
    slope_y = alpha_y * slope_y;

	// compute normal
    return normalize(float3(-slope_x, -slope_y, 1.0));
}

struct TrowbridgeReitzDistribution
{
    float alpha_x;
    float alpha_y;
    bool sample_visible_area;

    bool EffectivelySmooth() 
    { 
        return max(alpha_x, alpha_y) < 1e-3f; 
    }
    
    static float RoughnessToAlpha(float roughness)
    {
        if(roughness <= float(1e-3))
        {
            return roughness;
        }
        roughness = max(roughness, (float) 1e-3);
        float x = log(roughness);
        return 1.62142f + 0.819955f * x + 0.1734f * x * x + 0.0171201f * x * x * x +
           0.000640711f * x * x * x * x;
    }
    
    float D(float3 wm)
    {
        float tan_2_theta = Tan2Theta(wm);

        if (isinf(tan_2_theta))
        {
            return 0.0;
        }
        const float cos_4_theta = Cos2Theta(wm) * Cos2Theta(wm);

        float e = (Cos2Phi(wm) / (alpha_x * alpha_x) + Sin2Phi(wm) / (alpha_y * alpha_y)) * tan_2_theta;
        return 1 / (PI * alpha_x * alpha_y * cos_4_theta * (1 + e) * (1 + e));
    }
    
    float3 SampleWm(float3 wo, float2 u)
    {
        float3 wm = 0.f;

        if (!sample_visible_area)
        {
            float cos_theta = 0.0;
            float phi = 2.0 * PI * u.y;

            if (alpha_x == alpha_y)
            {
                float tan_theta_2 = alpha_x * alpha_x * u.x * (1.0 - u.x);
                cos_theta = 1.0 / sqrt(1.0 + tan_theta_2);
            }
            else
            {
                phi = atan(alpha_y / alpha_x * tan(2.0 * PI * u.y + 0.5 * PI));
                if (u.y > 0.5)
                {
                    phi += PI;
                }
                float sin_phi = sin(phi);
                float cos_phi = cos(phi);

                const float alpha_x2 = alpha_x * alpha_x;
                const float alpha_y2 = alpha_y * alpha_y;

                const float alpha_2 = 1.0 / (cos_phi * cos_phi / alpha_x2 + sin_phi * sin_phi / alpha_y2);
                float tan_theta_2 = alpha_2 * u.x / (1.0 - u.x);
                cos_theta = 1.0 / sqrt(1 + tan_theta_2);
            }

            float sin_theta = sqrt(max(0.0, 1.0 - cos_theta * cos_theta));
            float3 wm = SphericalDirection(sin_theta, cos_theta, phi);
            if (!SameHemisphere(wo, wm))
            {
                wm = -wm;
            }
        }
        else
        {
            bool flip = wo.z < 0.0;
            wm = TrowbridgeReitzSample(flip ? -wo : wo, alpha_x, alpha_y, u.x, u.y);
            if (flip)
            {
                wm = -wm;
            }
        }
        return wm;
    }

    float Lambda(float3 w)
    {
        float abs_tan_theta = abs(TanTheta(w));
        if (isinf(abs_tan_theta))
        {
            return 0.;
        }
        float alpha = sqrt(Cos2Phi(w) * alpha_x * alpha_x + Sin2Phi(w) * alpha_y * alpha_y);
        float alpha_2_tan_2_theta = (alpha * abs_tan_theta) * (alpha * abs_tan_theta);
        return (-1.0 + sqrt(1.0 + alpha_2_tan_2_theta)) / 2.0;
    }

    float G1(float3 w)
    {
        return 1.0 / (1.0 + Lambda(w));
    }

    float G(float3 wo, float3 wi)
    {
        return 1.0 / (1.0 + Lambda(wo) + Lambda(wi));
    }

    float Pdf(float3 wo, float3 wm)
    {
        if (sample_visible_area)
        {
            return D(wm) * G1(wo) * abs(dot(wo, wm)) / AbsCosTheta(wo);
        }
        else
        {
            return D(wm) * AbsCosTheta(wm);
        }
    }
};

struct DisneyMicrofacetDistribution
{
    float alpha_x;
    float alpha_y;
    bool sample_visible_area;

    bool EffectivelySmooth() 
    { 
        return max(alpha_x, alpha_y) < 1e-3f; 
    }
    
    float D(float3 wh)
    {
        float tan_2_theta = Tan2Theta(wh);

        if (isinf(tan_2_theta))
        {
            return 0.0;
        }
        const float cos_4_theta = Cos2Theta(wh) * Cos2Theta(wh);

        float e = (Cos2Phi(wh) / (alpha_x * alpha_x) + Sin2Phi(wh) / (alpha_y * alpha_y)) * tan_2_theta;
        return 1 / (PI * alpha_x * alpha_y * cos_4_theta * (1 + e) * (1 + e));
    }
    
    float3 SampleWh(float3 wo, float2 u)
    {
        float3 wh = float3(0.0, 0.0, 0.0);
        
        if (!sample_visible_area)
        {
            float cos_theta = 0.0;
            float phi = 2.0 * PI * u.y;

            if (alpha_x == alpha_y)
            {
                float tan_theta_2 = alpha_x * alpha_x * u.x * (1.0 - u.y);
                cos_theta = 1.0 / sqrt(1.0 + tan_theta_2);
            }
            else
            {
                phi = atan(alpha_y / alpha_x * tan(2.0 * PI * u.y + 0.5 * PI));
                if (u.y > 0.5)
                {
                    phi += PI;
                }
                float sin_phi = sin(phi);
                float cos_phi = cos(phi);

                const float alpha_x2 = alpha_x * alpha_x;
                const float alpha_y2 = alpha_y * alpha_y;

                const float alpha_2 = 1.0 / (cos_phi * cos_phi / alpha_x2 + sin_phi * sin_phi / alpha_y2);
                float tan_theta_2 = alpha_2 * u.x / (1.0 - u.x);
                cos_theta = 1.0 / sqrt(1 + tan_theta_2);
            }

            float sin_theta = sqrt(max(0.0, 1.0 - cos_theta * cos_theta));
            float3 wh = SphericalDirection(sin_theta, cos_theta, phi);
            if (!SameHemisphere(wo, wh))
            {
                wh = -wh;
            }
        }
        else
        {
            bool flip = wo.z < 0.0;
            wh = TrowbridgeReitzSample(flip ? -wo : wo, alpha_x, alpha_y, u.x, u.y);
            if (flip)
            {
                wh = -wh;
            }
        }
        return wh;
    }

    float Lambda(float3 w)
    {
        float abs_tan_theta = abs(TanTheta(w));
        if (isinf(abs_tan_theta))
        {
            return 0.;
        }
        float alpha = sqrt(Cos2Phi(w) * alpha_x * alpha_x + Sin2Phi(w) * alpha_y * alpha_y);
        float alpha_2_tan_2_theta = (alpha * abs_tan_theta) * (alpha * abs_tan_theta);
        return (-1.0 + sqrt(1.0 + alpha_2_tan_2_theta)) / 2.0;
    }

    float G1(float3 w)
    {
        return 1.0 / (1.0 + Lambda(w));
    }

    float G(float3 wo, float3 wi)
    {
        return G1(wo) * G1(wi);
    }

    float Pdf(float3 wo, float3 wh)
    {
        if (sample_visible_area)
        {
            return D(wh) * G1(wo) * abs(dot(wo, wh)) / AbsCosTheta(wo);
        }
        else
        {
            return D(wh) * AbsCosTheta(wh);
        }
    }
};

#endif

================================================
FILE: Source/Shaders/Material/Template.material.hlsli
================================================
#ifndef MATERIAL_HLSLI
#define MATERIAL_HLSLI

#include "../Attribute.hlsli"
#include "../Random.hlsli"

#include "BSDF/BSDF.hlsli"

{{#Textures}}
Texture2D<float4> {{Texture}};
{{/Textures}}

{{#Samplers}}
SamplerState {{Sampler}};
{{/Samplers}}

struct BSDF
{
    {{&BxDFType
}} {{&BxDFName}}

void Init()
{
        {{#Initializations}}
        {{ & Initialization
                }
            }
        {{ / Initializations
                }
            }
        }

        float3 Eval
        (
        float3 wo, float3 wi, TransportMode
        mode)
    {
            return {{ & BxDFName
                }
            }.
            Eval(wo, wi, mode);
        }

        float PDF
        (
        float3 wo, float3 wi, TransportMode
        mode, SampleFlags
        flags)
    {
            return {{ & BxDFName
                }
            }.
            PDF(wo, wi, mode, flags);
        }

        BSDFSample Samplef
        (
        float3 wo, float uc, float2 u, TransportMode
        mode, SampleFlags
        flags)
    {
            return {{ & BxDFName
                }
            }.
            Samplef(wo, uc, u, mode, flags);
        }
    }

struct Material
{
    BSDF bsdf;

    void Init()
    {
        bsdf.Init();
    }
}

#endif

================================================
FILE: Source/Shaders/Material.hlsli
================================================
#ifndef MATERIAL_HLSLI
#define MATERIAL_HLSLI

#include "Attribute.hlsli"
#include "Random.hlsli"
#include "Interaction.hlsli"
#include "MaterialResource.hlsli"

#include "Material/BSDF/BSDF.hlsli"

{{#MaterialHeaders}}
{{&MaterialHeader}}
{{/MaterialHeaders}}

struct MaterialData
{
    {{#Textures}}
    uint {{Texture}};
    {{/Textures}}
    {{#Samplers}}
    uint {{Sampler}};
    {{/Samplers}}
};

struct BSDF
{
    {{&BxDFType}} {{&BxDFName}};

    void Init(SurfaceInteraction surface_interaction)
    {
        MaterialData material_data = GetMaterialData < MaterialData > (surface_interaction.material);
        {{#Initializations}}
        {{&Initialization}}
        {{/Initializations}}
    }
        
     uint Flags()
     {
        return {{&BxDFName}}.Flags();
    }

    float3 Eval(float3 woW, float3 wiW, TransportMode mode)
    {
        return {{&BxDFName}}.Eval(woW, wiW, mode);
    }

    float PDF(float3 woW, float3 wiW, TransportMode mode, SampleFlags flags)
    {
        return {{&BxDFName}}.PDF(woW, wiW, mode, flags);
    }

    BSDFSample Samplef(float3 woW, float uc, float2 u, TransportMode mode, SampleFlags flags)
    {
        return {{&BxDFName}}.Samplef(woW, uc, u, mode, flags);
    }

    GBufferData GetGBufferData()
    {
        return {{&BxDFName}}.GetGBufferData();
    }
};

struct Material
{
    BSDF bsdf;

    void Init(SurfaceInteraction surface_interaction)
    {
        bsdf.Init(surface_interaction);
    }
};

#endif

================================================
FILE: Source/Shaders/MaterialResource.hlsli
================================================
#ifndef MATERIAL_RESOURCE_HLSLI
#define MATERIAL_RESOURCE_HLSLI

#include "Interaction.hlsli"

Texture2D<float4> Textures[] : register(s996);
SamplerState Samplers[] : register(s997);
StructuredBuffer<uint> MaterialOffsets : register(t998);
ByteAddressBuffer MaterialBuffer : register(t999);

float4 SampleTexture2D(uint texture_id, uint sampler_id, float2 uv, float2 duvdx, float2 duvdy)
{
    if (texture_id == ~0U)
    {
        return 0.f;
    }
    
#ifdef RASTERIZATION_PIPELINE
    return Textures[texture_id].Sample(Samplers[sampler_id], uv);
#else
    return Textures[texture_id].SampleGrad(Samplers[sampler_id], uv, duvdx, duvdy);
#endif
}

template<typename T>
T GetMaterialData(uint material_id)
{
    if (material_id == ~0U)
    {
        T data;
        return data;
    }
    return MaterialBuffer.Load<T>(MaterialOffsets[material_id]);
}

float3 ExtractNormalMap(SurfaceInteraction interaction, float3 normal_vector)
{
    float3 T, B;
    Frame frame;
    if(IsBlack(interaction.isect.nt))
    {
        frame.FromZ(interaction.isect.n);
    }
    else
    {
        frame.FromXZ(interaction.isect.nt, interaction.isect.n);
    }
    normal_vector = normal_vector * 2.0 - 1.0;
    normal_vector = normalize(normal_vector);
    return normalize(frame.ToWorld(normal_vector));
    
    
    //Frame frame;
    //frame.FromZ(interaction.isect.n);
    //float3x3 TBN = float3x3(frame.x, frame.y, frame.z);
    //normal_vector = normalize(normal_vector * 2.0 - 1.0);
    //float3 normal = normalize(mul(normal_vector, TBN));
    //interaction.isect.n = dot(interaction.isect.n, normal) <= 0.0 ? normal : -normal;
}

#endif

================================================
FILE: Source/Shaders/Math.hlsli
================================================
#ifndef MATH_HLSLI
#define MATH_HLSLI

#include "Complex.hlsli"

static const float PI = 3.14159265358979323846f;
static const float InvPI = 0.31830988618379067154f;
static const float Inv2PI = 0.15915494309189533577f;
static const float Inv4PI = 0.07957747154594766788f;
static const float PIOver2 = 1.57079632679489661923f;
static const float PIOver4 = 0.78539816339744830961f;
static const float Sqrt2 = 1.41421356237309504880f;

static const float ShadowEpsilon = 0.0001f;

static const float Infinity = 1e32;

void CoordinateSystem(float3 v1, out float3 v2, out float3 v3)
{
    const float3 ref = abs(dot(v1, float3(0, 1, 0))) > 0.99f ? float3(0, 0, 1) : float3(0, 1, 0);
    v2 = normalize(cross(ref, v1));
    v3 = cross(v1, v2);
    //float sign = v1.z / abs(v1.z);
    //float a = -1 / (sign + v1.z);
    //float b = v1.x * v1.y * a;
    //v2 = float3(1 + sign * v1.x * v1.x * a, sign * b, -sign * v1.x);
    //v3 = float3(b, sign + v1.y * v1.y * a, -v1.y);
}

float Sqr(float x)
{
    return x * x;
}

float LengthSquared(float2 x)
{
    return Sqr(x.x) + Sqr(x.y);
}

float LengthSquared(float3 x)
{
    return Sqr(x.x) + Sqr(x.y) + Sqr(x.z);
}

float DistanceSquared(float3 v1, float3 v2)
{
    float3 v = v1 - v2;
    return dot(v, v);
}

float3 FaceForward(float3 v1, float3 v2)
{
    return dot(v1, v2) > 0 ? v1 : -v1;
}

// Sampling Disk
// Polar Mapping
float2 UniformSampleDisk(float2 u)
{
    float r = sqrt(u.x);
    float theta = 2 * PI * u.y;
    return r * float2(cos(theta), sin(theta));
}

// Concentric Mapping
float2 SampleConcentricDisk(float2 u)
{
    float2 uOffset = 2.0 * u - 1.0;

    if (uOffset.x == 0 && uOffset.y == 0)
    {
        return float2(0.0, 0.0);
    }

    float theta, r;
    if (abs(uOffset.x) > abs(uOffset.y))
    {
        r = uOffset.x;
        theta = PIOver4 * (uOffset.y / uOffset.x);
    }
    else
    {
        r = uOffset.y;
        theta = PIOver2 - PIOver4 * (uOffset.x / uOffset.y);
    }

    return r * float2(cos(theta), sin(theta));
}

// Sampling Hemisphere
float3 UniformSampleHemisphere(float2 u)
{
    float z = u.x;
    float r = sqrt(max(0.0, 1.0 - z * z));
    float phi = 2 * PI * u.y;
    return float3(r * cos(phi), r * sin(phi), z);
}

float3 UniformSampleSphere(float2 u)
{
    float z = 1.0 - 2.0 * u.x;
    float r = sqrt(max(0.0, 1.0 - z * z));
    float phi = 2 * PI * u.y;
    return float3(r * cos(phi), r * sin(phi), z);
}

float UniformHemispherePdf()
{
    return Inv2PI;
}

float UniformSpherePdf()
{
    return Inv4PI;
}

float3 SampleCosineHemisphere(float2 u)
{
    float2 d = SampleConcentricDisk(u);
    float z = sqrt(max(0, 1 - d.x * d.x - d.y * d.y));
    return float3(d.x, d.y, z);
}

float CosineHemispherePdf(float cosTheta)
{
    return cosTheta * InvPI;
}

// Multiple Importance Sampling
float BalanceHeuristic(int nf, float fPdf, int ng, float gPdf)
{
    return (nf * fPdf) / (nf * fPdf + ng * gPdf);
}

float PowerHeuristic(int nf, float fPdf, int ng, float gPdf)
{
    float f = nf * fPdf;
    float g = ng * gPdf;
    return (f * f) / (f * f + g * g);
}

float SphericalPhi(float3 v)
{
    float p = atan2(v.y, v.x);
    return p < 0 ? (p + 2 * PI) : p;
}

float SphericalTheta(float3 v)
{
    return acos(clamp(v.z, -1.0, 1.0));
}

float ErfInv(float x)
{
    float w, p;
    x = clamp(x, -.99999, .99999);
    w = -log((1 - x) * (1 + x));
    if (w < 5)
    {
        w = w - 2.5;
        p = 2.81022636e-08;
        p = 3.43273939e-07 + p * w;
        p = -3.5233877e-06 + p * w;
        p = -4.39150654e-06 + p * w;
        p = 0.00021858087 + p * w;
        p = -0.00125372503 + p * w;
        p = -0.00417768164 + p * w;
        p = 0.246640727 + p * w;
        p = 1.50140941 + p * w;
    }
    else
    {
        w = sqrt(w) - 3;
        p = -0.000200214257;
        p = 0.000100950558 + p * w;
        p = 0.00134934322 + p * w;
        p = -0.00367342844 + p * w;
        p = 0.00573950773 + p * w;
        p = -0.0076224613 + p * w;
        p = 0.00943887047 + p * w;
        p = 1.00167406 + p * w;
        p = 2.83297682 + p * w;
    }
    return p * x;
}

float Erf(float x)
{
	// constants
    float a1 = 0.254829592f;
    float a2 = -0.284496736f;
    float a3 = 1.421413741f;
    float a4 = -1.453152027f;
    float a5 = 1.061405429f;
    float p = 0.3275911f;

	// Save the sign of x
    int sign = 1;
    if (x < 0)
    {
        sign = -1;
    }
    x = abs(x);

	// A&S formula 7.1.26
    float t = 1 / (1 + p * x);
    float y = 1 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * exp(-x * x);

    return sign * y;
}

float AbsCosTheta(float3 w)
{
    return abs(w.z);
}

float CosTheta(float3 w)
{
    return w.z;
}

float Cos2Theta(float3 w)
{
    return w.z * w.z;
}

float Sin2Theta(float3 w)
{
    return max(0.0, 1.0 - Cos2Theta(w));
}

float Tan2Theta(float3 w)
{
    return Sin2Theta(w) / Cos2Theta(w);
}

float SinTheta(float3 w)
{
    return sqrt(Sin2Theta(w));
}

float SinPhi(float3 w)
{
    float sinTheta = SinTheta(w);
    return sinTheta == 0.0 ? 0.0 : clamp(w.y / sinTheta, -1.0, 1.0);
}

float Sin2Phi(float3 w)
{
    return SinPhi(w) * SinPhi(w);
}

float CosPhi(float3 w)
{
    float sinTheta = SinTheta(w);
    return sinTheta == 0.0 ? 1.0 : clamp(w.x / sinTheta, -1.0, 1.0);
}

float Cos2Phi(float3 w)
{
    return CosPhi(w) * CosPhi(w);
}

float TanTheta(float3 w)
{
    return SinTheta(w) / CosTheta(w);
}

float3 SphericalDirection(float sinTheta, float cosTheta, float phi)
{
    return float3(sinTheta * cos(phi), sinTheta * sin(phi), cosTheta);
}

float3 Faceforward(float3 v, float3 v2)
{
    return dot(v, v2) < 0.0 ? -v : v;
}

bool SameHemisphere(float3 w, float3 wp)
{
    return w.z * wp.z > 0;
}

float Radians(float deg)
{
    return PI / 180.0 * deg;
}

float Degrees(float rad)
{
    return rad * 180.0 / PI;
}

bool IsBlack(float3 v)
{
    return v.x == 0.0 && v.y == 0.0 && v.z == 0.0;
}

/*https://www.rorydriscoll.com/2012/01/15/cubemap-texel-solid-angle/*/
float AreaIntegration(float x, float y)
{
    return atan2(sqrt(x * x + y * y + 1), x * y);
}

float CalculateSolidAngle(uint x, uint y, uint width, uint height)
{
    float u = 2.0 * (float(x) + 0.5) / float(width) - 1.0;
    float v = 2.0 * (float(y) + 0.5) / float(height) - 1.0;

    float x0 = u - 1.0 / float(width);
    float x1 = u + 1.0 / float(width);
    float y0 = v - 1.0 / float(height);
    float y1 = v + 1.0 / float(height);

    return AreaIntegration(x0, y0) - AreaIntegration(x0, y1) - AreaIntegration(x1, y0) + AreaIntegration(x1, y1);
}

float3 CalculateCubemapDirection(uint face_idx, uint face_x, uint face_y, uint width, uint height)
{
    float u = 2.0 * (float(face_x) + 0.5) / float(width) - 1.0;
    float v = 2.0 * (float(face_y) + 0.5) / float(height) - 1.0;
    float x, y, z;

    // POSITIVE_X 0
    // NEGATIVE_X 1
    // POSITIVE_Y 2
    // NEGATIVE_Y 3
    // POSITIVE_Z 4
    // NEGATIVE_Z 5
    
    switch (face_idx)
    {
        case 0:
            x = 1;
            y = -v;
            z = -u;
            break;
        case 1:
            x = -1;
            y = -v;
            z = u;
            break;
        case 2:
            x = u;
            y = 1;
            z = v;
            break;
        case 3:
            x = u;
            y = -1;
            z = -v;
            break;
        case 4:
            x = u;
            y = -v;
            z = 1;
            break;
        case 5:
            x = -u;
            y = -v;
            z = -1;
            break;
    }

    return normalize(float3(x, y, z));
}

uint HashCombine(uint hash1, uint hash2)
{
	hash1 ^= hash2 + 0x9e3779b9 + (hash1 << 6) + (hash1 >> 2);
    return hash1;
}

uint Hash(uint a)
{
    a = (a + 0x7ed55d16) + (a << 12);
    a = (a ^ 0xc761c23c) ^ (a >> 19);
    a = (a + 0x165667b1) + (a << 5);
    a = (a + 0xd3a2646c) ^ (a << 9);
    a = (a + 0xfd7046c5) + (a << 3);
    a = (a ^ 0xb55a4f09) ^ (a >> 16);
    return a;
}

uint Hash(float a)
{
    return Hash(asuint(a));
}

uint Hash(float3 a)
{
    return HashCombine(HashCombine(Hash(a.x), Hash(a.y)), Hash(a.z));
}

#endif

================================================
FILE: Source/Shaders/PostProcess/Bloom.hlsl
================================================
#include "../Common.hlsli"

struct Config
{
    float threshold;
    float radius;
    float intensity;
};

ConstantBuffer<Config> ConfigBuffer;

static const float blur_weights[5] = { 0.2734375, 0.21875, 0.109375, 0.03125, 0.00390625 };

groupshared uint3 shared_cache[128];
groupshared float3 shared_tile[64];

float3 BlurPixels(float3 a, float3 b, float3 c, float3 d, float3 e, float3 f, float3 g, float3 h, float3 i)
{
    return blur_weights[0] * e + blur_weights[1] * (d + f) + blur_weights[2] * (c + g) + blur_weights[3] * (b + h) + blur_weights[4] * (a + i);
}

void Store2Pixels(uint index, float3 pixel1, float3 pixel2)
{
    shared_cache[index] = f32tof16(pixel1) | f32tof16(pixel2) << 16;
}

void Load2Pixels(uint index, out float3 pixel1, out float3 pixel2)
{
    pixel1 = float3(f16tof32(shared_cache[index]));
    pixel2 = float3(f16tof32(shared_cache[index] >> 16));
}

void Store1Pixels(uint index, float3 pixel)
{
    shared_cache[index] = asuint(pixel);
}

void Load1Pixels(uint index, out float3 pixel)
{
    pixel = asfloat(shared_cache[index]);
}

void BlurHorizontally(uint index, uint start)
{
    float3 pixels[10];
    Load2Pixels(start + 0, pixels[0], pixels[1]);
    Load2Pixels(start + 1, pixels[2], pixels[3]);
    Load2Pixels(start + 2, pixels[4], pixels[5]);
    Load2Pixels(start + 3, pixels[6], pixels[7]);
    Load2Pixels(start + 4, pixels[8], pixels[9]);

    Store1Pixels(index, BlurPixels(pixels[0], pixels[1], pixels[2], pixels[3], pixels[4], pixels[5], pixels[6], pixels[7], pixels[8]));
    Store1Pixels(index + 1, BlurPixels(pixels[1], pixels[2], pixels[3], pixels[4], pixels[5], pixels[6], pixels[7], pixels[8], pixels[9]));
}

float3 BlurVertically(uint start)
{
    float3 pixels[9];
    Load1Pixels(start, pixels[0]);
    Load1Pixels(start + 8, pixels[1]);
    Load1Pixels(start + 16, pixels[2]);
    Load1Pixels(start + 24, pixels[3]);
    Load1Pixels(start + 32, pixels[4]);
    Load1Pixels(start + 40, pixels[5]);
    Load1Pixels(start + 48, pixels[6]);
    Load1Pixels(start + 56, pixels[7]);
    Load1Pixels(start + 64, pixels[8]);
    
    return BlurPixels(pixels[0], pixels[1], pixels[2], pixels[3], pixels[4], pixels[5], pixels[6], pixels[7], pixels[8]);
}

///////////////////////// Bloom Mask /////////////////////////////

Texture2D<float4> BloomMaskInput;
RWTexture2D<float4> BloomMaskOutput;

[numthreads(8, 8, 1)]
void BloomMask(CSParam param)
{
    uint2 extent;
    BloomMaskInput.GetDimensions(extent.x, extent.y);
    
    if (param.DispatchThreadID.x > extent.x || param.DispatchThreadID.y > extent.y)
    {
        return;
    }
    
    float3 color = BloomMaskInput.Load(uint3(param.DispatchThreadID.xy, 0)).rgb;
    float lum = Luminance(color);

    BloomMaskOutput[param.DispatchThreadID.xy] = float4(clamp(lum - ConfigBuffer.threshold, 0.0, 1.0) * color, 1.0);
}

///////////////////////// Bloom Down Sampling /////////////////////////////

Texture2D<float4> BloomDownSamplingInput;
RWTexture2D<float4> BloomDownSamplingOutput;
SamplerState BloomDownSampleSampler;

[numthreads(8, 8, 1)]
void BloomDownSampling(CSParam param)
{
    uint2 extent;
    BloomDownSamplingOutput.GetDimensions(extent.x, extent.y);
    
    if (param.DispatchThreadID.x >= extent.x || param.DispatchThreadID.y >= extent.y)
    {
        return;
    }
    
    float2 uv = (float2(param.DispatchThreadID.xy) + float2(0.5, 0.5)) / float2(extent);
    float3 avg_color = BloomDownSamplingInput.SampleLevel(BloomDownSampleSampler, uv, 0.0).rgb;
    BloomDownSamplingOutput[param.DispatchThreadID.xy] = float4(avg_color, 1.0);
}

///////////////////////// Bloom Blur /////////////////////////////

Texture2D<float4> BloomBlurInput;
RWTexture2D<float4> BloomBlurOutput;

[numthreads(8, 8, 1)]
void BloomBlur(CSParam param)
{
    int2 GroupUL = (param.GroupID.xy << 3) - 4;
    int2 ThreadUL = (param.GroupThreadID.xy << 1) + GroupUL;
    
    int start = param.GroupThreadID.x + (param.GroupThreadID.y << 4);
    
    Store2Pixels(
        start + 0,
        BloomBlurInput.Load(uint3(ThreadUL + uint2(0, 0), 0)).rgb,
        BloomBlurInput.Load(uint3(ThreadUL + uint2(1, 0), 0)).rgb
    );
    
    Store2Pixels(
        start + 8,
        BloomBlurInput.Load(uint3(ThreadUL + uint2(0, 1), 0)).rgb,
        BloomBlurInput.Load(uint3(ThreadUL + uint2(1, 1), 0)).rgb
    );
    
    GroupMemoryBarrierWithGroupSync();
    
    uint row = param.GroupThreadID.y << 4;
    BlurHorizontally(row + (param.GroupThreadID.x << 1), row + param.GroupThreadID.x + (param.GroupThreadID.x & 4));
    
    GroupMemoryBarrierWithGroupSync();
    
    BloomBlurOutput[param.DispatchThreadID.xy] = float4(BlurVertically((param.GroupThreadID.y << 3) + param.GroupThreadID.x), 1.0);
}

///////////////////////// Bloom Up Sampling /////////////////////////////

Texture2D BloomUpSamplingLow;
Texture2D BloomUpSamplingHigh;
RWTexture2D<float4> BloomUpSamplingOutput;

[numthreads(8, 8, 1)]
void BloomUpSampling(CSParam param)
{
    // TODO : Some bug here
    uint2 extent;
    BloomUpSamplingHigh.GetDimensions(extent.x, extent.y);
    
    float2 pixel_size = 1.0 / float2(extent);
        
    int2 GroupUL = (param.GroupID.xy << 3) - 4;
    int2 ThreadUL = (param.GroupThreadID.xy << 1) + GroupUL;
    
    int start = param.GroupThreadID.x + (param.GroupThreadID.y << 4);
    
    Store2Pixels(
        start + 0,
        lerp(
            BloomUpSamplingHigh.Load(uint3(ThreadUL + uint2(0, 0), 0), 0.0).rgb,
            BloomUpSamplingLow.Load(uint3((ThreadUL + uint2(0, 0)) / 2, 0), 0.0).rgb,
            ConfigBuffer.radius
        ),
        lerp(
            BloomUpSamplingHigh.Load(uint3(ThreadUL + uint2(1, 0), 0), 0.0).rgb,
            BloomUpSamplingLow.Load(uint3((ThreadUL + uint2(1, 0)) / 2, 0), 0.0).rgb,
            ConfigBuffer.radius
        )
    );
    
    Store2Pixels(
        start + 8,
        lerp(
            BloomUpSamplingHigh.Load(uint3(ThreadUL + uint2(0, 1), 0), 0.0).rgb,
            BloomUpSamplingLow.Load(uint3((ThreadUL + uint2(0, 1)) / 2, 0), 0.0).rgb,
            ConfigBuffer.radius
        ),
        lerp(
            BloomUpSamplingHigh.Load(uint3(ThreadUL + uint2(1, 1), 0), 0.0).rgb,
            BloomUpSamplingLow.Load(uint3((ThreadUL + uint2(1, 1)) / 2, 0), 0.0).rgb,
            ConfigBuffer.radius
        )
    );
        
    GroupMemoryBarrierWithGroupSync();
    
    uint row = param.GroupThreadID.y << 4;
    BlurHorizontally(row + (param.GroupThreadID.x << 1), row + param.GroupThreadID.x + (param.GroupThreadID.x & 4));
    
    GroupMemoryBarrierWithGroupSync();
    
    BloomUpSamplingOutput[param.DispatchThreadID.xy] = float4(BlurVertically((param.GroupThreadID.y << 3) + param.GroupThreadID.x), 1.0);
}

///////////////////////// Bloom Blend /////////////////////////////

Texture2D BloomBlendBloom;
Texture2D BloomBlendInput;
RWTexture2D<float4> BloomBlendOutput;

[numthreads(8, 8, 1)]
void BloomBlend(CSParam param)
{
    uint2 extent;
    BloomBlendOutput.GetDimensions(extent.x, extent.y);
    
    if (param.DispatchThreadID.x >= extent.x || param.DispatchThreadID.y >= extent.y)
    {
        return;
    }
    
    float2 uv = (float2(param.DispatchThreadID.xy) + float2(0.5, 0.5)) / float2(extent);
    
    BloomBlendOutput[param.DispatchThreadID.xy] = float4(BloomBlendInput.Load(uint3(param.DispatchThreadID.xy, 0), 0.0).rgb + ConfigBuffer.intensity * BloomBlendBloom.Load(uint3(param.DispatchThreadID.xy / 2, 0), 0.0).rgb, 1.0);
}

================================================
FILE: Source/Shaders/PostProcess/FXAA.hlsl
================================================
#include "../Common.hlsli"

struct Config
{
    float fixed_threshold;
    float relative_threshold;
    float subpixel_blending;
};

Texture2D Input;
SamplerState Sampler;
RWTexture2D<float4> Output;
ConstantBuffer<Config> ConfigBuffer;

#ifdef FXAA_QUALITY_LOW
#define EXTRA_EDGE_STEPS 3
#define EDGE_STEP_SIZES 1.5, 2.0, 2.0
#define LAST_EDGE_STEP_GUESS 8.0
#elif FXAA_QUALITY_MEDIUM
#define EXTRA_EDGE_STEPS 8
#define EDGE_STEP_SIZES 1.5, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 4.0
#define LAST_EDGE_STEP_GUESS 8.0
#else   // FXAA_QUALITY_HIGH
#define EXTRA_EDGE_STEPS 10
#define EDGE_STEP_SIZES 1.0, 1.0, 1.0, 1.0, 1.5, 2.0, 2.0, 2.0, 2.0, 4.0
#define LAST_EDGE_STEP_GUESS 8.0
#endif

static const float edgeStepSizes[EXTRA_EDGE_STEPS] = { EDGE_STEP_SIZES };

float GetLuma(float2 uv, float2 offset, float2 texel_size)
{
    uv += float2(offset) * texel_size;
    return sqrt(Luminance(Input.SampleLevel(Sampler, uv, 0.0).rgb));
}

// +1  NW   N     NE
// +0  W     M      E
// -1   SW    S      SE
//      -1      +0    +1
struct LumaNeighborhood
{
    float m, n, e, s, w, ne, se, sw, nw;
    float highest, lowest, range;
};

struct FXAAEdge
{
    bool is_horizontal;
    float pixel_step;
    float luma_gradient, luma;
};

LumaNeighborhood GetLumaNeighborhood(float2 uv, float2 texel_size)
{
    LumaNeighborhood luma;
    luma.m = GetLuma(uv, float2(0.0, 0.0), texel_size);
    luma.n = GetLuma(uv, float2(0.0, 1.0), texel_size);
    luma.e = GetLuma(uv, float2(1.0, 0.0), texel_size);
    luma.s = GetLuma(uv, float2(0.0, -1.0), texel_size);
    luma.w = GetLuma(uv, float2(-1.0, 0.0), texel_size);
    luma.ne = GetLuma(uv, float2(1.0, 1.0), texel_size);
    luma.se = GetLuma(uv, float2(1.0, -1.0), texel_size);
    luma.sw = GetLuma(uv, float2(-1.0, -1.0), texel_size);
    luma.nw = GetLuma(uv, float2(-1.0, 1.0), texel_size);
    luma.highest = max(luma.m, max(luma.n, max(luma.e, max(luma.s, luma.w))));
    luma.lowest = min(luma.m, min(luma.n, min(luma.e, min(luma.s, luma.w))));
    luma.range = luma.highest - luma.lowest;
    return luma;
}

float GetSubpixelBlendFactor(LumaNeighborhood luma)
{
    float filter = luma.n + luma.e + luma.s + luma.w;
    filter = 2.0 * filter + luma.ne + luma.se + luma.sw + luma.nw;
    filter *= 1.0 / 12.0;
    filter = saturate(filter / luma.range);
    filter = smoothstep(0.0, 1.0, filter);
    return filter * filter * ConfigBuffer.subpixel_blending;
}

bool FXAASkip(LumaNeighborhood luma)
{
    return luma.range < max(ConfigBuffer.fixed_threshold, ConfigBuffer.relative_threshold * luma.highest);
}

bool IsHorizontalEdge(LumaNeighborhood luma)
{
    float horizontal = 2.0 * abs(luma.n + luma.s - 2.0 * luma.m) + abs(luma.nw + luma.sw - 2.0 * luma.w) + abs(luma.ne + luma.se - 2.0 * luma.e);
    float vertical = 2.0 * abs(luma.e + luma.w - 2.0 * luma.m) + abs(luma.ne + luma.nw - 2.0 * luma.n) + abs(luma.se + luma.sw - 2.0 * luma.s);
    return horizontal >= vertical;
}

FXAAEdge GetFXAAEdge(LumaNeighborhood luma, float2 texel_size)
{
    FXAAEdge edge;
    edge.is_horizontal = IsHorizontalEdge(luma);
    float lumaP, lumaN;
    if (edge.is_horizontal)
    {
        edge.pixel_step = texel_size.y;
        lumaP = luma.n;
        lumaN = luma.s;
    }
    else
    {
        edge.pixel_step = texel_size.x;
        lumaP = luma.e;
        lumaN = luma.w;
    }
    
    float gradientP = abs(lumaP - luma.m);
    float gradientN = abs(lumaN - luma.m);
    
    if (gradientP < gradientN)
    {
        edge.pixel_step = -edge.pixel_step;
        edge.luma_gradient = gradientN;
        edge.luma = lumaN;
    }
    else
    {
        edge.luma_gradient = gradientP;
        edge.luma = lumaP;
    }
    
    return edge;
}

float GetEdgeBlendFactor(LumaNeighborhood luma, FXAAEdge edge, float2 uv, float2 texel_size)
{
    float2 edge_uv = uv;
    float2 uv_step = float2(0.0, 0.0);
    
    if (edge.is_horizontal)
    {
        edge_uv.y += 0.5 * edge.pixel_step;
        uv_step.x = texel_size.x;
    }
    else
    {
        edge_uv.x += 0.5 * edge.pixel_step;
        uv_step.y = texel_size.y;
    }
    
    float edge_luma = 0.5 * (luma.m + edge.luma);
    float gradient_threshold = 0.25 * edge.luma_gradient;
    
    float2 uvP = edge_uv + uv_step;
    float luma_deltaP = GetLuma(uvP, float2(0, 0), texel_size) - edge_luma;
    bool atP = abs(luma_deltaP) >= gradient_threshold;
    
    for (int i = 0; i < EXTRA_EDGE_STEPS && !atP; i++)
    {
        uvP += uv_step * edgeStepSizes[i];
        luma_deltaP = GetLuma(uvP, float2(0, 0), texel_size) - edge_luma;
        atP = abs(luma_deltaP) >= gradient_threshold;
    }
    if (!atP)
    {
        uvP += uv_step * LAST_EDGE_STEP_GUESS;
    }
    
    float2 uvN = edge_uv - uv_step;
    float luma_deltaN = GetLuma(uvN, float2(0, 0), texel_size) - edge_luma;
    bool atN = abs(luma_deltaN) >= gradient_threshold;
    
    for (int i = 0; i < EXTRA_EDGE_STEPS && !atN; i++)
    {
        uvN -= uv_step * edgeStepSizes[i];
        luma_deltaN = GetLuma(uvN, float2(0, 0), texel_size) - edge_luma;
        atN = abs(luma_deltaN) >= gradient_threshold;
    }
    if (!atN)
    {
        uvN -= uv_step * LAST_EDGE_STEP_GUESS;
    }
    
    float dist_to_P, dist_to_N;
    if (edge.is_horizontal)
    {
        dist_to_P = uvP.x - uv.x;
        dist_to_N = uv.x - uvN.x;
    }
    else
    {
        dist_to_P = uvP.y - uv.y;
        dist_to_N = uv.y - uvN.y;
    }
    
    float dist;
    bool delta_sign;
    
    if (dist_to_P <= dist_to_N)
    {
        dist = dist_to_P;
        delta_sign = luma_deltaP >= 0;
    }
    else
    {
        dist = dist_to_N;
        delta_sign = luma_deltaN >= 0;
    }
    
    if (delta_sign == (luma.m - edge_luma) > 0)
    {
        return 0.0;
    }
    
    return 0.5 - dist / (dist_to_N + dist_to_P);
}

[numthreads(8, 8, 1)]
void CSmain(CSParam param)
{
    uint2 extent;
    Input.GetDimensions(extent.x, extent.y);
    float2 texel_size = 1.0 / float2(extent);
    
    float2 uv = (float2(param.DispatchThreadID.xy) + float2(0.5, 0.5)) * texel_size;
    
    if (param.DispatchThreadID.x >= extent.x || param.DispatchThreadID.y >= extent.y)
    {
        return;
    }
    
    LumaNeighborhood luma = GetLumaNeighborhood(uv, texel_size);
    
    if (FXAASkip(luma))
    {
        Output[param.DispatchThreadID.xy] = float4(Input[param.DispatchThreadID.xy].rgb, 1.0);
        return;
    }
    
    FXAAEdge edge = GetFXAAEdge(luma, texel_size);
    float blend_factor = max(GetSubpixelBlendFactor(luma), GetEdgeBlendFactor(luma, edge, uv, texel_size));
    
    if (edge.is_horizontal)
    {
        uv.y += blend_factor * edge.pixel_step;
    }
    else
    {
        uv.x += blend_factor * edge.pixel_step;
    }
    
    Output[param.DispatchThreadID.xy] = float4(Input.SampleLevel(Sampler, uv, 0.0).rgb, 1.0);
}

================================================
FILE: Source/Shaders/PostProcess/Tonemapping.hlsl
================================================
#define TONEMAP_UNCHARTED
#include "../Tonemapper.hlsli"

struct UniformBlock
{
    float brightness;
    float contrast;
    float saturation;
    float vignette;
    float avgLum;
    int autoExposure;
    float Ywhite; // Burning white
    float key; // Log-average luminance
};

Texture2D Input;
SamplerState TexSampler;
RWTexture2D<float4> Output;
ConstantBuffer<UniformBlock> UniformBuffer;

struct CSParam
{
    uint3 DispatchThreadID : SV_DispatchThreadID;
};

// http://www.thetenthplanet.de/archives/5367
// Apply dithering to hide banding artifacts.
float3 Dither(float3 linear_color, float3 noise, float quant)
{
    float3 c0 = floor(LinearTosRGB(linear_color) / quant) * quant;
    float3 c1 = c0 + quant;
    float3 discr = lerp(sRGBToLinear(c0), sRGBToLinear(c1), noise);
    return lerp(c0, c1, float3(1.0, 1.0, 1.0) - step(linear_color, discr));
}

// http://user.ceng.metu.edu.tr/~akyuz/files/hdrgpu.pdf
static const float3x3 RGB2XYZ = float3x3(0.4124564, 0.3575761, 0.1804375, 0.2126729, 0.7151522, 0.0721750, 0.0193339, 0.1191920, 0.9503041);
float Luminance(float3 color)
{
    return dot(color, float3(0.2126f, 0.7152f, 0.0722f)); //color.r * 0.2126 + color.g * 0.7152 + color.b * 0.0722;
}

float3 ToneExposure(float3 RGB, float logAvgLum)
{
    float3 XYZ = mul(RGB2XYZ, RGB);
    float Y = (UniformBuffer.key / logAvgLum) * XYZ.y;
    float Yd = (Y * (1.0 + Y / (UniformBuffer.Ywhite * UniformBuffer.Ywhite))) / (1.0 + Y);
    return RGB / XYZ.y * Yd;
}

float3 ToneLocalExposure(float3 RGB, float logAvgLum, float2 uvCoords)
{
    float3 XYZ = mul(RGB2XYZ, RGB);
    float Y = (UniformBuffer.key / logAvgLum) * XYZ.y;
    float La; // local adaptation luminance
    float factor = UniformBuffer.key / logAvgLum;
    float epsilon = 0.05, phi = 2.0;
    float scale[7] = { 1, 2, 4, 8, 16, 32, 64 };
    for (int i = 0; i < 7; ++i)
    {
        float v1 = Luminance(Input.SampleLevel(TexSampler, uvCoords, i).rgb) * factor;
        float v2 = Luminance(Input.SampleLevel(TexSampler, uvCoords, i + 1).rgb) * factor;
        if (abs(v1 - v2) / ((UniformBuffer.key * pow(2, phi) / (scale[i] * scale[i])) + v1) > epsilon)
        {
            La = v1;
            break;
        }
        else
            La = v2;
    }
    float Yd = Y / (1.0 + La);
    return RGB / XYZ.y * Yd;
}

uint3 pcg3d(uint3 v)
{
    v = v * 1664525u + uint3(1013904223u, 1013904223u, 1013904223u);
    v.x += v.y * v.z;
    v.y += v.z * v.x;
    v.z += v.x * v.y;
    v ^= v >> uint3(16u, 16u, 16u);
    v.x += v.y * v.z;
    v.y += v.z * v.x;
    v.z += v.x * v.y;
    return v;
}

[numthreads(8, 8, 1)]
void CSmain(CSParam param)
{
    uint2 TexSize;
    Input.GetDimensions(TexSize.x, TexSize.y);
    float2 uvCoords = (float2(param.DispatchThreadID.xy) + float2(0.5, 0.5)) / float2(TexSize);
    float4 hdr = Input.SampleLevel(TexSampler, uvCoords, 0).rgba;
    
    if (((UniformBuffer.autoExposure >> 0) & 1) == 1)
    {
        float4 avg = Input.SampleLevel(TexSampler, float2(0.5, 0.5), 20).rgba; // Get the average value of the image
        float avgLum2 = Luminance(avg.rgb); // Find the luminance
        if (((UniformBuffer.autoExposure >> 1) & 1) == 1)
        {
            hdr.rgb = ToneLocalExposure(hdr.rgb, avgLum2, uvCoords); // Adjust exposure
        }
        else
        {
            hdr.rgb = ToneExposure(hdr.rgb, avgLum2); // Adjust exposure
        }
    }

    // Tonemap + Linear to sRgb
    float3 color = ToneMap(hdr.rgb, UniformBuffer.avgLum);

    // Remove banding
    uint3 r = pcg3d(uint3(param.DispatchThreadID.xy, 0));
    float3 noise = asfloat(0x3f800000 | (r >> 9)) - 1.0f;
    color = Dither(sRGBToLinear(color), noise, 1. / 255.);

    //contrast
    color = clamp(lerp(float3(0.5, 0.5, 0.5), color, UniformBuffer.contrast), 0, 1);
    // brighness
    float inv_brightness = 1.0 / UniformBuffer.brightness;
    color = pow(color, float3(inv_brightness, inv_brightness, inv_brightness));
    // saturation
    float s = dot(color, float3(0.299, 0.587, 0.114));
    float3 i = float3(s, s, s);
    color = lerp(i, color, UniformBuffer.saturation);
    // vignette
    float2 uv = (uvCoords - 0.5) * 2.0;
    color *= 1.0 - dot(uv, uv) * UniformBuffer.vignette;

    Output[int2(param.DispatchThreadID.xy)] = float4(color, hdr.a);
}

================================================
FILE: Source/Shaders/PreProcess/EquirectangularToCubemap.hlsl
================================================
Texture2D InputTexture;
SamplerState TexSampler;

static const float PI = 3.14159265358979323846f;
static const float4x4 InvViewProjections[6] =
{
    // +X
    float4x4(
        -0, 0, -0, 1,
        0, 1, 0, -0,
        1, 0, -0, 0,
        0, -0, -4.95, 5.0499997
    ),
    // -X
    float4x4(
        -0, 0, -0, -1,
        0, 1, 0, -0,
        -1, 0, -0, 0,
        0, -0, -4.95, 5.0499997
    ),
    // +Y
    float4x4(
        1, 0, -0, 0,
        0, -0, 0, 1,
        -0, 1, -0, 0,
        0, -0, -4.95, 5.0499997
    ),
    // -Y
    float4x4(
        1, 0, 0, 0,
        0, -0, 0, -1,
        -0, -1, -0, 0,
        0, -0, -4.95, 5.0499997
    ),
    // +Z
    float4x4(
        1, 0, -0, 0,
        0, 1, 0, -0,
        -0, 0, -0, -1,
        0, -0, -4.95, 5.0499997
    ),
    // -Z
    float4x4(
        -1, 0, -0, 0,
        0, 1, 0, -0,
        -0, -0, -0, 1,
        0, -0, -4.95, 5.0499997
    )
};

struct VSInput
{
    uint VertexID : SV_VertexID;
    uint InstanceID : SV_InstanceID;
};

struct VSOutput
{
    float3 Pos : POSITION0;
    float2 UV : TEXCOORD0;
    float4 Position : SV_POSITION;
    uint Layer : SV_RenderTargetArrayIndex;
};

struct FSInput
{
    float3 Pos : POSITION0;
    float2 UV : TEXCOORD0;
};

struct FSOutput
{
    float4 Color : SV_Target0;
};

float2 SampleSphericalMap(float3 v)
{
    float2 uv = float2(atan2(v.x, v.z), asin(v.y));
    uv.x /= 2 * PI;
    uv.y /= PI;
    uv += 0.5;
    uv.y = 1.0 - uv.y;
    return uv;
}

VSOutput VSmain(VSInput input)
{
    VSOutput output = (VSOutput) 0;
    
    output.UV = float2((input.VertexID << 1) & 2, input.VertexID & 2);
    output.Position = float4(output.UV * 2.0 - 1.0, 1.0, 1.0);
    output.Pos = mul(InvViewProjections[input.InstanceID], output.Position).xyz;
    output.Layer = input.InstanceID;

    return output;
}

FSOutput PSmain(FSInput input)
{
    FSOutput output;
    
    float2 UV = SampleSphericalMap(normalize(input.Pos));
    output.Color = float4(InputTexture.Sample(TexSampler, UV).rgb, 1.0);
    // output.Color = float4(UV, 0.0, 1.0);
    
    return output;
}

================================================
FILE: Source/Shaders/PreProcess/GGXBRDFLUT.hlsl
================================================
#include "../Random.hlsli"
#include "../Common.hlsli"

#define LOCAL_SIZE 8
#define SAMPLE_COUNT 32
#define LUT_SIZE 512

RWTexture2D<float2> Output;

float3 ImportanceSampleGGX(float2 Xi, float3 N, float roughness)
{
    float alpha = roughness * roughness;

    float theta = atan(alpha * sqrt(Xi.x) / sqrt(1 - Xi.x));
    float phi = 2.0 * PI * Xi.y;

    float3 H = float3(
        sin(theta) * cos(phi),
        sin(theta) * sin(phi),
        cos(theta)
    );

    float3 Up = N.z > 0.99 ? float3(0.0, 1.0, 0.0) : float3(0.0, 0.0, 1.0);
    float3 T = normalize(cross(N, Up));
    float3 B = normalize(cross(N, T));

    return T * H.x + B * H.y + N * H.z;
}

float Conv(in float kernel[9], in float data[9], in float denom, in float offset)
{
    float res = 0.0;
    for (int i = 0; i < 9; ++i)
    {
        res += kernel[i] * data[i];
    }
    return saturate(res / denom + offset);
}

float GeometrySchlickGGX(float NoV, float roughness)
{
    float alpha = roughness;
    float k = alpha * alpha / 2.0;

    return NoV / (NoV * (1.0 - k) + k);
}

float GeometrySmith(float roughness, float NoV, float NoL)
{
    return GeometrySchlickGGX(NoV, roughness) * GeometrySchlickGGX(NoL, roughness);
}

float2 IntegrateBRDF(float NoV, float roughness)
{
    float3 V;
    V.x = sqrt(1.0 - NoV * NoV);
    V.y = 0.0;
    V.z = NoV;

    float A = 0.0;
    float B = 0.0;

    float3 N = float3(0.0, 0.0, 1.0);

    for (uint i = 0; i < SAMPLE_COUNT; i++)
    {
        float2 Xi = Hammersley(i, SAMPLE_COUNT);
        float3 H = ImportanceSampleGGX(Xi, N, roughness);
        float3 L = normalize(H * 2.0 * dot(V, H) - V);

        float NoL = clamp(dot(N, L), 0.0, 1.0);
        float NoH = clamp(dot(N, H), 0.0, 1.0);
        float VoH = clamp(dot(V, H), 0.0, 1.0);

        if (NoL > 0.0)
        {
            float G = GeometrySmith(roughness, NoV, NoL);
            float w = VoH * G / (NoV * NoH);
            float Fc = pow(1.0 - VoH, 5.0);

            A += (1.0 - Fc) * w;
            B += Fc * w;
        }
    }

    return float2(A, B) / float(SAMPLE_COUNT);
}

[numthreads(LOCAL_SIZE, LOCAL_SIZE, 1)]
void CSmain(CSParam param)
{
    float2 tex_coord = float2(float2(param.DispatchThreadID.xy) + float2(0.5, 0.5)) / float(LUT_SIZE);
    float2 brdf = IntegrateBRDF(tex_coord.x, tex_coord.y);

    Output[int2(param.DispatchThreadID.xy)] = brdf;
}

================================================
FILE: Source/Shaders/Random.hlsli
================================================
#ifndef __RANDOM_HLSL__
#define __RANDOM_HLSL__

#include "Math.hlsli"

struct PCGSampler
{
    uint seed;
    
    void Init(uint2 resolution, uint2 screen_coord, uint frame)
    {
        uint v0 = screen_coord.y * resolution.x + screen_coord.x;
        uint v1 = frame;
        uint s0 = 0;

        for (uint n = 0; n < 16; n++)
        {
            s0 += 0x9e3779b9;
            v0 += ((v1 << 4) + 0xa341316c) ^ (v1 + s0) ^ ((v1 >> 5) + 0xc8013ea4);
            v1 += ((v0 << 4) + 0xad90777d) ^ (v0 + s0) ^ ((v0 >> 5) + 0x7e95761e);
        }
        
        seed = v0;
    }
    
    float Get1D()
    {
        // https://www.pcg-random.org/
        uint prev = seed * 747796405u + 2891336453u;
        uint word = ((prev >> ((prev >> 28u) + 4u)) ^ prev) * 277803737u;
        seed = prev;
        uint r = (word >> 22u) ^ word;
        return asfloat(0x3f800000 | (r >> 9)) - 1.0f;
    }
    
    float2 Get2D()
    {
        float x = Get1D();
        float y = Get1D();
        return float2(x, y);
    }
    
    float3 Get3D()
    {
        float x = Get1D();
        float y = Get1D();
        float z = Get1D();
        return float3(x, y, z);
    }
};

float Rand1To1(float x)
{
    return frac(sin(x) * 43758.5453123);
}

float Rand2To1(float2 uv)
{
    return frac(sin(dot(uv, float2(12.9898, 78.233))) * 43758.5453);
}

float Rand3To1(float3 uvw)
{
    return frac(sin(dot(uvw, float3(12.9898, 78.233, 144.7272))) * 43758.5453);
}

float2 PoissonDiskSamples2D(float2 seed, int samples_num, int rings_num, int step)
{
    float angle = Rand2To1(seed) * PI * 2.0 + step * PI * 2.0 * float(rings_num) / float(samples_num);
    float radius = (float(step) + 1.0) / float(samples_num);
    return float2(cos(angle) * sin(angle), cos(angle)) * pow(radius, 0.75);
}

float3 PoissonDiskSamples3D(float3 seed, int samples_num, int rings_num, float2 step)
{
    float2 angle = Rand3To1(seed) * PI * 2.0 + step * PI * 2.0 * float(rings_num) / float(samples_num);
    float radius = (length(step) + 1.0) / float(samples_num);
    return float3(sin(angle.x) * cos(angle.y), sin(angle.x) * sin(angle.y), cos(angle.x)) * pow(radius, 0.75);
}

float2 UniformDiskSamples2D(float2 seed)
{
    float rand_num = Rand2To1(seed);
    float sample_x = Rand1To1(rand_num);
    float sample_y = Rand1To1(sample_x);

    float radius = sqrt(sample_x);
    float angle = sample_y * PI * 2;

    return float2(radius * cos(angle), radius * sin(angle));
}

float3 UniformDiskSamples3D(float3 seed)
{
    float sample_x = Rand3To1(seed);
    float sample_y = Rand1To1(sample_x);
    float sample_z = Rand1To1(sample_y);

    float radius = sqrt(sample_x);
    float2 angle = float2(sample_y * PI * 2, sample_z * PI * 2);

    return float3(sin(angle.y) * cos(angle.x), sin(angle.y) * sin(angle.x), cos(angle.y)) * radius;
}

float RadicalInverse_VdC(uint bits)
{
    bits = (bits << 16u) | (bits >> 16u);
    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
    return float(bits) * 2.3283064365386963e-10; // / 0x100000000
}

float2 Hammersley(uint i, uint N)
{
    return float2(float(i) / float(N), RadicalInverse_VdC(i));
}

#endif

================================================
FILE: Source/Shaders/RayTracing/BidirectionalPathTracing.hlsl
================================================


================================================
FILE: Source/Shaders/RayTracing/PathTracing.hlsl
================================================
#include "../Interaction.hlsli"
#include "../Math.hlsli"
#include "../Common.hlsli"
#include "../Light.hlsli"
#include "../Random.hlsli"

struct Config
{
    uint max_bounce;
    uint max_spp;
    uint frame_count;
    float clamp_threshold;
    uint anti_aliasing;
};

RaytracingAccelerationStructure TopLevelAS;
StructuredBuffer<Instance> InstanceBuffer;
StructuredBuffer<Vertex> VertexBuffer[];
StructuredBuffer<uint> IndexBuffer[];
ConstantBuffer<View> ViewBuffer;
ConstantBuffer<Config> ConfigBuffer;
StructuredBuffer<PointLight> PointLightBuffer;
StructuredBuffer<SpotLight> SpotLightBuffer;
StructuredBuffer<DirectionalLight> DirectionalLightBuffer;
StructuredBuffer<RectLight> RectLightBuffer;
ConstantBuffer<LightInfo> LightInfoBuffer;
RWTexture2D<float4> Output;

#ifndef RAYTRACING_PIPELINE
#define RAYGEN_SHADER
#define CLOSESTHIT_SHADER
#define MISS_SHADER
#include "../Material/Material.hlsli"
#endif

#ifdef USE_SKYBOX
TextureCube<float4> Skybox;
SamplerState SkyboxSampler;
#endif

struct PayLoad
{
    SurfaceInteraction interaction;
    
    RayDiff ray_diff;

    PCGSampler rng;
    
    float3 wi;
    float pdf;
    float eta;
    float3 radiance;
    float3 throughout;
    bool terminate;
    bool visible;
    
    void Init()
    {
        radiance = 0.f;
        pdf = 1.f;
        eta = 1.f;
        throughout = 1.f;
        terminate = false;
    }
};

struct Light
{
    PointLight point_light;
    SpotLight spot_light;
    DirectionalLight directional_light;
    RectLight rect_light;
    uint light_type;
    
    void Init(uint light_id)
    {
        uint point_light_offset = 0;
        uint spot_light_offset = LightInfoBuffer.point_light_count;
        uint directional_light_offset = spot_light_offset + LightInfoBuffer.spot_light_count;
        uint rectangle_light_offset = directional_light_offset + LightInfoBuffer.directional_light_count;
        uint light_count = rectangle_light_offset + LightInfoBuffer.rect_light_count;
        
        if (light_id < spot_light_offset)
        {
            light_type = POINT_LIGHT;
            point_light = PointLightBuffer[light_id];
            return;
        }
        else if (light_id < directional_light_offset)
        {
            light_type = SPOT_LIGHT;
            spot_light = SpotLightBuffer[light_id - spot_light_offset];
            return;
        }
        else if (light_id < rectangle_light_offset)
        {
            light_type = DIRECTIONAL_LIGHT;
            directional_light = DirectionalLightBuffer[light_id - directional_light_offset];
            return;
        }
        else if (light_id < light_count)
        {
            light_type = RECT_LIGHT;
            rect_light = RectLightBuffer[light_id - rectangle_light_offset];
            return;
        }
    }
    
    LightLiSample SampleLi(LightSampleContext ctx, float2 u)
    {
        switch (light_type)
        {
            case POINT_LIGHT:
                return point_light.SampleLi(ctx, u);
            case SPOT_LIGHT:
                return spot_light.SampleLi(ctx, u);
            case DIRECTIONAL_LIGHT:
                return directional_light.SampleLi(ctx, u);
            case RECT_LIGHT:
                return rect_light.SampleLi(ctx, u);
        }
        
        LightLiSample light_sample;
        return light_sample;
    }

    float PDF_Li(LightSampleContext ctx, float3 wi)
    {
        switch (light_type)
        {
            case POINT_LIGHT:
                return point_light.PDF_Li(ctx, wi);
            case SPOT_LIGHT:
                return spot_light.PDF_Li(ctx, wi);
        }
        
        return 0;
    }
    
    bool IsDelta()
    {
        switch (light_type)
        {
            case POINT_LIGHT:
                return point_light.IsDelta();
            case SPOT_LIGHT:
                return spot_light.IsDelta();
            case DIRECTIONAL_LIGHT:
                return directional_light.IsDelta();
            case RECT_LIGHT:
                return rect_light.IsDelta();
        }
        return false;
    }
};

bool SceneIntersection(RayDesc ray, out PayLoad pay_load)
{
    pay_load.visible = true;
    TraceRay(
        TopLevelAS, // RaytracingAccelerationStructure
        RAY_FLAG_NONE, // RayFlags
        0xFF, // InstanceInclusionMask
        0, // RayContributionToHitGroupIndex
        1, // MultiplierForGeometryContributionToHitGroupIndex
        0, // MissShaderIndex
        ray, // Ray
        pay_load // Payload
    );
    
    return pay_load.visible;
}

bool Unoccluded(SurfaceInteraction surface_interaction, Interaction isect)
{
    float3 direction = normalize(isect.p - surface_interaction.isect.p);
    RayDesc shadow_ray = surface_interaction.isect.SpawnRay(direction);
    shadow_ray.TMin = 0.0;
    shadow_ray.TMax = distance(isect.p, surface_interaction.isect.p);
    
    PayLoad pay_load;
    pay_load.visible = true;
    
    TraceRay(
        TopLevelAS, // RaytracingAccelerationStructure
        RAY_FLAG_FORCE_OPAQUE | RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH | RAY_FLAG_SKIP_CLOSEST_HIT_SHADER, // RayFlags
        0xFF, // InstanceInclusionMask
        0, // RayContributionToHitGroupIndex
        1, // MultiplierForGeometryContributionToHitGroupIndex
        0, // MissShaderIndex
        shadow_ray, // Ray
        pay_load // Payload
    );
    
    return !pay_load.visible;
}

uint hash(uint a)
{
    a = (a + 0x7ed55d16) + (a << 12);
    a = (a ^ 0xc761c23c) ^ (a >> 19);
    a = (a + 0x165667b1) + (a << 5);
    a = (a + 0xd3a2646c) ^ (a << 9);
    a = (a + 0xfd7046c5) + (a << 3);
    a = (a ^ 0xb55a4f09) ^ (a >> 16);
    return a;
}

float3 GetColor(uint v)
{
    uint mhash = hash(v);
    return float3(float(mhash & 255), float((mhash >> 8) & 255), float((mhash >> 16) & 255)) / 255.0;
}

#ifdef RAYGEN_SHADER
[shader("raygeneration")]
void RayGenMain()
{
    uint2 launch_index = DispatchRaysIndex().xy;
    uint2 launch_dims = DispatchRaysDimensions().xy;
    
    PayLoad pay_load;
    pay_load.rng.Init(launch_dims, launch_index, ConfigBuffer.frame_count);
    pay_load.Init();
    
    const float2 pixel_pos = float2(launch_index.xy) + (pay_load.rng.Get2D() - float2(0.5, 0.5)) * ConfigBuffer.anti_aliasing + 0.5;
    const float2 scene_uv = pixel_pos / float2(launch_dims.xy) * 2.0 - 1.0;
    
    RayDesc ray;
    ViewBuffer.CastRay(scene_uv, (float2) launch_dims, ray, pay_load.ray_diff);
    
    uint bounce = 0;
    
    for (bounce = 0; bounce < ConfigBuffer.max_bounce && !pay_load.terminate; bounce++)
    {
        if (!SceneIntersection(ray, pay_load))
        {
            // Sample environment light
#ifdef USE_SKYBOX
            // Environment Sampling (HDR)
            // See:  https://arxiv.org/pdf/1901.05423.pdf
            float pdf = 1.0;
            float3 wi = normalize(ray.Direction);
            pay_load.radiance += Skybox.SampleLevel(SkyboxSampler, wi, 0.0).rgb * pay_load.throughout;
#else
            float pdf = 1.0;
#endif
            break;
        }
           
        ray = pay_load.interaction.isect.SpawnRay(pay_load.wi);
        
        // Russian roulette
        float3 rrBeta = pay_load.throughout * pay_load.eta;
        float max_cmpt = max(rrBeta.x, max(rrBeta.y, rrBeta.z));
        if (max_cmpt < 1.0 && bounce > 1)
        {
            float q = max(0.0, 1.0 - max_cmpt);
            if (pay_load.rng.Get1D() < q)
            {
                break;
            }
            pay_load.throughout /= 1.0 - q;
        }
    }
    
    // Clamp firefly
    float lum = Luminance(pay_load.radiance);
    if (lum > ConfigBuffer.clamp_threshold)
    {
        pay_load.radiance *= ConfigBuffer.clamp_threshold / lum;
    }
    
    int2 launch_id = int2(launch_index.x, launch_dims.y - launch_index.y);
    
    // Temporal Accumulation
    if (ConfigBuffer.frame_count == 0)
    {
        Output[launch_id] = float4(pay_load.radiance, 1.f);
    }
    else
    {
        float3 prev_color = Output[launch_id].rgb;
        float4 accumulated_color = 0.f;
        if ((isnan(prev_color.x) || isnan(prev_color.y) || isnan(prev_color.z)))
        {
            accumulated_color = float4(pay_load.radiance, 1.f);
        }
        else
        {
            accumulated_color = float4(lerp(prev_color, pay_load.radiance, 1.0 / float(ConfigBuffer.frame_count + 1)), 1.f);
        }
        
        Output[launch_id] = accumulated_color;
    }
}
#endif

#ifdef CLOSESTHIT_SHADER

float3 SampleLd(PayLoad pay_load, Material material)
{
    uint flags = material.bsdf.Flags();
    //if(IsReflective(flags)&&!IsTransmissive(flags))
    //{
    //    OffsetRayOrigin(pay_load.interaction.isect.wo, pay_load.interaction.isect.n);
    //}
    
    uint light_count = LightInfoBuffer.point_light_count + LightInfoBuffer.spot_light_count + LightInfoBuffer.directional_light_count + LightInfoBuffer.rect_light_count;
    
    // Uniformly sample one light
    if (light_count > 0)
    {
        uint light_id = (uint) min(light_count - 1, pay_load.rng.Get1D() * (float) light_count);
        float light_select_pdf = 1.0 / (float) light_count;
        
        Light light;
        light.Init(light_id);
        
        LightSampleContext sample_context;
        sample_context.n = pay_load.interaction.isect.n;
        sample_context.ns = pay_load.interaction.shading_n;
        sample_context.p = pay_load.interaction.isect.p;
        
        LightLiSample light_sample = light.SampleLi(sample_context, pay_load.rng.Get2D());
        
        float3 wo = pay_load.interaction.isect.wo;
        float3 f = material.bsdf.Eval(wo, light_sample.wi, TransportMode_Radiance);
        
        if (IsBlack(light_sample.L) || IsBlack(f) || !Unoccluded(pay_load.interaction, light_sample.isect))
        {
            return 0.f;
        }
        
        float p_l = light_select_pdf * light_sample.pdf;
        
        if (light.IsDelta())
        {
            return light_sample.L * f / p_l;
        }
        else
        {
            float p_b = material.bsdf.PDF(wo, light_sample.wi, TransportMode_Radiance, BSDF_All);
            float w_l = PowerHeuristic(1, p_l, 1, p_b);
            return w_l * light_sample.L * f / p_l;
        }
    }
    return 0.f;
}
#include "../Material/Scattering.hlsli"
[shader("closesthit")]
void ClosesthitMain(inout PayLoad pay_load : SV_RayPayload, BuiltInTriangleIntersectionAttributes attributes)
{
    pay_load.visible = true;
    
    SurfaceInteraction surface_interaction;
    
    const uint instance_id = InstanceIndex();
    const uint primitve_id = PrimitiveIndex();
    const float3 bary = float3(1.0 - attributes.barycentrics.x - attributes.barycentrics.y, attributes.barycentrics.x, attributes.barycentrics.y);
    
    Instance instance = InstanceBuffer[instance_id];

    Vertex v0 = VertexBuffer[instance.mesh_id][IndexBuffer[instance.mesh_id][primitve_id * 3]];
    Vertex v1 = VertexBuffer[instance.mesh_id][IndexBuffer[instance.mesh_id][primitve_id * 3 + 1]];
    Vertex v2 = VertexBuffer[instance.mesh_id][IndexBuffer[instance.mesh_id][primitve_id * 3 + 2]];
    
    surface_interaction.isect.p = WorldRayOrigin() + WorldRayDirection() * RayTCurrent();
    surface_interaction.isect.uv = v0.texcoord0.xy * bary.x + v1.texcoord0.xy * bary.y + v2.texcoord0.xy * bary.z;
    surface_interaction.isect.n = v0.normal.xyz * bary.x + v1.normal.xyz * bary.y + v2.normal.xyz * bary.z;
    surface_interaction.isect.n = normalize(mul(WorldToObject4x3(), normalize(surface_interaction.isect.n)).xyz);
    surface_interaction.isect.nt = v0.tangent.xyz * bary.x + v1.tangent.xyz * bary.y + v2.tangent.xyz * bary.z;
    surface_interaction.isect.nt = normalize(mul(WorldToObject4x3(), normalize(surface_interaction.isect.nt)).xyz);
    surface_interaction.shading_n = dot(surface_interaction.isect.n, -WorldRayDirection()) <= 0 ? -surface_interaction.isect.n : surface_interaction.isect.n;
    surface_interaction.isect.wo = -normalize(WorldRayDirection());
    surface_interaction.isect.t = RayTCurrent();
    surface_interaction.material = instance.material_id;
    
    float3 edge01 = mul(v1.position - v0.position, (float3x3) ObjectToWorld4x3()).xyz;
    float3 edge02 = mul(v2.position - v0.position, (float3x3) ObjectToWorld4x3()).xyz;
    float3 wgeom_normal = cross(edge01, edge02);
    
    // Compute Differential
    pay_load.ray_diff.Propagate(normalize(WorldRayDirection()), RayTCurrent(), surface_interaction.shading_n);
    
    float3 nu = cross(edge02, wgeom_normal);
    float3 nv = cross(edge01, wgeom_normal);
    float3 lu = nu / (dot(nu, edge01));
    float3 lv = nv / (dot(nv, edge02));

    float2 dBarydx = float2(dot(lu, pay_load.ray_diff.dOdx), dot(lv, pay_load.ray_diff.dOdx));
    float2 dBarydy = float2(dot(lu, pay_load.ray_diff.dOdy), dot(lv, pay_load.ray_diff.dOdy));
    
    float2 deltaUV1 = v1.texcoord0 - v0.texcoord0;
    float2 deltaUV2 = v2.texcoord0 - v0.texcoord0;
    
    surface_interaction.duvdx = dBarydx.x * deltaUV1 + dBarydx.y * deltaUV2;
    surface_interaction.duvdy = dBarydy.x * deltaUV1 + dBarydy.y * deltaUV2;
    
    Material material;
    material.Init(surface_interaction);

    // Sample emissive
    pay_load.radiance += material.bsdf.GetGBufferData().emissive * pay_load.throughout;
    
    pay_load.interaction = surface_interaction;
    float3 wo = surface_interaction.isect.wo;
    
    if (IsNonSpecular(material.bsdf.Flags()))
    {
        uint flags = material.bsdf.Flags();
        float3 Ld = SampleLd(pay_load, material);
        pay_load.radiance = pay_load.radiance.rgb + pay_load.throughout * Ld;
    }
    
    // Sample BSDF to get new path direction
    uint sample_type;
    BSDFSample bs = material.bsdf.Samplef(wo, pay_load.rng.Get1D(), pay_load.rng.Get2D(), TransportMode_Radiance, BSDF_All);
   
    if (IsBlack(bs.f) || bs.pdf == 0.0)
    {
        pay_load.terminate = true;
        return;
    }
    
    pay_load.throughout *= bs.f / bs.pdf;
    pay_load.pdf = bs.pdfIsProportional ? material.bsdf.PDF(wo, bs.wiW, TransportMode_Radiance, BSDF_All) : bs.pdf;
    bool specular_bounce = bs.IsSpecular();
    if (bs.IsTransmission())
    {
        pay_load.eta *= Sqr(bs.eta);
    }

    pay_load.wi = bs.wiW;
}
#endif

#ifdef MISS_SHADER
[shader("miss")]
void MissMain(inout PayLoad pay_load : SV_RayPayload)
{
    pay_load.visible = false;
}
#endif


================================================
FILE: Source/Shaders/Reflection/RayTracedReflection.hlsl
================================================


================================================
FILE: Source/Shaders/RenderPath/VisibilityBufferVisualization.hlsl
================================================
#include "../Common.hlsli"

Texture2D<uint> VisibilityBuffer;
Texture2D<float> DepthBuffer;
RWTexture2D<float4> InstanceID;
RWTexture2D<float4> PrimitiveID;

uint hash(uint a)
{
    a = (a + 0x7ed55d16) + (a << 12);
    a = (a ^ 0xc761c23c) ^ (a >> 19);
    a = (a + 0x165667b1) + (a << 5);
    a = (a + 0xd3a2646c) ^ (a << 9);
    a = (a + 0xfd7046c5) + (a << 3);
    a = (a ^ 0xb55a4f09) ^ (a >> 16);
    return a;
}

[numthreads(32, 32, 1)]
void CSmain(CSParam param)
{
    uint2 extent;
    VisibilityBuffer.GetDimensions(extent.x, extent.y);
    
    if (extent.x < param.DispatchThreadID.x || extent.y < param.DispatchThreadID.y)
    {
        return;
    }
    
    if (DepthBuffer.Load(int3(param.DispatchThreadID.xy, 0)).r > 3e38f)
    {
        InstanceID[param.DispatchThreadID.xy] = 0.f;
        PrimitiveID[param.DispatchThreadID.xy] = 0.f;
        return;
    }
    
    uint vbuffer = VisibilityBuffer.Load(int3(param.DispatchThreadID.xy, 0));
    uint instance_id = 0;
    uint primitive_id = 0;
    uint mesh_type = 0;
    
    UnPackVisibilityBuffer(vbuffer, mesh_type, instance_id, primitive_id);
    
    uint mhash = hash(instance_id);
    InstanceID[param.DispatchThreadID.xy] = float4(float3(float(mhash & 255), float((mhash >> 8) & 255), float((mhash >> 16) & 255)) / 255.0, 1.0);
    
    mhash = hash(primitive_id);
    PrimitiveID[param.DispatchThreadID.xy] = float4(float3(float(mhash & 255), float((mhash >> 8) & 255), float((mhash >> 16) & 255)) / 255.0, 1.0);
}

================================================
FILE: Source/Shaders/RenderPath/VisibilityGeometryPass.hlsl
================================================
#include "../Common.hlsli"

StructuredBuffer<Instance> InstanceBuffer;
StructuredBuffer<Meshlet> MeshletBuffer[];
StructuredBuffer<uint> MeshletDataBuffer[];
StructuredBuffer<uint> IndexBuffer[];
ConstantBuffer<View> ViewBuffer;

#ifdef HAS_SKINNED
StructuredBuffer<SkinnedVertex> VertexBuffer[];
StructuredBuffer<float4x4> BoneMatrices[];

struct VertexIn
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    int4 Bones0 : BLENDINDICES0;
    int4 Bones1 : BLENDINDICES1;
    float4 Weights0 : BLENDWEIGHT0;
    float4 Weights1 : BLENDWEIGHT1;
    uint InstanceID : SV_InstanceID;
};
#else
StructuredBuffer<Vertex> VertexBuffer[];

struct VertexIn
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    uint InstanceID : SV_InstanceID;
};
#endif

struct VertexOut
{
    float4 Position : SV_Position;
    float2 Texcoord : TEXCOORD0;
    uint InstanceID : COLOR0;
};

struct PrimitiveOut
{
    uint InstanceID : COLOR1;
    uint PrimitiveID : COLOR2;
};

struct PayLoad
{
    uint MeshletIndices[32];
    uint InstanceIndices[32];
};

groupshared PayLoad s_payload;

[numthreads(32, 1, 1)]
void ASmain(CSParam param)
{
    bool visible = false;
    
    uint instance_id = param.DispatchThreadID.y;
    uint meshlet_id = param.DispatchThreadID.x;
    
    uint instance_count = 0;
    uint instance_stride = 0;
    InstanceBuffer.GetDimensions(instance_count, instance_stride);
    
    if (instance_id < instance_count)
    {
        Instance instance = InstanceBuffer[instance_id];
        
        uint meshlet_count = 0;
        uint meshlet_stride = 0;
        MeshletBuffer[instance.mesh_id].GetDimensions(meshlet_count, meshlet_stride);
        
        if (meshlet_id < meshlet_count)
        {
#ifdef HAS_SKINNED
            visible = true;
#else
            Meshlet meshlet = MeshletBuffer[instance.mesh_id][meshlet_id];
            visible = ViewBuffer.IsVisible(meshlet, instance.transform);
#endif
        }
    }

    if (visible)
    {
        uint index = WavePrefixCountBits(visible);
        s_payload.InstanceIndices[index] = instance_id;
        s_payload.MeshletIndices[index] = meshlet_id;
    }
    
    uint visible_count = WaveActiveCountBits(visible);
    
    DispatchMesh(visible_count, 1, 1, s_payload);
}

[outputtopology("triangle")]
[numthreads(32, 1, 1)]
void MSmain(CSParam param, in payload PayLoad pay_load, out vertices VertexOut verts[64], out indices uint3 tris[124], out primitives PrimitiveOut prims[124])
{
    uint instance_id = pay_load.InstanceIndices[param.GroupID.x];
    uint meshlet_id = pay_load.MeshletIndices[param.GroupID.x];
    
    Instance instance = InstanceBuffer[instance_id];
    Meshlet meshlet = MeshletBuffer[instance.mesh_id][meshlet_id];
    
    uint meshlet_vertices_count = meshlet.vertex_count;
    uint meshlet_triangle_count = meshlet.triangle_count;
    
    SetMeshOutputCounts(meshlet_vertices_count, meshlet_triangle_count);
    
    for (uint i = param.GroupThreadID.x; i < meshlet_vertices_count; i += 32)
    {
        uint vertex_id = MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + i];
        
#ifdef HAS_SKINNED
        SkinnedVertex vertex = VertexBuffer[instance.mesh_id][vertex_id];
        
        if (instance.animation_id != ~0U)
        {
            uint bone_count = 0;
            uint bone_stride = 0;
            BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
            float4 total_position = 0.f;
            for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
            {
                if (vertex.bones[i] == -1)
                {
                    continue;
                }
                if (vertex.bones[i] >= bone_count)
                {
                    total_position = float4(vertex.position, 1.0f);
                    break;
                }
                float4 local_position = mul(BoneMatrices[instance.animation_id][vertex.bones[i]], float4(vertex.position, 1.0f));
                total_position += local_position * vertex.weights[i];
            }
            verts[i].Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(total_position.xyz, 1.0)));
        }
        else
        {
            verts[i].Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(vertex.position.xyz, 1.0)));
        }
        
        verts[i].Texcoord = vertex.texcoord0.xy;
#else
        Vertex vertex = VertexBuffer[instance.mesh_id][vertex_id];
        
        verts[i].Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(vertex.position.xyz, 1.0)));
        verts[i].Texcoord = vertex.texcoord0.xy;
#endif
    }
    
    for (uint i = param.GroupThreadID.x; i < meshlet_triangle_count; i += 32)
    {
        uint primitive_id = MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + meshlet.vertex_count + i];
        
        prims[i].InstanceID = instance_id;
        prims[i].PrimitiveID = primitive_id;
        
        uint v0, v1, v2;
        UnPackTriangle(MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + meshlet.vertex_count + meshlet.triangle_count + i], v0, v1, v2);
        
        tris[i] = uint3(v0, v1, v2);
    }
}

uint PSmain(VertexOut vert, PrimitiveOut prim) : SV_TARGET0
{
    return PackVisibilityBuffer(
#ifdef HAS_SKINNED
        SKINNED_MESH_TYPE,
#else
        MESH_TYPE,
#endif
        prim.InstanceID, 
        prim.PrimitiveID);
}

void VSmain(in VertexIn vert_in, out VertexOut vert_out, out PrimitiveOut prim)
{
    Instance instance = InstanceBuffer[vert_in.InstanceID];
    
#ifdef HAS_SKINNED
    if (instance.animation_id != ~0U)
    {
        uint bone_count = 0;
        uint bone_stride = 0;
        BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
        float4 total_position = 0.f;
        for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
        {
            int bone = -1;
            float weight = 0.f;
            
            if (i < 4)
            {
                bone = vert_in.Bones0[i];
                weight = vert_in.Weights0[i];
            }
            else
            {
                bone = vert_in.Bones1[i - 4];
                weight = vert_in.Weights1[i - 4];
            }
            
            if (bone == -1)
            {
                continue;
            }
            if (bone >= bone_count)
            {
                total_position = float4(vert_in.Position, 1.0f);
                break;
            }

            float4 local_position = mul(BoneMatrices[instance.animation_id][bone], float4(vert_in.Position, 1.0f));
            total_position += local_position * weight;
        }
        vert_out.Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(total_position.xyz, 1.0)));
    }
    else
    {
        vert_out.Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(vert_in.Position.xyz, 1.0)));
    }
#else
    vert_out.Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(vert_in.Position.xyz, 1.0)));
#endif
    
    vert_out.Texcoord = vert_in.Texcoord0.xy;
    vert_out.InstanceID = vert_in.InstanceID;
}

uint FSmain(VertexOut vert, uint PrimitiveID : SV_PrimitiveID) : SV_Target0
{
    return PackVisibilityBuffer(
#ifdef HAS_SKINNED
        SKINNED_MESH_TYPE,
#else
        MESH_TYPE,
#endif
        vert.InstanceID,
        PrimitiveID);
}

================================================
FILE: Source/Shaders/RenderPath/VisibilityLightingPass.hlsl
================================================
#include "../Common.hlsli"
#include "../Random.hlsli"
#include "../SphericalHarmonic.hlsli"

#define PREFILTER_MIP_LEVELS 5

#ifndef RUNTIME
#define HAS_MESH
#define HAS_SKINNED_MESH
#define HAS_POINT_LIGHT
#define HAS_SPOT_LIGHT
#define HAS_DIRECTIONAL_LIGHT
#define HAS_RECT_LIGHT
#define HAS_ENV_LIGHT
#define HAS_SHADOW_MAP
#define HAS_CASCADE_SHADOW_MAP
#define HAS_OMNI_SHADOW_MAP
#define HAS_IRRADIANCE_SH
#define HAS_PREFILTER_MAP
#define SHADOW_FILTER_NONE
#define SHADOW_FILTER_HARD
#define SHADOW_FILTER_PCF
#define SHADOW_FILTER_PCSS
#endif

Texture2D<uint> VisibilityBuffer;
Texture2D<float> DepthBuffer;

#ifdef HAS_MESH
StructuredBuffer<Instance> MeshInstanceBuffer;
#endif
#ifdef HAS_SKINNED_MESH
StructuredBuffer<Instance> SkinnedMeshInstanceBuffer;
#endif

RWStructuredBuffer<uint> MaterialCountBuffer;

[numthreads(8, 8, 1)]
void CollectMaterialCount(CSParam param)
{
    uint2 dispatch_id = param.DispatchThreadID.xy;
    
    uint2 extent;
    VisibilityBuffer.GetDimensions(extent.x, extent.y);
    
    if (dispatch_id.x >= extent.x ||
        dispatch_id.y >= extent.y ||
        DepthBuffer.Load(int3(dispatch_id, 0)).r > 3e38f)
    {
        return;
    }
    
    uint mesh_type, instance_id, primitive_id;
    UnPackVisibilityBuffer(VisibilityBuffer.Load(uint3(dispatch_id, 0)), mesh_type, instance_id, primitive_id);
    
    uint material_id = ~0;
#ifdef HAS_MESH
    if (mesh_type == MESH_TYPE)
    {
        material_id = MeshInstanceBuffer.Load(instance_id).material_id;
    }
#endif
#ifdef HAS_SKINNED_MESH
    if (mesh_type == SKINNED_MESH_TYPE)
    {
        material_id = SkinnedMeshInstanceBuffer.Load(instance_id).material_id;
    }
#endif
    
    if (material_id != ~0)
    {
        uint temp = 0;
        InterlockedAdd(MaterialCountBuffer[material_id], 1, temp);
    }
}

RWStructuredBuffer<uint> MaterialOffsetBuffer;

groupshared uint shared_data[256];

[numthreads(128, 1, 1)]
void CalculateMaterialOffset(CSParam param)
{
    uint id = param.GroupThreadID.x;
    
    uint material_count, temp;
    MaterialCountBuffer.GetDimensions(material_count, temp);
    
    uint range = (1u << (uint(log2(material_count)) + 1u));
    
    if (id < material_count)
    {
        shared_data[id] = MaterialCountBuffer[id];
    }
    else
    {
        shared_data[id] = 0;
    }
    
    GroupMemoryBarrierWithGroupSync();
    
    if (id >= range - 1)
    {
        return;
    }
    
    uint steps = uint(log2(id + 1)) + 1u;
    
    for (uint step = 0; step < steps; step++)
    {
        uint rd_id = range - 2u - id;
        uint wd_id = range - 2u - id + (1u << step);
        shared_data[wd_id] += shared_data[rd_id];
        GroupMemoryBarrierWithGroupSync();
    }
    
    if (id < material_count - 1)
    {
        MaterialOffsetBuffer[id + 1] = shared_data[id];
    }
}

RWStructuredBuffer<DispatchIndirectCommand> IndirectCommandBuffer;
RWStructuredBuffer<uint> MaterialPixelBuffer;

[numthreads(8, 8, 1)]
void CalculatePixelBuffer(CSParam param)
{
    uint2 dispatch_id = param.DispatchThreadID.xy;
    
    uint2 extent;
    VisibilityBuffer.GetDimensions(extent.x, extent.y);
    
    if (DepthBuffer.Load(int3(dispatch_id, 0)).r >= 3e38f ||
        dispatch_id.x >= extent.x ||
        dispatch_id.y >= extent.y)
    {
        return;
    }
    
    uint mesh_type, instance_id, primitive_id;
    UnPackVisibilityBuffer(VisibilityBuffer.Load(uint3(dispatch_id, 0)), mesh_type, instance_id, primitive_id);
    
    uint material_id = ~0;
    
#ifdef HAS_MESH
    if (mesh_type == MESH_TYPE)
    {
        material_id = MeshInstanceBuffer.Load(instance_id).material_id;
    }
#endif
    
#ifdef HAS_SKINNED_MESH
    if (mesh_type == SKINNED_MESH_TYPE)
    {
        material_id = SkinnedMeshInstanceBuffer.Load(instance_id).material_id;
    }
#endif
    
    uint idx;
    InterlockedAdd(IndirectCommandBuffer[material_id].x, 1, idx);
    MaterialPixelBuffer[idx + MaterialOffsetBuffer[material_id]] = PackXY(dispatch_id.x, dispatch_id.y);
}

[numthreads(8, 1, 1)]
void CalculateIndirectArgument(CSParam param)
{
    uint dispatch_id = param.DispatchThreadID.x;
    
    uint material_count, temp;
    IndirectCommandBuffer.GetDimensions(material_count, temp);
    
    if (dispatch_id >= material_count)
    {
        return;
    }
    
    IndirectCommandBuffer[dispatch_id].x = (IndirectCommandBuffer[dispatch_id].x + 8 - 1) / 8;
    IndirectCommandBuffer[dispatch_id].y = 1;
    IndirectCommandBuffer[dispatch_id].z = 1;
}

#ifndef DISPATCH_INDIRECT
#define MATERIAL_ID 0
#include "../Material/Material.hlsli"
#endif

#include "../Light.hlsli"

RWTexture2D<float4> LightDirectIllumination;
RWTexture2D<float4> EnvDirectIllumination;
RWTexture2D<float4> PositionDepth;
RWTexture2D<float4> NormalRoughness;
RWTexture2D<float4> AlbedoMetallic;

ConstantBuffer<View> ViewBuffer;
ConstantBuffer<LightInfo> LightInfoBuffer;

#if defined(HAS_SHADOW_MAP) || defined(HAS_CASCADE_SHADOW_MAP) || defined(HAS_OMNI_SHADOW_MAP)
SamplerState ShadowMapSampler;
#endif

#ifdef HAS_POINT_LIGHT
StructuredBuffer<PointLight> PointLightBuffer;
#ifdef HAS_OMNI_SHADOW_MAP
TextureCubeArray<float> PointLightShadow;
#endif
#endif

#ifdef HAS_SPOT_LIGHT
StructuredBuffer<SpotLight> SpotLightBuffer;
#ifdef HAS_SHADOW_MAP
Texture2DArray<float> SpotLightShadow;
#endif
#endif

#ifdef HAS_DIRECTIONAL_LIGHT
StructuredBuffer<DirectionalLight> DirectionalLightBuffer;
#ifdef HAS_CASCADE_SHADOW_MAP
Texture2DArray<float> DirectionalLightShadow;
#endif
#endif

#ifdef HAS_RECT_LIGHT
StructuredBuffer<RectLight> RectLightBuffer;
#endif

#ifdef HAS_MESH
StructuredBuffer<Vertex> MeshVertexBuffer[];
StructuredBuffer<uint> MeshIndexBuffer[];
#endif

#ifdef HAS_SKINNED_MESH
StructuredBuffer<SkinnedVertex> SkinnedMeshVertexBuffer[];
StructuredBuffer<uint> SkinnedMeshIndexBuffer[];
StructuredBuffer<float4x4> BoneMatrices[];
#endif

#ifdef HAS_ENV_LIGHT
#ifdef HAS_IRRADIANCE_SH
RWTexture2D<float4> IrradianceSH;
#endif
#ifdef HAS_PREFILTER_MAP
SamplerState PrefilterMapSampler;
TextureCube<float4> PrefilterMap;
Texture2D<float2> GGXPreintegration;
#endif
#endif

uint hash(uint a)
{
    a = (a + 0x7ed55d16) + (a << 12);
    a = (a ^ 0xc761c23c) ^ (a >> 19);
    a = (a + 0x165667b1) + (a << 5);
    a = (a + 0xd3a2646c) ^ (a << 9);
    a = (a + 0xfd7046c5) + (a << 3);
    a = (a ^ 0xb55a4f09) ^ (a >> 16);
    return a;
}

float3 GetColor(uint v)
{
    uint mhash = hash(v);
    return float3(float(mhash & 255), float((mhash >> 8) & 255), float((mhash >> 16) & 255)) / 255.0;
}

void CalculateBarycentre(float4x4 transform, float2 pixel, uint2 extent, float3 v0, float3 v1, float3 v2, out float3 bary, out float3 bary_ddx, out float3 bary_ddy)
{
    float4 clip_pos0 = mul(ViewBuffer.view_projection_matrix, mul(transform, float4(v0.xyz, 1.0)));
    float4 clip_pos1 = mul(ViewBuffer.view_projection_matrix, mul(transform, float4(v1.xyz, 1.0)));
    float4 clip_pos2 = mul(ViewBuffer.view_projection_matrix, mul(transform, float4(v2.xyz, 1.0)));
        
    float2 p0 = clip_pos1.xy - clip_pos0.xy;
    float2 p1 = clip_pos0.xy - clip_pos2.xy;
        
    // Calculate barycentric
    float3 inv_w = rcp(float3(clip_pos0.w, clip_pos1.w, clip_pos2.w));
        
    float3 ndc0 = clip_pos0.xyz / clip_pos0.w;
    float3 ndc1 = clip_pos1.xyz / clip_pos1.w;
    float3 ndc2 = clip_pos2.xyz / clip_pos2.w;
    float2 ndc = (float2(pixel) + float2(0.5, 0.5)) / float2(extent);
    ndc = ndc * 2 - 1.0;
    ndc.y *= -1;
        
    float3 pos_120_x = float3(ndc1.x, ndc2.x, ndc0.x);
    float3 pos_120_y = float3(ndc1.y, ndc2.y, ndc0.y);
    float3 pos_201_x = float3(ndc2.x, ndc0.x, ndc1.x);
    float3 pos_201_y = float3(ndc2.y, ndc0.y, ndc1.y);
        
    float3 C_dx = pos_201_y - pos_120_y;
    float3 C_dy = pos_120_x - pos_201_x;
     
    float3 C = C_dx * (ndc.x - pos_120_x) + C_dy * (ndc.y - pos_120_y);
    float3 G = C * inv_w;
    
    float H = dot(C, inv_w);
    float rcpH = rcp(H);
        
    bary = G * rcpH;
        
    float3 G_dx = C_dx * inv_w;
    float3 G_dy = C_dy * inv_w;

    float H_dx = dot(C_dx, inv_w);
    float H_dy = dot(C_dy, inv_w);
        
    bary_ddx = (G_dx * H - G * H_dx) * (rcpH * rcpH) * (2.0f / float(extent.x));
    bary_ddy = (G_dy * H - G * H_dy) * (rcpH * rcpH) * (-2.0f / float(extent.y));
}

#if defined(HAS_SHADOW_MAP) || defined(HAS_CASCADE_SHADOW_MAP) || defined(HAS_OMNI_SHADOW_MAP)
float LinearizeDepth(float depth, float znear, float zfar)
{
    float z = depth * 2.0 - 1.0;
    return znear * zfar / (zfar + depth * (znear - zfar));
}

float FindBlock(Texture2DArray<float> shadowmap, float4 shadow_coord, float layer, float filter_scale, uint filter_sample)
{
    uint2 tex_dim;
    uint layers;
    shadowmap.GetDimensions(tex_dim.x, tex_dim.y, layers);

	// Find blocker
    float z_blocker = 0.0;
    float num_blockers = 0.0;
    float2 offset = float2(0.0, 0.0);
    for (int i = 0; i < filter_sample; i++)
    {
        offset = PoissonDiskSamples2D(shadow_coord.xy + offset, filter_sample, 10, i);
        offset = offset * filter_scale / float2(tex_dim);
        float dist = shadowmap.SampleLevel(ShadowMapSampler, float3(shadow_coord.xy + offset, layer), 0.0).r;
        if (dist < shadow_coord.z)
        {
            num_blockers += 1.0;
            z_blocker += dist;
        }
    }

    if (num_blockers == 0.0)
    {
        return 0.0;
    }

    return num_blockers == 0.0 ? 0.0 : z_blocker / num_blockers;
}

float FindBlockCube(TextureCubeArray<float> shadowmap, float3 L, float layer, float filter_scale, uint filter_sample)
{
    uint2 tex_dim;
    uint layers;
    shadowmap.GetDimensions(tex_dim.x, tex_dim.y, layers);

    float light_depth = length(L);

	// Find blocker
    float z_blocker = 0.0;
    float num_blockers = 0.0;
    float disk_radius = filter_scale / float(max(tex_dim.x, tex_dim.y));
    float3 offset = float3(0.0, 0.0, 0.0);
    
    int x = int(sqrt(filter_sample));
    int y = filter_sample / x;
    for (int i = 0; i < x; i++)
    {
        for (int j = 0; j < y; j++)
        {
            // Poisson sampling
            offset = PoissonDiskSamples3D(L + offset, x * y, 10, float2(i, j)) * disk_radius;
            float dist = shadowmap.SampleLevel(ShadowMapSampler, float4(L + offset, layer), 0.0).r;
            if (light_depth > dist)
            {
                num_blockers += 1.0;
                z_blocker += dist;
            }
        }
    }

    if (num_blockers == 0.0)
    {
        return 0.0;
    }

    return num_blockers == 0.0 ? 0.0 : z_blocker / num_blockers;
}

// Sample shadow map
float SampleShadowmap(Texture2DArray<float> shadowmap, float4 shadow_coord, float layer, float2 offset)
{
    float shadow = 1.0;

    if (shadow_coord.z > -1.0 && shadow_coord.z < 1.0)
    {
        float dist = shadowmap.SampleLevel(ShadowMapSampler, float3(shadow_coord.xy + offset, layer), 0.0).r;
        if (shadow_coord.w > 0.0 && dist < shadow_coord.z)
        {
            shadow = 0.0;
        }
    }
    return shadow;
}

// Sample shadow map via PCF
float SampleShadowmapPCF(Texture2DArray<float> shadowmap, float4 shadow_coord, float layer, uint filter_sample, float filter_scale)
{
    uint2 tex_dim;
    uint layers;
    shadowmap.GetDimensions(tex_dim.x, tex_dim.y, layers);

    float shadow_factor = 0.0;

    float2 offset = float2(0.0, 0.0);
    for (int i = 0; i < filter_sample; i++)
    {
        offset = PoissonDiskSamples2D(shadow_coord.xy + offset, filter_sample, 10, i);
        offset = offset * filter_scale / float2(tex_dim);
        shadow_factor += SampleShadowmap(shadowmap, shadow_coord, layer, offset);
    }

    return shadow_factor / float(filter_sample);
}

// Sample shadow map via PCSS
float SampleShadowmapPCSS(Texture2DArray<float> shadowmap, float4 shadow_coord, float layer, uint filter_sample, float filter_scale, float light_scale)
{
    uint2 tex_dim;
    uint layers;
    shadowmap.GetDimensions(tex_dim.x, tex_dim.y, layers);

    float z_receiver = shadow_coord.z * shadow_coord.w;

	// Penumbra size
    float z_blocker = LinearizeDepth(FindBlock(shadowmap, shadow_coord, layer, filter_scale, filter_sample), 0.01, 1000.0);
    float w_light = 0.1;
    float w_penumbra = (z_receiver - z_blocker) * light_scale / z_blocker;

	// Filtering
    float shadow_factor = 0.0;
    float2 offset = float2(0.0, 0.0);
    for (int i = 0; i < filter_sample; i++)
    {
        offset = PoissonDiskSamples2D(shadow_coord.xy + offset, filter_sample, 10, i);
        offset = offset * w_penumbra / float2(tex_dim);
        shadow_factor += SampleShadowmap(shadowmap, shadow_coord, layer, offset);
    }

    return shadow_factor / float(filter_sample);
}

// Sample shadow cubemap
float SampleShadowmapCube(TextureCubeArray<float> shadowmap, float3 L, float layer, float3 offset)
{
    float shadow = 1.0;
    float light_depth = length(L);
    L.z = -L.z;
	// Reconstruct depth
    float dist = shadowmap.SampleLevel(ShadowMapSampler, float4(L + offset, layer), 0.0).r;
    dist *= 100.0;

    if (light_depth > dist)
    {
        shadow = 0.0;
    }

    return shadow;
}

// Sample shadow cubemap via PCF
float SampleShadowmapCubePCF(TextureCubeArray<float> shadowmap, float3 L, float layer, float filter_scale, uint filter_sample)
{
    uint2 tex_dim;
    uint layers;
    shadowmap.GetDimensions(tex_dim.x, tex_dim.y, layers);

    float shadow_factor = 0.0;
    float light_depth = length(L);

    float disk_radius = filter_scale / float(max(tex_dim.x, tex_dim.y));

    float3 offset = float3(0.0, 0.0, 0.0);
    int count = 0;
    int x = int(sqrt(filter_sample));
    int y = filter_sample / x;
    count = x * y;
    for (int i = 0; i < x; i++)
    {
        for (int j = 0; j < y; j++)
        {
            // Poisson sampling
            offset = PoissonDiskSamples3D(L + offset, count, 10, float2(i, j)) * disk_radius;
            shadow_factor += SampleShadowmapCube(shadowmap, L, layer, offset);
        }
    }
    return shadow_factor / float(count);
}

// Sample shadow cubemap via PCSS
float SampleShadowmapCubePCSS(TextureCubeArray<float> shadowmap, float3 L, float layer, float filter_scale, uint filter_sample, float light_scale)
{
    uint2 tex_dim;
    uint layers;
    shadowmap.GetDimensions(tex_dim.x, tex_dim.y, layers);

    float light_depth = length(L);
    float z_receiver = light_depth;

	// Penumbra size
    float z_blocker = LinearizeDepth(FindBlockCube(shadowmap, L, layer, filter_scale, filter_sample), 0.01, 1000.0);
    float w_light = 0.1;
    float w_penumbra = (z_receiver - z_blocker) * light_scale / z_blocker;

	// Filtering
    float shadow_factor = 0.0;
    float3 offset = float3(0.0, 0.0, 0.0);
    float disk_radius = filter_scale / float(max(tex_dim.x, tex_dim.y));
    int count = 0;
    int x = int(sqrt(filter_sample));
    int y = filter_sample / x;
    count = x * y;
    for (int i = 0; i < x; i++)
    {
        for (int j = 0; j < y; j++)
        {
            // Poisson sampling
            offset = PoissonDiskSamples3D(L + offset, count, 10, float2(i, j)) * w_penumbra / float(tex_dim.x);
            shadow_factor += SampleShadowmapCube(shadowmap, L, layer, offset);
        }
    }
    return shadow_factor / float(filter_sample);
}
#endif

#ifdef HAS_POINT_LIGHT
float CalculatePointLightShadow(PointLight light, uint idx, SurfaceInteraction interaction)
{
    float3 L = interaction.isect.p - light.position;
    
#ifdef HAS_OMNI_SHADOW_MAP
#ifdef SHADOW_FILTER_NONE
    return 1.f;
#endif
    
#ifdef SHADOW_FILTER_HARD
    return SampleShadowmapCube(PointLightShadow, L, idx, float3(0.0, 0.0, 0.0));
#endif
    
#ifdef SHADOW_FILTER_PCF
    return SampleShadowmapCubePCF(PointLightShadow, L, idx, light.filter_scale, light.filter_sample);
#endif
    
#ifdef SHADOW_FILTER_PCSS
    return SampleShadowmapCubePCSS(PointLightShadow, L, idx, light.filter_scale, light.filter_sample, light.light_scale);
#endif
    
#else
    return 1.f;
#endif
}
#endif

#ifdef HAS_SPOT_LIGHT
float CalculateSpotLightShadow(SpotLight light, uint idx, SurfaceInteraction interaction)
{
    float4 shadow_clip = mul(light.view_projection, float4(interaction.isect.p, 1.0));
    float4 shadow_coord = float4(shadow_clip.xyz / shadow_clip.w, shadow_clip.w);
    shadow_coord.xy = shadow_coord.xy * 0.5 + 0.5;
    shadow_coord.y = 1.0 - shadow_coord.y;

#ifdef HAS_OMNI_SHADOW_MAP
#ifdef SHADOW_FILTER_NONE
    return 1.f;
#endif
    
#ifdef SHADOW_FILTER_HARD
    return SampleShadowmap(SpotLightShadow, shadow_coord, idx, float2(0.0, 0.0));
#endif
    
#ifdef SHADOW_FILTER_PCF
    return SampleShadowmapPCF(SpotLightShadow, shadow_coord, idx, light.filter_sample, light.filter_scale);
#endif
    
#ifdef SHADOW_FILTER_PCSS
    return SampleShadowmapPCSS(SpotLightShadow, shadow_coord, idx, light.filter_sample, light.filter_scale, light.light_scale);
#endif
    
#else
    return 1.f;
#endif
}
#endif

#ifdef HAS_DIRECTIONAL_LIGHT
float CalculateDirectionalLightShadow(DirectionalLight light, uint idx, SurfaceInteraction interaction, float linear_z)
{
    float shadow = 1.f;
    
    linear_z = mul(ViewBuffer.view_projection_matrix, float4(interaction.isect.p, 1.f)).z;
    
    uint cascade_index = 0;
	// Select cascade
    for (uint i = 0; i < 3; ++i)
    {
        if (light.split_depth[i] > -linear_z)
        {
            cascade_index = i + 1;
        }
    }

    float4 shadow_clip = mul(light.view_projection[cascade_index], float4(interaction.isect.p, 1.0));
    float4 shadow_coord = float4(shadow_clip.xyz / shadow_clip.w, shadow_clip.w);
    shadow_coord.xy = shadow_coord.xy * 0.5 + 0.5;
    shadow_coord.y = 1.0 - shadow_coord.y;

    uint layer = idx * 4 + cascade_index;
    
#ifdef HAS_CASCADE_SHADOW_MAP
#ifdef SHADOW_FILTER_NONE
    return 1.f;
#endif
    
#ifdef SHADOW_FILTER_HARD
    return SampleShadowmap(DirectionalLightShadow, shadow_coord, idx * 4 + cascade_index, float2(0.0, 0.0));
#endif
    
#ifdef SHADOW_FILTER_PCF
    return SampleShadowmapPCF(DirectionalLightShadow, shadow_coord, idx * 4 + cascade_index, light.filter_sample, light.filter_scale);
#endif
    
#ifdef SHADOW_FILTER_PCSS
    return SampleShadowmapPCSS(DirectionalLightShadow, shadow_coord, idx * 4 + cascade_index, light.filter_sample, light.filter_scale, light.light_scale);
#endif

#else
    return 1.f;
#endif
}
#endif

[numthreads(8, 1, 1)]
void DispatchIndirect(CSParam param)
{
    uint id = param.DispatchThreadID.x;
    uint offset = MaterialOffsetBuffer.Load(MATERIAL_ID);
    uint count = MaterialCountBuffer.Load(MATERIAL_ID);
    
    if (id >= count)
    {
        return;
    }
    
    uint2 extent;
    VisibilityBuffer.GetDimensions(extent.x, extent.y);
    
    uint2 pixel;
    UnpackXY(MaterialPixelBuffer.Load(id + offset), pixel.x, pixel.y);
    
    uint instance_id, primitive_id, mesh_type;
    UnPackVisibilityBuffer(VisibilityBuffer.Load(uint3(pixel, 0)), mesh_type, instance_id, primitive_id);
    
    SurfaceInteraction interaction;
    
    float3 bary, bary_ddx, bary_ddy;
    
    float linear_z = 0.f;
    
#ifdef HAS_MESH
    if (mesh_type == MESH_TYPE)
    {
        Instance instance = MeshInstanceBuffer.Load(instance_id);
        uint mesh_id = instance.mesh_id;
        
        Vertex v0 = MeshVertexBuffer[mesh_id][MeshIndexBuffer[mesh_id][primitive_id * 3]];
        Vertex v1 = MeshVertexBuffer[mesh_id][MeshIndexBuffer[mesh_id][primitive_id * 3 + 1]];
        Vertex v2 = MeshVertexBuffer[mesh_id][MeshIndexBuffer[mesh_id][primitive_id * 3 + 2]];
        
        CalculateBarycentre(instance.transform, pixel, extent, v0.position, v1.position, v2.position, bary, bary_ddx, bary_ddy);
        
        interaction.isect.p = v0.position.xyz * bary.x + v1.position.xyz * bary.y + v2.position.xyz * bary.z;
        linear_z = mul(ViewBuffer.view_matrix, mul(instance.transform, float4(interaction.isect.p, 1.0))).z;
        interaction.isect.p = mul(instance.transform, float4(interaction.isect.p, 1.0)).xyz;
        interaction.isect.uv = v0.texcoord0.xy * bary.x + v1.texcoord0.xy * bary.y + v2.texcoord0.xy * bary.z;
        interaction.isect.n = v0.normal.xyz * bary.x + v1.normal.xyz * bary.y + v2.normal.xyz * bary.z;
        interaction.isect.n = normalize(mul((float3x3) instance.transform, normalize(interaction.isect.n)));
        interaction.isect.nt = v0.tangent.xyz * bary.x + v1.tangent.xyz * bary.y + v2.tangent.xyz * bary.z;
        interaction.isect.nt = normalize(mul((float3x3) instance.transform, normalize(interaction.isect.nt)).xyz);
        interaction.isect.wo = normalize(ViewBuffer.position - interaction.isect.p);
        interaction.shading_n = dot(interaction.isect.n, interaction.isect.wo) <= 0 ? -interaction.isect.n : interaction.isect.n;
        interaction.isect.t = length(ViewBuffer.position - interaction.isect.p);
        interaction.material = instance.material_id;
        interaction.duvdx = v0.texcoord0.xy * bary_ddx.x + v1.texcoord0.xy * bary_ddx.y + v2.texcoord0.xy * bary_ddx.z;
        interaction.duvdy = v0.texcoord0.xy * bary_ddy.x + v1.texcoord0.xy * bary_ddy.y + v2.texcoord0.xy * bary_ddy.z;
    }
#endif
    
#ifdef HAS_SKINNED_MESH
    if (mesh_type == SKINNED_MESH_TYPE)
    {
        Instance instance = SkinnedMeshInstanceBuffer.Load(instance_id);
        uint mesh_id = instance.mesh_id;
        
        SkinnedVertex v[3];
        
        v[0] = SkinnedMeshVertexBuffer[mesh_id][SkinnedMeshIndexBuffer[mesh_id][primitive_id * 3]];
        v[1] = SkinnedMeshVertexBuffer[mesh_id][SkinnedMeshIndexBuffer[mesh_id][primitive_id * 3 + 1]];
        v[2] = SkinnedMeshVertexBuffer[mesh_id][SkinnedMeshIndexBuffer[mesh_id][primitive_id * 3 + 2]];
        
        float3 position[3];
        float3 normal[3];
        float3 tangent[3];
        
        if (instance.animation_id != ~0U)
        {
            uint bone_count = 0;
            uint bone_stride = 0;
            BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
            for (uint v_idx = 0; v_idx < 3; v_idx++)
            {
                position[v_idx] = 0.f;
                normal[v_idx] = 0.f;
                tangent[v_idx] = 0.f;
                
                for (uint bone_idx = 0; bone_idx < MAX_BONE_INFLUENCE; bone_idx++)
                {
                    int bone = v[v_idx].bones[bone_idx];
                    float weight = v[v_idx].weights[bone_idx];
            
                    if (bone == -1)
                    {
                        continue;
                    }
                    
                    if (bone >= bone_count)
                    {
                        position[v_idx] = v[v_idx].position;
                        normal[v_idx] = v[v_idx].normal;
                        tangent[v_idx] = v[v_idx].tangent;
                        break;
                    }

                    position[v_idx] += mul(BoneMatrices[instance.animation_id][bone], float4(v[v_idx].position, 1.0f)).xyz * weight;
                    normal[v_idx] += mul((float3x3) BoneMatrices[instance.animation_id][bone], v[v_idx].normal) * weight;
                    tangent[v_idx] += mul((float3x3) BoneMatrices[instance.animation_id][bone], v[v_idx].tangent) * weight;
                }
            }
        }
        else
        {
            for (uint v_idx = 0; v_idx < 3; v_idx++)
            {
                position[v_idx] = v[v_idx].position;
                normal[v_idx] = v[v_idx].normal;
                tangent[v_idx] = v[v_idx].tangent;
            }
        }
        
        CalculateBarycentre(instance.transform, pixel, extent, position[0], position[1], position[2], bary, bary_ddx, bary_ddy);
        
        interaction.isect.p = position[0].xyz * bary.x + position[1].xyz * bary.y + position[2].xyz * bary.z;
        linear_z = mul(ViewBuffer.view_matrix, mul(instance.transform, float4(interaction.isect.p, 1.0))).z;
        interaction.isect.p = mul(instance.transform, float4(interaction.isect.p, 1.0)).xyz;
        interaction.isect.uv = v[0].texcoord0.xy * bary.x + v[1].texcoord0.xy * bary.y + v[2].texcoord0.xy * bary.z;
        interaction.isect.n = normal[0].xyz * bary.x + normal[1].xyz * bary.y + normal[2].xyz * bary.z;
        interaction.isect.n = normalize(mul((float3x3) instance.transform, normalize(interaction.isect.n)));
        interaction.isect.nt = tangent[0].xyz * bary.x + tangent[1].xyz * bary.y + tangent[2].xyz * bary.z;
        interaction.isect.nt = normalize(mul((float3x3) instance.transform, normalize(interaction.isect.nt)).xyz);
        interaction.isect.wo = normalize(ViewBuffer.position - interaction.isect.p);
        interaction.shading_n = dot(interaction.isect.n, interaction.isect.wo) <= 0 ? -interaction.isect.n : interaction.isect.n;
        interaction.isect.t = length(ViewBuffer.position - interaction.isect.p);
        interaction.material = instance.material_id;
        interaction.duvdx = v[0].texcoord0.xy * bary_ddx.x + v[1].texcoord0.xy * bary_ddx.y + v[2].texcoord0.xy * bary_ddx.z;
        interaction.duvdy = v[0].texcoord0.xy * bary_ddy.x + v[1].texcoord0.xy * bary_ddy.y + v[2].texcoord0.xy * bary_ddy.z;
    }
#endif
    
    Material material;
    material.Init(interaction);
    
    GBufferData g_buffer_data = material.bsdf.GetGBufferData();
    
    float3 radiance = g_buffer_data.emissive;
    float3 ambient = 0.f;
    
    LightSampleContext li_ctx;
    li_ctx.n = interaction.isect.n;
    li_ctx.ns = interaction.shading_n;
    li_ctx.p = interaction.isect.p;
    
    // Handle point light DI
#ifdef HAS_POINT_LIGHT
    uint point_light_id = 0;
    for (uint i = 0; i < LightInfoBuffer.point_light_count; i++)
    {
        PointLight light = PointLightBuffer.Load(i);
        LightLiSample light_sample = light.SampleLi(li_ctx, 0.f);
        float3 f = material.bsdf.Eval(interaction.isect.wo, light_sample.wi, TransportMode_Radiance);
        float3 color = f * light_sample.L;
        if (light.cast_shadow)
        {
            color *= CalculatePointLightShadow(light, light.shadow_id, interaction);
            point_light_id++;
        }
        radiance += color;

    }
#endif
    
    // Handle spot light DI
#ifdef HAS_SPOT_LIGHT
    uint spot_light_id = 0;
    for (uint i = 0; i < LightInfoBuffer.spot_light_count; i++)
    {
        SpotLight light = SpotLightBuffer.Load(i);
        LightLiSample light_sample = light.SampleLi(li_ctx, 0.f);
        float3 f = material.bsdf.Eval(interaction.isect.wo, light_sample.wi, TransportMode_Radiance);
        float3 color = f * light_sample.L;
        if (light.cast_shadow)
        {
            color *= CalculateSpotLightShadow(light, light.shadow_id, interaction);
            spot_light_id++;
        }
        radiance += color;
    }
#endif
    
    // Handle directional light DI
#ifdef HAS_DIRECTIONAL_LIGHT
    uint directional_light_id = 0;
    for (uint i = 0; i < LightInfoBuffer.directional_light_count; i++)
    {
        DirectionalLight light = DirectionalLightBuffer.Load(i);
        LightLiSample light_sample = light.SampleLi(li_ctx, 0.f);
        float3 f = material.bsdf.Eval(interaction.isect.wo, light_sample.wi, TransportMode_Radiance);
        float3 color = f * light_sample.L;
        if (light.cast_shadow)
        {
            color *= CalculateDirectionalLightShadow(light, light.shadow_id, interaction, linear_z);
            directional_light_id++;
        }
        radiance += color;
    }
#endif
    
#ifdef HAS_ENV_LIGHT
    {
#ifdef HAS_IRRADIANCE_SH
        float3 F0 = float3(0.0, 0.0, 0.0);
        F0 = lerp(F0, g_buffer_data.albedo.rgb, g_buffer_data.metallic);
        float3 F = F0 + (max(float3(1.0 - g_buffer_data.roughness, 1.0 - g_buffer_data.roughness, 1.0 - g_buffer_data.roughness), F0) * pow(1.0 - max(dot(g_buffer_data.normal, interaction.isect.wo), 0.0), 5.0));
        float3 Kd = (1.0 - F) * (1.0 - g_buffer_data.metallic);

        float3 irradiance = float3(0.0, 0.0, 0.0);
        SH9 basis = EvaluateSH(g_buffer_data.normal);
        for (uint i = 0; i < 9; i++)
        {
            irradiance += IrradianceSH[uint2(i, 0)].rgb * basis.weights[i];
        }
        irradiance = max(float3(0.0, 0.0, 0.0), irradiance) * InvPI;
        
        float3 diffuse = irradiance * g_buffer_data.albedo.rgb;
        ambient += Kd * diffuse;
#endif

#ifdef  HAS_PREFILTER_MAP
        float3 prefiltered_color = PrefilterMap.SampleLevel(PrefilterMapSampler, reflect(-interaction.isect.wo, g_buffer_data.normal), g_buffer_data.roughness * PREFILTER_MIP_LEVELS).rgb;
        float2 brdf = GGXPreintegration.SampleLevel(PrefilterMapSampler, float2(clamp(dot(g_buffer_data.normal, interaction.isect.wo), 0.0, 1.0), g_buffer_data.roughness), 0.0).rg;
        float3 specular = prefiltered_color * (F * brdf.x + brdf.y);
        ambient += specular;
#endif
    }
#endif
    
    // Clamp toxic pixel
    float lum = Luminance(radiance);
    if (lum > 4.f)
    {
        radiance *= 4.f / lum;
    }
    
    EnvDirectIllumination[pixel] = float4(ambient, 1.f);
    LightDirectIllumination[pixel] = float4(radiance, 1.f);
    PositionDepth[pixel] = float4(interaction.isect.p, linear_z);
    NormalRoughness[pixel] = float4(g_buffer_data.normal * 0.5f + 0.5f, g_buffer_data.roughness);
    AlbedoMetallic[pixel] = float4(g_buffer_data.albedo, g_buffer_data.metallic);
}

================================================
FILE: Source/Shaders/Shading/Composite.hlsl
================================================
#include "../Common.hlsli"

RWTexture2D<float4> Output;

#ifndef RUNTIME
#define HAS_LIGHT_DIRECT_ILLUMINATION
#define HAS_ENV_DIRECT_ILLUMINATION
#define HAS_AMBIENT_OCCLUSION
#define HAS_ENVIRONMENT
#endif

#ifdef HAS_AMBIENT_OCCLUSION
Texture2D<float> AmbientOcclusion;
#endif

#ifdef HAS_LIGHT_DIRECT_ILLUMINATION
Texture2D<float4> LightDirectIllumination;
#endif

#ifdef HAS_ENV_DIRECT_ILLUMINATION
Texture2D<float4> EnvDirectIllumination;
#endif

#ifdef HAS_ENVIRONMENT
Texture2D<float4> Environment;
#endif

[numthreads(8, 8, 1)]
void CSmain(CSParam param)
{
    uint2 extent;
    Output.GetDimensions(extent.x, extent.y);
    
    if (param.DispatchThreadID.x >= extent.x ||
        param.DispatchThreadID.y >= extent.y)
    {
        return;
    }
    
    float3 result = 0.f;
    float3 environment = 0.f;
#ifdef HAS_ENVIRONMENT
    environment = Environment[param.DispatchThreadID.xy].xyz;
#endif
    
    if (IsBlack(environment))
    {
#ifdef HAS_LIGHT_DIRECT_ILLUMINATION
        result += LightDirectIllumination[param.DispatchThreadID.xy].xyz;
#endif
        
#ifdef HAS_ENV_DIRECT_ILLUMINATION
        float3 env_direct_illumination = EnvDirectIllumination[param.DispatchThreadID.xy].xyz;
#ifdef HAS_AMBIENT_OCCLUSION
        env_direct_illumination *= AmbientOcclusion[param.DispatchThreadID.xy].r;
#endif
        result += env_direct_illumination;
#endif
    }
    else
    {
        result += environment;
    }
    
    Output[param.DispatchThreadID.xy] = float4(result, 1.f);
}

================================================
FILE: Source/Shaders/Shading/IBL.hlsl
================================================
#include "../Common.hlsli"
#include "../SphericalHarmonic.hlsli"

#define POSITIVE_X 0
#define NEGATIVE_X 1
#define POSITIVE_Y 2
#define NEGATIVE_Y 3
#define POSITIVE_Z 4
#define NEGATIVE_Z 5

#define LOCAL_SIZE 8

#define SH_INTERMEDIATE_SIZE 128 / 8
#define CUBEMAP_FACE_NUM 6
#define PREFILTER_MAP_SIZE 256
#define PREFILTER_MIP_LEVELS 5
#define SAMPLE_COUNT 1024

struct Config
{
    uint2 extent;
};

ConstantBuffer<Config> ConfigBuffer;
RWTexture2DArray<float4> SHIntermediate;
TextureCube Skybox;
SamplerState SkyboxSampler;

groupshared SH9Color projection_shared_sh_coeffs[LOCAL_SIZE][LOCAL_SIZE];
groupshared float projection_shared_weights[LOCAL_SIZE][LOCAL_SIZE];

[numthreads(LOCAL_SIZE, LOCAL_SIZE, 1)]
void CubemapSHProjection(CSParam param)
{
    for (uint i = 0; i < 9; i++)
    {
        projection_shared_sh_coeffs[param.GroupThreadID.x][param.GroupThreadID.y].weights[i] = float3(0.0, 0.0, 0.0);
    }

    GroupMemoryBarrier();
    
    uint2 extent = { 128, 128 };

    SH9 basis;

    float3 dir = CalculateCubemapDirection(param.DispatchThreadID.z, param.DispatchThreadID.x, param.DispatchThreadID.y, extent.x, extent.y);
    float solid_angle = CalculateSolidAngle(param.DispatchThreadID.x, param.DispatchThreadID.y, extent.x, extent.y);
    float3 texel = Skybox.SampleLevel(SkyboxSampler, dir, 0.0).rgb;

    basis = ProjectSH9(dir);

    projection_shared_weights[param.GroupThreadID.x][param.GroupThreadID.y] = solid_angle;

    for (uint i = 0; i < 9; i++)
    {
        projection_shared_sh_coeffs[param.GroupThreadID.x][param.GroupThreadID.y].weights[i] += texel * basis.weights[i] * solid_angle;
    }

    GroupMemoryBarrier();

	// Add up all coefficients and weights along the X axis
    if (param.GroupThreadID.x == 0)
    {
        for (int i = 1; i < LOCAL_SIZE; i++)
        {
            projection_shared_weights[0][param.GroupThreadID.y] += projection_shared_weights[i][param.GroupThreadID.y];
            for (int j = 0; j < 9; j++)
            {
                projection_shared_sh_coeffs[0][param.GroupThreadID.y].weights[j] += projection_shared_sh_coeffs[i][param.GroupThreadID.y].weights[j];
            }
        }
    }

    GroupMemoryBarrier();

	// Add up all coefficients and weights along the Y axis
    if (param.GroupThreadID.x == 0 && param.GroupThreadID.y == 0)
    {
        for (int i = 1; i < LOCAL_SIZE; i++)
        {
            projection_shared_weights[0][0] += projection_shared_weights[0][i];
            for (int j = 0; j < 9; j++)
            {
                projection_shared_sh_coeffs[0][0].weights[j] += projection_shared_sh_coeffs[0][i].weights[j];
            }
        }

        for (int j = 0; j < 9; j++)
        {
            int3 p = int3(extent.x / LOCAL_SIZE * j + param.DispatchThreadID.x / LOCAL_SIZE, param.DispatchThreadID.y / LOCAL_SIZE, param.DispatchThreadID.z);
            
            SHIntermediate[p] = float4(projection_shared_sh_coeffs[0][0].weights[j], projection_shared_weights[0][0]);
        }
    }
}

RWTexture2D<float4> IrradianceSH;

groupshared float3 add_shared_sh_coeffs[SH_INTERMEDIATE_SIZE][CUBEMAP_FACE_NUM];
groupshared float add_shared_weights[SH_INTERMEDIATE_SIZE][CUBEMAP_FACE_NUM];

[numthreads(1, SH_INTERMEDIATE_SIZE, CUBEMAP_FACE_NUM)]
void CubemapSHAdd(CSParam param)
{
    add_shared_sh_coeffs[param.DispatchThreadID.y][param.DispatchThreadID.z] = float3(0.0, 0.0, 0.0);
    add_shared_weights[param.DispatchThreadID.y][param.DispatchThreadID.z] = 0.0;

    GroupMemoryBarrier();

    for (uint i = 0; i < SH_INTERMEDIATE_SIZE; i++)
    {
        uint3 p = uint3(param.DispatchThreadID.x * SH_INTERMEDIATE_SIZE + i, param.DispatchThreadID.y, param.DispatchThreadID.z);
        float4 val = SHIntermediate[p];
        add_shared_sh_coeffs[param.DispatchThreadID.y][param.DispatchThreadID.z] += val.rgb;
        add_shared_weights[param.DispatchThreadID.y][param.DispatchThreadID.z] += val.a;
    }

    GroupMemoryBarrier();

    if (param.DispatchThreadID.z == 0)
    {
        for (uint i = 1; i < CUBEMAP_FACE_NUM; i++)
        {
            add_shared_sh_coeffs[param.DispatchThreadID.y][0] += add_shared_sh_coeffs[param.DispatchThreadID.y][i];
            add_shared_weights[param.DispatchThreadID.y][0] += add_shared_weights[param.DispatchThreadID.y][i];
        }
    }

    GroupMemoryBarrier();

    if (param.DispatchThreadID.y == 0 && param.DispatchThreadID.z == 0)
    {
        for (uint i = 0; i < SH_INTERMEDIATE_SIZE; i++)
        {
            add_shared_sh_coeffs[0][0] += add_shared_sh_coeffs[i][0];
            add_shared_weights[0][0] += add_shared_weights[i][0];
        }

        float scale = (4.0 * PI) / add_shared_weights[0][0];

        IrradianceSH[int2(param.DispatchThreadID.x, 0)] = float4(add_shared_sh_coeffs[0][0] * scale, add_shared_weights[0][0]);
    }
}

RWTexture2DArray<float4> PrefilterMap;

float3 CalculateDirection(uint face_idx, uint face_x, uint face_y, uint2 extent)
{
    float u = 2.0 * (float(face_x) + 0.5) / float(extent.x) - 1.0;
    float v = 2.0 * (float(face_y) + 0.5) / float(extent.y) - 1.0;
    float x, y, z;

    switch (face_idx)
    {
        case POSITIVE_X:
            x = 1;
            y = -v;
            z = -u;
            break;
        case NEGATIVE_X:
            x = -1;
            y = -v;
            z = u;
            break;
        case POSITIVE_Y:
            x = u;
            y = 1;
            z = v;
            break;
        case NEGATIVE_Y:
            x = u;
            y = -1;
            z = -v;
            break;
        case POSITIVE_Z:
            x = u;
            y = -v;
            z = 1;
            break;
        case NEGATIVE_Z:
            x = -u;
            y = -v;
            z = -1;
            break;
    }
	
    return normalize(float3(x, y, z));
}

float GGX(float3 N, float3 H, float roughness)
{
    float a = roughness * roughness;
    float a2 = a * a;
    float NoH = max(dot(N, H), 0.f);
    float NoH2 = NoH * NoH;
    float nom = a2;
    float denom = (NoH2 * (a2 - 1.f) + 1.f);
    denom = PI * denom * denom;
    return nom / denom;
}

float3 GGXImportanceSampling(float2 Xi, float3 N, float roughness)
{
    float a = roughness * roughness;

    float phi = 2.0 * PI * Xi.x;
    float cos_theta = sqrt((1.f - Xi.y) / (1.f + (a * a - 1.f) * Xi.y));
    float sin_theta = sqrt(1.f - cos_theta * cos_theta);

    float3 H = float3(
        cos(phi) * sin_theta,
        sin(phi) * sin_theta,
        cos_theta);

    float3 Up = N.z > 0.999 ? float3(0.0, 1.0, 0.0) : float3(0.0, 0.0, 1.0);
    float3 T = normalize(cross(N, Up));
    float3 B = normalize(cross(N, T));

    return T * H.x + B * H.y + N * H.z;
}

float RadicalInverse_VdC(uint bits)
{
    bits = (bits << 16u) | (bits >> 16u);
    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
    return float(bits) * 2.3283064365386963e-10; // / 0x100000000
}

float2 Hammersley(uint i, uint N)
{
    return float2(float(i) / float(N), RadicalInverse_VdC(i));
}

[numthreads(LOCAL_SIZE, LOCAL_SIZE, 1)]
void CubmapPrefilter(CSParam param)
{
    uint2 extent;
    uint layers;
    PrefilterMap.GetDimensions(extent.x, extent.y, layers);
    
    float3 colors[5] = {
        float3(0, 0, 0),
        float3(1, 0, 0),
        float3(0, 1, 0),
        float3(0, 0, 1),
        float3(1, 1, 1),
    };
    
    uint level = log2(PREFILTER_MAP_SIZE / extent.x);
    float roughness = float(level) / float(PREFILTER_MIP_LEVELS - 1);
    
    if (param.DispatchThreadID.x >= extent.x ||
        param.DispatchThreadID.y >= extent.y)
    {
        return;
    }
    
    uint2 size;
    Skybox.GetDimensions(size.x, size.y);
    uint resolution = size.x;
    
    float3 N = CalculateDirection(param.DispatchThreadID.z, param.DispatchThreadID.x, param.DispatchThreadID.y, extent);
    float3 R = N;
    float3 V = R;

    float3 prefilter_color = float3(0.0, 0.0, 0.0);
    float total_weight = 0.0;

    for (uint i = 0; i < SAMPLE_COUNT; i++)
    {
        float2 Xi = Hammersley(i, SAMPLE_COUNT);
        float3 H = GGXImportanceSampling(Xi, N, roughness);
        float3 L = normalize(2.0 * dot(V, H) * H - V);

        float NoL = max(dot(N, L), 0.0);
        if (NoL > 0.0)
        {
            float D = GGX(N, H, roughness);
            float NoH = max(dot(N, H), 0.f);
            float HoV = max(dot(H, V), 0.f);
            float pdf = D * NoH / (4 * HoV) + 0.0001;
            
            float texel_ = 4.f * PI / (6.f * resolution * resolution);
            float sample_ = 1.f / (float(SAMPLE_COUNT) * pdf + 0.0001f);
            
            float mip_level = (roughness == 0.0 ? 0.0 : 0.5f * log2(sample_ / texel_));
            
            prefilter_color += Skybox.SampleLevel(SkyboxSampler, L, mip_level).rgb * NoL;
            total_weight += NoL;
        }
    }

    prefilter_color /= total_weight;
    PrefilterMap[int3(param.DispatchThreadID.xyz)] = float4(prefilter_color, 1.0);
    //PrefilterMap[int3(param.DispatchThreadID.xyz)] = float4(colors[level], 1.0);
}

================================================
FILE: Source/Shaders/Shading/Skybox.hlsl
================================================
#include "Common.hlsli"

ConstantBuffer<View> ViewBuffer;
TextureCube Skybox;
SamplerState SkyboxSampler;

struct VSInput
{
    uint VertexID : SV_VertexID;
};

struct VSOutput
{
    float4 Pos : SV_Position;
    float3 UVW : POSITION0;
};

struct PSInput
{
    float3 UVW : POSITION0;
};

struct PSOutput
{
    float4 Color : SV_Target0;
};

// A cube
static const float3 vertices[] =
{
    { -1.0, -1.0, -1.0 }, // bottom-left
    { 1.0, 1.0, -1.0 }, // top-right
    { 1.0, -1.0, -1.0 }, // bottom-right
    { 1.0, 1.0, -1.0 }, // top-right
    { -1.0, -1.0, -1.0 }, // bottom-left
    { -1.0, 1.0, -1.0 }, // top-left
	                                  // front face
    { -1.0, -1.0, 1.0 }, // bottom-left
    { 1.0, -1.0, 1.0 }, // bottom-right
    { 1.0, 1.0, 1.0 }, // top-right
    { 1.0, 1.0, 1.0 }, // top-right
    { -1.0, 1.0, 1.0 }, // top-left
    { -1.0, -1.0, 1.0 }, // bottom-left
	                                  // left face
    { -1.0, 1.0, 1.0 }, // top-right
    { -1.0, 1.0, -1.0 }, // top-left
    { -1.0, -1.0, -1.0 }, // bottom-left
    { -1.0, -1.0, -1.0 }, // bottom-left
    { -1.0, -1.0, 1.0 }, // bottom-right
    { -1.0, 1.0, 1.0 }, // top-right
	                                  // right face
    { 1.0, 1.0, 1.0 }, // top-left
    { 1.0, -1.0, -1.0 }, // bottom-right
    { 1.0, 1.0, -1.0 }, // top-right
    { 1.0, -1.0, -1.0 }, // bottom-right
    { 1.0, 1.0, 1.0 }, // top-left
    { 1.0, -1.0, 1.0 }, // bottom-left
	                                  // bottom face
    { -1.0, -1.0, -1.0 }, // top-right
    { 1.0, -1.0, -1.0 }, // top-left
    { 1.0, -1.0, 1.0 }, // bottom-left
    { 1.0, -1.0, 1.0 }, // bottom-left
    { -1.0, -1.0, 1.0 }, // bottom-right
    { -1.0, -1.0, -1.0 }, // top-right
	                                  // top face
    { -1.0, 1.0, -1.0 }, // top-left
    { 1.0, 1.0, 1.0 }, // bottom-right
    { 1.0, 1.0, -1.0 }, // top-right
    { 1.0, 1.0, 1.0 }, // bottom-right
    { -1.0, 1.0, -1.0 }, // top-left
    { -1.0, 1.0, 1.0 }, // bottom-left
};

VSOutput VSmain(VSInput input)
{
    VSOutput output;
    output.UVW = vertices[input.VertexID];
    output.Pos = mul(ViewBuffer.view_projection_matrix, float4(output.UVW + ViewBuffer.position, 1.0)).xyww;
    return output;
}

PSOutput PSmain(PSInput input)
{
    PSOutput output;
    output.Color = float4(Skybox.Sample(SkyboxSampler, input.UVW).rgb, 1.0);
    return output;
}

================================================
FILE: Source/Shaders/Shadow/CascadeShadowMap.hlsl
================================================
#include "../Common.hlsli"
#include "../Light.hlsli"

StructuredBuffer<Instance> InstanceBuffer;
StructuredBuffer<Meshlet> MeshletBuffer[];
StructuredBuffer<uint> MeshletDataBuffer[];
StructuredBuffer<uint> IndexBuffer[];
StructuredBuffer<DirectionalLight> DirectionalLightBuffer;
ConstantBuffer<LightInfo> LightInfoBuffer;

#ifdef HAS_SKINNED
StructuredBuffer<SkinnedVertex> VertexBuffer[];
StructuredBuffer<float4x4> BoneMatrices[];

struct VertexIn
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    int4 Bones0 : BLENDINDICES0;
    int4 Bones1 : BLENDINDICES1;
    float4 Weights0 : BLENDWEIGHT0;
    float4 Weights1 : BLENDWEIGHT1;
    uint InstanceID : SV_InstanceID;
};
#else
StructuredBuffer<Vertex> VertexBuffer[];

struct VertexIn
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    uint InstanceID : SV_InstanceID;
};
#endif

struct VertexOut
{
    float4 Position : SV_Position;
    uint InstanceID : COLOR0;
};

struct PrimitiveOut
{
    uint Layer : SV_RenderTargetArrayIndex;
};

struct PayLoad
{
    uint MeshletIndices[32];
    uint InstanceIndices[32];
    uint LayerIndices[32];
};

groupshared PayLoad s_payload;

[numthreads(32, 1, 1)]
void ASmain(CSParam param)
{
    bool visible = false;
    
    uint meshlet_id = param.DispatchThreadID.x;
    uint instance_id = param.DispatchThreadID.y;
    uint layer_id = param.DispatchThreadID.z;
    
    uint instance_count = 0;
    uint instance_stride = 0;
    InstanceBuffer.GetDimensions(instance_count, instance_stride);
    
    if (layer_id / 4 >= LightInfoBuffer.directional_light_count)
    {
        return;
    }
    
    DirectionalLight light = DirectionalLightBuffer[layer_id / 4];
    
    if (!light.cast_shadow)
    {
        return;
    }
    
    if (instance_id < instance_count)
    {
        Instance instance = InstanceBuffer[instance_id];
        
        uint meshlet_count = 0;
        uint meshlet_stride = 0;
        MeshletBuffer[instance.mesh_id].GetDimensions(meshlet_count, meshlet_stride);
        
        if (meshlet_id < meshlet_count)
        {
#ifdef HAS_SKINNED
            visible = true;
#else
            Meshlet meshlet = MeshletBuffer[instance.mesh_id][meshlet_id];
            float4 frustum[6];
            CalculateFrustum(light.view_projection[layer_id % 4], frustum);
            visible = IsInsideFrustum(meshlet, instance.transform, frustum, meshlet.center - light.direction);
#endif
        }
    }

    if (visible)
    {
        uint index = WavePrefixCountBits(visible);
        s_payload.InstanceIndices[index] = instance_id;
        s_payload.MeshletIndices[index] = meshlet_id;
        s_payload.LayerIndices[index] = layer_id;
    }
    
    uint visible_count = WaveActiveCountBits(visible);
    
    DispatchMesh(visible_count, 1, 1, s_payload);
}

[outputtopology("triangle")]
[numthreads(32, 1, 1)]
void MSmain(CSParam param, in payload PayLoad pay_load, out vertices VertexOut verts[64], out indices uint3 tris[124], out primitives PrimitiveOut prims[124])
{
    uint instance_id = pay_load.InstanceIndices[param.GroupID.x];
    uint meshlet_id = pay_load.MeshletIndices[param.GroupID.x];
    uint layer_id = pay_load.LayerIndices[param.GroupID.x];
    uint light_id = layer_id / 4;
    
    Instance instance = InstanceBuffer[instance_id];
    Meshlet meshlet = MeshletBuffer[instance.mesh_id][meshlet_id];
    DirectionalLight light = DirectionalLightBuffer[light_id];
    
    uint meshlet_vertices_count = meshlet.vertex_count;
    uint meshlet_triangle_count = meshlet.triangle_count;
    
    SetMeshOutputCounts(meshlet_vertices_count, meshlet_triangle_count);
    
    for (uint i = param.GroupThreadID.x; i < meshlet_vertices_count; i += 32)
    {
        uint vertex_id = MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + i];
        
#ifdef HAS_SKINNED
        SkinnedVertex vertex = VertexBuffer[instance.mesh_id][vertex_id];
        
        if (instance.animation_id != ~0U)
        {
            uint bone_count = 0;
            uint bone_stride = 0;
            BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
            float4 total_position = 0.f;
            for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
            {
                if (vertex.bones[i] == -1)
                {
                    continue;
                }
                if (vertex.bones[i] >= bone_count)
                {
                    total_position = float4(vertex.position, 1.0f);
                    break;
                }
                float4 local_position = mul(BoneMatrices[instance.animation_id][vertex.bones[i]], float4(vertex.position, 1.0f));
                total_position += local_position * vertex.weights[i];
            }
            verts[i].Position = mul(light.view_projection[layer_id % 4], mul(instance.transform, float4(total_position.xyz, 1.0)));
        }
        else
        {
            verts[i].Position = mul(light.view_projection[layer_id % 4], mul(instance.transform, float4(vertex.position.xyz, 1.0)));
        }
#else
        Vertex vertex = VertexBuffer[instance.mesh_id][vertex_id];
        
        verts[i].Position = mul(light.view_projection[layer_id % 4], mul(instance.transform, float4(vertex.position.xyz, 1.0)));
#endif
    }
    
    for (uint i = param.GroupThreadID.x; i < meshlet_triangle_count; i += 32)
    {
        uint v0, v1, v2;
        UnPackTriangle(MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + meshlet.vertex_count + meshlet.triangle_count + i], v0, v1, v2);
        
        tris[i] = uint3(v0, v1, v2);
        prims[i].Layer = light.shadow_id * 4 + layer_id % 4;
    }
}

void PSmain(VertexOut vert)
{
}

void VSmain(in VertexIn vert_in, out VertexOut vert_out)
{
    Instance instance = InstanceBuffer[vert_in.InstanceID];
    
#ifdef HAS_SKINNED
    if (instance.animation_id != ~0U)
    {
        uint bone_count = 0;
        uint bone_stride = 0;
        BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
        float4 total_position = 0.f;
        for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
        {
            int bone = -1;
            float weight = 0.f;
            
            if (i < 4)
            {
                bone = vert_in.Bones0[i];
                weight = vert_in.Weights0[i];
            }
            else
            {
                bone = vert_in.Bones1[i - 4];
                weight = vert_in.Weights1[i - 4];
            }
            
            if (bone == -1)
            {
                continue;
            }
            if (bone >= bone_count)
            {
                total_position = float4(vert_in.Position, 1.0f);
                break;
            }

            float4 local_position = mul(BoneMatrices[instance.animation_id][bone], float4(vert_in.Position, 1.0f));
            total_position += local_position * weight;
        }
        //vert_out.Position = mul(ViewBuffer.view_projection, mul(instance.transform, float4(total_position.xyz, 1.0)));
    }
    else
    {
       // vert_out.Position = mul(ViewBuffer.view_projection, mul(instance.transform, float4(vert_in.Position.xyz, 1.0)));
    }
#else
    //vert_out.Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(vert_in.Position.xyz, 1.0)));
#endif
}

void FSmain(VertexOut vert, uint PrimitiveID : SV_PrimitiveID)
{
}

================================================
FILE: Source/Shaders/Shadow/OmniShadowMap.hlsl
================================================
#include "../Common.hlsli"
#include "../Light.hlsli"

StructuredBuffer<Instance> InstanceBuffer;
StructuredBuffer<Meshlet> MeshletBuffer[];
StructuredBuffer<uint> MeshletDataBuffer[];
StructuredBuffer<uint> IndexBuffer[];
StructuredBuffer<PointLight> PointLightBuffer;
ConstantBuffer<LightInfo> LightInfoBuffer;

static const float4x4 ViewProjection[6] =
{
    float4x4(
        0, 0, 1.0001999, 1,
        0, 1, 0, 0,
        1, 0, 0, 0,
        0, 0, -0.20002, 0
    ),
    float4x4(
        0, 0, -1.0001999, -1,
        0, 1, 0, 0,
        -1, 0, 0, 0,
        0, 0, -0.20002, 0
    ),
    float4x4(
        1, 0, 0, 0,
        0, 0, 1.0001999, 1,
        0, 1, 0, 0,
        0, 0, -0.20002, 0
    ),
    float4x4(
        1, 0, 0, 0,
        0, 0, -1.0001999, -1,
        0, -1, 0, 0,
        0, 0, -0.20002, 0
    ),
    float4x4(
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, -1.0001999, -1,
        0, 0, -0.20002, 0
    ),
    float4x4(
        -1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1.0001999, 1,
        0, 0, -0.20002, 0
    ),
};

#ifdef HAS_SKINNED
StructuredBuffer<SkinnedVertex> VertexBuffer[];
StructuredBuffer<float4x4> BoneMatrices[];

struct VertexIn
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    int4 Bones0 : BLENDINDICES0;
    int4 Bones1 : BLENDINDICES1;
    float4 Weights0 : BLENDWEIGHT0;
    float4 Weights1 : BLENDWEIGHT1;
    uint InstanceID : SV_InstanceID;
};
#else
StructuredBuffer<Vertex> VertexBuffer[];

struct VertexIn
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    uint InstanceID : SV_InstanceID;
};
#endif

struct VertexOut
{
    float4 Position : SV_Position;
    float3 Pos : POSITION0;
    float3 LightPos : POSITION1;
    uint InstanceID : COLOR0;
};

struct PrimitiveOut
{
    uint Layer : SV_RenderTargetArrayIndex;
};

struct PayLoad
{
    uint MeshletIndices[32];
    uint InstanceIndices[32];
    uint LayerIndices[32];
};

groupshared PayLoad s_payload;

[numthreads(32, 1, 1)]
void ASmain(CSParam param)
{
    bool visible = false;
    
    uint meshlet_id = param.DispatchThreadID.x;
    uint instance_id = param.DispatchThreadID.y;
    uint layer_id = param.DispatchThreadID.z;
    
    uint instance_count = 0;
    uint instance_stride = 0;
    InstanceBuffer.GetDimensions(instance_count, instance_stride);
    
    if (layer_id / 6 >= LightInfoBuffer.point_light_count)
    {
        return;
    }
    
    PointLight light = PointLightBuffer[layer_id / 6];
    
    if (!light.cast_shadow)
    {
        return;
    }
    
    if (instance_id < instance_count)
    {
        Instance instance = InstanceBuffer[instance_id];
        
        uint meshlet_count = 0;
        uint meshlet_stride = 0;
        MeshletBuffer[instance.mesh_id].GetDimensions(meshlet_count, meshlet_stride);
        
        if (meshlet_id < meshlet_count)
        {
#ifdef HAS_SKINNED
            visible = true;
#else
            Meshlet meshlet = MeshletBuffer[instance.mesh_id][meshlet_id];
            float4 frustum[6];
            CalculateFrustum(transpose(ViewProjection[layer_id % 6]), frustum);
            visible = IsInsideFrustum(meshlet, instance.transform, frustum, light.position, light.position);
#endif
        }
    }

    if (visible)
    {
        uint index = WavePrefixCountBits(visible);
        s_payload.InstanceIndices[index] = instance_id;
        s_payload.MeshletIndices[index] = meshlet_id;
        s_payload.LayerIndices[index] = layer_id;
    }
    
    uint visible_count = WaveActiveCountBits(visible);
    
    DispatchMesh(visible_count, 1, 1, s_payload);
}

[outputtopology("triangle")]
[numthreads(32, 1, 1)]
void MSmain(CSParam param, in payload PayLoad pay_load, out vertices VertexOut verts[64], out indices uint3 tris[124], out primitives PrimitiveOut prims[124])
{
    uint instance_id = pay_load.InstanceIndices[param.GroupID.x];
    uint meshlet_id = pay_load.MeshletIndices[param.GroupID.x];
    uint layer_id = pay_load.LayerIndices[param.GroupID.x];
    uint light_id = layer_id / 6;
    
    Instance instance = InstanceBuffer[instance_id];
    Meshlet meshlet = MeshletBuffer[instance.mesh_id][meshlet_id];
    PointLight light = PointLightBuffer[light_id];
    
    uint meshlet_vertices_count = meshlet.vertex_count;
    uint meshlet_triangle_count = meshlet.triangle_count;
    
    SetMeshOutputCounts(meshlet_vertices_count, meshlet_triangle_count);
    
    for (uint i = param.GroupThreadID.x; i < meshlet_vertices_count; i += 32)
    {
        uint vertex_id = MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + i];
        
        verts[i].LightPos = light.position;
        
#ifdef HAS_SKINNED
        SkinnedVertex vertex = VertexBuffer[instance.mesh_id][vertex_id];
        
        if (instance.animation_id != ~0U)
        {
            uint bone_count = 0;
            uint bone_stride = 0;
            BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
            float4 total_position = 0.f;
            for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
            {
                if (vertex.bones[i] == -1)
                {
                    continue;
                }
                if (vertex.bones[i] >= bone_count)
                {
                    total_position = float4(vertex.position, 1.0f);
                    break;
                }
                float4 local_position = mul(BoneMatrices[instance.animation_id][vertex.bones[i]], float4(vertex.position, 1.0f));
                total_position += local_position * vertex.weights[i];
            }
            verts[i].Pos = mul(instance.transform, float4(total_position.xyz, 1.0)).xyz;
            verts[i].Position = mul(transpose(ViewProjection[layer_id % 6]), float4(mul(instance.transform, float4(total_position.xyz, 1.0)).xyz - light.position, 1.f));
        }
        else
        {
            verts[i].Pos = mul(instance.transform, float4(vertex.position.xyz, 1.0)).xyz;
            verts[i].Position = mul(transpose(ViewProjection[layer_id % 6]), float4(mul(instance.transform, float4(vertex.position.xyz, 1.0)).xyz - light.position, 1.f));
        }
#else
        Vertex vertex = VertexBuffer[instance.mesh_id][vertex_id];
        verts[i].Pos = mul(instance.transform, float4(vertex.position.xyz, 1.0)).xyz;
        verts[i].Position = mul(transpose(ViewProjection[layer_id % 6]), float4(mul(instance.transform, float4(vertex.position.xyz, 1.0)).xyz - light.position, 1.f));
#endif
    }
    
    for (uint i = param.GroupThreadID.x; i < meshlet_triangle_count; i += 32)
    {
        uint v0, v1, v2;
        UnPackTriangle(MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + meshlet.vertex_count + meshlet.triangle_count + i], v0, v1, v2);
        
        tris[i] = uint3(v0, v1, v2);
        prims[i].Layer = light.shadow_id * 6 + layer_id % 6;
    }
}

float PSmain(VertexOut vert) : SV_Depth
{
    return (length(vert.Pos.xyz - vert.LightPos.xyz) + 0.01) / 100.0;
}

void VSmain(in VertexIn vert_in, out VertexOut vert_out)
{
    Instance instance = InstanceBuffer[vert_in.InstanceID];
    
#ifdef HAS_SKINNED
    if (instance.animation_id != ~0U)
    {
        uint bone_count = 0;
        uint bone_stride = 0;
        BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
        float4 total_position = 0.f;
        for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
        {
            int bone = -1;
            float weight = 0.f;
            
            if (i < 4)
            {
                bone = vert_in.Bones0[i];
                weight = vert_in.Weights0[i];
            }
            else
            {
                bone = vert_in.Bones1[i - 4];
                weight = vert_in.Weights1[i - 4];
            }
            
            if (bone == -1)
            {
                continue;
            }
            if (bone >= bone_count)
            {
                total_position = float4(vert_in.Position, 1.0f);
                break;
            }

            float4 local_position = mul(BoneMatrices[instance.animation_id][bone], float4(vert_in.Position, 1.0f));
            total_position += local_position * weight;
        }
        //vert_out.Position = mul(ViewBuffer.view_projection, mul(instance.transform, float4(total_position.xyz, 1.0)));
    }
    else
    {
       // vert_out.Position = mul(ViewBuffer.view_projection, mul(instance.transform, float4(vert_in.Position.xyz, 1.0)));
    }
#else
    //vert_out.Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(vert_in.Position.xyz, 1.0)));
#endif
}

void FSmain(VertexOut vert, uint PrimitiveID : SV_PrimitiveID)
{
}

================================================
FILE: Source/Shaders/Shadow/RayTracedShadow.hlsl
================================================


================================================
FILE: Source/Shaders/Shadow/ShadowMap.hlsl
================================================
#include "../Common.hlsli"
#include "../Light.hlsli"

StructuredBuffer<Instance> InstanceBuffer;
StructuredBuffer<Meshlet> MeshletBuffer[];
StructuredBuffer<uint> MeshletDataBuffer[];
StructuredBuffer<uint> IndexBuffer[];
StructuredBuffer<SpotLight> SpotLightBuffer;
ConstantBuffer<LightInfo> LightInfoBuffer;

#ifdef HAS_SKINNED
StructuredBuffer<SkinnedVertex> VertexBuffer[];
StructuredBuffer<float4x4> BoneMatrices[];

struct VertexIn
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    int4 Bones0 : BLENDINDICES0;
    int4 Bones1 : BLENDINDICES1;
    float4 Weights0 : BLENDWEIGHT0;
    float4 Weights1 : BLENDWEIGHT1;
    uint InstanceID : SV_InstanceID;
};
#else
StructuredBuffer<Vertex> VertexBuffer[];

struct VertexIn
{
    float3 Position : POSITION0;
    float3 Normal : NORMAL0;
    float3 Tangent : TANGENT0;
    float2 Texcoord0 : TEXCOORD0;
    float2 Texcoord1 : TEXCOORD1;
    uint InstanceID : SV_InstanceID;
};
#endif

struct VertexOut
{
    float4 Position : SV_Position;
    uint InstanceID : COLOR0;
};

struct PrimitiveOut
{
    uint Layer : SV_RenderTargetArrayIndex;
};

struct PayLoad
{
    uint MeshletIndices[32];
    uint InstanceIndices[32];
    uint LightIndices[32];
};

groupshared PayLoad s_payload;

[numthreads(32, 1, 1)]
void ASmain(CSParam param)
{
    bool visible = false;
    
    uint meshlet_id = param.DispatchThreadID.x;
    uint instance_id = param.DispatchThreadID.y;
    uint light_id = param.DispatchThreadID.z;
    
    if (light_id >= LightInfoBuffer.spot_light_count)
    {
        return;
    }
    
    SpotLight light = SpotLightBuffer[light_id];
    
    if(!light.cast_shadow)
    {
        return;
    }
    
    uint instance_count = 0;
    uint instance_stride = 0;
    InstanceBuffer.GetDimensions(instance_count, instance_stride);
    
    if (instance_id < instance_count)
    {
        Instance instance = InstanceBuffer[instance_id];
        
        uint meshlet_count = 0;
        uint meshlet_stride = 0;
        MeshletBuffer[instance.mesh_id].GetDimensions(meshlet_count, meshlet_stride);
        
        if (meshlet_id < meshlet_count)
        {
#ifdef HAS_SKINNED
            visible = true;
#else
            Meshlet meshlet = MeshletBuffer[instance.mesh_id][meshlet_id];
            float4 frustum[6];
            CalculateFrustum(light.view_projection, frustum);
            visible = IsInsideFrustum(meshlet, instance.transform, frustum, light.position);
           // visible = true;
#endif
        }
    }

    if (visible)
    {
        uint index = WavePrefixCountBits(visible);
        s_payload.InstanceIndices[index] = instance_id;
        s_payload.MeshletIndices[index] = meshlet_id;
        s_payload.LightIndices[index] = light_id;
    }
    
    uint visible_count = WaveActiveCountBits(visible);
    
    DispatchMesh(visible_count, 1, 1, s_payload);
}

[outputtopology("triangle")]
[numthreads(32, 1, 1)]
void MSmain(CSParam param, in payload PayLoad pay_load, out vertices VertexOut verts[64], out indices uint3 tris[124], out primitives PrimitiveOut prims[124])
{
    uint instance_id = pay_load.InstanceIndices[param.GroupID.x];
    uint meshlet_id = pay_load.MeshletIndices[param.GroupID.x];
    uint light_id = pay_load.LightIndices[param.GroupID.x];
    
    Instance instance = InstanceBuffer[instance_id];
    Meshlet meshlet = MeshletBuffer[instance.mesh_id][meshlet_id];
    SpotLight light = SpotLightBuffer[light_id];
    
    uint meshlet_vertices_count = meshlet.vertex_count;
    uint meshlet_triangle_count = meshlet.triangle_count;
    
    SetMeshOutputCounts(meshlet_vertices_count, meshlet_triangle_count);
    
    for (uint i = param.GroupThreadID.x; i < meshlet_vertices_count; i += 32)
    {
        uint vertex_id = MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + i];
        
#ifdef HAS_SKINNED
        SkinnedVertex vertex = VertexBuffer[instance.mesh_id][vertex_id];
        
        if (instance.animation_id != ~0U)
        {
            uint bone_count = 0;
            uint bone_stride = 0;
            BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
            float4 total_position = 0.f;
            for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
            {
                if (vertex.bones[i] == -1)
                {
                    continue;
                }
                if (vertex.bones[i] >= bone_count)
                {
                    total_position = float4(vertex.position, 1.0f);
                    break;
                }
                float4 local_position = mul(BoneMatrices[instance.animation_id][vertex.bones[i]], float4(vertex.position, 1.0f));
                total_position += local_position * vertex.weights[i];
            }
            verts[i].Position = mul(light.view_projection, mul(instance.transform, float4(total_position.xyz, 1.0)));
        }
        else
        {
            verts[i].Position = mul(light.view_projection, mul(instance.transform, float4(vertex.position.xyz, 1.0)));
        }
#else
        Vertex vertex = VertexBuffer[instance.mesh_id][vertex_id];
        
        verts[i].Position = mul(light.view_projection, mul(instance.transform, float4(vertex.position.xyz, 1.0)));
#endif
    }
    
    for (uint i = param.GroupThreadID.x; i < meshlet_triangle_count; i += 32)
    {
        uint v0, v1, v2;
        UnPackTriangle(MeshletDataBuffer[instance.mesh_id][meshlet.data_offset + meshlet.vertex_count + meshlet.triangle_count + i], v0, v1, v2);
        
        tris[i] = uint3(v0, v1, v2);
        prims[i].Layer = light.shadow_id;
    }
}

void PSmain(VertexOut vert)
{
}

void VSmain(in VertexIn vert_in, out VertexOut vert_out)
{
    Instance instance = InstanceBuffer[vert_in.InstanceID];
    
#ifdef HAS_SKINNED
    if (instance.animation_id != ~0U)
    {
        uint bone_count = 0;
        uint bone_stride = 0;
        BoneMatrices[instance.animation_id].GetDimensions(bone_count, bone_stride);
            
        float4 total_position = 0.f;
        for (uint i = 0; i < MAX_BONE_INFLUENCE; i++)
        {
            int bone = -1;
            float weight = 0.f;
            
            if (i < 4)
            {
                bone = vert_in.Bones0[i];
                weight = vert_in.Weights0[i];
            }
            else
            {
                bone = vert_in.Bones1[i - 4];
                weight = vert_in.Weights1[i - 4];
            }
            
            if (bone == -1)
            {
                continue;
            }
            if (bone >= bone_count)
            {
                total_position = float4(vert_in.Position, 1.0f);
                break;
            }

            float4 local_position = mul(BoneMatrices[instance.animation_id][bone], float4(vert_in.Position, 1.0f));
            total_position += local_position * weight;
        }
        //vert_out.Position = mul(ViewBuffer.view_projection, mul(instance.transform, float4(total_position.xyz, 1.0)));
    }
    else
    {
       // vert_out.Position = mul(ViewBuffer.view_projection, mul(instance.transform, float4(vert_in.Position.xyz, 1.0)));
    }
#else
    //vert_out.Position = mul(ViewBuffer.view_projection_matrix, mul(instance.transform, float4(vert_in.Position.xyz, 1.0)));
#endif
}

void FSmain(VertexOut vert, uint PrimitiveID : SV_PrimitiveID)
{
}

================================================
FILE: Source/Shaders/SphericalHarmonic.hlsli
================================================
#ifndef __SPHERICALHARMONIC_HLSL__
#define __SPHERICALHARMONIC_HLSL__

#include "Math.hlsli"

static const float CosineA0 = PI;
static const float CosineA1 = (2.0 * PI) / 3.0;
static const float CosineA2 = PI * 0.25;

struct SH9
{
    float weights[9];
};

struct SH9Color
{
    float3 weights[9];
};

SH9 ProjectSH9(float3 dir)
{
    SH9 sh;

    sh.weights[0] = 0.282095;

    sh.weights[1] = -0.488603 * dir.y;
    sh.weights[2] = 0.488603 * dir.z;
    sh.weights[3] = -0.488603 * dir.x;

    sh.weights[4] = 1.092548 * dir.x * dir.y;
    sh.weights[5] = -1.092548 * dir.y * dir.z;
    sh.weights[7] = 0.315392 * (3.0 * dir.z * dir.z - 1.0);
    sh.weights[6] = -1.092548 * dir.x * dir.z;
    sh.weights[8] = 0.546274 * (dir.x * dir.x - dir.y * dir.y);

    return sh;
}

SH9 EvaluateSH(float3 dir)
{
    SH9 basis = ProjectSH9(dir);

    basis.weights[0] *= CosineA0;

    basis.weights[1] *= CosineA1;
    basis.weights[2] *= CosineA1;
    basis.weights[3] *= CosineA1;

    basis.weights[4] *= CosineA2;
    basis.weights[5] *= CosineA2;
    basis.weights[6] *= CosineA2;
    basis.weights[7] *= CosineA2;
    basis.weights[8] *= CosineA2;

    return basis;
}

#endif

================================================
FILE: Source/Shaders/Tonemapper.hlsli
================================================
#ifndef __TONEMAPPER_HLSL__
#define __TONEMAPPER_HLSL__

static const float GAMMA = 2.2;
static const float INV_GAMMA = 1.0 / GAMMA;

// linear to sRGB approximation
// see http://chilliant.blogspot.com/2012/08/srgb-approximations-for-hlsl.html
float3 LinearTosRGB(float3 color)
{
    return pow(color, float3(INV_GAMMA, INV_GAMMA, INV_GAMMA));
}

// sRGB to linear approximation
// see http://chilliant.blogspot.com/2012/08/srgb-approximations-for-hlsl.html
float3 sRGBToLinear(float3 srgbIn)
{
    return float3(pow(srgbIn.xyz, float3(GAMMA, GAMMA, GAMMA)));
}

float4 sRGBToLinear(float4 srgbIn)
{
    return float4(sRGBToLinear(srgbIn.xyz), srgbIn.w);
}

// Uncharted 2 tone map
// see: http://filmicworlds.com/blog/filmic-tonemapping-operators/
float3 ToneMapUncharted2Impl(float3 color)
{
    const float A = 0.15;
    const float B = 0.50;
    const float C = 0.10;
    const float D = 0.20;
    const float E = 0.02;
    const float F = 0.30;
    return ((color * (A * color + C * B) + D * E) / (color * (A * color + B) + D * F)) - E / F;
}

float3 ToneMapUncharted(float3 color)
{
    const float W = 11.2;
    color = ToneMapUncharted2Impl(color * 2.0);
    float3 whiteScale = 1.0 / ToneMapUncharted2Impl(float3(W, W, W));
    return LinearTosRGB(color * whiteScale);
}

// Hejl Richard tone map
// see: http://filmicworlds.com/blog/filmic-tonemapping-operators/
float3 ToneMapHejlRichard(float3 color)
{
    color = max(float3(0.0, 0.0, 0.0), color - float3(0.004, 0.004, 0.004));
    return (color * (6.2 * color + .5)) / (color * (6.2 * color + 1.7) + 0.06);
}

// ACES tone map
// see: https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/
float3 ToneMapACES(float3 color)
{
    const float A = 2.51;
    const float B = 0.03;
    const float C = 2.43;
    const float D = 0.59;
    const float E = 0.14;
    return LinearTosRGB(clamp((color * (A * color + B)) / (color * (C * color + D) + E), 0.0, 1.0));
}


float3 ToneMap(float3 color, float exposure)
{
    color *= exposure;

#ifdef TONEMAP_UNCHARTED
  return ToneMapUncharted(color);
#endif

#ifdef TONEMAP_HEJLRICHARD
  return ToneMapHejlRichard(color);
#endif

#ifdef TONEMAP_ACES
  return ToneMapACES(color);
#endif

    return LinearTosRGB(color);
}

#endif

================================================
FILE: Source/Shaders/UpdateBoneMatrics.hlsl
================================================
struct UpdateInfoData
{
    uint count;
    float time;
};

Texture2D<float4> SkinnedMatrics;
RWStructuredBuffer<float4x4> BoneMatrics;
ConstantBuffer<UpdateInfoData> UpdateInfo;

struct CSParam
{
    uint3 DispatchThreadID : SV_DispatchThreadID;
};

[numthreads(8, 1, 1)]
void CSmain(CSParam param)
{
    uint bone_id = param.DispatchThreadID.x;
    
    uint bone_count = 0;
    uint frame_count = 0;
    uint level_count = 0;
    SkinnedMatrics.GetDimensions(0, bone_count, frame_count, level_count);
    bone_count /= 3;
        
    if (bone_id >= bone_count)
    {
        return;
    }
    
    uint frame0 = min(uint(UpdateInfo.time * 30.f), frame_count - 1);
    uint frame1 = min(uint(UpdateInfo.time * 30.f) + 1, frame_count - 1);
        
    float4x4 mat0 = float4x4(
        SkinnedMatrics.Load(int3(bone_id * 3 + 0, frame0, 0)),
        SkinnedMatrics.Load(int3(bone_id * 3 + 1, frame0, 0)),
        SkinnedMatrics.Load(int3(bone_id * 3 + 2, frame0, 0)),
        float4(0, 0, 0, 1));

    float4x4 mat1 = float4x4(
        SkinnedMatrics.Load(int3(bone_id * 3 + 0, frame1, 0)),
        SkinnedMatrics.Load(int3(bone_id * 3 + 1, frame1, 0)),
        SkinnedMatrics.Load(int3(bone_id * 3 + 2, frame1, 0)),
        float4(0, 0, 0, 1));
    
    BoneMatrics[bone_id] = lerp(mat0, mat1, frac(UpdateInfo.time * 30.f));
}

================================================
FILE: Source/xmake.lua
================================================
includes("External")
includes("Runtime")
includes("Plugin")

target("Editor")
    if is_mode("debug") then
        add_defines("DEBUG")
        set_kind("shared")
        add_rules("utils.symbols.export_all", {export_classes = true})
    elseif is_mode("release", "releasedbg") then
        set_kind("static")
    end

    set_pcxxheader("Editor/Precompile.hpp")

    add_files("Editor/**.cpp")
    add_headerfiles("Editor/**.hpp")
    add_includedirs("./", {public  = true})
    add_deps("Core", "RHI", "Scene", "ShaderCompiler", "ImGui-Tools")
    add_packages("imgui", "imnodes", "nativefiledialog")
target_end()

target("Shader")
    add_rules("shader", "empty")
    add_headerfiles("Shaders/**.hlsl")
    add_headerfiles("Shaders/**.hlsli")
target_end()

target("Engine")
    set_kind("binary")
    set_default(true,1)
    set_rundir("$(projectdir)")
    set_pcxxheader("Engine/Precompile.hpp")

    add_files("Engine/**.cpp")
    add_headerfiles("Engine/**.hpp")
    add_includedirs("Engine", {public  = true})
    add_deps("Core", "RHI", "Scene", "Geometry", "Resource", "Renderer", "Editor", "Plugin")
target_end()

================================================
FILE: imgui.ini
================================================
[Window][DockSpace]
Pos=0,24
Size=1440,786
Collapsed=0

[Window][Debug##Default]
Pos=60,60
Size=400,400
Collapsed=0

[Window][Animation Editor]
Pos=196,24
Size=785,515
Collapsed=0
DockId=0x00000003,4

[Window][Hierarchy]
Pos=0,24
Size=194,786
Collapsed=0
DockId=0x00000005,0

[Window][Inspector]
Pos=983,24
Size=457,786
Collapsed=0
DockId=0x00000002,0

[Window][Material Editor]
Pos=196,24
Size=785,515
Collapsed=0
DockId=0x00000003,2

[Window][Mesh Editor]
Pos=196,24
Size=785,515
Collapsed=0
DockId=0x00000003,3

[Window][Render Graph Editor]
Pos=196,24
Size=785,515
Collapsed=0
DockId=0x00000003,1

[Window][Resource Browser]
Pos=196,541
Size=785,269
Collapsed=0
DockId=0x00000004,0

[Window][Scene View]
Pos=196,24
Size=785,515
Collapsed=0
DockId=0x00000003,0

[Window][sync_test]
Pos=453,751
Size=79,36
Collapsed=0

[Window][visibility]
Pos=558,397
Size=68,36
Collapsed=0

[Window][pathtracing]
Pos=475,597
Size=90,36
Collapsed=0

[Window][test]
Pos=665,548
Size=41,36
Collapsed=0

[Window][2]
Pos=498,591
Size=25,36
Collapsed=0

[Window][3]
Pos=711,601
Size=25,36
Collapsed=0

[Window][1]
Pos=475,613
Size=25,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_SciFiHelmet_glTF_SciFiHelmet.gltf.mesh.0]
Pos=546,973
Size=581,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_plane.gltf.mesh.0]
Pos=634,986
Size=366,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_projects_bin_Debug-windows-x86_64_App_assets_skybox_newport_loft.hdr]
Pos=489,935
Size=713,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_SciFiHelmet_glTF_SciFiHelmet_Normal.png]
Pos=616,768
Size=542,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_plane.gltf]
Pos=698,658
Size=313,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_shader_ball.glb.mesh.0]
Pos=729,969
Size=406,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_shader_ball.glb]
Pos=812,656
Size=352,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_SciFiHelmet_glTF_SciFiHelmet.gltf]
Pos=548,641
Size=527,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_sphere.glb]
Size=322,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_sphere.glb.mesh.0]
Pos=885,984
Size=375,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_SciFiHelmet_glTF_SciFiHelmet_MetallicRoughness.png]
Size=666,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_pbr_rusted_iron_roughness.png]
Pos=838,821
Size=588,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_pbr_rusted_iron_albedo.png]
Pos=542,509
Size=563,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_pbr_rusted_iron_normal.png]
Pos=758,815
Size=564,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_SciFiHelmet_glTF_SciFiHelmet_BaseColor.png]
Pos=692,681
Size=610,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_pbr_wall_normal.png]
Pos=472,677
Size=516,36
Collapsed=0

[Window][4]
Pos=828,603
Size=25,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_pbr_wall_albedo.png]
Pos=332,659
Size=515,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_cg_normalmap__.jpg]
Pos=870,698
Size=516,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_cg_normalmap.jpg]
Pos=616,715
Size=501,36
Collapsed=0

[Window][5]
Pos=921,544
Size=25,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_conell_box.glb]
Pos=638,603
Size=347,36
Collapsed=0

[Window][default]
Pos=818,637
Size=61,36
Collapsed=0

[Window][red]
Pos=734,822
Size=38,36
Collapsed=0

[Window][green]
Pos=1072,729
Size=55,36
Collapsed=0

[Window][sphere]
Pos=1243,994
Size=62,36
Collapsed=0

[Window][conell_box]
Pos=605,843
Size=87,36
Collapsed=0

[Window][diffuse]
Pos=885,887
Size=60,36
Collapsed=0

[Window][Dieletric]
Pos=949,632
Size=70,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_conell_box.glb.mesh.6]
Pos=456,631
Size=400,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_conell_box.glb.mesh.4]
Pos=608,654
Size=400,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_conell_box.glb.mesh.1]
Pos=855,959
Size=16,16
Collapsed=0

[Window][conductor]
Pos=634,868
Size=82,36
Collapsed=0

[Window][thindielectric]
Pos=1037,603
Size=99,36
Collapsed=0

[Window][Mix]
Pos=1044,737
Size=40,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_pbr_wall_roughness.png]
Pos=571,678
Size=540,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_pbr_rusted_iron_metallic.png]
Pos=1257,699
Size=569,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_conell_box.glb.mesh.0]
Pos=700,959
Size=400,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_BoomBox_glTF_BoomBox.gltf.mesh.0]
Pos=441,974
Size=549,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_BoomBox_glTF_BoomBox_baseColor.png]
Pos=437,728
Size=576,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_BoomBox_glTF_BoomBox_occlusionRoughnessMetallic.png]
Pos=537,725
Size=697,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_BoomBox_glTF_BoomBox_normal.png]
Pos=577,774
Size=554,36
Collapsed=0

[Window][cube]
Pos=1352,950
Size=49,36
Collapsed=0

[Window][material]
Pos=669,640
Size=70,36
Collapsed=0

[Window][dielectric]
Pos=765,879
Size=75,36
Collapsed=0

[Window][mix]
Pos=1118,882
Size=40,36
Collapsed=0

[Window][thin_dielectric]
Pos=727,978
Size=107,36
Collapsed=0

[Window][E__Workspace_glTF-Sample-Models_2.0_Sponza_glTF_8006627369776289000.png]
Pos=1247,955
Size=580,36
Collapsed=0

[Window][mask]
Pos=997,884
Size=52,36
Collapsed=0

[Window][principled]
Pos=1242,877
Size=80,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_conell_box.glb.mesh.3]
Pos=1100,992
Size=400,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_conell_box.glb.mesh.5]
Pos=886,707
Size=400,36
Collapsed=0

[Window][E__Workspace_Ilum_Asset_Model_conell_box.glb.mesh.2]
Pos=1109,710
Size=400,36
Collapsed=0

[Window][checkboard]
Pos=521,874
Size=94,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_checkboard.png]
Pos=1004,743
Size=485,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_bricks2.jpg]
Pos=611,849
Size=450,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_bricks2_normal.jpg]
Pos=771,814
Size=503,36
Collapsed=0

[Window][E__Workspace_Chaf-Engine_src_App_assets_texture_green_checkerboard.png]
Pos=1114,724
Size=544,36
Collapsed=0

[Window][rust_iron]
Pos=643,981
Size=74,36
Collapsed=0

[Window][rough_conductor]
Pos=1272,845
Size=128,36
Collapsed=0

[Window][rough_dielectric]
Pos=524,983
Size=121,36
Collapsed=0

[Docking][Data]
DockSpace       ID=0x3FC20BEE Window=0x9A404470 Pos=87,145 Size=1440,786 Split=X Selected=0x08AA43A5
  DockNode      ID=0x00000001 Parent=0x3FC20BEE SizeRef=1461,1022 Split=X
    DockNode    ID=0x00000005 Parent=0x00000001 SizeRef=194,786 Selected=0x29EABFBD
    DockNode    ID=0x00000006 Parent=0x00000001 SizeRef=1244,786 Split=Y Selected=0x08AA43A5
      DockNode  ID=0x00000003 Parent=0x00000006 SizeRef=1265,751 CentralNode=1 Selected=0x08AA43A5
      DockNode  ID=0x00000004 Parent=0x00000006 SizeRef=1265,269 Selected=0xD4E0DDF3
  DockNode      ID=0x00000002 Parent=0x3FC20BEE SizeRef=457,1022 Selected=0xE7039252



================================================
FILE: xmake/module.lua
================================================
function add_runtime_moulde(name, group, pcxxheader, deps, pkgs)
    target(name)
        if is_mode("debug") then
            add_defines("DEBUG")
            set_kind("shared")
            add_rules("utils.symbols.export_all", {export_classes = true})
        elseif is_mode("release", "releasedbg") then
            set_kind("static")
        end

        if pcxxheader then
            set_pcxxheader(string.format("%s/Public/%s/Precompile.hpp", name, name))
        end

        add_files(string.format("%s/Private/**.cpp", name))
        add_headerfiles(string.format("%s/Public/**.hpp", name))
        add_includedirs(string.format("%s/Public/%s", name, name))
        add_includedirs(string.format("%s/Public", name), {public  = true})
        add_deps(deps)
        add_packages(pkgs)

        set_group(group)
    target_end()
end

================================================
FILE: xmake/plugin.lua
================================================
includes("rule.lua")

target("Plugin")
    add_rules("empty")
    set_group("Plugin")
target_end()

rule("plugin")
    on_load(function (target)
        if is_mode("debug") then
            target:add("defines", "DEBUG")
        end
    end)
    
    after_build(function (target)
        local source_path = path.join(target:targetdir(), string.format("%s.dll", target:name()))
        local target_path = path.join("$(projectdir)", "shared", string.sub(target:name(), 0, string.find(target:name(), "%.") - 1), string.format("%s.dll", target:name()))
        os.cp(source_path, target_path)
    end)


================================================
FILE: xmake/rule.lua
================================================
rule("empty")
    on_load(function (target)
        if is_mode("debug") then
            target:add("defines", "DEBUG")
        end
    end)

    on_build(function (target, sourcefile)
    end)

================================================
FILE: xmake/shader.lua
================================================
includes("rule.lua")

rule("shader")
    set_extensions(".hlsli", ".hlsl")
    on_load(function (target)
        
    end)

================================================
FILE: xmake.lua
================================================
set_project("Ilum")
set_version("0.0.1")

set_xmakever("2.7.5")

set_warnings("all")
set_languages("c++17")

add_rules("mode.debug", "mode.release", "mode.releasedbg")

set_runtimes("MD")
add_defines("NOMINMAX")
set_warnings("all")

includes("xmake/module.lua")
includes("xmake/plugin.lua")
includes("xmake/shader.lua")
includes("Source")