Copy disabled (too large)
Download .txt
Showing preview only (55,880K chars total). Download the full file to get everything.
Repository: PanosK92/SpartanEngine
Branch: master
Commit: 4a0fe6d6d6ae
Files: 1549
Total size: 53.0 MB
Directory structure:
gitextract_nrqdl6fz/
├── .editorconfig
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ └── bug_report.md
│ └── workflows/
│ └── workflow.yml
├── .gitignore
├── build_scripts/
│ ├── Dockerfile
│ ├── ci_test.bat
│ ├── file_utilities.py
│ ├── generate_project_files.py
│ ├── hash_printer.py
│ └── premake.lua
├── code_of_conduct.md
├── data/
│ ├── fonts/
│ │ └── OpenSans/
│ │ └── OFL.txt
│ └── shaders/
│ ├── amd_fidelity_fx/
│ │ ├── cas.hlsl
│ │ ├── ffx_a.h
│ │ ├── ffx_cas.h
│ │ ├── ffx_spd.h
│ │ └── spd.hlsl
│ ├── auto_exposure.hlsl
│ ├── blit.hlsl
│ ├── bloom.hlsl
│ ├── blur.hlsl
│ ├── brdf.hlsl
│ ├── chromatic_aberration.hlsl
│ ├── common.hlsl
│ ├── common_colorspace.hlsl
│ ├── common_resources.hlsl
│ ├── common_structs.hlsl
│ ├── common_terrain.hlsl
│ ├── common_tessellation.hlsl
│ ├── common_vertex_processing.hlsl
│ ├── compressonator/
│ │ ├── bcn_common_api.h
│ │ ├── bcn_common_kernel.h
│ │ └── common_def.h
│ ├── depth_light.hlsl
│ ├── depth_of_field.hlsl
│ ├── depth_prepass.hlsl
│ ├── dithering.hlsl
│ ├── film_grain.hlsl
│ ├── fog.hlsl
│ ├── font.hlsl
│ ├── fxaa/
│ │ ├── fxaa.hlsl
│ │ └── fxaa3_11.h
│ ├── g_buffer.hlsl
│ ├── grid.hlsl
│ ├── icon.hlsl
│ ├── imgui.hlsl
│ ├── indirect_cull.hlsl
│ ├── legacy/
│ │ ├── ssr.hlsl
│ │ └── temporal_antialiasing.hlsl
│ ├── light.hlsl
│ ├── light_composition.hlsl
│ ├── light_image_based.hlsl
│ ├── light_integration.hlsl
│ ├── light_reflections.hlsl
│ ├── line.hlsl
│ ├── motion_blur.hlsl
│ ├── nrd_prepare.hlsl
│ ├── outline.hlsl
│ ├── output.hlsl
│ ├── particles.hlsl
│ ├── ray_traced_reflections.hlsl
│ ├── ray_traced_shadows.hlsl
│ ├── restir_pt.hlsl
│ ├── restir_pt_spatial.hlsl
│ ├── restir_pt_temporal.hlsl
│ ├── restir_reservoir.hlsl
│ ├── scaling.hlsl
│ ├── screen_space_shadows/
│ │ ├── bend_sss.hlsl
│ │ ├── bend_sss_gpu.hlsl
│ │ └── screen_space_shadows.hlsl
│ ├── shadow_mapping.hlsl
│ ├── shared_buffers.h
│ ├── sky/
│ │ ├── cloud_noise.hlsl
│ │ ├── cloud_shadow.hlsl
│ │ └── skysphere.hlsl
│ ├── ssao.hlsl
│ ├── texture_compress_bc1.hlsl
│ ├── texture_compress_bc3.hlsl
│ ├── texture_compress_bc5.hlsl
│ ├── transparency_reflection_refraction.hlsl
│ ├── variable_rate_shading.hlsl
│ └── vhs.hlsl
├── funding.yml
├── generate_project_files.py
├── license.md
├── plan.md
├── readme.md
├── source/
│ ├── editor/
│ │ ├── Editor.cpp
│ │ ├── Editor.h
│ │ ├── GeneralWindows.cpp
│ │ ├── GeneralWindows.h
│ │ ├── ImGui/
│ │ │ ├── ImGui_Extension.h
│ │ │ ├── ImGui_Style.h
│ │ │ ├── ImGui_TransformGizmo.h
│ │ │ ├── Implementation/
│ │ │ │ ├── ImGui_RHI.h
│ │ │ │ ├── imgui_impl_sdl3.cpp
│ │ │ │ └── imgui_impl_sdl3.h
│ │ │ ├── Source/
│ │ │ │ ├── ImGuizmo/
│ │ │ │ │ ├── GraphEditor.cpp
│ │ │ │ │ ├── GraphEditor.h
│ │ │ │ │ ├── ImCurveEdit.cpp
│ │ │ │ │ ├── ImCurveEdit.h
│ │ │ │ │ ├── ImGradient.cpp
│ │ │ │ │ ├── ImGradient.h
│ │ │ │ │ ├── ImGuizmo.cpp
│ │ │ │ │ ├── ImGuizmo.h
│ │ │ │ │ ├── ImSequencer.cpp
│ │ │ │ │ ├── ImSequencer.h
│ │ │ │ │ ├── ImZoomSlider.h
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ └── README.md
│ │ │ │ ├── LICENSE.txt
│ │ │ │ ├── imconfig.h
│ │ │ │ ├── imgui.cpp
│ │ │ │ ├── imgui.h
│ │ │ │ ├── imgui_demo.cpp
│ │ │ │ ├── imgui_draw.cpp
│ │ │ │ ├── imgui_freetype.cpp
│ │ │ │ ├── imgui_freetype.h
│ │ │ │ ├── imgui_internal.h
│ │ │ │ ├── imgui_stdlib.cpp
│ │ │ │ ├── imgui_stdlib.h
│ │ │ │ ├── imgui_tables.cpp
│ │ │ │ ├── imgui_widgets.cpp
│ │ │ │ ├── imstb_rectpack.h
│ │ │ │ ├── imstb_textedit.h
│ │ │ │ ├── imstb_truetype.h
│ │ │ │ └── stb_sprintf.h
│ │ │ ├── TextEditor.cpp
│ │ │ └── TextEditor.h
│ │ ├── Widgets/
│ │ │ ├── AssetBrowser.cpp
│ │ │ ├── AssetBrowser.h
│ │ │ ├── ButtonColorPicker.cpp
│ │ │ ├── ButtonColorPicker.h
│ │ │ ├── Console.cpp
│ │ │ ├── Console.h
│ │ │ ├── FileDialog.cpp
│ │ │ ├── FileDialog.h
│ │ │ ├── FileSelection.h
│ │ │ ├── MenuBar.cpp
│ │ │ ├── MenuBar.h
│ │ │ ├── Profiler.cpp
│ │ │ ├── Profiler.h
│ │ │ ├── ProgressDialog.cpp
│ │ │ ├── ProgressDialog.h
│ │ │ ├── Properties.cpp
│ │ │ ├── Properties.h
│ │ │ ├── RenderOptions.cpp
│ │ │ ├── RenderOptions.h
│ │ │ ├── ResourceViewer.cpp
│ │ │ ├── ResourceViewer.h
│ │ │ ├── ScriptEditor.cpp
│ │ │ ├── ScriptEditor.h
│ │ │ ├── Sequence/
│ │ │ │ ├── Sequence.cpp
│ │ │ │ ├── Sequence.h
│ │ │ │ ├── Sequencer.cpp
│ │ │ │ └── Sequencer.h
│ │ │ ├── ShaderEditor.cpp
│ │ │ ├── ShaderEditor.h
│ │ │ ├── Style.cpp
│ │ │ ├── Style.h
│ │ │ ├── TextureViewer.cpp
│ │ │ ├── TextureViewer.h
│ │ │ ├── Viewport.cpp
│ │ │ ├── Viewport.h
│ │ │ ├── Widget.cpp
│ │ │ ├── Widget.h
│ │ │ ├── WorldViewer.cpp
│ │ │ └── WorldViewer.h
│ │ ├── Windows/
│ │ │ ├── Contributors.cpp
│ │ │ ├── Contributors.h
│ │ │ ├── WorldSelector.cpp
│ │ │ └── WorldSelector.h
│ │ └── main.cpp
│ └── runtime/
│ ├── Car/
│ │ ├── Car.cpp
│ │ ├── Car.h
│ │ ├── CarEngineSoundSynthesis.h
│ │ ├── CarSimulation.h
│ │ └── CarTireSquealSynthesis.h
│ ├── Commands/
│ │ ├── CircularStack.h
│ │ ├── Command.h
│ │ ├── CommandEntityDelete.cpp
│ │ ├── CommandEntityDelete.h
│ │ ├── CommandStack.cpp
│ │ ├── CommandStack.h
│ │ ├── CommandTransform.cpp
│ │ ├── CommandTransform.h
│ │ ├── CommandTransformMulti.cpp
│ │ ├── CommandTransformMulti.h
│ │ └── Console/
│ │ ├── ConsoleCommands.cpp
│ │ └── ConsoleCommands.h
│ ├── Core/
│ │ ├── Breadcrumbs.cpp
│ │ ├── Breadcrumbs.h
│ │ ├── Debugging.h
│ │ ├── Definitions.cpp
│ │ ├── Definitions.h
│ │ ├── Engine.cpp
│ │ ├── Engine.h
│ │ ├── Event.cpp
│ │ ├── Event.h
│ │ ├── ProgressTracker.cpp
│ │ ├── ProgressTracker.h
│ │ ├── Settings.cpp
│ │ ├── Settings.h
│ │ ├── SpartanObject.h
│ │ ├── Stopwatch.h
│ │ ├── ThreadPool.cpp
│ │ ├── ThreadPool.h
│ │ ├── Timer.cpp
│ │ ├── Timer.h
│ │ ├── Window.cpp
│ │ ├── Window.h
│ │ ├── pch.cpp
│ │ ├── pch.h
│ │ └── resource.rc
│ ├── Display/
│ │ ├── Display.cpp
│ │ ├── Display.h
│ │ └── DisplayMode.h
│ ├── FileSystem/
│ │ ├── FileSystem.cpp
│ │ └── FileSystem.h
│ ├── Font/
│ │ ├── Font.cpp
│ │ ├── Font.h
│ │ └── Glyph.h
│ ├── Game/
│ │ ├── Game.cpp
│ │ └── Game.h
│ ├── Geometry/
│ │ ├── GeometryGeneration.h
│ │ ├── GeometryProcessing.h
│ │ ├── Mesh.cpp
│ │ └── Mesh.h
│ ├── IO/
│ │ ├── pugiconfig.hpp
│ │ └── pugixml.hpp
│ ├── Input/
│ │ ├── Input.cpp
│ │ ├── Input.h
│ │ ├── InputGamepad.cpp
│ │ ├── InputKeyboard.cpp
│ │ ├── InputMouse.cpp
│ │ └── InputSteeringWheel.cpp
│ ├── Logging/
│ │ ├── ILogger.h
│ │ ├── Log.cpp
│ │ └── Log.h
│ ├── Math/
│ │ ├── BoundingBox.cpp
│ │ ├── BoundingBox.h
│ │ ├── Frustum.cpp
│ │ ├── Frustum.h
│ │ ├── Helper.h
│ │ ├── Matrix.cpp
│ │ ├── Matrix.h
│ │ ├── Plane.cpp
│ │ ├── Plane.h
│ │ ├── Quaternion.cpp
│ │ ├── Quaternion.h
│ │ ├── Ray.cpp
│ │ ├── Ray.h
│ │ ├── RayHitResult.h
│ │ ├── Rectangle.cpp
│ │ ├── Rectangle.h
│ │ ├── Sphere.cpp
│ │ ├── Sphere.h
│ │ ├── Vector2.cpp
│ │ ├── Vector2.h
│ │ ├── Vector3.cpp
│ │ ├── Vector3.h
│ │ ├── Vector4.cpp
│ │ └── Vector4.h
│ ├── Memory/
│ │ ├── Allocator.cpp
│ │ ├── Allocator.h
│ │ ├── MemoryOverrides.cpp
│ │ └── MemoryOverrides.h
│ ├── Physics/
│ │ ├── PhysicsWorld.cpp
│ │ └── PhysicsWorld.h
│ ├── Profiling/
│ │ ├── Profiler.cpp
│ │ ├── Profiler.h
│ │ ├── RenderDoc.cpp
│ │ ├── RenderDoc.h
│ │ ├── TimeBlock.cpp
│ │ └── TimeBlock.h
│ ├── RHI/
│ │ ├── D3D12/
│ │ │ ├── D3D12_AccelerationStructure.cpp
│ │ │ ├── D3D12_BlendState.cpp
│ │ │ ├── D3D12_Buffer.cpp
│ │ │ ├── D3D12_CommandList.cpp
│ │ │ ├── D3D12_DepthStencilState.cpp
│ │ │ ├── D3D12_DescriptorSet.cpp
│ │ │ ├── D3D12_DescriptorSetLayout.cpp
│ │ │ ├── D3D12_Device.cpp
│ │ │ ├── D3D12_InputLayout.cpp
│ │ │ ├── D3D12_Pipeline.cpp
│ │ │ ├── D3D12_Queue.cpp
│ │ │ ├── D3D12_RasterizerState.cpp
│ │ │ ├── D3D12_Sampler.cpp
│ │ │ ├── D3D12_Shader.cpp
│ │ │ ├── D3D12_SwapChain.cpp
│ │ │ ├── D3D12_SyncPrimitive.cpp
│ │ │ ├── D3D12_Texture.cpp
│ │ │ ├── D3D12_Utility.h
│ │ │ └── D3D12_VendorTechnology.cpp
│ │ ├── RHI_AccelerationStructure.h
│ │ ├── RHI_BlendState.h
│ │ ├── RHI_Buffer.h
│ │ ├── RHI_CommandList.cpp
│ │ ├── RHI_CommandList.h
│ │ ├── RHI_Definitions.h
│ │ ├── RHI_DepthStencilState.h
│ │ ├── RHI_Descriptor.h
│ │ ├── RHI_DescriptorSet.cpp
│ │ ├── RHI_DescriptorSet.h
│ │ ├── RHI_DescriptorSetLayout.cpp
│ │ ├── RHI_DescriptorSetLayout.h
│ │ ├── RHI_Device.cpp
│ │ ├── RHI_Device.h
│ │ ├── RHI_DirectXShaderCompiler.h
│ │ ├── RHI_Implementation.cpp
│ │ ├── RHI_Implementation.h
│ │ ├── RHI_InputLayout.h
│ │ ├── RHI_PhysicalDevice.cpp
│ │ ├── RHI_PhysicalDevice.h
│ │ ├── RHI_Pipeline.h
│ │ ├── RHI_PipelineState.cpp
│ │ ├── RHI_PipelineState.h
│ │ ├── RHI_Queue.h
│ │ ├── RHI_RasterizerState.h
│ │ ├── RHI_Sampler.cpp
│ │ ├── RHI_Sampler.h
│ │ ├── RHI_Shader.cpp
│ │ ├── RHI_Shader.h
│ │ ├── RHI_SwapChain.h
│ │ ├── RHI_SyncPrimitive.h
│ │ ├── RHI_Texture.cpp
│ │ ├── RHI_Texture.h
│ │ ├── RHI_VendorTechnology.h
│ │ ├── RHI_Vertex.h
│ │ ├── RHI_Viewport.cpp
│ │ ├── RHI_Viewport.h
│ │ └── Vulkan/
│ │ ├── Vulkan_AccelerationStructure.cpp
│ │ ├── Vulkan_BlendState.cpp
│ │ ├── Vulkan_Buffer.cpp
│ │ ├── Vulkan_CommandList.cpp
│ │ ├── Vulkan_DepthStencilState.cpp
│ │ ├── Vulkan_DescriptorSet.cpp
│ │ ├── Vulkan_DescriptorSetLayout.cpp
│ │ ├── Vulkan_Device.cpp
│ │ ├── Vulkan_InputLayout.cpp
│ │ ├── Vulkan_Pipeline.cpp
│ │ ├── Vulkan_Queue.cpp
│ │ ├── Vulkan_RasterizerState.cpp
│ │ ├── Vulkan_Sampler.cpp
│ │ ├── Vulkan_Shader.cpp
│ │ ├── Vulkan_SwapChain.cpp
│ │ ├── Vulkan_SyncPrimitive.cpp
│ │ ├── Vulkan_Texture.cpp
│ │ └── Vulkan_VendorTechnology.cpp
│ ├── Rendering/
│ │ ├── Animation/
│ │ │ ├── AnimationClip.h
│ │ │ ├── SkeletalMeshBinding.h
│ │ │ └── Skeleton.h
│ │ ├── Animation.cpp
│ │ ├── Animation.h
│ │ ├── Color.cpp
│ │ ├── Color.h
│ │ ├── GeometryBuffer.cpp
│ │ ├── GeometryBuffer.h
│ │ ├── Instance.h
│ │ ├── Material.cpp
│ │ ├── Material.h
│ │ ├── Renderer.cpp
│ │ ├── Renderer.h
│ │ ├── Renderer_Buffers.h
│ │ ├── Renderer_ConsoleVariables.cpp
│ │ ├── Renderer_Definitions.h
│ │ ├── Renderer_Passes.cpp
│ │ ├── Renderer_Primitives.cpp
│ │ ├── Renderer_Resources.cpp
│ │ └── bend_sss_cpu.h
│ ├── Resource/
│ │ ├── Animation/
│ │ │ ├── AnimationAssetValidation.cpp
│ │ │ ├── AnimationAssetValidation.h
│ │ │ ├── AnimationClipIO.cpp
│ │ │ ├── AnimationClipIO.h
│ │ │ ├── AnimationFileFormat.h
│ │ │ ├── BinaryIO.h
│ │ │ ├── SkeletonIO.cpp
│ │ │ └── SkeletonIO.h
│ │ ├── IResource.cpp
│ │ ├── IResource.h
│ │ ├── Import/
│ │ │ ├── FontImporter.cpp
│ │ │ ├── FontImporter.h
│ │ │ ├── ImageImporter.cpp
│ │ │ ├── ImageImporter.h
│ │ │ ├── ModelImporter.cpp
│ │ │ ├── ModelImporter.h
│ │ │ └── tinyddsloader.h
│ │ ├── ResourceCache.cpp
│ │ └── ResourceCache.h
│ ├── Testing/
│ │ ├── SmokeTest.cpp
│ │ └── SmokeTest.h
│ ├── World/
│ │ ├── Components/
│ │ │ ├── AudioSource.cpp
│ │ │ ├── AudioSource.h
│ │ │ ├── Camera.cpp
│ │ │ ├── Camera.h
│ │ │ ├── Component.cpp
│ │ │ ├── Component.h
│ │ │ ├── Light.cpp
│ │ │ ├── Light.h
│ │ │ ├── ParticleSystem.cpp
│ │ │ ├── ParticleSystem.h
│ │ │ ├── Physics.cpp
│ │ │ ├── Physics.h
│ │ │ ├── Render.cpp
│ │ │ ├── Render.h
│ │ │ ├── Script.cpp
│ │ │ ├── Script.h
│ │ │ ├── Spline.cpp
│ │ │ ├── Spline.h
│ │ │ ├── SplineFollower.cpp
│ │ │ ├── SplineFollower.h
│ │ │ ├── Terrain.cpp
│ │ │ ├── Terrain.h
│ │ │ ├── Volume.cpp
│ │ │ └── Volume.h
│ │ ├── Entity.cpp
│ │ ├── Entity.h
│ │ ├── Prefab.cpp
│ │ ├── Prefab.h
│ │ ├── World.cpp
│ │ └── World.h
│ └── XR/
│ ├── Xr.cpp
│ └── Xr.h
├── third_party/
│ ├── assimp/
│ │ ├── assimp/
│ │ │ ├── .editorconfig
│ │ │ ├── AssertHandler.h
│ │ │ ├── Base64.hpp
│ │ │ ├── BaseImporter.h
│ │ │ ├── Bitmap.h
│ │ │ ├── BlobIOSystem.h
│ │ │ ├── ByteSwapper.h
│ │ │ ├── ColladaMetaData.h
│ │ │ ├── Compiler/
│ │ │ │ ├── poppack1.h
│ │ │ │ ├── pstdint.h
│ │ │ │ └── pushpack1.h
│ │ │ ├── CreateAnimMesh.h
│ │ │ ├── DefaultIOStream.h
│ │ │ ├── DefaultIOSystem.h
│ │ │ ├── DefaultLogger.hpp
│ │ │ ├── Exceptional.h
│ │ │ ├── Exporter.hpp
│ │ │ ├── GenericProperty.h
│ │ │ ├── GltfMaterial.h
│ │ │ ├── Hash.h
│ │ │ ├── IOStream.hpp
│ │ │ ├── IOStreamBuffer.h
│ │ │ ├── IOSystem.hpp
│ │ │ ├── Importer.hpp
│ │ │ ├── LineSplitter.h
│ │ │ ├── LogAux.h
│ │ │ ├── LogStream.hpp
│ │ │ ├── Logger.hpp
│ │ │ ├── MathFunctions.h
│ │ │ ├── MemoryIOWrapper.h
│ │ │ ├── NullLogger.hpp
│ │ │ ├── ObjMaterial.h
│ │ │ ├── ParsingUtils.h
│ │ │ ├── Profiler.h
│ │ │ ├── ProgressHandler.hpp
│ │ │ ├── RemoveComments.h
│ │ │ ├── SGSpatialSort.h
│ │ │ ├── SceneCombiner.h
│ │ │ ├── SkeletonMeshBuilder.h
│ │ │ ├── SmallVector.h
│ │ │ ├── SmoothingGroups.h
│ │ │ ├── SmoothingGroups.inl
│ │ │ ├── SpatialSort.h
│ │ │ ├── StandardShapes.h
│ │ │ ├── StreamReader.h
│ │ │ ├── StreamWriter.h
│ │ │ ├── StringComparison.h
│ │ │ ├── StringUtils.h
│ │ │ ├── Subdivision.h
│ │ │ ├── TinyFormatter.h
│ │ │ ├── Vertex.h
│ │ │ ├── XMLTools.h
│ │ │ ├── XmlParser.h
│ │ │ ├── ZipArchiveIOSystem.h
│ │ │ ├── aabb.h
│ │ │ ├── ai_assert.h
│ │ │ ├── anim.h
│ │ │ ├── camera.h
│ │ │ ├── cexport.h
│ │ │ ├── cfileio.h
│ │ │ ├── cimport.h
│ │ │ ├── color4.h
│ │ │ ├── color4.inl
│ │ │ ├── commonMetaData.h
│ │ │ ├── config.h
│ │ │ ├── config.h.in
│ │ │ ├── defs.h
│ │ │ ├── fast_atof.h
│ │ │ ├── importerdesc.h
│ │ │ ├── light.h
│ │ │ ├── material.h
│ │ │ ├── material.inl
│ │ │ ├── matrix3x3.h
│ │ │ ├── matrix3x3.inl
│ │ │ ├── matrix4x4.h
│ │ │ ├── matrix4x4.inl
│ │ │ ├── mesh.h
│ │ │ ├── metadata.h
│ │ │ ├── module.modulemap
│ │ │ ├── pbrmaterial.h
│ │ │ ├── port/
│ │ │ │ └── AndroidJNI/
│ │ │ │ ├── AndroidJNIIOSystem.h
│ │ │ │ └── BundledAssetIOSystem.h
│ │ │ ├── postprocess.h
│ │ │ ├── qnan.h
│ │ │ ├── quaternion.h
│ │ │ ├── quaternion.inl
│ │ │ ├── revision.h
│ │ │ ├── revision.h.in
│ │ │ ├── scene.h
│ │ │ ├── texture.h
│ │ │ ├── types.h
│ │ │ ├── vector2.h
│ │ │ ├── vector2.inl
│ │ │ ├── vector3.h
│ │ │ ├── vector3.inl
│ │ │ └── version.h
│ │ └── version.txt
│ ├── compressonator/
│ │ ├── compressonator.h
│ │ └── version.txt
│ ├── dxc/
│ │ ├── dxc/
│ │ │ ├── d3d12shader.h
│ │ │ ├── dxcapi.h
│ │ │ ├── dxcerrors.h
│ │ │ └── dxcisense.h
│ │ └── version.txt
│ ├── fidelityfx/
│ │ ├── FidelityFX/
│ │ │ ├── gpu/
│ │ │ │ ├── CMakeCompileShaders.txt
│ │ │ │ ├── blur/
│ │ │ │ │ ├── CMakeCompileBlurShaders.txt
│ │ │ │ │ ├── ffx_blur.h
│ │ │ │ │ ├── ffx_blur_blur.h
│ │ │ │ │ ├── ffx_blur_callbacks_glsl.h
│ │ │ │ │ ├── ffx_blur_callbacks_hlsl.h
│ │ │ │ │ └── ffx_blur_resources.h
│ │ │ │ ├── brixelizer/
│ │ │ │ │ ├── CMakeCompileBrixelizerShaders.txt
│ │ │ │ │ ├── ffx_brixelizer_brick_common.h
│ │ │ │ │ ├── ffx_brixelizer_brick_common_private.h
│ │ │ │ │ ├── ffx_brixelizer_build_common.h
│ │ │ │ │ ├── ffx_brixelizer_callbacks_glsl.h
│ │ │ │ │ ├── ffx_brixelizer_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_brixelizer_cascade_ops.h
│ │ │ │ │ ├── ffx_brixelizer_common.h
│ │ │ │ │ ├── ffx_brixelizer_common_private.h
│ │ │ │ │ ├── ffx_brixelizer_context_ops.h
│ │ │ │ │ ├── ffx_brixelizer_debug_aabbs.h
│ │ │ │ │ ├── ffx_brixelizer_debug_visualization.h
│ │ │ │ │ ├── ffx_brixelizer_host_gpu_shared.h
│ │ │ │ │ ├── ffx_brixelizer_host_gpu_shared_private.h
│ │ │ │ │ ├── ffx_brixelizer_mesh_common.h
│ │ │ │ │ ├── ffx_brixelizer_resources.h
│ │ │ │ │ └── ffx_brixelizer_trace_ops.h
│ │ │ │ ├── brixelizergi/
│ │ │ │ │ ├── CMakeCompileBrixelizerGIShaders.txt
│ │ │ │ │ ├── ffx_brixelizergi_callbacks_glsl.h
│ │ │ │ │ ├── ffx_brixelizergi_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_brixelizergi_common.h
│ │ │ │ │ ├── ffx_brixelizergi_host_interface.h
│ │ │ │ │ ├── ffx_brixelizergi_main.h
│ │ │ │ │ ├── ffx_brixelizergi_probe_shading.h
│ │ │ │ │ ├── ffx_brixelizergi_radiance_cache_update.h
│ │ │ │ │ └── ffx_brixelizergi_resources.h
│ │ │ │ ├── cacao/
│ │ │ │ │ ├── CMakeCompileCACAOShaders.txt
│ │ │ │ │ ├── ffx_cacao_apply.h
│ │ │ │ │ ├── ffx_cacao_callbacks_glsl.h
│ │ │ │ │ ├── ffx_cacao_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_cacao_defines.h
│ │ │ │ │ ├── ffx_cacao_edge_sensitive_blur.h
│ │ │ │ │ ├── ffx_cacao_importance_map.h
│ │ │ │ │ ├── ffx_cacao_prepare.h
│ │ │ │ │ ├── ffx_cacao_resources.h
│ │ │ │ │ ├── ffx_cacao_ssao_generation.h
│ │ │ │ │ ├── ffx_cacao_upscale.h
│ │ │ │ │ └── ffx_cacao_utils.h
│ │ │ │ ├── cas/
│ │ │ │ │ ├── CMakeCompileCASShaders.txt
│ │ │ │ │ ├── ffx_cas.h
│ │ │ │ │ ├── ffx_cas_callbacks_glsl.h
│ │ │ │ │ ├── ffx_cas_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_cas_resources.h
│ │ │ │ │ └── ffx_cas_sharpen.h
│ │ │ │ ├── classifier/
│ │ │ │ │ ├── CMakeCompileClassifierShaders.txt
│ │ │ │ │ ├── ffx_classifier_common.h
│ │ │ │ │ ├── ffx_classifier_reflections.h
│ │ │ │ │ ├── ffx_classifier_reflections_callbacks_glsl.h
│ │ │ │ │ ├── ffx_classifier_reflections_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_classifier_reflections_common.h
│ │ │ │ │ ├── ffx_classifier_resources.h
│ │ │ │ │ ├── ffx_classifier_shadows.h
│ │ │ │ │ ├── ffx_classifier_shadows_callbacks_glsl.h
│ │ │ │ │ └── ffx_classifier_shadows_callbacks_hlsl.h
│ │ │ │ ├── denoiser/
│ │ │ │ │ ├── CMakeCompileDenoiserShaders.txt
│ │ │ │ │ ├── ffx_denoiser_reflections_callbacks_glsl.h
│ │ │ │ │ ├── ffx_denoiser_reflections_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_denoiser_reflections_common.h
│ │ │ │ │ ├── ffx_denoiser_reflections_config.h
│ │ │ │ │ ├── ffx_denoiser_reflections_prefilter.h
│ │ │ │ │ ├── ffx_denoiser_reflections_reproject.h
│ │ │ │ │ ├── ffx_denoiser_reflections_resolve_temporal.h
│ │ │ │ │ ├── ffx_denoiser_resources.h
│ │ │ │ │ ├── ffx_denoiser_shadows_callbacks_glsl.h
│ │ │ │ │ ├── ffx_denoiser_shadows_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_denoiser_shadows_filter.h
│ │ │ │ │ ├── ffx_denoiser_shadows_prepare.h
│ │ │ │ │ ├── ffx_denoiser_shadows_tileclassification.h
│ │ │ │ │ └── ffx_denoiser_shadows_util.h
│ │ │ │ ├── dof/
│ │ │ │ │ ├── CMakeCompileDOFShaders.txt
│ │ │ │ │ ├── ffx_dof_blur.h
│ │ │ │ │ ├── ffx_dof_callbacks_glsl.h
│ │ │ │ │ ├── ffx_dof_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_dof_common.h
│ │ │ │ │ ├── ffx_dof_composite.h
│ │ │ │ │ ├── ffx_dof_dilate_depth.h
│ │ │ │ │ ├── ffx_dof_downsample_color.h
│ │ │ │ │ ├── ffx_dof_downsample_depth.h
│ │ │ │ │ └── ffx_dof_resources.h
│ │ │ │ ├── ffx_common_types.h
│ │ │ │ ├── ffx_core.h
│ │ │ │ ├── ffx_core_cpu.h
│ │ │ │ ├── ffx_core_glsl.h
│ │ │ │ ├── ffx_core_gpu_common.h
│ │ │ │ ├── ffx_core_gpu_common_half.h
│ │ │ │ ├── ffx_core_hlsl.h
│ │ │ │ ├── ffx_core_portability.h
│ │ │ │ ├── frameinterpolation/
│ │ │ │ │ ├── CMakeCompileFrameinterpolationShaders.txt
│ │ │ │ │ ├── ffx_frameinterpolation.h
│ │ │ │ │ ├── ffx_frameinterpolation_callbacks_glsl.h
│ │ │ │ │ ├── ffx_frameinterpolation_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_frameinterpolation_common.h
│ │ │ │ │ ├── ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h
│ │ │ │ │ ├── ffx_frameinterpolation_compute_inpainting_pyramid.h
│ │ │ │ │ ├── ffx_frameinterpolation_debug_view.h
│ │ │ │ │ ├── ffx_frameinterpolation_disocclusion_mask.h
│ │ │ │ │ ├── ffx_frameinterpolation_game_motion_vector_field.h
│ │ │ │ │ ├── ffx_frameinterpolation_inpainting.h
│ │ │ │ │ ├── ffx_frameinterpolation_optical_flow_vector_field.h
│ │ │ │ │ ├── ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h
│ │ │ │ │ ├── ffx_frameinterpolation_reconstruct_previous_depth.h
│ │ │ │ │ ├── ffx_frameinterpolation_resources.h
│ │ │ │ │ └── ffx_frameinterpolation_setup.h
│ │ │ │ ├── fsr1/
│ │ │ │ │ ├── CMakeCompileFSR1Shaders.txt
│ │ │ │ │ ├── ffx_fsr1.h
│ │ │ │ │ ├── ffx_fsr1_callbacks_glsl.h
│ │ │ │ │ ├── ffx_fsr1_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_fsr1_easu.h
│ │ │ │ │ ├── ffx_fsr1_rcas.h
│ │ │ │ │ └── ffx_fsr1_resources.h
│ │ │ │ ├── fsr2/
│ │ │ │ │ ├── CMakeCompileFSR2Shaders.txt
│ │ │ │ │ ├── ffx_fsr2_accumulate.h
│ │ │ │ │ ├── ffx_fsr2_callbacks_glsl.h
│ │ │ │ │ ├── ffx_fsr2_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_fsr2_common.h
│ │ │ │ │ ├── ffx_fsr2_compute_luminance_pyramid.h
│ │ │ │ │ ├── ffx_fsr2_depth_clip.h
│ │ │ │ │ ├── ffx_fsr2_lock.h
│ │ │ │ │ ├── ffx_fsr2_postprocess_lock_status.h
│ │ │ │ │ ├── ffx_fsr2_rcas.h
│ │ │ │ │ ├── ffx_fsr2_reconstruct_dilated_velocity_and_previous_depth.h
│ │ │ │ │ ├── ffx_fsr2_reproject.h
│ │ │ │ │ ├── ffx_fsr2_resources.h
│ │ │ │ │ ├── ffx_fsr2_sample.h
│ │ │ │ │ ├── ffx_fsr2_tcr_autogen.h
│ │ │ │ │ └── ffx_fsr2_upsample.h
│ │ │ │ ├── fsr3/
│ │ │ │ │ ├── ffx_fsr3_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_fsr3_common.h
│ │ │ │ │ └── ffx_fsr3_resources.h
│ │ │ │ ├── fsr3upscaler/
│ │ │ │ │ ├── CMakeCompileFSR3UpscalerShaders.txt
│ │ │ │ │ ├── ffx_fsr3upscaler_accumulate.h
│ │ │ │ │ ├── ffx_fsr3upscaler_callbacks_glsl.h
│ │ │ │ │ ├── ffx_fsr3upscaler_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_fsr3upscaler_common.h
│ │ │ │ │ ├── ffx_fsr3upscaler_debug_view.h
│ │ │ │ │ ├── ffx_fsr3upscaler_luma_instability.h
│ │ │ │ │ ├── ffx_fsr3upscaler_luma_pyramid.h
│ │ │ │ │ ├── ffx_fsr3upscaler_prepare_inputs.h
│ │ │ │ │ ├── ffx_fsr3upscaler_prepare_reactivity.h
│ │ │ │ │ ├── ffx_fsr3upscaler_rcas.h
│ │ │ │ │ ├── ffx_fsr3upscaler_reproject.h
│ │ │ │ │ ├── ffx_fsr3upscaler_resources.h
│ │ │ │ │ ├── ffx_fsr3upscaler_sample.h
│ │ │ │ │ ├── ffx_fsr3upscaler_shading_change.h
│ │ │ │ │ ├── ffx_fsr3upscaler_shading_change_pyramid.h
│ │ │ │ │ └── ffx_fsr3upscaler_upsample.h
│ │ │ │ ├── lens/
│ │ │ │ │ ├── CMakeCompileLENSShaders.txt
│ │ │ │ │ ├── ffx_lens.h
│ │ │ │ │ ├── ffx_lens_callbacks_glsl.h
│ │ │ │ │ ├── ffx_lens_callbacks_hlsl.h
│ │ │ │ │ └── ffx_lens_resources.h
│ │ │ │ ├── lpm/
│ │ │ │ │ ├── CMakeCompileLPMShaders.txt
│ │ │ │ │ ├── ffx_lpm.h
│ │ │ │ │ ├── ffx_lpm_callbacks_glsl.h
│ │ │ │ │ ├── ffx_lpm_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_lpm_filter.h
│ │ │ │ │ └── ffx_lpm_resources.h
│ │ │ │ ├── opticalflow/
│ │ │ │ │ ├── CMakeCompileOpticalflowShaders.txt
│ │ │ │ │ ├── ffx_opticalflow_callbacks_glsl.h
│ │ │ │ │ ├── ffx_opticalflow_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_opticalflow_common.h
│ │ │ │ │ ├── ffx_opticalflow_compute_luminance_pyramid.h
│ │ │ │ │ ├── ffx_opticalflow_compute_optical_flow_v5.h
│ │ │ │ │ ├── ffx_opticalflow_compute_scd_divergence.h
│ │ │ │ │ ├── ffx_opticalflow_filter_optical_flow_v5.h
│ │ │ │ │ ├── ffx_opticalflow_generate_scd_histogram.h
│ │ │ │ │ ├── ffx_opticalflow_prepare_luma.h
│ │ │ │ │ ├── ffx_opticalflow_resources.h
│ │ │ │ │ └── ffx_opticalflow_scale_optical_flow_advanced_v5.h
│ │ │ │ ├── parallelsort/
│ │ │ │ │ ├── CMakeCompileParallelSortShaders.txt
│ │ │ │ │ ├── ffx_parallelsort.h
│ │ │ │ │ ├── ffx_parallelsort_callbacks_glsl.h
│ │ │ │ │ ├── ffx_parallelsort_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_parallelsort_common.h
│ │ │ │ │ ├── ffx_parallelsort_reduce.h
│ │ │ │ │ ├── ffx_parallelsort_resources.h
│ │ │ │ │ ├── ffx_parallelsort_scan.h
│ │ │ │ │ ├── ffx_parallelsort_scan_add.h
│ │ │ │ │ ├── ffx_parallelsort_scatter.h
│ │ │ │ │ ├── ffx_parallelsort_setup_indirect_args.h
│ │ │ │ │ └── ffx_parallelsort_sum.h
│ │ │ │ ├── spd/
│ │ │ │ │ ├── CMakeCompileSPDShaders.txt
│ │ │ │ │ ├── ffx_spd.h
│ │ │ │ │ ├── ffx_spd_callbacks_glsl.h
│ │ │ │ │ ├── ffx_spd_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_spd_downsample.h
│ │ │ │ │ └── ffx_spd_resources.h
│ │ │ │ ├── sssr/
│ │ │ │ │ ├── CMakeCompileSSSRShaders.txt
│ │ │ │ │ ├── ffx_sssr_callbacks_glsl.h
│ │ │ │ │ ├── ffx_sssr_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_sssr_classify_tiles.h
│ │ │ │ │ ├── ffx_sssr_common.h
│ │ │ │ │ ├── ffx_sssr_depth_downsample.h
│ │ │ │ │ ├── ffx_sssr_intersect.h
│ │ │ │ │ ├── ffx_sssr_prepare_blue_noise_texture.h
│ │ │ │ │ ├── ffx_sssr_prepare_indirect_args.h
│ │ │ │ │ └── ffx_sssr_resources.h
│ │ │ │ └── vrs/
│ │ │ │ ├── CMakeCompileVRSShaders.txt
│ │ │ │ ├── ffx_variable_shading.h
│ │ │ │ ├── ffx_vrs_callbacks_glsl.h
│ │ │ │ ├── ffx_vrs_callbacks_hlsl.h
│ │ │ │ └── ffx_vrs_resources.h
│ │ │ └── host/
│ │ │ ├── backends/
│ │ │ │ ├── dx12/
│ │ │ │ │ ├── d3dx12.h
│ │ │ │ │ ├── ffx_dx12.h
│ │ │ │ │ └── license.txt
│ │ │ │ └── vk/
│ │ │ │ └── ffx_vk.h
│ │ │ ├── ffx_assert.h
│ │ │ ├── ffx_blur.h
│ │ │ ├── ffx_breadcrumbs.h
│ │ │ ├── ffx_brixelizer.h
│ │ │ ├── ffx_brixelizer_raw.h
│ │ │ ├── ffx_brixelizergi.h
│ │ │ ├── ffx_cacao.h
│ │ │ ├── ffx_cas.h
│ │ │ ├── ffx_classifier.h
│ │ │ ├── ffx_denoiser.h
│ │ │ ├── ffx_dof.h
│ │ │ ├── ffx_error.h
│ │ │ ├── ffx_frameinterpolation.h
│ │ │ ├── ffx_fsr1.h
│ │ │ ├── ffx_fsr2.h
│ │ │ ├── ffx_fsr3.h
│ │ │ ├── ffx_fsr3upscaler.h
│ │ │ ├── ffx_fx.h
│ │ │ ├── ffx_interface.h
│ │ │ ├── ffx_lens.h
│ │ │ ├── ffx_lpm.h
│ │ │ ├── ffx_message.h
│ │ │ ├── ffx_opticalflow.h
│ │ │ ├── ffx_parallelsort.h
│ │ │ ├── ffx_spd.h
│ │ │ ├── ffx_sssr.h
│ │ │ ├── ffx_types.h
│ │ │ ├── ffx_util.h
│ │ │ └── ffx_vrs.h
│ │ └── version.txt
│ ├── free_image/
│ │ ├── FreeImage/
│ │ │ ├── CacheFile.h
│ │ │ ├── FreeImage/
│ │ │ │ ├── BitmapAccess.cpp
│ │ │ │ ├── CacheFile.cpp
│ │ │ │ ├── ColorLookup.cpp
│ │ │ │ ├── Conversion.cpp
│ │ │ │ ├── Conversion16_555.cpp
│ │ │ │ ├── Conversion16_565.cpp
│ │ │ │ ├── Conversion24.cpp
│ │ │ │ ├── Conversion32.cpp
│ │ │ │ ├── Conversion4.cpp
│ │ │ │ ├── Conversion8.cpp
│ │ │ │ ├── ConversionFloat.cpp
│ │ │ │ ├── ConversionRGB16.cpp
│ │ │ │ ├── ConversionRGBA16.cpp
│ │ │ │ ├── ConversionRGBAF.cpp
│ │ │ │ ├── ConversionRGBF.cpp
│ │ │ │ ├── ConversionType.cpp
│ │ │ │ ├── ConversionUINT16.cpp
│ │ │ │ ├── FreeImage.cpp
│ │ │ │ ├── FreeImageC.c
│ │ │ │ ├── FreeImageIO.cpp
│ │ │ │ ├── GetType.cpp
│ │ │ │ ├── Halftoning.cpp
│ │ │ │ ├── J2KHelper.cpp
│ │ │ │ ├── J2KHelper.h
│ │ │ │ ├── LFPQuantizer.cpp
│ │ │ │ ├── MNGHelper.cpp
│ │ │ │ ├── MemoryIO.cpp
│ │ │ │ ├── MultiPage.cpp
│ │ │ │ ├── NNQuantizer.cpp
│ │ │ │ ├── PSDParser.cpp
│ │ │ │ ├── PSDParser.h
│ │ │ │ ├── PixelAccess.cpp
│ │ │ │ ├── Plugin.cpp
│ │ │ │ ├── PluginBMP.cpp
│ │ │ │ ├── PluginCUT.cpp
│ │ │ │ ├── PluginDDS.cpp
│ │ │ │ ├── PluginEXR.cpp
│ │ │ │ ├── PluginG3.cpp
│ │ │ │ ├── PluginGIF.cpp
│ │ │ │ ├── PluginHDR.cpp
│ │ │ │ ├── PluginICO.cpp
│ │ │ │ ├── PluginIFF.cpp
│ │ │ │ ├── PluginJ2K.cpp
│ │ │ │ ├── PluginJNG.cpp
│ │ │ │ ├── PluginJP2.cpp
│ │ │ │ ├── PluginJPEG.cpp
│ │ │ │ ├── PluginJXR.cpp
│ │ │ │ ├── PluginKOALA.cpp
│ │ │ │ ├── PluginMNG.cpp
│ │ │ │ ├── PluginPCD.cpp
│ │ │ │ ├── PluginPCX.cpp
│ │ │ │ ├── PluginPFM.cpp
│ │ │ │ ├── PluginPICT.cpp
│ │ │ │ ├── PluginPNG.cpp
│ │ │ │ ├── PluginPNM.cpp
│ │ │ │ ├── PluginPSD.cpp
│ │ │ │ ├── PluginRAS.cpp
│ │ │ │ ├── PluginRAW.cpp
│ │ │ │ ├── PluginSGI.cpp
│ │ │ │ ├── PluginTARGA.cpp
│ │ │ │ ├── PluginTIFF.cpp
│ │ │ │ ├── PluginWBMP.cpp
│ │ │ │ ├── PluginWebP.cpp
│ │ │ │ ├── PluginXBM.cpp
│ │ │ │ ├── PluginXPM.cpp
│ │ │ │ ├── TIFFLogLuv.cpp
│ │ │ │ ├── ToneMapping.cpp
│ │ │ │ ├── WuQuantizer.cpp
│ │ │ │ ├── ZLibInterface.cpp
│ │ │ │ ├── tmoColorConvert.cpp
│ │ │ │ ├── tmoDrago03.cpp
│ │ │ │ ├── tmoFattal02.cpp
│ │ │ │ └── tmoReinhard05.cpp
│ │ │ ├── FreeImage.h
│ │ │ ├── FreeImageIO.h
│ │ │ ├── MapIntrospector.h
│ │ │ ├── Plugin.h
│ │ │ ├── Quantizers.h
│ │ │ ├── ToneMapping.h
│ │ │ └── Utilities.h
│ │ └── version.txt
│ ├── free_type/
│ │ ├── freetype/
│ │ │ ├── config/
│ │ │ │ ├── ftconfig.h
│ │ │ │ ├── ftheader.h
│ │ │ │ ├── ftmodule.h
│ │ │ │ ├── ftoption.h
│ │ │ │ ├── ftstdlib.h
│ │ │ │ ├── integer-types.h
│ │ │ │ ├── mac-support.h
│ │ │ │ └── public-macros.h
│ │ │ ├── freetype.h
│ │ │ ├── ftadvanc.h
│ │ │ ├── ftbbox.h
│ │ │ ├── ftbdf.h
│ │ │ ├── ftbitmap.h
│ │ │ ├── ftbzip2.h
│ │ │ ├── ftcache.h
│ │ │ ├── ftchapters.h
│ │ │ ├── ftcid.h
│ │ │ ├── ftcolor.h
│ │ │ ├── ftdriver.h
│ │ │ ├── fterrdef.h
│ │ │ ├── fterrors.h
│ │ │ ├── ftfntfmt.h
│ │ │ ├── ftgasp.h
│ │ │ ├── ftglyph.h
│ │ │ ├── ftgxval.h
│ │ │ ├── ftgzip.h
│ │ │ ├── ftimage.h
│ │ │ ├── ftincrem.h
│ │ │ ├── ftlcdfil.h
│ │ │ ├── ftlist.h
│ │ │ ├── ftlogging.h
│ │ │ ├── ftlzw.h
│ │ │ ├── ftmac.h
│ │ │ ├── ftmm.h
│ │ │ ├── ftmodapi.h
│ │ │ ├── ftmoderr.h
│ │ │ ├── ftotval.h
│ │ │ ├── ftoutln.h
│ │ │ ├── ftparams.h
│ │ │ ├── ftpfr.h
│ │ │ ├── ftrender.h
│ │ │ ├── ftsizes.h
│ │ │ ├── ftsnames.h
│ │ │ ├── ftstroke.h
│ │ │ ├── ftsynth.h
│ │ │ ├── ftsystem.h
│ │ │ ├── fttrigon.h
│ │ │ ├── fttypes.h
│ │ │ ├── ftwinfnt.h
│ │ │ ├── internal/
│ │ │ │ ├── autohint.h
│ │ │ │ ├── cffotypes.h
│ │ │ │ ├── cfftypes.h
│ │ │ │ ├── compiler-macros.h
│ │ │ │ ├── ftcalc.h
│ │ │ │ ├── ftdebug.h
│ │ │ │ ├── ftdrv.h
│ │ │ │ ├── ftgloadr.h
│ │ │ │ ├── fthash.h
│ │ │ │ ├── ftmemory.h
│ │ │ │ ├── ftmmtypes.h
│ │ │ │ ├── ftobjs.h
│ │ │ │ ├── ftpsprop.h
│ │ │ │ ├── ftrfork.h
│ │ │ │ ├── ftserv.h
│ │ │ │ ├── ftstream.h
│ │ │ │ ├── fttrace.h
│ │ │ │ ├── ftvalid.h
│ │ │ │ ├── psaux.h
│ │ │ │ ├── pshints.h
│ │ │ │ ├── services/
│ │ │ │ │ ├── svbdf.h
│ │ │ │ │ ├── svcfftl.h
│ │ │ │ │ ├── svcid.h
│ │ │ │ │ ├── svfntfmt.h
│ │ │ │ │ ├── svgldict.h
│ │ │ │ │ ├── svgxval.h
│ │ │ │ │ ├── svkern.h
│ │ │ │ │ ├── svmetric.h
│ │ │ │ │ ├── svmm.h
│ │ │ │ │ ├── svotval.h
│ │ │ │ │ ├── svpfr.h
│ │ │ │ │ ├── svpostnm.h
│ │ │ │ │ ├── svprop.h
│ │ │ │ │ ├── svpscmap.h
│ │ │ │ │ ├── svpsinfo.h
│ │ │ │ │ ├── svsfnt.h
│ │ │ │ │ ├── svttcmap.h
│ │ │ │ │ ├── svtteng.h
│ │ │ │ │ ├── svttglyf.h
│ │ │ │ │ └── svwinfnt.h
│ │ │ │ ├── sfnt.h
│ │ │ │ ├── svginterface.h
│ │ │ │ ├── t1types.h
│ │ │ │ ├── tttypes.h
│ │ │ │ └── wofftypes.h
│ │ │ ├── otsvg.h
│ │ │ ├── t1tables.h
│ │ │ ├── ttnameid.h
│ │ │ ├── tttables.h
│ │ │ └── tttags.h
│ │ ├── ft2build.h
│ │ └── version.txt
│ ├── lua/
│ │ ├── lua/
│ │ │ ├── lauxlib.h
│ │ │ ├── lua.h
│ │ │ ├── luaconf.h
│ │ │ └── lualib.h
│ │ ├── sol/
│ │ │ ├── config.hpp
│ │ │ ├── forward.hpp
│ │ │ └── sol.hpp
│ │ └── version.txt
│ ├── meshoptimizer/
│ │ ├── meshoptimizer/
│ │ │ ├── allocator.cpp
│ │ │ ├── clusterizer.cpp
│ │ │ ├── indexanalyzer.cpp
│ │ │ ├── indexcodec.cpp
│ │ │ ├── indexgenerator.cpp
│ │ │ ├── meshoptimizer.h
│ │ │ ├── overdrawoptimizer.cpp
│ │ │ ├── partition.cpp
│ │ │ ├── quantization.cpp
│ │ │ ├── rasterizer.cpp
│ │ │ ├── simplifier.cpp
│ │ │ ├── spatialorder.cpp
│ │ │ ├── stripifier.cpp
│ │ │ ├── vcacheoptimizer.cpp
│ │ │ ├── vertexcodec.cpp
│ │ │ ├── vertexfilter.cpp
│ │ │ └── vfetchoptimizer.cpp
│ │ └── version.md
│ ├── nrd/
│ │ ├── nrd/
│ │ │ ├── NRD.h
│ │ │ ├── NRDDescs.h
│ │ │ └── NRDSettings.h
│ │ └── version.txt
│ ├── openxr/
│ │ ├── openxr/
│ │ │ ├── openxr.h
│ │ │ ├── openxr_loader_negotiation.h
│ │ │ ├── openxr_platform.h
│ │ │ ├── openxr_platform_defines.h
│ │ │ ├── openxr_reflection.h
│ │ │ ├── openxr_reflection_parent_structs.h
│ │ │ └── openxr_reflection_structs.h
│ │ └── version.txt
│ ├── physx/
│ │ ├── physx/
│ │ │ ├── PxActor.h
│ │ │ ├── PxAggregate.h
│ │ │ ├── PxAnisotropy.h
│ │ │ ├── PxArrayConverter.h
│ │ │ ├── PxArticulationFlag.h
│ │ │ ├── PxArticulationJointReducedCoordinate.h
│ │ │ ├── PxArticulationLink.h
│ │ │ ├── PxArticulationMimicJoint.h
│ │ │ ├── PxArticulationReducedCoordinate.h
│ │ │ ├── PxArticulationTendon.h
│ │ │ ├── PxArticulationTendonData.h
│ │ │ ├── PxBaseMaterial.h
│ │ │ ├── PxBroadPhase.h
│ │ │ ├── PxClient.h
│ │ │ ├── PxConeLimitedConstraint.h
│ │ │ ├── PxConfig.h
│ │ │ ├── PxConstraint.h
│ │ │ ├── PxConstraintDesc.h
│ │ │ ├── PxContact.h
│ │ │ ├── PxContactModifyCallback.h
│ │ │ ├── PxDeformableAttachment.h
│ │ │ ├── PxDeformableBody.h
│ │ │ ├── PxDeformableBodyFlag.h
│ │ │ ├── PxDeformableElementFilter.h
│ │ │ ├── PxDeformableMaterial.h
│ │ │ ├── PxDeformableSkinning.h
│ │ │ ├── PxDeformableSurface.h
│ │ │ ├── PxDeformableSurfaceFlag.h
│ │ │ ├── PxDeformableSurfaceMaterial.h
│ │ │ ├── PxDeformableVolume.h
│ │ │ ├── PxDeformableVolumeFlag.h
│ │ │ ├── PxDeformableVolumeMaterial.h
│ │ │ ├── PxDeletionListener.h
│ │ │ ├── PxDirectGPUAPI.h
│ │ │ ├── PxFEMMaterial.h
│ │ │ ├── PxFEMParameter.h
│ │ │ ├── PxFEMSoftBodyMaterial.h
│ │ │ ├── PxFiltering.h
│ │ │ ├── PxForceMode.h
│ │ │ ├── PxImmediateMode.h
│ │ │ ├── PxIsosurfaceExtraction.h
│ │ │ ├── PxLockedData.h
│ │ │ ├── PxMaterial.h
│ │ │ ├── PxNodeIndex.h
│ │ │ ├── PxPBDMaterial.h
│ │ │ ├── PxPBDParticleSystem.h
│ │ │ ├── PxParticleBuffer.h
│ │ │ ├── PxParticleGpu.h
│ │ │ ├── PxParticleMaterial.h
│ │ │ ├── PxParticleNeighborhoodProvider.h
│ │ │ ├── PxParticleSolverType.h
│ │ │ ├── PxParticleSystem.h
│ │ │ ├── PxParticleSystemFlag.h
│ │ │ ├── PxPhysXConfig.h
│ │ │ ├── PxPhysics.h
│ │ │ ├── PxPhysicsAPI.h
│ │ │ ├── PxPhysicsSerialization.h
│ │ │ ├── PxPruningStructure.h
│ │ │ ├── PxQueryFiltering.h
│ │ │ ├── PxQueryReport.h
│ │ │ ├── PxResidual.h
│ │ │ ├── PxRigidActor.h
│ │ │ ├── PxRigidBody.h
│ │ │ ├── PxRigidDynamic.h
│ │ │ ├── PxRigidStatic.h
│ │ │ ├── PxSDFBuilder.h
│ │ │ ├── PxScene.h
│ │ │ ├── PxSceneDesc.h
│ │ │ ├── PxSceneLock.h
│ │ │ ├── PxSceneQueryDesc.h
│ │ │ ├── PxSceneQuerySystem.h
│ │ │ ├── PxShape.h
│ │ │ ├── PxSimulationEventCallback.h
│ │ │ ├── PxSimulationStatistics.h
│ │ │ ├── PxSmoothing.h
│ │ │ ├── PxSoftBody.h
│ │ │ ├── PxSoftBodyFlag.h
│ │ │ ├── PxSparseGridParams.h
│ │ │ ├── PxVisualizationParameter.h
│ │ │ ├── characterkinematic/
│ │ │ │ ├── PxBoxController.h
│ │ │ │ ├── PxCapsuleController.h
│ │ │ │ ├── PxController.h
│ │ │ │ ├── PxControllerBehavior.h
│ │ │ │ ├── PxControllerManager.h
│ │ │ │ ├── PxControllerObstacles.h
│ │ │ │ └── PxExtended.h
│ │ │ ├── collision/
│ │ │ │ └── PxCollisionDefs.h
│ │ │ ├── common/
│ │ │ │ ├── PxBase.h
│ │ │ │ ├── PxCollection.h
│ │ │ │ ├── PxCoreUtilityTypes.h
│ │ │ │ ├── PxInsertionCallback.h
│ │ │ │ ├── PxPhysXCommonConfig.h
│ │ │ │ ├── PxProfileZone.h
│ │ │ │ ├── PxRenderBuffer.h
│ │ │ │ ├── PxRenderOutput.h
│ │ │ │ ├── PxSerialFramework.h
│ │ │ │ ├── PxSerializer.h
│ │ │ │ ├── PxStringTable.h
│ │ │ │ ├── PxTolerancesScale.h
│ │ │ │ ├── PxTypeInfo.h
│ │ │ │ └── windows/
│ │ │ │ └── PxWindowsDelayLoadHook.h
│ │ │ ├── cooking/
│ │ │ │ ├── PxBVH33MidphaseDesc.h
│ │ │ │ ├── PxBVH34MidphaseDesc.h
│ │ │ │ ├── PxBVHDesc.h
│ │ │ │ ├── PxConvexMeshDesc.h
│ │ │ │ ├── PxCooking.h
│ │ │ │ ├── PxCookingInternal.h
│ │ │ │ ├── PxMidphaseDesc.h
│ │ │ │ ├── PxSDFDesc.h
│ │ │ │ ├── PxTetrahedronMeshDesc.h
│ │ │ │ ├── PxTriangleMeshDesc.h
│ │ │ │ └── Pxc.h
│ │ │ ├── cudamanager/
│ │ │ │ ├── PxCudaContext.h
│ │ │ │ ├── PxCudaContextManager.h
│ │ │ │ └── PxCudaTypes.h
│ │ │ ├── extensions/
│ │ │ │ ├── PxBroadPhaseExt.h
│ │ │ │ ├── PxCollectionExt.h
│ │ │ │ ├── PxConstraintExt.h
│ │ │ │ ├── PxConvexCoreExt.h
│ │ │ │ ├── PxConvexMeshExt.h
│ │ │ │ ├── PxCudaHelpersExt.h
│ │ │ │ ├── PxCustomGeometryExt.h
│ │ │ │ ├── PxCustomSceneQuerySystem.h
│ │ │ │ ├── PxD6Joint.h
│ │ │ │ ├── PxD6JointCreate.h
│ │ │ │ ├── PxDefaultAllocator.h
│ │ │ │ ├── PxDefaultCpuDispatcher.h
│ │ │ │ ├── PxDefaultErrorCallback.h
│ │ │ │ ├── PxDefaultProfiler.h
│ │ │ │ ├── PxDefaultSimulationFilterShader.h
│ │ │ │ ├── PxDefaultStreams.h
│ │ │ │ ├── PxDeformableSkinningExt.h
│ │ │ │ ├── PxDeformableSurfaceExt.h
│ │ │ │ ├── PxDeformableVolumeExt.h
│ │ │ │ ├── PxDistanceJoint.h
│ │ │ │ ├── PxExtensionsAPI.h
│ │ │ │ ├── PxFixedJoint.h
│ │ │ │ ├── PxGearJoint.h
│ │ │ │ ├── PxGjkQueryExt.h
│ │ │ │ ├── PxJoint.h
│ │ │ │ ├── PxJointLimit.h
│ │ │ │ ├── PxMassProperties.h
│ │ │ │ ├── PxParticleClothCooker.h
│ │ │ │ ├── PxParticleExt.h
│ │ │ │ ├── PxPrismaticJoint.h
│ │ │ │ ├── PxRackAndPinionJoint.h
│ │ │ │ ├── PxRaycastCCD.h
│ │ │ │ ├── PxRemeshingExt.h
│ │ │ │ ├── PxRepXSerializer.h
│ │ │ │ ├── PxRepXSimpleType.h
│ │ │ │ ├── PxRevoluteJoint.h
│ │ │ │ ├── PxRigidActorExt.h
│ │ │ │ ├── PxRigidBodyExt.h
│ │ │ │ ├── PxSamplingExt.h
│ │ │ │ ├── PxSceneQueryExt.h
│ │ │ │ ├── PxSceneQuerySystemExt.h
│ │ │ │ ├── PxSerialization.h
│ │ │ │ ├── PxShapeExt.h
│ │ │ │ ├── PxSimpleFactory.h
│ │ │ │ ├── PxSmoothNormals.h
│ │ │ │ ├── PxSoftBodyExt.h
│ │ │ │ ├── PxSphericalJoint.h
│ │ │ │ ├── PxStringTableExt.h
│ │ │ │ ├── PxTetMakerExt.h
│ │ │ │ ├── PxTetrahedronMeshAnalysisResult.h
│ │ │ │ ├── PxTetrahedronMeshExt.h
│ │ │ │ ├── PxTriangleMeshAnalysisResult.h
│ │ │ │ └── PxTriangleMeshExt.h
│ │ │ ├── filebuf/
│ │ │ │ └── PxFileBuf.h
│ │ │ ├── foundation/
│ │ │ │ ├── PxAlignedMalloc.h
│ │ │ │ ├── PxAlloca.h
│ │ │ │ ├── PxAllocator.h
│ │ │ │ ├── PxAllocatorCallback.h
│ │ │ │ ├── PxAoS.h
│ │ │ │ ├── PxArray.h
│ │ │ │ ├── PxAssert.h
│ │ │ │ ├── PxAtomic.h
│ │ │ │ ├── PxBasicTemplates.h
│ │ │ │ ├── PxBitAndData.h
│ │ │ │ ├── PxBitMap.h
│ │ │ │ ├── PxBitUtils.h
│ │ │ │ ├── PxBounds3.h
│ │ │ │ ├── PxBroadcast.h
│ │ │ │ ├── PxConstructor.h
│ │ │ │ ├── PxErrorCallback.h
│ │ │ │ ├── PxErrors.h
│ │ │ │ ├── PxFPU.h
│ │ │ │ ├── PxFlags.h
│ │ │ │ ├── PxFoundation.h
│ │ │ │ ├── PxFoundationConfig.h
│ │ │ │ ├── PxHash.h
│ │ │ │ ├── PxHashInternals.h
│ │ │ │ ├── PxHashMap.h
│ │ │ │ ├── PxHashSet.h
│ │ │ │ ├── PxIO.h
│ │ │ │ ├── PxInlineAllocator.h
│ │ │ │ ├── PxInlineAoS.h
│ │ │ │ ├── PxInlineArray.h
│ │ │ │ ├── PxIntrinsics.h
│ │ │ │ ├── PxMat33.h
│ │ │ │ ├── PxMat34.h
│ │ │ │ ├── PxMat44.h
│ │ │ │ ├── PxMath.h
│ │ │ │ ├── PxMathIntrinsics.h
│ │ │ │ ├── PxMathUtils.h
│ │ │ │ ├── PxMemory.h
│ │ │ │ ├── PxMutex.h
│ │ │ │ ├── PxPhysicsVersion.h
│ │ │ │ ├── PxPinnedArray.h
│ │ │ │ ├── PxPlane.h
│ │ │ │ ├── PxPool.h
│ │ │ │ ├── PxPreprocessor.h
│ │ │ │ ├── PxProfiler.h
│ │ │ │ ├── PxQuat.h
│ │ │ │ ├── PxSIMDHelpers.h
│ │ │ │ ├── PxSList.h
│ │ │ │ ├── PxSimpleTypes.h
│ │ │ │ ├── PxSocket.h
│ │ │ │ ├── PxSort.h
│ │ │ │ ├── PxSortInternals.h
│ │ │ │ ├── PxStrideIterator.h
│ │ │ │ ├── PxString.h
│ │ │ │ ├── PxSync.h
│ │ │ │ ├── PxTempAllocator.h
│ │ │ │ ├── PxThread.h
│ │ │ │ ├── PxTime.h
│ │ │ │ ├── PxTransform.h
│ │ │ │ ├── PxUnionCast.h
│ │ │ │ ├── PxUserAllocated.h
│ │ │ │ ├── PxUtilities.h
│ │ │ │ ├── PxVec2.h
│ │ │ │ ├── PxVec3.h
│ │ │ │ ├── PxVec4.h
│ │ │ │ ├── PxVecMath.h
│ │ │ │ ├── PxVecMathAoSScalar.h
│ │ │ │ ├── PxVecMathAoSScalarInline.h
│ │ │ │ ├── PxVecMathSSE.h
│ │ │ │ ├── PxVecQuat.h
│ │ │ │ ├── PxVecTransform.h
│ │ │ │ ├── unix/
│ │ │ │ │ ├── PxUnixAoS.h
│ │ │ │ │ ├── PxUnixFPU.h
│ │ │ │ │ ├── PxUnixInlineAoS.h
│ │ │ │ │ ├── PxUnixIntrinsics.h
│ │ │ │ │ ├── PxUnixMathIntrinsics.h
│ │ │ │ │ ├── PxUnixTrigConstants.h
│ │ │ │ │ ├── neon/
│ │ │ │ │ │ ├── PxUnixNeonAoS.h
│ │ │ │ │ │ └── PxUnixNeonInlineAoS.h
│ │ │ │ │ └── sse2/
│ │ │ │ │ ├── PxUnixSse2AoS.h
│ │ │ │ │ └── PxUnixSse2InlineAoS.h
│ │ │ │ └── windows/
│ │ │ │ ├── PxWindowsAoS.h
│ │ │ │ ├── PxWindowsFPU.h
│ │ │ │ ├── PxWindowsInclude.h
│ │ │ │ ├── PxWindowsInlineAoS.h
│ │ │ │ ├── PxWindowsIntrinsics.h
│ │ │ │ ├── PxWindowsMathIntrinsics.h
│ │ │ │ └── PxWindowsTrigConstants.h
│ │ │ ├── geometry/
│ │ │ │ ├── PxBVH.h
│ │ │ │ ├── PxBVHBuildStrategy.h
│ │ │ │ ├── PxBoxGeometry.h
│ │ │ │ ├── PxCapsuleGeometry.h
│ │ │ │ ├── PxConvexCoreGeometry.h
│ │ │ │ ├── PxConvexMesh.h
│ │ │ │ ├── PxConvexMeshGeometry.h
│ │ │ │ ├── PxCustomGeometry.h
│ │ │ │ ├── PxGeometry.h
│ │ │ │ ├── PxGeometryHelpers.h
│ │ │ │ ├── PxGeometryHit.h
│ │ │ │ ├── PxGeometryInternal.h
│ │ │ │ ├── PxGeometryQuery.h
│ │ │ │ ├── PxGeometryQueryContext.h
│ │ │ │ ├── PxGeometryQueryFlags.h
│ │ │ │ ├── PxGjkQuery.h
│ │ │ │ ├── PxHeightField.h
│ │ │ │ ├── PxHeightFieldDesc.h
│ │ │ │ ├── PxHeightFieldFlag.h
│ │ │ │ ├── PxHeightFieldGeometry.h
│ │ │ │ ├── PxHeightFieldSample.h
│ │ │ │ ├── PxMeshQuery.h
│ │ │ │ ├── PxMeshScale.h
│ │ │ │ ├── PxParticleSystemGeometry.h
│ │ │ │ ├── PxPlaneGeometry.h
│ │ │ │ ├── PxReportCallback.h
│ │ │ │ ├── PxSimpleTriangleMesh.h
│ │ │ │ ├── PxSphereGeometry.h
│ │ │ │ ├── PxTetrahedron.h
│ │ │ │ ├── PxTetrahedronMesh.h
│ │ │ │ ├── PxTetrahedronMeshGeometry.h
│ │ │ │ ├── PxTriangle.h
│ │ │ │ ├── PxTriangleMesh.h
│ │ │ │ └── PxTriangleMeshGeometry.h
│ │ │ ├── geomutils/
│ │ │ │ ├── PxContactBuffer.h
│ │ │ │ └── PxContactPoint.h
│ │ │ ├── gpu/
│ │ │ │ ├── PxGpu.h
│ │ │ │ └── PxPhysicsGpu.h
│ │ │ ├── omnipvd/
│ │ │ │ └── PxOmniPvd.h
│ │ │ ├── pvd/
│ │ │ │ ├── PxPvd.h
│ │ │ │ ├── PxPvdSceneClient.h
│ │ │ │ └── PxPvdTransport.h
│ │ │ ├── solver/
│ │ │ │ └── PxSolverDefs.h
│ │ │ ├── task/
│ │ │ │ ├── PxCpuDispatcher.h
│ │ │ │ ├── PxTask.h
│ │ │ │ └── PxTaskManager.h
│ │ │ └── vehicle2/
│ │ │ ├── PxVehicleAPI.h
│ │ │ ├── PxVehicleComponent.h
│ │ │ ├── PxVehicleComponentSequence.h
│ │ │ ├── PxVehicleFunctions.h
│ │ │ ├── PxVehicleLimits.h
│ │ │ ├── PxVehicleMaths.h
│ │ │ ├── PxVehicleParams.h
│ │ │ ├── braking/
│ │ │ │ ├── PxVehicleBrakingFunctions.h
│ │ │ │ └── PxVehicleBrakingParams.h
│ │ │ ├── commands/
│ │ │ │ ├── PxVehicleCommandHelpers.h
│ │ │ │ ├── PxVehicleCommandParams.h
│ │ │ │ └── PxVehicleCommandStates.h
│ │ │ ├── drivetrain/
│ │ │ │ ├── PxVehicleDrivetrainComponents.h
│ │ │ │ ├── PxVehicleDrivetrainFunctions.h
│ │ │ │ ├── PxVehicleDrivetrainHelpers.h
│ │ │ │ ├── PxVehicleDrivetrainParams.h
│ │ │ │ └── PxVehicleDrivetrainStates.h
│ │ │ ├── physxActor/
│ │ │ │ ├── PxVehiclePhysXActorComponents.h
│ │ │ │ ├── PxVehiclePhysXActorFunctions.h
│ │ │ │ ├── PxVehiclePhysXActorHelpers.h
│ │ │ │ └── PxVehiclePhysXActorStates.h
│ │ │ ├── physxConstraints/
│ │ │ │ ├── PxVehiclePhysXConstraintComponents.h
│ │ │ │ ├── PxVehiclePhysXConstraintFunctions.h
│ │ │ │ ├── PxVehiclePhysXConstraintHelpers.h
│ │ │ │ ├── PxVehiclePhysXConstraintParams.h
│ │ │ │ └── PxVehiclePhysXConstraintStates.h
│ │ │ ├── physxRoadGeometry/
│ │ │ │ ├── PxVehiclePhysXRoadGeometryComponents.h
│ │ │ │ ├── PxVehiclePhysXRoadGeometryFunctions.h
│ │ │ │ ├── PxVehiclePhysXRoadGeometryHelpers.h
│ │ │ │ ├── PxVehiclePhysXRoadGeometryParams.h
│ │ │ │ └── PxVehiclePhysXRoadGeometryState.h
│ │ │ ├── pvd/
│ │ │ │ ├── PxVehiclePvdComponents.h
│ │ │ │ ├── PxVehiclePvdFunctions.h
│ │ │ │ └── PxVehiclePvdHelpers.h
│ │ │ ├── rigidBody/
│ │ │ │ ├── PxVehicleRigidBodyComponents.h
│ │ │ │ ├── PxVehicleRigidBodyFunctions.h
│ │ │ │ ├── PxVehicleRigidBodyParams.h
│ │ │ │ └── PxVehicleRigidBodyStates.h
│ │ │ ├── roadGeometry/
│ │ │ │ └── PxVehicleRoadGeometryState.h
│ │ │ ├── steering/
│ │ │ │ ├── PxVehicleSteeringFunctions.h
│ │ │ │ └── PxVehicleSteeringParams.h
│ │ │ ├── suspension/
│ │ │ │ ├── PxVehicleSuspensionComponents.h
│ │ │ │ ├── PxVehicleSuspensionFunctions.h
│ │ │ │ ├── PxVehicleSuspensionHelpers.h
│ │ │ │ ├── PxVehicleSuspensionParams.h
│ │ │ │ └── PxVehicleSuspensionStates.h
│ │ │ ├── tire/
│ │ │ │ ├── PxVehicleTireComponents.h
│ │ │ │ ├── PxVehicleTireFunctions.h
│ │ │ │ ├── PxVehicleTireHelpers.h
│ │ │ │ ├── PxVehicleTireParams.h
│ │ │ │ └── PxVehicleTireStates.h
│ │ │ └── wheel/
│ │ │ ├── PxVehicleWheelComponents.h
│ │ │ ├── PxVehicleWheelFunctions.h
│ │ │ ├── PxVehicleWheelHelpers.h
│ │ │ ├── PxVehicleWheelParams.h
│ │ │ └── PxVehicleWheelStates.h
│ │ └── version.txt
│ ├── renderdoc/
│ │ ├── renderdoc/
│ │ │ ├── app/
│ │ │ │ └── renderdoc_app.h
│ │ │ └── replay/
│ │ │ ├── apidefs.h
│ │ │ ├── capture_options.h
│ │ │ ├── common_pipestate.h
│ │ │ ├── control_types.h
│ │ │ ├── d3d11_pipestate.h
│ │ │ ├── d3d12_pipestate.h
│ │ │ ├── data_types.h
│ │ │ ├── gl_pipestate.h
│ │ │ ├── pipestate.h
│ │ │ ├── pipestate.inl
│ │ │ ├── rdcarray.h
│ │ │ ├── rdcdatetime.h
│ │ │ ├── rdcflatmap.h
│ │ │ ├── rdcpair.h
│ │ │ ├── rdcstr.h
│ │ │ ├── renderdoc_replay.h
│ │ │ ├── renderdoc_tostr.inl
│ │ │ ├── replay_enums.h
│ │ │ ├── resourceid.h
│ │ │ ├── shader_types.h
│ │ │ ├── stringise.h
│ │ │ ├── structured_data.h
│ │ │ ├── version.h
│ │ │ └── vk_pipestate.h
│ │ └── version.txt
│ ├── sdl/
│ │ ├── SDL3/
│ │ │ ├── SDL.h
│ │ │ ├── SDL_assert.h
│ │ │ ├── SDL_asyncio.h
│ │ │ ├── SDL_atomic.h
│ │ │ ├── SDL_audio.h
│ │ │ ├── SDL_begin_code.h
│ │ │ ├── SDL_bits.h
│ │ │ ├── SDL_blendmode.h
│ │ │ ├── SDL_camera.h
│ │ │ ├── SDL_clipboard.h
│ │ │ ├── SDL_close_code.h
│ │ │ ├── SDL_copying.h
│ │ │ ├── SDL_cpuinfo.h
│ │ │ ├── SDL_dialog.h
│ │ │ ├── SDL_egl.h
│ │ │ ├── SDL_endian.h
│ │ │ ├── SDL_error.h
│ │ │ ├── SDL_events.h
│ │ │ ├── SDL_filesystem.h
│ │ │ ├── SDL_gamepad.h
│ │ │ ├── SDL_gpu.h
│ │ │ ├── SDL_guid.h
│ │ │ ├── SDL_haptic.h
│ │ │ ├── SDL_hidapi.h
│ │ │ ├── SDL_hints.h
│ │ │ ├── SDL_init.h
│ │ │ ├── SDL_intrin.h
│ │ │ ├── SDL_iostream.h
│ │ │ ├── SDL_joystick.h
│ │ │ ├── SDL_keyboard.h
│ │ │ ├── SDL_keycode.h
│ │ │ ├── SDL_loadso.h
│ │ │ ├── SDL_locale.h
│ │ │ ├── SDL_log.h
│ │ │ ├── SDL_main.h
│ │ │ ├── SDL_main_impl.h
│ │ │ ├── SDL_messagebox.h
│ │ │ ├── SDL_metal.h
│ │ │ ├── SDL_misc.h
│ │ │ ├── SDL_mouse.h
│ │ │ ├── SDL_mutex.h
│ │ │ ├── SDL_oldnames.h
│ │ │ ├── SDL_opengl.h
│ │ │ ├── SDL_opengl_glext.h
│ │ │ ├── SDL_opengles.h
│ │ │ ├── SDL_opengles2.h
│ │ │ ├── SDL_opengles2_gl2.h
│ │ │ ├── SDL_opengles2_gl2ext.h
│ │ │ ├── SDL_opengles2_gl2platform.h
│ │ │ ├── SDL_opengles2_khrplatform.h
│ │ │ ├── SDL_pen.h
│ │ │ ├── SDL_pixels.h
│ │ │ ├── SDL_platform.h
│ │ │ ├── SDL_platform_defines.h
│ │ │ ├── SDL_power.h
│ │ │ ├── SDL_process.h
│ │ │ ├── SDL_properties.h
│ │ │ ├── SDL_rect.h
│ │ │ ├── SDL_render.h
│ │ │ ├── SDL_revision.h
│ │ │ ├── SDL_scancode.h
│ │ │ ├── SDL_sensor.h
│ │ │ ├── SDL_stdinc.h
│ │ │ ├── SDL_storage.h
│ │ │ ├── SDL_surface.h
│ │ │ ├── SDL_system.h
│ │ │ ├── SDL_test.h
│ │ │ ├── SDL_test_assert.h
│ │ │ ├── SDL_test_common.h
│ │ │ ├── SDL_test_compare.h
│ │ │ ├── SDL_test_crc32.h
│ │ │ ├── SDL_test_font.h
│ │ │ ├── SDL_test_fuzzer.h
│ │ │ ├── SDL_test_harness.h
│ │ │ ├── SDL_test_log.h
│ │ │ ├── SDL_test_md5.h
│ │ │ ├── SDL_test_memory.h
│ │ │ ├── SDL_thread.h
│ │ │ ├── SDL_time.h
│ │ │ ├── SDL_timer.h
│ │ │ ├── SDL_touch.h
│ │ │ ├── SDL_tray.h
│ │ │ ├── SDL_version.h
│ │ │ ├── SDL_video.h
│ │ │ └── SDL_vulkan.h
│ │ └── version.txt
│ ├── spirv_cross/
│ │ ├── spirv_cross/
│ │ │ ├── GLSL.std.450.h
│ │ │ ├── spirv.h
│ │ │ ├── spirv.hpp
│ │ │ ├── spirv_cfg.hpp
│ │ │ ├── spirv_common.hpp
│ │ │ ├── spirv_cross.hpp
│ │ │ ├── spirv_cross_c.cpp
│ │ │ ├── spirv_cross_c.h
│ │ │ ├── spirv_cross_containers.hpp
│ │ │ ├── spirv_cross_error_handling.hpp
│ │ │ ├── spirv_cross_parsed_ir.hpp
│ │ │ ├── spirv_glsl.hpp
│ │ │ └── spirv_hlsl.hpp
│ │ └── version.txt
│ ├── vulkan/
│ │ ├── version.txt
│ │ ├── vk_video/
│ │ │ ├── vulkan_video_codec_av1std.h
│ │ │ ├── vulkan_video_codec_av1std_decode.h
│ │ │ ├── vulkan_video_codec_av1std_encode.h
│ │ │ ├── vulkan_video_codec_h264std.h
│ │ │ ├── vulkan_video_codec_h264std_decode.h
│ │ │ ├── vulkan_video_codec_h264std_encode.h
│ │ │ ├── vulkan_video_codec_h265std.h
│ │ │ ├── vulkan_video_codec_h265std_decode.h
│ │ │ ├── vulkan_video_codec_h265std_encode.h
│ │ │ ├── vulkan_video_codec_vp9std.h
│ │ │ ├── vulkan_video_codec_vp9std_decode.h
│ │ │ └── vulkan_video_codecs_common.h
│ │ └── vulkan/
│ │ ├── utility/
│ │ │ ├── vk_concurrent_unordered_map.hpp
│ │ │ ├── vk_dispatch_table.h
│ │ │ ├── vk_format_utils.h
│ │ │ ├── vk_safe_struct.hpp
│ │ │ ├── vk_safe_struct_utils.hpp
│ │ │ ├── vk_small_containers.hpp
│ │ │ ├── vk_sparse_range_map.hpp
│ │ │ └── vk_struct_helper.hpp
│ │ ├── vk_enum_string_helper.h
│ │ ├── vk_icd.h
│ │ ├── vk_layer.h
│ │ ├── vk_platform.h
│ │ ├── vulkan.cppm
│ │ ├── vulkan.h
│ │ ├── vulkan.hpp
│ │ ├── vulkan_android.h
│ │ ├── vulkan_beta.h
│ │ ├── vulkan_core.h
│ │ ├── vulkan_directfb.h
│ │ ├── vulkan_enums.hpp
│ │ ├── vulkan_extension_inspection.hpp
│ │ ├── vulkan_format_traits.hpp
│ │ ├── vulkan_fuchsia.h
│ │ ├── vulkan_funcs.hpp
│ │ ├── vulkan_ggp.h
│ │ ├── vulkan_handles.hpp
│ │ ├── vulkan_hash.hpp
│ │ ├── vulkan_hpp_macros.hpp
│ │ ├── vulkan_ios.h
│ │ ├── vulkan_layer_settings.hpp
│ │ ├── vulkan_macos.h
│ │ ├── vulkan_metal.h
│ │ ├── vulkan_ohos.h
│ │ ├── vulkan_profiles.hpp
│ │ ├── vulkan_raii.hpp
│ │ ├── vulkan_screen.h
│ │ ├── vulkan_shared.hpp
│ │ ├── vulkan_static_assertions.hpp
│ │ ├── vulkan_structs.hpp
│ │ ├── vulkan_to_string.hpp
│ │ ├── vulkan_vi.h
│ │ ├── vulkan_video.cppm
│ │ ├── vulkan_video.hpp
│ │ ├── vulkan_wayland.h
│ │ ├── vulkan_win32.h
│ │ ├── vulkan_xcb.h
│ │ ├── vulkan_xlib.h
│ │ └── vulkan_xlib_xrandr.h
│ ├── vulkan_memory_allocator/
│ │ ├── version.txt
│ │ └── vk_mem_alloc.h
│ └── xess/
│ ├── version.txt
│ └── xess/
│ ├── xess.h
│ ├── xess_d3d11.h
│ ├── xess_d3d12.h
│ ├── xess_d3d12_debug.h
│ ├── xess_debug.h
│ ├── xess_vk.h
│ └── xess_vk_debug.h
└── worlds/
└── plan.world
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
# top-most EditorConfig file
root = true
# ----------------------------------------------------------------------
# Global defaults for all files
# ----------------------------------------------------------------------
[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
indent_style = space
indent_size = 4
tab_width = 4
max_line_length = 120
force_editorconfig_settings = true
================================================
FILE: .gitattributes
================================================
# Ensure LF line endings in the repository and proper handling on checkouts
* text=auto
# C++ source and header files
*.cpp text diff=cpp
*.h text diff=cpp
*.hpp text diff=cpp
*.cxx text diff=cpp
*.cc text diff=cpp
# Treat project files that are often not merge-friendly as binary to avoid merge conflicts
*.sln binary
*.vcxproj binary
*.vcproj binary
*.proj binary
*.projitems binary
*.filters binary
# Treat build scripts and cmake configs as text
*.bat text eol=crlf
*.sh text eol=lf
CMakeLists.txt text
*.cmake text
# Image files are treated as binary to prevent corruption
*.png binary
*.jpg binary
*.jpeg binary
*.gif binary
*.ico binary
# Documentation and other text formats should have normalized line endings
*.md text
*.txt text
*.rtf text
# Lock binary files to avoid line ending modifications
*.exe binary
*.dll binary
*.so binary
*.lib binary
*.obj binary
*.o binary
# Ensure that diffs for certain types of files are handled correctly
*.json text diff=json
*.xml text diff=xml
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help improve the engine
title: ''
labels: ''
assignees: ''
---
### Bug Report
**Issue:**
[Briefly describe what the issue is.]
**Steps to Reproduce:**
1.
2.
3.
...
**Expected Outcome:**
[What should happen when steps are followed.]
**Actual Outcome:**
[What actually happened.]
**Environment:**
- Operating System:
- Visual Studio (if used):
- GPU
- CPU
**Log.txt (if it exists) or screenshots:**
[Attach any screenshots or logs related to the issue here.]
**Callstack:**
================================================
FILE: .github/workflows/workflow.yml
================================================
name: build
on:
push:
paths-ignore:
- '**.md'
- 'funding.yml'
- '.gitignore'
- '.gitattributes'
- '.github/images'
- '.github/ISSUE_TEMPLATE'
pull_request:
paths-ignore:
- '**.md'
- 'funding.yml'
- '.gitignore'
- '.gitattributes'
- '.github/images'
- '.github/ISSUE_TEMPLATE'
jobs:
build:
strategy:
matrix:
include:
- api: vulkan
configuration: release
- api: vulkan
configuration: debug
- api: d3d12
configuration: release
runs-on: windows-2022
steps:
- uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.9'
- name: Install Python dependencies
run: python -m pip install requests tqdm
- name: Setup MSBuild / Visual Studio Environment
uses: microsoft/setup-msbuild@v1
with:
vs-version: '[17.0,18.0)'
- name: Show MSVC version (for debugging)
shell: cmd
run: |
where msbuild
msbuild /version
call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && cl
- name: Generate project files
shell: python
working-directory: ${{ github.workspace }}
env:
API: ${{ matrix.api }}
run: |
import subprocess
import os
api = os.environ["API"]
choice = "1" if api == "vulkan" else "2"
subprocess.run(["python", "generate_project_files.py", choice])
- name: Verify solution file exists
shell: cmd
working-directory: ${{ github.workspace }}
run: |
if not exist spartan.slnx (
echo Error: spartan.slnx not found!
dir *.sln*
exit /b 1
)
echo Solution file found: spartan.slnx
- name: Build
shell: cmd
working-directory: ${{ github.workspace }}
run: msbuild /p:Platform=x64 /p:Configuration=${{ matrix.configuration }} /p:PlatformToolset=v143 /m spartan.slnx
- name: Create artifacts
if: github.event_name != 'pull_request' && matrix.api == 'vulkan'
shell: cmd
run: |
echo "Creating artifacts for ${{ matrix.api }} - ${{ matrix.configuration }}"
IF "${{ matrix.configuration }}" == "release" (
echo "Creating binaries-only archive for Release..."
build_scripts\7z.exe a -bb1 spartan_vulkan_release.7z .\binaries\7z.exe .\binaries\7z.dll .\binaries\dxcompiler.dll .\binaries\libxess.dll .\binaries\data .\binaries\spartan_${{ matrix.api }}.exe
) ELSE (
echo "Creating binaries-only archive for Debug..."
build_scripts\7z.exe a -bb1 spartan_vulkan_debug.7z .\binaries\7z.exe .\binaries\7z.dll .\binaries\libxess.dll .\binaries\data .\binaries\spartan_${{ matrix.api }}_debug.exe
)
echo "Artifact creation completed for ${{ matrix.api }} - ${{ matrix.configuration }}"
- name: Upload artifact
if: github.event_name != 'pull_request' && matrix.api == 'vulkan'
uses: actions/upload-artifact@v4
with:
name: spartan_vulkan_${{ matrix.configuration == 'Release' && 'release' || 'debug' }}
path: spartan_vulkan_${{ matrix.configuration == 'Release' && 'release' || 'debug' }}.7z
release:
if: github.event_name != 'pull_request'
runs-on: ubuntu-latest
needs: build
permissions:
contents: write
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Download vulkan release build
uses: actions/download-artifact@v4
with:
name: spartan_vulkan_release
path: .
- name: Download vulkan debug build
uses: actions/download-artifact@v4
with:
name: spartan_vulkan_debug
path: .
- name: Get date and time for versioning
id: get_datetime
run: echo "version=$(date +'%Y.%m.%d.%H.%M')" >> $GITHUB_OUTPUT
- name: Rename release artifact
run: |
mv spartan_vulkan_release.7z spartan_vulkan_release_${{ steps.get_datetime.outputs.version }}.7z
- name: Rename debug artifact
run: |
mv spartan_vulkan_debug.7z spartan_vulkan_debug_${{ steps.get_datetime.outputs.version }}.7z
- name: Generate release notes
id: generate_release_notes
uses: actions/github-script@v7
with:
script: |
// 1. Fetch Releases and Commits
const { data: releases } = await github.rest.repos.listReleases({
owner: context.repo.owner,
repo: context.repo.repo,
per_page: 1
});
let commits = [];
const lastRelease = releases[0];
if (lastRelease && lastRelease.tag_name) {
const { data: compareData } = await github.rest.repos.compareCommits({
owner: context.repo.owner,
repo: context.repo.repo,
base: lastRelease.tag_name,
head: context.sha
});
commits = compareData.commits || [];
} else {
const { data: recentCommits } = await github.rest.repos.listCommits({
owner: context.repo.owner,
repo: context.repo.repo,
per_page: 50
});
commits = recentCommits || [];
}
// 2. Format Commits
const commitLines = commits
.filter(commit => !commit.commit.message.startsWith('Merge'))
.map(commit => {
const shortSha = commit.sha.substring(0, 7);
const message = commit.commit.message.split('\n')[0];
const url = commit.html_url;
return `- [\`${shortSha}\`](${url}) ${message}`;
});
// 3. Extract Unique Contributors (Restored this logic)
const authorSet = new Set();
commits.forEach(commit => {
if (commit.author && commit.author.login) {
authorSet.add(commit.author.login);
} else {
authorSet.add(commit.commit.author.name);
}
});
const authors = [...authorSet];
let finalNotes = "";
if (commitLines.length > 0) {
finalNotes += commitLines.join('\n');
// Add Contributors section manually (Required because we are using a custom body)
if (authors.length > 0) {
finalNotes += "\n\n### Contributors\n\n";
finalNotes += authors.map(a => `@${a}`).join(', ');
}
} else {
finalNotes = "- Initial release or no new commits found";
}
// 4. Write Direct to Output
const fs = require('fs');
const delimiter = 'EOF_' + Math.random().toString(36).substr(2, 9);
fs.appendFileSync(process.env.GITHUB_OUTPUT, `notes<<${delimiter}\n${finalNotes}\n${delimiter}\n`);
- name: Publish release
uses: softprops/action-gh-release@v2
with:
tag_name: ${{ steps.get_datetime.outputs.version }}
name: "Spartan v${{ steps.get_datetime.outputs.version }}"
body: ${{ steps.generate_release_notes.outputs.notes }}
prerelease: true
files: |
spartan_vulkan_release_${{ steps.get_datetime.outputs.version }}.7z
spartan_vulkan_debug_${{ steps.get_datetime.outputs.version }}.7z
================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
# User-specific files
*.sln
*.vcxproj
*.vcxproj.filters
*.suo
*.user
*.userosscache
*.sln.docstates
*.VC.opendb
*.VC.db
/Binaries
/third_party/libraries/*.lib
/third_party/libraries/*.dll
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
[Xx]64/
[Xx]86/
[Bb]uild/
bld/
[Bb]in/
[Oo]bj/
# Visual Studio 2015 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUNIT
*.VisualState.xml
TestResult.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# DNX
project.lock.json
artifacts/
*_i.c
*_p.c
*_i.h
*.ilk
*.meta
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# JustCode is a .NET coding add-in
.JustCode
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# TODO: Un-comment the next line if you do not want to checkin
# your web deploy settings because they may include unencrypted
# passwords
#*.pubxml
*.publishproj
# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/packages/*
# except build/, which is used as an MSBuild target.
!**/packages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/packages/repositories.config
# NuGet v3's project.json files produces more ignoreable files
*.nuget.props
*.nuget.targets
# Microsoft Azure Build Output
csx/
*.build.csdef
# Microsoft Azure Emulator
ecf/
rcf/
# Microsoft Azure ApplicationInsights config file
ApplicationInsights.config
# Windows Store app package directory
AppPackages/
BundleArtifacts/
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!*.[Cc]ache/
# Others
ClientBin/
[Ss]tyle[Cc]op.*
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.pfx
*.publishsettings
node_modules/
orleans.codegen.cs
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
# SQL Server files
*.mdf
*.ldf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
# Microsoft Fakes
FakesAssemblies/
# GhostDoc plugin setting file
*.GhostDoc.xml
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions
# LightSwitch generated files
GeneratedArtifacts/
ModelManifest.xml
# Paket dependency manager
.paket/paket.exe
# FAKE - F# Make
.fake/
.vscode/
# Rider IDE config dir
.idea/
/third_party/libraries/libraries.7z
/assets
/assets
/build_scripts/__pycache__/file_utilities.cpython-312.pyc
/build_scripts/__pycache__/file_utilities.cpython-313.pyc
/spartan.slnx
*.pyc
/nul
================================================
FILE: build_scripts/Dockerfile
================================================
FROM ubuntu:22.04
# Get all the necessary dependencies from the package manager
RUN apt update -y &&\
apt install -y build-essential libassimp-dev librenderdoc-dev libfreetype-dev libbullet-dev libsdl2-dev libspirv-cross-c-shared-dev git python3 libvulkan-dev pkg-config cmake wget unzip p7zip-full python3-pip &&\
mkdir /deps
RUN pip install requests
# Download and install premake5
RUN cd /deps &&\
mkdir premake5; cd premake5 &&\
wget https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-linux.tar.gz &&\
tar xvf premake-5.0.0-beta2-linux.tar.gz &&\
mv premake5 /bin/premake5
# Download, build and install the compressonator library
RUN cd /deps &&\
git clone --recursive --depth=1 https://github.com/GPUOpen-Tools/Compressonator.git; cd Compressonator &&\
cd scripts/; python3 fetch_dependencies.py; cd .. &&\
cmake -DOPTION_ENABLE_ALL_APPS=OFF -DOPTION_BUILD_CMP_SDK=ON -DOPTION_CMP_OPENGL=OFF -DOPTION_CMP_QT=OFF -DOPTION_CMP_OPENCV=OFF &&\
make -j $(nproc); \
mkdir /usr/lib/Compressonator; cp cmp_compressonatorlib/compressonator.h /usr/include/compressonator.h &&\
cp lib/*.a /usr/lib
# Download and install the DirectXShaderCompiler library
RUN cd /deps &&\
wget https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.7.2308/linux_dxc_2023_08_14.x86_64.tar.gz &&\
mkdir linux_dxc_2023_08_14; cd linux_dxc_2023_08_14 &&\
tar xvf ../linux_dxc_2023_08_14.x86_64.tar.gz &&\
cp -r include/* /usr/include/dxc/ &&\
cp lib/* /usr/lib/
# Download and install FreeImage
COPY patches/freeimage.patch /deps/freeimage.patch
RUN cd /deps &&\
wget https://sourceforge.net/projects/freeimage/files/Source%20Distribution/3.18.0/FreeImage3180.zip &&\
unzip FreeImage3180 &&\
cd FreeImage/ &&\
git apply ../freeimage.patch &&\
make -f Makefile.gnu libfreeimage-3.18.0.so -j $(nproc) &&\
cp libfreeimage-3.18.0.so /usr/lib/libFreeImageLib.so &&\
mkdir /usr/include/FreeImage &&\
cp Source/FreeImage.h Source/Utilities.h /usr/include/FreeImage
# Download and install OpenImageDenoiser
RUN cd /deps &&\
wget https://github.com/RenderKit/oidn/releases/download/v2.3.0/oidn-2.3.0.x86_64.linux.tar.gz &&\
tar xvf oidn-2.3.0.x86_64.linux.tar.gz &&\
rm oidn-2.3.0.x86_64.linux.tar.gz &&\
cd oidn-2.3.0.x86_64.linux &&\
cp -r include/OpenImageDenoise/ /usr/include/OpenImageDenoise &&\
cp -r lib/*.so* /usr/lib/
# Clean up all the intermediate directories created for building and installing external dependencies
RUN rm -rf /deps/
================================================
FILE: build_scripts/ci_test.bat
================================================
cd binaries
spartan_%1.exe -ci_test
timeout /t 10
================================================
FILE: build_scripts/file_utilities.py
================================================
# Copyright(c) 2015-2026 Panos Karabelas
#
# 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.
import hashlib
import importlib
import os
import shutil
import stat
import subprocess
import sys
from pathlib import Path
def install_and_import(package):
try:
importlib.import_module(package)
except ImportError:
print(f"{package} not installed. Installing now...")
subprocess.check_call([sys.executable, "-m", "pip", "install", package])
finally:
globals()[package] = importlib.import_module(package)
install_and_import('tqdm')
install_and_import('requests')
install_and_import('tenacity')
import requests
from tqdm import tqdm
from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
def calculate_file_hash(file_path):
hash_func = hashlib.new("sha256")
with open(file_path, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
hash_func.update(chunk)
return hash_func.hexdigest()
def download_file(url, destination, expected_hash, max_retries=3, chunk_size=1024):
"""
Download a file with retry and resume support.
Args:
url (str): URL of the file to download.
destination (str): Local path to save the file.
expected_hash (str): Expected SHA256 hash of the file.
max_retries (int): Maximum number of retry attempts.
chunk_size (int): Size of chunks to read/write.
"""
# Ensure destination directory exists
os.makedirs(os.path.dirname(destination), exist_ok=True)
# Check if file exists and get its size
current_size = 0
if os.path.exists(destination):
if calculate_file_hash(destination) == expected_hash:
print(f"File {destination} already exists with the correct hash. Skipping download.")
return True
current_size = os.path.getsize(destination)
@retry(
stop=stop_after_attempt(max_retries),
wait=wait_exponential(multiplier=1, min=4, max=10),
retry=retry_if_exception_type((requests.ConnectionError, requests.Timeout, requests.HTTPError)),
reraise=True
)
def download_with_retry():
nonlocal current_size
headers = {'Range': f'bytes={current_size}-'} if current_size > 0 else {}
mode = 'ab' if current_size > 0 else 'wb'
print(f"\nDownloading {destination} (Starting from: {current_size:,} bytes)...")
response = None
try:
response = requests.get(url, stream=True, headers=headers, timeout=30)
response.raise_for_status() # Raise exception for bad status codes
# Determine total_size
total_size = None
if 'content-length' in response.headers:
remaining = int(response.headers['content-length'])
else:
remaining = None
# Parse content-range if available
if 'content-range' in response.headers:
cr = response.headers['content-range']
total_str = cr.rsplit('/', 1)[-1]
if total_str.isdigit():
total_size = int(total_str)
# If content-length available but no total from range, compute it
if remaining is not None and total_size is None:
total_size = current_size + remaining
# Check if server supports range requests
if current_size > 0 and response.status_code != 206:
print("Server does not support range requests. Restarting download from scratch...")
response.close()
# Truncate the file to zero
open(destination, 'wb').close()
current_size = 0
raise requests.RequestException("Restarting due to lack of range support") # Trigger retry to restart
# Print total size if known
if total_size is not None:
print(f"Total size detected: {total_size:,} bytes")
# Now create tqdm with known total or None
t = tqdm(total=total_size, initial=current_size, unit='iB', unit_scale=True)
# Open file and download
with open(destination, mode) as f:
for chunk in response.iter_content(chunk_size):
if chunk: # Filter out keep-alive chunks
f.write(chunk)
t.update(len(chunk))
except requests.RequestException as e:
print(f"Download failed: {e}. Retrying...")
raise
finally:
if response:
response.close()
t.close()
# Verify file size if known
downloaded_size = os.path.getsize(destination)
if total_size is not None and downloaded_size != total_size:
print(f"Download incomplete: {downloaded_size:,} of {total_size:,} bytes downloaded.")
raise requests.RequestException("Incomplete download")
# Verify hash
downloaded_hash = calculate_file_hash(destination)
if downloaded_hash != expected_hash:
print(f"Hash mismatch. Expected: {expected_hash}, Got: {downloaded_hash}. Downloaded file is corrupted.")
raise requests.RequestException("Hash mismatch")
print(f"Successfully downloaded {destination}.")
return True
try:
return download_with_retry()
except Exception as e:
print(f"Failed to download {destination} after {max_retries} attempts: {e}")
return False
def extract_archive(archive_path, destination_path):
# Check if 7z.exe exists locally
current_dir_7z = Path("7z.exe")
if current_dir_7z.exists():
seven_zip_exe = current_dir_7z
else:
# define the path where 7z.exe should be if not in the current directory
seven_zip_exe = Path("build_scripts") / "7z.exe"
seven_zip_exe = seven_zip_exe.resolve()
# check if the 7z executable exists
if not os.path.exists(seven_zip_exe):
raise FileNotFoundError(f"The 7z executable was not found at {seven_zip_exe}. Please check the path or installation.")
archive_path_str = str(Path(archive_path).resolve())
destination_path_str = str(Path(destination_path).resolve())
cmd = [str(seven_zip_exe), 'x', archive_path_str, '-o'+destination_path_str, '-aoa']
print(f"Extracting {archive_path} to {destination_path} using: {seven_zip_exe}")
try:
result = subprocess.run(cmd, check=True, capture_output=True, text=True)
print(result.stdout)
except subprocess.CalledProcessError as e:
print(f"An error occurred while extracting: {e}")
print(f"Error output: {e.stderr}")
raise
def copy(source, destination):
def on_rm_error(func, path, exc_info):
os.chmod(path, stat.S_IWRITE)
func(path)
source_path = Path(source).resolve()
dest_path = Path(destination).resolve()
# check if source is a directory or file
if source_path.is_dir():
# if source is a directory, ensure destination is a directory too
dest_path.mkdir(parents=True, exist_ok=True) # Create the destination directory if it doesn't exist
print(f"Copying directory \"{source_path}\" to directory \"{dest_path}\"...")
shutil.rmtree(str(dest_path), onerror=on_rm_error)
shutil.copytree(str(source_path), str(dest_path), dirs_exist_ok=True)
elif source_path.is_file():
# if source is a file, ensure the parent directory of the destination exists
dest_path.parent.mkdir(parents=True, exist_ok=True) # Create parent directory if it doesn't exist
target = dest_path if dest_path.is_file() else dest_path / source_path.name
print(f"Copying file \"{source_path}\" to \"{target}\"...")
shutil.copy2(str(source_path), str(target))
else:
print(f"Error: Source '{source_path}' is neither a file nor a directory.")
return False
return True
================================================
FILE: build_scripts/generate_project_files.py
================================================
# Copyright(c) 2016-2025 Panos Karabelas
#
# 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.
import os
import shutil
import stat
import subprocess
import sys
from pathlib import Path
import file_utilities
paths = {
"binaries": {
"data": Path("binaries") / "data",
"models": Path("binaries") / "project" / "models",
"music": Path("binaries") / "project" / "music",
"terrain": Path("binaries") / "project" / "terrain",
"materials": Path("binaries") / "project" / "materials",
},
"third_party_libs": {
"dx": Path("third_party") / "libraries" / "dxcompiler.dll",
"xess": Path("third_party") / "libraries" / "libxess.dll",
},
"assets": {
"models": Path("assets") / "models",
"music": Path("assets") / "music",
"terrain": Path("assets") / "terrain",
"materials": Path("assets") / "materials",
},
}
def generate_project_files():
# determine if we're using Windows or another platform
is_windows = sys.argv[1].startswith("vs") # Assuming 'vs' prefix for Visual Studio
# construct the command, stripping any surrounding quotes from arguments
premake_exe = Path.cwd() / "build_scripts" / ("premake5.exe" if is_windows else "premake5")
premake_lua = Path("build_scripts") / "premake.lua"
# remove quotes if they exist around sys.argv[1] and sys.argv[2]
action = sys.argv[1].strip('"')
platform = sys.argv[2].strip('"')
# construct the command as a string with quoted paths
cmd = f'"{str(premake_exe)}" --file="{str(premake_lua)}" "{action}" "{platform}"'
print("Running command:", cmd)
try:
result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
print(result.stdout)
if result.stderr:
print(result.stderr)
if result.returncode != 0:
print(f"\nPremake failed with exit code {result.returncode}")
input("\nPress Enter to exit...")
sys.exit(1)
except Exception as e:
print(f"An unexpected error occurred: {e}")
input("\nPress Enter to exit...")
sys.exit(1)
def main():
is_ci = "ci" in sys.argv
print("\n1. Create binaries folder with the required data files...\n")
file_utilities.copy("data", paths["binaries"]["data"])
file_utilities.copy(Path("build_scripts") / "7z.exe", "binaries")
file_utilities.copy(Path("build_scripts") / "7z.dll", "binaries")
print("\n2. Download and extract libraries...")
library_url = 'https://www.dropbox.com/scl/fi/bqm5ds2jgal9i4xqlq9p7/libraries.7z?rlkey=2tjj312w4jd0sxavdrpzt7aru&st=kkutkjir&dl=1'
library_expected_hash = 'd84b0e2c9bf3622f48f3a0f7b3a00d0f9cf11925b75067879923081516eedf15'
library_destination = Path("third_party") / "libraries" / "libraries.7z"
file_utilities.download_file(library_url, str(library_destination), library_expected_hash)
file_utilities.extract_archive(str(library_destination), str(Path("third_party") / "libraries"))
print("3. Copying required DLLs to the binary directory...")
for lib in paths["third_party_libs"].values():
file_utilities.copy(lib, Path("binaries"))
print("\n4. Generate project files...\n")
generate_project_files()
if not is_ci:
input("\nPress any key to continue...")
sys.exit(0)
if __name__ == "__main__":
main()
================================================
FILE: build_scripts/hash_printer.py
================================================
#Copyright(c) 2016-2024 Panos Karabelas
#
#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.
import os
from pathlib import Path
import file_utilities
def print_local_file_hashes():
local_files = {
'libraries': '../third_party/libraries/libraries.7z',
'project': '../binaries/project/project.7z'
}
print("Local file hashes:")
for name, path in local_files.items():
if os.path.exists(path):
hash = file_utilities.calculate_file_hash(path)
print(f"{name}: {hash}")
else:
print(f"{name}: File not found")
# wait for user input to give them time to read the hashes
input("\nPress Enter to continue...")
if __name__ == "__main__":
print_local_file_hashes()
================================================
FILE: build_scripts/premake.lua
================================================
-- Copyright(c) 2015-2025 Panos Karabelas
--
-- 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.
CPP_VERSION = "C++20"
SOLUTION_NAME = "spartan"
EXECUTABLE_NAME = "spartan"
SOURCE_DIR = "../source"
LIBRARY_DIR = "../third_party/libraries"
OBJ_DIR = "../binaries/obj"
TARGET_DIR = "../binaries"
API_CPP_DEFINE = ""
ARG_API_GRAPHICS = _ARGS[1]
function configure_graphics_api()
if ARG_API_GRAPHICS == "d3d12" then
API_CPP_DEFINE = "API_GRAPHICS_D3D12"
EXECUTABLE_NAME = EXECUTABLE_NAME .. "_d3d12"
elseif ARG_API_GRAPHICS == "vulkan" then
API_CPP_DEFINE = "API_GRAPHICS_VULKAN"
EXECUTABLE_NAME = EXECUTABLE_NAME .. "_vulkan"
else
error("Unsupported graphics API: " .. tostring(ARG_API_GRAPHICS))
end
end
function solution_configuration()
solution(SOLUTION_NAME)
location ".."
language "C++"
configurations { "debug", "release" }
fatalwarnings { "All" }
filter { "configurations:debug" }
defines { "DEBUG" }
flags { "MultiProcessorCompile" }
optimize "Off"
symbols "On"
debugformat "c7"
filter { "configurations:release" }
flags { "MultiProcessorCompile" }
linktimeoptimization "On"
optimize "Speed"
symbols "Off"
filter { "system:windows" }
platforms { "x64" }
toolset "msc"
systemversion "latest"
architecture "x64"
buildoptions { "/arch:AVX2" }
filter { "system:linux" }
platforms { "x64" }
system "linux"
architecture "x86_64"
buildoptions { "-mavx2" }
end
function spartan_project_configuration()
project(SOLUTION_NAME)
location "../"
objdir(OBJ_DIR)
cppdialect(CPP_VERSION)
kind "WindowedApp"
staticruntime "On"
defines { API_CPP_DEFINE }
libdirs { LIBRARY_DIR }
files {
SOURCE_DIR .. "/**.h", SOURCE_DIR .. "/**.cpp",
SOURCE_DIR .. "/**.hpp", SOURCE_DIR .. "/**.inl",
SOURCE_DIR .. "/**.rc"
}
if ARG_API_GRAPHICS == "d3d12" then
removefiles { SOURCE_DIR .. "/runtime/RHI/Vulkan/**" }
elseif ARG_API_GRAPHICS == "vulkan" then
removefiles { SOURCE_DIR .. "/runtime/RHI/D3D12/**" }
end
pchheader "pch.h"
pchsource(SOURCE_DIR .. "/runtime/Core/pch.cpp")
-- Windows includes for all builds
filter { "system:windows" }
includedirs {
SOURCE_DIR, SOURCE_DIR .. "/runtime", SOURCE_DIR .. "/runtime/Core", SOURCE_DIR .. "/editor",
"../third_party/sdl", "../third_party/assimp", "../third_party/physx", "../third_party/free_image",
"../third_party/free_type", "../third_party/compressonator", "../third_party/renderdoc",
"../third_party/meshoptimizer", "../third_party/dxc", "../third_party/nrd", "../third_party/openxr",
"../third_party/lua", "../third_party/lua/lua"
}
linkoptions {
"/LIBPATH:" .. path.getabsolute("../third_party/libraries"),
"/NODEFAULTLIB:MSVCRT.lib", -- block dynamic crt (using static runtime)
"/NODEFAULTLIB:MSVCPRT.lib"
}
buildoptions { "/bigobj" }
-- Linux includes
filter { "system:linux" }
includedirs {
SOURCE_DIR, SOURCE_DIR .. "/runtime", SOURCE_DIR .. "/runtime/Core", SOURCE_DIR .. "/editor",
"/usr/include/SDL3", "/usr/include/assimp", "/usr/include/physx",
"/usr/include/freetype2", "/usr/include/renderdoc"
}
-- Vulkan-specific includes (Windows only)
filter { "system:windows" }
if ARG_API_GRAPHICS == "vulkan" then
includedirs {
"../third_party/spirv_cross",
"../third_party/vulkan",
"../third_party/fidelityfx",
"../third_party/xess",
"../third_party/vulkan_memory_allocator"
}
end
-- Release configuration
filter { "configurations:release" }
targetname(EXECUTABLE_NAME)
targetdir(TARGET_DIR)
debugdir(TARGET_DIR)
links { "dxcompiler", "assimp", "FreeImageLib", "freetype", "SDL3", "Compressonator_MT", "meshoptimizer", "NRD", "ShaderMakeBlob", "openxr_loader", "lua" }
links {
"PhysX_static_64", "PhysXCommon_static_64", "PhysXFoundation_static_64", "PhysXExtensions_static_64",
"PhysXPvdSDK_static_64", "PhysXCooking_static_64", "PhysXVehicle2_static_64", "PhysXCharacterKinematic_static_64"
}
filter { "system:windows", "configurations:release" }
if ARG_API_GRAPHICS == "vulkan" then
links {
"spirv-cross-c", "spirv-cross-core", "spirv-cross-cpp", "spirv-cross-glsl", "spirv-cross-hlsl",
"ffx_backend_vk_x64", "ffx_frameinterpolation_x64", "ffx_fsr3_x64", "ffx_fsr3upscaler_x64",
"ffx_opticalflow_x64", "ffx_denoiser_x64", "libxess"
}
end
-- Debug configuration
filter { "configurations:debug" }
targetname(EXECUTABLE_NAME .. "_debug")
targetdir(TARGET_DIR)
debugdir(TARGET_DIR)
links { "dxcompiler" }
linkoptions { "/IGNORE:4099" }
filter { "configurations:debug", "system:windows" }
links { "assimp_debug", "FreeImageLib_debug", "freetype_debug", "SDL3_debug", "Compressonator_MT_debug", "meshoptimizer_debug", "NRD_debug", "ShaderMakeBlob_debug", "openxr_loader_debug", "lua_debug" }
links {
"PhysX_static_64_debug", "PhysXCommon_static_64_debug", "PhysXFoundation_static_64_debug", "PhysXExtensions_static_64_debug",
"PhysXPvdSDK_static_64_debug", "PhysXCooking_static_64_debug", "PhysXVehicle2_static_64_debug", "PhysXCharacterKinematic_static_64_debug"
}
if ARG_API_GRAPHICS == "vulkan" then
links {
"spirv-cross-c_debug", "spirv-cross-core_debug", "spirv-cross-cpp_debug", "spirv-cross-glsl_debug", "spirv-cross-hlsl_debug",
"ffx_backend_vk_x64d", "ffx_frameinterpolation_x64d", "ffx_fsr3_x64d", "ffx_fsr3upscaler_x64d",
"ffx_opticalflow_x64d", "ffx_denoiser_x64d", "libxess"
}
end
filter { "configurations:debug", "system:linux" }
links { "assimp", "FreeImageLib", "freetype", "SDL3", "Compressonator_MT" }
end
configure_graphics_api()
solution_configuration()
spartan_project_configuration()
================================================
FILE: code_of_conduct.md
================================================
# **Core Principles**
## **Free Speech, Reason and Respect**
We believe in the power of dialogue and exchanging ideas. Disagreeing with someone does not mean you dislike, hate, or cancel them. Say what you think, debate hard if you must, but do it constructively. Growth comes from ideas, not drama.
Be kind, be reasonable. A strong argument does not need insults to land. Let your points speak for themselves.
---
## **Self-Preservation of the Discord Community**
Free speech is vital, but if someone becomes highly toxic, attacks others, and drives members away, killing the community, we draw the line. There is no room for suicidal empathy when the server’s survival is at stake.
---
## **Expected Behavior**
1. **Engage Constructively**: Share your thoughts and opinions without hostility or malice.
2. **Be Kind**: Treat others with respect and empathy, even in strong disagreements.
3. **Stay on Topic**: Keep discussions focused on the community’s goals and purpose.
4. **Help Others**: Offer support, share insights, and build connections.
---
## **Unacceptable Behavior**
To protect the community, the following behaviors will not be tolerated because they threaten the server’s survival:
- Lying, spreading false information, or misrepresenting facts.
- Personal attacks, insults, or hostility toward others.
- Refusing to engage in constructive dialogue when conflicts arise.
These actions put the community at risk and will be addressed immediately.
---
## **Enforcement**
We value dialogue first. Problematic behavior will be handled like this:
1. **Discussion**: The person will be confronted directly and honestly to resolve the issue.
2. **Ban**: If dialogue fails and the behavior continues to threaten the community, a ban will be issued immediately. Protecting the community comes first.
---
## **Reporting Issues**
If you see behavior that breaks this Code of Conduct, contact Panos Karabelas immediately, publicly or privately, by any available means.
================================================
FILE: data/fonts/OpenSans/OFL.txt
================================================
Copyright 2020 The Open Sans Project Authors (https://github.com/googlefonts/opensans)
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL
-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.
The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).
"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.
"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.
PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:
1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.
2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.
3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.
5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.
TERMINATION
This license becomes null and void if any of the above conditions are
not met.
DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.
================================================
FILE: data/shaders/amd_fidelity_fx/cas.hlsl
================================================
/*
Copyright(c) 2016-2024 Panos Karabelas
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.
*/
//= INCLUDES ============
#include "../common.hlsl"
//=======================
#define A_GPU
#define A_HLSL
#include "ffx_a.h"
// functions ffx_cas.h wants defined
float3 CasLoad(float2 pos)
{
return tex[pos].rgb;
}
// lets you transform input from the load into a linear color space between 0 and 1.
void CasInput(inout float r, inout float g, inout float b)
{
}
#include "ffx_cas.h"
[numthreads(THREAD_GROUP_COUNT_X, THREAD_GROUP_COUNT_Y, 1)]
void main_cs(uint3 thread_id : SV_DispatchThreadID)
{
float2 resolution_out;
tex_uav.GetDimensions(resolution_out.x, resolution_out.y);
if (any(int2(thread_id.xy) >= resolution_out))
return;
float4 const0;
float4 const1;
float sharpness = pass_get_f3_value().x;
CasSetup(const0, const1, sharpness, resolution_out.x, resolution_out.y, resolution_out.x, resolution_out.y);
float3 color = 0.0f;
CasFilter(color.r, color.g, color.b, thread_id.xy, const0, const1, true);
const float a = tex[thread_id.xy].a;
tex_uav[thread_id.xy] = float4(color, a);
}
================================================
FILE: data/shaders/amd_fidelity_fx/ffx_a.h
================================================
//==============================================================================================================================
//
// [A] SHADER PORTABILITY 1.20210629
//
//==============================================================================================================================
// FidelityFX Super Resolution Sample
//
// Copyright (c) 2021 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.
//------------------------------------------------------------------------------------------------------------------------------
// MIT LICENSE
// ===========
// Copyright (c) 2014 Michal Drobot (for concepts used in "FLOAT APPROXIMATIONS").
// -----------
// 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.
//------------------------------------------------------------------------------------------------------------------------------
// ABOUT
// =====
// Common central point for high-level shading language and C portability for various shader headers.
//------------------------------------------------------------------------------------------------------------------------------
// DEFINES
// =======
// A_CPU ..... Include the CPU related code.
// A_GPU ..... Include the GPU related code.
// A_GLSL .... Using GLSL.
// A_HLSL .... Using HLSL.
// A_HLSL_6_2 Using HLSL 6.2 with new 'uint16_t' and related types (requires '-enable-16bit-types').
// A_NO_16_BIT_CAST Don't use instructions that are not availabe in SPIR-V (needed for running A_HLSL_6_2 on Vulkan)
// A_GCC ..... Using a GCC compatible compiler (else assume MSVC compatible compiler by default).
// =======
// A_BYTE .... Support 8-bit integer.
// A_HALF .... Support 16-bit integer and floating point.
// A_LONG .... Support 64-bit integer.
// A_DUBL .... Support 64-bit floating point.
// =======
// A_WAVE .... Support wave-wide operations.
//------------------------------------------------------------------------------------------------------------------------------
// To get #include "ffx_a.h" working in GLSL use '#extension GL_GOOGLE_include_directive:require'.
//------------------------------------------------------------------------------------------------------------------------------
// SIMPLIFIED TYPE SYSTEM
// ======================
// - All ints will be unsigned with exception of when signed is required.
// - Type naming simplified and shortened "A<type><#components>",
// - H = 16-bit float (half)
// - F = 32-bit float (float)
// - D = 64-bit float (double)
// - P = 1-bit integer (predicate, not using bool because 'B' is used for byte)
// - B = 8-bit integer (byte)
// - W = 16-bit integer (word)
// - U = 32-bit integer (unsigned)
// - L = 64-bit integer (long)
// - Using "AS<type><#components>" for signed when required.
//------------------------------------------------------------------------------------------------------------------------------
// TODO
// ====
// - Make sure 'ALerp*(a,b,m)' does 'b*m+(-a*m+a)' (2 ops).
//------------------------------------------------------------------------------------------------------------------------------
// CHANGE LOG
// ==========
// 20200914 - Expanded wave ops and prx code.
// 20200713 - Added [ZOL] section, fixed serious bugs in sRGB and Rec.709 color conversion code, etc.
//==============================================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// COMMON
//==============================================================================================================================
#define A_2PI 6.28318530718
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
//
//
// CPU
//
//
//==============================================================================================================================
#ifdef A_CPU
// Supporting user defined overrides.
#ifndef A_RESTRICT
#define A_RESTRICT __restrict
#endif
//------------------------------------------------------------------------------------------------------------------------------
#ifndef A_STATIC
#define A_STATIC static
#endif
//------------------------------------------------------------------------------------------------------------------------------
// Same types across CPU and GPU.
// Predicate uses 32-bit integer (C friendly bool).
typedef uint32_t AP1;
typedef float AF1;
typedef double AD1;
typedef uint8_t AB1;
typedef uint16_t AW1;
typedef uint32_t AU1;
typedef uint64_t AL1;
typedef int8_t ASB1;
typedef int16_t ASW1;
typedef int32_t ASU1;
typedef int64_t ASL1;
//------------------------------------------------------------------------------------------------------------------------------
#define AD1_(a) ((AD1)(a))
#define AF1_(a) ((AF1)(a))
#define AL1_(a) ((AL1)(a))
#define AU1_(a) ((AU1)(a))
//------------------------------------------------------------------------------------------------------------------------------
#define ASL1_(a) ((ASL1)(a))
#define ASU1_(a) ((ASU1)(a))
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AU1 AU1_AF1(AF1 a){union{AF1 f;AU1 u;}bits;bits.f=a;return bits.u;}
//------------------------------------------------------------------------------------------------------------------------------
#define A_TRUE 1
#define A_FALSE 0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
//
// CPU/GPU PORTING
//
//------------------------------------------------------------------------------------------------------------------------------
// Get CPU and GPU to share all setup code, without duplicate code paths.
// This uses a lower-case prefix for special vector constructs.
// - In C restrict pointers are used.
// - In the shading language, in/inout/out arguments are used.
// This depends on the ability to access a vector value in both languages via array syntax (aka color[2]).
//==============================================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// VECTOR ARGUMENT/RETURN/INITIALIZATION PORTABILITY
//==============================================================================================================================
#define retAD2 AD1 *A_RESTRICT
#define retAD3 AD1 *A_RESTRICT
#define retAD4 AD1 *A_RESTRICT
#define retAF2 AF1 *A_RESTRICT
#define retAF3 AF1 *A_RESTRICT
#define retAF4 AF1 *A_RESTRICT
#define retAL2 AL1 *A_RESTRICT
#define retAL3 AL1 *A_RESTRICT
#define retAL4 AL1 *A_RESTRICT
#define retAU2 AU1 *A_RESTRICT
#define retAU3 AU1 *A_RESTRICT
#define retAU4 AU1 *A_RESTRICT
//------------------------------------------------------------------------------------------------------------------------------
#define inAD2 AD1 *A_RESTRICT
#define inAD3 AD1 *A_RESTRICT
#define inAD4 AD1 *A_RESTRICT
#define inAF2 AF1 *A_RESTRICT
#define inAF3 AF1 *A_RESTRICT
#define inAF4 AF1 *A_RESTRICT
#define inAL2 AL1 *A_RESTRICT
#define inAL3 AL1 *A_RESTRICT
#define inAL4 AL1 *A_RESTRICT
#define inAU2 AU1 *A_RESTRICT
#define inAU3 AU1 *A_RESTRICT
#define inAU4 AU1 *A_RESTRICT
//------------------------------------------------------------------------------------------------------------------------------
#define inoutAD2 AD1 *A_RESTRICT
#define inoutAD3 AD1 *A_RESTRICT
#define inoutAD4 AD1 *A_RESTRICT
#define inoutAF2 AF1 *A_RESTRICT
#define inoutAF3 AF1 *A_RESTRICT
#define inoutAF4 AF1 *A_RESTRICT
#define inoutAL2 AL1 *A_RESTRICT
#define inoutAL3 AL1 *A_RESTRICT
#define inoutAL4 AL1 *A_RESTRICT
#define inoutAU2 AU1 *A_RESTRICT
#define inoutAU3 AU1 *A_RESTRICT
#define inoutAU4 AU1 *A_RESTRICT
//------------------------------------------------------------------------------------------------------------------------------
#define outAD2 AD1 *A_RESTRICT
#define outAD3 AD1 *A_RESTRICT
#define outAD4 AD1 *A_RESTRICT
#define outAF2 AF1 *A_RESTRICT
#define outAF3 AF1 *A_RESTRICT
#define outAF4 AF1 *A_RESTRICT
#define outAL2 AL1 *A_RESTRICT
#define outAL3 AL1 *A_RESTRICT
#define outAL4 AL1 *A_RESTRICT
#define outAU2 AU1 *A_RESTRICT
#define outAU3 AU1 *A_RESTRICT
#define outAU4 AU1 *A_RESTRICT
//------------------------------------------------------------------------------------------------------------------------------
#define varAD2(x) AD1 x[2]
#define varAD3(x) AD1 x[3]
#define varAD4(x) AD1 x[4]
#define varAF2(x) AF1 x[2]
#define varAF3(x) AF1 x[3]
#define varAF4(x) AF1 x[4]
#define varAL2(x) AL1 x[2]
#define varAL3(x) AL1 x[3]
#define varAL4(x) AL1 x[4]
#define varAU2(x) AU1 x[2]
#define varAU3(x) AU1 x[3]
#define varAU4(x) AU1 x[4]
//------------------------------------------------------------------------------------------------------------------------------
#define initAD2(x,y) {x,y}
#define initAD3(x,y,z) {x,y,z}
#define initAD4(x,y,z,w) {x,y,z,w}
#define initAF2(x,y) {x,y}
#define initAF3(x,y,z) {x,y,z}
#define initAF4(x,y,z,w) {x,y,z,w}
#define initAL2(x,y) {x,y}
#define initAL3(x,y,z) {x,y,z}
#define initAL4(x,y,z,w) {x,y,z,w}
#define initAU2(x,y) {x,y}
#define initAU3(x,y,z) {x,y,z}
#define initAU4(x,y,z,w) {x,y,z,w}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// SCALAR RETURN OPS
//------------------------------------------------------------------------------------------------------------------------------
// TODO
// ====
// - Replace transcendentals with manual versions.
//==============================================================================================================================
#ifdef A_GCC
A_STATIC AD1 AAbsD1(AD1 a){return __builtin_fabs(a);}
A_STATIC AF1 AAbsF1(AF1 a){return __builtin_fabsf(a);}
A_STATIC AU1 AAbsSU1(AU1 a){return AU1_(__builtin_abs(ASU1_(a)));}
A_STATIC AL1 AAbsSL1(AL1 a){return AL1_(__builtin_llabs(ASL1_(a)));}
#else
A_STATIC AD1 AAbsD1(AD1 a){return fabs(a);}
A_STATIC AF1 AAbsF1(AF1 a){return fabsf(a);}
A_STATIC AU1 AAbsSU1(AU1 a){return AU1_(abs(ASU1_(a)));}
A_STATIC AL1 AAbsSL1(AL1 a){return AL1_(labs((long)ASL1_(a)));}
#endif
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_GCC
A_STATIC AD1 ACosD1(AD1 a){return __builtin_cos(a);}
A_STATIC AF1 ACosF1(AF1 a){return __builtin_cosf(a);}
#else
A_STATIC AD1 ACosD1(AD1 a){return cos(a);}
A_STATIC AF1 ACosF1(AF1 a){return cosf(a);}
#endif
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 ADotD2(inAD2 a,inAD2 b){return a[0]*b[0]+a[1]*b[1];}
A_STATIC AD1 ADotD3(inAD3 a,inAD3 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];}
A_STATIC AD1 ADotD4(inAD4 a,inAD4 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+a[3]*b[3];}
A_STATIC AF1 ADotF2(inAF2 a,inAF2 b){return a[0]*b[0]+a[1]*b[1];}
A_STATIC AF1 ADotF3(inAF3 a,inAF3 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];}
A_STATIC AF1 ADotF4(inAF4 a,inAF4 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+a[3]*b[3];}
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_GCC
A_STATIC AD1 AExp2D1(AD1 a){return __builtin_exp2(a);}
A_STATIC AF1 AExp2F1(AF1 a){return __builtin_exp2f(a);}
#else
A_STATIC AD1 AExp2D1(AD1 a){return exp2(a);}
A_STATIC AF1 AExp2F1(AF1 a){return exp2f(a);}
#endif
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_GCC
A_STATIC AD1 AFloorD1(AD1 a){return __builtin_floor(a);}
A_STATIC AF1 AFloorF1(AF1 a){return __builtin_floorf(a);}
#else
A_STATIC AD1 AFloorD1(AD1 a){return floor(a);}
A_STATIC AF1 AFloorF1(AF1 a){return floorf(a);}
#endif
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 ALerpD1(AD1 a,AD1 b,AD1 c){return b*c+(-a*c+a);}
A_STATIC AF1 ALerpF1(AF1 a,AF1 b,AF1 c){return b*c+(-a*c+a);}
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_GCC
A_STATIC AD1 ALog2D1(AD1 a){return __builtin_log2(a);}
A_STATIC AF1 ALog2F1(AF1 a){return __builtin_log2f(a);}
#else
A_STATIC AD1 ALog2D1(AD1 a){return log2(a);}
A_STATIC AF1 ALog2F1(AF1 a){return log2f(a);}
#endif
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 AMaxD1(AD1 a,AD1 b){return a>b?a:b;}
A_STATIC AF1 AMaxF1(AF1 a,AF1 b){return a>b?a:b;}
A_STATIC AL1 AMaxL1(AL1 a,AL1 b){return a>b?a:b;}
A_STATIC AU1 AMaxU1(AU1 a,AU1 b){return a>b?a:b;}
//------------------------------------------------------------------------------------------------------------------------------
// These follow the convention that A integer types don't have signage, until they are operated on.
A_STATIC AL1 AMaxSL1(AL1 a,AL1 b){return (ASL1_(a)>ASL1_(b))?a:b;}
A_STATIC AU1 AMaxSU1(AU1 a,AU1 b){return (ASU1_(a)>ASU1_(b))?a:b;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 AMinD1(AD1 a,AD1 b){return a<b?a:b;}
A_STATIC AF1 AMinF1(AF1 a,AF1 b){return a<b?a:b;}
A_STATIC AL1 AMinL1(AL1 a,AL1 b){return a<b?a:b;}
A_STATIC AU1 AMinU1(AU1 a,AU1 b){return a<b?a:b;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AL1 AMinSL1(AL1 a,AL1 b){return (ASL1_(a)<ASL1_(b))?a:b;}
A_STATIC AU1 AMinSU1(AU1 a,AU1 b){return (ASU1_(a)<ASU1_(b))?a:b;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 ARcpD1(AD1 a){return 1.0/a;}
A_STATIC AF1 ARcpF1(AF1 a){return 1.0f/a;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AL1 AShrSL1(AL1 a,AL1 b){return AL1_(ASL1_(a)>>ASL1_(b));}
A_STATIC AU1 AShrSU1(AU1 a,AU1 b){return AU1_(ASU1_(a)>>ASU1_(b));}
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_GCC
A_STATIC AD1 ASinD1(AD1 a){return __builtin_sin(a);}
A_STATIC AF1 ASinF1(AF1 a){return __builtin_sinf(a);}
#else
A_STATIC AD1 ASinD1(AD1 a){return sin(a);}
A_STATIC AF1 ASinF1(AF1 a){return sinf(a);}
#endif
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_GCC
A_STATIC AD1 ASqrtD1(AD1 a){return __builtin_sqrt(a);}
A_STATIC AF1 ASqrtF1(AF1 a){return __builtin_sqrtf(a);}
#else
A_STATIC AD1 ASqrtD1(AD1 a){return sqrt(a);}
A_STATIC AF1 ASqrtF1(AF1 a){return sqrtf(a);}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// SCALAR RETURN OPS - DEPENDENT
//==============================================================================================================================
A_STATIC AD1 AClampD1(AD1 x,AD1 n,AD1 m){return AMaxD1(n,AMinD1(x,m));}
A_STATIC AF1 AClampF1(AF1 x,AF1 n,AF1 m){return AMaxF1(n,AMinF1(x,m));}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 AFractD1(AD1 a){return a-AFloorD1(a);}
A_STATIC AF1 AFractF1(AF1 a){return a-AFloorF1(a);}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 APowD1(AD1 a,AD1 b){return AExp2D1(b*ALog2D1(a));}
A_STATIC AF1 APowF1(AF1 a,AF1 b){return AExp2F1(b*ALog2F1(a));}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 ARsqD1(AD1 a){return ARcpD1(ASqrtD1(a));}
A_STATIC AF1 ARsqF1(AF1 a){return ARcpF1(ASqrtF1(a));}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC AD1 ASatD1(AD1 a){return AMinD1(1.0,AMaxD1(0.0,a));}
A_STATIC AF1 ASatF1(AF1 a){return AMinF1(1.0f,AMaxF1(0.0f,a));}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// VECTOR OPS
//------------------------------------------------------------------------------------------------------------------------------
// These are added as needed for production or prototyping, so not necessarily a complete set.
// They follow a convention of taking in a destination and also returning the destination value to increase utility.
//==============================================================================================================================
A_STATIC retAD2 opAAbsD2(outAD2 d,inAD2 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1(a[1]);return d;}
A_STATIC retAD3 opAAbsD3(outAD3 d,inAD3 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1(a[1]);d[2]=AAbsD1(a[2]);return d;}
A_STATIC retAD4 opAAbsD4(outAD4 d,inAD4 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1(a[1]);d[2]=AAbsD1(a[2]);d[3]=AAbsD1(a[3]);return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opAAbsF2(outAF2 d,inAF2 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1(a[1]);return d;}
A_STATIC retAF3 opAAbsF3(outAF3 d,inAF3 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1(a[1]);d[2]=AAbsF1(a[2]);return d;}
A_STATIC retAF4 opAAbsF4(outAF4 d,inAF4 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1(a[1]);d[2]=AAbsF1(a[2]);d[3]=AAbsF1(a[3]);return d;}
//==============================================================================================================================
A_STATIC retAD2 opAAddD2(outAD2 d,inAD2 a,inAD2 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];return d;}
A_STATIC retAD3 opAAddD3(outAD3 d,inAD3 a,inAD3 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];d[2]=a[2]+b[2];return d;}
A_STATIC retAD4 opAAddD4(outAD4 d,inAD4 a,inAD4 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];d[2]=a[2]+b[2];d[3]=a[3]+b[3];return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opAAddF2(outAF2 d,inAF2 a,inAF2 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];return d;}
A_STATIC retAF3 opAAddF3(outAF3 d,inAF3 a,inAF3 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];d[2]=a[2]+b[2];return d;}
A_STATIC retAF4 opAAddF4(outAF4 d,inAF4 a,inAF4 b){d[0]=a[0]+b[0];d[1]=a[1]+b[1];d[2]=a[2]+b[2];d[3]=a[3]+b[3];return d;}
//==============================================================================================================================
A_STATIC retAD2 opAAddOneD2(outAD2 d,inAD2 a,AD1 b){d[0]=a[0]+b;d[1]=a[1]+b;return d;}
A_STATIC retAD3 opAAddOneD3(outAD3 d,inAD3 a,AD1 b){d[0]=a[0]+b;d[1]=a[1]+b;d[2]=a[2]+b;return d;}
A_STATIC retAD4 opAAddOneD4(outAD4 d,inAD4 a,AD1 b){d[0]=a[0]+b;d[1]=a[1]+b;d[2]=a[2]+b;d[3]=a[3]+b;return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opAAddOneF2(outAF2 d,inAF2 a,AF1 b){d[0]=a[0]+b;d[1]=a[1]+b;return d;}
A_STATIC retAF3 opAAddOneF3(outAF3 d,inAF3 a,AF1 b){d[0]=a[0]+b;d[1]=a[1]+b;d[2]=a[2]+b;return d;}
A_STATIC retAF4 opAAddOneF4(outAF4 d,inAF4 a,AF1 b){d[0]=a[0]+b;d[1]=a[1]+b;d[2]=a[2]+b;d[3]=a[3]+b;return d;}
//==============================================================================================================================
A_STATIC retAD2 opACpyD2(outAD2 d,inAD2 a){d[0]=a[0];d[1]=a[1];return d;}
A_STATIC retAD3 opACpyD3(outAD3 d,inAD3 a){d[0]=a[0];d[1]=a[1];d[2]=a[2];return d;}
A_STATIC retAD4 opACpyD4(outAD4 d,inAD4 a){d[0]=a[0];d[1]=a[1];d[2]=a[2];d[3]=a[3];return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opACpyF2(outAF2 d,inAF2 a){d[0]=a[0];d[1]=a[1];return d;}
A_STATIC retAF3 opACpyF3(outAF3 d,inAF3 a){d[0]=a[0];d[1]=a[1];d[2]=a[2];return d;}
A_STATIC retAF4 opACpyF4(outAF4 d,inAF4 a){d[0]=a[0];d[1]=a[1];d[2]=a[2];d[3]=a[3];return d;}
//==============================================================================================================================
A_STATIC retAD2 opALerpD2(outAD2 d,inAD2 a,inAD2 b,inAD2 c){d[0]=ALerpD1(a[0],b[0],c[0]);d[1]=ALerpD1(a[1],b[1],c[1]);return d;}
A_STATIC retAD3 opALerpD3(outAD3 d,inAD3 a,inAD3 b,inAD3 c){d[0]=ALerpD1(a[0],b[0],c[0]);d[1]=ALerpD1(a[1],b[1],c[1]);d[2]=ALerpD1(a[2],b[2],c[2]);return d;}
A_STATIC retAD4 opALerpD4(outAD4 d,inAD4 a,inAD4 b,inAD4 c){d[0]=ALerpD1(a[0],b[0],c[0]);d[1]=ALerpD1(a[1],b[1],c[1]);d[2]=ALerpD1(a[2],b[2],c[2]);d[3]=ALerpD1(a[3],b[3],c[3]);return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opALerpF2(outAF2 d,inAF2 a,inAF2 b,inAF2 c){d[0]=ALerpF1(a[0],b[0],c[0]);d[1]=ALerpF1(a[1],b[1],c[1]);return d;}
A_STATIC retAF3 opALerpF3(outAF3 d,inAF3 a,inAF3 b,inAF3 c){d[0]=ALerpF1(a[0],b[0],c[0]);d[1]=ALerpF1(a[1],b[1],c[1]);d[2]=ALerpF1(a[2],b[2],c[2]);return d;}
A_STATIC retAF4 opALerpF4(outAF4 d,inAF4 a,inAF4 b,inAF4 c){d[0]=ALerpF1(a[0],b[0],c[0]);d[1]=ALerpF1(a[1],b[1],c[1]);d[2]=ALerpF1(a[2],b[2],c[2]);d[3]=ALerpF1(a[3],b[3],c[3]);return d;}
//==============================================================================================================================
A_STATIC retAD2 opALerpOneD2(outAD2 d,inAD2 a,inAD2 b,AD1 c){d[0]=ALerpD1(a[0],b[0],c);d[1]=ALerpD1(a[1],b[1],c);return d;}
A_STATIC retAD3 opALerpOneD3(outAD3 d,inAD3 a,inAD3 b,AD1 c){d[0]=ALerpD1(a[0],b[0],c);d[1]=ALerpD1(a[1],b[1],c);d[2]=ALerpD1(a[2],b[2],c);return d;}
A_STATIC retAD4 opALerpOneD4(outAD4 d,inAD4 a,inAD4 b,AD1 c){d[0]=ALerpD1(a[0],b[0],c);d[1]=ALerpD1(a[1],b[1],c);d[2]=ALerpD1(a[2],b[2],c);d[3]=ALerpD1(a[3],b[3],c);return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opALerpOneF2(outAF2 d,inAF2 a,inAF2 b,AF1 c){d[0]=ALerpF1(a[0],b[0],c);d[1]=ALerpF1(a[1],b[1],c);return d;}
A_STATIC retAF3 opALerpOneF3(outAF3 d,inAF3 a,inAF3 b,AF1 c){d[0]=ALerpF1(a[0],b[0],c);d[1]=ALerpF1(a[1],b[1],c);d[2]=ALerpF1(a[2],b[2],c);return d;}
A_STATIC retAF4 opALerpOneF4(outAF4 d,inAF4 a,inAF4 b,AF1 c){d[0]=ALerpF1(a[0],b[0],c);d[1]=ALerpF1(a[1],b[1],c);d[2]=ALerpF1(a[2],b[2],c);d[3]=ALerpF1(a[3],b[3],c);return d;}
//==============================================================================================================================
A_STATIC retAD2 opAMaxD2(outAD2 d,inAD2 a,inAD2 b){d[0]=AMaxD1(a[0],b[0]);d[1]=AMaxD1(a[1],b[1]);return d;}
A_STATIC retAD3 opAMaxD3(outAD3 d,inAD3 a,inAD3 b){d[0]=AMaxD1(a[0],b[0]);d[1]=AMaxD1(a[1],b[1]);d[2]=AMaxD1(a[2],b[2]);return d;}
A_STATIC retAD4 opAMaxD4(outAD4 d,inAD4 a,inAD4 b){d[0]=AMaxD1(a[0],b[0]);d[1]=AMaxD1(a[1],b[1]);d[2]=AMaxD1(a[2],b[2]);d[3]=AMaxD1(a[3],b[3]);return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opAMaxF2(outAF2 d,inAF2 a,inAF2 b){d[0]=AMaxF1(a[0],b[0]);d[1]=AMaxF1(a[1],b[1]);return d;}
A_STATIC retAF3 opAMaxF3(outAF3 d,inAF3 a,inAF3 b){d[0]=AMaxF1(a[0],b[0]);d[1]=AMaxF1(a[1],b[1]);d[2]=AMaxF1(a[2],b[2]);return d;}
A_STATIC retAF4 opAMaxF4(outAF4 d,inAF4 a,inAF4 b){d[0]=AMaxF1(a[0],b[0]);d[1]=AMaxF1(a[1],b[1]);d[2]=AMaxF1(a[2],b[2]);d[3]=AMaxF1(a[3],b[3]);return d;}
//==============================================================================================================================
A_STATIC retAD2 opAMinD2(outAD2 d,inAD2 a,inAD2 b){d[0]=AMinD1(a[0],b[0]);d[1]=AMinD1(a[1],b[1]);return d;}
A_STATIC retAD3 opAMinD3(outAD3 d,inAD3 a,inAD3 b){d[0]=AMinD1(a[0],b[0]);d[1]=AMinD1(a[1],b[1]);d[2]=AMinD1(a[2],b[2]);return d;}
A_STATIC retAD4 opAMinD4(outAD4 d,inAD4 a,inAD4 b){d[0]=AMinD1(a[0],b[0]);d[1]=AMinD1(a[1],b[1]);d[2]=AMinD1(a[2],b[2]);d[3]=AMinD1(a[3],b[3]);return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opAMinF2(outAF2 d,inAF2 a,inAF2 b){d[0]=AMinF1(a[0],b[0]);d[1]=AMinF1(a[1],b[1]);return d;}
A_STATIC retAF3 opAMinF3(outAF3 d,inAF3 a,inAF3 b){d[0]=AMinF1(a[0],b[0]);d[1]=AMinF1(a[1],b[1]);d[2]=AMinF1(a[2],b[2]);return d;}
A_STATIC retAF4 opAMinF4(outAF4 d,inAF4 a,inAF4 b){d[0]=AMinF1(a[0],b[0]);d[1]=AMinF1(a[1],b[1]);d[2]=AMinF1(a[2],b[2]);d[3]=AMinF1(a[3],b[3]);return d;}
//==============================================================================================================================
A_STATIC retAD2 opAMulD2(outAD2 d,inAD2 a,inAD2 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];return d;}
A_STATIC retAD3 opAMulD3(outAD3 d,inAD3 a,inAD3 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];d[2]=a[2]*b[2];return d;}
A_STATIC retAD4 opAMulD4(outAD4 d,inAD4 a,inAD4 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];d[2]=a[2]*b[2];d[3]=a[3]*b[3];return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opAMulF2(outAF2 d,inAF2 a,inAF2 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];return d;}
A_STATIC retAF3 opAMulF3(outAF3 d,inAF3 a,inAF3 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];d[2]=a[2]*b[2];return d;}
A_STATIC retAF4 opAMulF4(outAF4 d,inAF4 a,inAF4 b){d[0]=a[0]*b[0];d[1]=a[1]*b[1];d[2]=a[2]*b[2];d[3]=a[3]*b[3];return d;}
//==============================================================================================================================
A_STATIC retAD2 opAMulOneD2(outAD2 d,inAD2 a,AD1 b){d[0]=a[0]*b;d[1]=a[1]*b;return d;}
A_STATIC retAD3 opAMulOneD3(outAD3 d,inAD3 a,AD1 b){d[0]=a[0]*b;d[1]=a[1]*b;d[2]=a[2]*b;return d;}
A_STATIC retAD4 opAMulOneD4(outAD4 d,inAD4 a,AD1 b){d[0]=a[0]*b;d[1]=a[1]*b;d[2]=a[2]*b;d[3]=a[3]*b;return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opAMulOneF2(outAF2 d,inAF2 a,AF1 b){d[0]=a[0]*b;d[1]=a[1]*b;return d;}
A_STATIC retAF3 opAMulOneF3(outAF3 d,inAF3 a,AF1 b){d[0]=a[0]*b;d[1]=a[1]*b;d[2]=a[2]*b;return d;}
A_STATIC retAF4 opAMulOneF4(outAF4 d,inAF4 a,AF1 b){d[0]=a[0]*b;d[1]=a[1]*b;d[2]=a[2]*b;d[3]=a[3]*b;return d;}
//==============================================================================================================================
A_STATIC retAD2 opANegD2(outAD2 d,inAD2 a){d[0]=-a[0];d[1]=-a[1];return d;}
A_STATIC retAD3 opANegD3(outAD3 d,inAD3 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a[2];return d;}
A_STATIC retAD4 opANegD4(outAD4 d,inAD4 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a[2];d[3]=-a[3];return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opANegF2(outAF2 d,inAF2 a){d[0]=-a[0];d[1]=-a[1];return d;}
A_STATIC retAF3 opANegF3(outAF3 d,inAF3 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a[2];return d;}
A_STATIC retAF4 opANegF4(outAF4 d,inAF4 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a[2];d[3]=-a[3];return d;}
//==============================================================================================================================
A_STATIC retAD2 opARcpD2(outAD2 d,inAD2 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1(a[1]);return d;}
A_STATIC retAD3 opARcpD3(outAD3 d,inAD3 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1(a[1]);d[2]=ARcpD1(a[2]);return d;}
A_STATIC retAD4 opARcpD4(outAD4 d,inAD4 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1(a[1]);d[2]=ARcpD1(a[2]);d[3]=ARcpD1(a[3]);return d;}
//------------------------------------------------------------------------------------------------------------------------------
A_STATIC retAF2 opARcpF2(outAF2 d,inAF2 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1(a[1]);return d;}
A_STATIC retAF3 opARcpF3(outAF3 d,inAF3 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1(a[1]);d[2]=ARcpF1(a[2]);return d;}
A_STATIC retAF4 opARcpF4(outAF4 d,inAF4 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1(a[1]);d[2]=ARcpF1(a[2]);d[3]=ARcpF1(a[3]);return d;}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// HALF FLOAT PACKING
//==============================================================================================================================
// Convert float to half (in lower 16-bits of output).
// Same fast technique as documented here: ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf
// Supports denormals.
// Conversion rules are to make computations possibly "safer" on the GPU,
// -INF & -NaN -> -65504
// +INF & +NaN -> +65504
A_STATIC AU1 AU1_AH1_AF1(AF1 f){
static AW1 base[512]={
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,0x0100,
0x0200,0x0400,0x0800,0x0c00,0x1000,0x1400,0x1800,0x1c00,0x2000,0x2400,0x2800,0x2c00,0x3000,0x3400,0x3800,0x3c00,
0x4000,0x4400,0x4800,0x4c00,0x5000,0x5400,0x5800,0x5c00,0x6000,0x6400,0x6800,0x6c00,0x7000,0x7400,0x7800,0x7bff,
0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,
0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,
0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,
0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,
0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,
0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,
0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,0x7bff,
0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,
0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,
0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,
0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,
0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,
0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,
0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8001,0x8002,0x8004,0x8008,0x8010,0x8020,0x8040,0x8080,0x8100,
0x8200,0x8400,0x8800,0x8c00,0x9000,0x9400,0x9800,0x9c00,0xa000,0xa400,0xa800,0xac00,0xb000,0xb400,0xb800,0xbc00,
0xc000,0xc400,0xc800,0xcc00,0xd000,0xd400,0xd800,0xdc00,0xe000,0xe400,0xe800,0xec00,0xf000,0xf400,0xf800,0xfbff,
0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,
0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,
0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,
0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,
0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,
0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,
0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff,0xfbff};
static AB1 shift[512]={
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x17,0x16,0x15,0x14,0x13,0x12,0x11,0x10,0x0f,
0x0e,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,
0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x17,0x16,0x15,0x14,0x13,0x12,0x11,0x10,0x0f,
0x0e,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,
0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18};
union{AF1 f;AU1 u;}bits;bits.f=f;AU1 u=bits.u;AU1 i=u>>23;return (AU1)(base[i])+((u&0x7fffff)>>shift[i]);}
//------------------------------------------------------------------------------------------------------------------------------
// Used to output packed constant.
A_STATIC AU1 AU1_AH2_AF2(inAF2 a){return AU1_AH1_AF1(a[0])+(AU1_AH1_AF1(a[1])<<16);}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
//
//
// GLSL
//
//
//==============================================================================================================================
#if defined(A_GLSL) && defined(A_GPU)
#ifndef A_SKIP_EXT
#ifdef A_HALF
#extension GL_EXT_shader_16bit_storage:require
#extension GL_EXT_shader_explicit_arithmetic_types:require
#endif
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_LONG
#extension GL_ARB_gpu_shader_int64:require
#extension GL_NV_shader_atomic_int64:require
#endif
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_WAVE
#extension GL_KHR_shader_subgroup_arithmetic:require
#extension GL_KHR_shader_subgroup_ballot:require
#extension GL_KHR_shader_subgroup_quad:require
#extension GL_KHR_shader_subgroup_shuffle:require
#endif
#endif
//==============================================================================================================================
#define AP1 bool
#define AP2 bvec2
#define AP3 bvec3
#define AP4 bvec4
//------------------------------------------------------------------------------------------------------------------------------
#define AF1 float
#define AF2 vec2
#define AF3 vec3
#define AF4 vec4
//------------------------------------------------------------------------------------------------------------------------------
#define AU1 uint
#define AU2 uvec2
#define AU3 uvec3
#define AU4 uvec4
//------------------------------------------------------------------------------------------------------------------------------
#define ASU1 int
#define ASU2 ivec2
#define ASU3 ivec3
#define ASU4 ivec4
//==============================================================================================================================
#define AF1_AU1(x) uintBitsToFloat(AU1(x))
#define AF2_AU2(x) uintBitsToFloat(AU2(x))
#define AF3_AU3(x) uintBitsToFloat(AU3(x))
#define AF4_AU4(x) uintBitsToFloat(AU4(x))
//------------------------------------------------------------------------------------------------------------------------------
#define AU1_AF1(x) floatBitsToUint(AF1(x))
#define AU2_AF2(x) floatBitsToUint(AF2(x))
#define AU3_AF3(x) floatBitsToUint(AF3(x))
#define AU4_AF4(x) floatBitsToUint(AF4(x))
//------------------------------------------------------------------------------------------------------------------------------
AU1 AU1_AH1_AF1_x(AF1 a){return packHalf2x16(AF2(a,0.0));}
#define AU1_AH1_AF1(a) AU1_AH1_AF1_x(AF1(a))
//------------------------------------------------------------------------------------------------------------------------------
#define AU1_AH2_AF2 packHalf2x16
#define AU1_AW2Unorm_AF2 packUnorm2x16
#define AU1_AB4Unorm_AF4 packUnorm4x8
//------------------------------------------------------------------------------------------------------------------------------
#define AF2_AH2_AU1 unpackHalf2x16
#define AF2_AW2Unorm_AU1 unpackUnorm2x16
#define AF4_AB4Unorm_AU1 unpackUnorm4x8
//==============================================================================================================================
AF1 AF1_x(AF1 a){return AF1(a);}
AF2 AF2_x(AF1 a){return AF2(a,a);}
AF3 AF3_x(AF1 a){return AF3(a,a,a);}
AF4 AF4_x(AF1 a){return AF4(a,a,a,a);}
#define AF1_(a) AF1_x(AF1(a))
#define AF2_(a) AF2_x(AF1(a))
#define AF3_(a) AF3_x(AF1(a))
#define AF4_(a) AF4_x(AF1(a))
//------------------------------------------------------------------------------------------------------------------------------
AU1 AU1_x(AU1 a){return AU1(a);}
AU2 AU2_x(AU1 a){return AU2(a,a);}
AU3 AU3_x(AU1 a){return AU3(a,a,a);}
AU4 AU4_x(AU1 a){return AU4(a,a,a,a);}
#define AU1_(a) AU1_x(AU1(a))
#define AU2_(a) AU2_x(AU1(a))
#define AU3_(a) AU3_x(AU1(a))
#define AU4_(a) AU4_x(AU1(a))
//==============================================================================================================================
AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));}
AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));}
AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));}
AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 ABfe(AU1 src,AU1 off,AU1 bits){return bitfieldExtract(src,ASU1(off),ASU1(bits));}
AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));}
// Proxy for V_BFI_B32 where the 'mask' is set as 'bits', 'mask=(1<<bits)-1', and 'bits' needs to be an immediate.
AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){return bitfieldInsert(src,ins,0,ASU1(bits));}
//------------------------------------------------------------------------------------------------------------------------------
// V_MED3_F32.
AF1 AClampF1(AF1 x,AF1 n,AF1 m){return clamp(x,n,m);}
AF2 AClampF2(AF2 x,AF2 n,AF2 m){return clamp(x,n,m);}
AF3 AClampF3(AF3 x,AF3 n,AF3 m){return clamp(x,n,m);}
AF4 AClampF4(AF4 x,AF4 n,AF4 m){return clamp(x,n,m);}
//------------------------------------------------------------------------------------------------------------------------------
// V_FRACT_F32 (note DX frac() is different).
AF1 AFractF1(AF1 x){return fract(x);}
AF2 AFractF2(AF2 x){return fract(x);}
AF3 AFractF3(AF3 x){return fract(x);}
AF4 AFractF4(AF4 x){return fract(x);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return mix(x,y,a);}
AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return mix(x,y,a);}
AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return mix(x,y,a);}
AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return mix(x,y,a);}
//------------------------------------------------------------------------------------------------------------------------------
// V_MAX3_F32.
AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));}
AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));}
AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));}
AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(z))));}
AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(z))));}
AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(z))));}
AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(z))));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));}
AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));}
AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));}
AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));}
AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));}
AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));}
AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
// Clamp has an easier pattern match for med3 when some ordering is known.
// V_MED3_F32.
AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));}
AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));}
AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));}
AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));}
//------------------------------------------------------------------------------------------------------------------------------
// V_MIN3_F32.
AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));}
AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));}
AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));}
AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(z))));}
AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(z))));}
AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(z))));}
AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(z))));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));}
AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));}
AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));}
AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));}
AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));}
AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));}
AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
// Normalized trig. Valid input domain is {-256 to +256}. No GLSL compiler intrinsic exists to map to this currently.
// V_COS_F32.
AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));}
AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));}
AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));}
AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));}
//------------------------------------------------------------------------------------------------------------------------------
// Normalized trig. Valid input domain is {-256 to +256}. No GLSL compiler intrinsic exists to map to this currently.
// V_SIN_F32.
AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));}
AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));}
AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));}
AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ARcpF1(AF1 x){return AF1_(1.0)/x;}
AF2 ARcpF2(AF2 x){return AF2_(1.0)/x;}
AF3 ARcpF3(AF3 x){return AF3_(1.0)/x;}
AF4 ARcpF4(AF4 x){return AF4_(1.0)/x;}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ARsqF1(AF1 x){return AF1_(1.0)/sqrt(x);}
AF2 ARsqF2(AF2 x){return AF2_(1.0)/sqrt(x);}
AF3 ARsqF3(AF3 x){return AF3_(1.0)/sqrt(x);}
AF4 ARsqF4(AF4 x){return AF4_(1.0)/sqrt(x);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ASatF1(AF1 x){return clamp(x,AF1_(0.0),AF1_(1.0));}
AF2 ASatF2(AF2 x){return clamp(x,AF2_(0.0),AF2_(1.0));}
AF3 ASatF3(AF3 x){return clamp(x,AF3_(0.0),AF3_(1.0));}
AF4 ASatF4(AF4 x){return clamp(x,AF4_(0.0),AF4_(1.0));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));}
AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));}
AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));}
AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// GLSL BYTE
//==============================================================================================================================
#ifdef A_BYTE
#define AB1 uint8_t
#define AB2 u8vec2
#define AB3 u8vec3
#define AB4 u8vec4
//------------------------------------------------------------------------------------------------------------------------------
#define ASB1 int8_t
#define ASB2 i8vec2
#define ASB3 i8vec3
#define ASB4 i8vec4
//------------------------------------------------------------------------------------------------------------------------------
AB1 AB1_x(AB1 a){return AB1(a);}
AB2 AB2_x(AB1 a){return AB2(a,a);}
AB3 AB3_x(AB1 a){return AB3(a,a,a);}
AB4 AB4_x(AB1 a){return AB4(a,a,a,a);}
#define AB1_(a) AB1_x(AB1(a))
#define AB2_(a) AB2_x(AB1(a))
#define AB3_(a) AB3_x(AB1(a))
#define AB4_(a) AB4_x(AB1(a))
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// GLSL HALF
//==============================================================================================================================
#ifdef A_HALF
#define AH1 float16_t
#define AH2 f16vec2
#define AH3 f16vec3
#define AH4 f16vec4
//------------------------------------------------------------------------------------------------------------------------------
#define AW1 uint16_t
#define AW2 u16vec2
#define AW3 u16vec3
#define AW4 u16vec4
//------------------------------------------------------------------------------------------------------------------------------
#define ASW1 int16_t
#define ASW2 i16vec2
#define ASW3 i16vec3
#define ASW4 i16vec4
//==============================================================================================================================
#define AH2_AU1(x) unpackFloat2x16(AU1(x))
AH4 AH4_AU2_x(AU2 x){return AH4(unpackFloat2x16(x.x),unpackFloat2x16(x.y));}
#define AH4_AU2(x) AH4_AU2_x(AU2(x))
#define AW2_AU1(x) unpackUint2x16(AU1(x))
#define AW4_AU2(x) unpackUint4x16(pack64(AU2(x)))
//------------------------------------------------------------------------------------------------------------------------------
#define AU1_AH2(x) packFloat2x16(AH2(x))
AU2 AU2_AH4_x(AH4 x){return AU2(packFloat2x16(x.xy),packFloat2x16(x.zw));}
#define AU2_AH4(x) AU2_AH4_x(AH4(x))
#define AU1_AW2(x) packUint2x16(AW2(x))
#define AU2_AW4(x) unpack32(packUint4x16(AW4(x)))
//==============================================================================================================================
#define AW1_AH1(x) halfBitsToUint16(AH1(x))
#define AW2_AH2(x) halfBitsToUint16(AH2(x))
#define AW3_AH3(x) halfBitsToUint16(AH3(x))
#define AW4_AH4(x) halfBitsToUint16(AH4(x))
//------------------------------------------------------------------------------------------------------------------------------
#define AH1_AW1(x) uint16BitsToHalf(AW1(x))
#define AH2_AW2(x) uint16BitsToHalf(AW2(x))
#define AH3_AW3(x) uint16BitsToHalf(AW3(x))
#define AH4_AW4(x) uint16BitsToHalf(AW4(x))
//==============================================================================================================================
AH1 AH1_x(AH1 a){return AH1(a);}
AH2 AH2_x(AH1 a){return AH2(a,a);}
AH3 AH3_x(AH1 a){return AH3(a,a,a);}
AH4 AH4_x(AH1 a){return AH4(a,a,a,a);}
#define AH1_(a) AH1_x(AH1(a))
#define AH2_(a) AH2_x(AH1(a))
#define AH3_(a) AH3_x(AH1(a))
#define AH4_(a) AH4_x(AH1(a))
//------------------------------------------------------------------------------------------------------------------------------
AW1 AW1_x(AW1 a){return AW1(a);}
AW2 AW2_x(AW1 a){return AW2(a,a);}
AW3 AW3_x(AW1 a){return AW3(a,a,a);}
AW4 AW4_x(AW1 a){return AW4(a,a,a,a);}
#define AW1_(a) AW1_x(AW1(a))
#define AW2_(a) AW2_x(AW1(a))
#define AW3_(a) AW3_x(AW1(a))
#define AW4_(a) AW4_x(AW1(a))
//==============================================================================================================================
AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));}
AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));}
AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));}
AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AClampH1(AH1 x,AH1 n,AH1 m){return clamp(x,n,m);}
AH2 AClampH2(AH2 x,AH2 n,AH2 m){return clamp(x,n,m);}
AH3 AClampH3(AH3 x,AH3 n,AH3 m){return clamp(x,n,m);}
AH4 AClampH4(AH4 x,AH4 n,AH4 m){return clamp(x,n,m);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AFractH1(AH1 x){return fract(x);}
AH2 AFractH2(AH2 x){return fract(x);}
AH3 AFractH3(AH3 x){return fract(x);}
AH4 AFractH4(AH4 x){return fract(x);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return mix(x,y,a);}
AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return mix(x,y,a);}
AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return mix(x,y,a);}
AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return mix(x,y,a);}
//------------------------------------------------------------------------------------------------------------------------------
// No packed version of max3.
AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));}
AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));}
AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));}
AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));}
AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));}
AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));}
AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
// No packed version of min3.
AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));}
AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));}
AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));}
AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));}
AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));}
AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));}
AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ARcpH1(AH1 x){return AH1_(1.0)/x;}
AH2 ARcpH2(AH2 x){return AH2_(1.0)/x;}
AH3 ARcpH3(AH3 x){return AH3_(1.0)/x;}
AH4 ARcpH4(AH4 x){return AH4_(1.0)/x;}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ARsqH1(AH1 x){return AH1_(1.0)/sqrt(x);}
AH2 ARsqH2(AH2 x){return AH2_(1.0)/sqrt(x);}
AH3 ARsqH3(AH3 x){return AH3_(1.0)/sqrt(x);}
AH4 ARsqH4(AH4 x){return AH4_(1.0)/sqrt(x);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ASatH1(AH1 x){return clamp(x,AH1_(0.0),AH1_(1.0));}
AH2 ASatH2(AH2 x){return clamp(x,AH2_(0.0),AH2_(1.0));}
AH3 ASatH3(AH3 x){return clamp(x,AH3_(0.0),AH3_(1.0));}
AH4 ASatH4(AH4 x){return clamp(x,AH4_(0.0),AH4_(1.0));}
//------------------------------------------------------------------------------------------------------------------------------
AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));}
AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));}
AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));}
AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// GLSL DOUBLE
//==============================================================================================================================
#ifdef A_DUBL
#define AD1 double
#define AD2 dvec2
#define AD3 dvec3
#define AD4 dvec4
//------------------------------------------------------------------------------------------------------------------------------
AD1 AD1_x(AD1 a){return AD1(a);}
AD2 AD2_x(AD1 a){return AD2(a,a);}
AD3 AD3_x(AD1 a){return AD3(a,a,a);}
AD4 AD4_x(AD1 a){return AD4(a,a,a,a);}
#define AD1_(a) AD1_x(AD1(a))
#define AD2_(a) AD2_x(AD1(a))
#define AD3_(a) AD3_x(AD1(a))
#define AD4_(a) AD4_x(AD1(a))
//==============================================================================================================================
AD1 AFractD1(AD1 x){return fract(x);}
AD2 AFractD2(AD2 x){return fract(x);}
AD3 AFractD3(AD3 x){return fract(x);}
AD4 AFractD4(AD4 x){return fract(x);}
//------------------------------------------------------------------------------------------------------------------------------
AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return mix(x,y,a);}
AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return mix(x,y,a);}
AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return mix(x,y,a);}
AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return mix(x,y,a);}
//------------------------------------------------------------------------------------------------------------------------------
AD1 ARcpD1(AD1 x){return AD1_(1.0)/x;}
AD2 ARcpD2(AD2 x){return AD2_(1.0)/x;}
AD3 ARcpD3(AD3 x){return AD3_(1.0)/x;}
AD4 ARcpD4(AD4 x){return AD4_(1.0)/x;}
//------------------------------------------------------------------------------------------------------------------------------
AD1 ARsqD1(AD1 x){return AD1_(1.0)/sqrt(x);}
AD2 ARsqD2(AD2 x){return AD2_(1.0)/sqrt(x);}
AD3 ARsqD3(AD3 x){return AD3_(1.0)/sqrt(x);}
AD4 ARsqD4(AD4 x){return AD4_(1.0)/sqrt(x);}
//------------------------------------------------------------------------------------------------------------------------------
AD1 ASatD1(AD1 x){return clamp(x,AD1_(0.0),AD1_(1.0));}
AD2 ASatD2(AD2 x){return clamp(x,AD2_(0.0),AD2_(1.0));}
AD3 ASatD3(AD3 x){return clamp(x,AD3_(0.0),AD3_(1.0));}
AD4 ASatD4(AD4 x){return clamp(x,AD4_(0.0),AD4_(1.0));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// GLSL LONG
//==============================================================================================================================
#ifdef A_LONG
#define AL1 uint64_t
#define AL2 u64vec2
#define AL3 u64vec3
#define AL4 u64vec4
//------------------------------------------------------------------------------------------------------------------------------
#define ASL1 int64_t
#define ASL2 i64vec2
#define ASL3 i64vec3
#define ASL4 i64vec4
//------------------------------------------------------------------------------------------------------------------------------
#define AL1_AU2(x) packUint2x32(AU2(x))
#define AU2_AL1(x) unpackUint2x32(AL1(x))
//------------------------------------------------------------------------------------------------------------------------------
AL1 AL1_x(AL1 a){return AL1(a);}
AL2 AL2_x(AL1 a){return AL2(a,a);}
AL3 AL3_x(AL1 a){return AL3(a,a,a);}
AL4 AL4_x(AL1 a){return AL4(a,a,a,a);}
#define AL1_(a) AL1_x(AL1(a))
#define AL2_(a) AL2_x(AL1(a))
#define AL3_(a) AL3_x(AL1(a))
#define AL4_(a) AL4_x(AL1(a))
//==============================================================================================================================
AL1 AAbsSL1(AL1 a){return AL1(abs(ASL1(a)));}
AL2 AAbsSL2(AL2 a){return AL2(abs(ASL2(a)));}
AL3 AAbsSL3(AL3 a){return AL3(abs(ASL3(a)));}
AL4 AAbsSL4(AL4 a){return AL4(abs(ASL4(a)));}
//------------------------------------------------------------------------------------------------------------------------------
AL1 AMaxSL1(AL1 a,AL1 b){return AL1(max(ASU1(a),ASU1(b)));}
AL2 AMaxSL2(AL2 a,AL2 b){return AL2(max(ASU2(a),ASU2(b)));}
AL3 AMaxSL3(AL3 a,AL3 b){return AL3(max(ASU3(a),ASU3(b)));}
AL4 AMaxSL4(AL4 a,AL4 b){return AL4(max(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
AL1 AMinSL1(AL1 a,AL1 b){return AL1(min(ASU1(a),ASU1(b)));}
AL2 AMinSL2(AL2 a,AL2 b){return AL2(min(ASU2(a),ASU2(b)));}
AL3 AMinSL3(AL3 a,AL3 b){return AL3(min(ASU3(a),ASU3(b)));}
AL4 AMinSL4(AL4 a,AL4 b){return AL4(min(ASU4(a),ASU4(b)));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// WAVE OPERATIONS
//==============================================================================================================================
#ifdef A_WAVE
// Where 'x' must be a compile time literal.
AF1 AWaveXorF1(AF1 v,AU1 x){return subgroupShuffleXor(v,x);}
AF2 AWaveXorF2(AF2 v,AU1 x){return subgroupShuffleXor(v,x);}
AF3 AWaveXorF3(AF3 v,AU1 x){return subgroupShuffleXor(v,x);}
AF4 AWaveXorF4(AF4 v,AU1 x){return subgroupShuffleXor(v,x);}
AU1 AWaveXorU1(AU1 v,AU1 x){return subgroupShuffleXor(v,x);}
AU2 AWaveXorU2(AU2 v,AU1 x){return subgroupShuffleXor(v,x);}
AU3 AWaveXorU3(AU3 v,AU1 x){return subgroupShuffleXor(v,x);}
AU4 AWaveXorU4(AU4 v,AU1 x){return subgroupShuffleXor(v,x);}
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_HALF
AH2 AWaveXorH2(AH2 v,AU1 x){return AH2_AU1(subgroupShuffleXor(AU1_AH2(v),x));}
AH4 AWaveXorH4(AH4 v,AU1 x){return AH4_AU2(subgroupShuffleXor(AU2_AH4(v),x));}
AW2 AWaveXorW2(AW2 v,AU1 x){return AW2_AU1(subgroupShuffleXor(AU1_AW2(v),x));}
AW4 AWaveXorW4(AW4 v,AU1 x){return AW4_AU2(subgroupShuffleXor(AU2_AW4(v),x));}
#endif
#endif
//==============================================================================================================================
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
//
//
// HLSL
//
//
//==============================================================================================================================
#if defined(A_HLSL) && defined(A_GPU)
#ifdef A_HLSL_6_2
#define AP1 bool
#define AP2 bool2
#define AP3 bool3
#define AP4 bool4
//------------------------------------------------------------------------------------------------------------------------------
#define AF1 float32_t
#define AF2 float32_t2
#define AF3 float32_t3
#define AF4 float32_t4
//------------------------------------------------------------------------------------------------------------------------------
#define AU1 uint32_t
#define AU2 uint32_t2
#define AU3 uint32_t3
#define AU4 uint32_t4
//------------------------------------------------------------------------------------------------------------------------------
#define ASU1 int32_t
#define ASU2 int32_t2
#define ASU3 int32_t3
#define ASU4 int32_t4
#else
#define AP1 bool
#define AP2 bool2
#define AP3 bool3
#define AP4 bool4
//------------------------------------------------------------------------------------------------------------------------------
#define AF1 float
#define AF2 float2
#define AF3 float3
#define AF4 float4
//------------------------------------------------------------------------------------------------------------------------------
#define AU1 uint
#define AU2 uint2
#define AU3 uint3
#define AU4 uint4
//------------------------------------------------------------------------------------------------------------------------------
#define ASU1 int
#define ASU2 int2
#define ASU3 int3
#define ASU4 int4
#endif
//==============================================================================================================================
#define AF1_AU1(x) asfloat(AU1(x))
#define AF2_AU2(x) asfloat(AU2(x))
#define AF3_AU3(x) asfloat(AU3(x))
#define AF4_AU4(x) asfloat(AU4(x))
//------------------------------------------------------------------------------------------------------------------------------
#define AU1_AF1(x) asuint(AF1(x))
#define AU2_AF2(x) asuint(AF2(x))
#define AU3_AF3(x) asuint(AF3(x))
#define AU4_AF4(x) asuint(AF4(x))
//------------------------------------------------------------------------------------------------------------------------------
AU1 AU1_AH1_AF1_x(AF1 a){return f32tof16(a);}
#define AU1_AH1_AF1(a) AU1_AH1_AF1_x(AF1(a))
//------------------------------------------------------------------------------------------------------------------------------
AU1 AU1_AH2_AF2_x(AF2 a){return f32tof16(a.x)|(f32tof16(a.y)<<16);}
#define AU1_AH2_AF2(a) AU1_AH2_AF2_x(AF2(a))
#define AU1_AB4Unorm_AF4(x) D3DCOLORtoUBYTE4(AF4(x))
//------------------------------------------------------------------------------------------------------------------------------
AF2 AF2_AH2_AU1_x(AU1 x){return AF2(f16tof32(x&0xFFFF),f16tof32(x>>16));}
#define AF2_AH2_AU1(x) AF2_AH2_AU1_x(AU1(x))
//==============================================================================================================================
AF1 AF1_x(AF1 a){return AF1(a);}
AF2 AF2_x(AF1 a){return AF2(a,a);}
AF3 AF3_x(AF1 a){return AF3(a,a,a);}
AF4 AF4_x(AF1 a){return AF4(a,a,a,a);}
#define AF1_(a) AF1_x(AF1(a))
#define AF2_(a) AF2_x(AF1(a))
#define AF3_(a) AF3_x(AF1(a))
#define AF4_(a) AF4_x(AF1(a))
//------------------------------------------------------------------------------------------------------------------------------
AU1 AU1_x(AU1 a){return AU1(a);}
AU2 AU2_x(AU1 a){return AU2(a,a);}
AU3 AU3_x(AU1 a){return AU3(a,a,a);}
AU4 AU4_x(AU1 a){return AU4(a,a,a,a);}
#define AU1_(a) AU1_x(AU1(a))
#define AU2_(a) AU2_x(AU1(a))
#define AU3_(a) AU3_x(AU1(a))
#define AU4_(a) AU4_x(AU1(a))
//==============================================================================================================================
AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));}
AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));}
AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));}
AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 ABfe(AU1 src,AU1 off,AU1 bits){AU1 mask=(1u<<bits)-1;return (src>>off)&mask;}
AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));}
AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){AU1 mask=(1u<<bits)-1;return (ins&mask)|(src&(~mask));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AClampF1(AF1 x,AF1 n,AF1 m){return max(n,min(x,m));}
AF2 AClampF2(AF2 x,AF2 n,AF2 m){return max(n,min(x,m));}
AF3 AClampF3(AF3 x,AF3 n,AF3 m){return max(n,min(x,m));}
AF4 AClampF4(AF4 x,AF4 n,AF4 m){return max(n,min(x,m));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AFractF1(AF1 x){return x-floor(x);}
AF2 AFractF2(AF2 x){return x-floor(x);}
AF3 AFractF3(AF3 x){return x-floor(x);}
AF4 AFractF4(AF4 x){return x-floor(x);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return lerp(x,y,a);}
AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return lerp(x,y,a);}
AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return lerp(x,y,a);}
AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return lerp(x,y,a);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));}
AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));}
AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));}
AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(z))));}
AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(z))));}
AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(z))));}
AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(z))));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));}
AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));}
AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));}
AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));}
AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));}
AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));}
AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));}
AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));}
AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));}
AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));}
AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));}
AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));}
AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(z))));}
AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(z))));}
AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(z))));}
AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(z))));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));}
AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));}
AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));}
AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));}
AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));}
AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));}
AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));}
AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));}
AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));}
AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));}
AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));}
AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));}
AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ARcpF1(AF1 x){return rcp(x);}
AF2 ARcpF2(AF2 x){return rcp(x);}
AF3 ARcpF3(AF3 x){return rcp(x);}
AF4 ARcpF4(AF4 x){return rcp(x);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ARsqF1(AF1 x){return rsqrt(x);}
AF2 ARsqF2(AF2 x){return rsqrt(x);}
AF3 ARsqF3(AF3 x){return rsqrt(x);}
AF4 ARsqF4(AF4 x){return rsqrt(x);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ASatF1(AF1 x){return saturate(x);}
AF2 ASatF2(AF2 x){return saturate(x);}
AF3 ASatF3(AF3 x){return saturate(x);}
AF4 ASatF4(AF4 x){return saturate(x);}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));}
AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));}
AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));}
AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// HLSL BYTE
//==============================================================================================================================
#ifdef A_BYTE
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// HLSL HALF
//==============================================================================================================================
#ifdef A_HALF
#ifdef A_HLSL_6_2
#define AH1 float16_t
#define AH2 float16_t2
#define AH3 float16_t3
#define AH4 float16_t4
//------------------------------------------------------------------------------------------------------------------------------
#define AW1 uint16_t
#define AW2 uint16_t2
#define AW3 uint16_t3
#define AW4 uint16_t4
//------------------------------------------------------------------------------------------------------------------------------
#define ASW1 int16_t
#define ASW2 int16_t2
#define ASW3 int16_t3
#define ASW4 int16_t4
#else
#define AH1 min16float
#define AH2 min16float2
#define AH3 min16float3
#define AH4 min16float4
//------------------------------------------------------------------------------------------------------------------------------
#define AW1 min16uint
#define AW2 min16uint2
#define AW3 min16uint3
#define AW4 min16uint4
//------------------------------------------------------------------------------------------------------------------------------
#define ASW1 min16int
#define ASW2 min16int2
#define ASW3 min16int3
#define ASW4 min16int4
#endif
//==============================================================================================================================
// Need to use manual unpack to get optimal execution (don't use packed types in buffers directly).
// Unpack requires this pattern: https://gpuopen.com/first-steps-implementing-fp16/
AH2 AH2_AU1_x(AU1 x){AF2 t=f16tof32(AU2(x&0xFFFF,x>>16));return AH2(t);}
AH4 AH4_AU2_x(AU2 x){return AH4(AH2_AU1_x(x.x),AH2_AU1_x(x.y));}
AW2 AW2_AU1_x(AU1 x){AU2 t=AU2(x&0xFFFF,x>>16);return AW2(t);}
AW4 AW4_AU2_x(AU2 x){return AW4(AW2_AU1_x(x.x),AW2_AU1_x(x.y));}
#define AH2_AU1(x) AH2_AU1_x(AU1(x))
#define AH4_AU2(x) AH4_AU2_x(AU2(x))
#define AW2_AU1(x) AW2_AU1_x(AU1(x))
#define AW4_AU2(x) AW4_AU2_x(AU2(x))
//------------------------------------------------------------------------------------------------------------------------------
AU1 AU1_AH2_x(AH2 x){return f32tof16(x.x)+(f32tof16(x.y)<<16);}
AU2 AU2_AH4_x(AH4 x){return AU2(AU1_AH2_x(x.xy),AU1_AH2_x(x.zw));}
AU1 AU1_AW2_x(AW2 x){return AU1(x.x)+(AU1(x.y)<<16);}
AU2 AU2_AW4_x(AW4 x){return AU2(AU1_AW2_x(x.xy),AU1_AW2_x(x.zw));}
#define AU1_AH2(x) AU1_AH2_x(AH2(x))
#define AU2_AH4(x) AU2_AH4_x(AH4(x))
#define AU1_AW2(x) AU1_AW2_x(AW2(x))
#define AU2_AW4(x) AU2_AW4_x(AW4(x))
//==============================================================================================================================
#if defined(A_HLSL_6_2) && !defined(A_NO_16_BIT_CAST)
#define AW1_AH1(x) asuint16(x)
#define AW2_AH2(x) asuint16(x)
#define AW3_AH3(x) asuint16(x)
#define AW4_AH4(x) asuint16(x)
#else
#define AW1_AH1(a) AW1(f32tof16(AF1(a)))
#define AW2_AH2(a) AW2(AW1_AH1((a).x),AW1_AH1((a).y))
#define AW3_AH3(a) AW3(AW1_AH1((a).x),AW1_AH1((a).y),AW1_AH1((a).z))
#define AW4_AH4(a) AW4(AW1_AH1((a).x),AW1_AH1((a).y),AW1_AH1((a).z),AW1_AH1((a).w))
#endif
//------------------------------------------------------------------------------------------------------------------------------
#if defined(A_HLSL_6_2) && !defined(A_NO_16_BIT_CAST)
#define AH1_AW1(x) asfloat16(x)
#define AH2_AW2(x) asfloat16(x)
#define AH3_AW3(x) asfloat16(x)
#define AH4_AW4(x) asfloat16(x)
#else
#define AH1_AW1(a) AH1(f16tof32(AU1(a)))
#define AH2_AW2(a) AH2(AH1_AW1((a).x),AH1_AW1((a).y))
#define AH3_AW3(a) AH3(AH1_AW1((a).x),AH1_AW1((a).y),AH1_AW1((a).z))
#define AH4_AW4(a) AH4(AH1_AW1((a).x),AH1_AW1((a).y),AH1_AW1((a).z),AH1_AW1((a).w))
#endif
//==============================================================================================================================
AH1 AH1_x(AH1 a){return AH1(a);}
AH2 AH2_x(AH1 a){return AH2(a,a);}
AH3 AH3_x(AH1 a){return AH3(a,a,a);}
AH4 AH4_x(AH1 a){return AH4(a,a,a,a);}
#define AH1_(a) AH1_x(AH1(a))
#define AH2_(a) AH2_x(AH1(a))
#define AH3_(a) AH3_x(AH1(a))
#define AH4_(a) AH4_x(AH1(a))
//------------------------------------------------------------------------------------------------------------------------------
AW1 AW1_x(AW1 a){return AW1(a);}
AW2 AW2_x(AW1 a){return AW2(a,a);}
AW3 AW3_x(AW1 a){return AW3(a,a,a);}
AW4 AW4_x(AW1 a){return AW4(a,a,a,a);}
#define AW1_(a) AW1_x(AW1(a))
#define AW2_(a) AW2_x(AW1(a))
#define AW3_(a) AW3_x(AW1(a))
#define AW4_(a) AW4_x(AW1(a))
//==============================================================================================================================
AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));}
AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));}
AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));}
AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AClampH1(AH1 x,AH1 n,AH1 m){return max(n,min(x,m));}
AH2 AClampH2(AH2 x,AH2 n,AH2 m){return max(n,min(x,m));}
AH3 AClampH3(AH3 x,AH3 n,AH3 m){return max(n,min(x,m));}
AH4 AClampH4(AH4 x,AH4 n,AH4 m){return max(n,min(x,m));}
//------------------------------------------------------------------------------------------------------------------------------
// V_FRACT_F16 (note DX frac() is different).
AH1 AFractH1(AH1 x){return x-floor(x);}
AH2 AFractH2(AH2 x){return x-floor(x);}
AH3 AFractH3(AH3 x){return x-floor(x);}
AH4 AFractH4(AH4 x){return x-floor(x);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return lerp(x,y,a);}
AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return lerp(x,y,a);}
AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return lerp(x,y,a);}
AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return lerp(x,y,a);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));}
AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));}
AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));}
AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));}
AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));}
AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));}
AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));}
AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));}
AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));}
AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));}
//------------------------------------------------------------------------------------------------------------------------------
AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));}
AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));}
AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));}
AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ARcpH1(AH1 x){return rcp(x);}
AH2 ARcpH2(AH2 x){return rcp(x);}
AH3 ARcpH3(AH3 x){return rcp(x);}
AH4 ARcpH4(AH4 x){return rcp(x);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ARsqH1(AH1 x){return rsqrt(x);}
AH2 ARsqH2(AH2 x){return rsqrt(x);}
AH3 ARsqH3(AH3 x){return rsqrt(x);}
AH4 ARsqH4(AH4 x){return rsqrt(x);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ASatH1(AH1 x){return saturate(x);}
AH2 ASatH2(AH2 x){return saturate(x);}
AH3 ASatH3(AH3 x){return saturate(x);}
AH4 ASatH4(AH4 x){return saturate(x);}
//------------------------------------------------------------------------------------------------------------------------------
AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));}
AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));}
AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));}
AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// HLSL DOUBLE
//==============================================================================================================================
#ifdef A_DUBL
#ifdef A_HLSL_6_2
#define AD1 float64_t
#define AD2 float64_t2
#define AD3 float64_t3
#define AD4 float64_t4
#else
#define AD1 double
#define AD2 double2
#define AD3 double3
#define AD4 double4
#endif
//------------------------------------------------------------------------------------------------------------------------------
AD1 AD1_x(AD1 a){return AD1(a);}
AD2 AD2_x(AD1 a){return AD2(a,a);}
AD3 AD3_x(AD1 a){return AD3(a,a,a);}
AD4 AD4_x(AD1 a){return AD4(a,a,a,a);}
#define AD1_(a) AD1_x(AD1(a))
#define AD2_(a) AD2_x(AD1(a))
#define AD3_(a) AD3_x(AD1(a))
#define AD4_(a) AD4_x(AD1(a))
//==============================================================================================================================
AD1 AFractD1(AD1 a){return a-floor(a);}
AD2 AFractD2(AD2 a){return a-floor(a);}
AD3 AFractD3(AD3 a){return a-floor(a);}
AD4 AFractD4(AD4 a){return a-floor(a);}
//------------------------------------------------------------------------------------------------------------------------------
AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return lerp(x,y,a);}
AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return lerp(x,y,a);}
AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return lerp(x,y,a);}
AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return lerp(x,y,a);}
//------------------------------------------------------------------------------------------------------------------------------
AD1 ARcpD1(AD1 x){return rcp(x);}
AD2 ARcpD2(AD2 x){return rcp(x);}
AD3 ARcpD3(AD3 x){return rcp(x);}
AD4 ARcpD4(AD4 x){return rcp(x);}
//------------------------------------------------------------------------------------------------------------------------------
AD1 ARsqD1(AD1 x){return rsqrt(x);}
AD2 ARsqD2(AD2 x){return rsqrt(x);}
AD3 ARsqD3(AD3 x){return rsqrt(x);}
AD4 ARsqD4(AD4 x){return rsqrt(x);}
//------------------------------------------------------------------------------------------------------------------------------
AD1 ASatD1(AD1 x){return saturate(x);}
AD2 ASatD2(AD2 x){return saturate(x);}
AD3 ASatD3(AD3 x){return saturate(x);}
AD4 ASatD4(AD4 x){return saturate(x);}
#endif
//==============================================================================================================================
// HLSL WAVE
//==============================================================================================================================
#ifdef A_WAVE
// Where 'x' must be a compile time literal.
AF1 AWaveXorF1(AF1 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AF2 AWaveXorF2(AF2 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AF3 AWaveXorF3(AF3 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AF4 AWaveXorF4(AF4 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AU1 AWaveXorU1(AU1 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AU2 AWaveXorU1(AU2 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AU3 AWaveXorU1(AU3 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AU4 AWaveXorU1(AU4 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_HALF
AH2 AWaveXorH2(AH2 v,AU1 x){return AH2_AU1(WaveReadLaneAt(AU1_AH2(v),WaveGetLaneIndex()^x));}
AH4 AWaveXorH4(AH4 v,AU1 x){return AH4_AU2(WaveReadLaneAt(AU2_AH4(v),WaveGetLaneIndex()^x));}
AW2 AWaveXorW2(AW2 v,AU1 x){return AW2_AU1(WaveReadLaneAt(AU1_AW2(v),WaveGetLaneIndex()^x));}
AW4 AWaveXorW4(AW4 v,AU1 x){return AW4_AU1(WaveReadLaneAt(AU1_AW4(v),WaveGetLaneIndex()^x));}
#endif
#endif
//==============================================================================================================================
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
//
//
// GPU COMMON
//
//
//==============================================================================================================================
#ifdef A_GPU
// Negative and positive infinity.
#define A_INFP_F AF1_AU1(0x7f800000u)
#define A_INFN_F AF1_AU1(0xff800000u)
//------------------------------------------------------------------------------------------------------------------------------
// Copy sign from 's' to positive 'd'.
AF1 ACpySgnF1(AF1 d,AF1 s){return AF1_AU1(AU1_AF1(d)|(AU1_AF1(s)&AU1_(0x80000000u)));}
AF2 ACpySgnF2(AF2 d,AF2 s){return AF2_AU2(AU2_AF2(d)|(AU2_AF2(s)&AU2_(0x80000000u)));}
AF3 ACpySgnF3(AF3 d,AF3 s){return AF3_AU3(AU3_AF3(d)|(AU3_AF3(s)&AU3_(0x80000000u)));}
AF4 ACpySgnF4(AF4 d,AF4 s){return AF4_AU4(AU4_AF4(d)|(AU4_AF4(s)&AU4_(0x80000000u)));}
//------------------------------------------------------------------------------------------------------------------------------
// Single operation to return (useful to create a mask to use in lerp for branch free logic),
// m=NaN := 0
// m>=0 := 0
// m<0 := 1
// Uses the following useful floating point logic,
// saturate(+a*(-INF)==-INF) := 0
// saturate( 0*(-INF)== NaN) := 0
// saturate(-a*(-INF)==+INF) := 1
AF1 ASignedF1(AF1 m){return ASatF1(m*AF1_(A_INFN_F));}
AF2 ASignedF2(AF2 m){return ASatF2(m*AF2_(A_INFN_F));}
AF3 ASignedF3(AF3 m){return ASatF3(m*AF3_(A_INFN_F));}
AF4 ASignedF4(AF4 m){return ASatF4(m*AF4_(A_INFN_F));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AGtZeroF1(AF1 m){return ASatF1(m*AF1_(A_INFP_F));}
AF2 AGtZeroF2(AF2 m){return ASatF2(m*AF2_(A_INFP_F));}
AF3 AGtZeroF3(AF3 m){return ASatF3(m*AF3_(A_INFP_F));}
AF4 AGtZeroF4(AF4 m){return ASatF4(m*AF4_(A_INFP_F));}
//==============================================================================================================================
#ifdef A_HALF
#ifdef A_HLSL_6_2
#define A_INFP_H AH1_AW1((uint16_t)0x7c00u)
#define A_INFN_H AH1_AW1((uint16_t)0xfc00u)
#else
#define A_INFP_H AH1_AW1(0x7c00u)
#define A_INFN_H AH1_AW1(0xfc00u)
#endif
//------------------------------------------------------------------------------------------------------------------------------
AH1 ACpySgnH1(AH1 d,AH1 s){return AH1_AW1(AW1_AH1(d)|(AW1_AH1(s)&AW1_(0x8000u)));}
AH2 ACpySgnH2(AH2 d,AH2 s){return AH2_AW2(AW2_AH2(d)|(AW2_AH2(s)&AW2_(0x8000u)));}
AH3 ACpySgnH3(AH3 d,AH3 s){return AH3_AW3(AW3_AH3(d)|(AW3_AH3(s)&AW3_(0x8000u)));}
AH4 ACpySgnH4(AH4 d,AH4 s){return AH4_AW4(AW4_AH4(d)|(AW4_AH4(s)&AW4_(0x8000u)));}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ASignedH1(AH1 m){return ASatH1(m*AH1_(A_INFN_H));}
AH2 ASignedH2(AH2 m){return ASatH2(m*AH2_(A_INFN_H));}
AH3 ASignedH3(AH3 m){return ASatH3(m*AH3_(A_INFN_H));}
AH4 ASignedH4(AH4 m){return ASatH4(m*AH4_(A_INFN_H));}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AGtZeroH1(AH1 m){return ASatH1(m*AH1_(A_INFP_H));}
AH2 AGtZeroH2(AH2 m){return ASatH2(m*AH2_(A_INFP_H));}
AH3 AGtZeroH3(AH3 m){return ASatH3(m*AH3_(A_INFP_H));}
AH4 AGtZeroH4(AH4 m){return ASatH4(m*AH4_(A_INFP_H));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// [FIS] FLOAT INTEGER SORTABLE
//------------------------------------------------------------------------------------------------------------------------------
// Float to integer sortable.
// - If sign bit=0, flip the sign bit (positives).
// - If sign bit=1, flip all bits (negatives).
// Integer sortable to float.
// - If sign bit=1, flip the sign bit (positives).
// - If sign bit=0, flip all bits (negatives).
// Has nice side effects.
// - Larger integers are more positive values.
// - Float zero is mapped to center of integers (so clear to integer zero is a nice default for atomic max usage).
// Burns 3 ops for conversion {shift,or,xor}.
//==============================================================================================================================
AU1 AFisToU1(AU1 x){return x^(( AShrSU1(x,AU1_(31)))|AU1_(0x80000000));}
AU1 AFisFromU1(AU1 x){return x^((~AShrSU1(x,AU1_(31)))|AU1_(0x80000000));}
//------------------------------------------------------------------------------------------------------------------------------
// Just adjust high 16-bit value (useful when upper part of 32-bit word is a 16-bit float value).
AU1 AFisToHiU1(AU1 x){return x^(( AShrSU1(x,AU1_(15)))|AU1_(0x80000000));}
AU1 AFisFromHiU1(AU1 x){return x^((~AShrSU1(x,AU1_(15)))|AU1_(0x80000000));}
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_HALF
AW1 AFisToW1(AW1 x){return x^(( AShrSW1(x,AW1_(15)))|AW1_(0x8000));}
AW1 AFisFromW1(AW1 x){return x^((~AShrSW1(x,AW1_(15)))|AW1_(0x8000));}
//------------------------------------------------------------------------------------------------------------------------------
AW2 AFisToW2(AW2 x){return x^(( AShrSW2(x,AW2_(15)))|AW2_(0x8000));}
AW2 AFisFromW2(AW2 x){return x^((~AShrSW2(x,AW2_(15)))|AW2_(0x8000));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// [PERM] V_PERM_B32
//------------------------------------------------------------------------------------------------------------------------------
// Support for V_PERM_B32 started in the 3rd generation of GCN.
//------------------------------------------------------------------------------------------------------------------------------
// yyyyxxxx - The 'i' input.
// 76543210
// ========
// HGFEDCBA - Naming on permutation.
//------------------------------------------------------------------------------------------------------------------------------
// TODO
// ====
// - Make sure compiler optimizes this.
//==============================================================================================================================
#ifdef A_HALF
AU1 APerm0E0A(AU2 i){return((i.x )&0xffu)|((i.y<<16)&0xff0000u);}
AU1 APerm0F0B(AU2 i){return((i.x>> 8)&0xffu)|((i.y<< 8)&0xff0000u);}
AU1 APerm0G0C(AU2 i){return((i.x>>16)&0xffu)|((i.y )&0xff0000u);}
AU1 APerm0H0D(AU2 i){return((i.x>>24)&0xffu)|((i.y>> 8)&0xff0000u);}
//------------------------------------------------------------------------------------------------------------------------------
AU1 APermHGFA(AU2 i){return((i.x )&0x000000ffu)|(i.y&0xffffff00u);}
AU1 APermHGFC(AU2 i){return((i.x>>16)&0x000000ffu)|(i.y&0xffffff00u);}
AU1 APermHGAE(AU2 i){return((i.x<< 8)&0x0000ff00u)|(i.y&0xffff00ffu);}
AU1 APermHGCE(AU2 i){return((i.x>> 8)&0x0000ff00u)|(i.y&0xffff00ffu);}
AU1 APermHAFE(AU2 i){return((i.x<<16)&0x00ff0000u)|(i.y&0xff00ffffu);}
AU1 APermHCFE(AU2 i){return((i.x )&0x00ff0000u)|(i.y&0xff00ffffu);}
AU1 APermAGFE(AU2 i){return((i.x<<24)&0xff000000u)|(i.y&0x00ffffffu);}
AU1 APermCGFE(AU2 i){return((i.x<< 8)&0xff000000u)|(i.y&0x00ffffffu);}
//------------------------------------------------------------------------------------------------------------------------------
AU1 APermGCEA(AU2 i){return((i.x)&0x00ff00ffu)|((i.y<<8)&0xff00ff00u);}
AU1 APermGECA(AU2 i){return(((i.x)&0xffu)|((i.x>>8)&0xff00u)|((i.y<<16)&0xff0000u)|((i.y<<8)&0xff000000u));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// [BUC] BYTE UNSIGNED CONVERSION
//------------------------------------------------------------------------------------------------------------------------------
// Designed to use the optimal conversion, enables the scaling to possibly be factored into other computation.
// Works on a range of {0 to A_BUC_<32,16>}, for <32-bit, and 16-bit> respectively.
//------------------------------------------------------------------------------------------------------------------------------
// OPCODE NOTES
// ============
// GCN does not do UNORM or SNORM for bytes in opcodes.
// - V_CVT_F32_UBYTE{0,1,2,3} - Unsigned byte to float.
// - V_CVT_PKACC_U8_F32 - Float to unsigned byte (does bit-field insert into 32-bit integer).
// V_PERM_B32 does byte packing with ability to zero fill bytes as well.
// - Can pull out byte values from two sources, and zero fill upper 8-bits of packed hi and lo.
//------------------------------------------------------------------------------------------------------------------------------
// BYTE : FLOAT - ABuc{0,1,2,3}{To,From}U1() - Designed for V_CVT_F32_UBYTE* and V_CVT_PKACCUM_U8_F32 ops.
// ==== =====
// 0 : 0
// 1 : 1
// ...
// 255 : 255
// : 256 (just outside the encoding range)
//------------------------------------------------------------------------------------------------------------------------------
// BYTE : FLOAT - ABuc{0,1,2,3}{To,From}U2() - Designed for 16-bit denormal tricks and V_PERM_B32.
// ==== =====
// 0 : 0
// 1 : 1/512
// 2 : 1/256
// ...
// 64 : 1/8
// 128 : 1/4
// 255 : 255/512
// : 1/2 (just outside the encoding range)
//------------------------------------------------------------------------------------------------------------------------------
// OPTIMAL IMPLEMENTATIONS ON AMD ARCHITECTURES
// ============================================
// r=ABuc0FromU1(i)
// V_CVT_F32_UBYTE0 r,i
// --------------------------------------------
// r=ABuc0ToU1(d,i)
// V_CVT_PKACCUM_U8_F32 r,i,0,d
// --------------------------------------------
// d=ABuc0FromU2(i)
// Where 'k0' is an SGPR with 0x0E0A
// Where 'k1' is an SGPR with {32768.0} packed into the lower 16-bits
// V_PERM_B32 d,i.x,i.y,k0
// V_PK_FMA_F16 d,d,k1.x,0
// --------------------------------------------
// r=ABuc0ToU2(d,i)
// Where 'k0' is an SGPR with {1.0/32768.0} packed into the lower 16-bits
// Where 'k1' is an SGPR with 0x????
// Where 'k2' is an SGPR with 0x????
// V_PK_FMA_F16 i,i,k0.x,0
// V_PERM_B32 r.x,i,i,k1
// V_PERM_B32 r.y,i,i,k2
//==============================================================================================================================
// Peak range for 32-bit and 16-bit operations.
#define A_BUC_32 (255.0)
#define A_BUC_16 (255.0/512.0)
//==============================================================================================================================
#if 1
// Designed to be one V_CVT_PKACCUM_U8_F32.
// The extra min is required to pattern match to V_CVT_PKACCUM_U8_F32.
AU1 ABuc0ToU1(AU1 d,AF1 i){return (d&0xffffff00u)|((min(AU1(i),255u) )&(0x000000ffu));}
AU1 ABuc1ToU1(AU1 d,AF1 i){return (d&0xffff00ffu)|((min(AU1(i),255u)<< 8)&(0x0000ff00u));}
AU1 ABuc2ToU1(AU1 d,AF1 i){return (d&0xff00ffffu)|((min(AU1(i),255u)<<16)&(0x00ff0000u));}
AU1 ABuc3ToU1(AU1 d,AF1 i){return (d&0x00ffffffu)|((min(AU1(i),255u)<<24)&(0xff000000u));}
//------------------------------------------------------------------------------------------------------------------------------
// Designed to be one V_CVT_F32_UBYTE*.
AF1 ABuc0FromU1(AU1 i){return AF1((i )&255u);}
AF1 ABuc1FromU1(AU1 i){return AF1((i>> 8)&255u);}
AF1 ABuc2FromU1(AU1 i){return AF1((i>>16)&255u);}
AF1 ABuc3FromU1(AU1 i){return AF1((i>>24)&255u);}
#endif
//==============================================================================================================================
#ifdef A_HALF
// Takes {x0,x1} and {y0,y1} and builds {{x0,y0},{x1,y1}}.
AW2 ABuc01ToW2(AH2 x,AH2 y){x*=AH2_(1.0/32768.0);y*=AH2_(1.0/32768.0);
return AW2_AU1(APermGCEA(AU2(AU1_AW2(AW2_AH2(x)),AU1_AW2(AW2_AH2(y)))));}
//------------------------------------------------------------------------------------------------------------------------------
// Designed for 3 ops to do SOA to AOS and conversion.
AU2 ABuc0ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));}
AU2 ABuc1ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));}
AU2 ABuc2ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));}
AU2 ABuc3ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));}
//------------------------------------------------------------------------------------------------------------------------------
// Designed for 2 ops to do both AOS to SOA, and conversion.
AH2 ABuc0FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)))*AH2_(32768.0);}
AH2 ABuc1FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)))*AH2_(32768.0);}
AH2 ABuc2FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)))*AH2_(32768.0);}
AH2 ABuc3FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)))*AH2_(32768.0);}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// [BSC] BYTE SIGNED CONVERSION
//------------------------------------------------------------------------------------------------------------------------------
// Similar to [BUC].
// Works on a range of {-/+ A_BSC_<32,16>}, for <32-bit, and 16-bit> respectively.
//------------------------------------------------------------------------------------------------------------------------------
// ENCODING (without zero-based encoding)
// ========
// 0 = unused (can be used to mean something else)
// 1 = lowest value
// 128 = exact zero center (zero based encoding
// 255 = highest value
//------------------------------------------------------------------------------------------------------------------------------
// Zero-based [Zb] flips the MSB bit of the byte (making 128 "exact zero" actually zero).
// This is useful if there is a desire for cleared values to decode as zero.
//------------------------------------------------------------------------------------------------------------------------------
// BYTE : FLOAT - ABsc{0,1,2,3}{To,From}U2() - Designed for 16-bit denormal tricks and V_PERM_B32.
// ==== =====
// 0 : -127/512 (unused)
// 1 : -126/512
// 2 : -125/512
// ...
// 128 : 0
// ...
// 255 : 127/512
// : 1/4 (just outside the encoding range)
//==============================================================================================================================
// Peak range for 32-bit and 16-bit operations.
#define A_BSC_32 (127.0)
#define A_BSC_16 (127.0/512.0)
//==============================================================================================================================
#if 1
AU1 ABsc0ToU1(AU1 d,AF1 i){return (d&0xffffff00u)|((min(AU1(i+128.0),255u) )&(0x000000ffu));}
AU1 ABsc1ToU1(AU1 d,AF1 i){return (d&0xffff00ffu)|((min(AU1(i+128.0),255u)<< 8)&(0x0000ff00u));}
AU1 ABsc2ToU1(AU1 d,AF1 i){return (d&0xff00ffffu)|((min(AU1(i+128.0),255u)<<16)&(0x00ff0000u));}
AU1 ABsc3ToU1(AU1 d,AF1 i){return (d&0x00ffffffu)|((min(AU1(i+128.0),255u)<<24)&(0xff000000u));}
//------------------------------------------------------------------------------------------------------------------------------
AU1 ABsc0ToZbU1(AU1 d,AF1 i){return ((d&0xffffff00u)|((min(AU1(trunc(i)+128.0),255u) )&(0x000000ffu)))^0x00000080u;}
AU1 ABsc1ToZbU1(AU1 d,AF1 i){return ((d&0xffff00ffu)|((min(AU1(trunc(i)+128.0),255u)<< 8)&(0x0000ff00u)))^0x00008000u;}
AU1 ABsc2ToZbU1(AU1 d,AF1 i){return ((d&0xff00ffffu)|((min(AU1(trunc(i)+128.0),255u)<<16)&(0x00ff0000u)))^0x00800000u;}
AU1 ABsc3ToZbU1(AU1 d,AF1 i){return ((d&0x00ffffffu)|((min(AU1(trunc(i)+128.0),255u)<<24)&(0xff000000u)))^0x80000000u;}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ABsc0FromU1(AU1 i){return AF1((i )&255u)-128.0;}
AF1 ABsc1FromU1(AU1 i){return AF1((i>> 8)&255u)-128.0;}
AF1 ABsc2FromU1(AU1 i){return AF1((i>>16)&255u)-128.0;}
AF1 ABsc3FromU1(AU1 i){return AF1((i>>24)&255u)-128.0;}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ABsc0FromZbU1(AU1 i){return AF1(((i )&255u)^0x80u)-128.0;}
AF1 ABsc1FromZbU1(AU1 i){return AF1(((i>> 8)&255u)^0x80u)-128.0;}
AF1 ABsc2FromZbU1(AU1 i){return AF1(((i>>16)&255u)^0x80u)-128.0;}
AF1 ABsc3FromZbU1(AU1 i){return AF1(((i>>24)&255u)^0x80u)-128.0;}
#endif
//==============================================================================================================================
#ifdef A_HALF
// Takes {x0,x1} and {y0,y1} and builds {{x0,y0},{x1,y1}}.
AW2 ABsc01ToW2(AH2 x,AH2 y){x=x*AH2_(1.0/32768.0)+AH2_(0.25/32768.0);y=y*AH2_(1.0/32768.0)+AH2_(0.25/32768.0);
return AW2_AU1(APermGCEA(AU2(AU1_AW2(AW2_AH2(x)),AU1_AW2(AW2_AH2(y)))));}
//------------------------------------------------------------------------------------------------------------------------------
AU2 ABsc0ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)));
return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));}
AU2 ABsc1ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)));
return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));}
AU2 ABsc2ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)));
return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));}
AU2 ABsc3ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)));
return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));}
//------------------------------------------------------------------------------------------------------------------------------
AU2 ABsc0ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u;
return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));}
AU2 ABsc1ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u;
return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));}
AU2 ABsc2ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u;
return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));}
AU2 ABsc3ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u;
return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));}
//------------------------------------------------------------------------------------------------------------------------------
AH2 ABsc0FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc1FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc2FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc3FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)))*AH2_(32768.0)-AH2_(0.25);}
//------------------------------------------------------------------------------------------------------------------------------
AH2 ABsc0FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc1FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc2FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc3FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// HALF APPROXIMATIONS
//------------------------------------------------------------------------------------------------------------------------------
// These support only positive inputs.
// Did not see value yet in specialization for range.
// Using quick testing, ended up mostly getting the same "best" approximation for various ranges.
// With hardware that can co-execute transcendentals, the value in approximations could be less than expected.
// However from a latency perspective, if execution of a transcendental is 4 clk, with no packed support, -> 8 clk total.
// And co-execution would require a compiler interleaving a lot of independent work for packed usage.
//------------------------------------------------------------------------------------------------------------------------------
// The one Newton Raphson iteration form of rsq() was skipped (requires 6 ops total).
// Same with sqrt(), as this could be x*rsq() (7 ops).
//==============================================================================================================================
#ifdef A_HALF
// Minimize squared error across full positive range, 2 ops.
// The 0x1de2 based approximation maps {0 to 1} input maps to < 1 output.
AH1 APrxLoSqrtH1(AH1 a){return AH1_AW1((AW1_AH1(a)>>AW1_(1))+AW1_(0x1de2));}
AH2 APrxLoSqrtH2(AH2 a){return AH2_AW2((AW2_AH2(a)>>AW2_(1))+AW2_(0x1de2));}
AH3 APrxLoSqrtH3(AH3 a){return AH3_AW3((AW3_AH3(a)>>AW3_(1))+AW3_(0x1de2));}
AH4 APrxLoSqrtH4(AH4 a){return AH4_AW4((AW4_AH4(a)>>AW4_(1))+AW4_(0x1de2));}
//------------------------------------------------------------------------------------------------------------------------------
// Lower precision estimation, 1 op.
// Minimize squared error across {smallest normal to 16384.0}.
AH1 APrxLoRcpH1(AH1 a){return AH1_AW1(AW1_(0x7784)-AW1_AH1(a));}
AH2 APrxLoRcpH2(AH2 a){return AH2_AW2(AW2_(0x7784)-AW2_AH2(a));}
AH3 APrxLoRcpH3(AH3 a){return AH3_AW3(AW3_(0x7784)-AW3_AH3(a));}
AH4 APrxLoRcpH4(AH4 a){return AH4_AW4(AW4_(0x7784)-AW4_AH4(a));}
//------------------------------------------------------------------------------------------------------------------------------
// Medium precision estimation, one Newton Raphson iteration, 3 ops.
AH1 APrxMedRcpH1(AH1 a){AH1 b=AH1_AW1(AW1_(0x778d)-AW1_AH1(a));return b*(-b*a+AH1_(2.0));}
AH2 APrxMedRcpH2(AH2 a){AH2 b=AH2_AW2(AW2_(0x778d)-AW2_AH2(a));return b*(-b*a+AH2_(2.0));}
AH3 APrxMedRcpH3(AH3 a){AH3 b=AH3_AW3(AW3_(0x778d)-AW3_AH3(a));return b*(-b*a+AH3_(2.0));}
AH4 APrxMedRcpH4(AH4 a){AH4 b=AH4_AW4(AW4_(0x778d)-AW4_AH4(a));return b*(-b*a+AH4_(2.0));}
//------------------------------------------------------------------------------------------------------------------------------
// Minimize squared error across {smallest normal to 16384.0}, 2 ops.
AH1 APrxLoRsqH1(AH1 a){return AH1_AW1(AW1_(0x59a3)-(AW1_AH1(a)>>AW1_(1)));}
AH2 APrxLoRsqH2(AH2 a){return AH2_AW2(AW2_(0x59a3)-(AW2_AH2(a)>>AW2_(1)));}
AH3 APrxLoRsqH3(AH3 a){return AH3_AW3(AW3_(0x59a3)-(AW3_AH3(a)>>AW3_(1)));}
AH4 APrxLoRsqH4(AH4 a){return AH4_AW4(AW4_(0x59a3)-(AW4_AH4(a)>>AW4_(1)));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// FLOAT APPROXIMATIONS
//------------------------------------------------------------------------------------------------------------------------------
// Michal Drobot has an excellent presentation on these: "Low Level Optimizations For GCN",
// - Idea dates back to SGI, then to Quake 3, etc.
// - https://michaldrobot.files.wordpress.com/2014/05/gcn_alu_opt_digitaldragons2014.pdf
// - sqrt(x)=rsqrt(x)*x
// - rcp(x)=rsqrt(x)*rsqrt(x) for positive x
// - https://github.com/michaldrobot/ShaderFastLibs/blob/master/ShaderFastMathLib.h
//------------------------------------------------------------------------------------------------------------------------------
// These below are from perhaps less complete searching for optimal.
// Used FP16 normal range for testing with +4096 32-bit step size for sampling error.
// So these match up well with the half approximations.
//==============================================================================================================================
AF1 APrxLoSqrtF1(AF1 a){return AF1_AU1((AU1_AF1(a)>>AU1_(1))+AU1_(0x1fbc4639));}
AF1 APrxLoRcpF1(AF1 a){return AF1_AU1(AU1_(0x7ef07ebb)-AU1_AF1(a));}
AF1 APrxMedRcpF1(AF1 a){AF1 b=AF1_AU1(AU1_(0x7ef19fff)-AU1_AF1(a));return b*(-b*a+AF1_(2.0));}
AF1 APrxLoRsqF1(AF1 a){return AF1_AU1(AU1_(0x5f347d74)-(AU1_AF1(a)>>AU1_(1)));}
//------------------------------------------------------------------------------------------------------------------------------
AF2 APrxLoSqrtF2(AF2 a){return AF2_AU2((AU2_AF2(a)>>AU2_(1))+AU2_(0x1fbc4639));}
AF2 APrxLoRcpF2(AF2 a){return AF2_AU2(AU2_(0x7ef07ebb)-AU2_AF2(a));}
AF2 APrxMedRcpF2(AF2 a){AF2 b=AF2_AU2(AU2_(0x7ef19fff)-AU2_AF2(a));return b*(-b*a+AF2_(2.0));}
AF2 APrxLoRsqF2(AF2 a){return AF2_AU2(AU2_(0x5f347d74)-(AU2_AF2(a)>>AU2_(1)));}
//------------------------------------------------------------------------------------------------------------------------------
AF3 APrxLoSqrtF3(AF3 a){return AF3_AU3((AU3_AF3(a)>>AU3_(1))+AU3_(0x1fbc4639));}
AF3 APrxLoRcpF3(AF3 a){return AF3_AU3(AU3_(0x7ef07ebb)-AU3_AF3(a));}
AF3 APrxMedRcpF3(AF3 a){AF3 b=AF3_AU3(AU3_(0x7ef19fff)-AU3_AF3(a));return b*(-b*a+AF3_(2.0));}
AF3 APrxLoRsqF3(AF3 a){return AF3_AU3(AU3_(0x5f347d74)-(AU3_AF3(a)>>AU3_(1)));}
//------------------------------------------------------------------------------------------------------------------------------
AF4 APrxLoSqrtF4(AF4 a){return AF4_AU4((AU4_AF4(a)>>AU4_(1))+AU4_(0x1fbc4639));}
AF4 APrxLoRcpF4(AF4 a){return AF4_AU4(AU4_(0x7ef07ebb)-AU4_AF4(a));}
AF4 APrxMedRcpF4(AF4 a){AF4 b=AF4_AU4(AU4_(0x7ef19fff)-AU4_AF4(a));return b*(-b*a+AF4_(2.0));}
AF4 APrxLoRsqF4(AF4 a){return AF4_AU4(AU4_(0x5f347d74)-(AU4_AF4(a)>>AU4_(1)));}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// PQ APPROXIMATIONS
//------------------------------------------------------------------------------------------------------------------------------
// PQ is very close to x^(1/8). The functions below Use the fast float approximation method to do
// PQ<~>Gamma2 (4th power and fast 4th root) and PQ<~>Linear (8th power and fast 8th root). Maximum error is ~0.2%.
//==============================================================================================================================
// Helpers
AF1 Quart(AF1 a) { a = a * a; return a * a;}
AF1 Oct(AF1 a) { a = a * a; a = a * a; return a * a; }
AF2 Quart(AF2 a) { a = a * a; return a * a; }
AF2 Oct(AF2 a) { a = a * a; a = a * a; return a * a; }
AF3 Quart(AF3 a) { a = a * a; return a * a; }
AF3 Oct(AF3 a) { a = a * a; a = a * a; return a * a; }
AF4 Quart(AF4 a) { a = a * a; return a * a; }
AF4 Oct(AF4 a) { a = a * a; a = a * a; return a * a; }
//------------------------------------------------------------------------------------------------------------------------------
AF1 APrxPQToGamma2(AF1 a) { return Quart(a); }
AF1 APrxPQToLinear(AF1 a) { return Oct(a); }
AF1 APrxLoGamma2ToPQ(AF1 a) { return AF1_AU1((AU1_AF1(a) >> AU1_(2)) + AU1_(0x2F9A4E46)); }
AF1 APrxMedGamma2ToPQ(AF1 a) { AF1 b = AF1_AU1((AU1_AF1(a) >> AU1_(2)) + AU1_(0x2F9A4E46)); AF1 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); }
AF1 APrxHighGamma2ToPQ(AF1 a) { return sqrt(sqrt(a)); }
AF1 APrxLoLinearToPQ(AF1 a) { return AF1_AU1((AU1_AF1(a) >> AU1_(3)) + AU1_(0x378D8723)); }
AF1 APrxMedLinearToPQ(AF1 a) { AF1 b = AF1_AU1((AU1_AF1(a) >> AU1_(3)) + AU1_(0x378D8723)); AF1 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); }
AF1 APrxHighLinearToPQ(AF1 a) { return sqrt(sqrt(sqrt(a))); }
//------------------------------------------------------------------------------------------------------------------------------
AF2 APrxPQToGamma2(AF2 a) { return Quart(a); }
AF2 APrxPQToLinear(AF2 a) { return Oct(a); }
AF2 APrxLoGamma2ToPQ(AF2 a) { return AF2_AU2((AU2_AF2(a) >> AU2_(2)) + AU2_(0x2F9A4E46)); }
AF2 APrxMedGamma2ToPQ(AF2 a) { AF2 b = AF2_AU2((AU2_AF2(a) >> AU2_(2)) + AU2_(0x2F9A4E46)); AF2 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); }
AF2 APrxHighGamma2ToPQ(AF2 a) { return sqrt(sqrt(a)); }
AF2 APrxLoLinearToPQ(AF2 a) { return AF2_AU2((AU2_AF2(a) >> AU2_(3)) + AU2_(0x378D8723)); }
AF2 APrxMedLinearToPQ(AF2 a) { AF2 b = AF2_AU2((AU2_AF2(a) >> AU2_(3)) + AU2_(0x378D8723)); AF2 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); }
AF2 APrxHighLinearToPQ(AF2 a) { return sqrt(sqrt(sqrt(a))); }
//------------------------------------------------------------------------------------------------------------------------------
AF3 APrxPQToGamma2(AF3 a) { return Quart(a); }
AF3 APrxPQToLinear(AF3 a) { return Oct(a); }
AF3 APrxLoGamma2ToPQ(AF3 a) { return AF3_AU3((AU3_AF3(a) >> AU3_(2)) + AU3_(0x2F9A4E46)); }
AF3 APrxMedGamma2ToPQ(AF3 a) { AF3 b = AF3_AU3((AU3_AF3(a) >> AU3_(2)) + AU3_(0x2F9A4E46)); AF3 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); }
AF3 APrxHighGamma2ToPQ(AF3 a) { return sqrt(sqrt(a)); }
AF3 APrxLoLinearToPQ(AF3 a) { return AF3_AU3((AU3_AF3(a) >> AU3_(3)) + AU3_(0x378D8723)); }
AF3 APrxMedLinearToPQ(AF3 a) { AF3 b = AF3_AU3((AU3_AF3(a) >> AU3_(3)) + AU3_(0x378D8723)); AF3 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); }
AF3 APrxHighLinearToPQ(AF3 a) { return sqrt(sqrt(sqrt(a))); }
//------------------------------------------------------------------------------------------------------------------------------
AF4 APrxPQToGamma2(AF4 a) { return Quart(a); }
AF4 APrxPQToLinear(AF4 a) { return Oct(a); }
AF4 APrxLoGamma2ToPQ(AF4 a) { return AF4_AU4((AU4_AF4(a) >> AU4_(2)) + AU4_(0x2F9A4E46)); }
AF4 APrxMedGamma2ToPQ(AF4 a) { AF4 b = AF4_AU4((AU4_AF4(a) >> AU4_(2)) + AU4_(0x2F9A4E46)); AF4 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); }
AF4 APrxHighGamma2ToPQ(AF4 a) { return sqrt(sqrt(a)); }
AF4 APrxLoLinearToPQ(AF4 a) { return AF4_AU4((AU4_AF4(a) >> AU4_(3)) + AU4_(0x378D8723)); }
AF4 APrxMedLinearToPQ(AF4 a) { AF4 b = AF4_AU4((AU4_AF4(a) >> AU4_(3)) + AU4_(0x378D8723)); AF4 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); }
AF4 APrxHighLinearToPQ(AF4 a) { return sqrt(sqrt(sqrt(a))); }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// PARABOLIC SIN & COS
//------------------------------------------------------------------------------------------------------------------------------
// Approximate answers to transcendental questions.
//------------------------------------------------------------------------------------------------------------------------------
//==============================================================================================================================
#if 1
// Valid input range is {-1 to 1} representing {0 to 2 pi}.
// Output range is {-1/4 to 1/4} representing {-1 to 1}.
AF1 APSinF1(AF1 x){return x*abs(x)-x;} // MAD.
AF2 APSinF2(AF2 x){return x*abs(x)-x;}
AF1 APCosF1(AF1 x){x=AFractF1(x*AF1_(0.5)+AF1_(0.75));x=x*AF1_(2.0)-AF1_(1.0);return APSinF1(x);} // 3x MAD, FRACT
AF2 APCosF2(AF2 x){x=AFractF2(x*AF2_(0.5)+AF2_(0.75));x=x*AF2_(2.0)-AF2_(1.0);return APSinF2(x);}
AF2 APSinCosF1(AF1 x){AF1 y=AFractF1(x*AF1_(0.5)+AF1_(0.75));y=y*AF1_(2.0)-AF1_(1.0);return APSinF2(AF2(x,y));}
#endif
//------------------------------------------------------------------------------------------------------------------------------
#ifdef A_HALF
// For a packed {sin,cos} pair,
// - Native takes 16 clocks and 4 issue slots (no packed transcendentals).
// - Parabolic takes 8 clocks and 8 issue slots (only fract is non-packed).
AH1 APSinH1(AH1 x){return x*abs(x)-x;}
AH2 APSinH2(AH2 x){return x*abs(x)-x;} // AND,FMA
AH1 APCosH1(AH1 x){x=AFractH1(x*AH1_(0.5)+AH1_(0.75));x=x*AH1_(2.0)-AH1_(1.0);return APSinH1(x);}
AH2 APCosH2(AH2 x){x=AFractH2(x*AH2_(0.5)+AH2_(0.75));x=x*AH2_(2.0)-AH2_(1.0);return APSinH2(x);} // 3x FMA, 2xFRACT, AND
AH2 APSinCosH1(AH1 x){AH1 y=AFractH1(x*AH1_(0.5)+AH1_(0.75));y=y*AH1_(2.0)-AH1_(1.0);return APSinH2(AH2(x,y));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// [ZOL] ZERO ONE LOGIC
//------------------------------------------------------------------------------------------------------------------------------
// Conditional free logic designed for easy 16-bit packing, and backwards porting to 32-bit.
//------------------------------------------------------------------------------------------------------------------------------
// 0 := false
// 1 := true
//------------------------------------------------------------------------------------------------------------------------------
// AndNot(x,y) -> !(x&y) .... One op.
// AndOr(x,y,z) -> (x&y)|z ... One op.
// GtZero(x) -> x>0.0 ..... One op.
// Sel(x,y,z) -> x?y:z ..... Two ops, has no precision loss.
// Signed(x) -> x<0.0 ..... One op.
// ZeroPass(x,y) -> x?0:y ..... Two ops, 'y' is a pass through safe for aliasing as integer.
//------------------------------------------------------------------------------------------------------------------------------
// OPTIMIZATION NOTES
// ==================
// - On Vega to use 2 constants in a packed op, pass in as one AW2 or one AH2 'k.xy' and use as 'k.xx' and 'k.yy'.
// For example 'a.xy*k.xx+k.yy'.
//==============================================================================================================================
#if 1
AU1 AZolAndU1(AU1 x,AU1 y){return min(x,y);}
AU2 AZolAndU2(AU2 x,AU2 y){return min(x,y);}
AU3 AZolAndU3(AU3 x,AU3 y){return min(x,y);}
AU4 AZolAndU4(AU4 x,AU4 y){return min(x,y);}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AZolNotU1(AU1 x){return x^AU1_(1);}
AU2 AZolNotU2(AU2 x){return x^AU2_(1);}
AU3 AZolNotU3(AU3 x){return x^AU3_(1);}
AU4 AZolNotU4(AU4 x){return x^AU4_(1);}
//------------------------------------------------------------------------------------------------------------------------------
AU1 AZolOrU1(AU1 x,AU1 y){return max(x,y);}
AU2 AZolOrU2(AU2 x,AU2 y){return max(x,y);}
AU3 AZolOrU3(AU3 x,AU3 y){return max(x,y);}
AU4 AZolOrU4(AU4 x,AU4 y){return max(x,y);}
//==============================================================================================================================
AU1 AZolF1ToU1(AF1 x){return AU1(x);}
AU2 AZolF2ToU2(AF2 x){return AU2(x);}
AU3 AZolF3ToU3(AF3 x){return AU3(x);}
AU4 AZolF4ToU4(AF4 x){return AU4(x);}
//------------------------------------------------------------------------------------------------------------------------------
// 2 ops, denormals don't work in 32-bit on PC (and if they are enabled, OMOD is disabled).
AU1 AZolNotF1ToU1(AF1 x){return AU1(AF1_(1.0)-x);}
AU2 AZolNotF2ToU2(AF2 x){return AU2(AF2_(1.0)-x);}
AU3 AZolNotF3ToU3(AF3 x){return AU3(AF3_(1.0)-x);}
AU4 AZolNotF4ToU4(AF4 x){return AU4(AF4_(1.0)-x);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AZolU1ToF1(AU1 x){return AF1(x);}
AF2 AZolU2ToF2(AU2 x){return AF2(x);}
AF3 AZolU3ToF3(AU3 x){return AF3(x);}
AF4 AZolU4ToF4(AU4 x){return AF4(x);}
//==============================================================================================================================
AF1 AZolAndF1(AF1 x,AF1 y){return min(x,y);}
AF2 AZolAndF2(AF2 x,AF2 y){return min(x,y);}
AF3 AZolAndF3(AF3 x,AF3 y){return min(x,y);}
AF4 AZolAndF4(AF4 x,AF4 y){return min(x,y);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 ASolAndNotF1(AF1 x,AF1 y){return (-x)*y+AF1_(1.0);}
AF2 ASolAndNotF2(AF2 x,AF2 y){return (-x)*y+AF2_(1.0);}
AF3 ASolAndNotF3(AF3 x,AF3 y){return (-x)*y+AF3_(1.0);}
AF4 ASolAndNotF4(AF4 x,AF4 y){return (-x)*y+AF4_(1.0);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AZolAndOrF1(AF1 x,AF1 y,AF1 z){return ASatF1(x*y+z);}
AF2 AZolAndOrF2(AF2 x,AF2 y,AF2 z){return ASatF2(x*y+z);}
AF3 AZolAndOrF3(AF3 x,AF3 y,AF3 z){return ASatF3(x*y+z);}
AF4 AZolAndOrF4(AF4 x,AF4 y,AF4 z){return ASatF4(x*y+z);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AZolGtZeroF1(AF1 x){return ASatF1(x*AF1_(A_INFP_F));}
AF2 AZolGtZeroF2(AF2 x){return ASatF2(x*AF2_(A_INFP_F));}
AF3 AZolGtZeroF3(AF3 x){return ASatF3(x*AF3_(A_INFP_F));}
AF4 AZolGtZeroF4(AF4 x){return ASatF4(x*AF4_(A_INFP_F));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AZolNotF1(AF1 x){return AF1_(1.0)-x;}
AF2 AZolNotF2(AF2 x){return AF2_(1.0)-x;}
AF3 AZolNotF3(AF3 x){return AF3_(1.0)-x;}
AF4 AZolNotF4(AF4 x){return AF4_(1.0)-x;}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AZolOrF1(AF1 x,AF1 y){return max(x,y);}
AF2 AZolOrF2(AF2 x,AF2 y){return max(x,y);}
AF3 AZolOrF3(AF3 x,AF3 y){return max(x,y);}
AF4 AZolOrF4(AF4 x,AF4 y){return max(x,y);}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AZolSelF1(AF1 x,AF1 y,AF1 z){AF1 r=(-x)*z+z;return x*y+r;}
AF2 AZolSelF2(AF2 x,AF2 y,AF2 z){AF2 r=(-x)*z+z;return x*y+r;}
AF3 AZolSelF3(AF3 x,AF3 y,AF3 z){AF3 r=(-x)*z+z;return x*y+r;}
AF4 AZolSelF4(AF4 x,AF4 y,AF4 z){AF4 r=(-x)*z+z;return x*y+r;}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AZolSignedF1(AF1 x){return ASatF1(x*AF1_(A_INFN_F));}
AF2 AZolSignedF2(AF2 x){return ASatF2(x*AF2_(A_INFN_F));}
AF3 AZolSignedF3(AF3 x){return ASatF3(x*AF3_(A_INFN_F));}
AF4 AZolSignedF4(AF4 x){return ASatF4(x*AF4_(A_INFN_F));}
//------------------------------------------------------------------------------------------------------------------------------
AF1 AZolZeroPassF1(AF1 x, AF1 y){return AF1_AU1(select(AU1_AF1(y), AU1_(0), AU1_AF1(x) != AU1_(0)));}
AF2 AZolZeroPassF2(AF2 x, AF2 y){return AF2_AU2(select(AU2_AF2(y), AU2_(0), AU2_AF2(x) != AU2_(0)));}
AF3 AZolZeroPassF3(AF3 x, AF3 y){return AF3_AU3(select(AU3_AF3(y), AU3_(0), AU3_AF3(x) != AU3_(0)));}
AF4 AZolZeroPassF4(AF4 x, AF4 y){return AF4_AU4(select(AU4_AF4(y), AU4_(0), AU4_AF4(x) != AU4_(0)));}
#endif
//==============================================================================================================================
#ifdef A_HALF
AW1 AZolAndW1(AW1 x,AW1 y){return min(x,y);}
AW2 AZolAndW2(AW2 x,AW2 y){return min(x,y);}
AW3 AZolAndW3(AW3 x,AW3 y){return min(x,y);}
AW4 AZolAndW4(AW4 x,AW4 y){return min(x,y);}
//------------------------------------------------------------------------------------------------------------------------------
AW1 AZolNotW1(AW1 x){return x^AW1_(1);}
AW2 AZolNotW2(AW2 x){return x^AW2_(1);}
AW3 AZolNotW3(AW3 x){return x^AW3_(1);}
AW4 AZolNotW4(AW4 x){return x^AW4_(1);}
//------------------------------------------------------------------------------------------------------------------------------
AW1 AZolOrW1(AW1 x,AW1 y){return max(x,y);}
AW2 AZolOrW2(AW2 x,AW2 y){return max(x,y);}
AW3 AZolOrW3(AW3 x,AW3 y){return max(x,y);}
AW4 AZolOrW4(AW4 x,AW4 y){return max(x,y);}
//==============================================================================================================================
// Uses denormal trick.
AW1 AZolH1ToW1(AH1 x){return AW1_AH1(x*AH1_AW1(AW1_(1)));}
AW2 AZolH2ToW2(AH2 x){return AW2_AH2(x*AH2_AW2(AW2_(1)));}
AW3 AZolH3ToW3(AH3 x){return AW3_AH3(x*AH3_AW3(AW3_(1)));}
AW4 AZolH4ToW4(AH4 x){return AW4_AH4(x*AH4_AW4(AW4_(1)));}
//------------------------------------------------------------------------------------------------------------------------------
// AMD arch lacks a packed conversion opcode.
AH1 AZolW1ToH1(AW1 x){return AH1_AW1(x*AW1_AH1(AH1_(1.0)));}
AH2 AZolW2ToH2(AW2 x){return AH2_AW2(x*AW2_AH2(AH2_(1.0)));}
AH3 AZolW1ToH3(AW3 x){return AH3_AW3(x*AW3_AH3(AH3_(1.0)));}
AH4 AZolW2ToH4(AW4 x){return AH4_AW4(x*AW4_AH4(AH4_(1.0)));}
//==============================================================================================================================
AH1 AZolAndH1(AH1 x,AH1 y){return min(x,y);}
AH2 AZolAndH2(AH2 x,AH2 y){return min(x,y);}
AH3 AZolAndH3(AH3 x,AH3 y){return min(x,y);}
AH4 AZolAndH4(AH4 x,AH4 y){return min(x,y);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 ASolAndNotH1(AH1 x,AH1 y){return (-x)*y+AH1_(1.0);}
AH2 ASolAndNotH2(AH2 x,AH2 y){return (-x)*y+AH2_(1.0);}
AH3 ASolAndNotH3(AH3 x,AH3 y){return (-x)*y+AH3_(1.0);}
AH4 ASolAndNotH4(AH4 x,AH4 y){return (-x)*y+AH4_(1.0);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AZolAndOrH1(AH1 x,AH1 y,AH1 z){return ASatH1(x*y+z);}
AH2 AZolAndOrH2(AH2 x,AH2 y,AH2 z){return ASatH2(x*y+z);}
AH3 AZolAndOrH3(AH3 x,AH3 y,AH3 z){return ASatH3(x*y+z);}
AH4 AZolAndOrH4(AH4 x,AH4 y,AH4 z){return ASatH4(x*y+z);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AZolGtZeroH1(AH1 x){return ASatH1(x*AH1_(A_INFP_H));}
AH2 AZolGtZeroH2(AH2 x){return ASatH2(x*AH2_(A_INFP_H));}
AH3 AZolGtZeroH3(AH3 x){return ASatH3(x*AH3_(A_INFP_H));}
AH4 AZolGtZeroH4(AH4 x){return ASatH4(x*AH4_(A_INFP_H));}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AZolNotH1(AH1 x){return AH1_(1.0)-x;}
AH2 AZolNotH2(AH2 x){return AH2_(1.0)-x;}
AH3 AZolNotH3(AH3 x){return AH3_(1.0)-x;}
AH4 AZolNotH4(AH4 x){return AH4_(1.0)-x;}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AZolOrH1(AH1 x,AH1 y){return max(x,y);}
AH2 AZolOrH2(AH2 x,AH2 y){return max(x,y);}
AH3 AZolOrH3(AH3 x,AH3 y){return max(x,y);}
AH4 AZolOrH4(AH4 x,AH4 y){return max(x,y);}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AZolSelH1(AH1 x,AH1 y,AH1 z){AH1 r=(-x)*z+z;return x*y+r;}
AH2 AZolSelH2(AH2 x,AH2 y,AH2 z){AH2 r=(-x)*z+z;return x*y+r;}
AH3 AZolSelH3(AH3 x,AH3 y,AH3 z){AH3 r=(-x)*z+z;return x*y+r;}
AH4 AZolSelH4(AH4 x,AH4 y,AH4 z){AH4 r=(-x)*z+z;return x*y+r;}
//------------------------------------------------------------------------------------------------------------------------------
AH1 AZolSignedH1(AH1 x){return ASatH1(x*AH1_(A_INFN_H));}
AH2 AZolSignedH2(AH2 x){return ASatH2(x*AH2_(A_INFN_H));}
AH3 AZolSignedH3(AH3 x){return ASatH3(x*AH3_(A_INFN_H));}
AH4 AZolSignedH4(AH4 x){return ASatH4(x*AH4_(A_INFN_H));}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________/\_______________________________________________________________
//==============================================================================================================================
// COLOR CONVERSIONS
//------------------------------------------------------------------------------------------------------------------------------
// These are all linear to/from some other space (where 'linear' has been shortened out of the function name).
// So 'ToGamma' is 'LinearToGamma', and 'FromGamma' is 'LinearFromGamma'.
// These are branch free implementations.
// The AToSrgbF1() function is useful for stores for compute shaders for GPUs without hardware linear->sRGB store conversion.
//------------------------------------------------------------------------------------------------------------------------------
// TRANSFER FUNCTIONS
// ==================
// 709 ..... Rec709 used for some HDTVs
// Gamma ... Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native
// Pq ...... PQ native for HDR10
// Srgb .... The sRGB output, typical of PC displays, useful for 10-bit output, or storing to 8-bit UNORM without SRGB type
// Two ..... Gamma 2.0, fastest conversion (useful for intermediate pass approximations)
// Three ... Gamma 3.0, less fast, but good for HDR.
//------------------------------------------------------------------------------------------------------------------------------
// KEEPING TO SPEC
// ===============
// Both Rec.709 and sRGB have a linear segment which as spec'ed would intersect the curved segment 2 times.
// (a.) For 8-bit sRGB, steps {0 to 10.3} are in the linear region (4% of the encoding range).
// (b.) For 8-bit 709, steps {0 to 20.7} are in the linear region (8% of the encoding range).
// Also there is a slight step in the transition regions.
// Precision of the coefficients in the spec being the likely cause.
// Main usage case of the sRGB code is to do the linear->sRGB converstion in a compute shader before store.
// This is to work around lack of hardware (typically only ROP does the conversion for free).
// To "correct" the linear segment, would be to introduce error, because hardware decode of sRGB->linear is fixed (and free).
// So this header keeps with the spec.
// For linear->sRGB transforms, the linear segment in some respects reduces error, because rounding in that region is linear.
// Rounding in the curved region in hardware (and fast software code) introduces error due to rounding in non-linear.
//------------------------------------------------------------------------------------------
gitextract_nrqdl6fz/
├── .editorconfig
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ └── bug_report.md
│ └── workflows/
│ └── workflow.yml
├── .gitignore
├── build_scripts/
│ ├── Dockerfile
│ ├── ci_test.bat
│ ├── file_utilities.py
│ ├── generate_project_files.py
│ ├── hash_printer.py
│ └── premake.lua
├── code_of_conduct.md
├── data/
│ ├── fonts/
│ │ └── OpenSans/
│ │ └── OFL.txt
│ └── shaders/
│ ├── amd_fidelity_fx/
│ │ ├── cas.hlsl
│ │ ├── ffx_a.h
│ │ ├── ffx_cas.h
│ │ ├── ffx_spd.h
│ │ └── spd.hlsl
│ ├── auto_exposure.hlsl
│ ├── blit.hlsl
│ ├── bloom.hlsl
│ ├── blur.hlsl
│ ├── brdf.hlsl
│ ├── chromatic_aberration.hlsl
│ ├── common.hlsl
│ ├── common_colorspace.hlsl
│ ├── common_resources.hlsl
│ ├── common_structs.hlsl
│ ├── common_terrain.hlsl
│ ├── common_tessellation.hlsl
│ ├── common_vertex_processing.hlsl
│ ├── compressonator/
│ │ ├── bcn_common_api.h
│ │ ├── bcn_common_kernel.h
│ │ └── common_def.h
│ ├── depth_light.hlsl
│ ├── depth_of_field.hlsl
│ ├── depth_prepass.hlsl
│ ├── dithering.hlsl
│ ├── film_grain.hlsl
│ ├── fog.hlsl
│ ├── font.hlsl
│ ├── fxaa/
│ │ ├── fxaa.hlsl
│ │ └── fxaa3_11.h
│ ├── g_buffer.hlsl
│ ├── grid.hlsl
│ ├── icon.hlsl
│ ├── imgui.hlsl
│ ├── indirect_cull.hlsl
│ ├── legacy/
│ │ ├── ssr.hlsl
│ │ └── temporal_antialiasing.hlsl
│ ├── light.hlsl
│ ├── light_composition.hlsl
│ ├── light_image_based.hlsl
│ ├── light_integration.hlsl
│ ├── light_reflections.hlsl
│ ├── line.hlsl
│ ├── motion_blur.hlsl
│ ├── nrd_prepare.hlsl
│ ├── outline.hlsl
│ ├── output.hlsl
│ ├── particles.hlsl
│ ├── ray_traced_reflections.hlsl
│ ├── ray_traced_shadows.hlsl
│ ├── restir_pt.hlsl
│ ├── restir_pt_spatial.hlsl
│ ├── restir_pt_temporal.hlsl
│ ├── restir_reservoir.hlsl
│ ├── scaling.hlsl
│ ├── screen_space_shadows/
│ │ ├── bend_sss.hlsl
│ │ ├── bend_sss_gpu.hlsl
│ │ └── screen_space_shadows.hlsl
│ ├── shadow_mapping.hlsl
│ ├── shared_buffers.h
│ ├── sky/
│ │ ├── cloud_noise.hlsl
│ │ ├── cloud_shadow.hlsl
│ │ └── skysphere.hlsl
│ ├── ssao.hlsl
│ ├── texture_compress_bc1.hlsl
│ ├── texture_compress_bc3.hlsl
│ ├── texture_compress_bc5.hlsl
│ ├── transparency_reflection_refraction.hlsl
│ ├── variable_rate_shading.hlsl
│ └── vhs.hlsl
├── funding.yml
├── generate_project_files.py
├── license.md
├── plan.md
├── readme.md
├── source/
│ ├── editor/
│ │ ├── Editor.cpp
│ │ ├── Editor.h
│ │ ├── GeneralWindows.cpp
│ │ ├── GeneralWindows.h
│ │ ├── ImGui/
│ │ │ ├── ImGui_Extension.h
│ │ │ ├── ImGui_Style.h
│ │ │ ├── ImGui_TransformGizmo.h
│ │ │ ├── Implementation/
│ │ │ │ ├── ImGui_RHI.h
│ │ │ │ ├── imgui_impl_sdl3.cpp
│ │ │ │ └── imgui_impl_sdl3.h
│ │ │ ├── Source/
│ │ │ │ ├── ImGuizmo/
│ │ │ │ │ ├── GraphEditor.cpp
│ │ │ │ │ ├── GraphEditor.h
│ │ │ │ │ ├── ImCurveEdit.cpp
│ │ │ │ │ ├── ImCurveEdit.h
│ │ │ │ │ ├── ImGradient.cpp
│ │ │ │ │ ├── ImGradient.h
│ │ │ │ │ ├── ImGuizmo.cpp
│ │ │ │ │ ├── ImGuizmo.h
│ │ │ │ │ ├── ImSequencer.cpp
│ │ │ │ │ ├── ImSequencer.h
│ │ │ │ │ ├── ImZoomSlider.h
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ └── README.md
│ │ │ │ ├── LICENSE.txt
│ │ │ │ ├── imconfig.h
│ │ │ │ ├── imgui.cpp
│ │ │ │ ├── imgui.h
│ │ │ │ ├── imgui_demo.cpp
│ │ │ │ ├── imgui_draw.cpp
│ │ │ │ ├── imgui_freetype.cpp
│ │ │ │ ├── imgui_freetype.h
│ │ │ │ ├── imgui_internal.h
│ │ │ │ ├── imgui_stdlib.cpp
│ │ │ │ ├── imgui_stdlib.h
│ │ │ │ ├── imgui_tables.cpp
│ │ │ │ ├── imgui_widgets.cpp
│ │ │ │ ├── imstb_rectpack.h
│ │ │ │ ├── imstb_textedit.h
│ │ │ │ ├── imstb_truetype.h
│ │ │ │ └── stb_sprintf.h
│ │ │ ├── TextEditor.cpp
│ │ │ └── TextEditor.h
│ │ ├── Widgets/
│ │ │ ├── AssetBrowser.cpp
│ │ │ ├── AssetBrowser.h
│ │ │ ├── ButtonColorPicker.cpp
│ │ │ ├── ButtonColorPicker.h
│ │ │ ├── Console.cpp
│ │ │ ├── Console.h
│ │ │ ├── FileDialog.cpp
│ │ │ ├── FileDialog.h
│ │ │ ├── FileSelection.h
│ │ │ ├── MenuBar.cpp
│ │ │ ├── MenuBar.h
│ │ │ ├── Profiler.cpp
│ │ │ ├── Profiler.h
│ │ │ ├── ProgressDialog.cpp
│ │ │ ├── ProgressDialog.h
│ │ │ ├── Properties.cpp
│ │ │ ├── Properties.h
│ │ │ ├── RenderOptions.cpp
│ │ │ ├── RenderOptions.h
│ │ │ ├── ResourceViewer.cpp
│ │ │ ├── ResourceViewer.h
│ │ │ ├── ScriptEditor.cpp
│ │ │ ├── ScriptEditor.h
│ │ │ ├── Sequence/
│ │ │ │ ├── Sequence.cpp
│ │ │ │ ├── Sequence.h
│ │ │ │ ├── Sequencer.cpp
│ │ │ │ └── Sequencer.h
│ │ │ ├── ShaderEditor.cpp
│ │ │ ├── ShaderEditor.h
│ │ │ ├── Style.cpp
│ │ │ ├── Style.h
│ │ │ ├── TextureViewer.cpp
│ │ │ ├── TextureViewer.h
│ │ │ ├── Viewport.cpp
│ │ │ ├── Viewport.h
│ │ │ ├── Widget.cpp
│ │ │ ├── Widget.h
│ │ │ ├── WorldViewer.cpp
│ │ │ └── WorldViewer.h
│ │ ├── Windows/
│ │ │ ├── Contributors.cpp
│ │ │ ├── Contributors.h
│ │ │ ├── WorldSelector.cpp
│ │ │ └── WorldSelector.h
│ │ └── main.cpp
│ └── runtime/
│ ├── Car/
│ │ ├── Car.cpp
│ │ ├── Car.h
│ │ ├── CarEngineSoundSynthesis.h
│ │ ├── CarSimulation.h
│ │ └── CarTireSquealSynthesis.h
│ ├── Commands/
│ │ ├── CircularStack.h
│ │ ├── Command.h
│ │ ├── CommandEntityDelete.cpp
│ │ ├── CommandEntityDelete.h
│ │ ├── CommandStack.cpp
│ │ ├── CommandStack.h
│ │ ├── CommandTransform.cpp
│ │ ├── CommandTransform.h
│ │ ├── CommandTransformMulti.cpp
│ │ ├── CommandTransformMulti.h
│ │ └── Console/
│ │ ├── ConsoleCommands.cpp
│ │ └── ConsoleCommands.h
│ ├── Core/
│ │ ├── Breadcrumbs.cpp
│ │ ├── Breadcrumbs.h
│ │ ├── Debugging.h
│ │ ├── Definitions.cpp
│ │ ├── Definitions.h
│ │ ├── Engine.cpp
│ │ ├── Engine.h
│ │ ├── Event.cpp
│ │ ├── Event.h
│ │ ├── ProgressTracker.cpp
│ │ ├── ProgressTracker.h
│ │ ├── Settings.cpp
│ │ ├── Settings.h
│ │ ├── SpartanObject.h
│ │ ├── Stopwatch.h
│ │ ├── ThreadPool.cpp
│ │ ├── ThreadPool.h
│ │ ├── Timer.cpp
│ │ ├── Timer.h
│ │ ├── Window.cpp
│ │ ├── Window.h
│ │ ├── pch.cpp
│ │ ├── pch.h
│ │ └── resource.rc
│ ├── Display/
│ │ ├── Display.cpp
│ │ ├── Display.h
│ │ └── DisplayMode.h
│ ├── FileSystem/
│ │ ├── FileSystem.cpp
│ │ └── FileSystem.h
│ ├── Font/
│ │ ├── Font.cpp
│ │ ├── Font.h
│ │ └── Glyph.h
│ ├── Game/
│ │ ├── Game.cpp
│ │ └── Game.h
│ ├── Geometry/
│ │ ├── GeometryGeneration.h
│ │ ├── GeometryProcessing.h
│ │ ├── Mesh.cpp
│ │ └── Mesh.h
│ ├── IO/
│ │ ├── pugiconfig.hpp
│ │ └── pugixml.hpp
│ ├── Input/
│ │ ├── Input.cpp
│ │ ├── Input.h
│ │ ├── InputGamepad.cpp
│ │ ├── InputKeyboard.cpp
│ │ ├── InputMouse.cpp
│ │ └── InputSteeringWheel.cpp
│ ├── Logging/
│ │ ├── ILogger.h
│ │ ├── Log.cpp
│ │ └── Log.h
│ ├── Math/
│ │ ├── BoundingBox.cpp
│ │ ├── BoundingBox.h
│ │ ├── Frustum.cpp
│ │ ├── Frustum.h
│ │ ├── Helper.h
│ │ ├── Matrix.cpp
│ │ ├── Matrix.h
│ │ ├── Plane.cpp
│ │ ├── Plane.h
│ │ ├── Quaternion.cpp
│ │ ├── Quaternion.h
│ │ ├── Ray.cpp
│ │ ├── Ray.h
│ │ ├── RayHitResult.h
│ │ ├── Rectangle.cpp
│ │ ├── Rectangle.h
│ │ ├── Sphere.cpp
│ │ ├── Sphere.h
│ │ ├── Vector2.cpp
│ │ ├── Vector2.h
│ │ ├── Vector3.cpp
│ │ ├── Vector3.h
│ │ ├── Vector4.cpp
│ │ └── Vector4.h
│ ├── Memory/
│ │ ├── Allocator.cpp
│ │ ├── Allocator.h
│ │ ├── MemoryOverrides.cpp
│ │ └── MemoryOverrides.h
│ ├── Physics/
│ │ ├── PhysicsWorld.cpp
│ │ └── PhysicsWorld.h
│ ├── Profiling/
│ │ ├── Profiler.cpp
│ │ ├── Profiler.h
│ │ ├── RenderDoc.cpp
│ │ ├── RenderDoc.h
│ │ ├── TimeBlock.cpp
│ │ └── TimeBlock.h
│ ├── RHI/
│ │ ├── D3D12/
│ │ │ ├── D3D12_AccelerationStructure.cpp
│ │ │ ├── D3D12_BlendState.cpp
│ │ │ ├── D3D12_Buffer.cpp
│ │ │ ├── D3D12_CommandList.cpp
│ │ │ ├── D3D12_DepthStencilState.cpp
│ │ │ ├── D3D12_DescriptorSet.cpp
│ │ │ ├── D3D12_DescriptorSetLayout.cpp
│ │ │ ├── D3D12_Device.cpp
│ │ │ ├── D3D12_InputLayout.cpp
│ │ │ ├── D3D12_Pipeline.cpp
│ │ │ ├── D3D12_Queue.cpp
│ │ │ ├── D3D12_RasterizerState.cpp
│ │ │ ├── D3D12_Sampler.cpp
│ │ │ ├── D3D12_Shader.cpp
│ │ │ ├── D3D12_SwapChain.cpp
│ │ │ ├── D3D12_SyncPrimitive.cpp
│ │ │ ├── D3D12_Texture.cpp
│ │ │ ├── D3D12_Utility.h
│ │ │ └── D3D12_VendorTechnology.cpp
│ │ ├── RHI_AccelerationStructure.h
│ │ ├── RHI_BlendState.h
│ │ ├── RHI_Buffer.h
│ │ ├── RHI_CommandList.cpp
│ │ ├── RHI_CommandList.h
│ │ ├── RHI_Definitions.h
│ │ ├── RHI_DepthStencilState.h
│ │ ├── RHI_Descriptor.h
│ │ ├── RHI_DescriptorSet.cpp
│ │ ├── RHI_DescriptorSet.h
│ │ ├── RHI_DescriptorSetLayout.cpp
│ │ ├── RHI_DescriptorSetLayout.h
│ │ ├── RHI_Device.cpp
│ │ ├── RHI_Device.h
│ │ ├── RHI_DirectXShaderCompiler.h
│ │ ├── RHI_Implementation.cpp
│ │ ├── RHI_Implementation.h
│ │ ├── RHI_InputLayout.h
│ │ ├── RHI_PhysicalDevice.cpp
│ │ ├── RHI_PhysicalDevice.h
│ │ ├── RHI_Pipeline.h
│ │ ├── RHI_PipelineState.cpp
│ │ ├── RHI_PipelineState.h
│ │ ├── RHI_Queue.h
│ │ ├── RHI_RasterizerState.h
│ │ ├── RHI_Sampler.cpp
│ │ ├── RHI_Sampler.h
│ │ ├── RHI_Shader.cpp
│ │ ├── RHI_Shader.h
│ │ ├── RHI_SwapChain.h
│ │ ├── RHI_SyncPrimitive.h
│ │ ├── RHI_Texture.cpp
│ │ ├── RHI_Texture.h
│ │ ├── RHI_VendorTechnology.h
│ │ ├── RHI_Vertex.h
│ │ ├── RHI_Viewport.cpp
│ │ ├── RHI_Viewport.h
│ │ └── Vulkan/
│ │ ├── Vulkan_AccelerationStructure.cpp
│ │ ├── Vulkan_BlendState.cpp
│ │ ├── Vulkan_Buffer.cpp
│ │ ├── Vulkan_CommandList.cpp
│ │ ├── Vulkan_DepthStencilState.cpp
│ │ ├── Vulkan_DescriptorSet.cpp
│ │ ├── Vulkan_DescriptorSetLayout.cpp
│ │ ├── Vulkan_Device.cpp
│ │ ├── Vulkan_InputLayout.cpp
│ │ ├── Vulkan_Pipeline.cpp
│ │ ├── Vulkan_Queue.cpp
│ │ ├── Vulkan_RasterizerState.cpp
│ │ ├── Vulkan_Sampler.cpp
│ │ ├── Vulkan_Shader.cpp
│ │ ├── Vulkan_SwapChain.cpp
│ │ ├── Vulkan_SyncPrimitive.cpp
│ │ ├── Vulkan_Texture.cpp
│ │ └── Vulkan_VendorTechnology.cpp
│ ├── Rendering/
│ │ ├── Animation/
│ │ │ ├── AnimationClip.h
│ │ │ ├── SkeletalMeshBinding.h
│ │ │ └── Skeleton.h
│ │ ├── Animation.cpp
│ │ ├── Animation.h
│ │ ├── Color.cpp
│ │ ├── Color.h
│ │ ├── GeometryBuffer.cpp
│ │ ├── GeometryBuffer.h
│ │ ├── Instance.h
│ │ ├── Material.cpp
│ │ ├── Material.h
│ │ ├── Renderer.cpp
│ │ ├── Renderer.h
│ │ ├── Renderer_Buffers.h
│ │ ├── Renderer_ConsoleVariables.cpp
│ │ ├── Renderer_Definitions.h
│ │ ├── Renderer_Passes.cpp
│ │ ├── Renderer_Primitives.cpp
│ │ ├── Renderer_Resources.cpp
│ │ └── bend_sss_cpu.h
│ ├── Resource/
│ │ ├── Animation/
│ │ │ ├── AnimationAssetValidation.cpp
│ │ │ ├── AnimationAssetValidation.h
│ │ │ ├── AnimationClipIO.cpp
│ │ │ ├── AnimationClipIO.h
│ │ │ ├── AnimationFileFormat.h
│ │ │ ├── BinaryIO.h
│ │ │ ├── SkeletonIO.cpp
│ │ │ └── SkeletonIO.h
│ │ ├── IResource.cpp
│ │ ├── IResource.h
│ │ ├── Import/
│ │ │ ├── FontImporter.cpp
│ │ │ ├── FontImporter.h
│ │ │ ├── ImageImporter.cpp
│ │ │ ├── ImageImporter.h
│ │ │ ├── ModelImporter.cpp
│ │ │ ├── ModelImporter.h
│ │ │ └── tinyddsloader.h
│ │ ├── ResourceCache.cpp
│ │ └── ResourceCache.h
│ ├── Testing/
│ │ ├── SmokeTest.cpp
│ │ └── SmokeTest.h
│ ├── World/
│ │ ├── Components/
│ │ │ ├── AudioSource.cpp
│ │ │ ├── AudioSource.h
│ │ │ ├── Camera.cpp
│ │ │ ├── Camera.h
│ │ │ ├── Component.cpp
│ │ │ ├── Component.h
│ │ │ ├── Light.cpp
│ │ │ ├── Light.h
│ │ │ ├── ParticleSystem.cpp
│ │ │ ├── ParticleSystem.h
│ │ │ ├── Physics.cpp
│ │ │ ├── Physics.h
│ │ │ ├── Render.cpp
│ │ │ ├── Render.h
│ │ │ ├── Script.cpp
│ │ │ ├── Script.h
│ │ │ ├── Spline.cpp
│ │ │ ├── Spline.h
│ │ │ ├── SplineFollower.cpp
│ │ │ ├── SplineFollower.h
│ │ │ ├── Terrain.cpp
│ │ │ ├── Terrain.h
│ │ │ ├── Volume.cpp
│ │ │ └── Volume.h
│ │ ├── Entity.cpp
│ │ ├── Entity.h
│ │ ├── Prefab.cpp
│ │ ├── Prefab.h
│ │ ├── World.cpp
│ │ └── World.h
│ └── XR/
│ ├── Xr.cpp
│ └── Xr.h
├── third_party/
│ ├── assimp/
│ │ ├── assimp/
│ │ │ ├── .editorconfig
│ │ │ ├── AssertHandler.h
│ │ │ ├── Base64.hpp
│ │ │ ├── BaseImporter.h
│ │ │ ├── Bitmap.h
│ │ │ ├── BlobIOSystem.h
│ │ │ ├── ByteSwapper.h
│ │ │ ├── ColladaMetaData.h
│ │ │ ├── Compiler/
│ │ │ │ ├── poppack1.h
│ │ │ │ ├── pstdint.h
│ │ │ │ └── pushpack1.h
│ │ │ ├── CreateAnimMesh.h
│ │ │ ├── DefaultIOStream.h
│ │ │ ├── DefaultIOSystem.h
│ │ │ ├── DefaultLogger.hpp
│ │ │ ├── Exceptional.h
│ │ │ ├── Exporter.hpp
│ │ │ ├── GenericProperty.h
│ │ │ ├── GltfMaterial.h
│ │ │ ├── Hash.h
│ │ │ ├── IOStream.hpp
│ │ │ ├── IOStreamBuffer.h
│ │ │ ├── IOSystem.hpp
│ │ │ ├── Importer.hpp
│ │ │ ├── LineSplitter.h
│ │ │ ├── LogAux.h
│ │ │ ├── LogStream.hpp
│ │ │ ├── Logger.hpp
│ │ │ ├── MathFunctions.h
│ │ │ ├── MemoryIOWrapper.h
│ │ │ ├── NullLogger.hpp
│ │ │ ├── ObjMaterial.h
│ │ │ ├── ParsingUtils.h
│ │ │ ├── Profiler.h
│ │ │ ├── ProgressHandler.hpp
│ │ │ ├── RemoveComments.h
│ │ │ ├── SGSpatialSort.h
│ │ │ ├── SceneCombiner.h
│ │ │ ├── SkeletonMeshBuilder.h
│ │ │ ├── SmallVector.h
│ │ │ ├── SmoothingGroups.h
│ │ │ ├── SmoothingGroups.inl
│ │ │ ├── SpatialSort.h
│ │ │ ├── StandardShapes.h
│ │ │ ├── StreamReader.h
│ │ │ ├── StreamWriter.h
│ │ │ ├── StringComparison.h
│ │ │ ├── StringUtils.h
│ │ │ ├── Subdivision.h
│ │ │ ├── TinyFormatter.h
│ │ │ ├── Vertex.h
│ │ │ ├── XMLTools.h
│ │ │ ├── XmlParser.h
│ │ │ ├── ZipArchiveIOSystem.h
│ │ │ ├── aabb.h
│ │ │ ├── ai_assert.h
│ │ │ ├── anim.h
│ │ │ ├── camera.h
│ │ │ ├── cexport.h
│ │ │ ├── cfileio.h
│ │ │ ├── cimport.h
│ │ │ ├── color4.h
│ │ │ ├── color4.inl
│ │ │ ├── commonMetaData.h
│ │ │ ├── config.h
│ │ │ ├── config.h.in
│ │ │ ├── defs.h
│ │ │ ├── fast_atof.h
│ │ │ ├── importerdesc.h
│ │ │ ├── light.h
│ │ │ ├── material.h
│ │ │ ├── material.inl
│ │ │ ├── matrix3x3.h
│ │ │ ├── matrix3x3.inl
│ │ │ ├── matrix4x4.h
│ │ │ ├── matrix4x4.inl
│ │ │ ├── mesh.h
│ │ │ ├── metadata.h
│ │ │ ├── module.modulemap
│ │ │ ├── pbrmaterial.h
│ │ │ ├── port/
│ │ │ │ └── AndroidJNI/
│ │ │ │ ├── AndroidJNIIOSystem.h
│ │ │ │ └── BundledAssetIOSystem.h
│ │ │ ├── postprocess.h
│ │ │ ├── qnan.h
│ │ │ ├── quaternion.h
│ │ │ ├── quaternion.inl
│ │ │ ├── revision.h
│ │ │ ├── revision.h.in
│ │ │ ├── scene.h
│ │ │ ├── texture.h
│ │ │ ├── types.h
│ │ │ ├── vector2.h
│ │ │ ├── vector2.inl
│ │ │ ├── vector3.h
│ │ │ ├── vector3.inl
│ │ │ └── version.h
│ │ └── version.txt
│ ├── compressonator/
│ │ ├── compressonator.h
│ │ └── version.txt
│ ├── dxc/
│ │ ├── dxc/
│ │ │ ├── d3d12shader.h
│ │ │ ├── dxcapi.h
│ │ │ ├── dxcerrors.h
│ │ │ └── dxcisense.h
│ │ └── version.txt
│ ├── fidelityfx/
│ │ ├── FidelityFX/
│ │ │ ├── gpu/
│ │ │ │ ├── CMakeCompileShaders.txt
│ │ │ │ ├── blur/
│ │ │ │ │ ├── CMakeCompileBlurShaders.txt
│ │ │ │ │ ├── ffx_blur.h
│ │ │ │ │ ├── ffx_blur_blur.h
│ │ │ │ │ ├── ffx_blur_callbacks_glsl.h
│ │ │ │ │ ├── ffx_blur_callbacks_hlsl.h
│ │ │ │ │ └── ffx_blur_resources.h
│ │ │ │ ├── brixelizer/
│ │ │ │ │ ├── CMakeCompileBrixelizerShaders.txt
│ │ │ │ │ ├── ffx_brixelizer_brick_common.h
│ │ │ │ │ ├── ffx_brixelizer_brick_common_private.h
│ │ │ │ │ ├── ffx_brixelizer_build_common.h
│ │ │ │ │ ├── ffx_brixelizer_callbacks_glsl.h
│ │ │ │ │ ├── ffx_brixelizer_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_brixelizer_cascade_ops.h
│ │ │ │ │ ├── ffx_brixelizer_common.h
│ │ │ │ │ ├── ffx_brixelizer_common_private.h
│ │ │ │ │ ├── ffx_brixelizer_context_ops.h
│ │ │ │ │ ├── ffx_brixelizer_debug_aabbs.h
│ │ │ │ │ ├── ffx_brixelizer_debug_visualization.h
│ │ │ │ │ ├── ffx_brixelizer_host_gpu_shared.h
│ │ │ │ │ ├── ffx_brixelizer_host_gpu_shared_private.h
│ │ │ │ │ ├── ffx_brixelizer_mesh_common.h
│ │ │ │ │ ├── ffx_brixelizer_resources.h
│ │ │ │ │ └── ffx_brixelizer_trace_ops.h
│ │ │ │ ├── brixelizergi/
│ │ │ │ │ ├── CMakeCompileBrixelizerGIShaders.txt
│ │ │ │ │ ├── ffx_brixelizergi_callbacks_glsl.h
│ │ │ │ │ ├── ffx_brixelizergi_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_brixelizergi_common.h
│ │ │ │ │ ├── ffx_brixelizergi_host_interface.h
│ │ │ │ │ ├── ffx_brixelizergi_main.h
│ │ │ │ │ ├── ffx_brixelizergi_probe_shading.h
│ │ │ │ │ ├── ffx_brixelizergi_radiance_cache_update.h
│ │ │ │ │ └── ffx_brixelizergi_resources.h
│ │ │ │ ├── cacao/
│ │ │ │ │ ├── CMakeCompileCACAOShaders.txt
│ │ │ │ │ ├── ffx_cacao_apply.h
│ │ │ │ │ ├── ffx_cacao_callbacks_glsl.h
│ │ │ │ │ ├── ffx_cacao_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_cacao_defines.h
│ │ │ │ │ ├── ffx_cacao_edge_sensitive_blur.h
│ │ │ │ │ ├── ffx_cacao_importance_map.h
│ │ │ │ │ ├── ffx_cacao_prepare.h
│ │ │ │ │ ├── ffx_cacao_resources.h
│ │ │ │ │ ├── ffx_cacao_ssao_generation.h
│ │ │ │ │ ├── ffx_cacao_upscale.h
│ │ │ │ │ └── ffx_cacao_utils.h
│ │ │ │ ├── cas/
│ │ │ │ │ ├── CMakeCompileCASShaders.txt
│ │ │ │ │ ├── ffx_cas.h
│ │ │ │ │ ├── ffx_cas_callbacks_glsl.h
│ │ │ │ │ ├── ffx_cas_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_cas_resources.h
│ │ │ │ │ └── ffx_cas_sharpen.h
│ │ │ │ ├── classifier/
│ │ │ │ │ ├── CMakeCompileClassifierShaders.txt
│ │ │ │ │ ├── ffx_classifier_common.h
│ │ │ │ │ ├── ffx_classifier_reflections.h
│ │ │ │ │ ├── ffx_classifier_reflections_callbacks_glsl.h
│ │ │ │ │ ├── ffx_classifier_reflections_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_classifier_reflections_common.h
│ │ │ │ │ ├── ffx_classifier_resources.h
│ │ │ │ │ ├── ffx_classifier_shadows.h
│ │ │ │ │ ├── ffx_classifier_shadows_callbacks_glsl.h
│ │ │ │ │ └── ffx_classifier_shadows_callbacks_hlsl.h
│ │ │ │ ├── denoiser/
│ │ │ │ │ ├── CMakeCompileDenoiserShaders.txt
│ │ │ │ │ ├── ffx_denoiser_reflections_callbacks_glsl.h
│ │ │ │ │ ├── ffx_denoiser_reflections_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_denoiser_reflections_common.h
│ │ │ │ │ ├── ffx_denoiser_reflections_config.h
│ │ │ │ │ ├── ffx_denoiser_reflections_prefilter.h
│ │ │ │ │ ├── ffx_denoiser_reflections_reproject.h
│ │ │ │ │ ├── ffx_denoiser_reflections_resolve_temporal.h
│ │ │ │ │ ├── ffx_denoiser_resources.h
│ │ │ │ │ ├── ffx_denoiser_shadows_callbacks_glsl.h
│ │ │ │ │ ├── ffx_denoiser_shadows_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_denoiser_shadows_filter.h
│ │ │ │ │ ├── ffx_denoiser_shadows_prepare.h
│ │ │ │ │ ├── ffx_denoiser_shadows_tileclassification.h
│ │ │ │ │ └── ffx_denoiser_shadows_util.h
│ │ │ │ ├── dof/
│ │ │ │ │ ├── CMakeCompileDOFShaders.txt
│ │ │ │ │ ├── ffx_dof_blur.h
│ │ │ │ │ ├── ffx_dof_callbacks_glsl.h
│ │ │ │ │ ├── ffx_dof_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_dof_common.h
│ │ │ │ │ ├── ffx_dof_composite.h
│ │ │ │ │ ├── ffx_dof_dilate_depth.h
│ │ │ │ │ ├── ffx_dof_downsample_color.h
│ │ │ │ │ ├── ffx_dof_downsample_depth.h
│ │ │ │ │ └── ffx_dof_resources.h
│ │ │ │ ├── ffx_common_types.h
│ │ │ │ ├── ffx_core.h
│ │ │ │ ├── ffx_core_cpu.h
│ │ │ │ ├── ffx_core_glsl.h
│ │ │ │ ├── ffx_core_gpu_common.h
│ │ │ │ ├── ffx_core_gpu_common_half.h
│ │ │ │ ├── ffx_core_hlsl.h
│ │ │ │ ├── ffx_core_portability.h
│ │ │ │ ├── frameinterpolation/
│ │ │ │ │ ├── CMakeCompileFrameinterpolationShaders.txt
│ │ │ │ │ ├── ffx_frameinterpolation.h
│ │ │ │ │ ├── ffx_frameinterpolation_callbacks_glsl.h
│ │ │ │ │ ├── ffx_frameinterpolation_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_frameinterpolation_common.h
│ │ │ │ │ ├── ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h
│ │ │ │ │ ├── ffx_frameinterpolation_compute_inpainting_pyramid.h
│ │ │ │ │ ├── ffx_frameinterpolation_debug_view.h
│ │ │ │ │ ├── ffx_frameinterpolation_disocclusion_mask.h
│ │ │ │ │ ├── ffx_frameinterpolation_game_motion_vector_field.h
│ │ │ │ │ ├── ffx_frameinterpolation_inpainting.h
│ │ │ │ │ ├── ffx_frameinterpolation_optical_flow_vector_field.h
│ │ │ │ │ ├── ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h
│ │ │ │ │ ├── ffx_frameinterpolation_reconstruct_previous_depth.h
│ │ │ │ │ ├── ffx_frameinterpolation_resources.h
│ │ │ │ │ └── ffx_frameinterpolation_setup.h
│ │ │ │ ├── fsr1/
│ │ │ │ │ ├── CMakeCompileFSR1Shaders.txt
│ │ │ │ │ ├── ffx_fsr1.h
│ │ │ │ │ ├── ffx_fsr1_callbacks_glsl.h
│ │ │ │ │ ├── ffx_fsr1_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_fsr1_easu.h
│ │ │ │ │ ├── ffx_fsr1_rcas.h
│ │ │ │ │ └── ffx_fsr1_resources.h
│ │ │ │ ├── fsr2/
│ │ │ │ │ ├── CMakeCompileFSR2Shaders.txt
│ │ │ │ │ ├── ffx_fsr2_accumulate.h
│ │ │ │ │ ├── ffx_fsr2_callbacks_glsl.h
│ │ │ │ │ ├── ffx_fsr2_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_fsr2_common.h
│ │ │ │ │ ├── ffx_fsr2_compute_luminance_pyramid.h
│ │ │ │ │ ├── ffx_fsr2_depth_clip.h
│ │ │ │ │ ├── ffx_fsr2_lock.h
│ │ │ │ │ ├── ffx_fsr2_postprocess_lock_status.h
│ │ │ │ │ ├── ffx_fsr2_rcas.h
│ │ │ │ │ ├── ffx_fsr2_reconstruct_dilated_velocity_and_previous_depth.h
│ │ │ │ │ ├── ffx_fsr2_reproject.h
│ │ │ │ │ ├── ffx_fsr2_resources.h
│ │ │ │ │ ├── ffx_fsr2_sample.h
│ │ │ │ │ ├── ffx_fsr2_tcr_autogen.h
│ │ │ │ │ └── ffx_fsr2_upsample.h
│ │ │ │ ├── fsr3/
│ │ │ │ │ ├── ffx_fsr3_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_fsr3_common.h
│ │ │ │ │ └── ffx_fsr3_resources.h
│ │ │ │ ├── fsr3upscaler/
│ │ │ │ │ ├── CMakeCompileFSR3UpscalerShaders.txt
│ │ │ │ │ ├── ffx_fsr3upscaler_accumulate.h
│ │ │ │ │ ├── ffx_fsr3upscaler_callbacks_glsl.h
│ │ │ │ │ ├── ffx_fsr3upscaler_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_fsr3upscaler_common.h
│ │ │ │ │ ├── ffx_fsr3upscaler_debug_view.h
│ │ │ │ │ ├── ffx_fsr3upscaler_luma_instability.h
│ │ │ │ │ ├── ffx_fsr3upscaler_luma_pyramid.h
│ │ │ │ │ ├── ffx_fsr3upscaler_prepare_inputs.h
│ │ │ │ │ ├── ffx_fsr3upscaler_prepare_reactivity.h
│ │ │ │ │ ├── ffx_fsr3upscaler_rcas.h
│ │ │ │ │ ├── ffx_fsr3upscaler_reproject.h
│ │ │ │ │ ├── ffx_fsr3upscaler_resources.h
│ │ │ │ │ ├── ffx_fsr3upscaler_sample.h
│ │ │ │ │ ├── ffx_fsr3upscaler_shading_change.h
│ │ │ │ │ ├── ffx_fsr3upscaler_shading_change_pyramid.h
│ │ │ │ │ └── ffx_fsr3upscaler_upsample.h
│ │ │ │ ├── lens/
│ │ │ │ │ ├── CMakeCompileLENSShaders.txt
│ │ │ │ │ ├── ffx_lens.h
│ │ │ │ │ ├── ffx_lens_callbacks_glsl.h
│ │ │ │ │ ├── ffx_lens_callbacks_hlsl.h
│ │ │ │ │ └── ffx_lens_resources.h
│ │ │ │ ├── lpm/
│ │ │ │ │ ├── CMakeCompileLPMShaders.txt
│ │ │ │ │ ├── ffx_lpm.h
│ │ │ │ │ ├── ffx_lpm_callbacks_glsl.h
│ │ │ │ │ ├── ffx_lpm_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_lpm_filter.h
│ │ │ │ │ └── ffx_lpm_resources.h
│ │ │ │ ├── opticalflow/
│ │ │ │ │ ├── CMakeCompileOpticalflowShaders.txt
│ │ │ │ │ ├── ffx_opticalflow_callbacks_glsl.h
│ │ │ │ │ ├── ffx_opticalflow_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_opticalflow_common.h
│ │ │ │ │ ├── ffx_opticalflow_compute_luminance_pyramid.h
│ │ │ │ │ ├── ffx_opticalflow_compute_optical_flow_v5.h
│ │ │ │ │ ├── ffx_opticalflow_compute_scd_divergence.h
│ │ │ │ │ ├── ffx_opticalflow_filter_optical_flow_v5.h
│ │ │ │ │ ├── ffx_opticalflow_generate_scd_histogram.h
│ │ │ │ │ ├── ffx_opticalflow_prepare_luma.h
│ │ │ │ │ ├── ffx_opticalflow_resources.h
│ │ │ │ │ └── ffx_opticalflow_scale_optical_flow_advanced_v5.h
│ │ │ │ ├── parallelsort/
│ │ │ │ │ ├── CMakeCompileParallelSortShaders.txt
│ │ │ │ │ ├── ffx_parallelsort.h
│ │ │ │ │ ├── ffx_parallelsort_callbacks_glsl.h
│ │ │ │ │ ├── ffx_parallelsort_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_parallelsort_common.h
│ │ │ │ │ ├── ffx_parallelsort_reduce.h
│ │ │ │ │ ├── ffx_parallelsort_resources.h
│ │ │ │ │ ├── ffx_parallelsort_scan.h
│ │ │ │ │ ├── ffx_parallelsort_scan_add.h
│ │ │ │ │ ├── ffx_parallelsort_scatter.h
│ │ │ │ │ ├── ffx_parallelsort_setup_indirect_args.h
│ │ │ │ │ └── ffx_parallelsort_sum.h
│ │ │ │ ├── spd/
│ │ │ │ │ ├── CMakeCompileSPDShaders.txt
│ │ │ │ │ ├── ffx_spd.h
│ │ │ │ │ ├── ffx_spd_callbacks_glsl.h
│ │ │ │ │ ├── ffx_spd_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_spd_downsample.h
│ │ │ │ │ └── ffx_spd_resources.h
│ │ │ │ ├── sssr/
│ │ │ │ │ ├── CMakeCompileSSSRShaders.txt
│ │ │ │ │ ├── ffx_sssr_callbacks_glsl.h
│ │ │ │ │ ├── ffx_sssr_callbacks_hlsl.h
│ │ │ │ │ ├── ffx_sssr_classify_tiles.h
│ │ │ │ │ ├── ffx_sssr_common.h
│ │ │ │ │ ├── ffx_sssr_depth_downsample.h
│ │ │ │ │ ├── ffx_sssr_intersect.h
│ │ │ │ │ ├── ffx_sssr_prepare_blue_noise_texture.h
│ │ │ │ │ ├── ffx_sssr_prepare_indirect_args.h
│ │ │ │ │ └── ffx_sssr_resources.h
│ │ │ │ └── vrs/
│ │ │ │ ├── CMakeCompileVRSShaders.txt
│ │ │ │ ├── ffx_variable_shading.h
│ │ │ │ ├── ffx_vrs_callbacks_glsl.h
│ │ │ │ ├── ffx_vrs_callbacks_hlsl.h
│ │ │ │ └── ffx_vrs_resources.h
│ │ │ └── host/
│ │ │ ├── backends/
│ │ │ │ ├── dx12/
│ │ │ │ │ ├── d3dx12.h
│ │ │ │ │ ├── ffx_dx12.h
│ │ │ │ │ └── license.txt
│ │ │ │ └── vk/
│ │ │ │ └── ffx_vk.h
│ │ │ ├── ffx_assert.h
│ │ │ ├── ffx_blur.h
│ │ │ ├── ffx_breadcrumbs.h
│ │ │ ├── ffx_brixelizer.h
│ │ │ ├── ffx_brixelizer_raw.h
│ │ │ ├── ffx_brixelizergi.h
│ │ │ ├── ffx_cacao.h
│ │ │ ├── ffx_cas.h
│ │ │ ├── ffx_classifier.h
│ │ │ ├── ffx_denoiser.h
│ │ │ ├── ffx_dof.h
│ │ │ ├── ffx_error.h
│ │ │ ├── ffx_frameinterpolation.h
│ │ │ ├── ffx_fsr1.h
│ │ │ ├── ffx_fsr2.h
│ │ │ ├── ffx_fsr3.h
│ │ │ ├── ffx_fsr3upscaler.h
│ │ │ ├── ffx_fx.h
│ │ │ ├── ffx_interface.h
│ │ │ ├── ffx_lens.h
│ │ │ ├── ffx_lpm.h
│ │ │ ├── ffx_message.h
│ │ │ ├── ffx_opticalflow.h
│ │ │ ├── ffx_parallelsort.h
│ │ │ ├── ffx_spd.h
│ │ │ ├── ffx_sssr.h
│ │ │ ├── ffx_types.h
│ │ │ ├── ffx_util.h
│ │ │ └── ffx_vrs.h
│ │ └── version.txt
│ ├── free_image/
│ │ ├── FreeImage/
│ │ │ ├── CacheFile.h
│ │ │ ├── FreeImage/
│ │ │ │ ├── BitmapAccess.cpp
│ │ │ │ ├── CacheFile.cpp
│ │ │ │ ├── ColorLookup.cpp
│ │ │ │ ├── Conversion.cpp
│ │ │ │ ├── Conversion16_555.cpp
│ │ │ │ ├── Conversion16_565.cpp
│ │ │ │ ├── Conversion24.cpp
│ │ │ │ ├── Conversion32.cpp
│ │ │ │ ├── Conversion4.cpp
│ │ │ │ ├── Conversion8.cpp
│ │ │ │ ├── ConversionFloat.cpp
│ │ │ │ ├── ConversionRGB16.cpp
│ │ │ │ ├── ConversionRGBA16.cpp
│ │ │ │ ├── ConversionRGBAF.cpp
│ │ │ │ ├── ConversionRGBF.cpp
│ │ │ │ ├── ConversionType.cpp
│ │ │ │ ├── ConversionUINT16.cpp
│ │ │ │ ├── FreeImage.cpp
│ │ │ │ ├── FreeImageC.c
│ │ │ │ ├── FreeImageIO.cpp
│ │ │ │ ├── GetType.cpp
│ │ │ │ ├── Halftoning.cpp
│ │ │ │ ├── J2KHelper.cpp
│ │ │ │ ├── J2KHelper.h
│ │ │ │ ├── LFPQuantizer.cpp
│ │ │ │ ├── MNGHelper.cpp
│ │ │ │ ├── MemoryIO.cpp
│ │ │ │ ├── MultiPage.cpp
│ │ │ │ ├── NNQuantizer.cpp
│ │ │ │ ├── PSDParser.cpp
│ │ │ │ ├── PSDParser.h
│ │ │ │ ├── PixelAccess.cpp
│ │ │ │ ├── Plugin.cpp
│ │ │ │ ├── PluginBMP.cpp
│ │ │ │ ├── PluginCUT.cpp
│ │ │ │ ├── PluginDDS.cpp
│ │ │ │ ├── PluginEXR.cpp
│ │ │ │ ├── PluginG3.cpp
│ │ │ │ ├── PluginGIF.cpp
│ │ │ │ ├── PluginHDR.cpp
│ │ │ │ ├── PluginICO.cpp
│ │ │ │ ├── PluginIFF.cpp
│ │ │ │ ├── PluginJ2K.cpp
│ │ │ │ ├── PluginJNG.cpp
│ │ │ │ ├── PluginJP2.cpp
│ │ │ │ ├── PluginJPEG.cpp
│ │ │ │ ├── PluginJXR.cpp
│ │ │ │ ├── PluginKOALA.cpp
│ │ │ │ ├── PluginMNG.cpp
│ │ │ │ ├── PluginPCD.cpp
│ │ │ │ ├── PluginPCX.cpp
│ │ │ │ ├── PluginPFM.cpp
│ │ │ │ ├── PluginPICT.cpp
│ │ │ │ ├── PluginPNG.cpp
│ │ │ │ ├── PluginPNM.cpp
│ │ │ │ ├── PluginPSD.cpp
│ │ │ │ ├── PluginRAS.cpp
│ │ │ │ ├── PluginRAW.cpp
│ │ │ │ ├── PluginSGI.cpp
│ │ │ │ ├── PluginTARGA.cpp
│ │ │ │ ├── PluginTIFF.cpp
│ │ │ │ ├── PluginWBMP.cpp
│ │ │ │ ├── PluginWebP.cpp
│ │ │ │ ├── PluginXBM.cpp
│ │ │ │ ├── PluginXPM.cpp
│ │ │ │ ├── TIFFLogLuv.cpp
│ │ │ │ ├── ToneMapping.cpp
│ │ │ │ ├── WuQuantizer.cpp
│ │ │ │ ├── ZLibInterface.cpp
│ │ │ │ ├── tmoColorConvert.cpp
│ │ │ │ ├── tmoDrago03.cpp
│ │ │ │ ├── tmoFattal02.cpp
│ │ │ │ └── tmoReinhard05.cpp
│ │ │ ├── FreeImage.h
│ │ │ ├── FreeImageIO.h
│ │ │ ├── MapIntrospector.h
│ │ │ ├── Plugin.h
│ │ │ ├── Quantizers.h
│ │ │ ├── ToneMapping.h
│ │ │ └── Utilities.h
│ │ └── version.txt
│ ├── free_type/
│ │ ├── freetype/
│ │ │ ├── config/
│ │ │ │ ├── ftconfig.h
│ │ │ │ ├── ftheader.h
│ │ │ │ ├── ftmodule.h
│ │ │ │ ├── ftoption.h
│ │ │ │ ├── ftstdlib.h
│ │ │ │ ├── integer-types.h
│ │ │ │ ├── mac-support.h
│ │ │ │ └── public-macros.h
│ │ │ ├── freetype.h
│ │ │ ├── ftadvanc.h
│ │ │ ├── ftbbox.h
│ │ │ ├── ftbdf.h
│ │ │ ├── ftbitmap.h
│ │ │ ├── ftbzip2.h
│ │ │ ├── ftcache.h
│ │ │ ├── ftchapters.h
│ │ │ ├── ftcid.h
│ │ │ ├── ftcolor.h
│ │ │ ├── ftdriver.h
│ │ │ ├── fterrdef.h
│ │ │ ├── fterrors.h
│ │ │ ├── ftfntfmt.h
│ │ │ ├── ftgasp.h
│ │ │ ├── ftglyph.h
│ │ │ ├── ftgxval.h
│ │ │ ├── ftgzip.h
│ │ │ ├── ftimage.h
│ │ │ ├── ftincrem.h
│ │ │ ├── ftlcdfil.h
│ │ │ ├── ftlist.h
│ │ │ ├── ftlogging.h
│ │ │ ├── ftlzw.h
│ │ │ ├── ftmac.h
│ │ │ ├── ftmm.h
│ │ │ ├── ftmodapi.h
│ │ │ ├── ftmoderr.h
│ │ │ ├── ftotval.h
│ │ │ ├── ftoutln.h
│ │ │ ├── ftparams.h
│ │ │ ├── ftpfr.h
│ │ │ ├── ftrender.h
│ │ │ ├── ftsizes.h
│ │ │ ├── ftsnames.h
│ │ │ ├── ftstroke.h
│ │ │ ├── ftsynth.h
│ │ │ ├── ftsystem.h
│ │ │ ├── fttrigon.h
│ │ │ ├── fttypes.h
│ │ │ ├── ftwinfnt.h
│ │ │ ├── internal/
│ │ │ │ ├── autohint.h
│ │ │ │ ├── cffotypes.h
│ │ │ │ ├── cfftypes.h
│ │ │ │ ├── compiler-macros.h
│ │ │ │ ├── ftcalc.h
│ │ │ │ ├── ftdebug.h
│ │ │ │ ├── ftdrv.h
│ │ │ │ ├── ftgloadr.h
│ │ │ │ ├── fthash.h
│ │ │ │ ├── ftmemory.h
│ │ │ │ ├── ftmmtypes.h
│ │ │ │ ├── ftobjs.h
│ │ │ │ ├── ftpsprop.h
│ │ │ │ ├── ftrfork.h
│ │ │ │ ├── ftserv.h
│ │ │ │ ├── ftstream.h
│ │ │ │ ├── fttrace.h
│ │ │ │ ├── ftvalid.h
│ │ │ │ ├── psaux.h
│ │ │ │ ├── pshints.h
│ │ │ │ ├── services/
│ │ │ │ │ ├── svbdf.h
│ │ │ │ │ ├── svcfftl.h
│ │ │ │ │ ├── svcid.h
│ │ │ │ │ ├── svfntfmt.h
│ │ │ │ │ ├── svgldict.h
│ │ │ │ │ ├── svgxval.h
│ │ │ │ │ ├── svkern.h
│ │ │ │ │ ├── svmetric.h
│ │ │ │ │ ├── svmm.h
│ │ │ │ │ ├── svotval.h
│ │ │ │ │ ├── svpfr.h
│ │ │ │ │ ├── svpostnm.h
│ │ │ │ │ ├── svprop.h
│ │ │ │ │ ├── svpscmap.h
│ │ │ │ │ ├── svpsinfo.h
│ │ │ │ │ ├── svsfnt.h
│ │ │ │ │ ├── svttcmap.h
│ │ │ │ │ ├── svtteng.h
│ │ │ │ │ ├── svttglyf.h
│ │ │ │ │ └── svwinfnt.h
│ │ │ │ ├── sfnt.h
│ │ │ │ ├── svginterface.h
│ │ │ │ ├── t1types.h
│ │ │ │ ├── tttypes.h
│ │ │ │ └── wofftypes.h
│ │ │ ├── otsvg.h
│ │ │ ├── t1tables.h
│ │ │ ├── ttnameid.h
│ │ │ ├── tttables.h
│ │ │ └── tttags.h
│ │ ├── ft2build.h
│ │ └── version.txt
│ ├── lua/
│ │ ├── lua/
│ │ │ ├── lauxlib.h
│ │ │ ├── lua.h
│ │ │ ├── luaconf.h
│ │ │ └── lualib.h
│ │ ├── sol/
│ │ │ ├── config.hpp
│ │ │ ├── forward.hpp
│ │ │ └── sol.hpp
│ │ └── version.txt
│ ├── meshoptimizer/
│ │ ├── meshoptimizer/
│ │ │ ├── allocator.cpp
│ │ │ ├── clusterizer.cpp
│ │ │ ├── indexanalyzer.cpp
│ │ │ ├── indexcodec.cpp
│ │ │ ├── indexgenerator.cpp
│ │ │ ├── meshoptimizer.h
│ │ │ ├── overdrawoptimizer.cpp
│ │ │ ├── partition.cpp
│ │ │ ├── quantization.cpp
│ │ │ ├── rasterizer.cpp
│ │ │ ├── simplifier.cpp
│ │ │ ├── spatialorder.cpp
│ │ │ ├── stripifier.cpp
│ │ │ ├── vcacheoptimizer.cpp
│ │ │ ├── vertexcodec.cpp
│ │ │ ├── vertexfilter.cpp
│ │ │ └── vfetchoptimizer.cpp
│ │ └── version.md
│ ├── nrd/
│ │ ├── nrd/
│ │ │ ├── NRD.h
│ │ │ ├── NRDDescs.h
│ │ │ └── NRDSettings.h
│ │ └── version.txt
│ ├── openxr/
│ │ ├── openxr/
│ │ │ ├── openxr.h
│ │ │ ├── openxr_loader_negotiation.h
│ │ │ ├── openxr_platform.h
│ │ │ ├── openxr_platform_defines.h
│ │ │ ├── openxr_reflection.h
│ │ │ ├── openxr_reflection_parent_structs.h
│ │ │ └── openxr_reflection_structs.h
│ │ └── version.txt
│ ├── physx/
│ │ ├── physx/
│ │ │ ├── PxActor.h
│ │ │ ├── PxAggregate.h
│ │ │ ├── PxAnisotropy.h
│ │ │ ├── PxArrayConverter.h
│ │ │ ├── PxArticulationFlag.h
│ │ │ ├── PxArticulationJointReducedCoordinate.h
│ │ │ ├── PxArticulationLink.h
│ │ │ ├── PxArticulationMimicJoint.h
│ │ │ ├── PxArticulationReducedCoordinate.h
│ │ │ ├── PxArticulationTendon.h
│ │ │ ├── PxArticulationTendonData.h
│ │ │ ├── PxBaseMaterial.h
│ │ │ ├── PxBroadPhase.h
│ │ │ ├── PxClient.h
│ │ │ ├── PxConeLimitedConstraint.h
│ │ │ ├── PxConfig.h
│ │ │ ├── PxConstraint.h
│ │ │ ├── PxConstraintDesc.h
│ │ │ ├── PxContact.h
│ │ │ ├── PxContactModifyCallback.h
│ │ │ ├── PxDeformableAttachment.h
│ │ │ ├── PxDeformableBody.h
│ │ │ ├── PxDeformableBodyFlag.h
│ │ │ ├── PxDeformableElementFilter.h
│ │ │ ├── PxDeformableMaterial.h
│ │ │ ├── PxDeformableSkinning.h
│ │ │ ├── PxDeformableSurface.h
│ │ │ ├── PxDeformableSurfaceFlag.h
│ │ │ ├── PxDeformableSurfaceMaterial.h
│ │ │ ├── PxDeformableVolume.h
│ │ │ ├── PxDeformableVolumeFlag.h
│ │ │ ├── PxDeformableVolumeMaterial.h
│ │ │ ├── PxDeletionListener.h
│ │ │ ├── PxDirectGPUAPI.h
│ │ │ ├── PxFEMMaterial.h
│ │ │ ├── PxFEMParameter.h
│ │ │ ├── PxFEMSoftBodyMaterial.h
│ │ │ ├── PxFiltering.h
│ │ │ ├── PxForceMode.h
│ │ │ ├── PxImmediateMode.h
│ │ │ ├── PxIsosurfaceExtraction.h
│ │ │ ├── PxLockedData.h
│ │ │ ├── PxMaterial.h
│ │ │ ├── PxNodeIndex.h
│ │ │ ├── PxPBDMaterial.h
│ │ │ ├── PxPBDParticleSystem.h
│ │ │ ├── PxParticleBuffer.h
│ │ │ ├── PxParticleGpu.h
│ │ │ ├── PxParticleMaterial.h
│ │ │ ├── PxParticleNeighborhoodProvider.h
│ │ │ ├── PxParticleSolverType.h
│ │ │ ├── PxParticleSystem.h
│ │ │ ├── PxParticleSystemFlag.h
│ │ │ ├── PxPhysXConfig.h
│ │ │ ├── PxPhysics.h
│ │ │ ├── PxPhysicsAPI.h
│ │ │ ├── PxPhysicsSerialization.h
│ │ │ ├── PxPruningStructure.h
│ │ │ ├── PxQueryFiltering.h
│ │ │ ├── PxQueryReport.h
│ │ │ ├── PxResidual.h
│ │ │ ├── PxRigidActor.h
│ │ │ ├── PxRigidBody.h
│ │ │ ├── PxRigidDynamic.h
│ │ │ ├── PxRigidStatic.h
│ │ │ ├── PxSDFBuilder.h
│ │ │ ├── PxScene.h
│ │ │ ├── PxSceneDesc.h
│ │ │ ├── PxSceneLock.h
│ │ │ ├── PxSceneQueryDesc.h
│ │ │ ├── PxSceneQuerySystem.h
│ │ │ ├── PxShape.h
│ │ │ ├── PxSimulationEventCallback.h
│ │ │ ├── PxSimulationStatistics.h
│ │ │ ├── PxSmoothing.h
│ │ │ ├── PxSoftBody.h
│ │ │ ├── PxSoftBodyFlag.h
│ │ │ ├── PxSparseGridParams.h
│ │ │ ├── PxVisualizationParameter.h
│ │ │ ├── characterkinematic/
│ │ │ │ ├── PxBoxController.h
│ │ │ │ ├── PxCapsuleController.h
│ │ │ │ ├── PxController.h
│ │ │ │ ├── PxControllerBehavior.h
│ │ │ │ ├── PxControllerManager.h
│ │ │ │ ├── PxControllerObstacles.h
│ │ │ │ └── PxExtended.h
│ │ │ ├── collision/
│ │ │ │ └── PxCollisionDefs.h
│ │ │ ├── common/
│ │ │ │ ├── PxBase.h
│ │ │ │ ├── PxCollection.h
│ │ │ │ ├── PxCoreUtilityTypes.h
│ │ │ │ ├── PxInsertionCallback.h
│ │ │ │ ├── PxPhysXCommonConfig.h
│ │ │ │ ├── PxProfileZone.h
│ │ │ │ ├── PxRenderBuffer.h
│ │ │ │ ├── PxRenderOutput.h
│ │ │ │ ├── PxSerialFramework.h
│ │ │ │ ├── PxSerializer.h
│ │ │ │ ├── PxStringTable.h
│ │ │ │ ├── PxTolerancesScale.h
│ │ │ │ ├── PxTypeInfo.h
│ │ │ │ └── windows/
│ │ │ │ └── PxWindowsDelayLoadHook.h
│ │ │ ├── cooking/
│ │ │ │ ├── PxBVH33MidphaseDesc.h
│ │ │ │ ├── PxBVH34MidphaseDesc.h
│ │ │ │ ├── PxBVHDesc.h
│ │ │ │ ├── PxConvexMeshDesc.h
│ │ │ │ ├── PxCooking.h
│ │ │ │ ├── PxCookingInternal.h
│ │ │ │ ├── PxMidphaseDesc.h
│ │ │ │ ├── PxSDFDesc.h
│ │ │ │ ├── PxTetrahedronMeshDesc.h
│ │ │ │ ├── PxTriangleMeshDesc.h
│ │ │ │ └── Pxc.h
│ │ │ ├── cudamanager/
│ │ │ │ ├── PxCudaContext.h
│ │ │ │ ├── PxCudaContextManager.h
│ │ │ │ └── PxCudaTypes.h
│ │ │ ├── extensions/
│ │ │ │ ├── PxBroadPhaseExt.h
│ │ │ │ ├── PxCollectionExt.h
│ │ │ │ ├── PxConstraintExt.h
│ │ │ │ ├── PxConvexCoreExt.h
│ │ │ │ ├── PxConvexMeshExt.h
│ │ │ │ ├── PxCudaHelpersExt.h
│ │ │ │ ├── PxCustomGeometryExt.h
│ │ │ │ ├── PxCustomSceneQuerySystem.h
│ │ │ │ ├── PxD6Joint.h
│ │ │ │ ├── PxD6JointCreate.h
│ │ │ │ ├── PxDefaultAllocator.h
│ │ │ │ ├── PxDefaultCpuDispatcher.h
│ │ │ │ ├── PxDefaultErrorCallback.h
│ │ │ │ ├── PxDefaultProfiler.h
│ │ │ │ ├── PxDefaultSimulationFilterShader.h
│ │ │ │ ├── PxDefaultStreams.h
│ │ │ │ ├── PxDeformableSkinningExt.h
│ │ │ │ ├── PxDeformableSurfaceExt.h
│ │ │ │ ├── PxDeformableVolumeExt.h
│ │ │ │ ├── PxDistanceJoint.h
│ │ │ │ ├── PxExtensionsAPI.h
│ │ │ │ ├── PxFixedJoint.h
│ │ │ │ ├── PxGearJoint.h
│ │ │ │ ├── PxGjkQueryExt.h
│ │ │ │ ├── PxJoint.h
│ │ │ │ ├── PxJointLimit.h
│ │ │ │ ├── PxMassProperties.h
│ │ │ │ ├── PxParticleClothCooker.h
│ │ │ │ ├── PxParticleExt.h
│ │ │ │ ├── PxPrismaticJoint.h
│ │ │ │ ├── PxRackAndPinionJoint.h
│ │ │ │ ├── PxRaycastCCD.h
│ │ │ │ ├── PxRemeshingExt.h
│ │ │ │ ├── PxRepXSerializer.h
│ │ │ │ ├── PxRepXSimpleType.h
│ │ │ │ ├── PxRevoluteJoint.h
│ │ │ │ ├── PxRigidActorExt.h
│ │ │ │ ├── PxRigidBodyExt.h
│ │ │ │ ├── PxSamplingExt.h
│ │ │ │ ├── PxSceneQueryExt.h
│ │ │ │ ├── PxSceneQuerySystemExt.h
│ │ │ │ ├── PxSerialization.h
│ │ │ │ ├── PxShapeExt.h
│ │ │ │ ├── PxSimpleFactory.h
│ │ │ │ ├── PxSmoothNormals.h
│ │ │ │ ├── PxSoftBodyExt.h
│ │ │ │ ├── PxSphericalJoint.h
│ │ │ │ ├── PxStringTableExt.h
│ │ │ │ ├── PxTetMakerExt.h
│ │ │ │ ├── PxTetrahedronMeshAnalysisResult.h
│ │ │ │ ├── PxTetrahedronMeshExt.h
│ │ │ │ ├── PxTriangleMeshAnalysisResult.h
│ │ │ │ └── PxTriangleMeshExt.h
│ │ │ ├── filebuf/
│ │ │ │ └── PxFileBuf.h
│ │ │ ├── foundation/
│ │ │ │ ├── PxAlignedMalloc.h
│ │ │ │ ├── PxAlloca.h
│ │ │ │ ├── PxAllocator.h
│ │ │ │ ├── PxAllocatorCallback.h
│ │ │ │ ├── PxAoS.h
│ │ │ │ ├── PxArray.h
│ │ │ │ ├── PxAssert.h
│ │ │ │ ├── PxAtomic.h
│ │ │ │ ├── PxBasicTemplates.h
│ │ │ │ ├── PxBitAndData.h
│ │ │ │ ├── PxBitMap.h
│ │ │ │ ├── PxBitUtils.h
│ │ │ │ ├── PxBounds3.h
│ │ │ │ ├── PxBroadcast.h
│ │ │ │ ├── PxConstructor.h
│ │ │ │ ├── PxErrorCallback.h
│ │ │ │ ├── PxErrors.h
│ │ │ │ ├── PxFPU.h
│ │ │ │ ├── PxFlags.h
│ │ │ │ ├── PxFoundation.h
│ │ │ │ ├── PxFoundationConfig.h
│ │ │ │ ├── PxHash.h
│ │ │ │ ├── PxHashInternals.h
│ │ │ │ ├── PxHashMap.h
│ │ │ │ ├── PxHashSet.h
│ │ │ │ ├── PxIO.h
│ │ │ │ ├── PxInlineAllocator.h
│ │ │ │ ├── PxInlineAoS.h
│ │ │ │ ├── PxInlineArray.h
│ │ │ │ ├── PxIntrinsics.h
│ │ │ │ ├── PxMat33.h
│ │ │ │ ├── PxMat34.h
│ │ │ │ ├── PxMat44.h
│ │ │ │ ├── PxMath.h
│ │ │ │ ├── PxMathIntrinsics.h
│ │ │ │ ├── PxMathUtils.h
│ │ │ │ ├── PxMemory.h
│ │ │ │ ├── PxMutex.h
│ │ │ │ ├── PxPhysicsVersion.h
│ │ │ │ ├── PxPinnedArray.h
│ │ │ │ ├── PxPlane.h
│ │ │ │ ├── PxPool.h
│ │ │ │ ├── PxPreprocessor.h
│ │ │ │ ├── PxProfiler.h
│ │ │ │ ├── PxQuat.h
│ │ │ │ ├── PxSIMDHelpers.h
│ │ │ │ ├── PxSList.h
│ │ │ │ ├── PxSimpleTypes.h
│ │ │ │ ├── PxSocket.h
│ │ │ │ ├── PxSort.h
│ │ │ │ ├── PxSortInternals.h
│ │ │ │ ├── PxStrideIterator.h
│ │ │ │ ├── PxString.h
│ │ │ │ ├── PxSync.h
│ │ │ │ ├── PxTempAllocator.h
│ │ │ │ ├── PxThread.h
│ │ │ │ ├── PxTime.h
│ │ │ │ ├── PxTransform.h
│ │ │ │ ├── PxUnionCast.h
│ │ │ │ ├── PxUserAllocated.h
│ │ │ │ ├── PxUtilities.h
│ │ │ │ ├── PxVec2.h
│ │ │ │ ├── PxVec3.h
│ │ │ │ ├── PxVec4.h
│ │ │ │ ├── PxVecMath.h
│ │ │ │ ├── PxVecMathAoSScalar.h
│ │ │ │ ├── PxVecMathAoSScalarInline.h
│ │ │ │ ├── PxVecMathSSE.h
│ │ │ │ ├── PxVecQuat.h
│ │ │ │ ├── PxVecTransform.h
│ │ │ │ ├── unix/
│ │ │ │ │ ├── PxUnixAoS.h
│ │ │ │ │ ├── PxUnixFPU.h
│ │ │ │ │ ├── PxUnixInlineAoS.h
│ │ │ │ │ ├── PxUnixIntrinsics.h
│ │ │ │ │ ├── PxUnixMathIntrinsics.h
│ │ │ │ │ ├── PxUnixTrigConstants.h
│ │ │ │ │ ├── neon/
│ │ │ │ │ │ ├── PxUnixNeonAoS.h
│ │ │ │ │ │ └── PxUnixNeonInlineAoS.h
│ │ │ │ │ └── sse2/
│ │ │ │ │ ├── PxUnixSse2AoS.h
│ │ │ │ │ └── PxUnixSse2InlineAoS.h
│ │ │ │ └── windows/
│ │ │ │ ├── PxWindowsAoS.h
│ │ │ │ ├── PxWindowsFPU.h
│ │ │ │ ├── PxWindowsInclude.h
│ │ │ │ ├── PxWindowsInlineAoS.h
│ │ │ │ ├── PxWindowsIntrinsics.h
│ │ │ │ ├── PxWindowsMathIntrinsics.h
│ │ │ │ └── PxWindowsTrigConstants.h
│ │ │ ├── geometry/
│ │ │ │ ├── PxBVH.h
│ │ │ │ ├── PxBVHBuildStrategy.h
│ │ │ │ ├── PxBoxGeometry.h
│ │ │ │ ├── PxCapsuleGeometry.h
│ │ │ │ ├── PxConvexCoreGeometry.h
│ │ │ │ ├── PxConvexMesh.h
│ │ │ │ ├── PxConvexMeshGeometry.h
│ │ │ │ ├── PxCustomGeometry.h
│ │ │ │ ├── PxGeometry.h
│ │ │ │ ├── PxGeometryHelpers.h
│ │ │ │ ├── PxGeometryHit.h
│ │ │ │ ├── PxGeometryInternal.h
│ │ │ │ ├── PxGeometryQuery.h
│ │ │ │ ├── PxGeometryQueryContext.h
│ │ │ │ ├── PxGeometryQueryFlags.h
│ │ │ │ ├── PxGjkQuery.h
│ │ │ │ ├── PxHeightField.h
│ │ │ │ ├── PxHeightFieldDesc.h
│ │ │ │ ├── PxHeightFieldFlag.h
│ │ │ │ ├── PxHeightFieldGeometry.h
│ │ │ │ ├── PxHeightFieldSample.h
│ │ │ │ ├── PxMeshQuery.h
│ │ │ │ ├── PxMeshScale.h
│ │ │ │ ├── PxParticleSystemGeometry.h
│ │ │ │ ├── PxPlaneGeometry.h
│ │ │ │ ├── PxReportCallback.h
│ │ │ │ ├── PxSimpleTriangleMesh.h
│ │ │ │ ├── PxSphereGeometry.h
│ │ │ │ ├── PxTetrahedron.h
│ │ │ │ ├── PxTetrahedronMesh.h
│ │ │ │ ├── PxTetrahedronMeshGeometry.h
│ │ │ │ ├── PxTriangle.h
│ │ │ │ ├── PxTriangleMesh.h
│ │ │ │ └── PxTriangleMeshGeometry.h
│ │ │ ├── geomutils/
│ │ │ │ ├── PxContactBuffer.h
│ │ │ │ └── PxContactPoint.h
│ │ │ ├── gpu/
│ │ │ │ ├── PxGpu.h
│ │ │ │ └── PxPhysicsGpu.h
│ │ │ ├── omnipvd/
│ │ │ │ └── PxOmniPvd.h
│ │ │ ├── pvd/
│ │ │ │ ├── PxPvd.h
│ │ │ │ ├── PxPvdSceneClient.h
│ │ │ │ └── PxPvdTransport.h
│ │ │ ├── solver/
│ │ │ │ └── PxSolverDefs.h
│ │ │ ├── task/
│ │ │ │ ├── PxCpuDispatcher.h
│ │ │ │ ├── PxTask.h
│ │ │ │ └── PxTaskManager.h
│ │ │ └── vehicle2/
│ │ │ ├── PxVehicleAPI.h
│ │ │ ├── PxVehicleComponent.h
│ │ │ ├── PxVehicleComponentSequence.h
│ │ │ ├── PxVehicleFunctions.h
│ │ │ ├── PxVehicleLimits.h
│ │ │ ├── PxVehicleMaths.h
│ │ │ ├── PxVehicleParams.h
│ │ │ ├── braking/
│ │ │ │ ├── PxVehicleBrakingFunctions.h
│ │ │ │ └── PxVehicleBrakingParams.h
│ │ │ ├── commands/
│ │ │ │ ├── PxVehicleCommandHelpers.h
│ │ │ │ ├── PxVehicleCommandParams.h
│ │ │ │ └── PxVehicleCommandStates.h
│ │ │ ├── drivetrain/
│ │ │ │ ├── PxVehicleDrivetrainComponents.h
│ │ │ │ ├── PxVehicleDrivetrainFunctions.h
│ │ │ │ ├── PxVehicleDrivetrainHelpers.h
│ │ │ │ ├── PxVehicleDrivetrainParams.h
│ │ │ │ └── PxVehicleDrivetrainStates.h
│ │ │ ├── physxActor/
│ │ │ │ ├── PxVehiclePhysXActorComponents.h
│ │ │ │ ├── PxVehiclePhysXActorFunctions.h
│ │ │ │ ├── PxVehiclePhysXActorHelpers.h
│ │ │ │ └── PxVehiclePhysXActorStates.h
│ │ │ ├── physxConstraints/
│ │ │ │ ├── PxVehiclePhysXConstraintComponents.h
│ │ │ │ ├── PxVehiclePhysXConstraintFunctions.h
│ │ │ │ ├── PxVehiclePhysXConstraintHelpers.h
│ │ │ │ ├── PxVehiclePhysXConstraintParams.h
│ │ │ │ └── PxVehiclePhysXConstraintStates.h
│ │ │ ├── physxRoadGeometry/
│ │ │ │ ├── PxVehiclePhysXRoadGeometryComponents.h
│ │ │ │ ├── PxVehiclePhysXRoadGeometryFunctions.h
│ │ │ │ ├── PxVehiclePhysXRoadGeometryHelpers.h
│ │ │ │ ├── PxVehiclePhysXRoadGeometryParams.h
│ │ │ │ └── PxVehiclePhysXRoadGeometryState.h
│ │ │ ├── pvd/
│ │ │ │ ├── PxVehiclePvdComponents.h
│ │ │ │ ├── PxVehiclePvdFunctions.h
│ │ │ │ └── PxVehiclePvdHelpers.h
│ │ │ ├── rigidBody/
│ │ │ │ ├── PxVehicleRigidBodyComponents.h
│ │ │ │ ├── PxVehicleRigidBodyFunctions.h
│ │ │ │ ├── PxVehicleRigidBodyParams.h
│ │ │ │ └── PxVehicleRigidBodyStates.h
│ │ │ ├── roadGeometry/
│ │ │ │ └── PxVehicleRoadGeometryState.h
│ │ │ ├── steering/
│ │ │ │ ├── PxVehicleSteeringFunctions.h
│ │ │ │ └── PxVehicleSteeringParams.h
│ │ │ ├── suspension/
│ │ │ │ ├── PxVehicleSuspensionComponents.h
│ │ │ │ ├── PxVehicleSuspensionFunctions.h
│ │ │ │ ├── PxVehicleSuspensionHelpers.h
│ │ │ │ ├── PxVehicleSuspensionParams.h
│ │ │ │ └── PxVehicleSuspensionStates.h
│ │ │ ├── tire/
│ │ │ │ ├── PxVehicleTireComponents.h
│ │ │ │ ├── PxVehicleTireFunctions.h
│ │ │ │ ├── PxVehicleTireHelpers.h
│ │ │ │ ├── PxVehicleTireParams.h
│ │ │ │ └── PxVehicleTireStates.h
│ │ │ └── wheel/
│ │ │ ├── PxVehicleWheelComponents.h
│ │ │ ├── PxVehicleWheelFunctions.h
│ │ │ ├── PxVehicleWheelHelpers.h
│ │ │ ├── PxVehicleWheelParams.h
│ │ │ └── PxVehicleWheelStates.h
│ │ └── version.txt
│ ├── renderdoc/
│ │ ├── renderdoc/
│ │ │ ├── app/
│ │ │ │ └── renderdoc_app.h
│ │ │ └── replay/
│ │ │ ├── apidefs.h
│ │ │ ├── capture_options.h
│ │ │ ├── common_pipestate.h
│ │ │ ├── control_types.h
│ │ │ ├── d3d11_pipestate.h
│ │ │ ├── d3d12_pipestate.h
│ │ │ ├── data_types.h
│ │ │ ├── gl_pipestate.h
│ │ │ ├── pipestate.h
│ │ │ ├── pipestate.inl
│ │ │ ├── rdcarray.h
│ │ │ ├── rdcdatetime.h
│ │ │ ├── rdcflatmap.h
│ │ │ ├── rdcpair.h
│ │ │ ├── rdcstr.h
│ │ │ ├── renderdoc_replay.h
│ │ │ ├── renderdoc_tostr.inl
│ │ │ ├── replay_enums.h
│ │ │ ├── resourceid.h
│ │ │ ├── shader_types.h
│ │ │ ├── stringise.h
│ │ │ ├── structured_data.h
│ │ │ ├── version.h
│ │ │ └── vk_pipestate.h
│ │ └── version.txt
│ ├── sdl/
│ │ ├── SDL3/
│ │ │ ├── SDL.h
│ │ │ ├── SDL_assert.h
│ │ │ ├── SDL_asyncio.h
│ │ │ ├── SDL_atomic.h
│ │ │ ├── SDL_audio.h
│ │ │ ├── SDL_begin_code.h
│ │ │ ├── SDL_bits.h
│ │ │ ├── SDL_blendmode.h
│ │ │ ├── SDL_camera.h
│ │ │ ├── SDL_clipboard.h
│ │ │ ├── SDL_close_code.h
│ │ │ ├── SDL_copying.h
│ │ │ ├── SDL_cpuinfo.h
│ │ │ ├── SDL_dialog.h
│ │ │ ├── SDL_egl.h
│ │ │ ├── SDL_endian.h
│ │ │ ├── SDL_error.h
│ │ │ ├── SDL_events.h
│ │ │ ├── SDL_filesystem.h
│ │ │ ├── SDL_gamepad.h
│ │ │ ├── SDL_gpu.h
│ │ │ ├── SDL_guid.h
│ │ │ ├── SDL_haptic.h
│ │ │ ├── SDL_hidapi.h
│ │ │ ├── SDL_hints.h
│ │ │ ├── SDL_init.h
│ │ │ ├── SDL_intrin.h
│ │ │ ├── SDL_iostream.h
│ │ │ ├── SDL_joystick.h
│ │ │ ├── SDL_keyboard.h
│ │ │ ├── SDL_keycode.h
│ │ │ ├── SDL_loadso.h
│ │ │ ├── SDL_locale.h
│ │ │ ├── SDL_log.h
│ │ │ ├── SDL_main.h
│ │ │ ├── SDL_main_impl.h
│ │ │ ├── SDL_messagebox.h
│ │ │ ├── SDL_metal.h
│ │ │ ├── SDL_misc.h
│ │ │ ├── SDL_mouse.h
│ │ │ ├── SDL_mutex.h
│ │ │ ├── SDL_oldnames.h
│ │ │ ├── SDL_opengl.h
│ │ │ ├── SDL_opengl_glext.h
│ │ │ ├── SDL_opengles.h
│ │ │ ├── SDL_opengles2.h
│ │ │ ├── SDL_opengles2_gl2.h
│ │ │ ├── SDL_opengles2_gl2ext.h
│ │ │ ├── SDL_opengles2_gl2platform.h
│ │ │ ├── SDL_opengles2_khrplatform.h
│ │ │ ├── SDL_pen.h
│ │ │ ├── SDL_pixels.h
│ │ │ ├── SDL_platform.h
│ │ │ ├── SDL_platform_defines.h
│ │ │ ├── SDL_power.h
│ │ │ ├── SDL_process.h
│ │ │ ├── SDL_properties.h
│ │ │ ├── SDL_rect.h
│ │ │ ├── SDL_render.h
│ │ │ ├── SDL_revision.h
│ │ │ ├── SDL_scancode.h
│ │ │ ├── SDL_sensor.h
│ │ │ ├── SDL_stdinc.h
│ │ │ ├── SDL_storage.h
│ │ │ ├── SDL_surface.h
│ │ │ ├── SDL_system.h
│ │ │ ├── SDL_test.h
│ │ │ ├── SDL_test_assert.h
│ │ │ ├── SDL_test_common.h
│ │ │ ├── SDL_test_compare.h
│ │ │ ├── SDL_test_crc32.h
│ │ │ ├── SDL_test_font.h
│ │ │ ├── SDL_test_fuzzer.h
│ │ │ ├── SDL_test_harness.h
│ │ │ ├── SDL_test_log.h
│ │ │ ├── SDL_test_md5.h
│ │ │ ├── SDL_test_memory.h
│ │ │ ├── SDL_thread.h
│ │ │ ├── SDL_time.h
│ │ │ ├── SDL_timer.h
│ │ │ ├── SDL_touch.h
│ │ │ ├── SDL_tray.h
│ │ │ ├── SDL_version.h
│ │ │ ├── SDL_video.h
│ │ │ └── SDL_vulkan.h
│ │ └── version.txt
│ ├── spirv_cross/
│ │ ├── spirv_cross/
│ │ │ ├── GLSL.std.450.h
│ │ │ ├── spirv.h
│ │ │ ├── spirv.hpp
│ │ │ ├── spirv_cfg.hpp
│ │ │ ├── spirv_common.hpp
│ │ │ ├── spirv_cross.hpp
│ │ │ ├── spirv_cross_c.cpp
│ │ │ ├── spirv_cross_c.h
│ │ │ ├── spirv_cross_containers.hpp
│ │ │ ├── spirv_cross_error_handling.hpp
│ │ │ ├── spirv_cross_parsed_ir.hpp
│ │ │ ├── spirv_glsl.hpp
│ │ │ └── spirv_hlsl.hpp
│ │ └── version.txt
│ ├── vulkan/
│ │ ├── version.txt
│ │ ├── vk_video/
│ │ │ ├── vulkan_video_codec_av1std.h
│ │ │ ├── vulkan_video_codec_av1std_decode.h
│ │ │ ├── vulkan_video_codec_av1std_encode.h
│ │ │ ├── vulkan_video_codec_h264std.h
│ │ │ ├── vulkan_video_codec_h264std_decode.h
│ │ │ ├── vulkan_video_codec_h264std_encode.h
│ │ │ ├── vulkan_video_codec_h265std.h
│ │ │ ├── vulkan_video_codec_h265std_decode.h
│ │ │ ├── vulkan_video_codec_h265std_encode.h
│ │ │ ├── vulkan_video_codec_vp9std.h
│ │ │ ├── vulkan_video_codec_vp9std_decode.h
│ │ │ └── vulkan_video_codecs_common.h
│ │ └── vulkan/
│ │ ├── utility/
│ │ │ ├── vk_concurrent_unordered_map.hpp
│ │ │ ├── vk_dispatch_table.h
│ │ │ ├── vk_format_utils.h
│ │ │ ├── vk_safe_struct.hpp
│ │ │ ├── vk_safe_struct_utils.hpp
│ │ │ ├── vk_small_containers.hpp
│ │ │ ├── vk_sparse_range_map.hpp
│ │ │ └── vk_struct_helper.hpp
│ │ ├── vk_enum_string_helper.h
│ │ ├── vk_icd.h
│ │ ├── vk_layer.h
│ │ ├── vk_platform.h
│ │ ├── vulkan.cppm
│ │ ├── vulkan.h
│ │ ├── vulkan.hpp
│ │ ├── vulkan_android.h
│ │ ├── vulkan_beta.h
│ │ ├── vulkan_core.h
│ │ ├── vulkan_directfb.h
│ │ ├── vulkan_enums.hpp
│ │ ├── vulkan_extension_inspection.hpp
│ │ ├── vulkan_format_traits.hpp
│ │ ├── vulkan_fuchsia.h
│ │ ├── vulkan_funcs.hpp
│ │ ├── vulkan_ggp.h
│ │ ├── vulkan_handles.hpp
│ │ ├── vulkan_hash.hpp
│ │ ├── vulkan_hpp_macros.hpp
│ │ ├── vulkan_ios.h
│ │ ├── vulkan_layer_settings.hpp
│ │ ├── vulkan_macos.h
│ │ ├── vulkan_metal.h
│ │ ├── vulkan_ohos.h
│ │ ├── vulkan_profiles.hpp
│ │ ├── vulkan_raii.hpp
│ │ ├── vulkan_screen.h
│ │ ├── vulkan_shared.hpp
│ │ ├── vulkan_static_assertions.hpp
│ │ ├── vulkan_structs.hpp
│ │ ├── vulkan_to_string.hpp
│ │ ├── vulkan_vi.h
│ │ ├── vulkan_video.cppm
│ │ ├── vulkan_video.hpp
│ │ ├── vulkan_wayland.h
│ │ ├── vulkan_win32.h
│ │ ├── vulkan_xcb.h
│ │ ├── vulkan_xlib.h
│ │ └── vulkan_xlib_xrandr.h
│ ├── vulkan_memory_allocator/
│ │ ├── version.txt
│ │ └── vk_mem_alloc.h
│ └── xess/
│ ├── version.txt
│ └── xess/
│ ├── xess.h
│ ├── xess_d3d11.h
│ ├── xess_d3d12.h
│ ├── xess_d3d12_debug.h
│ ├── xess_debug.h
│ ├── xess_vk.h
│ └── xess_vk_debug.h
└── worlds/
└── plan.world
Copy disabled (too large)
Download .txt
Showing preview only (291,032K chars total). Download the full file to get everything.
SYMBOL INDEX (47712 symbols across 1250 files)
FILE: build_scripts/file_utilities.py
function install_and_import (line 29) | def install_and_import(package):
function calculate_file_hash (line 46) | def calculate_file_hash(file_path):
function download_file (line 53) | def download_file(url, destination, expected_hash, max_retries=3, chunk_...
function extract_archive (line 163) | def extract_archive(archive_path, destination_path):
function copy (line 192) | def copy(source, destination):
FILE: build_scripts/generate_project_files.py
function generate_project_files (line 49) | def generate_project_files():
function main (line 80) | def main():
FILE: build_scripts/hash_printer.py
function print_local_file_hashes (line 24) | def print_local_file_hashes():
FILE: data/shaders/amd_fidelity_fx/ffx_a.h
type AP1 (line 121) | typedef uint32_t AP1;
type AF1 (line 122) | typedef float AF1;
type AD1 (line 123) | typedef double AD1;
type AB1 (line 124) | typedef uint8_t AB1;
type AW1 (line 125) | typedef uint16_t AW1;
type AU1 (line 126) | typedef uint32_t AU1;
type AL1 (line 127) | typedef uint64_t AL1;
type ASB1 (line 128) | typedef int8_t ASB1;
type ASW1 (line 129) | typedef int16_t ASW1;
type ASU1 (line 130) | typedef int32_t ASU1;
type ASL1 (line 131) | typedef int64_t ASL1;
function A_STATIC (line 141) | A_STATIC AU1 AU1_AF1(AF1 a){union{AF1 f;AU1 u;}bits;bits.f=a;return bits...
function A_STATIC (line 255) | A_STATIC AD1 AAbsD1(AD1 a){return __builtin_fabs(a);}
function A_STATIC (line 256) | A_STATIC AF1 AAbsF1(AF1 a){return __builtin_fabsf(a);}
function A_STATIC (line 257) | A_STATIC AU1 AAbsSU1(AU1 a){return AU1_(__builtin_abs(ASU1_(a)));}
function A_STATIC (line 258) | A_STATIC AL1 AAbsSL1(AL1 a){return AL1_(__builtin_llabs(ASL1_(a)));}
function A_STATIC (line 260) | A_STATIC AD1 AAbsD1(AD1 a){return fabs(a);}
function A_STATIC (line 261) | A_STATIC AF1 AAbsF1(AF1 a){return fabsf(a);}
function A_STATIC (line 262) | A_STATIC AU1 AAbsSU1(AU1 a){return AU1_(abs(ASU1_(a)));}
function A_STATIC (line 263) | A_STATIC AL1 AAbsSL1(AL1 a){return AL1_(labs((long)ASL1_(a)));}
function A_STATIC (line 267) | A_STATIC AD1 ACosD1(AD1 a){return __builtin_cos(a);}
function A_STATIC (line 268) | A_STATIC AF1 ACosF1(AF1 a){return __builtin_cosf(a);}
function A_STATIC (line 270) | A_STATIC AD1 ACosD1(AD1 a){return cos(a);}
function A_STATIC (line 271) | A_STATIC AF1 ACosF1(AF1 a){return cosf(a);}
function A_STATIC (line 274) | A_STATIC AD1 ADotD2(inAD2 a,inAD2 b){return a[0]*b[0]+a[1]*b[1];}
function A_STATIC (line 275) | A_STATIC AD1 ADotD3(inAD3 a,inAD3 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];}
function A_STATIC (line 276) | A_STATIC AD1 ADotD4(inAD4 a,inAD4 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2...
function A_STATIC (line 277) | A_STATIC AF1 ADotF2(inAF2 a,inAF2 b){return a[0]*b[0]+a[1]*b[1];}
function A_STATIC (line 278) | A_STATIC AF1 ADotF3(inAF3 a,inAF3 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];}
function A_STATIC (line 279) | A_STATIC AF1 ADotF4(inAF4 a,inAF4 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2...
function A_STATIC (line 282) | A_STATIC AD1 AExp2D1(AD1 a){return __builtin_exp2(a);}
function A_STATIC (line 283) | A_STATIC AF1 AExp2F1(AF1 a){return __builtin_exp2f(a);}
function A_STATIC (line 285) | A_STATIC AD1 AExp2D1(AD1 a){return exp2(a);}
function A_STATIC (line 286) | A_STATIC AF1 AExp2F1(AF1 a){return exp2f(a);}
function A_STATIC (line 290) | A_STATIC AD1 AFloorD1(AD1 a){return __builtin_floor(a);}
function A_STATIC (line 291) | A_STATIC AF1 AFloorF1(AF1 a){return __builtin_floorf(a);}
function A_STATIC (line 293) | A_STATIC AD1 AFloorD1(AD1 a){return floor(a);}
function A_STATIC (line 294) | A_STATIC AF1 AFloorF1(AF1 a){return floorf(a);}
function A_STATIC (line 297) | A_STATIC AD1 ALerpD1(AD1 a,AD1 b,AD1 c){return b*c+(-a*c+a);}
function A_STATIC (line 298) | A_STATIC AF1 ALerpF1(AF1 a,AF1 b,AF1 c){return b*c+(-a*c+a);}
function A_STATIC (line 301) | A_STATIC AD1 ALog2D1(AD1 a){return __builtin_log2(a);}
function A_STATIC (line 302) | A_STATIC AF1 ALog2F1(AF1 a){return __builtin_log2f(a);}
function A_STATIC (line 304) | A_STATIC AD1 ALog2D1(AD1 a){return log2(a);}
function A_STATIC (line 305) | A_STATIC AF1 ALog2F1(AF1 a){return log2f(a);}
function A_STATIC (line 308) | A_STATIC AD1 AMaxD1(AD1 a,AD1 b){return a>b?a:b;}
function A_STATIC (line 309) | A_STATIC AF1 AMaxF1(AF1 a,AF1 b){return a>b?a:b;}
function A_STATIC (line 310) | A_STATIC AL1 AMaxL1(AL1 a,AL1 b){return a>b?a:b;}
function A_STATIC (line 311) | A_STATIC AU1 AMaxU1(AU1 a,AU1 b){return a>b?a:b;}
function A_STATIC (line 314) | A_STATIC AL1 AMaxSL1(AL1 a,AL1 b){return (ASL1_(a)>ASL1_(b))?a:b;}
function A_STATIC (line 315) | A_STATIC AU1 AMaxSU1(AU1 a,AU1 b){return (ASU1_(a)>ASU1_(b))?a:b;}
function A_STATIC (line 317) | A_STATIC AD1 AMinD1(AD1 a,AD1 b){return a<b?a:b;}
function A_STATIC (line 318) | A_STATIC AF1 AMinF1(AF1 a,AF1 b){return a<b?a:b;}
function A_STATIC (line 319) | A_STATIC AL1 AMinL1(AL1 a,AL1 b){return a<b?a:b;}
function A_STATIC (line 320) | A_STATIC AU1 AMinU1(AU1 a,AU1 b){return a<b?a:b;}
function A_STATIC (line 322) | A_STATIC AL1 AMinSL1(AL1 a,AL1 b){return (ASL1_(a)<ASL1_(b))?a:b;}
function A_STATIC (line 323) | A_STATIC AU1 AMinSU1(AU1 a,AU1 b){return (ASU1_(a)<ASU1_(b))?a:b;}
function A_STATIC (line 325) | A_STATIC AD1 ARcpD1(AD1 a){return 1.0/a;}
function A_STATIC (line 326) | A_STATIC AF1 ARcpF1(AF1 a){return 1.0f/a;}
function A_STATIC (line 328) | A_STATIC AL1 AShrSL1(AL1 a,AL1 b){return AL1_(ASL1_(a)>>ASL1_(b));}
function A_STATIC (line 329) | A_STATIC AU1 AShrSU1(AU1 a,AU1 b){return AU1_(ASU1_(a)>>ASU1_(b));}
function A_STATIC (line 332) | A_STATIC AD1 ASinD1(AD1 a){return __builtin_sin(a);}
function A_STATIC (line 333) | A_STATIC AF1 ASinF1(AF1 a){return __builtin_sinf(a);}
function A_STATIC (line 335) | A_STATIC AD1 ASinD1(AD1 a){return sin(a);}
function A_STATIC (line 336) | A_STATIC AF1 ASinF1(AF1 a){return sinf(a);}
function A_STATIC (line 340) | A_STATIC AD1 ASqrtD1(AD1 a){return __builtin_sqrt(a);}
function A_STATIC (line 341) | A_STATIC AF1 ASqrtF1(AF1 a){return __builtin_sqrtf(a);}
function A_STATIC (line 343) | A_STATIC AD1 ASqrtD1(AD1 a){return sqrt(a);}
function A_STATIC (line 344) | A_STATIC AF1 ASqrtF1(AF1 a){return sqrtf(a);}
function A_STATIC (line 352) | A_STATIC AD1 AClampD1(AD1 x,AD1 n,AD1 m){return AMaxD1(n,AMinD1(x,m));}
function A_STATIC (line 353) | A_STATIC AF1 AClampF1(AF1 x,AF1 n,AF1 m){return AMaxF1(n,AMinF1(x,m));}
function A_STATIC (line 355) | A_STATIC AD1 AFractD1(AD1 a){return a-AFloorD1(a);}
function A_STATIC (line 356) | A_STATIC AF1 AFractF1(AF1 a){return a-AFloorF1(a);}
function A_STATIC (line 358) | A_STATIC AD1 APowD1(AD1 a,AD1 b){return AExp2D1(b*ALog2D1(a));}
function A_STATIC (line 359) | A_STATIC AF1 APowF1(AF1 a,AF1 b){return AExp2F1(b*ALog2F1(a));}
function A_STATIC (line 361) | A_STATIC AD1 ARsqD1(AD1 a){return ARcpD1(ASqrtD1(a));}
function A_STATIC (line 362) | A_STATIC AF1 ARsqF1(AF1 a){return ARcpF1(ASqrtF1(a));}
function A_STATIC (line 364) | A_STATIC AD1 ASatD1(AD1 a){return AMinD1(1.0,AMaxD1(0.0,a));}
function A_STATIC (line 365) | A_STATIC AF1 ASatF1(AF1 a){return AMinF1(1.0f,AMaxF1(0.0f,a));}
function A_STATIC (line 375) | A_STATIC retAD2 opAAbsD2(outAD2 d,inAD2 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1...
function A_STATIC (line 376) | A_STATIC retAD3 opAAbsD3(outAD3 d,inAD3 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1...
function A_STATIC (line 377) | A_STATIC retAD4 opAAbsD4(outAD4 d,inAD4 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1...
function A_STATIC (line 379) | A_STATIC retAF2 opAAbsF2(outAF2 d,inAF2 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1...
function A_STATIC (line 380) | A_STATIC retAF3 opAAbsF3(outAF3 d,inAF3 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1...
function A_STATIC (line 381) | A_STATIC retAF4 opAAbsF4(outAF4 d,inAF4 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1...
function A_STATIC (line 383) | A_STATIC retAD2 opAAddD2(outAD2 d,inAD2 a,inAD2 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 384) | A_STATIC retAD3 opAAddD3(outAD3 d,inAD3 a,inAD3 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 385) | A_STATIC retAD4 opAAddD4(outAD4 d,inAD4 a,inAD4 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 387) | A_STATIC retAF2 opAAddF2(outAF2 d,inAF2 a,inAF2 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 388) | A_STATIC retAF3 opAAddF3(outAF3 d,inAF3 a,inAF3 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 389) | A_STATIC retAF4 opAAddF4(outAF4 d,inAF4 a,inAF4 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 391) | A_STATIC retAD2 opAAddOneD2(outAD2 d,inAD2 a,AD1 b){d[0]=a[0]+b;d[1]=a[1...
function A_STATIC (line 392) | A_STATIC retAD3 opAAddOneD3(outAD3 d,inAD3 a,AD1 b){d[0]=a[0]+b;d[1]=a[1...
function A_STATIC (line 393) | A_STATIC retAD4 opAAddOneD4(outAD4 d,inAD4 a,AD1 b){d[0]=a[0]+b;d[1]=a[1...
function A_STATIC (line 395) | A_STATIC retAF2 opAAddOneF2(outAF2 d,inAF2 a,AF1 b){d[0]=a[0]+b;d[1]=a[1...
function A_STATIC (line 396) | A_STATIC retAF3 opAAddOneF3(outAF3 d,inAF3 a,AF1 b){d[0]=a[0]+b;d[1]=a[1...
function A_STATIC (line 397) | A_STATIC retAF4 opAAddOneF4(outAF4 d,inAF4 a,AF1 b){d[0]=a[0]+b;d[1]=a[1...
function A_STATIC (line 399) | A_STATIC retAD2 opACpyD2(outAD2 d,inAD2 a){d[0]=a[0];d[1]=a[1];return d;}
function A_STATIC (line 400) | A_STATIC retAD3 opACpyD3(outAD3 d,inAD3 a){d[0]=a[0];d[1]=a[1];d[2]=a[2]...
function A_STATIC (line 401) | A_STATIC retAD4 opACpyD4(outAD4 d,inAD4 a){d[0]=a[0];d[1]=a[1];d[2]=a[2]...
function A_STATIC (line 403) | A_STATIC retAF2 opACpyF2(outAF2 d,inAF2 a){d[0]=a[0];d[1]=a[1];return d;}
function A_STATIC (line 404) | A_STATIC retAF3 opACpyF3(outAF3 d,inAF3 a){d[0]=a[0];d[1]=a[1];d[2]=a[2]...
function A_STATIC (line 405) | A_STATIC retAF4 opACpyF4(outAF4 d,inAF4 a){d[0]=a[0];d[1]=a[1];d[2]=a[2]...
function A_STATIC (line 407) | A_STATIC retAD2 opALerpD2(outAD2 d,inAD2 a,inAD2 b,inAD2 c){d[0]=ALerpD1...
function A_STATIC (line 408) | A_STATIC retAD3 opALerpD3(outAD3 d,inAD3 a,inAD3 b,inAD3 c){d[0]=ALerpD1...
function A_STATIC (line 409) | A_STATIC retAD4 opALerpD4(outAD4 d,inAD4 a,inAD4 b,inAD4 c){d[0]=ALerpD1...
function A_STATIC (line 411) | A_STATIC retAF2 opALerpF2(outAF2 d,inAF2 a,inAF2 b,inAF2 c){d[0]=ALerpF1...
function A_STATIC (line 412) | A_STATIC retAF3 opALerpF3(outAF3 d,inAF3 a,inAF3 b,inAF3 c){d[0]=ALerpF1...
function A_STATIC (line 413) | A_STATIC retAF4 opALerpF4(outAF4 d,inAF4 a,inAF4 b,inAF4 c){d[0]=ALerpF1...
function A_STATIC (line 415) | A_STATIC retAD2 opALerpOneD2(outAD2 d,inAD2 a,inAD2 b,AD1 c){d[0]=ALerpD...
function A_STATIC (line 416) | A_STATIC retAD3 opALerpOneD3(outAD3 d,inAD3 a,inAD3 b,AD1 c){d[0]=ALerpD...
function A_STATIC (line 417) | A_STATIC retAD4 opALerpOneD4(outAD4 d,inAD4 a,inAD4 b,AD1 c){d[0]=ALerpD...
function A_STATIC (line 419) | A_STATIC retAF2 opALerpOneF2(outAF2 d,inAF2 a,inAF2 b,AF1 c){d[0]=ALerpF...
function A_STATIC (line 420) | A_STATIC retAF3 opALerpOneF3(outAF3 d,inAF3 a,inAF3 b,AF1 c){d[0]=ALerpF...
function A_STATIC (line 421) | A_STATIC retAF4 opALerpOneF4(outAF4 d,inAF4 a,inAF4 b,AF1 c){d[0]=ALerpF...
function A_STATIC (line 423) | A_STATIC retAD2 opAMaxD2(outAD2 d,inAD2 a,inAD2 b){d[0]=AMaxD1(a[0],b[0]...
function A_STATIC (line 424) | A_STATIC retAD3 opAMaxD3(outAD3 d,inAD3 a,inAD3 b){d[0]=AMaxD1(a[0],b[0]...
function A_STATIC (line 425) | A_STATIC retAD4 opAMaxD4(outAD4 d,inAD4 a,inAD4 b){d[0]=AMaxD1(a[0],b[0]...
function A_STATIC (line 427) | A_STATIC retAF2 opAMaxF2(outAF2 d,inAF2 a,inAF2 b){d[0]=AMaxF1(a[0],b[0]...
function A_STATIC (line 428) | A_STATIC retAF3 opAMaxF3(outAF3 d,inAF3 a,inAF3 b){d[0]=AMaxF1(a[0],b[0]...
function A_STATIC (line 429) | A_STATIC retAF4 opAMaxF4(outAF4 d,inAF4 a,inAF4 b){d[0]=AMaxF1(a[0],b[0]...
function A_STATIC (line 431) | A_STATIC retAD2 opAMinD2(outAD2 d,inAD2 a,inAD2 b){d[0]=AMinD1(a[0],b[0]...
function A_STATIC (line 432) | A_STATIC retAD3 opAMinD3(outAD3 d,inAD3 a,inAD3 b){d[0]=AMinD1(a[0],b[0]...
function A_STATIC (line 433) | A_STATIC retAD4 opAMinD4(outAD4 d,inAD4 a,inAD4 b){d[0]=AMinD1(a[0],b[0]...
function A_STATIC (line 435) | A_STATIC retAF2 opAMinF2(outAF2 d,inAF2 a,inAF2 b){d[0]=AMinF1(a[0],b[0]...
function A_STATIC (line 436) | A_STATIC retAF3 opAMinF3(outAF3 d,inAF3 a,inAF3 b){d[0]=AMinF1(a[0],b[0]...
function A_STATIC (line 437) | A_STATIC retAF4 opAMinF4(outAF4 d,inAF4 a,inAF4 b){d[0]=AMinF1(a[0],b[0]...
function A_STATIC (line 439) | A_STATIC retAD2 opAMulD2(outAD2 d,inAD2 a,inAD2 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 440) | A_STATIC retAD3 opAMulD3(outAD3 d,inAD3 a,inAD3 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 441) | A_STATIC retAD4 opAMulD4(outAD4 d,inAD4 a,inAD4 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 443) | A_STATIC retAF2 opAMulF2(outAF2 d,inAF2 a,inAF2 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 444) | A_STATIC retAF3 opAMulF3(outAF3 d,inAF3 a,inAF3 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 445) | A_STATIC retAF4 opAMulF4(outAF4 d,inAF4 a,inAF4 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 447) | A_STATIC retAD2 opAMulOneD2(outAD2 d,inAD2 a,AD1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 448) | A_STATIC retAD3 opAMulOneD3(outAD3 d,inAD3 a,AD1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 449) | A_STATIC retAD4 opAMulOneD4(outAD4 d,inAD4 a,AD1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 451) | A_STATIC retAF2 opAMulOneF2(outAF2 d,inAF2 a,AF1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 452) | A_STATIC retAF3 opAMulOneF3(outAF3 d,inAF3 a,AF1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 453) | A_STATIC retAF4 opAMulOneF4(outAF4 d,inAF4 a,AF1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 455) | A_STATIC retAD2 opANegD2(outAD2 d,inAD2 a){d[0]=-a[0];d[1]=-a[1];return d;}
function A_STATIC (line 456) | A_STATIC retAD3 opANegD3(outAD3 d,inAD3 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a...
function A_STATIC (line 457) | A_STATIC retAD4 opANegD4(outAD4 d,inAD4 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a...
function A_STATIC (line 459) | A_STATIC retAF2 opANegF2(outAF2 d,inAF2 a){d[0]=-a[0];d[1]=-a[1];return d;}
function A_STATIC (line 460) | A_STATIC retAF3 opANegF3(outAF3 d,inAF3 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a...
function A_STATIC (line 461) | A_STATIC retAF4 opANegF4(outAF4 d,inAF4 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a...
function A_STATIC (line 463) | A_STATIC retAD2 opARcpD2(outAD2 d,inAD2 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1...
function A_STATIC (line 464) | A_STATIC retAD3 opARcpD3(outAD3 d,inAD3 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1...
function A_STATIC (line 465) | A_STATIC retAD4 opARcpD4(outAD4 d,inAD4 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1...
function A_STATIC (line 467) | A_STATIC retAF2 opARcpF2(outAF2 d,inAF2 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1...
function A_STATIC (line 468) | A_STATIC retAF3 opARcpF3(outAF3 d,inAF3 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1...
function A_STATIC (line 469) | A_STATIC retAF4 opARcpF4(outAF4 d,inAF4 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1...
function A_STATIC (line 482) | A_STATIC AU1 AU1_AH1_AF1(AF1 f){
function A_STATIC (line 552) | A_STATIC AU1 AU1_AH2_AF2(inAF2 a){return AU1_AH1_AF1(a[0])+(AU1_AH1_AF1(...
function AU1 (line 618) | AU1 AU1_AH1_AF1_x(AF1 a){return packHalf2x16(AF2(a,0.0));}
function AF1 (line 629) | AF1 AF1_x(AF1 a){return AF1(a);}
function AF2 (line 630) | AF2 AF2_x(AF1 a){return AF2(a,a);}
function AF3 (line 631) | AF3 AF3_x(AF1 a){return AF3(a,a,a);}
function AF4 (line 632) | AF4 AF4_x(AF1 a){return AF4(a,a,a,a);}
function AU1 (line 638) | AU1 AU1_x(AU1 a){return AU1(a);}
function AU2 (line 639) | AU2 AU2_x(AU1 a){return AU2(a,a);}
function AU3 (line 640) | AU3 AU3_x(AU1 a){return AU3(a,a,a);}
function AU4 (line 641) | AU4 AU4_x(AU1 a){return AU4(a,a,a,a);}
function AU1 (line 647) | AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));}
function AU2 (line 648) | AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));}
function AU3 (line 649) | AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));}
function AU4 (line 650) | AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));}
function AU1 (line 652) | AU1 ABfe(AU1 src,AU1 off,AU1 bits){return bitfieldExtract(src,ASU1(off),...
function AU1 (line 653) | AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));}
function AU1 (line 655) | AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){return bitfieldInsert(src,ins,0,ASU1...
function AF1 (line 658) | AF1 AClampF1(AF1 x,AF1 n,AF1 m){return clamp(x,n,m);}
function AF2 (line 659) | AF2 AClampF2(AF2 x,AF2 n,AF2 m){return clamp(x,n,m);}
function AF3 (line 660) | AF3 AClampF3(AF3 x,AF3 n,AF3 m){return clamp(x,n,m);}
function AF4 (line 661) | AF4 AClampF4(AF4 x,AF4 n,AF4 m){return clamp(x,n,m);}
function AF1 (line 664) | AF1 AFractF1(AF1 x){return fract(x);}
function AF2 (line 665) | AF2 AFractF2(AF2 x){return fract(x);}
function AF3 (line 666) | AF3 AFractF3(AF3 x){return fract(x);}
function AF4 (line 667) | AF4 AFractF4(AF4 x){return fract(x);}
function AF1 (line 669) | AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return mix(x,y,a);}
function AF2 (line 670) | AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return mix(x,y,a);}
function AF3 (line 671) | AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return mix(x,y,a);}
function AF4 (line 672) | AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return mix(x,y,a);}
function AF1 (line 675) | AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));}
function AF2 (line 676) | AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));}
function AF3 (line 677) | AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));}
function AF4 (line 678) | AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));}
function AU1 (line 680) | AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(...
function AU2 (line 681) | AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(...
function AU3 (line 682) | AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(...
function AU4 (line 683) | AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(...
function AU1 (line 685) | AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));}
function AU2 (line 686) | AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));}
function AU3 (line 687) | AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));}
function AU4 (line 688) | AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));}
function AU1 (line 690) | AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));}
function AU2 (line 691) | AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));}
function AU3 (line 692) | AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));}
function AU4 (line 693) | AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));}
function AF1 (line 697) | AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));}
function AF2 (line 698) | AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));}
function AF3 (line 699) | AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));}
function AF4 (line 700) | AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));}
function AF1 (line 703) | AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));}
function AF2 (line 704) | AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));}
function AF3 (line 705) | AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));}
function AF4 (line 706) | AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));}
function AU1 (line 708) | AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(...
function AU2 (line 709) | AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(...
function AU3 (line 710) | AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(...
function AU4 (line 711) | AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(...
function AU1 (line 713) | AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));}
function AU2 (line 714) | AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));}
function AU3 (line 715) | AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));}
function AU4 (line 716) | AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));}
function AU1 (line 718) | AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));}
function AU2 (line 719) | AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));}
function AU3 (line 720) | AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));}
function AU4 (line 721) | AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));}
function AF1 (line 725) | AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));}
function AF2 (line 726) | AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));}
function AF3 (line 727) | AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));}
function AF4 (line 728) | AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));}
function AF1 (line 732) | AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));}
function AF2 (line 733) | AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));}
function AF3 (line 734) | AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));}
function AF4 (line 735) | AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));}
function AF1 (line 737) | AF1 ARcpF1(AF1 x){return AF1_(1.0)/x;}
function AF2 (line 738) | AF2 ARcpF2(AF2 x){return AF2_(1.0)/x;}
function AF3 (line 739) | AF3 ARcpF3(AF3 x){return AF3_(1.0)/x;}
function AF4 (line 740) | AF4 ARcpF4(AF4 x){return AF4_(1.0)/x;}
function AF1 (line 742) | AF1 ARsqF1(AF1 x){return AF1_(1.0)/sqrt(x);}
function AF2 (line 743) | AF2 ARsqF2(AF2 x){return AF2_(1.0)/sqrt(x);}
function AF3 (line 744) | AF3 ARsqF3(AF3 x){return AF3_(1.0)/sqrt(x);}
function AF4 (line 745) | AF4 ARsqF4(AF4 x){return AF4_(1.0)/sqrt(x);}
function AF1 (line 747) | AF1 ASatF1(AF1 x){return clamp(x,AF1_(0.0),AF1_(1.0));}
function AF2 (line 748) | AF2 ASatF2(AF2 x){return clamp(x,AF2_(0.0),AF2_(1.0));}
function AF3 (line 749) | AF3 ASatF3(AF3 x){return clamp(x,AF3_(0.0),AF3_(1.0));}
function AF4 (line 750) | AF4 ASatF4(AF4 x){return clamp(x,AF4_(0.0),AF4_(1.0));}
function AU1 (line 752) | AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));}
function AU2 (line 753) | AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));}
function AU3 (line 754) | AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));}
function AU4 (line 755) | AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));}
function AB1 (line 773) | AB1 AB1_x(AB1 a){return AB1(a);}
function AB2 (line 774) | AB2 AB2_x(AB1 a){return AB2(a,a);}
function AB3 (line 775) | AB3 AB3_x(AB1 a){return AB3(a,a,a);}
function AB4 (line 776) | AB4 AB4_x(AB1 a){return AB4(a,a,a,a);}
function AH4 (line 805) | AH4 AH4_AU2_x(AU2 x){return AH4(unpackFloat2x16(x.x),unpackFloat2x16(x.y...
function AU2 (line 811) | AU2 AU2_AH4_x(AH4 x){return AU2(packFloat2x16(x.xy),packFloat2x16(x.zw));}
function AH1 (line 826) | AH1 AH1_x(AH1 a){return AH1(a);}
function AH2 (line 827) | AH2 AH2_x(AH1 a){return AH2(a,a);}
function AH3 (line 828) | AH3 AH3_x(AH1 a){return AH3(a,a,a);}
function AH4 (line 829) | AH4 AH4_x(AH1 a){return AH4(a,a,a,a);}
function AW1 (line 835) | AW1 AW1_x(AW1 a){return AW1(a);}
function AW2 (line 836) | AW2 AW2_x(AW1 a){return AW2(a,a);}
function AW3 (line 837) | AW3 AW3_x(AW1 a){return AW3(a,a,a);}
function AW4 (line 838) | AW4 AW4_x(AW1 a){return AW4(a,a,a,a);}
function AW1 (line 844) | AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));}
function AW2 (line 845) | AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));}
function AW3 (line 846) | AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));}
function AW4 (line 847) | AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));}
function AH1 (line 849) | AH1 AClampH1(AH1 x,AH1 n,AH1 m){return clamp(x,n,m);}
function AH2 (line 850) | AH2 AClampH2(AH2 x,AH2 n,AH2 m){return clamp(x,n,m);}
function AH3 (line 851) | AH3 AClampH3(AH3 x,AH3 n,AH3 m){return clamp(x,n,m);}
function AH4 (line 852) | AH4 AClampH4(AH4 x,AH4 n,AH4 m){return clamp(x,n,m);}
function AH1 (line 854) | AH1 AFractH1(AH1 x){return fract(x);}
function AH2 (line 855) | AH2 AFractH2(AH2 x){return fract(x);}
function AH3 (line 856) | AH3 AFractH3(AH3 x){return fract(x);}
function AH4 (line 857) | AH4 AFractH4(AH4 x){return fract(x);}
function AH1 (line 859) | AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return mix(x,y,a);}
function AH2 (line 860) | AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return mix(x,y,a);}
function AH3 (line 861) | AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return mix(x,y,a);}
function AH4 (line 862) | AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return mix(x,y,a);}
function AH1 (line 865) | AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));}
function AH2 (line 866) | AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));}
function AH3 (line 867) | AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));}
function AH4 (line 868) | AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));}
function AW1 (line 870) | AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));}
function AW2 (line 871) | AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));}
function AW3 (line 872) | AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));}
function AW4 (line 873) | AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));}
function AH1 (line 876) | AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));}
function AH2 (line 877) | AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));}
function AH3 (line 878) | AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));}
function AH4 (line 879) | AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));}
function AW1 (line 881) | AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));}
function AW2 (line 882) | AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));}
function AW3 (line 883) | AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));}
function AW4 (line 884) | AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));}
function AH1 (line 886) | AH1 ARcpH1(AH1 x){return AH1_(1.0)/x;}
function AH2 (line 887) | AH2 ARcpH2(AH2 x){return AH2_(1.0)/x;}
function AH3 (line 888) | AH3 ARcpH3(AH3 x){return AH3_(1.0)/x;}
function AH4 (line 889) | AH4 ARcpH4(AH4 x){return AH4_(1.0)/x;}
function AH1 (line 891) | AH1 ARsqH1(AH1 x){return AH1_(1.0)/sqrt(x);}
function AH2 (line 892) | AH2 ARsqH2(AH2 x){return AH2_(1.0)/sqrt(x);}
function AH3 (line 893) | AH3 ARsqH3(AH3 x){return AH3_(1.0)/sqrt(x);}
function AH4 (line 894) | AH4 ARsqH4(AH4 x){return AH4_(1.0)/sqrt(x);}
function AH1 (line 896) | AH1 ASatH1(AH1 x){return clamp(x,AH1_(0.0),AH1_(1.0));}
function AH2 (line 897) | AH2 ASatH2(AH2 x){return clamp(x,AH2_(0.0),AH2_(1.0));}
function AH3 (line 898) | AH3 ASatH3(AH3 x){return clamp(x,AH3_(0.0),AH3_(1.0));}
function AH4 (line 899) | AH4 ASatH4(AH4 x){return clamp(x,AH4_(0.0),AH4_(1.0));}
function AW1 (line 901) | AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));}
function AW2 (line 902) | AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));}
function AW3 (line 903) | AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));}
function AW4 (line 904) | AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));}
function AD1 (line 918) | AD1 AD1_x(AD1 a){return AD1(a);}
function AD2 (line 919) | AD2 AD2_x(AD1 a){return AD2(a,a);}
function AD3 (line 920) | AD3 AD3_x(AD1 a){return AD3(a,a,a);}
function AD4 (line 921) | AD4 AD4_x(AD1 a){return AD4(a,a,a,a);}
function AD1 (line 927) | AD1 AFractD1(AD1 x){return fract(x);}
function AD2 (line 928) | AD2 AFractD2(AD2 x){return fract(x);}
function AD3 (line 929) | AD3 AFractD3(AD3 x){return fract(x);}
function AD4 (line 930) | AD4 AFractD4(AD4 x){return fract(x);}
function AD1 (line 932) | AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return mix(x,y,a);}
function AD2 (line 933) | AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return mix(x,y,a);}
function AD3 (line 934) | AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return mix(x,y,a);}
function AD4 (line 935) | AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return mix(x,y,a);}
function AD1 (line 937) | AD1 ARcpD1(AD1 x){return AD1_(1.0)/x;}
function AD2 (line 938) | AD2 ARcpD2(AD2 x){return AD2_(1.0)/x;}
function AD3 (line 939) | AD3 ARcpD3(AD3 x){return AD3_(1.0)/x;}
function AD4 (line 940) | AD4 ARcpD4(AD4 x){return AD4_(1.0)/x;}
function AD1 (line 942) | AD1 ARsqD1(AD1 x){return AD1_(1.0)/sqrt(x);}
function AD2 (line 943) | AD2 ARsqD2(AD2 x){return AD2_(1.0)/sqrt(x);}
function AD3 (line 944) | AD3 ARsqD3(AD3 x){return AD3_(1.0)/sqrt(x);}
function AD4 (line 945) | AD4 ARsqD4(AD4 x){return AD4_(1.0)/sqrt(x);}
function AD1 (line 947) | AD1 ASatD1(AD1 x){return clamp(x,AD1_(0.0),AD1_(1.0));}
function AD2 (line 948) | AD2 ASatD2(AD2 x){return clamp(x,AD2_(0.0),AD2_(1.0));}
function AD3 (line 949) | AD3 ASatD3(AD3 x){return clamp(x,AD3_(0.0),AD3_(1.0));}
function AD4 (line 950) | AD4 ASatD4(AD4 x){return clamp(x,AD4_(0.0),AD4_(1.0));}
function AL1 (line 972) | AL1 AL1_x(AL1 a){return AL1(a);}
function AL2 (line 973) | AL2 AL2_x(AL1 a){return AL2(a,a);}
function AL3 (line 974) | AL3 AL3_x(AL1 a){return AL3(a,a,a);}
function AL4 (line 975) | AL4 AL4_x(AL1 a){return AL4(a,a,a,a);}
function AL1 (line 981) | AL1 AAbsSL1(AL1 a){return AL1(abs(ASL1(a)));}
function AL2 (line 982) | AL2 AAbsSL2(AL2 a){return AL2(abs(ASL2(a)));}
function AL3 (line 983) | AL3 AAbsSL3(AL3 a){return AL3(abs(ASL3(a)));}
function AL4 (line 984) | AL4 AAbsSL4(AL4 a){return AL4(abs(ASL4(a)));}
function AL1 (line 986) | AL1 AMaxSL1(AL1 a,AL1 b){return AL1(max(ASU1(a),ASU1(b)));}
function AL2 (line 987) | AL2 AMaxSL2(AL2 a,AL2 b){return AL2(max(ASU2(a),ASU2(b)));}
function AL3 (line 988) | AL3 AMaxSL3(AL3 a,AL3 b){return AL3(max(ASU3(a),ASU3(b)));}
function AL4 (line 989) | AL4 AMaxSL4(AL4 a,AL4 b){return AL4(max(ASU4(a),ASU4(b)));}
function AL1 (line 991) | AL1 AMinSL1(AL1 a,AL1 b){return AL1(min(ASU1(a),ASU1(b)));}
function AL2 (line 992) | AL2 AMinSL2(AL2 a,AL2 b){return AL2(min(ASU2(a),ASU2(b)));}
function AL3 (line 993) | AL3 AMinSL3(AL3 a,AL3 b){return AL3(min(ASU3(a),ASU3(b)));}
function AL4 (line 994) | AL4 AMinSL4(AL4 a,AL4 b){return AL4(min(ASU4(a),ASU4(b)));}
function AF1 (line 1004) | AF1 AWaveXorF1(AF1 v,AU1 x){return subgroupShuffleXor(v,x);}
function AF2 (line 1005) | AF2 AWaveXorF2(AF2 v,AU1 x){return subgroupShuffleXor(v,x);}
function AF3 (line 1006) | AF3 AWaveXorF3(AF3 v,AU1 x){return subgroupShuffleXor(v,x);}
function AF4 (line 1007) | AF4 AWaveXorF4(AF4 v,AU1 x){return subgroupShuffleXor(v,x);}
function AU1 (line 1008) | AU1 AWaveXorU1(AU1 v,AU1 x){return subgroupShuffleXor(v,x);}
function AU2 (line 1009) | AU2 AWaveXorU2(AU2 v,AU1 x){return subgroupShuffleXor(v,x);}
function AU3 (line 1010) | AU3 AWaveXorU3(AU3 v,AU1 x){return subgroupShuffleXor(v,x);}
function AU4 (line 1011) | AU4 AWaveXorU4(AU4 v,AU1 x){return subgroupShuffleXor(v,x);}
function AH2 (line 1014) | AH2 AWaveXorH2(AH2 v,AU1 x){return AH2_AU1(subgroupShuffleXor(AU1_AH2(v)...
function AH4 (line 1015) | AH4 AWaveXorH4(AH4 v,AU1 x){return AH4_AU2(subgroupShuffleXor(AU2_AH4(v)...
function AW2 (line 1016) | AW2 AWaveXorW2(AW2 v,AU1 x){return AW2_AU1(subgroupShuffleXor(AU1_AW2(v)...
function AW4 (line 1017) | AW4 AWaveXorW4(AW4 v,AU1 x){return AW4_AU2(subgroupShuffleXor(AU2_AW4(v)...
function AU1 (line 1089) | AU1 AU1_AH1_AF1_x(AF1 a){return f32tof16(a);}
function AU1 (line 1092) | AU1 AU1_AH2_AF2_x(AF2 a){return f32tof16(a.x)|(f32tof16(a.y)<<16);}
function AF2 (line 1096) | AF2 AF2_AH2_AU1_x(AU1 x){return AF2(f16tof32(x&0xFFFF),f16tof32(x>>16));}
function AF1 (line 1099) | AF1 AF1_x(AF1 a){return AF1(a);}
function AF2 (line 1100) | AF2 AF2_x(AF1 a){return AF2(a,a);}
function AF3 (line 1101) | AF3 AF3_x(AF1 a){return AF3(a,a,a);}
function AF4 (line 1102) | AF4 AF4_x(AF1 a){return AF4(a,a,a,a);}
function AU1 (line 1108) | AU1 AU1_x(AU1 a){return AU1(a);}
function AU2 (line 1109) | AU2 AU2_x(AU1 a){return AU2(a,a);}
function AU3 (line 1110) | AU3 AU3_x(AU1 a){return AU3(a,a,a);}
function AU4 (line 1111) | AU4 AU4_x(AU1 a){return AU4(a,a,a,a);}
function AU1 (line 1117) | AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));}
function AU2 (line 1118) | AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));}
function AU3 (line 1119) | AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));}
function AU4 (line 1120) | AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));}
function AU1 (line 1122) | AU1 ABfe(AU1 src,AU1 off,AU1 bits){AU1 mask=(1u<<bits)-1;return (src>>of...
function AU1 (line 1123) | AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));}
function AU1 (line 1124) | AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){AU1 mask=(1u<<bits)-1;return (ins&ma...
function AF1 (line 1126) | AF1 AClampF1(AF1 x,AF1 n,AF1 m){return max(n,min(x,m));}
function AF2 (line 1127) | AF2 AClampF2(AF2 x,AF2 n,AF2 m){return max(n,min(x,m));}
function AF3 (line 1128) | AF3 AClampF3(AF3 x,AF3 n,AF3 m){return max(n,min(x,m));}
function AF4 (line 1129) | AF4 AClampF4(AF4 x,AF4 n,AF4 m){return max(n,min(x,m));}
function AF1 (line 1131) | AF1 AFractF1(AF1 x){return x-floor(x);}
function AF2 (line 1132) | AF2 AFractF2(AF2 x){return x-floor(x);}
function AF3 (line 1133) | AF3 AFractF3(AF3 x){return x-floor(x);}
function AF4 (line 1134) | AF4 AFractF4(AF4 x){return x-floor(x);}
function AF1 (line 1136) | AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return lerp(x,y,a);}
function AF2 (line 1137) | AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return lerp(x,y,a);}
function AF3 (line 1138) | AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return lerp(x,y,a);}
function AF4 (line 1139) | AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return lerp(x,y,a);}
function AF1 (line 1141) | AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));}
function AF2 (line 1142) | AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));}
function AF3 (line 1143) | AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));}
function AF4 (line 1144) | AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));}
function AU1 (line 1146) | AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(...
function AU2 (line 1147) | AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(...
function AU3 (line 1148) | AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(...
function AU4 (line 1149) | AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(...
function AU1 (line 1151) | AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));}
function AU2 (line 1152) | AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));}
function AU3 (line 1153) | AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));}
function AU4 (line 1154) | AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));}
function AU1 (line 1156) | AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));}
function AU2 (line 1157) | AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));}
function AU3 (line 1158) | AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));}
function AU4 (line 1159) | AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));}
function AF1 (line 1161) | AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));}
function AF2 (line 1162) | AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));}
function AF3 (line 1163) | AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));}
function AF4 (line 1164) | AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));}
function AF1 (line 1166) | AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));}
function AF2 (line 1167) | AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));}
function AF3 (line 1168) | AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));}
function AF4 (line 1169) | AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));}
function AU1 (line 1171) | AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(...
function AU2 (line 1172) | AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(...
function AU3 (line 1173) | AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(...
function AU4 (line 1174) | AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(...
function AU1 (line 1176) | AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));}
function AU2 (line 1177) | AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));}
function AU3 (line 1178) | AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));}
function AU4 (line 1179) | AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));}
function AU1 (line 1181) | AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));}
function AU2 (line 1182) | AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));}
function AU3 (line 1183) | AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));}
function AU4 (line 1184) | AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));}
function AF1 (line 1186) | AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));}
function AF2 (line 1187) | AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));}
function AF3 (line 1188) | AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));}
function AF4 (line 1189) | AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));}
function AF1 (line 1191) | AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));}
function AF2 (line 1192) | AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));}
function AF3 (line 1193) | AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));}
function AF4 (line 1194) | AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));}
function AF1 (line 1196) | AF1 ARcpF1(AF1 x){return rcp(x);}
function AF2 (line 1197) | AF2 ARcpF2(AF2 x){return rcp(x);}
function AF3 (line 1198) | AF3 ARcpF3(AF3 x){return rcp(x);}
function AF4 (line 1199) | AF4 ARcpF4(AF4 x){return rcp(x);}
function AF1 (line 1201) | AF1 ARsqF1(AF1 x){return rsqrt(x);}
function AF2 (line 1202) | AF2 ARsqF2(AF2 x){return rsqrt(x);}
function AF3 (line 1203) | AF3 ARsqF3(AF3 x){return rsqrt(x);}
function AF4 (line 1204) | AF4 ARsqF4(AF4 x){return rsqrt(x);}
function AF1 (line 1206) | AF1 ASatF1(AF1 x){return saturate(x);}
function AF2 (line 1207) | AF2 ASatF2(AF2 x){return saturate(x);}
function AF3 (line 1208) | AF3 ASatF3(AF3 x){return saturate(x);}
function AF4 (line 1209) | AF4 ASatF4(AF4 x){return saturate(x);}
function AU1 (line 1211) | AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));}
function AU2 (line 1212) | AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));}
function AU3 (line 1213) | AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));}
function AU4 (line 1214) | AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));}
function AH2 (line 1264) | AH2 AH2_AU1_x(AU1 x){AF2 t=f16tof32(AU2(x&0xFFFF,x>>16));return AH2(t);}
function AH4 (line 1265) | AH4 AH4_AU2_x(AU2 x){return AH4(AH2_AU1_x(x.x),AH2_AU1_x(x.y));}
function AW2 (line 1266) | AW2 AW2_AU1_x(AU1 x){AU2 t=AU2(x&0xFFFF,x>>16);return AW2(t);}
function AW4 (line 1267) | AW4 AW4_AU2_x(AU2 x){return AW4(AW2_AU1_x(x.x),AW2_AU1_x(x.y));}
function AU1 (line 1273) | AU1 AU1_AH2_x(AH2 x){return f32tof16(x.x)+(f32tof16(x.y)<<16);}
function AU2 (line 1274) | AU2 AU2_AH4_x(AH4 x){return AU2(AU1_AH2_x(x.xy),AU1_AH2_x(x.zw));}
function AU1 (line 1275) | AU1 AU1_AW2_x(AW2 x){return AU1(x.x)+(AU1(x.y)<<16);}
function AU2 (line 1276) | AU2 AU2_AW4_x(AW4 x){return AU2(AU1_AW2_x(x.xy),AU1_AW2_x(x.zw));}
function AH1 (line 1306) | AH1 AH1_x(AH1 a){return AH1(a);}
function AH2 (line 1307) | AH2 AH2_x(AH1 a){return AH2(a,a);}
function AH3 (line 1308) | AH3 AH3_x(AH1 a){return AH3(a,a,a);}
function AH4 (line 1309) | AH4 AH4_x(AH1 a){return AH4(a,a,a,a);}
function AW1 (line 1315) | AW1 AW1_x(AW1 a){return AW1(a);}
function AW2 (line 1316) | AW2 AW2_x(AW1 a){return AW2(a,a);}
function AW3 (line 1317) | AW3 AW3_x(AW1 a){return AW3(a,a,a);}
function AW4 (line 1318) | AW4 AW4_x(AW1 a){return AW4(a,a,a,a);}
function AW1 (line 1324) | AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));}
function AW2 (line 1325) | AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));}
function AW3 (line 1326) | AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));}
function AW4 (line 1327) | AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));}
function AH1 (line 1329) | AH1 AClampH1(AH1 x,AH1 n,AH1 m){return max(n,min(x,m));}
function AH2 (line 1330) | AH2 AClampH2(AH2 x,AH2 n,AH2 m){return max(n,min(x,m));}
function AH3 (line 1331) | AH3 AClampH3(AH3 x,AH3 n,AH3 m){return max(n,min(x,m));}
function AH4 (line 1332) | AH4 AClampH4(AH4 x,AH4 n,AH4 m){return max(n,min(x,m));}
function AH1 (line 1335) | AH1 AFractH1(AH1 x){return x-floor(x);}
function AH2 (line 1336) | AH2 AFractH2(AH2 x){return x-floor(x);}
function AH3 (line 1337) | AH3 AFractH3(AH3 x){return x-floor(x);}
function AH4 (line 1338) | AH4 AFractH4(AH4 x){return x-floor(x);}
function AH1 (line 1340) | AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return lerp(x,y,a);}
function AH2 (line 1341) | AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return lerp(x,y,a);}
function AH3 (line 1342) | AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return lerp(x,y,a);}
function AH4 (line 1343) | AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return lerp(x,y,a);}
function AH1 (line 1345) | AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));}
function AH2 (line 1346) | AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));}
function AH3 (line 1347) | AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));}
function AH4 (line 1348) | AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));}
function AW1 (line 1350) | AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));}
function AW2 (line 1351) | AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));}
function AW3 (line 1352) | AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));}
function AW4 (line 1353) | AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));}
function AH1 (line 1355) | AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));}
function AH2 (line 1356) | AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));}
function AH3 (line 1357) | AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));}
function AH4 (line 1358) | AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));}
function AW1 (line 1360) | AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));}
function AW2 (line 1361) | AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));}
function AW3 (line 1362) | AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));}
function AW4 (line 1363) | AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));}
function AH1 (line 1365) | AH1 ARcpH1(AH1 x){return rcp(x);}
function AH2 (line 1366) | AH2 ARcpH2(AH2 x){return rcp(x);}
function AH3 (line 1367) | AH3 ARcpH3(AH3 x){return rcp(x);}
function AH4 (line 1368) | AH4 ARcpH4(AH4 x){return rcp(x);}
function AH1 (line 1370) | AH1 ARsqH1(AH1 x){return rsqrt(x);}
function AH2 (line 1371) | AH2 ARsqH2(AH2 x){return rsqrt(x);}
function AH3 (line 1372) | AH3 ARsqH3(AH3 x){return rsqrt(x);}
function AH4 (line 1373) | AH4 ARsqH4(AH4 x){return rsqrt(x);}
function AH1 (line 1375) | AH1 ASatH1(AH1 x){return saturate(x);}
function AH2 (line 1376) | AH2 ASatH2(AH2 x){return saturate(x);}
function AH3 (line 1377) | AH3 ASatH3(AH3 x){return saturate(x);}
function AH4 (line 1378) | AH4 ASatH4(AH4 x){return saturate(x);}
function AW1 (line 1380) | AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));}
function AW2 (line 1381) | AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));}
function AW3 (line 1382) | AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));}
function AW4 (line 1383) | AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));}
function AD1 (line 1404) | AD1 AD1_x(AD1 a){return AD1(a);}
function AD2 (line 1405) | AD2 AD2_x(AD1 a){return AD2(a,a);}
function AD3 (line 1406) | AD3 AD3_x(AD1 a){return AD3(a,a,a);}
function AD4 (line 1407) | AD4 AD4_x(AD1 a){return AD4(a,a,a,a);}
function AD1 (line 1413) | AD1 AFractD1(AD1 a){return a-floor(a);}
function AD2 (line 1414) | AD2 AFractD2(AD2 a){return a-floor(a);}
function AD3 (line 1415) | AD3 AFractD3(AD3 a){return a-floor(a);}
function AD4 (line 1416) | AD4 AFractD4(AD4 a){return a-floor(a);}
function AD1 (line 1418) | AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return lerp(x,y,a);}
function AD2 (line 1419) | AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return lerp(x,y,a);}
function AD3 (line 1420) | AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return lerp(x,y,a);}
function AD4 (line 1421) | AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return lerp(x,y,a);}
function AD1 (line 1423) | AD1 ARcpD1(AD1 x){return rcp(x);}
function AD2 (line 1424) | AD2 ARcpD2(AD2 x){return rcp(x);}
function AD3 (line 1425) | AD3 ARcpD3(AD3 x){return rcp(x);}
function AD4 (line 1426) | AD4 ARcpD4(AD4 x){return rcp(x);}
function AD1 (line 1428) | AD1 ARsqD1(AD1 x){return rsqrt(x);}
function AD2 (line 1429) | AD2 ARsqD2(AD2 x){return rsqrt(x);}
function AD3 (line 1430) | AD3 ARsqD3(AD3 x){return rsqrt(x);}
function AD4 (line 1431) | AD4 ARsqD4(AD4 x){return rsqrt(x);}
function AD1 (line 1433) | AD1 ASatD1(AD1 x){return saturate(x);}
function AD2 (line 1434) | AD2 ASatD2(AD2 x){return saturate(x);}
function AD3 (line 1435) | AD3 ASatD3(AD3 x){return saturate(x);}
function AD4 (line 1436) | AD4 ASatD4(AD4 x){return saturate(x);}
function AF1 (line 1443) | AF1 AWaveXorF1(AF1 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
function AF2 (line 1444) | AF2 AWaveXorF2(AF2 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
function AF3 (line 1445) | AF3 AWaveXorF3(AF3 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
function AF4 (line 1446) | AF4 AWaveXorF4(AF4 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
function AU1 (line 1447) | AU1 AWaveXorU1(AU1 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
function AU2 (line 1448) | AU2 AWaveXorU1(AU2 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
function AU3 (line 1449) | AU3 AWaveXorU1(AU3 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
function AU4 (line 1450) | AU4 AWaveXorU1(AU4 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
function AH2 (line 1453) | AH2 AWaveXorH2(AH2 v,AU1 x){return AH2_AU1(WaveReadLaneAt(AU1_AH2(v),Wav...
function AH4 (line 1454) | AH4 AWaveXorH4(AH4 v,AU1 x){return AH4_AU2(WaveReadLaneAt(AU2_AH4(v),Wav...
function AW2 (line 1455) | AW2 AWaveXorW2(AW2 v,AU1 x){return AW2_AU1(WaveReadLaneAt(AU1_AW2(v),Wav...
function AW4 (line 1456) | AW4 AWaveXorW4(AW4 v,AU1 x){return AW4_AU1(WaveReadLaneAt(AU1_AW4(v),Wav...
function AF1 (line 1481) | AF1 ACpySgnF1(AF1 d,AF1 s){return AF1_AU1(AU1_AF1(d)|(AU1_AF1(s)&AU1_(0x...
function AF2 (line 1482) | AF2 ACpySgnF2(AF2 d,AF2 s){return AF2_AU2(AU2_AF2(d)|(AU2_AF2(s)&AU2_(0x...
function AF3 (line 1483) | AF3 ACpySgnF3(AF3 d,AF3 s){return AF3_AU3(AU3_AF3(d)|(AU3_AF3(s)&AU3_(0x...
function AF4 (line 1484) | AF4 ACpySgnF4(AF4 d,AF4 s){return AF4_AU4(AU4_AF4(d)|(AU4_AF4(s)&AU4_(0x...
function AF1 (line 1494) | AF1 ASignedF1(AF1 m){return ASatF1(m*AF1_(A_INFN_F));}
function AF2 (line 1495) | AF2 ASignedF2(AF2 m){return ASatF2(m*AF2_(A_INFN_F));}
function AF3 (line 1496) | AF3 ASignedF3(AF3 m){return ASatF3(m*AF3_(A_INFN_F));}
function AF4 (line 1497) | AF4 ASignedF4(AF4 m){return ASatF4(m*AF4_(A_INFN_F));}
function AF1 (line 1499) | AF1 AGtZeroF1(AF1 m){return ASatF1(m*AF1_(A_INFP_F));}
function AF2 (line 1500) | AF2 AGtZeroF2(AF2 m){return ASatF2(m*AF2_(A_INFP_F));}
function AF3 (line 1501) | AF3 AGtZeroF3(AF3 m){return ASatF3(m*AF3_(A_INFP_F));}
function AF4 (line 1502) | AF4 AGtZeroF4(AF4 m){return ASatF4(m*AF4_(A_INFP_F));}
function AH1 (line 1514) | AH1 ACpySgnH1(AH1 d,AH1 s){return AH1_AW1(AW1_AH1(d)|(AW1_AH1(s)&AW1_(0x...
function AH2 (line 1515) | AH2 ACpySgnH2(AH2 d,AH2 s){return AH2_AW2(AW2_AH2(d)|(AW2_AH2(s)&AW2_(0x...
function AH3 (line 1516) | AH3 ACpySgnH3(AH3 d,AH3 s){return AH3_AW3(AW3_AH3(d)|(AW3_AH3(s)&AW3_(0x...
function AH4 (line 1517) | AH4 ACpySgnH4(AH4 d,AH4 s){return AH4_AW4(AW4_AH4(d)|(AW4_AH4(s)&AW4_(0x...
function AH1 (line 1519) | AH1 ASignedH1(AH1 m){return ASatH1(m*AH1_(A_INFN_H));}
function AH2 (line 1520) | AH2 ASignedH2(AH2 m){return ASatH2(m*AH2_(A_INFN_H));}
function AH3 (line 1521) | AH3 ASignedH3(AH3 m){return ASatH3(m*AH3_(A_INFN_H));}
function AH4 (line 1522) | AH4 ASignedH4(AH4 m){return ASatH4(m*AH4_(A_INFN_H));}
function AH1 (line 1524) | AH1 AGtZeroH1(AH1 m){return ASatH1(m*AH1_(A_INFP_H));}
function AH2 (line 1525) | AH2 AGtZeroH2(AH2 m){return ASatH2(m*AH2_(A_INFP_H));}
function AH3 (line 1526) | AH3 AGtZeroH3(AH3 m){return ASatH3(m*AH3_(A_INFP_H));}
function AH4 (line 1527) | AH4 AGtZeroH4(AH4 m){return ASatH4(m*AH4_(A_INFP_H));}
function AU1 (line 1546) | AU1 AFisToU1(AU1 x){return x^(( AShrSU1(x,AU1_(31)))|AU1_(0x80000000));}
function AU1 (line 1547) | AU1 AFisFromU1(AU1 x){return x^((~AShrSU1(x,AU1_(31)))|AU1_(0x80000000));}
function AU1 (line 1550) | AU1 AFisToHiU1(AU1 x){return x^(( AShrSU1(x,AU1_(15)))|AU1_(0x80000000));}
function AU1 (line 1551) | AU1 AFisFromHiU1(AU1 x){return x^((~AShrSU1(x,AU1_(15)))|AU1_(0x80000000...
function AW1 (line 1554) | AW1 AFisToW1(AW1 x){return x^(( AShrSW1(x,AW1_(15)))|AW1_(0x8000));}
function AW1 (line 1555) | AW1 AFisFromW1(AW1 x){return x^((~AShrSW1(x,AW1_(15)))|AW1_(0x8000));}
function AW2 (line 1557) | AW2 AFisToW2(AW2 x){return x^(( AShrSW2(x,AW2_(15)))|AW2_(0x8000));}
function AW2 (line 1558) | AW2 AFisFromW2(AW2 x){return x^((~AShrSW2(x,AW2_(15)))|AW2_(0x8000));}
function AU1 (line 1578) | AU1 APerm0E0A(AU2 i){return((i.x )&0xffu)|((i.y<<16)&0xff0000u);}
function AU1 (line 1579) | AU1 APerm0F0B(AU2 i){return((i.x>> 8)&0xffu)|((i.y<< 8)&0xff0000u);}
function AU1 (line 1580) | AU1 APerm0G0C(AU2 i){return((i.x>>16)&0xffu)|((i.y )&0xff0000u);}
function AU1 (line 1581) | AU1 APerm0H0D(AU2 i){return((i.x>>24)&0xffu)|((i.y>> 8)&0xff0000u);}
function AU1 (line 1583) | AU1 APermHGFA(AU2 i){return((i.x )&0x000000ffu)|(i.y&0xffffff00u);}
function AU1 (line 1584) | AU1 APermHGFC(AU2 i){return((i.x>>16)&0x000000ffu)|(i.y&0xffffff00u);}
function AU1 (line 1585) | AU1 APermHGAE(AU2 i){return((i.x<< 8)&0x0000ff00u)|(i.y&0xffff00ffu);}
function AU1 (line 1586) | AU1 APermHGCE(AU2 i){return((i.x>> 8)&0x0000ff00u)|(i.y&0xffff00ffu);}
function AU1 (line 1587) | AU1 APermHAFE(AU2 i){return((i.x<<16)&0x00ff0000u)|(i.y&0xff00ffffu);}
function AU1 (line 1588) | AU1 APermHCFE(AU2 i){return((i.x )&0x00ff0000u)|(i.y&0xff00ffffu);}
function AU1 (line 1589) | AU1 APermAGFE(AU2 i){return((i.x<<24)&0xff000000u)|(i.y&0x00ffffffu);}
function AU1 (line 1590) | AU1 APermCGFE(AU2 i){return((i.x<< 8)&0xff000000u)|(i.y&0x00ffffffu);}
function AU1 (line 1592) | AU1 APermGCEA(AU2 i){return((i.x)&0x00ff00ffu)|((i.y<<8)&0xff00ff00u);}
function AU1 (line 1593) | AU1 APermGECA(AU2 i){return(((i.x)&0xffu)|((i.x>>8)&0xff00u)|((i.y<<16)&...
function AU1 (line 1660) | AU1 ABuc0ToU1(AU1 d,AF1 i){return (d&0xffffff00u)|((min(AU1(i),255u) ...
function AU1 (line 1661) | AU1 ABuc1ToU1(AU1 d,AF1 i){return (d&0xffff00ffu)|((min(AU1(i),255u)<< 8...
function AU1 (line 1662) | AU1 ABuc2ToU1(AU1 d,AF1 i){return (d&0xff00ffffu)|((min(AU1(i),255u)<<16...
function AU1 (line 1663) | AU1 ABuc3ToU1(AU1 d,AF1 i){return (d&0x00ffffffu)|((min(AU1(i),255u)<<24...
function AF1 (line 1666) | AF1 ABuc0FromU1(AU1 i){return AF1((i )&255u);}
function AF1 (line 1667) | AF1 ABuc1FromU1(AU1 i){return AF1((i>> 8)&255u);}
function AF1 (line 1668) | AF1 ABuc2FromU1(AU1 i){return AF1((i>>16)&255u);}
function AF1 (line 1669) | AF1 ABuc3FromU1(AU1 i){return AF1((i>>24)&255u);}
function AW2 (line 1674) | AW2 ABuc01ToW2(AH2 x,AH2 y){x*=AH2_(1.0/32768.0);y*=AH2_(1.0/32768.0);
function AU2 (line 1678) | AU2 ABuc0ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
function AU2 (line 1680) | AU2 ABuc1ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
function AU2 (line 1682) | AU2 ABuc2ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
function AU2 (line 1684) | AU2 ABuc3ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
function AH2 (line 1688) | AH2 ABuc0FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)))*AH2_(32768....
function AH2 (line 1689) | AH2 ABuc1FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)))*AH2_(32768....
function AH2 (line 1690) | AH2 ABuc2FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)))*AH2_(32768....
function AH2 (line 1691) | AH2 ABuc3FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)))*AH2_(32768....
function AU1 (line 1728) | AU1 ABsc0ToU1(AU1 d,AF1 i){return (d&0xffffff00u)|((min(AU1(i+128.0),255...
function AU1 (line 1729) | AU1 ABsc1ToU1(AU1 d,AF1 i){return (d&0xffff00ffu)|((min(AU1(i+128.0),255...
function AU1 (line 1730) | AU1 ABsc2ToU1(AU1 d,AF1 i){return (d&0xff00ffffu)|((min(AU1(i+128.0),255...
function AU1 (line 1731) | AU1 ABsc3ToU1(AU1 d,AF1 i){return (d&0x00ffffffu)|((min(AU1(i+128.0),255...
function AU1 (line 1733) | AU1 ABsc0ToZbU1(AU1 d,AF1 i){return ((d&0xffffff00u)|((min(AU1(trunc(i)+...
function AU1 (line 1734) | AU1 ABsc1ToZbU1(AU1 d,AF1 i){return ((d&0xffff00ffu)|((min(AU1(trunc(i)+...
function AU1 (line 1735) | AU1 ABsc2ToZbU1(AU1 d,AF1 i){return ((d&0xff00ffffu)|((min(AU1(trunc(i)+...
function AU1 (line 1736) | AU1 ABsc3ToZbU1(AU1 d,AF1 i){return ((d&0x00ffffffu)|((min(AU1(trunc(i)+...
function AF1 (line 1738) | AF1 ABsc0FromU1(AU1 i){return AF1((i )&255u)-128.0;}
function AF1 (line 1739) | AF1 ABsc1FromU1(AU1 i){return AF1((i>> 8)&255u)-128.0;}
function AF1 (line 1740) | AF1 ABsc2FromU1(AU1 i){return AF1((i>>16)&255u)-128.0;}
function AF1 (line 1741) | AF1 ABsc3FromU1(AU1 i){return AF1((i>>24)&255u)-128.0;}
function AF1 (line 1743) | AF1 ABsc0FromZbU1(AU1 i){return AF1(((i )&255u)^0x80u)-128.0;}
function AF1 (line 1744) | AF1 ABsc1FromZbU1(AU1 i){return AF1(((i>> 8)&255u)^0x80u)-128.0;}
function AF1 (line 1745) | AF1 ABsc2FromZbU1(AU1 i){return AF1(((i>>16)&255u)^0x80u)-128.0;}
function AF1 (line 1746) | AF1 ABsc3FromZbU1(AU1 i){return AF1(((i>>24)&255u)^0x80u)-128.0;}
function AW2 (line 1751) | AW2 ABsc01ToW2(AH2 x,AH2 y){x=x*AH2_(1.0/32768.0)+AH2_(0.25/32768.0);y=y...
function AU2 (line 1754) | AU2 ABsc0ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2...
function AU2 (line 1756) | AU2 ABsc1ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2...
function AU2 (line 1758) | AU2 ABsc2ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2...
function AU2 (line 1760) | AU2 ABsc3ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2...
function AU2 (line 1763) | AU2 ABsc0ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+A...
function AU2 (line 1765) | AU2 ABsc1ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+A...
function AU2 (line 1767) | AU2 ABsc2ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+A...
function AU2 (line 1769) | AU2 ABsc3ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+A...
function AH2 (line 1772) | AH2 ABsc0FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)))*AH2_(32768....
function AH2 (line 1773) | AH2 ABsc1FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)))*AH2_(32768....
function AH2 (line 1774) | AH2 ABsc2FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)))*AH2_(32768....
function AH2 (line 1775) | AH2 ABsc3FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)))*AH2_(32768....
function AH2 (line 1777) | AH2 ABsc0FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)^0x00800080u...
function AH2 (line 1778) | AH2 ABsc1FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)^0x00800080u...
function AH2 (line 1779) | AH2 ABsc2FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)^0x00800080u...
function AH2 (line 1780) | AH2 ABsc3FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)^0x00800080u...
function AH1 (line 1801) | AH1 APrxLoSqrtH1(AH1 a){return AH1_AW1((AW1_AH1(a)>>AW1_(1))+AW1_(0x1de2...
function AH2 (line 1802) | AH2 APrxLoSqrtH2(AH2 a){return AH2_AW2((AW2_AH2(a)>>AW2_(1))+AW2_(0x1de2...
function AH3 (line 1803) | AH3 APrxLoSqrtH3(AH3 a){return AH3_AW3((AW3_AH3(a)>>AW3_(1))+AW3_(0x1de2...
function AH4 (line 1804) | AH4 APrxLoSqrtH4(AH4 a){return AH4_AW4((AW4_AH4(a)>>AW4_(1))+AW4_(0x1de2...
function AH1 (line 1808) | AH1 APrxLoRcpH1(AH1 a){return AH1_AW1(AW1_(0x7784)-AW1_AH1(a));}
function AH2 (line 1809) | AH2 APrxLoRcpH2(AH2 a){return AH2_AW2(AW2_(0x7784)-AW2_AH2(a));}
function AH3 (line 1810) | AH3 APrxLoRcpH3(AH3 a){return AH3_AW3(AW3_(0x7784)-AW3_AH3(a));}
function AH4 (line 1811) | AH4 APrxLoRcpH4(AH4 a){return AH4_AW4(AW4_(0x7784)-AW4_AH4(a));}
function AH1 (line 1814) | AH1 APrxMedRcpH1(AH1 a){AH1 b=AH1_AW1(AW1_(0x778d)-AW1_AH1(a));return b*...
function AH2 (line 1815) | AH2 APrxMedRcpH2(AH2 a){AH2 b=AH2_AW2(AW2_(0x778d)-AW2_AH2(a));return b*...
function AH3 (line 1816) | AH3 APrxMedRcpH3(AH3 a){AH3 b=AH3_AW3(AW3_(0x778d)-AW3_AH3(a));return b*...
function AH4 (line 1817) | AH4 APrxMedRcpH4(AH4 a){AH4 b=AH4_AW4(AW4_(0x778d)-AW4_AH4(a));return b*...
function AH1 (line 1820) | AH1 APrxLoRsqH1(AH1 a){return AH1_AW1(AW1_(0x59a3)-(AW1_AH1(a)>>AW1_(1)));}
function AH2 (line 1821) | AH2 APrxLoRsqH2(AH2 a){return AH2_AW2(AW2_(0x59a3)-(AW2_AH2(a)>>AW2_(1)));}
function AH3 (line 1822) | AH3 APrxLoRsqH3(AH3 a){return AH3_AW3(AW3_(0x59a3)-(AW3_AH3(a)>>AW3_(1)));}
function AH4 (line 1823) | AH4 APrxLoRsqH4(AH4 a){return AH4_AW4(AW4_(0x59a3)-(AW4_AH4(a)>>AW4_(1)));}
function AF1 (line 1842) | AF1 APrxLoSqrtF1(AF1 a){return AF1_AU1((AU1_AF1(a)>>AU1_(1))+AU1_(0x1fbc...
function AF1 (line 1843) | AF1 APrxLoRcpF1(AF1 a){return AF1_AU1(AU1_(0x7ef07ebb)-AU1_AF1(a));}
function AF1 (line 1844) | AF1 APrxMedRcpF1(AF1 a){AF1 b=AF1_AU1(AU1_(0x7ef19fff)-AU1_AF1(a));retur...
function AF1 (line 1845) | AF1 APrxLoRsqF1(AF1 a){return AF1_AU1(AU1_(0x5f347d74)-(AU1_AF1(a)>>AU1_...
function AF2 (line 1847) | AF2 APrxLoSqrtF2(AF2 a){return AF2_AU2((AU2_AF2(a)>>AU2_(1))+AU2_(0x1fbc...
function AF2 (line 1848) | AF2 APrxLoRcpF2(AF2 a){return AF2_AU2(AU2_(0x7ef07ebb)-AU2_AF2(a));}
function AF2 (line 1849) | AF2 APrxMedRcpF2(AF2 a){AF2 b=AF2_AU2(AU2_(0x7ef19fff)-AU2_AF2(a));retur...
function AF2 (line 1850) | AF2 APrxLoRsqF2(AF2 a){return AF2_AU2(AU2_(0x5f347d74)-(AU2_AF2(a)>>AU2_...
function AF3 (line 1852) | AF3 APrxLoSqrtF3(AF3 a){return AF3_AU3((AU3_AF3(a)>>AU3_(1))+AU3_(0x1fbc...
function AF3 (line 1853) | AF3 APrxLoRcpF3(AF3 a){return AF3_AU3(AU3_(0x7ef07ebb)-AU3_AF3(a));}
function AF3 (line 1854) | AF3 APrxMedRcpF3(AF3 a){AF3 b=AF3_AU3(AU3_(0x7ef19fff)-AU3_AF3(a));retur...
function AF3 (line 1855) | AF3 APrxLoRsqF3(AF3 a){return AF3_AU3(AU3_(0x5f347d74)-(AU3_AF3(a)>>AU3_...
function AF4 (line 1857) | AF4 APrxLoSqrtF4(AF4 a){return AF4_AU4((AU4_AF4(a)>>AU4_(1))+AU4_(0x1fbc...
function AF4 (line 1858) | AF4 APrxLoRcpF4(AF4 a){return AF4_AU4(AU4_(0x7ef07ebb)-AU4_AF4(a));}
function AF4 (line 1859) | AF4 APrxMedRcpF4(AF4 a){AF4 b=AF4_AU4(AU4_(0x7ef19fff)-AU4_AF4(a));retur...
function AF4 (line 1860) | AF4 APrxLoRsqF4(AF4 a){return AF4_AU4(AU4_(0x5f347d74)-(AU4_AF4(a)>>AU4_...
function AF1 (line 1871) | AF1 Quart(AF1 a) { a = a * a; return a * a;}
function AF1 (line 1872) | AF1 Oct(AF1 a) { a = a * a; a = a * a; return a * a; }
function AF2 (line 1873) | AF2 Quart(AF2 a) { a = a * a; return a * a; }
function AF2 (line 1874) | AF2 Oct(AF2 a) { a = a * a; a = a * a; return a * a; }
function AF3 (line 1875) | AF3 Quart(AF3 a) { a = a * a; return a * a; }
function AF3 (line 1876) | AF3 Oct(AF3 a) { a = a * a; a = a * a; return a * a; }
function AF4 (line 1877) | AF4 Quart(AF4 a) { a = a * a; return a * a; }
function AF4 (line 1878) | AF4 Oct(AF4 a) { a = a * a; a = a * a; return a * a; }
function AF1 (line 1880) | AF1 APrxPQToGamma2(AF1 a) { return Quart(a); }
function AF1 (line 1881) | AF1 APrxPQToLinear(AF1 a) { return Oct(a); }
function AF1 (line 1882) | AF1 APrxLoGamma2ToPQ(AF1 a) { return AF1_AU1((AU1_AF1(a) >> AU1_(2)) + A...
function AF1 (line 1883) | AF1 APrxMedGamma2ToPQ(AF1 a) { AF1 b = AF1_AU1((AU1_AF1(a) >> AU1_(2)) +...
function AF1 (line 1884) | AF1 APrxHighGamma2ToPQ(AF1 a) { return sqrt(sqrt(a)); }
function AF1 (line 1885) | AF1 APrxLoLinearToPQ(AF1 a) { return AF1_AU1((AU1_AF1(a) >> AU1_(3)) + A...
function AF1 (line 1886) | AF1 APrxMedLinearToPQ(AF1 a) { AF1 b = AF1_AU1((AU1_AF1(a) >> AU1_(3)) +...
function AF1 (line 1887) | AF1 APrxHighLinearToPQ(AF1 a) { return sqrt(sqrt(sqrt(a))); }
function AF2 (line 1889) | AF2 APrxPQToGamma2(AF2 a) { return Quart(a); }
function AF2 (line 1890) | AF2 APrxPQToLinear(AF2 a) { return Oct(a); }
function AF2 (line 1891) | AF2 APrxLoGamma2ToPQ(AF2 a) { return AF2_AU2((AU2_AF2(a) >> AU2_(2)) + A...
function AF2 (line 1892) | AF2 APrxMedGamma2ToPQ(AF2 a) { AF2 b = AF2_AU2((AU2_AF2(a) >> AU2_(2)) +...
function AF2 (line 1893) | AF2 APrxHighGamma2ToPQ(AF2 a) { return sqrt(sqrt(a)); }
function AF2 (line 1894) | AF2 APrxLoLinearToPQ(AF2 a) { return AF2_AU2((AU2_AF2(a) >> AU2_(3)) + A...
function AF2 (line 1895) | AF2 APrxMedLinearToPQ(AF2 a) { AF2 b = AF2_AU2((AU2_AF2(a) >> AU2_(3)) +...
function AF2 (line 1896) | AF2 APrxHighLinearToPQ(AF2 a) { return sqrt(sqrt(sqrt(a))); }
function AF3 (line 1898) | AF3 APrxPQToGamma2(AF3 a) { return Quart(a); }
function AF3 (line 1899) | AF3 APrxPQToLinear(AF3 a) { return Oct(a); }
function AF3 (line 1900) | AF3 APrxLoGamma2ToPQ(AF3 a) { return AF3_AU3((AU3_AF3(a) >> AU3_(2)) + A...
function AF3 (line 1901) | AF3 APrxMedGamma2ToPQ(AF3 a) { AF3 b = AF3_AU3((AU3_AF3(a) >> AU3_(2)) +...
function AF3 (line 1902) | AF3 APrxHighGamma2ToPQ(AF3 a) { return sqrt(sqrt(a)); }
function AF3 (line 1903) | AF3 APrxLoLinearToPQ(AF3 a) { return AF3_AU3((AU3_AF3(a) >> AU3_(3)) + A...
function AF3 (line 1904) | AF3 APrxMedLinearToPQ(AF3 a) { AF3 b = AF3_AU3((AU3_AF3(a) >> AU3_(3)) +...
function AF3 (line 1905) | AF3 APrxHighLinearToPQ(AF3 a) { return sqrt(sqrt(sqrt(a))); }
function AF4 (line 1907) | AF4 APrxPQToGamma2(AF4 a) { return Quart(a); }
function AF4 (line 1908) | AF4 APrxPQToLinear(AF4 a) { return Oct(a); }
function AF4 (line 1909) | AF4 APrxLoGamma2ToPQ(AF4 a) { return AF4_AU4((AU4_AF4(a) >> AU4_(2)) + A...
function AF4 (line 1910) | AF4 APrxMedGamma2ToPQ(AF4 a) { AF4 b = AF4_AU4((AU4_AF4(a) >> AU4_(2)) +...
function AF4 (line 1911) | AF4 APrxHighGamma2ToPQ(AF4 a) { return sqrt(sqrt(a)); }
function AF4 (line 1912) | AF4 APrxLoLinearToPQ(AF4 a) { return AF4_AU4((AU4_AF4(a) >> AU4_(3)) + A...
function AF4 (line 1913) | AF4 APrxMedLinearToPQ(AF4 a) { AF4 b = AF4_AU4((AU4_AF4(a) >> AU4_(3)) +...
function AF4 (line 1914) | AF4 APrxHighLinearToPQ(AF4 a) { return sqrt(sqrt(sqrt(a))); }
function AF1 (line 1927) | AF1 APSinF1(AF1 x){return x*abs(x)-x;}
function AF2 (line 1928) | AF2 APSinF2(AF2 x){return x*abs(x)-x;}
function AF1 (line 1929) | AF1 APCosF1(AF1 x){x=AFractF1(x*AF1_(0.5)+AF1_(0.75));x=x*AF1_(2.0)-AF1_...
function AF2 (line 1930) | AF2 APCosF2(AF2 x){x=AFractF2(x*AF2_(0.5)+AF2_(0.75));x=x*AF2_(2.0)-AF2_...
function AF2 (line 1931) | AF2 APSinCosF1(AF1 x){AF1 y=AFractF1(x*AF1_(0.5)+AF1_(0.75));y=y*AF1_(2....
function AH1 (line 1938) | AH1 APSinH1(AH1 x){return x*abs(x)-x;}
function AH2 (line 1939) | AH2 APSinH2(AH2 x){return x*abs(x)-x;}
function AH1 (line 1940) | AH1 APCosH1(AH1 x){x=AFractH1(x*AH1_(0.5)+AH1_(0.75));x=x*AH1_(2.0)-AH1_...
function AH2 (line 1941) | AH2 APCosH2(AH2 x){x=AFractH2(x*AH2_(0.5)+AH2_(0.75));x=x*AH2_(2.0)-AH2_...
function AH2 (line 1942) | AH2 APSinCosH1(AH1 x){AH1 y=AFractH1(x*AH1_(0.5)+AH1_(0.75));y=y*AH1_(2....
function AU1 (line 1968) | AU1 AZolAndU1(AU1 x,AU1 y){return min(x,y);}
function AU2 (line 1969) | AU2 AZolAndU2(AU2 x,AU2 y){return min(x,y);}
function AU3 (line 1970) | AU3 AZolAndU3(AU3 x,AU3 y){return min(x,y);}
function AU4 (line 1971) | AU4 AZolAndU4(AU4 x,AU4 y){return min(x,y);}
function AU1 (line 1973) | AU1 AZolNotU1(AU1 x){return x^AU1_(1);}
function AU2 (line 1974) | AU2 AZolNotU2(AU2 x){return x^AU2_(1);}
function AU3 (line 1975) | AU3 AZolNotU3(AU3 x){return x^AU3_(1);}
function AU4 (line 1976) | AU4 AZolNotU4(AU4 x){return x^AU4_(1);}
function AU1 (line 1978) | AU1 AZolOrU1(AU1 x,AU1 y){return max(x,y);}
function AU2 (line 1979) | AU2 AZolOrU2(AU2 x,AU2 y){return max(x,y);}
function AU3 (line 1980) | AU3 AZolOrU3(AU3 x,AU3 y){return max(x,y);}
function AU4 (line 1981) | AU4 AZolOrU4(AU4 x,AU4 y){return max(x,y);}
function AU1 (line 1983) | AU1 AZolF1ToU1(AF1 x){return AU1(x);}
function AU2 (line 1984) | AU2 AZolF2ToU2(AF2 x){return AU2(x);}
function AU3 (line 1985) | AU3 AZolF3ToU3(AF3 x){return AU3(x);}
function AU4 (line 1986) | AU4 AZolF4ToU4(AF4 x){return AU4(x);}
function AU1 (line 1989) | AU1 AZolNotF1ToU1(AF1 x){return AU1(AF1_(1.0)-x);}
function AU2 (line 1990) | AU2 AZolNotF2ToU2(AF2 x){return AU2(AF2_(1.0)-x);}
function AU3 (line 1991) | AU3 AZolNotF3ToU3(AF3 x){return AU3(AF3_(1.0)-x);}
function AU4 (line 1992) | AU4 AZolNotF4ToU4(AF4 x){return AU4(AF4_(1.0)-x);}
function AF1 (line 1994) | AF1 AZolU1ToF1(AU1 x){return AF1(x);}
function AF2 (line 1995) | AF2 AZolU2ToF2(AU2 x){return AF2(x);}
function AF3 (line 1996) | AF3 AZolU3ToF3(AU3 x){return AF3(x);}
function AF4 (line 1997) | AF4 AZolU4ToF4(AU4 x){return AF4(x);}
function AF1 (line 1999) | AF1 AZolAndF1(AF1 x,AF1 y){return min(x,y);}
function AF2 (line 2000) | AF2 AZolAndF2(AF2 x,AF2 y){return min(x,y);}
function AF3 (line 2001) | AF3 AZolAndF3(AF3 x,AF3 y){return min(x,y);}
function AF4 (line 2002) | AF4 AZolAndF4(AF4 x,AF4 y){return min(x,y);}
function AF1 (line 2004) | AF1 ASolAndNotF1(AF1 x,AF1 y){return (-x)*y+AF1_(1.0);}
function AF2 (line 2005) | AF2 ASolAndNotF2(AF2 x,AF2 y){return (-x)*y+AF2_(1.0);}
function AF3 (line 2006) | AF3 ASolAndNotF3(AF3 x,AF3 y){return (-x)*y+AF3_(1.0);}
function AF4 (line 2007) | AF4 ASolAndNotF4(AF4 x,AF4 y){return (-x)*y+AF4_(1.0);}
function AF1 (line 2009) | AF1 AZolAndOrF1(AF1 x,AF1 y,AF1 z){return ASatF1(x*y+z);}
function AF2 (line 2010) | AF2 AZolAndOrF2(AF2 x,AF2 y,AF2 z){return ASatF2(x*y+z);}
function AF3 (line 2011) | AF3 AZolAndOrF3(AF3 x,AF3 y,AF3 z){return ASatF3(x*y+z);}
function AF4 (line 2012) | AF4 AZolAndOrF4(AF4 x,AF4 y,AF4 z){return ASatF4(x*y+z);}
function AF1 (line 2014) | AF1 AZolGtZeroF1(AF1 x){return ASatF1(x*AF1_(A_INFP_F));}
function AF2 (line 2015) | AF2 AZolGtZeroF2(AF2 x){return ASatF2(x*AF2_(A_INFP_F));}
function AF3 (line 2016) | AF3 AZolGtZeroF3(AF3 x){return ASatF3(x*AF3_(A_INFP_F));}
function AF4 (line 2017) | AF4 AZolGtZeroF4(AF4 x){return ASatF4(x*AF4_(A_INFP_F));}
function AF1 (line 2019) | AF1 AZolNotF1(AF1 x){return AF1_(1.0)-x;}
function AF2 (line 2020) | AF2 AZolNotF2(AF2 x){return AF2_(1.0)-x;}
function AF3 (line 2021) | AF3 AZolNotF3(AF3 x){return AF3_(1.0)-x;}
function AF4 (line 2022) | AF4 AZolNotF4(AF4 x){return AF4_(1.0)-x;}
function AF1 (line 2024) | AF1 AZolOrF1(AF1 x,AF1 y){return max(x,y);}
function AF2 (line 2025) | AF2 AZolOrF2(AF2 x,AF2 y){return max(x,y);}
function AF3 (line 2026) | AF3 AZolOrF3(AF3 x,AF3 y){return max(x,y);}
function AF4 (line 2027) | AF4 AZolOrF4(AF4 x,AF4 y){return max(x,y);}
function AF1 (line 2029) | AF1 AZolSelF1(AF1 x,AF1 y,AF1 z){AF1 r=(-x)*z+z;return x*y+r;}
function AF2 (line 2030) | AF2 AZolSelF2(AF2 x,AF2 y,AF2 z){AF2 r=(-x)*z+z;return x*y+r;}
function AF3 (line 2031) | AF3 AZolSelF3(AF3 x,AF3 y,AF3 z){AF3 r=(-x)*z+z;return x*y+r;}
function AF4 (line 2032) | AF4 AZolSelF4(AF4 x,AF4 y,AF4 z){AF4 r=(-x)*z+z;return x*y+r;}
function AF1 (line 2034) | AF1 AZolSignedF1(AF1 x){return ASatF1(x*AF1_(A_INFN_F));}
function AF2 (line 2035) | AF2 AZolSignedF2(AF2 x){return ASatF2(x*AF2_(A_INFN_F));}
function AF3 (line 2036) | AF3 AZolSignedF3(AF3 x){return ASatF3(x*AF3_(A_INFN_F));}
function AF4 (line 2037) | AF4 AZolSignedF4(AF4 x){return ASatF4(x*AF4_(A_INFN_F));}
function AF1 (line 2039) | AF1 AZolZeroPassF1(AF1 x, AF1 y){return AF1_AU1(select(AU1_AF1(y), AU1_(...
function AF2 (line 2040) | AF2 AZolZeroPassF2(AF2 x, AF2 y){return AF2_AU2(select(AU2_AF2(y), AU2_(...
function AF3 (line 2041) | AF3 AZolZeroPassF3(AF3 x, AF3 y){return AF3_AU3(select(AU3_AF3(y), AU3_(...
function AF4 (line 2042) | AF4 AZolZeroPassF4(AF4 x, AF4 y){return AF4_AU4(select(AU4_AF4(y), AU4_(...
function AW1 (line 2046) | AW1 AZolAndW1(AW1 x,AW1 y){return min(x,y);}
function AW2 (line 2047) | AW2 AZolAndW2(AW2 x,AW2 y){return min(x,y);}
function AW3 (line 2048) | AW3 AZolAndW3(AW3 x,AW3 y){return min(x,y);}
function AW4 (line 2049) | AW4 AZolAndW4(AW4 x,AW4 y){return min(x,y);}
function AW1 (line 2051) | AW1 AZolNotW1(AW1 x){return x^AW1_(1);}
function AW2 (line 2052) | AW2 AZolNotW2(AW2 x){return x^AW2_(1);}
function AW3 (line 2053) | AW3 AZolNotW3(AW3 x){return x^AW3_(1);}
function AW4 (line 2054) | AW4 AZolNotW4(AW4 x){return x^AW4_(1);}
function AW1 (line 2056) | AW1 AZolOrW1(AW1 x,AW1 y){return max(x,y);}
function AW2 (line 2057) | AW2 AZolOrW2(AW2 x,AW2 y){return max(x,y);}
function AW3 (line 2058) | AW3 AZolOrW3(AW3 x,AW3 y){return max(x,y);}
function AW4 (line 2059) | AW4 AZolOrW4(AW4 x,AW4 y){return max(x,y);}
function AW1 (line 2062) | AW1 AZolH1ToW1(AH1 x){return AW1_AH1(x*AH1_AW1(AW1_(1)));}
function AW2 (line 2063) | AW2 AZolH2ToW2(AH2 x){return AW2_AH2(x*AH2_AW2(AW2_(1)));}
function AW3 (line 2064) | AW3 AZolH3ToW3(AH3 x){return AW3_AH3(x*AH3_AW3(AW3_(1)));}
function AW4 (line 2065) | AW4 AZolH4ToW4(AH4 x){return AW4_AH4(x*AH4_AW4(AW4_(1)));}
function AH1 (line 2068) | AH1 AZolW1ToH1(AW1 x){return AH1_AW1(x*AW1_AH1(AH1_(1.0)));}
function AH2 (line 2069) | AH2 AZolW2ToH2(AW2 x){return AH2_AW2(x*AW2_AH2(AH2_(1.0)));}
function AH3 (line 2070) | AH3 AZolW1ToH3(AW3 x){return AH3_AW3(x*AW3_AH3(AH3_(1.0)));}
function AH4 (line 2071) | AH4 AZolW2ToH4(AW4 x){return AH4_AW4(x*AW4_AH4(AH4_(1.0)));}
function AH1 (line 2073) | AH1 AZolAndH1(AH1 x,AH1 y){return min(x,y);}
function AH2 (line 2074) | AH2 AZolAndH2(AH2 x,AH2 y){return min(x,y);}
function AH3 (line 2075) | AH3 AZolAndH3(AH3 x,AH3 y){return min(x,y);}
function AH4 (line 2076) | AH4 AZolAndH4(AH4 x,AH4 y){return min(x,y);}
function AH1 (line 2078) | AH1 ASolAndNotH1(AH1 x,AH1 y){return (-x)*y+AH1_(1.0);}
function AH2 (line 2079) | AH2 ASolAndNotH2(AH2 x,AH2 y){return (-x)*y+AH2_(1.0);}
function AH3 (line 2080) | AH3 ASolAndNotH3(AH3 x,AH3 y){return (-x)*y+AH3_(1.0);}
function AH4 (line 2081) | AH4 ASolAndNotH4(AH4 x,AH4 y){return (-x)*y+AH4_(1.0);}
function AH1 (line 2083) | AH1 AZolAndOrH1(AH1 x,AH1 y,AH1 z){return ASatH1(x*y+z);}
function AH2 (line 2084) | AH2 AZolAndOrH2(AH2 x,AH2 y,AH2 z){return ASatH2(x*y+z);}
function AH3 (line 2085) | AH3 AZolAndOrH3(AH3 x,AH3 y,AH3 z){return ASatH3(x*y+z);}
function AH4 (line 2086) | AH4 AZolAndOrH4(AH4 x,AH4 y,AH4 z){return ASatH4(x*y+z);}
function AH1 (line 2088) | AH1 AZolGtZeroH1(AH1 x){return ASatH1(x*AH1_(A_INFP_H));}
function AH2 (line 2089) | AH2 AZolGtZeroH2(AH2 x){return ASatH2(x*AH2_(A_INFP_H));}
function AH3 (line 2090) | AH3 AZolGtZeroH3(AH3 x){return ASatH3(x*AH3_(A_INFP_H));}
function AH4 (line 2091) | AH4 AZolGtZeroH4(AH4 x){return ASatH4(x*AH4_(A_INFP_H));}
function AH1 (line 2093) | AH1 AZolNotH1(AH1 x){return AH1_(1.0)-x;}
function AH2 (line 2094) | AH2 AZolNotH2(AH2 x){return AH2_(1.0)-x;}
function AH3 (line 2095) | AH3 AZolNotH3(AH3 x){return AH3_(1.0)-x;}
function AH4 (line 2096) | AH4 AZolNotH4(AH4 x){return AH4_(1.0)-x;}
function AH1 (line 2098) | AH1 AZolOrH1(AH1 x,AH1 y){return max(x,y);}
function AH2 (line 2099) | AH2 AZolOrH2(AH2 x,AH2 y){return max(x,y);}
function AH3 (line 2100) | AH3 AZolOrH3(AH3 x,AH3 y){return max(x,y);}
function AH4 (line 2101) | AH4 AZolOrH4(AH4 x,AH4 y){return max(x,y);}
function AH1 (line 2103) | AH1 AZolSelH1(AH1 x,AH1 y,AH1 z){AH1 r=(-x)*z+z;return x*y+r;}
function AH2 (line 2104) | AH2 AZolSelH2(AH2 x,AH2 y,AH2 z){AH2 r=(-x)*z+z;return x*y+r;}
function AH3 (line 2105) | AH3 AZolSelH3(AH3 x,AH3 y,AH3 z){AH3 r=(-x)*z+z;return x*y+r;}
function AH4 (line 2106) | AH4 AZolSelH4(AH4 x,AH4 y,AH4 z){AH4 r=(-x)*z+z;return x*y+r;}
function AH1 (line 2108) | AH1 AZolSignedH1(AH1 x){return ASatH1(x*AH1_(A_INFN_H));}
function AH2 (line 2109) | AH2 AZolSignedH2(AH2 x){return ASatH2(x*AH2_(A_INFN_H));}
function AH3 (line 2110) | AH3 AZolSignedH3(AH3 x){return ASatH3(x*AH3_(A_INFN_H));}
function AH4 (line 2111) | AH4 AZolSignedH4(AH4 x){return ASatH4(x*AH4_(A_INFN_H));}
function AF1 (line 2166) | AF1 ATo709F1(AF1 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099);
function AF2 (line 2168) | AF2 ATo709F2(AF2 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099);
function AF3 (line 2170) | AF3 ATo709F3(AF3 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099);
function AF1 (line 2174) | AF1 AToGammaF1(AF1 c,AF1 rcpX){return pow(c,AF1_(rcpX));}
function AF2 (line 2175) | AF2 AToGammaF2(AF2 c,AF1 rcpX){return pow(c,AF2_(rcpX));}
function AF3 (line 2176) | AF3 AToGammaF3(AF3 c,AF1 rcpX){return pow(c,AF3_(rcpX));}
function AF1 (line 2178) | AF1 AToPqF1(AF1 x){AF1 p=pow(x,AF1_(0.159302));
function AF2 (line 2180) | AF2 AToPqF1(AF2 x){AF2 p=pow(x,AF2_(0.159302));
function AF3 (line 2182) | AF3 AToPqF1(AF3 x){AF3 p=pow(x,AF3_(0.159302));
function AF1 (line 2185) | AF1 AToSrgbF1(AF1 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(...
function AF2 (line 2187) | AF2 AToSrgbF2(AF2 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(...
function AF3 (line 2189) | AF3 AToSrgbF3(AF3 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(...
function AF1 (line 2192) | AF1 AToTwoF1(AF1 c){return sqrt(c);}
function AF2 (line 2193) | AF2 AToTwoF2(AF2 c){return sqrt(c);}
function AF3 (line 2194) | AF3 AToTwoF3(AF3 c){return sqrt(c);}
function AF1 (line 2196) | AF1 AToThreeF1(AF1 c){return pow(c,AF1_(1.0/3.0));}
function AF2 (line 2197) | AF2 AToThreeF2(AF2 c){return pow(c,AF2_(1.0/3.0));}
function AF3 (line 2198) | AF3 AToThreeF3(AF3 c){return pow(c,AF3_(1.0/3.0));}
function AF1 (line 2203) | AF1 AFrom709F1(AF1 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1....
function AF2 (line 2205) | AF2 AFrom709F2(AF2 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1....
function AF3 (line 2207) | AF3 AFrom709F3(AF3 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1....
function AF1 (line 2210) | AF1 AFromGammaF1(AF1 c,AF1 x){return pow(c,AF1_(x));}
function AF2 (line 2211) | AF2 AFromGammaF2(AF2 c,AF1 x){return pow(c,AF2_(x));}
function AF3 (line 2212) | AF3 AFromGammaF3(AF3 c,AF1 x){return pow(c,AF3_(x));}
function AF1 (line 2214) | AF1 AFromPqF1(AF1 x){AF1 p=pow(x,AF1_(0.0126833));
function AF2 (line 2216) | AF2 AFromPqF1(AF2 x){AF2 p=pow(x,AF2_(0.0126833));
function AF3 (line 2218) | AF3 AFromPqF1(AF3 x){AF3 p=pow(x,AF3_(0.0126833));
function AF1 (line 2222) | AF1 AFromSrgbF1(AF1 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(...
function AF2 (line 2224) | AF2 AFromSrgbF2(AF2 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(...
function AF3 (line 2226) | AF3 AFromSrgbF3(AF3 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(...
function AF1 (line 2229) | AF1 AFromTwoF1(AF1 c){return c*c;}
function AF2 (line 2230) | AF2 AFromTwoF2(AF2 c){return c*c;}
function AF3 (line 2231) | AF3 AFromTwoF3(AF3 c){return c*c;}
function AF1 (line 2233) | AF1 AFromThreeF1(AF1 c){return c*c*c;}
function AF2 (line 2234) | AF2 AFromThreeF2(AF2 c){return c*c*c;}
function AF3 (line 2235) | AF3 AFromThreeF3(AF3 c){return c*c*c;}
function AH1 (line 2239) | AH1 ATo709H1(AH1 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099);
function AH2 (line 2241) | AH2 ATo709H2(AH2 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099);
function AH3 (line 2243) | AH3 ATo709H3(AH3 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099);
function AH1 (line 2246) | AH1 AToGammaH1(AH1 c,AH1 rcpX){return pow(c,AH1_(rcpX));}
function AH2 (line 2247) | AH2 AToGammaH2(AH2 c,AH1 rcpX){return pow(c,AH2_(rcpX));}
function AH3 (line 2248) | AH3 AToGammaH3(AH3 c,AH1 rcpX){return pow(c,AH3_(rcpX));}
function AH1 (line 2250) | AH1 AToSrgbH1(AH1 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(...
function AH2 (line 2252) | AH2 AToSrgbH2(AH2 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(...
function AH3 (line 2254) | AH3 AToSrgbH3(AH3 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(...
function AH1 (line 2257) | AH1 AToTwoH1(AH1 c){return sqrt(c);}
function AH2 (line 2258) | AH2 AToTwoH2(AH2 c){return sqrt(c);}
function AH3 (line 2259) | AH3 AToTwoH3(AH3 c){return sqrt(c);}
function AH1 (line 2261) | AH1 AToThreeF1(AH1 c){return pow(c,AH1_(1.0/3.0));}
function AH2 (line 2262) | AH2 AToThreeF2(AH2 c){return pow(c,AH2_(1.0/3.0));}
function AH3 (line 2263) | AH3 AToThreeF3(AH3 c){return pow(c,AH3_(1.0/3.0));}
function AH1 (line 2267) | AH1 AFrom709H1(AH1 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1....
function AH2 (line 2269) | AH2 AFrom709H2(AH2 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1....
function AH3 (line 2271) | AH3 AFrom709H3(AH3 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1....
function AH1 (line 2274) | AH1 AFromGammaH1(AH1 c,AH1 x){return pow(c,AH1_(x));}
function AH2 (line 2275) | AH2 AFromGammaH2(AH2 c,AH1 x){return pow(c,AH2_(x));}
function AH3 (line 2276) | AH3 AFromGammaH3(AH3 c,AH1 x){return pow(c,AH3_(x));}
function AH1 (line 2278) | AH1 AHromSrgbF1(AH1 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(...
function AH2 (line 2280) | AH2 AHromSrgbF2(AH2 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(...
function AH3 (line 2282) | AH3 AHromSrgbF3(AH3 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(...
function AH1 (line 2285) | AH1 AFromTwoH1(AH1 c){return c*c;}
function AH2 (line 2286) | AH2 AFromTwoH2(AH2 c){return c*c;}
function AH3 (line 2287) | AH3 AFromTwoH3(AH3 c){return c*c;}
function AH1 (line 2289) | AH1 AFromThreeH1(AH1 c){return c*c*c;}
function AH2 (line 2290) | AH2 AFromThreeH2(AH2 c){return c*c*c;}
function AH3 (line 2291) | AH3 AFromThreeH3(AH3 c){return c*c*c;}
function AU2 (line 2304) | AU2 ARmp8x8(AU1 a){return AU2(ABfe(a,1u,3u),ABfiM(ABfe(a,3u,3u),a,1u));}
function AU2 (line 2322) | AU2 ARmpRed8x8(AU1 a){return AU2(ABfiM(ABfe(a,2u,3u),a,1u),ABfiM(ABfe(a,...
function AW2 (line 2325) | AW2 ARmp8x8H(AU1 a){return AW2(ABfe(a,1u,3u),ABfiM(ABfe(a,3u,3u),a,1u));}
function AW2 (line 2326) | AW2 ARmpRed8x8H(AU1 a){return AW2(ABfiM(ABfe(a,2u,3u),a,1u),ABfiM(ABfe(a...
function AD2 (line 2560) | AD2 opAAbsD2(outAD2 d,inAD2 a){d=abs(a);return d;}
function AD3 (line 2561) | AD3 opAAbsD3(outAD3 d,inAD3 a){d=abs(a);return d;}
function AD4 (line 2562) | AD4 opAAbsD4(outAD4 d,inAD4 a){d=abs(a);return d;}
function AD2 (line 2564) | AD2 opAAddD2(outAD2 d,inAD2 a,inAD2 b){d=a+b;return d;}
function AD3 (line 2565) | AD3 opAAddD3(outAD3 d,inAD3 a,inAD3 b){d=a+b;return d;}
function AD4 (line 2566) | AD4 opAAddD4(outAD4 d,inAD4 a,inAD4 b){d=a+b;return d;}
function AD2 (line 2568) | AD2 opAAddOneD2(outAD2 d,inAD2 a,AD1 b){d=a+AD2_(b);return d;}
function AD3 (line 2569) | AD3 opAAddOneD3(outAD3 d,inAD3 a,AD1 b){d=a+AD3_(b);return d;}
function AD4 (line 2570) | AD4 opAAddOneD4(outAD4 d,inAD4 a,AD1 b){d=a+AD4_(b);return d;}
function AD2 (line 2572) | AD2 opACpyD2(outAD2 d,inAD2 a){d=a;return d;}
function AD3 (line 2573) | AD3 opACpyD3(outAD3 d,inAD3 a){d=a;return d;}
function AD4 (line 2574) | AD4 opACpyD4(outAD4 d,inAD4 a){d=a;return d;}
function AD2 (line 2576) | AD2 opALerpD2(outAD2 d,inAD2 a,inAD2 b,inAD2 c){d=ALerpD2(a,b,c);return d;}
function AD3 (line 2577) | AD3 opALerpD3(outAD3 d,inAD3 a,inAD3 b,inAD3 c){d=ALerpD3(a,b,c);return d;}
function AD4 (line 2578) | AD4 opALerpD4(outAD4 d,inAD4 a,inAD4 b,inAD4 c){d=ALerpD4(a,b,c);return d;}
function AD2 (line 2580) | AD2 opALerpOneD2(outAD2 d,inAD2 a,inAD2 b,AD1 c){d=ALerpD2(a,b,AD2_(c));...
function AD3 (line 2581) | AD3 opALerpOneD3(outAD3 d,inAD3 a,inAD3 b,AD1 c){d=ALerpD3(a,b,AD3_(c));...
function AD4 (line 2582) | AD4 opALerpOneD4(outAD4 d,inAD4 a,inAD4 b,AD1 c){d=ALerpD4(a,b,AD4_(c));...
function AD2 (line 2584) | AD2 opAMaxD2(outAD2 d,inAD2 a,inAD2 b){d=max(a,b);return d;}
function AD3 (line 2585) | AD3 opAMaxD3(outAD3 d,inAD3 a,inAD3 b){d=max(a,b);return d;}
function AD4 (line 2586) | AD4 opAMaxD4(outAD4 d,inAD4 a,inAD4 b){d=max(a,b);return d;}
function AD2 (line 2588) | AD2 opAMinD2(outAD2 d,inAD2 a,inAD2 b){d=min(a,b);return d;}
function AD3 (line 2589) | AD3 opAMinD3(outAD3 d,inAD3 a,inAD3 b){d=min(a,b);return d;}
function AD4 (line 2590) | AD4 opAMinD4(outAD4 d,inAD4 a,inAD4 b){d=min(a,b);return d;}
function AD2 (line 2592) | AD2 opAMulD2(outAD2 d,inAD2 a,inAD2 b){d=a*b;return d;}
function AD3 (line 2593) | AD3 opAMulD3(outAD3 d,inAD3 a,inAD3 b){d=a*b;return d;}
function AD4 (line 2594) | AD4 opAMulD4(outAD4 d,inAD4 a,inAD4 b){d=a*b;return d;}
function AD2 (line 2596) | AD2 opAMulOneD2(outAD2 d,inAD2 a,AD1 b){d=a*AD2_(b);return d;}
function AD3 (line 2597) | AD3 opAMulOneD3(outAD3 d,inAD3 a,AD1 b){d=a*AD3_(b);return d;}
function AD4 (line 2598) | AD4 opAMulOneD4(outAD4 d,inAD4 a,AD1 b){d=a*AD4_(b);return d;}
function AD2 (line 2600) | AD2 opANegD2(outAD2 d,inAD2 a){d=-a;return d;}
function AD3 (line 2601) | AD3 opANegD3(outAD3 d,inAD3 a){d=-a;return d;}
function AD4 (line 2602) | AD4 opANegD4(outAD4 d,inAD4 a){d=-a;return d;}
function AD2 (line 2604) | AD2 opARcpD2(outAD2 d,inAD2 a){d=ARcpD2(a);return d;}
function AD3 (line 2605) | AD3 opARcpD3(outAD3 d,inAD3 a){d=ARcpD3(a);return d;}
function AD4 (line 2606) | AD4 opARcpD4(outAD4 d,inAD4 a){d=ARcpD4(a);return d;}
function AF2 (line 2609) | AF2 opAAbsF2(outAF2 d,inAF2 a){d=abs(a);return d;}
function AF3 (line 2610) | AF3 opAAbsF3(outAF3 d,inAF3 a){d=abs(a);return d;}
function AF4 (line 2611) | AF4 opAAbsF4(outAF4 d,inAF4 a){d=abs(a);return d;}
function AF2 (line 2613) | AF2 opAAddF2(outAF2 d,inAF2 a,inAF2 b){d=a+b;return d;}
function AF3 (line 2614) | AF3 opAAddF3(outAF3 d,inAF3 a,inAF3 b){d=a+b;return d;}
function AF4 (line 2615) | AF4 opAAddF4(outAF4 d,inAF4 a,inAF4 b){d=a+b;return d;}
function AF2 (line 2617) | AF2 opAAddOneF2(outAF2 d,inAF2 a,AF1 b){d=a+AF2_(b);return d;}
function AF3 (line 2618) | AF3 opAAddOneF3(outAF3 d,inAF3 a,AF1 b){d=a+AF3_(b);return d;}
function AF4 (line 2619) | AF4 opAAddOneF4(outAF4 d,inAF4 a,AF1 b){d=a+AF4_(b);return d;}
function AF2 (line 2621) | AF2 opACpyF2(outAF2 d,inAF2 a){d=a;return d;}
function AF3 (line 2622) | AF3 opACpyF3(outAF3 d,inAF3 a){d=a;return d;}
function AF4 (line 2623) | AF4 opACpyF4(outAF4 d,inAF4 a){d=a;return d;}
function AF2 (line 2625) | AF2 opALerpF2(outAF2 d,inAF2 a,inAF2 b,inAF2 c){d=ALerpF2(a,b,c);return d;}
function AF3 (line 2626) | AF3 opALerpF3(outAF3 d,inAF3 a,inAF3 b,inAF3 c){d=ALerpF3(a,b,c);return d;}
function AF4 (line 2627) | AF4 opALerpF4(outAF4 d,inAF4 a,inAF4 b,inAF4 c){d=ALerpF4(a,b,c);return d;}
function AF2 (line 2629) | AF2 opALerpOneF2(outAF2 d,inAF2 a,inAF2 b,AF1 c){d=ALerpF2(a,b,AF2_(c));...
function AF3 (line 2630) | AF3 opALerpOneF3(outAF3 d,inAF3 a,inAF3 b,AF1 c){d=ALerpF3(a,b,AF3_(c));...
function AF4 (line 2631) | AF4 opALerpOneF4(outAF4 d,inAF4 a,inAF4 b,AF1 c){d=ALerpF4(a,b,AF4_(c));...
function AF2 (line 2633) | AF2 opAMaxF2(outAF2 d,inAF2 a,inAF2 b){d=max(a,b);return d;}
function AF3 (line 2634) | AF3 opAMaxF3(outAF3 d,inAF3 a,inAF3 b){d=max(a,b);return d;}
function AF4 (line 2635) | AF4 opAMaxF4(outAF4 d,inAF4 a,inAF4 b){d=max(a,b);return d;}
function AF2 (line 2637) | AF2 opAMinF2(outAF2 d,inAF2 a,inAF2 b){d=min(a,b);return d;}
function AF3 (line 2638) | AF3 opAMinF3(outAF3 d,inAF3 a,inAF3 b){d=min(a,b);return d;}
function AF4 (line 2639) | AF4 opAMinF4(outAF4 d,inAF4 a,inAF4 b){d=min(a,b);return d;}
function AF2 (line 2641) | AF2 opAMulF2(outAF2 d,inAF2 a,inAF2 b){d=a*b;return d;}
function AF3 (line 2642) | AF3 opAMulF3(outAF3 d,inAF3 a,inAF3 b){d=a*b;return d;}
function AF4 (line 2643) | AF4 opAMulF4(outAF4 d,inAF4 a,inAF4 b){d=a*b;return d;}
function AF2 (line 2645) | AF2 opAMulOneF2(outAF2 d,inAF2 a,AF1 b){d=a*AF2_(b);return d;}
function AF3 (line 2646) | AF3 opAMulOneF3(outAF3 d,inAF3 a,AF1 b){d=a*AF3_(b);return d;}
function AF4 (line 2647) | AF4 opAMulOneF4(outAF4 d,inAF4 a,AF1 b){d=a*AF4_(b);return d;}
function AF2 (line 2649) | AF2 opANegF2(outAF2 d,inAF2 a){d=-a;return d;}
function AF3 (line 2650) | AF3 opANegF3(outAF3 d,inAF3 a){d=-a;return d;}
function AF4 (line 2651) | AF4 opANegF4(outAF4 d,inAF4 a){d=-a;return d;}
function AF2 (line 2653) | AF2 opARcpF2(outAF2 d,inAF2 a){d=ARcpF2(a);return d;}
function AF3 (line 2654) | AF3 opARcpF3(outAF3 d,inAF3 a){d=ARcpF3(a);return d;}
function AF4 (line 2655) | AF4 opARcpF4(outAF4 d,inAF4 a){d=ARcpF4(a);return d;}
FILE: data/shaders/amd_fidelity_fx/ffx_cas.h
function AP1 (line 372) | AP1 CasSupportScaling(AF1 outX,AF1 outY,AF1 inX,AF1 inY){return ((outX*o...
function A_STATIC (line 375) | A_STATIC void CasSetup(
function AF3 (line 404) | AF3 CasLoad(ASU2 p){return AF3(0.0,0.0,0.0);}
function CasInput (line 405) | void CasInput(inout AF1 r,inout AF1 g,inout AF1 b){}
function CasFilter (line 408) | void CasFilter(
function CasDepack (line 896) | void CasDepack(out AH4 pix0,out AH4 pix1,AH2 pixR,AH2 pixG,AH2 pixB){
function CasFilterH (line 904) | void CasFilterH(
FILE: data/shaders/amd_fidelity_fx/ffx_spd.h
function A_STATIC (line 327) | A_STATIC void SpdSetup(
function A_STATIC (line 353) | A_STATIC void SpdSetup(
function AF4 (line 368) | AF4 SpdLoadSourceImage(ASU2 p, AU1 slice){return AF4(0.0,0.0,0.0,0.0);}
function AF4 (line 369) | AF4 SpdLoad(ASU2 p, AU1 slice){return AF4(0.0,0.0,0.0,0.0);}
function SpdStore (line 370) | void SpdStore(ASU2 p, AF4 value, AU1 mip, AU1 slice){}
function AF4 (line 371) | AF4 SpdLoadIntermediate(AU1 x, AU1 y){return AF4(0.0,0.0,0.0,0.0);}
function SpdStoreIntermediate (line 372) | void SpdStoreIntermediate(AU1 x, AU1 y, AF4 value){}
function AF4 (line 373) | AF4 SpdReduce4(AF4 v0, AF4 v1, AF4 v2, AF4 v3){return AF4(0.0,0.0,0.0,0....
function SpdWorkgroupShuffleBarrier (line 381) | void SpdWorkgroupShuffleBarrier() {
function SpdExitWorkgroup (line 391) | bool SpdExitWorkgroup(AU1 numWorkGroups, AU1 localInvocationIndex, AU1 s...
function AF4 (line 407) | AF4 SpdReduceQuad(AF4 v)
function AF4 (line 450) | AF4 SpdReduceIntermediate(AU2 i0, AU2 i1, AU2 i2, AU2 i3)
function AF4 (line 459) | AF4 SpdReduceLoad4(AU2 i0, AU2 i1, AU2 i2, AU2 i3, AU1 slice)
function AF4 (line 468) | AF4 SpdReduceLoad4(AU2 base, AU1 slice)
function AF4 (line 478) | AF4 SpdReduceLoadSourceImage4(AU2 i0, AU2 i1, AU2 i2, AU2 i3, AU1 slice)
function AF4 (line 487) | AF4 SpdReduceLoadSourceImage(AU2 base, AU1 slice)
function SpdDownsampleMips_0_1_Intrinsics (line 501) | void SpdDownsampleMips_0_1_Intrinsics(AU1 x, AU1 y, AU2 workGroupID, AU1...
function SpdDownsampleMips_0_1_LDS (line 557) | void SpdDownsampleMips_0_1_LDS(AU1 x, AU1 y, AU2 workGroupID, AU1 localI...
function SpdDownsampleMips_0_1 (line 610) | void SpdDownsampleMips_0_1(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvoc...
function SpdDownsampleMip_2 (line 620) | void SpdDownsampleMip_2(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvocati...
function SpdDownsampleMip_3 (line 654) | void SpdDownsampleMip_3(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvocati...
function SpdDownsampleMip_4 (line 698) | void SpdDownsampleMip_4(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvocati...
function SpdDownsampleMip_5 (line 733) | void SpdDownsampleMip_5(AU2 workGroupID, AU1 localInvocationIndex, AU1 m...
function SpdDownsampleMips_6_7 (line 762) | void SpdDownsampleMips_6_7(AU1 x, AU1 y, AU1 mips, AU1 slice)
function SpdDownsampleNextFour (line 792) | void SpdDownsampleNextFour(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvoc...
function SpdDownsample (line 811) | void SpdDownsample(
function SpdDownsample (line 837) | void SpdDownsample(
function AH4 (line 861) | AH4 SpdReduceQuadH(AH4 v)
function AH4 (line 905) | AH4 SpdReduceIntermediateH(AU2 i0, AU2 i1, AU2 i2, AU2 i3)
function AH4 (line 914) | AH4 SpdReduceLoad4H(AU2 i0, AU2 i1, AU2 i2, AU2 i3, AU1 slice)
function AH4 (line 923) | AH4 SpdReduceLoad4H(AU2 base, AU1 slice)
function AH4 (line 933) | AH4 SpdReduceLoadSourceImage4H(AU2 i0, AU2 i1, AU2 i2, AU2 i3, AU1 slice)
function AH4 (line 942) | AH4 SpdReduceLoadSourceImageH(AU2 base, AU1 slice)
function SpdDownsampleMips_0_1_IntrinsicsH (line 956) | void SpdDownsampleMips_0_1_IntrinsicsH(AU1 x, AU1 y, AU2 workGroupID, AU...
function SpdDownsampleMips_0_1_LDSH (line 1004) | void SpdDownsampleMips_0_1_LDSH(AU1 x, AU1 y, AU2 workGroupID, AU1 local...
function SpdDownsampleMips_0_1H (line 1057) | void SpdDownsampleMips_0_1H(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvo...
function SpdDownsampleMip_2H (line 1067) | void SpdDownsampleMip_2H(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvocat...
function SpdDownsampleMip_3H (line 1101) | void SpdDownsampleMip_3H(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvocat...
function SpdDownsampleMip_4H (line 1145) | void SpdDownsampleMip_4H(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvocat...
function SpdDownsampleMip_5H (line 1180) | void SpdDownsampleMip_5H(AU2 workGroupID, AU1 localInvocationIndex, AU1 ...
function SpdDownsampleMips_6_7H (line 1209) | void SpdDownsampleMips_6_7H(AU1 x, AU1 y, AU1 mips, AU1 slice)
function SpdDownsampleNextFourH (line 1239) | void SpdDownsampleNextFourH(AU1 x, AU1 y, AU2 workGroupID, AU1 localInvo...
function SpdDownsampleH (line 1258) | void SpdDownsampleH(
function SpdDownsampleH (line 1285) | void SpdDownsampleH(
FILE: data/shaders/compressonator/bcn_common_api.h
function CMP_STATIC (line 53) | CMP_STATIC CGU_FLOAT cmp_fabs(CMP_IN CGU_FLOAT x)
function CMP_STATIC (line 58) | CMP_STATIC CGU_FLOAT cmp_linearToSrgbf(CMP_IN CGU_FLOAT Color)
function CMP_STATIC (line 70) | CMP_STATIC CGU_Vec3f cmp_linearToSrgb(CMP_IN CGU_Vec3f Color)
function CMP_STATIC (line 78) | CMP_STATIC CGU_FLOAT cmp_srgbToLinearf(CMP_IN CGU_FLOAT Color)
function CMP_STATIC (line 90) | CMP_STATIC CGU_Vec3f cmp_srgbToLinear(CMP_IN CGU_Vec3f Color)
function CMP_STATIC (line 98) | CMP_STATIC CGU_Vec3f cmp_565ToLinear(CMP_IN CGU_UINT32 n565)
function CMP_STATIC (line 121) | CMP_STATIC CGU_UINT32 cmp_get2Bit32(CMP_IN CGU_UINT32 value, CMP_IN CGU_...
function CMP_STATIC (line 126) | CMP_STATIC CGU_UINT32 cmp_set2Bit32(CMP_IN CGU_UINT32 value, CMP_IN CGU_...
function CMP_STATIC (line 131) | CMP_STATIC CGU_UINT32 cmp_constructColor(CMP_IN CGU_UINT32 R, CMP_IN CGU...
function CMP_STATIC (line 136) | CMP_STATIC CGU_FLOAT cmp_clampf(CMP_IN CGU_FLOAT v, CMP_IN CGU_FLOAT a, ...
function CMP_STATIC (line 145) | CMP_STATIC CGU_Vec3f cmp_clampVec3f(CMP_IN CGU_Vec3f value, CMP_IN CGU_F...
function CMP_STATIC (line 158) | CMP_STATIC CGU_Vec3f cmp_saturate(CMP_IN CGU_Vec3f value)
function CGU_Vec3f (line 167) | static CGU_Vec3f cmp_powVec3f(CGU_Vec3f color, CGU_FLOAT ex)
function CMP_STATIC (line 180) | CMP_STATIC CGU_Vec3f cmp_minVec3f(CMP_IN CGU_Vec3f a, CMP_IN CGU_Vec3f b)
function CMP_STATIC (line 201) | CMP_STATIC CGU_Vec3f cmp_maxVec3f(CMP_IN CGU_Vec3f a, CMP_IN CGU_Vec3f b)
function CGU_Vec3f (line 222) | inline CGU_Vec3f cmp_min3f(CMP_IN CGU_Vec3f value1, CMP_IN CGU_Vec3f val...
function CGU_Vec3f (line 235) | inline CGU_Vec3f cmp_max3f(CMP_IN CGU_Vec3f value1, CMP_IN CGU_Vec3f val...
function CMP_STATIC (line 248) | CMP_STATIC CGU_FLOAT cmp_minf(CMP_IN CGU_FLOAT a, CMP_IN CGU_FLOAT b)
function CMP_STATIC (line 253) | CMP_STATIC CGU_FLOAT cmp_maxf(CMP_IN CGU_FLOAT a, CMP_IN CGU_FLOAT b)
function CMP_STATIC (line 258) | CMP_STATIC CGU_FLOAT cmp_floor(CMP_IN CGU_FLOAT value)
function CMP_STATIC (line 270) | CMP_STATIC CGU_Vec3f cmp_floorVec3f(CMP_IN CGU_Vec3f value)
function CMP_STATIC (line 292) | CMP_STATIC CGU_Vec4i cmp_castimp(CGU_Vec4ui v1)
function CMP_STATIC (line 301) | CMP_STATIC CGU_Vec3i cmp_castimp(CGU_Vec3ui v1)
function CMP_STATIC (line 314) | CMP_STATIC CGU_UINT8 cmp_min8(CMP_IN CGU_UINT8 a, CMP_IN CGU_UINT8 b)
function CMP_STATIC (line 319) | CMP_STATIC CGU_UINT8 cmp_max8(CMP_IN CGU_UINT8 a, CMP_IN CGU_UINT8 b)
function CMP_STATIC (line 324) | CMP_STATIC CGU_UINT32 cmp_mini(CMP_IN CGU_UINT32 a, CMP_IN CGU_UINT32 b)
function CMP_STATIC (line 329) | CMP_STATIC CGU_UINT32 cmp_maxi(CMP_IN CGU_UINT32 a, CMP_IN CGU_UINT32 b)
function CMP_STATIC (line 334) | CMP_STATIC CGU_FLOAT cmp_max3(CMP_IN CGU_FLOAT i, CMP_IN CGU_FLOAT j, CM...
function CMP_STATIC (line 351) | CMP_STATIC CGU_Vec4ui cmp_minVec4ui(CMP_IN CGU_Vec4ui a, CMP_IN CGU_Vec4...
function CMP_STATIC (line 378) | CMP_STATIC CGU_Vec4ui cmp_maxVec4ui(CMP_IN CGU_Vec4ui a, CMP_IN CGU_Vec4...
function CMP_STATIC (line 409) | CMP_STATIC CGU_UINT32 cmp_clampui32(CMP_IN CGU_UINT32 v, CMP_IN CGU_UINT...
function CMP_STATIC (line 435) | CMP_STATIC CGU_FLOAT HalfToFloat(CGU_UINT32 h)
function CMP_STATIC (line 462) | CMP_STATIC CGU_FLOAT cmp_half2float1(CGU_UINT32 Value)
function CMP_STATIC (line 496) | CMP_STATIC CGU_Vec3f cmp_half2floatVec3(CGU_Vec3ui color_h)
function CMP_STATIC (line 507) | CMP_STATIC CGU_UINT16 FloatToHalf(CGU_FLOAT value)
function CMP_STATIC (line 577) | CMP_STATIC CGU_UINT32 cmp_float2halfui(CGU_FLOAT f)
function CMP_STATIC (line 610) | CMP_STATIC CGU_Vec3ui cmp_float2half(CGU_Vec3f endPoint_f)
function CMP_STATIC (line 615) | CMP_STATIC CGU_UINT32 cmp_float2half1(CGU_FLOAT f)
function CMP_STATIC (line 648) | CMP_STATIC CGU_Vec3ui cmp_float2halfVec3(CGU_Vec3f endPoint_f)
function CMP_STATIC (line 653) | CMP_STATIC CGU_FLOAT cmp_f32tof16(CMP_IN CGU_FLOAT value)
function CMP_STATIC (line 666) | CMP_STATIC CGU_Vec3f cmp_f32tof16(CMP_IN CGU_Vec3f value)
function CMP_STATIC (line 683) | CMP_STATIC CGU_FLOAT cmp_f16tof32(CGU_UINT32 value)
function CMP_STATIC (line 696) | CMP_STATIC CGU_Vec3f cmp_f16tof32(CGU_Vec3ui value)
function CMP_STATIC (line 713) | CMP_STATIC CGU_Vec3f cmp_f16tof32(CGU_Vec3f value)
function CMP_STATIC (line 730) | CMP_STATIC void cmp_swap(CMP_INOUT CGU_Vec3f CMP_REFINOUT a, CMP_INOUT C...
function CMP_STATIC (line 737) | CMP_STATIC void cmp_swap(CMP_INOUT CGU_FLOAT CMP_REFINOUT a, CMP_INOUT C...
function CMP_STATIC (line 744) | CMP_STATIC void cmp_swap(CMP_INOUT CGU_Vec3i CMP_REFINOUT lhs, CMP_INOUT...
function CMP_STATIC (line 751) | CMP_STATIC CGU_INT cmp_dotVec2i(CMP_IN CGU_Vec2i value1, CMP_IN CGU_Vec2...
function CMP_STATIC (line 760) | CMP_STATIC CGU_FLOAT cmp_dotVec3f(CMP_IN CGU_Vec3f value1, CMP_IN CGU_Ve...
function CMP_STATIC (line 769) | CMP_STATIC CGU_UINT32 cmp_dotVec3ui(CMP_IN CGU_Vec3ui value1, CMP_IN CGU...
function CMP_STATIC (line 778) | CMP_STATIC CGU_UINT32 cmp_dotVec4i(CMP_IN CGU_Vec4i value1, CMP_IN CGU_V...
function CMP_STATIC (line 787) | CMP_STATIC CGU_UINT32 cmp_dotVec4ui(CMP_IN CGU_Vec4ui value1, CMP_IN CGU...
function CMP_STATIC (line 796) | CMP_STATIC CGU_Vec3f cmp_clampVec3fi(CMP_IN CGU_Vec3f value, CMP_IN CGU_...
function CMP_STATIC (line 809) | CMP_STATIC CGU_Vec4ui cmp_clampVec4ui(CMP_IN CGU_Vec4ui value, CMP_IN CG...
function CMP_STATIC (line 823) | CMP_STATIC CGU_Vec4f cmp_clampVec4f(CMP_IN CGU_Vec4f value, CMP_IN CGU_F...
function CMP_STATIC (line 837) | CMP_STATIC CGU_Vec3f cmp_clamp3Vec3f(CMP_IN CGU_Vec3f value, CMP_IN CGU_...
function CMP_STATIC (line 850) | CMP_STATIC CGU_Vec3f cmp_exp2(CMP_IN CGU_Vec3f value)
function CMP_STATIC (line 863) | CMP_STATIC CGU_Vec3f cmp_roundVec3f(CMP_IN CGU_Vec3f value)
function CMP_STATIC (line 877) | CMP_STATIC CGU_Vec3f cmp_log2Vec3f(CMP_IN CGU_Vec3f value)
function CMP_STATIC (line 891) | CMP_STATIC CGU_FLOAT cmp_saturate(CMP_IN CGU_FLOAT value)
function CMP_STATIC (line 900) | CMP_STATIC CGU_FLOAT cmp_rcp(CMP_IN CGU_FLOAT det)
function CMP_STATIC (line 912) | CMP_STATIC CGU_UINT32 cmp_Get4BitIndexPos(CMP_IN CGU_FLOAT indexPos, CMP...
function CMP_STATIC (line 919) | CMP_STATIC CGU_FLOAT cmp_CalcMSLE(CMP_IN CGU_Vec3f a, CMP_IN CGU_Vec3f b)
function CMP_STATIC (line 927) | CMP_STATIC void cmp_GetTexelMinMax(CMP_IN CGU_Vec3f texels[16], CMP_INOU...
function CMP_STATIC (line 939) | CMP_STATIC void cmp_RefineMinMaxAsLog2(CMP_IN CGU_Vec3f texels[16], CMP_...
function CMP_STATIC (line 964) | CMP_STATIC void cmp_RefineMinMaxAs16BitLeastSquares(CMP_IN CGU_Vec3f ...
function CMP_STATIC (line 1016) | CMP_STATIC CGU_Vec3f cmp_fabsVec3f(CGU_Vec3f value)
function CMP_STATIC (line 1029) | CMP_STATIC CGU_UINT32 cmp_constructColor(CMP_IN CGU_Vec3ui EndPoints)
function CMP_STATIC (line 1034) | CMP_STATIC CGU_UINT32 cmp_constructColorBGR(CMP_IN CGU_Vec3f EndPoints)
function CMP_STATIC (line 1039) | CMP_STATIC CGU_FLOAT cmp_mod(CMP_IN CGU_FLOAT value, CMP_IN CGU_FLOAT mo...
function CMP_STATIC (line 1047) | CMP_STATIC CGU_Vec3f cmp_truncVec3f(CMP_IN CGU_Vec3f value)
function CMP_STATIC (line 1060) | CMP_STATIC CGU_Vec3f cmp_ceilVec3f(CMP_IN CGU_Vec3f value)
function CMP_STATIC (line 1069) | CMP_STATIC CGU_FLOAT cmp_sqrt(CGU_FLOAT value)
function CMP_STATIC (line 1075) | CMP_STATIC CGV_FLOAT cmp_rsqrt(CGV_FLOAT f)
function CGU_UINT32 (line 1087) | CGU_UINT32 cmp_shift_right_uint32(CMP_IN CGU_UINT32 v, CMP_IN CGU_INT bits)
function CGU_INT (line 1092) | CGU_INT cmp_clampi(CMP_IN CGU_INT value, CMP_IN CGU_INT low, CMP_IN CGU_...
function CGU_INT32 (line 1101) | CGU_INT32 cmp_clampi32(CMP_IN CGU_INT32 value, CMP_IN CGU_INT32 low, CMP...
function CMP_STATIC (line 1110) | CMP_STATIC CGV_FLOAT cmp_dot4f(CMP_IN CGV_Vec4f value1, CMP_IN CGV_Vec4f...
function cmp_set_vec4f (line 1119) | void cmp_set_vec4f(CMP_INOUT CGU_Vec4f CMP_REFINOUT pV, CMP_IN CGU_FLOAT...
function cmp_set_vec4ui (line 1127) | void cmp_set_vec4ui(CGU_Vec4ui CMP_REFINOUT pV, CMP_IN CGU_UINT8 x, CMP_...
function CMP_STATIC (line 1135) | CMP_STATIC inline void cmp_set_vec4ui_clamped(CGU_Vec4ui CMP_REFINOUT pR...
function CMP_STATIC (line 1143) | CMP_STATIC inline CGU_Vec4f cmp_clampNorm4f(CMP_IN CGU_Vec4f pV)
function CGU_Vec4f (line 1153) | CGU_Vec4f cmp_vec4ui_to_vec4f(CMP_IN CGU_Vec4ui pC)
function cmp_normalize (line 1160) | void cmp_normalize(CGU_Vec4f CMP_REFINOUT pV)
function CGV_FLOAT (line 1170) | CGV_FLOAT cmp_squaref(CMP_IN CGV_FLOAT v)
function CGU_INT (line 1175) | CGU_INT cmp_squarei(CMP_IN CGU_INT i)
function CMP_STATIC (line 1180) | CMP_STATIC CGU_UINT8 cmp_clampui8(CMP_IN CGU_UINT8 v, CMP_IN CGU_UINT8 a...
function CMP_STATIC (line 1189) | CMP_STATIC CGU_INT32 cmp_abs32(CMP_IN CGU_INT32 v)
function CMP_STATIC (line 1195) | CMP_STATIC void cmp_swap32(CMP_INOUT CGU_UINT32 CMP_REFINOUT a, CMP_INOU...
function CMP_STATIC (line 1203) | CMP_STATIC CGV_FLOAT cmp_Image_rsqrt(CMP_IN CGV_FLOAT f)
function CMP_STATIC (line 1212) | CMP_STATIC void cmp_pack4bitindex32(CMP_INOUT CGU_UINT32 packed_index[2]...
function CMP_STATIC (line 1226) | CMP_STATIC void cmp_pack4bitindex(CMP_INOUT CGU_UINT32 packed_index[2], ...
function CGU_INT (line 1240) | CGU_INT cmp_expandbits(CMP_IN CGU_INT v, CMP_IN CGU_INT bits)
function CGU_UINT8 (line 1247) | CGU_UINT8 cmp_ep_find_floor2(CMP_IN CGV_FLOAT v, CMP_IN CGU_UINT8 bits, ...
function CMP_STATIC (line 1265) | CMP_STATIC CGV_FLOAT cmp_absf(CMP_IN CGV_FLOAT a)
function CGU_UINT32 (line 1270) | CGU_UINT32 cmp_pow2Packed(CMP_IN CGU_INT x)
function CGU_UINT8 (line 1275) | CGU_UINT8 cmp_clampIndex(CMP_IN CGU_UINT8 v, CMP_IN CGU_UINT8 a, CMP_IN ...
function CGU_UINT8 (line 1284) | CGU_UINT8 shift_right_uint82(CMP_IN CGU_UINT8 v, CMP_IN CGU_UINT8 bits)
function CMP_STATIC (line 1291) | CMP_STATIC CGU_INT cmp_QuantizeToBitSize(CMP_IN CGU_INT value, CMP_IN CG...
FILE: data/shaders/compressonator/bcn_common_kernel.h
type CMP_BLOCK64_UNORM (line 130) | typedef union
type CMP_BLOCK64_SNORM (line 143) | typedef union
type CMP_BLOCK128_UNORM (line 156) | typedef union
type CMP_di (line 165) | typedef struct
type CMP_df (line 171) | typedef struct
type CMP_BC15Options (line 177) | typedef struct
type CMP_BC1_Encode_Results (line 197) | typedef struct
type CMP_EndPoints (line 206) | typedef struct
type CMP_EncodeData (line 214) | typedef struct
type CMP_BC1_Block (line 225) | typedef struct CMP_BC1_Block_t
function CGU_BOOL (line 263) | static CGU_BOOL cmp_compareprecision(CGU_FLOAT f1, CGU_FLOAT f2, CGU_INT...
function CGU_FLOAT (line 271) | static CGU_FLOAT cmp_getfloatprecision(CGU_FLOAT f1, CGU_INT Prec)
function CGU_FLOAT (line 277) | static CGU_FLOAT cmp_getIndicesRGB(CMP_INOUT CGU_UINT32 CMP_PTRINOUT cmp...
function SetDefaultBC15Options (line 336) | static void SetDefaultBC15Options(CMP_BC15Options* BC15Options)
function CMP_BC15Options (line 364) | static CMP_BC15Options CalculateColourWeightings(CGU_Vec4f rgbaBlock[BLO...
function CMP_BC15Options (line 430) | static CMP_BC15Options CalculateColourWeightings3f(CGU_Vec3f rgbBlock[BL...
function CGU_FLOAT (line 496) | static CGU_FLOAT cmp_getRampErr(CGU_FLOAT Prj[BLOCK_SIZE_4X4],
function CGU_Vec2ui (line 536) | static CGU_Vec2ui cmp_compressExplicitAlphaBlock(const CGU_FLOAT AlphaBl...
function CGU_FLOAT (line 559) | static CGU_FLOAT cmp_getRampError(CGU_FLOAT _Blk[BLOCK_SIZE_4X4],
function CGU_FLOAT (line 599) | static CGU_FLOAT cmp_linearBlockRefine(CGU_FLOAT ...
function CGU_Vec2f (line 660) | static CGU_Vec2f cmp_getLinearEndPoints(CGU_FLOAT _Blk[BLOCK_SIZE_4X4], ...
function CGU_Vec2ui (line 851) | static CGU_Vec2ui cmp_getBlockPackedIndices(CGU_Vec2f RampMinMax, CGU_FL...
function CGU_INT8 (line 1005) | static CGU_INT8 cmp_snormFloatToSInt(CGU_FLOAT fsnorm)
function CGU_Vec2f (line 1030) | static CGU_Vec2f cmp_optimizeEndPoints(CGU_FLOAT pPoints[BLOCK_SIZE_4X4]...
function CGU_Vec2i (line 1163) | static CGU_Vec2i cmp_findEndpointsAlphaBlockSnorm(CGU_FLOAT alphaBlockSn...
function CGU_UINT64 (line 1217) | static CGU_UINT64 cmp_getBlockPackedIndicesSNorm(CGU_Vec2f alphaMinMax, ...
function cmp_getCompressedAlphaRampS (line 1268) | static void cmp_getCompressedAlphaRampS(CGU_INT8 alpha[8], const CGU_UIN...
function cmp_decompressAlphaBlockS (line 1313) | static void cmp_decompressAlphaBlockS(CGU_INT8 alphaBlock[BLOCK_SIZE_4X4...
function CGU_Vec2ui (line 1339) | static CGU_Vec2ui cmp_compressAlphaBlock(CMP_IN CGU_FLOAT alphaBlock[BLO...
function cmp_getCompressedAlphaRamp (line 1400) | static void cmp_getCompressedAlphaRamp(CGU_UINT8 alpha[8], const CGU_UIN...
function cmp_decompressAlphaBlock (line 1445) | static void cmp_decompressAlphaBlock(CGU_UINT8 alphaBlock[BLOCK_SIZE_4X4...
function cmp_ProcessColors (line 1468) | static void cmp_ProcessColors(CMP_INOUT CGU_Vec3f CMP_PTRINOUT colorMin,
function cmp_decompressDXTRGBA_Internal (line 1534) | static void cmp_decompressDXTRGBA_Internal(CGU_UINT8 rgbBlock[BLOCK_SIZE...
function cmp_decompressRGBBlock (line 1690) | static void cmp_decompressRGBBlock(CMP_INOUT CGU_Vec3f rgbBlock[BLOCK_SI...
function CMP_RGBBlockError (line 1757) | static float CMP_RGBBlockError(const CGU_Vec3f src_rgbBlock[BLOCK_SIZE_4...
function CGU_FLOAT (line 1804) | static CGU_FLOAT cpu_bcnComputeBestEndpoints(CGU_FLOAT endpointsOut[NUM_...
function CGU_Vec2ui (line 1846) | static CGU_Vec2ui CompressRGBBlock_FM(const CGU_Vec3f rgbBlockUVf[16], C...
function CMP_EndPoints (line 2125) | static CMP_EndPoints CompressRGBBlock_Slow(CGU_Vec3f BlkInBGRf_UV[BLOCK...
function CGU_Vec2ui (line 2545) | static CGU_Vec2ui CompressBlockBC1_RGBA_Internal(const CGU_Vec3f rgbBlo...
function CGU_Vec2ui (line 2883) | static CGU_Vec2ui CompressBlockBC1_UNORM(CGU_Vec3f rgbablockf[BLOCK_SIZE...
function CGU_Vec4ui (line 2898) | static CGU_Vec4ui CompressBlockBC2_UNORM(CMP_IN CGU_Vec3f BlockRGB[BLOCK...
function CGU_Vec4ui (line 2917) | static CGU_Vec4ui CompressBlockBC3_UNORM(CMP_IN CGU_Vec3f BlockRGB[BLOCK...
function CGU_Vec2ui (line 2937) | static CGU_Vec2ui CompressBlockBC4_UNORM(CMP_IN CGU_FLOAT Block[BLOCK_SI...
function CGU_Vec2ui (line 2945) | static CGU_Vec2ui CompressBlockBC4_SNORM(CMP_IN CGU_FLOAT Block[BLOCK_SI...
function CGU_Vec4ui (line 2953) | static CGU_Vec4ui CompressBlockBC5_UNORM(CMP_IN CGU_FLOAT BlockU[BLOCK_S...
FILE: data/shaders/compressonator/common_def.h
type float2 (line 189) | typedef float2 CGU_Vec2f;
type float2 (line 190) | typedef float2 CGV_Vec2f;
type float3 (line 191) | typedef float3 CGU_Vec3f;
type float3 (line 192) | typedef float3 CGV_Vec3f;
type float4 (line 193) | typedef float4 CGU_Vec4f;
type float4 (line 194) | typedef float4 CGV_Vec4f;
type int2 (line 196) | typedef int2 CGU_Vec2i;
type int2 (line 197) | typedef int2 CGV_Vec2i;
type uint2 (line 198) | typedef uint2 CGU_Vec2ui;
type uint2 (line 199) | typedef uint2 CGV_Vec2ui;
type int3 (line 201) | typedef int3 CGU_Vec3i;
type int3 (line 202) | typedef int3 CGV_Vec3i;
type uint3 (line 203) | typedef uint3 CGU_Vec3ui;
type uint3 (line 204) | typedef uint3 CGV_Vec3ui;
type int4 (line 206) | typedef int4 CGU_Vec4i;
type int4 (line 207) | typedef int4 CGV_Vec4i;
type int4 (line 209) | typedef int4 CGU_Vec4uc;
type int4 (line 210) | typedef int4 CGV_Vec4uc;
type uint4 (line 212) | typedef uint4 CGU_Vec4ui;
type uint4 (line 213) | typedef uint4 CGV_Vec4ui;
type CGU_INT8 (line 216) | typedef int CGU_INT8;
type CGU_INT (line 217) | typedef int CGU_INT;
type CGV_INT (line 218) | typedef int CGV_INT;
type uint (line 219) | typedef uint CGU_UINT8;
type uint (line 220) | typedef uint CGU_UINT;
type CGU_BOOL (line 223) | typedef int CGU_BOOL;
type CGV_BOOL (line 224) | typedef int CGV_BOOL;
type CGV_INT8 (line 225) | typedef int CGV_INT8;
type CGV_UINT8 (line 226) | typedef int CGV_UINT8;
type uint (line 227) | typedef uint CGU_UINT16;
type CGU_INT32 (line 228) | typedef int CGU_INT32;
type CGV_INT32 (line 229) | typedef int CGV_INT32;
type uint (line 230) | typedef uint CGU_UINT32;
type uint (line 231) | typedef uint CGV_UINT32;
type CGV_FLOAT (line 232) | typedef float CGV_FLOAT;
type CGU_FLOAT (line 233) | typedef float CGU_FLOAT;
type min16float (line 234) | typedef min16float CGU_MIN16_FLOAT;
type CGU_ERROR_CODES (line 266) | typedef enum
type float2 (line 279) | typedef float2 CGU_Vec2f;
type float2 (line 280) | typedef float2 CGV_Vec2f;
type float3 (line 281) | typedef float3 CMP_Vec3f;
type float3 (line 282) | typedef float3 CGU_Vec3f;
type float3 (line 283) | typedef float3 CGV_Vec3f;
type float4 (line 284) | typedef float4 CGU_Vec4f;
type float4 (line 285) | typedef float4 CGV_Vec4f;
type uchar3 (line 287) | typedef uchar3 CGU_Vec3uc;
type uchar3 (line 288) | typedef uchar3 CGV_Vec3uc;
type uchar4 (line 290) | typedef uchar4 CMP_Vec4uc;
type uchar4 (line 291) | typedef uchar4 CGU_Vec4uc;
type uchar4 (line 292) | typedef uchar4 CGV_Vec4uc;
type int2 (line 294) | typedef int2 CGU_Vec2i;
type int2 (line 295) | typedef int2 CGV_Vec2i;
type int3 (line 296) | typedef int3 CGU_Vec3i;
type int3 (line 297) | typedef int3 CGV_Vec3i;
type int4 (line 298) | typedef int4 CGU_Vec4i;
type int4 (line 299) | typedef int4 CGV_Vec4i;
type uint2 (line 302) | typedef uint2 CGU_Vec2ui;
type uint2 (line 303) | typedef uint2 CGV_Vec2ui;
type uint3 (line 304) | typedef uint3 CGU_Vec3ui;
type uint3 (line 305) | typedef uint3 CGV_Vec3ui;
type uint4 (line 306) | typedef uint4 CGU_Vec4ui;
type uint4 (line 307) | typedef uint4 CGV_Vec4ui;
type CGU_DWORD (line 329) | typedef unsigned int CGU_DWORD;
type CGU_INT (line 330) | typedef int CGU_INT;
type CGU_BOOL (line 331) | typedef bool CGU_BOOL;
type CGU_SHORT (line 332) | typedef unsigned short CGU_SHORT;
type CGU_FLOAT (line 333) | typedef float CGU_FLOAT;
type half (line 334) | typedef half CGU_MIN16_FLOAT;
type uint32 (line 335) | typedef unsigned int uint32;
type CGV_INT (line 337) | typedef int CGV_INT;
type CGU_UINT (line 338) | typedef unsigned int CGU_UINT;
type CGUV_INT (line 339) | typedef int CGUV_INT;
type CGV_BOOL (line 340) | typedef int CGV_BOOL;
type CGU_INT8 (line 342) | typedef char CGU_INT8;
type CGU_UINT8 (line 343) | typedef unsigned char CGU_UINT8;
type CGU_INT16 (line 344) | typedef short CGU_INT16;
type CGU_UINT16 (line 345) | typedef unsigned short CGU_UINT16;
type CGU_INT32 (line 346) | typedef int CGU_INT32;
type CGU_UINT32 (line 347) | typedef unsigned int CGU_UINT32;
type CGU_UINT64 (line 348) | typedef unsigned long long CGU_UINT64;
type CGV_INT8 (line 350) | typedef char CGV_INT8;
type CGV_UINT8 (line 351) | typedef unsigned char CGV_UINT8;
type CGV_INT16 (line 352) | typedef short CGV_INT16;
type CGV_UINT16 (line 353) | typedef unsigned short CGV_UINT16;
type CGV_INT32 (line 354) | typedef int CGV_INT32;
type CGV_UINT32 (line 355) | typedef unsigned int CGV_UINT32;
type CGV_UINT64 (line 356) | typedef unsigned long CGV_UINT64;
type CGV_FLOAT (line 358) | typedef float CGV_FLOAT;
type CMP_UNIFORM (line 388) | typedef CMP_UNIFORM bool CGU_BOOL;
type CGV_BOOL (line 389) | typedef bool CGV_BOOL;
type uint8 (line 391) | typedef unsigned int8 uint8;
type uint16 (line 392) | typedef unsigned int16 uint16;
type uint32 (line 393) | typedef unsigned int32 uint32;
type uint64 (line 394) | typedef unsigned int64 uint64;
type CMP_UNIFORM (line 395) | typedef CMP_UNIFORM float CGU_FLOAT;
type varying (line 396) | typedef varying float CGV_FLOAT;
type CMP_UNIFORM (line 397) | typedef CMP_UNIFORM float CGU_MIN16_FLOAT;
type CMP_UNIFORM (line 399) | typedef CMP_UNIFORM uint16 CGU_UINT16;
type CMP_UNIFORM (line 401) | typedef CMP_UNIFORM uint8 CGU_UINT8;
type varying (line 402) | typedef varying uint8 CGV_UINT8;
type CMP_UNIFORM (line 404) | typedef CMP_UNIFORM uint64 CGU_UINT64;
type CGV_UINT8 (line 406) | typedef CGV_UINT8<4> CGV_Vec4uc;
type CGU_UINT8 (line 407) | typedef CGU_UINT8<4> CGU_Vec4uc;
type CGU_FLOAT (line 409) | typedef CGU_FLOAT<2> CGU_Vec2f;
type CGV_FLOAT (line 410) | typedef CGV_FLOAT<2> CGV_Vec2f;
type CGU_FLOAT (line 411) | typedef CGU_FLOAT<3> CGU_Vec3f;
type CGV_FLOAT (line 412) | typedef CGV_FLOAT<3> CGV_Vec3f;
type CGU_FLOAT (line 413) | typedef CGU_FLOAT<4> CGU_Vec4f;
type CGV_FLOAT (line 414) | typedef CGV_FLOAT<4> CGV_Vec4f;
type CGU_UINT32 (line 416) | typedef CGU_UINT32<3> CGU_Vec3ui;
type CGV_UINT32 (line 417) | typedef CGV_UINT32<3> CGV_Vec3ui;
type CGU_UINT32 (line 419) | typedef CGU_UINT32<4> CGU_Vec4ui;
type CGV_UINT32 (line 420) | typedef CGV_UINT32<4> CGV_Vec4ui;
type int8 (line 440) | typedef char int8;
type int16 (line 441) | typedef short int16;
type int32 (line 442) | typedef int int32;
type int64 (line 443) | typedef long long int64;
type uint8 (line 444) | typedef unsigned char uint8;
type uint16 (line 445) | typedef unsigned short uint16;
type uint32 (line 446) | typedef unsigned int uint32;
type uint64 (line 447) | typedef unsigned long long uint64;
type int8 (line 449) | typedef int8 CGV_BOOL;
type CGU_BOOL (line 450) | typedef bool CGU_BOOL;
type int16 (line 451) | typedef int16 CGU_WORD;
type uint8 (line 452) | typedef uint8 CGU_SHORT;
type CGU_LONG (line 453) | typedef long CGU_LONG;
type CGU_ULONG (line 454) | typedef unsigned long CGU_ULONG;
type CMP_UNIFORM (line 456) | typedef CMP_UNIFORM float CGU_FLOAT;
type varying (line 457) | typedef varying float CGV_FLOAT;
type CMP_UNIFORM (line 458) | typedef CMP_UNIFORM float CGU_MIN16_FLOAT;
type CMP_UNIFORM (line 460) | typedef CMP_UNIFORM uint8 CGU_UINT8;
type varying (line 461) | typedef varying uint8 CGV_UINT8;
type CMP_UNIFORM (line 463) | typedef CMP_UNIFORM uint16 CGU_UINT16;
type CMP_Vec3ui (line 465) | typedef CMP_Vec3ui CGU_Vec3ui;
type CMP_Vec3ui (line 466) | typedef CMP_Vec3ui CGV_Vec3ui;
type CMP_Vec2f (line 468) | typedef CMP_Vec2f CGU_Vec2f;
type CMP_Vec3f (line 469) | typedef CMP_Vec3f CGU_Vec3f;
type CMP_Vec4uc (line 471) | typedef CMP_Vec4uc CGU_Vec4uc;
type CMP_Vec4uc (line 472) | typedef CMP_Vec4uc CGV_Vec4uc;
type CMP_Vec4i (line 473) | typedef CMP_Vec4i CGU_Vec4i;
type CMP_Vec4ui (line 474) | typedef CMP_Vec4ui CGU_Vec4ui;
type CMP_Vec4ui (line 475) | typedef CMP_Vec4ui CGV_Vec4ui;
type CMP_Vec4f (line 476) | typedef CMP_Vec4f CGU_Vec4f;
type CMP_Vec4f (line 477) | typedef CMP_Vec4f CGV_Vec4f;
type CMP_UNIFORM (line 497) | typedef CMP_UNIFORM int32 CGU_DWORD;
type CMP_UNIFORM (line 498) | typedef CMP_UNIFORM uint8 CGU_UBYTE;
type CMP_UNIFORM (line 499) | typedef CMP_UNIFORM int CGU_INT;
type CMP_UNIFORM (line 500) | typedef CMP_UNIFORM int8 CGU_INT8;
type CMP_UNIFORM (line 502) | typedef CMP_UNIFORM int16 CGU_INT16;
type CMP_UNIFORM (line 503) | typedef CMP_UNIFORM uint16 CGU_UINT16;
type CMP_UNIFORM (line 504) | typedef CMP_UNIFORM int32 CGU_INT32;
type CMP_UNIFORM (line 505) | typedef CMP_UNIFORM uint32 CGU_UINT32;
type CMP_UNIFORM (line 506) | typedef CMP_UNIFORM uint64 CGU_UINT64;
type CGV_INT (line 508) | typedef int CGV_INT;
type int8 (line 509) | typedef int8 CGV_INT8;
type int16 (line 510) | typedef int16 CGV_INT16;
type int32 (line 511) | typedef int32 CGV_INT32;
type uint16 (line 512) | typedef uint16 CGV_UINT16;
type uint32 (line 513) | typedef uint32 CGV_UINT32;
type uint64 (line 514) | typedef uint64 CGV_UINT64;
type Source_Info (line 520) | typedef struct
type texture_surface (line 532) | struct texture_surface
type AP1 (line 620) | typedef uint32_t AP1;
type AF1 (line 621) | typedef float AF1;
type AD1 (line 622) | typedef double AD1;
type AB1 (line 623) | typedef uint8_t AB1;
type AW1 (line 624) | typedef uint16_t AW1;
type AU1 (line 625) | typedef uint32_t AU1;
type AL1 (line 626) | typedef uint64_t AL1;
type ASB1 (line 627) | typedef int8_t ASB1;
type ASW1 (line 628) | typedef int16_t ASW1;
type ASU1 (line 629) | typedef int32_t ASU1;
type ASL1 (line 630) | typedef int64_t ASL1;
function A_STATIC (line 641) | A_STATIC AU1 AU1_AF1(AF1 a){union{AF1 f;AU1 u;}bits;bits.f=a;return bits...
function A_STATIC (line 756) | A_STATIC AD1 AAbsD1(AD1 a){return __builtin_fabs(a);}
function A_STATIC (line 757) | A_STATIC AF1 AAbsF1(AF1 a){return __builtin_fabsf(a);}
function A_STATIC (line 758) | A_STATIC AU1 AAbsSU1(AU1 a){return AU1_(__builtin_abs(ASU1_(a)));}
function A_STATIC (line 759) | A_STATIC AL1 AAbsSL1(AL1 a){return AL1_(__builtin_labs(ASL1_(a)));}
function A_STATIC (line 761) | A_STATIC AD1 AAbsD1(AD1 a){return fabs(a);}
function A_STATIC (line 762) | A_STATIC AF1 AAbsF1(AF1 a){return fabsf(a);}
function A_STATIC (line 763) | A_STATIC AU1 AAbsSU1(AU1 a){return AU1_(abs(ASU1_(a)));}
function A_STATIC (line 764) | A_STATIC AL1 AAbsSL1(AL1 a){return AL1_(llabs(ASL1_(a)));}
function A_STATIC (line 768) | A_STATIC AD1 ACosD1(AD1 a){return __builtin_cos(a);}
function A_STATIC (line 769) | A_STATIC AF1 ACosF1(AF1 a){return __builtin_cosf(a);}
function A_STATIC (line 771) | A_STATIC AD1 ACosD1(AD1 a){return cos(a);}
function A_STATIC (line 772) | A_STATIC AF1 ACosF1(AF1 a){return cosf(a);}
function A_STATIC (line 775) | A_STATIC AD1 ADotD2(inAD2 a,inAD2 b){return a[0]*b[0]+a[1]*b[1];}
function A_STATIC (line 776) | A_STATIC AD1 ADotD3(inAD3 a,inAD3 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];}
function A_STATIC (line 777) | A_STATIC AD1 ADotD4(inAD4 a,inAD4 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2...
function A_STATIC (line 778) | A_STATIC AF1 ADotF2(inAF2 a,inAF2 b){return a[0]*b[0]+a[1]*b[1];}
function A_STATIC (line 779) | A_STATIC AF1 ADotF3(inAF3 a,inAF3 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];}
function A_STATIC (line 780) | A_STATIC AF1 ADotF4(inAF4 a,inAF4 b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2...
function A_STATIC (line 783) | A_STATIC AD1 AExp2D1(AD1 a){return __builtin_exp2(a);}
function A_STATIC (line 784) | A_STATIC AF1 AExp2F1(AF1 a){return __builtin_exp2f(a);}
function A_STATIC (line 786) | A_STATIC AD1 AExp2D1(AD1 a){return exp2(a);}
function A_STATIC (line 787) | A_STATIC AF1 AExp2F1(AF1 a){return exp2f(a);}
function A_STATIC (line 791) | A_STATIC AD1 AFloorD1(AD1 a){return __builtin_floor(a);}
function A_STATIC (line 792) | A_STATIC AF1 AFloorF1(AF1 a){return __builtin_floorf(a);}
function A_STATIC (line 794) | A_STATIC AD1 AFloorD1(AD1 a){return floor(a);}
function A_STATIC (line 795) | A_STATIC AF1 AFloorF1(AF1 a){return floorf(a);}
function A_STATIC (line 798) | A_STATIC AD1 ALerpD1(AD1 a,AD1 b,AD1 c){return b*c+(-a*c+a);}
function A_STATIC (line 799) | A_STATIC AF1 ALerpF1(AF1 a,AF1 b,AF1 c){return b*c+(-a*c+a);}
function A_STATIC (line 802) | A_STATIC AD1 ALog2D1(AD1 a){return __builtin_log2(a);}
function A_STATIC (line 803) | A_STATIC AF1 ALog2F1(AF1 a){return __builtin_log2f(a);}
function A_STATIC (line 805) | A_STATIC AD1 ALog2D1(AD1 a){return log2(a);}
function A_STATIC (line 806) | A_STATIC AF1 ALog2F1(AF1 a){return log2f(a);}
function A_STATIC (line 809) | A_STATIC AD1 AMaxD1(AD1 a,AD1 b){return a>b?a:b;}
function A_STATIC (line 810) | A_STATIC AF1 AMaxF1(AF1 a,AF1 b){return a>b?a:b;}
function A_STATIC (line 811) | A_STATIC AL1 AMaxL1(AL1 a,AL1 b){return a>b?a:b;}
function A_STATIC (line 812) | A_STATIC AU1 AMaxU1(AU1 a,AU1 b){return a>b?a:b;}
function A_STATIC (line 815) | A_STATIC AL1 AMaxSL1(AL1 a,AL1 b){return (ASL1_(a)>ASL1_(b))?a:b;}
function A_STATIC (line 816) | A_STATIC AU1 AMaxSU1(AU1 a,AU1 b){return (ASU1_(a)>ASU1_(b))?a:b;}
function A_STATIC (line 818) | A_STATIC AD1 AMinD1(AD1 a,AD1 b){return a<b?a:b;}
function A_STATIC (line 819) | A_STATIC AF1 AMinF1(AF1 a,AF1 b){return a<b?a:b;}
function A_STATIC (line 820) | A_STATIC AL1 AMinL1(AL1 a,AL1 b){return a<b?a:b;}
function A_STATIC (line 821) | A_STATIC AU1 AMinU1(AU1 a,AU1 b){return a<b?a:b;}
function A_STATIC (line 823) | A_STATIC AL1 AMinSL1(AL1 a,AL1 b){return (ASL1_(a)<ASL1_(b))?a:b;}
function A_STATIC (line 824) | A_STATIC AU1 AMinSU1(AU1 a,AU1 b){return (ASU1_(a)<ASU1_(b))?a:b;}
function A_STATIC (line 826) | A_STATIC AD1 ARcpD1(AD1 a){return 1.0/a;}
function A_STATIC (line 827) | A_STATIC AF1 ARcpF1(AF1 a){return 1.0f/a;}
function A_STATIC (line 829) | A_STATIC AL1 AShrSL1(AL1 a,AL1 b){return AL1_(ASL1_(a)>>ASL1_(b));}
function A_STATIC (line 830) | A_STATIC AU1 AShrSU1(AU1 a,AU1 b){return AU1_(ASU1_(a)>>ASU1_(b));}
function A_STATIC (line 833) | A_STATIC AD1 ASinD1(AD1 a){return __builtin_sin(a);}
function A_STATIC (line 834) | A_STATIC AF1 ASinF1(AF1 a){return __builtin_sinf(a);}
function A_STATIC (line 836) | A_STATIC AD1 ASinD1(AD1 a){return sin(a);}
function A_STATIC (line 837) | A_STATIC AF1 ASinF1(AF1 a){return sinf(a);}
function A_STATIC (line 841) | A_STATIC AD1 ASqrtD1(AD1 a){return __builtin_sqrt(a);}
function A_STATIC (line 842) | A_STATIC AF1 ASqrtF1(AF1 a){return __builtin_sqrtf(a);}
function A_STATIC (line 844) | A_STATIC AD1 ASqrtD1(AD1 a){return sqrt(a);}
function A_STATIC (line 845) | A_STATIC AF1 ASqrtF1(AF1 a){return sqrtf(a);}
function A_STATIC (line 853) | A_STATIC AD1 AFractD1(AD1 a){return a-AFloorD1(a);}
function A_STATIC (line 854) | A_STATIC AF1 AFractF1(AF1 a){return a-AFloorF1(a);}
function A_STATIC (line 856) | A_STATIC AD1 APowD1(AD1 a,AD1 b){return AExp2D1(b*ALog2D1(a));}
function A_STATIC (line 857) | A_STATIC AF1 APowF1(AF1 a,AF1 b){return AExp2F1(b*ALog2F1(a));}
function A_STATIC (line 859) | A_STATIC AD1 ARsqD1(AD1 a){return ARcpD1(ASqrtD1(a));}
function A_STATIC (line 860) | A_STATIC AF1 ARsqF1(AF1 a){return ARcpF1(ASqrtF1(a));}
function A_STATIC (line 862) | A_STATIC AD1 ASatD1(AD1 a){return AMinD1(1.0,AMaxD1(0.0,a));}
function A_STATIC (line 863) | A_STATIC AF1 ASatF1(AF1 a){return AMinF1(1.0f,AMaxF1(0.0f,a));}
function A_STATIC (line 873) | A_STATIC retAD2 opAAbsD2(outAD2 d,inAD2 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1...
function A_STATIC (line 874) | A_STATIC retAD3 opAAbsD3(outAD3 d,inAD3 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1...
function A_STATIC (line 875) | A_STATIC retAD4 opAAbsD4(outAD4 d,inAD4 a){d[0]=AAbsD1(a[0]);d[1]=AAbsD1...
function A_STATIC (line 877) | A_STATIC retAF2 opAAbsF2(outAF2 d,inAF2 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1...
function A_STATIC (line 878) | A_STATIC retAF3 opAAbsF3(outAF3 d,inAF3 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1...
function A_STATIC (line 879) | A_STATIC retAF4 opAAbsF4(outAF4 d,inAF4 a){d[0]=AAbsF1(a[0]);d[1]=AAbsF1...
function A_STATIC (line 881) | A_STATIC retAD2 opAAddD2(outAD2 d,inAD2 a,inAD2 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 882) | A_STATIC retAD3 opAAddD3(outAD3 d,inAD3 a,inAD3 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 883) | A_STATIC retAD4 opAAddD4(outAD4 d,inAD4 a,inAD4 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 885) | A_STATIC retAF2 opAAddF2(outAF2 d,inAF2 a,inAF2 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 886) | A_STATIC retAF3 opAAddF3(outAF3 d,inAF3 a,inAF3 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 887) | A_STATIC retAF4 opAAddF4(outAF4 d,inAF4 a,inAF4 b){d[0]=a[0]+b[0];d[1]=a...
function A_STATIC (line 889) | A_STATIC retAD2 opACpyD2(outAD2 d,inAD2 a){d[0]=a[0];d[1]=a[1];return d;}
function A_STATIC (line 890) | A_STATIC retAD3 opACpyD3(outAD3 d,inAD3 a){d[0]=a[0];d[1]=a[1];d[2]=a[2]...
function A_STATIC (line 891) | A_STATIC retAD4 opACpyD4(outAD4 d,inAD4 a){d[0]=a[0];d[1]=a[1];d[2]=a[2]...
function A_STATIC (line 893) | A_STATIC retAF2 opACpyF2(outAF2 d,inAF2 a){d[0]=a[0];d[1]=a[1];return d;}
function A_STATIC (line 894) | A_STATIC retAF3 opACpyF3(outAF3 d,inAF3 a){d[0]=a[0];d[1]=a[1];d[2]=a[2]...
function A_STATIC (line 895) | A_STATIC retAF4 opACpyF4(outAF4 d,inAF4 a){d[0]=a[0];d[1]=a[1];d[2]=a[2]...
function A_STATIC (line 897) | A_STATIC retAD2 opALerpD2(outAD2 d,inAD2 a,inAD2 b,inAD2 c){d[0]=ALerpD1...
function A_STATIC (line 898) | A_STATIC retAD3 opALerpD3(outAD3 d,inAD3 a,inAD3 b,inAD3 c){d[0]=ALerpD1...
function A_STATIC (line 899) | A_STATIC retAD4 opALerpD4(outAD4 d,inAD4 a,inAD4 b,inAD4 c){d[0]=ALerpD1...
function A_STATIC (line 901) | A_STATIC retAF2 opALerpF2(outAF2 d,inAF2 a,inAF2 b,inAF2 c){d[0]=ALerpF1...
function A_STATIC (line 902) | A_STATIC retAF3 opALerpF3(outAF3 d,inAF3 a,inAF3 b,inAF3 c){d[0]=ALerpF1...
function A_STATIC (line 903) | A_STATIC retAF4 opALerpF4(outAF4 d,inAF4 a,inAF4 b,inAF4 c){d[0]=ALerpF1...
function A_STATIC (line 905) | A_STATIC retAD2 opALerpOneD2(outAD2 d,inAD2 a,inAD2 b,AD1 c){d[0]=ALerpD...
function A_STATIC (line 906) | A_STATIC retAD3 opALerpOneD3(outAD3 d,inAD3 a,inAD3 b,AD1 c){d[0]=ALerpD...
function A_STATIC (line 907) | A_STATIC retAD4 opALerpOneD4(outAD4 d,inAD4 a,inAD4 b,AD1 c){d[0]=ALerpD...
function A_STATIC (line 909) | A_STATIC retAF2 opALerpOneF2(outAF2 d,inAF2 a,inAF2 b,AF1 c){d[0]=ALerpF...
function A_STATIC (line 910) | A_STATIC retAF3 opALerpOneF3(outAF3 d,inAF3 a,inAF3 b,AF1 c){d[0]=ALerpF...
function A_STATIC (line 911) | A_STATIC retAF4 opALerpOneF4(outAF4 d,inAF4 a,inAF4 b,AF1 c){d[0]=ALerpF...
function A_STATIC (line 913) | A_STATIC retAD2 opAMaxD2(outAD2 d,inAD2 a,inAD2 b){d[0]=AMaxD1(a[0],b[0]...
function A_STATIC (line 914) | A_STATIC retAD3 opAMaxD3(outAD3 d,inAD3 a,inAD3 b){d[0]=AMaxD1(a[0],b[0]...
function A_STATIC (line 915) | A_STATIC retAD4 opAMaxD4(outAD4 d,inAD4 a,inAD4 b){d[0]=AMaxD1(a[0],b[0]...
function A_STATIC (line 917) | A_STATIC retAF2 opAMaxF2(outAF2 d,inAF2 a,inAF2 b){d[0]=AMaxF1(a[0],b[0]...
function A_STATIC (line 918) | A_STATIC retAF3 opAMaxF3(outAF3 d,inAF3 a,inAF3 b){d[0]=AMaxF1(a[0],b[0]...
function A_STATIC (line 919) | A_STATIC retAF4 opAMaxF4(outAF4 d,inAF4 a,inAF4 b){d[0]=AMaxF1(a[0],b[0]...
function A_STATIC (line 921) | A_STATIC retAD2 opAMinD2(outAD2 d,inAD2 a,inAD2 b){d[0]=AMinD1(a[0],b[0]...
function A_STATIC (line 922) | A_STATIC retAD3 opAMinD3(outAD3 d,inAD3 a,inAD3 b){d[0]=AMinD1(a[0],b[0]...
function A_STATIC (line 923) | A_STATIC retAD4 opAMinD4(outAD4 d,inAD4 a,inAD4 b){d[0]=AMinD1(a[0],b[0]...
function A_STATIC (line 925) | A_STATIC retAF2 opAMinF2(outAF2 d,inAF2 a,inAF2 b){d[0]=AMinF1(a[0],b[0]...
function A_STATIC (line 926) | A_STATIC retAF3 opAMinF3(outAF3 d,inAF3 a,inAF3 b){d[0]=AMinF1(a[0],b[0]...
function A_STATIC (line 927) | A_STATIC retAF4 opAMinF4(outAF4 d,inAF4 a,inAF4 b){d[0]=AMinF1(a[0],b[0]...
function A_STATIC (line 929) | A_STATIC retAD2 opAMulD2(outAD2 d,inAD2 a,inAD2 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 930) | A_STATIC retAD3 opAMulD3(outAD3 d,inAD3 a,inAD3 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 931) | A_STATIC retAD4 opAMulD4(outAD4 d,inAD4 a,inAD4 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 933) | A_STATIC retAF2 opAMulF2(outAF2 d,inAF2 a,inAF2 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 934) | A_STATIC retAF3 opAMulF3(outAF3 d,inAF3 a,inAF3 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 935) | A_STATIC retAF4 opAMulF4(outAF4 d,inAF4 a,inAF4 b){d[0]=a[0]*b[0];d[1]=a...
function A_STATIC (line 937) | A_STATIC retAD2 opAMulOneD2(outAD2 d,inAD2 a,AD1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 938) | A_STATIC retAD3 opAMulOneD3(outAD3 d,inAD3 a,AD1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 939) | A_STATIC retAD4 opAMulOneD4(outAD4 d,inAD4 a,AD1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 941) | A_STATIC retAF2 opAMulOneF2(outAF2 d,inAF2 a,AF1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 942) | A_STATIC retAF3 opAMulOneF3(outAF3 d,inAF3 a,AF1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 943) | A_STATIC retAF4 opAMulOneF4(outAF4 d,inAF4 a,AF1 b){d[0]=a[0]*b;d[1]=a[1...
function A_STATIC (line 945) | A_STATIC retAD2 opANegD2(outAD2 d,inAD2 a){d[0]=-a[0];d[1]=-a[1];return d;}
function A_STATIC (line 946) | A_STATIC retAD3 opANegD3(outAD3 d,inAD3 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a...
function A_STATIC (line 947) | A_STATIC retAD4 opANegD4(outAD4 d,inAD4 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a...
function A_STATIC (line 949) | A_STATIC retAF2 opANegF2(outAF2 d,inAF2 a){d[0]=-a[0];d[1]=-a[1];return d;}
function A_STATIC (line 950) | A_STATIC retAF3 opANegF3(outAF3 d,inAF3 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a...
function A_STATIC (line 951) | A_STATIC retAF4 opANegF4(outAF4 d,inAF4 a){d[0]=-a[0];d[1]=-a[1];d[2]=-a...
function A_STATIC (line 953) | A_STATIC retAD2 opARcpD2(outAD2 d,inAD2 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1...
function A_STATIC (line 954) | A_STATIC retAD3 opARcpD3(outAD3 d,inAD3 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1...
function A_STATIC (line 955) | A_STATIC retAD4 opARcpD4(outAD4 d,inAD4 a){d[0]=ARcpD1(a[0]);d[1]=ARcpD1...
function A_STATIC (line 957) | A_STATIC retAF2 opARcpF2(outAF2 d,inAF2 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1...
function A_STATIC (line 958) | A_STATIC retAF3 opARcpF3(outAF3 d,inAF3 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1...
function A_STATIC (line 959) | A_STATIC retAF4 opARcpF4(outAF4 d,inAF4 a){d[0]=ARcpF1(a[0]);d[1]=ARcpF1...
function A_STATIC (line 972) | A_STATIC AU1 AU1_AH1_AF1(AF1 f){
function A_STATIC (line 1042) | A_STATIC AU1 AU1_AH2_AF2(inAF2 a){return AU1_AH1_AF1(a[0])+(AU1_AH1_AF1(...
function AF1 (line 1107) | AF1 AF1_x(AF1 a){return AF1(a);}
function AF2 (line 1108) | AF2 AF2_x(AF1 a){return AF2(a,a);}
function AF3 (line 1109) | AF3 AF3_x(AF1 a){return AF3(a,a,a);}
function AF4 (line 1110) | AF4 AF4_x(AF1 a){return AF4(a,a,a,a);}
function AU1 (line 1116) | AU1 AU1_x(AU1 a){return AU1(a);}
function AU2 (line 1117) | AU2 AU2_x(AU1 a){return AU2(a,a);}
function AU3 (line 1118) | AU3 AU3_x(AU1 a){return AU3(a,a,a);}
function AU4 (line 1119) | AU4 AU4_x(AU1 a){return AU4(a,a,a,a);}
function AU1 (line 1125) | AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));}
function AU2 (line 1126) | AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));}
function AU3 (line 1127) | AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));}
function AU4 (line 1128) | AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));}
function AU1 (line 1130) | AU1 ABfe(AU1 src,AU1 off,AU1 bits){return bitfieldExtract(src,ASU1(off),...
function AU1 (line 1131) | AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));}
function AU1 (line 1133) | AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){return bitfieldInsert(src,ins,0,ASU1...
function AF1 (line 1136) | AF1 AFractF1(AF1 x){return fract(x);}
function AF2 (line 1137) | AF2 AFractF2(AF2 x){return fract(x);}
function AF3 (line 1138) | AF3 AFractF3(AF3 x){return fract(x);}
function AF4 (line 1139) | AF4 AFractF4(AF4 x){return fract(x);}
function AF1 (line 1141) | AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return mix(x,y,a);}
function AF2 (line 1142) | AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return mix(x,y,a);}
function AF3 (line 1143) | AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return mix(x,y,a);}
function AF4 (line 1144) | AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return mix(x,y,a);}
function AF1 (line 1147) | AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));}
function AF2 (line 1148) | AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));}
function AF3 (line 1149) | AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));}
function AF4 (line 1150) | AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));}
function AU1 (line 1152) | AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(...
function AU2 (line 1153) | AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(...
function AU3 (line 1154) | AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(...
function AU4 (line 1155) | AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(...
function AU1 (line 1157) | AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));}
function AU2 (line 1158) | AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));}
function AU3 (line 1159) | AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));}
function AU4 (line 1160) | AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));}
function AU1 (line 1162) | AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));}
function AU2 (line 1163) | AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));}
function AU3 (line 1164) | AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));}
function AU4 (line 1165) | AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));}
function AF1 (line 1169) | AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));}
function AF2 (line 1170) | AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));}
function AF3 (line 1171) | AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));}
function AF4 (line 1172) | AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));}
function AF1 (line 1175) | AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));}
function AF2 (line 1176) | AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));}
function AF3 (line 1177) | AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));}
function AF4 (line 1178) | AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));}
function AU1 (line 1180) | AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(...
function AU2 (line 1181) | AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(...
function AU3 (line 1182) | AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(...
function AU4 (line 1183) | AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(...
function AU1 (line 1185) | AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));}
function AU2 (line 1186) | AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));}
function AU3 (line 1187) | AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));}
function AU4 (line 1188) | AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));}
function AU1 (line 1190) | AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));}
function AU2 (line 1191) | AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));}
function AU3 (line 1192) | AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));}
function AU4 (line 1193) | AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));}
function AF1 (line 1197) | AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));}
function AF2 (line 1198) | AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));}
function AF3 (line 1199) | AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));}
function AF4 (line 1200) | AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));}
function AF1 (line 1204) | AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));}
function AF2 (line 1205) | AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));}
function AF3 (line 1206) | AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));}
function AF4 (line 1207) | AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));}
function AF1 (line 1209) | AF1 ARcpF1(AF1 x){return AF1_(1.0)/x;}
function AF2 (line 1210) | AF2 ARcpF2(AF2 x){return AF2_(1.0)/x;}
function AF3 (line 1211) | AF3 ARcpF3(AF3 x){return AF3_(1.0)/x;}
function AF4 (line 1212) | AF4 ARcpF4(AF4 x){return AF4_(1.0)/x;}
function AF1 (line 1214) | AF1 ARsqF1(AF1 x){return AF1_(1.0)/sqrt(x);}
function AF2 (line 1215) | AF2 ARsqF2(AF2 x){return AF2_(1.0)/sqrt(x);}
function AF3 (line 1216) | AF3 ARsqF3(AF3 x){return AF3_(1.0)/sqrt(x);}
function AF4 (line 1217) | AF4 ARsqF4(AF4 x){return AF4_(1.0)/sqrt(x);}
function AF1 (line 1219) | AF1 ASatF1(AF1 x){return clamp(x,AF1_(0.0),AF1_(1.0));}
function AF2 (line 1220) | AF2 ASatF2(AF2 x){return clamp(x,AF2_(0.0),AF2_(1.0));}
function AF3 (line 1221) | AF3 ASatF3(AF3 x){return clamp(x,AF3_(0.0),AF3_(1.0));}
function AF4 (line 1222) | AF4 ASatF4(AF4 x){return clamp(x,AF4_(0.0),AF4_(1.0));}
function AU1 (line 1224) | AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));}
function AU2 (line 1225) | AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));}
function AU3 (line 1226) | AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));}
function AU4 (line 1227) | AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));}
function AB1 (line 1245) | AB1 AB1_x(AB1 a){return AB1(a);}
function AB2 (line 1246) | AB2 AB2_x(AB1 a){return AB2(a,a);}
function AB3 (line 1247) | AB3 AB3_x(AB1 a){return AB3(a,a,a);}
function AB4 (line 1248) | AB4 AB4_x(AB1 a){return AB4(a,a,a,a);}
function AH4 (line 1277) | AH4 AH4_AU2_x(AU2 x){return AH4(unpackFloat2x16(x.x),unpackFloat2x16(x.y...
function AU2 (line 1283) | AU2 AU2_AH4_x(AH4 x){return AU2(packFloat2x16(x.xy),packFloat2x16(x.zw));}
function AH1 (line 1298) | AH1 AH1_x(AH1 a){return AH1(a);}
function AH2 (line 1299) | AH2 AH2_x(AH1 a){return AH2(a,a);}
function AH3 (line 1300) | AH3 AH3_x(AH1 a){return AH3(a,a,a);}
function AH4 (line 1301) | AH4 AH4_x(AH1 a){return AH4(a,a,a,a);}
function AW1 (line 1307) | AW1 AW1_x(AW1 a){return AW1(a);}
function AW2 (line 1308) | AW2 AW2_x(AW1 a){return AW2(a,a);}
function AW3 (line 1309) | AW3 AW3_x(AW1 a){return AW3(a,a,a);}
function AW4 (line 1310) | AW4 AW4_x(AW1 a){return AW4(a,a,a,a);}
function AW1 (line 1316) | AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));}
function AW2 (line 1317) | AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));}
function AW3 (line 1318) | AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));}
function AW4 (line 1319) | AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));}
function AH1 (line 1321) | AH1 AFractH1(AH1 x){return fract(x);}
function AH2 (line 1322) | AH2 AFractH2(AH2 x){return fract(x);}
function AH3 (line 1323) | AH3 AFractH3(AH3 x){return fract(x);}
function AH4 (line 1324) | AH4 AFractH4(AH4 x){return fract(x);}
function AH1 (line 1326) | AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return mix(x,y,a);}
function AH2 (line 1327) | AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return mix(x,y,a);}
function AH3 (line 1328) | AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return mix(x,y,a);}
function AH4 (line 1329) | AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return mix(x,y,a);}
function AH1 (line 1332) | AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));}
function AH2 (line 1333) | AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));}
function AH3 (line 1334) | AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));}
function AH4 (line 1335) | AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));}
function AW1 (line 1337) | AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));}
function AW2 (line 1338) | AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));}
function AW3 (line 1339) | AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));}
function AW4 (line 1340) | AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));}
function AH1 (line 1343) | AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));}
function AH2 (line 1344) | AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));}
function AH3 (line 1345) | AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));}
function AH4 (line 1346) | AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));}
function AW1 (line 1348) | AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));}
function AW2 (line 1349) | AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));}
function AW3 (line 1350) | AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));}
function AW4 (line 1351) | AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));}
function AH1 (line 1353) | AH1 ARcpH1(AH1 x){return AH1_(1.0)/x;}
function AH2 (line 1354) | AH2 ARcpH2(AH2 x){return AH2_(1.0)/x;}
function AH3 (line 1355) | AH3 ARcpH3(AH3 x){return AH3_(1.0)/x;}
function AH4 (line 1356) | AH4 ARcpH4(AH4 x){return AH4_(1.0)/x;}
function AH1 (line 1358) | AH1 ARsqH1(AH1 x){return AH1_(1.0)/sqrt(x);}
function AH2 (line 1359) | AH2 ARsqH2(AH2 x){return AH2_(1.0)/sqrt(x);}
function AH3 (line 1360) | AH3 ARsqH3(AH3 x){return AH3_(1.0)/sqrt(x);}
function AH4 (line 1361) | AH4 ARsqH4(AH4 x){return AH4_(1.0)/sqrt(x);}
function AH1 (line 1363) | AH1 ASatH1(AH1 x){return clamp(x,AH1_(0.0),AH1_(1.0));}
function AH2 (line 1364) | AH2 ASatH2(AH2 x){return clamp(x,AH2_(0.0),AH2_(1.0));}
function AH3 (line 1365) | AH3 ASatH3(AH3 x){return clamp(x,AH3_(0.0),AH3_(1.0));}
function AH4 (line 1366) | AH4 ASatH4(AH4 x){return clamp(x,AH4_(0.0),AH4_(1.0));}
function AW1 (line 1368) | AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));}
function AW2 (line 1369) | AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));}
function AW3 (line 1370) | AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));}
function AW4 (line 1371) | AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));}
function AD1 (line 1383) | AD1 AD1_x(AD1 a){return AD1(a);}
function AD2 (line 1384) | AD2 AD2_x(AD1 a){return AD2(a,a);}
function AD3 (line 1385) | AD3 AD3_x(AD1 a){return AD3(a,a,a);}
function AD4 (line 1386) | AD4 AD4_x(AD1 a){return AD4(a,a,a,a);}
function AD1 (line 1392) | AD1 AFractD1(AD1 x){return fract(x);}
function AD2 (line 1393) | AD2 AFractD2(AD2 x){return fract(x);}
function AD3 (line 1394) | AD3 AFractD3(AD3 x){return fract(x);}
function AD4 (line 1395) | AD4 AFractD4(AD4 x){return fract(x);}
function AD1 (line 1397) | AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return mix(x,y,a);}
function AD2 (line 1398) | AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return mix(x,y,a);}
function AD3 (line 1399) | AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return mix(x,y,a);}
function AD4 (line 1400) | AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return mix(x,y,a);}
function AD1 (line 1402) | AD1 ARcpD1(AD1 x){return AD1_(1.0)/x;}
function AD2 (line 1403) | AD2 ARcpD2(AD2 x){return AD2_(1.0)/x;}
function AD3 (line 1404) | AD3 ARcpD3(AD3 x){return AD3_(1.0)/x;}
function AD4 (line 1405) | AD4 ARcpD4(AD4 x){return AD4_(1.0)/x;}
function AD1 (line 1407) | AD1 ARsqD1(AD1 x){return AD1_(1.0)/sqrt(x);}
function AD2 (line 1408) | AD2 ARsqD2(AD2 x){return AD2_(1.0)/sqrt(x);}
function AD3 (line 1409) | AD3 ARsqD3(AD3 x){return AD3_(1.0)/sqrt(x);}
function AD4 (line 1410) | AD4 ARsqD4(AD4 x){return AD4_(1.0)/sqrt(x);}
function AD1 (line 1412) | AD1 ASatD1(AD1 x){return clamp(x,AD1_(0.0),AD1_(1.0));}
function AD2 (line 1413) | AD2 ASatD2(AD2 x){return clamp(x,AD2_(0.0),AD2_(1.0));}
function AD3 (line 1414) | AD3 ASatD3(AD3 x){return clamp(x,AD3_(0.0),AD3_(1.0));}
function AD4 (line 1415) | AD4 ASatD4(AD4 x){return clamp(x,AD4_(0.0),AD4_(1.0));}
function AL1 (line 1435) | AL1 AL1_x(AL1 a){return AL1(a);}
function AL2 (line 1436) | AL2 AL2_x(AL1 a){return AL2(a,a);}
function AL3 (line 1437) | AL3 AL3_x(AL1 a){return AL3(a,a,a);}
function AL4 (line 1438) | AL4 AL4_x(AL1 a){return AL4(a,a,a,a);}
function AL1 (line 1444) | AL1 AAbsSL1(AL1 a){return AL1(abs(ASL1(a)));}
function AL2 (line 1445) | AL2 AAbsSL2(AL2 a){return AL2(abs(ASL2(a)));}
function AL3 (line 1446) | AL3 AAbsSL3(AL3 a){return AL3(abs(ASL3(a)));}
function AL4 (line 1447) | AL4 AAbsSL4(AL4 a){return AL4(abs(ASL4(a)));}
function AL1 (line 1449) | AL1 AMaxSL1(AL1 a,AL1 b){return AL1(max(ASU1(a),ASU1(b)));}
function AL2 (line 1450) | AL2 AMaxSL2(AL2 a,AL2 b){return AL2(max(ASU2(a),ASU2(b)));}
function AL3 (line 1451) | AL3 AMaxSL3(AL3 a,AL3 b){return AL3(max(ASU3(a),ASU3(b)));}
function AL4 (line 1452) | AL4 AMaxSL4(AL4 a,AL4 b){return AL4(max(ASU4(a),ASU4(b)));}
function AL1 (line 1454) | AL1 AMinSL1(AL1 a,AL1 b){return AL1(min(ASU1(a),ASU1(b)));}
function AL2 (line 1455) | AL2 AMinSL2(AL2 a,AL2 b){return AL2(min(ASU2(a),ASU2(b)));}
function AL3 (line 1456) | AL3 AMinSL3(AL3 a,AL3 b){return AL3(min(ASU3(a),ASU3(b)));}
function AL4 (line 1457) | AL4 AMinSL4(AL4 a,AL4 b){return AL4(min(ASU4(a),ASU4(b)));}
function AF1 (line 1464) | AF1 AWaveAdd(AF1 v){return subgroupAdd(v);}
function AF2 (line 1465) | AF2 AWaveAdd(AF2 v){return subgroupAdd(v);}
function AF3 (line 1466) | AF3 AWaveAdd(AF3 v){return subgroupAdd(v);}
function AF4 (line 1467) | AF4 AWaveAdd(AF4 v){return subgroupAdd(v);}
function AU1 (line 1506) | AU1 AU1_AH2_AF2_x(AF2 a){return f32tof16(a.x)|(f32tof16(a.y)<<16);}
function AF2 (line 1510) | AF2 AF2_AH2_AU1_x(AU1 x){return AF2(f16tof32(x&0xFFFF),f16tof32(x>>16));}
function AF1 (line 1513) | AF1 AF1_x(AF1 a){return AF1(a);}
function AF2 (line 1514) | AF2 AF2_x(AF1 a){return AF2(a,a);}
function AF3 (line 1515) | AF3 AF3_x(AF1 a){return AF3(a,a,a);}
function AF4 (line 1516) | AF4 AF4_x(AF1 a){return AF4(a,a,a,a);}
function AU1 (line 1522) | AU1 AU1_x(AU1 a){return AU1(a);}
function AU2 (line 1523) | AU2 AU2_x(AU1 a){return AU2(a,a);}
function AU3 (line 1524) | AU3 AU3_x(AU1 a){return AU3(a,a,a);}
function AU4 (line 1525) | AU4 AU4_x(AU1 a){return AU4(a,a,a,a);}
function AU1 (line 1531) | AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));}
function AU2 (line 1532) | AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));}
function AU3 (line 1533) | AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));}
function AU4 (line 1534) | AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));}
function AU1 (line 1536) | AU1 ABfe(AU1 src,AU1 off,AU1 bits){AU1 mask=(1<<bits)-1;return (src>>off...
function AU1 (line 1537) | AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));}
function AU1 (line 1538) | AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){AU1 mask=(1<<bits)-1;return (ins&mas...
function AF1 (line 1540) | AF1 AFractF1(AF1 x){return x-floor(x);}
function AF2 (line 1541) | AF2 AFractF2(AF2 x){return x-floor(x);}
function AF3 (line 1542) | AF3 AFractF3(AF3 x){return x-floor(x);}
function AF4 (line 1543) | AF4 AFractF4(AF4 x){return x-floor(x);}
function AF1 (line 1545) | AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return lerp(x,y,a);}
function AF2 (line 1546) | AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return lerp(x,y,a);}
function AF3 (line 1547) | AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return lerp(x,y,a);}
function AF4 (line 1548) | AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return lerp(x,y,a);}
function AF1 (line 1550) | AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));}
function AF2 (line 1551) | AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));}
function AF3 (line 1552) | AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));}
function AF4 (line 1553) | AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));}
function AU1 (line 1555) | AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(...
function AU2 (line 1556) | AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(...
function AU3 (line 1557) | AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(...
function AU4 (line 1558) | AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(...
function AU1 (line 1560) | AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));}
function AU2 (line 1561) | AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));}
function AU3 (line 1562) | AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));}
function AU4 (line 1563) | AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));}
function AU1 (line 1565) | AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));}
function AU2 (line 1566) | AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));}
function AU3 (line 1567) | AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));}
function AU4 (line 1568) | AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));}
function AF1 (line 1570) | AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));}
function AF2 (line 1571) | AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));}
function AF3 (line 1572) | AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));}
function AF4 (line 1573) | AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));}
function AF1 (line 1575) | AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));}
function AF2 (line 1576) | AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));}
function AF3 (line 1577) | AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));}
function AF4 (line 1578) | AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));}
function AU1 (line 1580) | AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(...
function AU2 (line 1581) | AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(...
function AU3 (line 1582) | AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(...
function AU4 (line 1583) | AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(...
function AU1 (line 1585) | AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));}
function AU2 (line 1586) | AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));}
function AU3 (line 1587) | AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));}
function AU4 (line 1588) | AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));}
function AU1 (line 1590) | AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));}
function AU2 (line 1591) | AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));}
function AU3 (line 1592) | AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));}
function AU4 (line 1593) | AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));}
function AF1 (line 1595) | AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));}
function AF2 (line 1596) | AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));}
function AF3 (line 1597) | AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));}
function AF4 (line 1598) | AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));}
function AF1 (line 1600) | AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));}
function AF2 (line 1601) | AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));}
function AF3 (line 1602) | AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));}
function AF4 (line 1603) | AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));}
function AF1 (line 1605) | AF1 ARcpF1(AF1 x){return rcp(x);}
function AF2 (line 1606) | AF2 ARcpF2(AF2 x){return rcp(x);}
function AF3 (line 1607) | AF3 ARcpF3(AF3 x){return rcp(x);}
function AF4 (line 1608) | AF4 ARcpF4(AF4 x){return rcp(x);}
function AF1 (line 1610) | AF1 ARsqF1(AF1 x){return rsqrt(x);}
function AF2 (line 1611) | AF2 ARsqF2(AF2 x){return rsqrt(x);}
function AF3 (line 1612) | AF3 ARsqF3(AF3 x){return rsqrt(x);}
function AF4 (line 1613) | AF4 ARsqF4(AF4 x){return rsqrt(x);}
function AF1 (line 1615) | AF1 ASatF1(AF1 x){return saturate(x);}
function AF2 (line 1616) | AF2 ASatF2(AF2 x){return saturate(x);}
function AF3 (line 1617) | AF3 ASatF3(AF3 x){return saturate(x);}
function AF4 (line 1618) | AF4 ASatF4(AF4 x){return saturate(x);}
function AU1 (line 1620) | AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));}
function AU2 (line 1621) | AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));}
function AU3 (line 1622) | AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));}
function AU4 (line 1623) | AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));}
function AH2 (line 1656) | AH2 AH2_AU1_x(AU1 x){AF2 t=f16tof32(AU2(x&0xFFFF,x>>16));return AH2(t);}
function AH4 (line 1657) | AH4 AH4_AU2_x(AU2 x){return AH4(AH2_AU1_x(x.x),AH2_AU1_x(x.y));}
function AW2 (line 1658) | AW2 AW2_AU1_x(AU1 x){AU2 t=AU2(x&0xFFFF,x>>16);return AW2(t);}
function AW4 (line 1659) | AW4 AW4_AU2_x(AU2 x){return AW4(AW2_AU1_x(x.x),AW2_AU1_x(x.y));}
function AU1 (line 1665) | AU1 AU1_AH2_x(AH2 x){return f32tof16(x.x)+(f32tof16(x.y)<<16);}
function AU2 (line 1666) | AU2 AU2_AH4_x(AH4 x){return AU2(AU1_AH2_x(x.xy),AU1_AH2_x(x.zw));}
function AU1 (line 1667) | AU1 AU1_AW2_x(AW2 x){return AU1(x.x)+(AU1(x.y)<<16);}
function AU2 (line 1668) | AU2 AU2_AW4_x(AW4 x){return AU2(AU1_AW2_x(x.xy),AU1_AW2_x(x.zw));}
function AH1 (line 1686) | AH1 AH1_x(AH1 a){return AH1(a);}
function AH2 (line 1687) | AH2 AH2_x(AH1 a){return AH2(a,a);}
function AH3 (line 1688) | AH3 AH3_x(AH1 a){return AH3(a,a,a);}
function AH4 (line 1689) | AH4 AH4_x(AH1 a){return AH4(a,a,a,a);}
function AW1 (line 1695) | AW1 AW1_x(AW1 a){return AW1(a);}
function AW2 (line 1696) | AW2 AW2_x(AW1 a){return AW2(a,a);}
function AW3 (line 1697) | AW3 AW3_x(AW1 a){return AW3(a,a,a);}
function AW4 (line 1698) | AW4 AW4_x(AW1 a){return AW4(a,a,a,a);}
function AW1 (line 1704) | AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));}
function AW2 (line 1705) | AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));}
function AW3 (line 1706) | AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));}
function AW4 (line 1707) | AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));}
function AH1 (line 1710) | AH1 AFractH1(AH1 x){return x-floor(x);}
function AH2 (line 1711) | AH2 AFractH2(AH2 x){return x-floor(x);}
function AH3 (line 1712) | AH3 AFractH3(AH3 x){return x-floor(x);}
function AH4 (line 1713) | AH4 AFractH4(AH4 x){return x-floor(x);}
function AH1 (line 1715) | AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return lerp(x,y,a);}
function AH2 (line 1716) | AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return lerp(x,y,a);}
function AH3 (line 1717) | AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return lerp(x,y,a);}
function AH4 (line 1718) | AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return lerp(x,y,a);}
function AH1 (line 1720) | AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));}
function AH2 (line 1721) | AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));}
function AH3 (line 1722) | AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));}
function AH4 (line 1723) | AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));}
function AW1 (line 1725) | AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));}
function AW2 (line 1726) | AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));}
function AW3 (line 1727) | AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));}
function AW4 (line 1728) | AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));}
function AH1 (line 1730) | AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));}
function AH2 (line 1731) | AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));}
function AH3 (line 1732) | AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));}
function AH4 (line 1733) | AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));}
function AW1 (line 1735) | AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));}
function AW2 (line 1736) | AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));}
function AW3 (line 1737) | AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));}
function AW4 (line 1738) | AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));}
function AH1 (line 1740) | AH1 ARcpH1(AH1 x){return rcp(x);}
function AH2 (line 1741) | AH2 ARcpH2(AH2 x){return rcp(x);}
function AH3 (line 1742) | AH3 ARcpH3(AH3 x){return rcp(x);}
function AH4 (line 1743) | AH4 ARcpH4(AH4 x){return rcp(x);}
function AH1 (line 1745) | AH1 ARsqH1(AH1 x){return rsqrt(x);}
function AH2 (line 1746) | AH2 ARsqH2(AH2 x){return rsqrt(x);}
function AH3 (line 1747) | AH3 ARsqH3(AH3 x){return rsqrt(x);}
function AH4 (line 1748) | AH4 ARsqH4(AH4 x){return rsqrt(x);}
function AH1 (line 1750) | AH1 ASatH1(AH1 x){return saturate(x);}
function AH2 (line 1751) | AH2 ASatH2(AH2 x){return saturate(x);}
function AH3 (line 1752) | AH3 ASatH3(AH3 x){return saturate(x);}
function AH4 (line 1753) | AH4 ASatH4(AH4 x){return saturate(x);}
function AW1 (line 1755) | AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));}
function AW2 (line 1756) | AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));}
function AW3 (line 1757) | AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));}
function AW4 (line 1758) | AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));}
function AD1 (line 1772) | AD1 AD1_x(AD1 a){return AD1(a);}
function AD2 (line 1773) | AD2 AD2_x(AD1 a){return AD2(a,a);}
function AD3 (line 1774) | AD3 AD3_x(AD1 a){return AD3(a,a,a);}
function AD4 (line 1775) | AD4 AD4_x(AD1 a){return AD4(a,a,a,a);}
function AD1 (line 1781) | AD1 AFractD1(AD1 a){return a-floor(a);}
function AD2 (line 1782) | AD2 AFractD2(AD2 a){return a-floor(a);}
function AD3 (line 1783) | AD3 AFractD3(AD3 a){return a-floor(a);}
function AD4 (line 1784) | AD4 AFractD4(AD4 a){return a-floor(a);}
function AD1 (line 1786) | AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return lerp(x,y,a);}
function AD2 (line 1787) | AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return lerp(x,y,a);}
function AD3 (line 1788) | AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return lerp(x,y,a);}
function AD4 (line 1789) | AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return lerp(x,y,a);}
function AD1 (line 1791) | AD1 ARcpD1(AD1 x){return rcp(x);}
function AD2 (line 1792) | AD2 ARcpD2(AD2 x){return rcp(x);}
function AD3 (line 1793) | AD3 ARcpD3(AD3 x){return rcp(x);}
function AD4 (line 1794) | AD4 ARcpD4(AD4 x){return rcp(x);}
function AD1 (line 1796) | AD1 ARsqD1(AD1 x){return rsqrt(x);}
function AD2 (line 1797) | AD2 ARsqD2(AD2 x){return rsqrt(x);}
function AD3 (line 1798) | AD3 ARsqD3(AD3 x){return rsqrt(x);}
function AD4 (line 1799) | AD4 ARsqD4(AD4 x){return rsqrt(x);}
function AD1 (line 1801) | AD1 ASatD1(AD1 x){return saturate(x);}
function AD2 (line 1802) | AD2 ASatD2(AD2 x){return saturate(x);}
function AD3 (line 1803) | AD3 ASatD3(AD3 x){return saturate(x);}
function AD4 (line 1804) | AD4 ASatD4(AD4 x){return saturate(x);}
function AF1 (line 1826) | AF1 ACpySgnF1(AF1 d,AF1 s){return AF1_AU1(AU1_AF1(d)|(AU1_AF1(s)&AU1_(0x...
function AF2 (line 1827) | AF2 ACpySgnF2(AF2 d,AF2 s){return AF2_AU2(AU2_AF2(d)|(AU2_AF2(s)&AU2_(0x...
function AF3 (line 1828) | AF3 ACpySgnF3(AF3 d,AF3 s){return AF3_AU3(AU3_AF3(d)|(AU3_AF3(s)&AU3_(0x...
function AF4 (line 1829) | AF4 ACpySgnF4(AF4 d,AF4 s){return AF4_AU4(AU4_AF4(d)|(AU4_AF4(s)&AU4_(0x...
function AF1 (line 1839) | AF1 ASignedF1(AF1 m){return ASatF1(m*AF1_(A_INFN_F));}
function AF2 (line 1840) | AF2 ASignedF2(AF2 m){return ASatF2(m*AF2_(A_INFN_F));}
function AF3 (line 1841) | AF3 ASignedF3(AF3 m){return ASatF3(m*AF3_(A_INFN_F));}
function AF4 (line 1842) | AF4 ASignedF4(AF4 m){return ASatF4(m*AF4_(A_INFN_F));}
function AH1 (line 1848) | AH1 ACpySgnH1(AH1 d,AH1 s){return AH1_AW1(AW1_AH1(d)|(AW1_AH1(s)&AW1_(0x...
function AH2 (line 1849) | AH2 ACpySgnH2(AH2 d,AH2 s){return AH2_AW2(AW2_AH2(d)|(AW2_AH2(s)&AW2_(0x...
function AH3 (line 1850) | AH3 ACpySgnH3(AH3 d,AH3 s){return AH3_AW3(AW3_AH3(d)|(AW3_AH3(s)&AW3_(0x...
function AH4 (line 1851) | AH4 ACpySgnH4(AH4 d,AH4 s){return AH4_AW4(AW4_AH4(d)|(AW4_AH4(s)&AW4_(0x...
function AH1 (line 1853) | AH1 ASignedH1(AH1 m){return ASatH1(m*AH1_(A_INFN_H));}
function AH2 (line 1854) | AH2 ASignedH2(AH2 m){return ASatH2(m*AH2_(A_INFN_H));}
function AH3 (line 1855) | AH3 ASignedH3(AH3 m){return ASatH3(m*AH3_(A_INFN_H));}
function AH4 (line 1856) | AH4 ASignedH4(AH4 m){return ASatH4(m*AH4_(A_INFN_H));}
function AH1 (line 1883) | AH1 APrxLoSqrtH1(AH1 a){return AH1_AW1((AW1_AH1(a)>>AW1_(1))+AW1_(0x1de2...
function AH2 (line 1884) | AH2 APrxLoSqrtH2(AH2 a){return AH2_AW2((AW2_AH2(a)>>AW2_(1))+AW2_(0x1de2...
function AH1 (line 1888) | AH1 APrxLoRcpH1(AH1 a){return AH1_AW1(AW1_(0x7784)-AW1_AH1(a));}
function AH2 (line 1889) | AH2 APrxLoRcpH2(AH2 a){return AH2_AW2(AW2_(0x7784)-AW2_AH2(a));}
function AH1 (line 1892) | AH1 APrxMedRcpH1(AH1 a){AH1 b=AH1_AW1(AW1_(0x778d)-AW1_AH1(a));return b*...
function AH2 (line 1893) | AH2 APrxMedRcpH2(AH2 a){AH2 b=AH2_AW2(AW2_(0x778d)-AW2_AH2(a));return b*...
function AH1 (line 1896) | AH1 APrxLoRsqH1(AH1 a){return AH1_AW1(AW1_(0x59a3)-(AW1_AH1(a)>>AW1_(1)));}
function AH2 (line 1897) | AH2 APrxLoRsqH2(AH2 a){return AH2_AW2(AW2_(0x59a3)-(AW2_AH2(a)>>AW2_(1)));}
function AF1 (line 1916) | AF1 APrxLoSqrtF1(AF1 a){return AF1_AU1((AU1_AF1(a)>>AU1_(1))+AU1_(0x1fbc...
function AF1 (line 1917) | AF1 APrxLoRcpF1(AF1 a){return AF1_AU1(AU1_(0x7ef07ebb)-AU1_AF1(a));}
function AF1 (line 1918) | AF1 APrxMedRcpF1(AF1 a){AF1 b=AF1_AU1(AU1_(0x7ef19fff)-AU1_AF1(a));retur...
function AF1 (line 1919) | AF1 APrxLoRsqF1(AF1 a){return AF1_AU1(AU1_(0x5f347d74)-(AU1_AF1(a)>>AU1_...
function AF1 (line 1934) | AF1 APSinF1(AF1 x){return x*abs(x)-x;}
function AF1 (line 1935) | AF1 APCosF1(AF1 x){x=AFractF1(x*AF1_(0.5)+AF1_(0.75));x=x*AF1_(2.0)-AF1_...
function AH2 (line 1941) | AH2 APSinH2(AH2 x){return x*abs(x)-x;}
function AH2 (line 1942) | AH2 APCosH2(AH2 x){x=AFractH2(x*AH2_(0.5)+AH2_(0.75));x=x*AH2_(2.0)-AH2_...
function AF1 (line 1981) | AF1 ATo709F1(AF1 c){return max(min(c*AF1_(4.5),AF1_(0.018)),AF1_(1.099)*...
function AF1 (line 1984) | AF1 AToGammaF1(AF1 c,AF1 rcpX){return pow(c,rcpX);}
function AF1 (line 1986) | AF1 AToPqF1(AF1 x){AF1 p=pow(x,AF1_(0.159302));
function AF1 (line 1989) | AF1 AToSrgbF1(AF1 c){return max(min(c*AF1_(12.92),AF1_(0.0031308)),AF1_(...
function AF1 (line 1991) | AF1 AToTwoF1(AF1 c){return sqrt(c);}
function AF1 (line 1993) | AF1 AFrom709F1(AF1 c){return max(min(c*AF1_(1.0/4.5),AF1_(0.081)),
function AF1 (line 1996) | AF1 AFromGammaF1(AF1 c,AF1 x){return pow(c,x);}
function AF1 (line 1998) | AF1 AFromPqF1(AF1 x){AF1 p=pow(x,AF1_(0.0126833));
function AF1 (line 2001) | AF1 AFromSrgbF1(AF1 c){return max(min(c*AF1_(1.0/12.92),AF1_(0.04045)),
function AF1 (line 2004) | AF1 AFromTwoF1(AF1 c){return c*c;}
function AH2 (line 2007) | AH2 ATo709H2(AH2 c){return max(min(c*AH2_(4.5),AH2_(0.018)),AH2_(1.099)*...
function AH2 (line 2009) | AH2 AToGammaH2(AH2 c,AH1 rcpX){return pow(c,AH2_(rcpX));}
function AH2 (line 2011) | AH2 AToSrgbH2(AH2 c){return max(min(c*AH2_(12.92),AH2_(0.0031308)),AH2_(...
function AH2 (line 2013) | AH2 AToTwoH2(AH2 c){return sqrt(c);}
function AH2 (line 2017) | AH2 AFrom709H2(AH2 c){return max(min(c*AH2_(1.0/4.5),AH2_(0.081)),
function AH2 (line 2020) | AH2 AFromGammaH2(AH2 c,AH1 x){return pow(c,AH2_(x));}
function AH2 (line 2022) | AH2 AFromSrgbH2(AH2 c){return max(min(c*AH2_(1.0/12.92),AH2_(0.04045)),
function AH2 (line 2025) | AH2 AFromTwoH2(AH2 c){return c*c;}
function AU2 (line 2038) | AU2 ARmp8x8(AU1 a){return AU2(ABfe(a,1u,3u),ABfiM(ABfe(a,3u,3u),a,1u));}
function AU2 (line 2056) | AU2 ARmpRed8x8(AU1 a){return AU2(ABfiM(ABfe(a,2u,3u),a,1u),ABfiM(ABfe(a,...
function AD2 (line 2205) | AD2 opAAbsD2(outAD2 d,inAD2 a){d=abs(a);return d;}
function AD3 (line 2206) | AD3 opAAbsD3(outAD3 d,inAD3 a){d=abs(a);return d;}
function AD4 (line 2207) | AD4 opAAbsD4(outAD4 d,inAD4 a){d=abs(a);return d;}
function AD2 (line 2209) | AD2 opAAddD2(outAD2 d,inAD2 a,inAD2 b){d=a+b;return d;}
function AD3 (line 2210) | AD3 opAAddD3(outAD3 d,inAD3 a,inAD3 b){d=a+b;return d;}
function AD4 (line 2211) | AD4 opAAddD4(outAD4 d,inAD4 a,inAD4 b){d=a+b;return d;}
function AD2 (line 2213) | AD2 opACpyD2(outAD2 d,inAD2 a){d=a;return d;}
function AD3 (line 2214) | AD3 opACpyD3(outAD3 d,inAD3 a){d=a;return d;}
function AD4 (line 2215) | AD4 opACpyD4(outAD4 d,inAD4 a){d=a;return d;}
function AD2 (line 2217) | AD2 opALerpD2(outAD2 d,inAD2 a,inAD2 b,inAD2 c){d=ALerpD2(a,b,c);return d;}
function AD3 (line 2218) | AD3 opALerpD3(outAD3 d,inAD3 a,inAD3 b,inAD3 c){d=ALerpD3(a,b,c);return d;}
function AD4 (line 2219) | AD4 opALerpD4(outAD4 d,inAD4 a,inAD4 b,inAD4 c){d=ALerpD4(a,b,c);return d;}
function AD2 (line 2221) | AD2 opALerpOneD2(outAD2 d,inAD2 a,inAD2 b,AD1 c){d=ALerpD2(a,b,AD2_(c));...
function AD3 (line 2222) | AD3 opALerpOneD3(outAD3 d,inAD3 a,inAD3 b,AD1 c){d=ALerpD3(a,b,AD3_(c));...
function AD4 (line 2223) | AD4 opALerpOneD4(outAD4 d,inAD4 a,inAD4 b,AD1 c){d=ALerpD4(a,b,AD4_(c));...
function AD2 (line 2225) | AD2 opAMaxD2(outAD2 d,inAD2 a,inAD2 b){d=max(a,b);return d;}
function AD3 (line 2226) | AD3 opAMaxD3(outAD3 d,inAD3 a,inAD3 b){d=max(a,b);return d;}
function AD4 (line 2227) | AD4 opAMaxD4(outAD4 d,inAD4 a,inAD4 b){d=max(a,b);return d;}
function AD2 (line 2229) | AD2 opAMinD2(outAD2 d,inAD2 a,inAD2 b){d=min(a,b);return d;}
function AD3 (line 2230) | AD3 opAMinD3(outAD3 d,inAD3 a,inAD3 b){d=min(a,b);return d;}
function AD4 (line 2231) | AD4 opAMinD4(outAD4 d,inAD4 a,inAD4 b){d=min(a,b);return d;}
function AD2 (line 2233) | AD2 opAMulD2(outAD2 d,inAD2 a,inAD2 b){d=a*b;return d;}
function AD3 (line 2234) | AD3 opAMulD3(outAD3 d,inAD3 a,inAD3 b){d=a*b;return d;}
function AD4 (line 2235) | AD4 opAMulD4(outAD4 d,inAD4 a,inAD4 b){d=a*b;return d;}
function AD2 (line 2237) | AD2 opAMulOneD2(outAD2 d,inAD2 a,AD1 b){d=a*AD2_(b);return d;}
function AD3 (line 2238) | AD3 opAMulOneD3(outAD3 d,inAD3 a,AD1 b){d=a*AD3_(b);return d;}
function AD4 (line 2239) | AD4 opAMulOneD4(outAD4 d,inAD4 a,AD1 b){d=a*AD4_(b);return d;}
function AD2 (line 2241) | AD2 opANegD2(outAD2 d,inAD2 a){d=-a;return d;}
function AD3 (line 2242) | AD3 opANegD3(outAD3 d,inAD3 a){d=-a;return d;}
function AD4 (line 2243) | AD4 opANegD4(outAD4 d,inAD4 a){d=-a;return d;}
function AD2 (line 2245) | AD2 opARcpD2(outAD2 d,inAD2 a){d=ARcpD2(a);return d;}
function AD3 (line 2246) | AD3 opARcpD3(outAD3 d,inAD3 a){d=ARcpD3(a);return d;}
function AD4 (line 2247) | AD4 opARcpD4(outAD4 d,inAD4 a){d=ARcpD4(a);return d;}
function AF2 (line 2250) | AF2 opAAbsF2(outAF2 d,inAF2 a){d=abs(a);return d;}
function AF3 (line 2251) | AF3 opAAbsF3(outAF3 d,inAF3 a){d=abs(a);return d;}
function AF4 (line 2252) | AF4 opAAbsF4(outAF4 d,inAF4 a){d=abs(a);return d;}
function AF2 (line 2254) | AF2 opAAddF2(outAF2 d,inAF2 a,inAF2 b){d=a+b;return d;}
function AF3 (line 2255) | AF3 opAAddF3(outAF3 d,inAF3 a,inAF3 b){d=a+b;return d;}
function AF4 (line 2256) | AF4 opAAddF4(outAF4 d,inAF4 a,inAF4 b){d=a+b;return d;}
function AF2 (line 2258) | AF2 opACpyF2(outAF2 d,inAF2 a){d=a;return d;}
function AF3 (line 2259) | AF3 opACpyF3(outAF3 d,inAF3 a){d=a;return d;}
function AF4 (line 2260) | AF4 opACpyF4(outAF4 d,inAF4 a){d=a;return d;}
function AF2 (line 2262) | AF2 opALerpF2(outAF2 d,inAF2 a,inAF2 b,inAF2 c){d=ALerpF2(a,b,c);return d;}
function AF3 (line 2263) | AF3 opALerpF3(outAF3 d,inAF3 a,inAF3 b,inAF3 c){d=ALerpF3(a,b,c);return d;}
function AF4 (line 2264) | AF4 opALerpF4(outAF4 d,inAF4 a,inAF4 b,inAF4 c){d=ALerpF4(a,b,c);return d;}
function AF2 (line 2266) | AF2 opALerpOneF2(outAF2 d,inAF2 a,inAF2 b,AF1 c){d=ALerpF2(a,b,AF2_(c));...
function AF3 (line 2267) | AF3 opALerpOneF3(outAF3 d,inAF3 a,inAF3 b,AF1 c){d=ALerpF3(a,b,AF3_(c));...
function AF4 (line 2268) | AF4 opALerpOneF4(outAF4 d,inAF4 a,inAF4 b,AF1 c){d=ALerpF4(a,b,AF4_(c));...
function AF2 (line 2270) | AF2 opAMaxF2(outAF2 d,inAF2 a,inAF2 b){d=max(a,b);return d;}
function AF3 (line 2271) | AF3 opAMaxF3(outAF3 d,inAF3 a,inAF3 b){d=max(a,b);return d;}
function AF4 (line 2272) | AF4 opAMaxF4(outAF4 d,inAF4 a,inAF4 b){d=max(a,b);return d;}
function AF2 (line 2274) | AF2 opAMinF2(outAF2 d,inAF2 a,inAF2 b){d=min(a,b);return d;}
function AF3 (line 2275) | AF3 opAMinF3(outAF3 d,inAF3 a,inAF3 b){d=min(a,b);return d;}
function AF4 (line 2276) | AF4 opAMinF4(outAF4 d,inAF4 a,inAF4 b){d=min(a,b);return d;}
function AF2 (line 2278) | AF2 opAMulF2(outAF2 d,inAF2 a,inAF2 b){d=a*b;return d;}
function AF3 (line 2279) | AF3 opAMulF3(outAF3 d,inAF3 a,inAF3 b){d=a*b;return d;}
function AF4 (line 2280) | AF4 opAMulF4(outAF4 d,inAF4 a,inAF4 b){d=a*b;return d;}
function AF2 (line 2282) | AF2 opAMulOneF2(outAF2 d,inAF2 a,AF1 b){d=a*AF2_(b);return d;}
function AF3 (line 2283) | AF3 opAMulOneF3(outAF3 d,inAF3 a,AF1 b){d=a*AF3_(b);return d;}
function AF4 (line 2284) | AF4 opAMulOneF4(outAF4 d,inAF4 a,AF1 b){d=a*AF4_(b);return d;}
function AF2 (line 2286) | AF2 opANegF2(outAF2 d,inAF2 a){d=-a;return d;}
function AF3 (line 2287) | AF3 opANegF3(outAF3 d,inAF3 a){d=-a;return d;}
function AF4 (line 2288) | AF4 opANegF4(outAF4 d,inAF4 a){d=-a;return d;}
function AF2 (line 2290) | AF2 opARcpF2(outAF2 d,inAF2 a){d=ARcpF2(a);return d;}
function AF3 (line 2291) | AF3 opARcpF3(outAF3 d,inAF3 a){d=ARcpF3(a);return d;}
function AF4 (line 2292) | AF4 opARcpF4(outAF4 d,inAF4 a){d=ARcpF4(a);return d;}
FILE: data/shaders/fxaa/fxaa3_11.h
type FxaaTex (line 685) | struct FxaaTex { SamplerState smpl; Texture2D tex; }
type FxaaTex (line 692) | struct FxaaTex { SamplerState smpl; Texture2D tex; }
function FxaaFloat (line 706) | FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }
function FxaaFloat (line 708) | FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }
function FxaaFloat4 (line 721) | FxaaFloat4 FxaaPixelShader(
function FxaaFloat4 (line 1258) | FxaaFloat4 FxaaPixelShader(
function half4 (line 1598) | half4 FxaaPixelShader(
function half4 (line 1907) | half4 FxaaPixelShader(
FILE: data/shaders/shared_buffers.h
type FrameBufferData (line 53) | struct FrameBufferData
type PassBufferData (line 132) | struct PassBufferData
type MaterialParameters (line 159) | struct MaterialParameters
type LightParameters (line 198) | struct LightParameters
type Aabb (line 216) | struct Aabb
type GeometryInfo (line 225) | struct GeometryInfo
type IndirectDrawArgs (line 232) | struct IndirectDrawArgs
type DrawData (line 242) | struct DrawData
type PulledVertex (line 253) | struct PulledVertex
type PackedInstance (line 262) | struct PackedInstance
type Particle (line 270) | struct Particle
type EmitterParams (line 282) | struct EmitterParams
function namespace (line 304) | namespace spartan
FILE: generate_project_files.py
function print_menu (line 32) | def print_menu():
function get_user_choice (line 42) | def get_user_choice():
function generate_project (line 55) | def generate_project(config):
function main (line 67) | def main():
FILE: source/editor/Editor.cpp
function process_event (line 56) | void process_event(spartan::sp_variant data)
FILE: source/editor/GeneralWindows.cpp
function center_next_window (line 42) | static void center_next_window(Editor* editor)
type welcome (line 52) | namespace welcome
function window (line 56) | void window()
type about (line 118) | namespace about
function personal_details (line 144) | void personal_details()
function tab_general (line 178) | void tab_general()
function tab_contributors (line 222) | void tab_contributors()
type third_party_lib (line 227) | struct third_party_lib
function tab_libraries (line 260) | void tab_libraries()
function window (line 296) | void window()
type controls (line 335) | namespace controls
type Shortcut (line 339) | struct Shortcut
type ControlBinding (line 356) | struct ControlBinding
function render_key_combo (line 402) | void render_key_combo(const char* key_string)
function show_shortcut_table (line 438) | void show_shortcut_table(const char* str_id, const Shortcut* shortcuts...
function show_control_binding_table (line 471) | void show_control_binding_table(const char* str_id, const ControlBindi...
function window (line 506) | void window()
FILE: source/editor/GeneralWindows.h
function class (line 26) | class GeneralWindows
FILE: source/editor/ImGui/ImGui_Extension.h
function namespace (line 42) | namespace ImGuiSp
function image (line 177) | static void image(const spartan::IconType icon, const float size)
function image (line 189) | static void image(const spartan::IconType icon, const float size,const I...
type DragDropPayload (line 201) | struct DragDropPayload
function create_drag_drop_payload (line 215) | static void create_drag_drop_payload(const DragDropPayload& payload)
function DragDropPayload (line 220) | static DragDropPayload* receive_drag_drop_payload(DragPayloadType type)
function image_slot (line 235) | static bool image_slot(spartan::RHI_Texture* texture_in, const std::func...
function tooltip (line 322) | static void tooltip(const char* text)
function combo_box (line 385) | static bool combo_box(const char* label, const std::vector<std::string>&...
function toggle_switch (line 494) | static bool toggle_switch(const char* label, bool* v)
function ButtonPress (line 585) | inline ButtonPress window_yes_no(const char* title, const char* text)
FILE: source/editor/ImGui/ImGui_Style.h
function namespace (line 27) | namespace ImGui::Style
FILE: source/editor/ImGui/ImGui_TransformGizmo.h
function namespace (line 37) | namespace ImGui::TransformGizmo
FILE: source/editor/ImGui/Implementation/ImGui_RHI.h
type ViewportRhiResources (line 61) | struct ViewportRhiResources
type WindowData (line 80) | struct WindowData
function on_hdr_toggled (line 102) | void on_hdr_toggled()
function destroy_rhi_resources (line 116) | void destroy_rhi_resources()
function shutdown (line 205) | void shutdown()
function GetObjectId (line 351) | GetRenderTarget(Renderer_RenderTarget::frame_output)->GetObjectId() == t...
function window_create (line 446) | void window_create(ImGuiViewport* viewport)
function window_destroy (line 469) | void window_destroy(ImGuiViewport* viewport)
function window_resize (line 478) | void window_resize(ImGuiViewport* viewport, const ImVec2 size)
function window_render (line 483) | void window_render(ImGuiViewport* viewport, void*)
function window_present (line 489) | void window_present(ImGuiViewport* viewport, void*)
function initialize_platform_interface (line 495) | void initialize_platform_interface()
FILE: source/editor/ImGui/Implementation/imgui_impl_sdl3.cpp
type ImGui_ImplSDL3_Data (line 94) | struct ImGui_ImplSDL3_Data
method ImGui_ImplSDL3_Data (line 121) | ImGui_ImplSDL3_Data() { memset((void*)this, 0, sizeof(*this)); }
function ImGui_ImplSDL3_Data (line 128) | static ImGui_ImplSDL3_Data* ImGui_ImplSDL3_GetBackendData()
method ImGui_ImplSDL3_Data (line 121) | ImGui_ImplSDL3_Data() { memset((void*)this, 0, sizeof(*this)); }
function ImGui_ImplSDL3_SetClipboardText (line 149) | static void ImGui_ImplSDL3_SetClipboardText(ImGuiContext*, const char* t...
function ImGui_ImplSDL3_PlatformSetImeData (line 154) | static void ImGui_ImplSDL3_PlatformSetImeData(ImGuiContext*, ImGuiViewpo...
function ImGuiKey (line 179) | ImGuiKey ImGui_ImplSDL3_KeyEventToImGuiKey(SDL_Keycode keycode, SDL_Scan...
function ImGui_ImplSDL3_UpdateKeyModifiers (line 312) | static void ImGui_ImplSDL3_UpdateKeyModifiers(SDL_Keymod sdl_key_mods)
function ImGuiViewport (line 321) | static ImGuiViewport* ImGui_ImplSDL3_GetViewportForWindowID(SDL_WindowID...
function ImGui_ImplSDL3_ProcessEvent (line 330) | bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event)
function ImGui_ImplSDL3_SetupPlatformHandles (line 464) | static void ImGui_ImplSDL3_SetupPlatformHandles(ImGuiViewport* viewport,...
function ImGui_ImplSDL3_Init (line 475) | static bool ImGui_ImplSDL3_Init(SDL_Window* window, SDL_Renderer* render...
function ImGui_ImplSDL3_InitForOpenGL (line 565) | bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window, void* sdl_gl_context)
function ImGui_ImplSDL3_InitForVulkan (line 570) | bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window)
function ImGui_ImplSDL3_InitForD3D (line 579) | bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window)
function ImGui_ImplSDL3_InitForMetal (line 587) | bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window)
function ImGui_ImplSDL3_InitForSDLRenderer (line 592) | bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window, SDL_Renderer*...
function ImGui_ImplSDL3_InitForSDLGPU (line 597) | bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window)
function ImGui_ImplSDL3_InitForOther (line 602) | bool ImGui_ImplSDL3_InitForOther(SDL_Window* window)
function ImGui_ImplSDL3_Shutdown (line 609) | void ImGui_ImplSDL3_Shutdown()
function ImGui_ImplSDL3_UpdateMouseData (line 630) | static void ImGui_ImplSDL3_UpdateMouseData()
function ImGui_ImplSDL3_UpdateMouseCursor (line 692) | static void ImGui_ImplSDL3_UpdateMouseCursor()
function ImGui_ImplSDL3_CloseGamepads (line 718) | static void ImGui_ImplSDL3_CloseGamepads()
function ImGui_ImplSDL3_SetGamepadMode (line 727) | void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode, SDL_...
function ImGui_ImplSDL3_UpdateGamepadButton (line 745) | static void ImGui_ImplSDL3_UpdateGamepadButton(ImGui_ImplSDL3_Data* bd, ...
function Saturate (line 753) | static inline float Saturate(float v) { return v < 0.0f ? 0.0f : v > 1....
function ImGui_ImplSDL3_UpdateGamepadAnalog (line 754) | static void ImGui_ImplSDL3_UpdateGamepadAnalog(ImGui_ImplSDL3_Data* bd, ...
function ImGui_ImplSDL3_UpdateGamepads (line 766) | static void ImGui_ImplSDL3_UpdateGamepads()
function ImGui_ImplSDL3_UpdateMonitors (line 824) | static void ImGui_ImplSDL3_UpdateMonitors()
function ImGui_ImplSDL3_NewFrame (line 856) | void ImGui_ImplSDL3_NewFrame()
type ImGui_ImplSDL3_ViewportData (line 914) | struct ImGui_ImplSDL3_ViewportData
method ImGui_ImplSDL3_ViewportData (line 922) | ImGui_ImplSDL3_ViewportData() { Window = ParentWindow = nullptr; Windo...
function SDL_Window (line 926) | static SDL_Window* ImGui_ImplSDL3_GetSDLWindowFromViewportID(ImGuiID vie...
function ImGui_ImplSDL3_CreateWindow (line 937) | static void ImGui_ImplSDL3_CreateWindow(ImGuiViewport* viewport)
function ImGui_ImplSDL3_DestroyWindow (line 981) | static void ImGui_ImplSDL3_DestroyWindow(ImGuiViewport* viewport)
function ImGui_ImplSDL3_ShowWindow (line 996) | static void ImGui_ImplSDL3_ShowWindow(ImGuiViewport* viewport)
function ImGui_ImplSDL3_UpdateWindow (line 1018) | static void ImGui_ImplSDL3_UpdateWindow(ImGuiViewport* viewport)
function ImVec2 (line 1032) | static ImVec2 ImGui_ImplSDL3_GetWindowPos(ImGuiViewport* viewport)
function ImGui_ImplSDL3_SetWindowPos (line 1040) | static void ImGui_ImplSDL3_SetWindowPos(ImGuiViewport* viewport, ImVec2 ...
function ImVec2 (line 1046) | static ImVec2 ImGui_ImplSDL3_GetWindowSize(ImGuiViewport* viewport)
function ImGui_ImplSDL3_SetWindowSize (line 1054) | static void ImGui_ImplSDL3_SetWindowSize(ImGuiViewport* viewport, ImVec2...
function ImGui_ImplSDL3_SetWindowTitle (line 1060) | static void ImGui_ImplSDL3_SetWindowTitle(ImGuiViewport* viewport, const...
function ImGui_ImplSDL3_SetWindowAlpha (line 1066) | static void ImGui_ImplSDL3_SetWindowAlpha(ImGuiViewport* viewport, float...
function ImGui_ImplSDL3_SetWindowFocus (line 1072) | static void ImGui_ImplSDL3_SetWindowFocus(ImGuiViewport* viewport)
function ImGui_ImplSDL3_GetWindowFocus (line 1078) | static bool ImGui_ImplSDL3_GetWindowFocus(ImGuiViewport* viewport)
function ImGui_ImplSDL3_GetWindowMinimized (line 1084) | static bool ImGui_ImplSDL3_GetWindowMinimized(ImGuiViewport* viewport)
function ImGui_ImplSDL3_RenderWindow (line 1090) | static void ImGui_ImplSDL3_RenderWindow(ImGuiViewport* viewport, void*)
function ImGui_ImplSDL3_SwapBuffers (line 1097) | static void ImGui_ImplSDL3_SwapBuffers(ImGuiViewport* viewport, void*)
function ImGui_ImplSDL3_CreateVkSurface (line 1110) | static int ImGui_ImplSDL3_CreateVkSurface(ImGuiViewport* viewport, ImU64...
function ImGui_ImplSDL3_InitMultiViewportSupport (line 1118) | static void ImGui_ImplSDL3_InitMultiViewportSupport(SDL_Window* window, ...
function ImGui_ImplSDL3_ShutdownMultiViewportSupport (line 1151) | static void ImGui_ImplSDL3_ShutdownMultiViewportSupport()
FILE: source/editor/ImGui/Implementation/imgui_impl_sdl3.h
type SDL_Window (line 28) | struct SDL_Window
type SDL_Renderer (line 29) | struct SDL_Renderer
type SDL_Gamepad (line 30) | struct SDL_Gamepad
type SDL_Event (line 31) | typedef union SDL_Event SDL_Event;
type ImGui_ImplSDL3_GamepadMode (line 47) | enum ImGui_ImplSDL3_GamepadMode { ImGui_ImplSDL3_GamepadMode_AutoFirst, ...
FILE: source/editor/ImGui/Source/ImGuizmo/GraphEditor.cpp
type GraphEditor (line 35) | namespace GraphEditor {
function Distance (line 37) | static inline float Distance(const ImVec2& a, const ImVec2& b)
function sign (line 42) | static inline float sign(float v)
function ImVec2 (line 47) | static ImVec2 GetInputSlotPos(Delegate& delegate, const Node& node, Sl...
function ImVec2 (line 55) | static ImVec2 GetOutputSlotPos(Delegate& delegate, const Node& node, S...
function ImRect (line 63) | static ImRect GetNodeRect(const Node& node, float factor)
type NodeOperation (line 73) | enum NodeOperation
function HandleZoomScroll (line 84) | static void HandleZoomScroll(ImRect regionRect, ViewState& viewState, ...
function GraphEditorClear (line 111) | void GraphEditorClear()
function FitNodes (line 116) | static void FitNodes(Delegate& delegate, ViewState& viewState, const I...
function DisplayLinks (line 161) | static void DisplayLinks(Delegate& delegate,
function HandleQuadSelection (line 284) | static void HandleQuadSelection(Delegate& delegate, ImDrawList* drawLi...
function HandleConnections (line 347) | static bool HandleConnections(ImDrawList* drawList,
function DrawGrid (line 515) | static void DrawGrid(ImDrawList* drawList, ImVec2 windowPos, const Vie...
function DrawNode (line 533) | static bool DrawNode(ImDrawList* drawList,
function DrawMiniMap (line 717) | bool DrawMiniMap(ImDrawList* drawList, Delegate& delegate, ViewState& ...
function Show (line 822) | void Show(Delegate& delegate, const Options& options, ViewState& viewS...
function EditOptions (line 1043) | bool EditOptions(Options& options)
FILE: source/editor/ImGui/Source/ImGuizmo/GraphEditor.h
type NodeIndex (line 36) | typedef size_t NodeIndex;
type SlotIndex (line 37) | typedef size_t SlotIndex;
type LinkIndex (line 38) | typedef size_t LinkIndex;
type TemplateIndex (line 39) | typedef size_t TemplateIndex;
type FitOnScreen (line 43) | enum FitOnScreen
type Options (line 51) | struct Options
function mLineThickness (line 63) | float mLineThickness{ 5 }
function mRenderGrid (line 76) | bool mRenderGrid{ true }; // grid or nothing
FILE: source/editor/ImGui/Source/ImGuizmo/ImCurveEdit.cpp
type ImCurveEdit (line 42) | namespace ImCurveEdit
function ImVec2 (line 46) | static ImVec2 operator+(const ImVec2& a, const ImVec2& b) {
function ImVec2 (line 50) | static ImVec2 operator-(const ImVec2& a, const ImVec2& b) {
function ImVec2 (line 54) | static ImVec2 operator*(const ImVec2& a, const ImVec2& b) {
function ImVec2 (line 58) | static ImVec2 operator/(const ImVec2& a, const ImVec2& b) {
function ImVec2 (line 62) | static ImVec2 operator*(const ImVec2& a, const float b) {
function smoothstep (line 67) | static float smoothstep(float edge0, float edge1, float x)
function distance (line 73) | static float distance(float x, float y, float x1, float y1, float x2, ...
function DrawPoint (line 106) | static int DrawPoint(ImDrawList* draw_list, ImVec2 pos, const ImVec2 s...
function Edit (line 137) | int Edit(Delegate& delegate, const ImVec2& size, unsigned int id, cons...
FILE: source/editor/ImGui/Source/ImGuizmo/ImCurveEdit.h
type ImRect (line 30) | struct ImRect
function namespace (line 32) | namespace ImCurveEdit
FILE: source/editor/ImGui/Source/ImGuizmo/ImGradient.cpp
type ImGradient (line 32) | namespace ImGradient
function ImVec2 (line 35) | static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { r...
function ImVec2 (line 36) | static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { r...
function ImVec2 (line 37) | static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) {...
function ImVec2 (line 38) | static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) {...
function ImVec2 (line 39) | static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) {...
function ImVec2 (line 40) | static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) {...
function DrawPoint (line 43) | static int DrawPoint(ImDrawList* draw_list, ImVec4 color, const ImVec2...
function Edit (line 67) | bool Edit(Delegate& delegate, const ImVec2& size, int& selection)
FILE: source/editor/ImGui/Source/ImGuizmo/ImGradient.h
type ImVec4 (line 29) | struct ImVec4
type ImVec2 (line 30) | struct ImVec2
function namespace (line 32) | namespace ImGradient
FILE: source/editor/ImGui/Source/ImGuizmo/ImGuizmo.cpp
type IMGUIZMO_NAMESPACE (line 48) | namespace IMGUIZMO_NAMESPACE
function OPERATION (line 57) | static OPERATION operator&(OPERATION lhs, OPERATION rhs)
function Intersects (line 67) | static bool Intersects(OPERATION lhs, OPERATION rhs)
function Contains (line 73) | static bool Contains(OPERATION lhs, OPERATION rhs)
function FPU_MatrixF_x_MatrixF (line 81) | void FPU_MatrixF_x_MatrixF(const float* a, const float* b, float* r)
function Frustum (line 104) | void Frustum(float left, float right, float bottom, float top, float z...
function Perspective (line 129) | void Perspective(float fovyInDegrees, float aspectRatio, float znear, ...
function Cross (line 137) | void Cross(const float* a, const float* b, float* r)
function Dot (line 144) | float Dot(const float* a, const float* b)
function Normalize (line 149) | void Normalize(const float* a, float* r)
function LookAt (line 157) | void LookAt(const float* eye, const float* at, const float* up, float*...
function T (line 189) | T Clamp(T x, T y, T z) { return ((x < y) ? y : ((x > z) ? z : x)); }
function T (line 190) | T max(T x, T y) { return (x > y) ? x : y; }
function T (line 191) | T min(T x, T y) { return (x < y) ? x : y; }
function IsWithin (line 192) | bool IsWithin(T x, T y, T z) { return (x >= y) && (x <= z); }
type matrix_t (line 194) | struct matrix_t
method Translation (line 326) | void Translation(float _x, float _y, float _z) { this->Translation(m...
method Translation (line 328) | void Translation(const vec_t& vt)
method Scale (line 336) | void Scale(float _x, float _y, float _z)
method Scale (line 343) | void Scale(const vec_t& s) { Scale(s.x, s.y, s.z); }
method matrix_t (line 345) | matrix_t& operator *= (const matrix_t& mat)
method matrix_t (line 353) | matrix_t operator * (const matrix_t& mat) const
method Multiply (line 360) | void Multiply(const matrix_t& matrix)
method Multiply (line 368) | void Multiply(const matrix_t& m1, const matrix_t& m2)
method GetDeterminant (line 373) | float GetDeterminant() const
method SetToIdentity (line 380) | void SetToIdentity()
method Transpose (line 387) | void Transpose()
method OrthoNormalize (line 402) | void OrthoNormalize()
type vec_t (line 195) | struct vec_t
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y + z * z); }
method LengthSq (line 224) | float LengthSq() const { return (x * x + y * y + z * z); }
method vec_t (line 225) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
method vec_t (line 226) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
method Cross (line 229) | void Cross(const vec_t& v)
method Cross (line 242) | void Cross(const vec_t& v1, const vec_t& v2)
method Dot (line 250) | float Dot(const vec_t& v) const
method Dot3 (line 255) | float Dot3(const vec_t& v) const
method TransformVector (line 265) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
method TransformPoint (line 266) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
function vec_t (line 273) | vec_t makeVect(float _x, float _y, float _z = 0.f, float _w = 0.f) { v...
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y + z * z); }
method LengthSq (line 224) | float LengthSq() const { return (x * x + y * y + z * z); }
method vec_t (line 225) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
method vec_t (line 226) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
method Cross (line 229) | void Cross(const vec_t& v)
method Cross (line 242) | void Cross(const vec_t& v1, const vec_t& v2)
method Dot (line 250) | float Dot(const vec_t& v) const
method Dot3 (line 255) | float Dot3(const vec_t& v) const
method TransformVector (line 265) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
method TransformPoint (line 266) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
function vec_t (line 274) | vec_t makeVect(ImVec2 v) { vec_t res; res.x = v.x; res.y = v.y; res.z ...
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y + z * z); }
method LengthSq (line 224) | float LengthSq() const { return (x * x + y * y + z * z); }
method vec_t (line 225) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
method vec_t (line 226) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
method Cross (line 229) | void Cross(const vec_t& v)
method Cross (line 242) | void Cross(const vec_t& v1, const vec_t& v2)
method Dot (line 250) | float Dot(const vec_t& v) const
method Dot3 (line 255) | float Dot3(const vec_t& v) const
method TransformVector (line 265) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
method TransformPoint (line 266) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
function vec_t (line 275) | vec_t vec_t::operator * (float f) const { return makeVect(x * f, y * f...
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y + z * z); }
method LengthSq (line 224) | float LengthSq() const { return (x * x + y * y + z * z); }
method vec_t (line 225) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
method vec_t (line 226) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
method Cross (line 229) | void Cross(const vec_t& v)
method Cross (line 242) | void Cross(const vec_t& v1, const vec_t& v2)
method Dot (line 250) | float Dot(const vec_t& v) const
method Dot3 (line 255) | float Dot3(const vec_t& v) const
method TransformVector (line 265) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
method TransformPoint (line 266) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
function vec_t (line 276) | vec_t vec_t::operator - () const { return makeVect(-x, -y, -z, -w); }
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y + z * z); }
method LengthSq (line 224) | float LengthSq() const { return (x * x + y * y + z * z); }
method vec_t (line 225) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
method vec_t (line 226) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
method Cross (line 229) | void Cross(const vec_t& v)
method Cross (line 242) | void Cross(const vec_t& v1, const vec_t& v2)
method Dot (line 250) | float Dot(const vec_t& v) const
method Dot3 (line 255) | float Dot3(const vec_t& v) const
method TransformVector (line 265) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
method TransformPoint (line 266) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
function vec_t (line 277) | vec_t vec_t::operator - (const vec_t& v) const { return makeVect(x - v...
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y + z * z); }
method LengthSq (line 224) | float LengthSq() const { return (x * x + y * y + z * z); }
method vec_t (line 225) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
method vec_t (line 226) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
method Cross (line 229) | void Cross(const vec_t& v)
method Cross (line 242) | void Cross(const vec_t& v1, const vec_t& v2)
method Dot (line 250) | float Dot(const vec_t& v) const
method Dot3 (line 255) | float Dot3(const vec_t& v) const
method TransformVector (line 265) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
method TransformPoint (line 266) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
function vec_t (line 278) | vec_t vec_t::operator + (const vec_t& v) const { return makeVect(x + v...
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y + z * z); }
method LengthSq (line 224) | float LengthSq() const { return (x * x + y * y + z * z); }
method vec_t (line 225) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
method vec_t (line 226) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
method Cross (line 229) | void Cross(const vec_t& v)
method Cross (line 242) | void Cross(const vec_t& v1, const vec_t& v2)
method Dot (line 250) | float Dot(const vec_t& v) const
method Dot3 (line 255) | float Dot3(const vec_t& v) const
method TransformVector (line 265) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
method TransformPoint (line 266) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
function vec_t (line 279) | vec_t vec_t::operator * (const vec_t& v) const { return makeVect(x * v...
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y + z * z); }
method LengthSq (line 224) | float LengthSq() const { return (x * x + y * y + z * z); }
method vec_t (line 225) | vec_t Normalize() { (*this) *= (1.f / ( Length() > FLT_EPSILON ? Len...
method vec_t (line 226) | vec_t Normalize(const vec_t& v) { this->Set(v.x, v.y, v.z, v.w); thi...
method Cross (line 229) | void Cross(const vec_t& v)
method Cross (line 242) | void Cross(const vec_t& v1, const vec_t& v2)
method Dot (line 250) | float Dot(const vec_t& v) const
method Dot3 (line 255) | float Dot3(const vec_t& v) const
method TransformVector (line 265) | void TransformVector(const vec_t& v, const matrix_t& matrix) { (*thi...
method TransformPoint (line 266) | void TransformPoint(const vec_t& v, const matrix_t& matrix) { (*this...
function vec_t (line 280) | vec_t vec_t::Abs() const { return makeVect(fabsf(x), fabsf(y), fabsf(z...
method Lerp (line 200) | void Lerp(const vec_t& v, float t)
method Set (line 208) | void Set(float v) { x = y = z = w = v; }
method Set (line 209) | void Set(float _x, float _y, float _z = 0.f, float _w = 0.f) { x = _...
method vec_t (line 211) | vec_t& operator -= (const vec_t& v) { x -= v.x; y -= v.y; z -= v.z; ...
method vec_t (line 212) | vec_t& operator += (const vec_t& v) { x += v.x; y += v.y; z += v.z; ...
method vec_t (line 213) | vec_t& operator *= (const vec_t& v) { x *= v.x; y *= v.y; z *= v.z; ...
method vec_t (line 214) | vec_t& operator *= (float v) { x *= v; y *= v; z *= v; w *=...
method vec_t (line 222) | const vec_t& operator + () const { return (*this); }
method Length (line 223) | float Length() const { return sqrtf(x * x + y * y +
Copy disabled (too large)
Download .json
Condensed preview — 1549 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (57,324K chars).
[
{
"path": ".editorconfig",
"chars": 425,
"preview": "# top-most EditorConfig file\nroot = true\n\n# ----------------------------------------------------------------------\n# Glo"
},
{
"path": ".gitattributes",
"chars": 999,
"preview": "# Ensure LF line endings in the repository and proper handling on checkouts\n* text=auto\n\n# C++ source and header files\n*"
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 528,
"preview": "---\nname: Bug report\nabout: Create a report to help improve the engine\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n### Bug "
},
{
"path": ".github/workflows/workflow.yml",
"chars": 7834,
"preview": "name: build\n\non:\n push:\n paths-ignore:\n - '**.md'\n - 'funding.yml'\n - '.gitignore'\n - '.gitattri"
},
{
"path": ".gitignore",
"chars": 4184,
"preview": "## Ignore Visual Studio temporary files, build results, and\n## files generated by popular Visual Studio add-ons.\n\n# User"
},
{
"path": "build_scripts/Dockerfile",
"chars": 2603,
"preview": "FROM ubuntu:22.04\n\n# Get all the necessary dependencies from the package manager\nRUN apt update -y &&\\\n apt install -"
},
{
"path": "build_scripts/ci_test.bat",
"chars": 53,
"preview": "cd binaries\r\nspartan_%1.exe -ci_test\r\ntimeout /t 10\r\n"
},
{
"path": "build_scripts/file_utilities.py",
"chars": 9132,
"preview": "# Copyright(c) 2015-2026 Panos Karabelas\n#\n# Permission is hereby granted, free of charge, to any person obtaining a cop"
},
{
"path": "build_scripts/generate_project_files.py",
"chars": 4417,
"preview": "# Copyright(c) 2016-2025 Panos Karabelas\n#\n# Permission is hereby granted, free of charge, to any person obtaining a cop"
},
{
"path": "build_scripts/hash_printer.py",
"chars": 1749,
"preview": "#Copyright(c) 2016-2024 Panos Karabelas\n#\n#Permission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "build_scripts/premake.lua",
"chars": 7970,
"preview": "-- Copyright(c) 2015-2025 Panos Karabelas\n--\n-- Permission is hereby granted, free of charge, to any person obtaining a "
},
{
"path": "code_of_conduct.md",
"chars": 2013,
"preview": "# **Core Principles** \n\n## **Free Speech, Reason and Respect** \n\nWe believe in the power of dialogue and exchanging id"
},
{
"path": "data/fonts/OpenSans/OFL.txt",
"chars": 4390,
"preview": "Copyright 2020 The Open Sans Project Authors (https://github.com/googlefonts/opensans)\n\nThis Font Software is licensed u"
},
{
"path": "data/shaders/amd_fidelity_fx/cas.hlsl",
"chars": 2129,
"preview": "/*\nCopyright(c) 2016-2024 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/amd_fidelity_fx/ffx_a.h",
"chars": 181959,
"preview": "//======================================================================================================================"
},
{
"path": "data/shaders/amd_fidelity_fx/ffx_cas.h",
"chars": 60828,
"preview": "//_____________________________________________________________/\\_______________________________________________________"
},
{
"path": "data/shaders/amd_fidelity_fx/ffx_spd.h",
"chars": 49662,
"preview": "//_____________________________________________________________/\\_______________________________________________________"
},
{
"path": "data/shaders/amd_fidelity_fx/spd.hlsl",
"chars": 2809,
"preview": "/*\nCopyright(c) 2016-2024 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/auto_exposure.hlsl",
"chars": 4069,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/blit.hlsl",
"chars": 1319,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/bloom.hlsl",
"chars": 7765,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/blur.hlsl",
"chars": 3962,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/brdf.hlsl",
"chars": 9821,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/chromatic_aberration.hlsl",
"chars": 3510,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/common.hlsl",
"chars": 18859,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/common_colorspace.hlsl",
"chars": 1802,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/common_resources.hlsl",
"chars": 10150,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/common_structs.hlsl",
"chars": 18883,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/common_terrain.hlsl",
"chars": 2998,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/common_tessellation.hlsl",
"chars": 6843,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/common_vertex_processing.hlsl",
"chars": 20893,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/compressonator/bcn_common_api.h",
"chars": 37636,
"preview": "//===============================================================================\n// Copyright (c) 2021-2024 Advanced"
},
{
"path": "data/shaders/compressonator/bcn_common_kernel.h",
"chars": 109089,
"preview": "//=============================================================================\n// Copyright (c) 2018-2024 Advanced M"
},
{
"path": "data/shaders/compressonator/common_def.h",
"chars": 132891,
"preview": "// ==================================================================================================\n// Copyright (c) 2"
},
{
"path": "data/shaders/depth_light.hlsl",
"chars": 2807,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/depth_of_field.hlsl",
"chars": 11050,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/depth_prepass.hlsl",
"chars": 2692,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/dithering.hlsl",
"chars": 2355,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/film_grain.hlsl",
"chars": 2573,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/fog.hlsl",
"chars": 13075,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/font.hlsl",
"chars": 1765,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/fxaa/fxaa.hlsl",
"chars": 2381,
"preview": "/*\nCopyright(c) 2016-2024 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/fxaa/fxaa3_11.h",
"chars": 85880,
"preview": "/*============================================================================\n\n\n NVIDIA FXAA 3.11 by"
},
{
"path": "data/shaders/g_buffer.hlsl",
"chars": 14080,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/grid.hlsl",
"chars": 4164,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/icon.hlsl",
"chars": 3335,
"preview": "//= INCLUDES =========\n#include \"common.hlsl\"\n//====================\n\n/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermiss"
},
{
"path": "data/shaders/imgui.hlsl",
"chars": 5834,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/indirect_cull.hlsl",
"chars": 6740,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/legacy/ssr.hlsl",
"chars": 7610,
"preview": "/*\nCopyright(c) 2016-2025 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/legacy/temporal_antialiasing.hlsl",
"chars": 11095,
"preview": "/*\nCopyright(c) 2016-2025 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/light.hlsl",
"chars": 11377,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/light_composition.hlsl",
"chars": 5457,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/light_image_based.hlsl",
"chars": 5617,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/light_integration.hlsl",
"chars": 10477,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/light_reflections.hlsl",
"chars": 9039,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/line.hlsl",
"chars": 1467,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/motion_blur.hlsl",
"chars": 13349,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/nrd_prepare.hlsl",
"chars": 4227,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/outline.hlsl",
"chars": 1890,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/output.hlsl",
"chars": 15699,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/particles.hlsl",
"chars": 9486,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/ray_traced_reflections.hlsl",
"chars": 8775,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/ray_traced_shadows.hlsl",
"chars": 9057,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/restir_pt.hlsl",
"chars": 31156,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/restir_pt_spatial.hlsl",
"chars": 15018,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/restir_pt_temporal.hlsl",
"chars": 14556,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/restir_reservoir.hlsl",
"chars": 18657,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/scaling.hlsl",
"chars": 1614,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/screen_space_shadows/bend_sss.hlsl",
"chars": 4248,
"preview": "/*\nCopyright(c) 2016-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/screen_space_shadows/bend_sss_gpu.hlsl",
"chars": 25473,
"preview": "// Copyright 2023 Sony Interactive Entertainment.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
},
{
"path": "data/shaders/screen_space_shadows/screen_space_shadows.hlsl",
"chars": 3509,
"preview": "/*\nCopyright(c) 2016-2025 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/shadow_mapping.hlsl",
"chars": 12153,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/shared_buffers.h",
"chars": 10997,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/sky/cloud_noise.hlsl",
"chars": 4490,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/sky/cloud_shadow.hlsl",
"chars": 5262,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/sky/skysphere.hlsl",
"chars": 36943,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/ssao.hlsl",
"chars": 12017,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/texture_compress_bc1.hlsl",
"chars": 4013,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/texture_compress_bc3.hlsl",
"chars": 5048,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/texture_compress_bc5.hlsl",
"chars": 4088,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/transparency_reflection_refraction.hlsl",
"chars": 11497,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/variable_rate_shading.hlsl",
"chars": 2405,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "data/shaders/vhs.hlsl",
"chars": 9185,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "funding.yml",
"chars": 350,
"preview": "# These are supported funding model platforms\ngithub: [PanosK92]\npatreon: # Replace with a single Patreon username\nopen_"
},
{
"path": "generate_project_files.py",
"chars": 3429,
"preview": "# Copyright(c) 2015-2026 Panos Karabelas\n#\n# Permission is hereby granted, free of charge, to any person obtaining a cop"
},
{
"path": "license.md",
"chars": 1081,
"preview": "The MIT License\n\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obt"
},
{
"path": "plan.md",
"chars": 3909,
"preview": "# The Plan\n\n<p align=\"center\">\n <a href=\"https://youtu.be/R3QvniaZ5qM?t=53\">\n <img src=\"https://img.youtube.com/vi/R"
},
{
"path": "readme.md",
"chars": 13467,
"preview": "<p align=\"center\">\n <img src=\"https://raw.githubusercontent.com/PanosK92/SpartanEngine/master/data/textures/banner.bmp\""
},
{
"path": "source/editor/Editor.cpp",
"chars": 9971,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Editor.h",
"chars": 1772,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/GeneralWindows.cpp",
"chars": 25629,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/GeneralWindows.h",
"chars": 1395,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/ImGui/ImGui_Extension.h",
"chars": 21657,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/ImGui/ImGui_Style.h",
"chars": 11946,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/ImGui/ImGui_TransformGizmo.h",
"chars": 12453,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/ImGui/Implementation/ImGui_RHI.h",
"chars": 23337,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/ImGui/Implementation/imgui_impl_sdl3.cpp",
"chars": 57110,
"preview": "// dear imgui: Platform Backend for SDL3\n// This needs to be used along with a Renderer (e.g. SDL_GPU, DirectX11, OpenGL"
},
{
"path": "source/editor/ImGui/Implementation/imgui_impl_sdl3.h",
"chars": 3552,
"preview": "// dear imgui: Platform Backend for SDL3\n// This needs to be used along with a Renderer (e.g. SDL_GPU, DirectX11, OpenGL"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/GraphEditor.cpp",
"chars": 44850,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/GraphEditor.h",
"chars": 5993,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImCurveEdit.cpp",
"chars": 15678,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImCurveEdit.h",
"chars": 2827,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImGradient.cpp",
"chars": 4472,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImGradient.h",
"chars": 1670,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImGuizmo.cpp",
"chars": 114502,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImGuizmo.h",
"chars": 11628,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImSequencer.cpp",
"chars": 30694,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImSequencer.h",
"chars": 3163,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/ImZoomSlider.h",
"chars": 10440,
"preview": "// https://github.com/CedricGuillemet/ImGuizmo\n// v 1.89 WIP\n//\n// The MIT License(MIT)\n//\n// Copyright(c) 2021 Cedric G"
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/LICENSE",
"chars": 1083,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2016 Cedric Guillemet\n\nPermission is hereby granted, free of charge, to any person "
},
{
"path": "source/editor/ImGui/Source/ImGuizmo/README.md",
"chars": 6434,
"preview": "# ImGuizmo\n\nLatest stable tagged version is 1.83. Current master version is 1.84 WIP.\n\nWhat started with the gizmo is no"
},
{
"path": "source/editor/ImGui/Source/LICENSE.txt",
"chars": 1083,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2014-2024 Omar Cornut\n\nPermission is hereby granted, free of charge, to any person "
},
{
"path": "source/editor/ImGui/Source/imconfig.h",
"chars": 11580,
"preview": "//-----------------------------------------------------------------------------\n// DEAR IMGUI COMPILE-TIME OPTIONS\n// Ru"
},
{
"path": "source/editor/ImGui/Source/imgui.cpp",
"chars": 1183689,
"preview": "// dear imgui, v1.91.9 WIP\n// (main code and documentation)\n\n// Help:\n// - See links below.\n// - Call and read ImGui::Sh"
},
{
"path": "source/editor/ImGui/Source/imgui.h",
"chars": 408185,
"preview": "// dear imgui, v1.91.9 WIP\n// (headers)\n\n// Help:\n// - See links below.\n// - Call and read ImGui::ShowDemoWindow() in im"
},
{
"path": "source/editor/ImGui/Source/imgui_demo.cpp",
"chars": 568093,
"preview": "// dear imgui, v1.91.9 WIP\n// (demo code)\n\n// Help:\n// - Read FAQ at http://dearimgui.com/faq\n// - Call and read ImGui::"
},
{
"path": "source/editor/ImGui/Source/imgui_draw.cpp",
"chars": 260584,
"preview": "// dear imgui, v1.91.9 WIP\n// (drawing and font code)\n\n/*\n\nIndex of this file:\n\n// [SECTION] STB libraries implementatio"
},
{
"path": "source/editor/ImGui/Source/imgui_freetype.cpp",
"chars": 47793,
"preview": "// dear imgui: FreeType font builder (used as a replacement for the stb_truetype builder)\n// (code)\n\n// Get the latest v"
},
{
"path": "source/editor/ImGui/Source/imgui_freetype.h",
"chars": 3944,
"preview": "// dear imgui: FreeType font builder (used as a replacement for the stb_truetype builder)\n// (headers)\n\n#pragma once\n#in"
},
{
"path": "source/editor/ImGui/Source/imgui_internal.h",
"chars": 297860,
"preview": "// dear imgui, v1.91.9 WIP\n// (internal structures/api)\n\n// You may use this file to debug, understand or extend Dear Im"
},
{
"path": "source/editor/ImGui/Source/imgui_stdlib.cpp",
"chars": 3429,
"preview": "// dear imgui: wrappers for C++ standard library (STL) types (std::string, etc.)\n// This is also an example of how you m"
},
{
"path": "source/editor/ImGui/Source/imgui_stdlib.h",
"chars": 1228,
"preview": "// dear imgui: wrappers for C++ standard library (STL) types (std::string, etc.)\n// This is also an example of how you m"
},
{
"path": "source/editor/ImGui/Source/imgui_tables.cpp",
"chars": 245759,
"preview": "// dear imgui, v1.91.9 WIP\n// (tables and columns code)\n\n/*\n\nIndex of this file:\n\n// [SECTION] Commentary\n// [SECTION] H"
},
{
"path": "source/editor/ImGui/Source/imgui_widgets.cpp",
"chars": 523045,
"preview": "// dear imgui, v1.91.9 WIP\n// (widgets code)\n\n/*\n\nIndex of this file:\n\n// [SECTION] Forward Declarations\n// [SECTION] Wi"
},
{
"path": "source/editor/ImGui/Source/imstb_rectpack.h",
"chars": 20344,
"preview": "// [DEAR IMGUI]\n// This is a slightly modified version of stb_rect_pack.h 1.01.\n// Grep for [DEAR IMGUI] to find the cha"
},
{
"path": "source/editor/ImGui/Source/imstb_textedit.h",
"chars": 57128,
"preview": "// [DEAR IMGUI]\n// This is a slightly modified version of stb_textedit.h 1.14.\n// Those changes would need to be pushed "
},
{
"path": "source/editor/ImGui/Source/imstb_truetype.h",
"chars": 199485,
"preview": "// [DEAR IMGUI]\n// This is a slightly modified version of stb_truetype.h 1.26.\n// Mostly fixing for compiler and static "
},
{
"path": "source/editor/ImGui/Source/stb_sprintf.h",
"chars": 58223,
"preview": "// stb_sprintf - v1.10 - public domain snprintf() implementation\n// originally by Jeff Roberts / RAD Game Tools, 2015/10"
},
{
"path": "source/editor/ImGui/TextEditor.cpp",
"chars": 95903,
"preview": "#include \"pch.h\"\n#include <algorithm>\n#include <chrono>\n#include <string>\n#include <regex>\n#include <cmath>\n\n#include \"T"
},
{
"path": "source/editor/ImGui/TextEditor.h",
"chars": 10882,
"preview": "#pragma once\n\n#include <string>\n#include <vector>\n#include <array>\n#include <unordered_set>\n#include <unordered_map>\n#in"
},
{
"path": "source/editor/Widgets/AssetBrowser.cpp",
"chars": 6131,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/AssetBrowser.h",
"chars": 1391,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ButtonColorPicker.cpp",
"chars": 7296,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ButtonColorPicker.h",
"chars": 2029,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Console.cpp",
"chars": 39086,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Console.h",
"chars": 4283,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/FileDialog.cpp",
"chars": 48478,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/FileDialog.h",
"chars": 6117,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/FileSelection.h",
"chars": 2804,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/MenuBar.cpp",
"chars": 31565,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/MenuBar.h",
"chars": 1418,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Profiler.cpp",
"chars": 29353,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Profiler.h",
"chars": 2580,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ProgressDialog.cpp",
"chars": 3474,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ProgressDialog.h",
"chars": 1362,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Properties.cpp",
"chars": 111987,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Properties.h",
"chars": 2696,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/RenderOptions.cpp",
"chars": 19081,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/RenderOptions.h",
"chars": 1298,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ResourceViewer.cpp",
"chars": 8893,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ResourceViewer.h",
"chars": 1278,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ScriptEditor.cpp",
"chars": 2662,
"preview": "#include \"pch.h\"\n#include \"ScriptEditor.h\"\n#include \"ImGui/TextEditor.h\"\n#include \"World/Entity.h\"\n#include \"World/Worl"
},
{
"path": "source/editor/Widgets/ScriptEditor.h",
"chars": 350,
"preview": "#pragma once\n\n\n#include \"Widget.h\"\n#include \"ImGui/TextEditor.h\"\n\nclass ScriptEditor : public Widget\n{\npublic:\n Scri"
},
{
"path": "source/editor/Widgets/Sequence/Sequence.cpp",
"chars": 23313,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Sequence/Sequence.h",
"chars": 5810,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Sequence/Sequencer.cpp",
"chars": 107748,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Sequence/Sequencer.h",
"chars": 4069,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ShaderEditor.cpp",
"chars": 8142,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/ShaderEditor.h",
"chars": 1826,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Style.cpp",
"chars": 7307,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Style.h",
"chars": 1480,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/TextureViewer.cpp",
"chars": 10401,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/TextureViewer.h",
"chars": 1943,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Viewport.cpp",
"chars": 8367,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Viewport.h",
"chars": 1379,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Widget.cpp",
"chars": 3942,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/Widget.h",
"chars": 3321,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/WorldViewer.cpp",
"chars": 41882,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Widgets/WorldViewer.h",
"chars": 2414,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Windows/Contributors.cpp",
"chars": 9133,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Windows/Contributors.h",
"chars": 1137,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Windows/WorldSelector.cpp",
"chars": 33522,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/Windows/WorldSelector.h",
"chars": 1278,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/editor/main.cpp",
"chars": 2824,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Car/Car.cpp",
"chars": 107502,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Car/Car.h",
"chars": 7152,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Car/CarEngineSoundSynthesis.h",
"chars": 36860,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Car/CarSimulation.h",
"chars": 160471,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Car/CarTireSquealSynthesis.h",
"chars": 15496,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Commands/CircularStack.h",
"chars": 2769,
"preview": "/*\nCopyright(c) 2024 Roman Koshchei\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof thi"
},
{
"path": "source/runtime/Commands/Command.h",
"chars": 1299,
"preview": "/*\nCopyright(c) 2023 Fredrik Svantesson\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof"
},
{
"path": "source/runtime/Commands/CommandEntityDelete.cpp",
"chars": 2957,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Commands/CommandEntityDelete.h",
"chars": 1593,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Commands/CommandStack.cpp",
"chars": 2426,
"preview": "/*\nCopyright(c) 2023 Fredrik Svantesson\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof"
},
{
"path": "source/runtime/Commands/CommandStack.h",
"chars": 2897,
"preview": "/*\nCopyright(c) 2023 Fredrik Svantesson\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof"
},
{
"path": "source/runtime/Commands/CommandTransform.cpp",
"chars": 2835,
"preview": "/*\nCopyright(c) 2023 Fredrik Svantesson\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof"
},
{
"path": "source/runtime/Commands/CommandTransform.h",
"chars": 1848,
"preview": "/*\nCopyright(c) 2023 Fredrik Svantesson\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof"
},
{
"path": "source/runtime/Commands/CommandTransformMulti.cpp",
"chars": 3194,
"preview": "/*\nCopyright(c) 2023 Fredrik Svantesson\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof"
},
{
"path": "source/runtime/Commands/CommandTransformMulti.h",
"chars": 2229,
"preview": "/*\nCopyright(c) 2023 Fredrik Svantesson\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof"
},
{
"path": "source/runtime/Commands/Console/ConsoleCommands.cpp",
"chars": 5486,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Commands/Console/ConsoleCommands.h",
"chars": 6786,
"preview": "/*\nCopyright(c) 2015-2026 Bryan Casagrande\n\nPermission is hereby granted, free of charge, to any person obtaining a copy"
},
{
"path": "source/runtime/Core/Breadcrumbs.cpp",
"chars": 8238,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Core/Breadcrumbs.h",
"chars": 6213,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Core/Debugging.h",
"chars": 3093,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Core/Definitions.cpp",
"chars": 4200,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Core/Definitions.h",
"chars": 9162,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Core/Engine.cpp",
"chars": 5876,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Core/Engine.h",
"chars": 1669,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Core/Event.cpp",
"chars": 2407,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "source/runtime/Core/Event.h",
"chars": 4615,
"preview": "/*\nCopyright(c) 2015-2026 Panos Karabelas\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
}
]
// ... and 1349 more files (download for full content)
About this extraction
This page contains the full source code of the PanosK92/SpartanEngine GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1549 files (53.0 MB), approximately 14.0M tokens, and a symbol index with 47712 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.